1 package com.atlassian.cache.ehcache.wrapper;
2
3 import net.sf.ehcache.Ehcache;
4 import net.sf.ehcache.Status;
5 import net.sf.ehcache.loader.CacheLoader;
6 import org.junit.Before;
7 import org.junit.Rule;
8 import org.junit.Test;
9 import org.mockito.Mock;
10 import org.mockito.junit.MockitoJUnit;
11 import org.mockito.junit.MockitoRule;
12
13 import java.util.Collections;
14 import java.util.HashMap;
15 import java.util.Map;
16
17 import static org.junit.Assert.assertEquals;
18 import static org.junit.Assert.assertSame;
19 import static org.mockito.ArgumentMatchers.any;
20 import static org.mockito.ArgumentMatchers.eq;
21 import static org.mockito.ArgumentMatchers.same;
22 import static org.mockito.Mockito.mock;
23 import static org.mockito.Mockito.times;
24 import static org.mockito.Mockito.verify;
25 import static org.mockito.Mockito.verifyNoMoreInteractions;
26 import static org.mockito.Mockito.when;
27
28 public class ValueProcessorEhcacheLoaderDecoratorTest {
29
30 @Rule
31 public MockitoRule mockitoRule = MockitoJUnit.rule();
32
33 @Mock
34 private CacheLoader mockLoader;
35
36 private ValueProcessorEhcacheLoaderDecorator tested;
37
38 @Before
39 public void init() {
40 tested = new ValueProcessorEhcacheLoaderDecorator(mockLoader, WrapperTestUtils.getValueProcessor());
41 }
42
43 @SuppressWarnings("Duplicates")
44 @Test
45 public void testLoadShouldUnwrapKeyAndWrapResult() {
46 Object key = new Object();
47 Object value = new Object();
48
49 when(mockLoader.load(key)).thenReturn(value);
50
51 Object loaded = tested.load(new MockWrappedValue(key));
52
53 verify(mockLoader).load(same(key));
54 verifyNoMoreInteractions(mockLoader);
55 assertSame(MockWrappedValue.class, loaded.getClass());
56 assertSame(value, ((MockWrappedValue) loaded).getValue());
57 }
58
59 @Test
60 public void testLoadWithArgShouldUnwrapKeyAndWrapResult() {
61 Object key = new Object();
62 Object arg = new Object();
63 Object value = new Object();
64
65 when(mockLoader.load(key, arg)).thenReturn(value);
66
67 Object loaded = tested.load(new MockWrappedValue(key), arg);
68
69 verify(mockLoader).load(same(key), same(arg));
70 verifyNoMoreInteractions(mockLoader);
71 assertSame(MockWrappedValue.class, loaded.getClass());
72 assertSame(value, ((MockWrappedValue) loaded).getValue());
73 }
74
75 @SuppressWarnings("unchecked")
76 @Test
77 public void testLoadAllShouldUnwrapKeyAndWrapResult() {
78 Object key = new Object();
79 Object value = new Object();
80
81 when(mockLoader.loadAll(any())).thenReturn(new HashMap() {{put(key,value);}});
82
83 Map loadedMap = tested.loadAll(Collections.singleton(new MockWrappedValue(key)));
84 assertEquals(1, loadedMap.size());
85
86 Object loaded = loadedMap.values().iterator().next();
87 assertSame(MockWrappedValue.class, loaded.getClass());
88 assertSame(value, ((MockWrappedValue) loaded).getValue());
89 verify(mockLoader).loadAll(eq(Collections.singletonList(key)));
90 verifyNoMoreInteractions(mockLoader);
91 }
92
93 @SuppressWarnings("unchecked")
94 @Test
95 public void testLoadAllWithArgShouldUnwrapKeyAndWrapResult() {
96 Object key = new Object();
97 Object arg = new Object();
98 Object value = new Object();
99
100 when(mockLoader.loadAll(any(), eq(arg))).thenReturn(new HashMap() {{put(key,value);}});
101
102 Map loadedMap = tested.loadAll(Collections.singleton(new MockWrappedValue(key)), arg);
103 assertEquals(1, loadedMap.size());
104
105 Object loaded = loadedMap.values().iterator().next();
106 assertSame(MockWrappedValue.class, loaded.getClass());
107 assertSame(value, ((MockWrappedValue) loaded).getValue());
108 verify(mockLoader).loadAll(eq(Collections.singletonList(key)), eq(arg));
109 verifyNoMoreInteractions(mockLoader);
110 }
111
112 @Test
113 public void testGetName() {
114 String name = "name";
115
116 when(mockLoader.getName()).thenReturn(name);
117 assertEquals(name, tested.getName());
118 verify(mockLoader).getName();
119 verifyNoMoreInteractions(mockLoader);
120 }
121
122 @Test
123 public void testInit() {
124 tested.getName();
125 verify(mockLoader).getName();
126 verifyNoMoreInteractions(mockLoader);
127 }
128
129 @Test
130 public void testClone() throws CloneNotSupportedException {
131 Ehcache mockCache = mock(Ehcache.class);
132 ValueProcessorEhcacheLoaderDecorator mockClone = mock(ValueProcessorEhcacheLoaderDecorator.class);
133
134 when(mockLoader.clone(mockCache)).thenReturn(mockClone);
135
136 assertEquals(mockClone, tested.clone(mockCache));
137 verify(mockLoader).clone(mockCache);
138 verifyNoMoreInteractions(mockLoader);
139 }
140
141 @Test
142 public void testDispose() {
143 tested.dispose();
144 verify(mockLoader).dispose();
145 verifyNoMoreInteractions(mockLoader);
146 }
147
148 @Test
149 public void testGetStatus() {
150 when(mockLoader.getStatus())
151 .thenReturn(Status.STATUS_UNINITIALISED)
152 .thenReturn(Status.STATUS_ALIVE)
153 .thenReturn(Status.STATUS_SHUTDOWN);
154
155 assertEquals(Status.STATUS_UNINITIALISED, tested.getStatus());
156 assertEquals(Status.STATUS_ALIVE, tested.getStatus());
157 assertEquals(Status.STATUS_SHUTDOWN, tested.getStatus());
158
159 verify(mockLoader, times(3)).getStatus();
160 verifyNoMoreInteractions(mockLoader);
161 }
162
163 }