/activeobjects-plugin/src/test/java/com/atlassian/activeobjects/osgi/DelegatingActiveObjectsTest.java
Java | 223 lines | 179 code | 40 blank | 4 comment | 0 complexity | 2780075d51b79dc78ebeaf81493fa3be MD5 | raw file
Possible License(s): Apache-2.0
1package com.atlassian.activeobjects.osgi;
2
3import com.atlassian.activeobjects.external.ActiveObjects;
4import com.atlassian.sal.api.transaction.TransactionCallback;
5import com.google.common.base.Suppliers;
6import net.java.ao.DBParam;
7import net.java.ao.EntityManager;
8import net.java.ao.Query;
9import net.java.ao.RawEntity;
10import org.junit.Before;
11import org.junit.Test;
12import org.junit.runner.RunWith;
13import org.mockito.Mock;
14import org.mockito.runners.MockitoJUnitRunner;
15
16import java.beans.PropertyChangeListener;
17import java.util.HashMap;
18
19import static org.mockito.Mockito.*;
20
21/**
22 * The main reason for this tests is to ensure that we use the supplier.
23 */
24@RunWith(MockitoJUnitRunner.class)
25public class DelegatingActiveObjectsTest
26{
27 private ActiveObjects activeObjects;
28
29 @Mock
30 private ActiveObjects delegateActiveObjects;
31
32 @Before
33 public void setUp() throws Exception
34 {
35 activeObjects = new DelegatingActiveObjects(Suppliers.ofInstance(delegateActiveObjects));
36 }
37
38 @Test
39 @SuppressWarnings("unchecked")
40 public void testMigrate() throws Exception
41 {
42 activeObjects.migrate(AnEntity.class);
43 verify(delegateActiveObjects).migrate(AnEntity.class);
44 }
45
46 @Test
47 public void testFlushAll() throws Exception
48 {
49 activeObjects.flushAll();
50 verify(delegateActiveObjects).flushAll();
51 }
52
53 @Test
54 public void testFlush() throws Exception
55 {
56 activeObjects.flush();
57 verify(delegateActiveObjects).flush();
58 }
59
60 @Test
61 public void testGetEntityKey() throws Exception
62 {
63 final Integer key = 1;
64 activeObjects.get(AnEntity.class, key);
65
66 verify(delegateActiveObjects).get(AnEntity.class, key);
67 }
68
69 @Test
70 public void testGetEntityKeys() throws Exception
71 {
72 final Integer key1 = 1;
73 final Integer key2 = 2;
74 activeObjects.get(AnEntity.class, key1, key2);
75 verify(delegateActiveObjects).get(AnEntity.class, key1, key2);
76 }
77
78 @Test
79 public void testCreateEntityMap() throws Exception
80 {
81 final HashMap<String, Object> aMap = new HashMap<String, Object>();
82 activeObjects.create(AnEntity.class, aMap);
83 verify(delegateActiveObjects).create(AnEntity.class, aMap);
84 }
85
86 @Test
87 public void testCreateEntityDBParams() throws Exception
88 {
89 final DBParam dbParam = new DBParam("field", "value");
90 activeObjects.create(AnEntity.class, dbParam);
91 verify(delegateActiveObjects).create(AnEntity.class, dbParam);
92 }
93
94 @Test
95 public void testDelete() throws Exception
96 {
97 final AnEntity entity = new AnEntity();
98 activeObjects.delete(entity);
99 verify(delegateActiveObjects).delete(entity);
100 }
101
102 @Test
103 public void testFindClass() throws Exception
104 {
105 activeObjects.find(AnEntity.class);
106 verify(delegateActiveObjects).find(AnEntity.class);
107 }
108
109 @Test
110 public void testFindClassCriteriaObjects() throws Exception
111 {
112 final Class<AnEntity> type = AnEntity.class;
113 final String criteria = "criteria";
114 final Object param = new Object();
115
116 activeObjects.find(type, criteria, param);
117 verify(delegateActiveObjects).find(type, criteria, param);
118 }
119
120 @Test
121 public void testFindClassQuery() throws Exception
122 {
123 final Class<AnEntity> type = AnEntity.class;
124 final Query query = Query.select();
125
126 activeObjects.find(type, query);
127 verify(delegateActiveObjects).find(type, query);
128 }
129
130 @Test
131 public void testFindClassStringQuery() throws Exception
132 {
133 final Class<AnEntity> type = AnEntity.class;
134 final String field = "field";
135 final Query query = Query.select();
136
137 activeObjects.find(type, field, query);
138 verify(delegateActiveObjects).find(type, field, query);
139 }
140
141 @Test
142 public void testFindWithSQL() throws Exception
143 {
144 final Class<AnEntity> type = AnEntity.class;
145 final String keyField = "field";
146 final String sql = "sql";
147 final Object param = new Object();
148
149 activeObjects.findWithSQL(type, keyField, sql, param);
150 verify(delegateActiveObjects).findWithSQL(type, keyField, sql, param);
151 }
152
153 @Test
154 public void testCountClass() throws Exception
155 {
156 final Class<AnEntity> type = AnEntity.class;
157
158 activeObjects.count(type);
159 verify(delegateActiveObjects).count(type);
160 }
161
162 @Test
163 public void testCountClassStringObjects() throws Exception
164 {
165 final Class<AnEntity> type = AnEntity.class;
166 final String criteria = "criteria";
167 final Object param = new Object();
168
169 activeObjects.count(type, criteria, param);
170 verify(delegateActiveObjects).count(type, criteria, param);
171 }
172
173 @Test
174 public void testCountClassQuery() throws Exception
175 {
176 final Class<AnEntity> type = AnEntity.class;
177 final Query query = Query.select();
178
179 activeObjects.count(type, query);
180 verify(delegateActiveObjects).count(type, query);
181 }
182
183 @Test
184 public void testExecuteInTransaction() throws Exception
185 {
186 @SuppressWarnings({"unchecked"}) final TransactionCallback<Object> callback = mock(TransactionCallback.class);
187 activeObjects.executeInTransaction(callback);
188 verify(delegateActiveObjects).executeInTransaction(callback);
189 }
190
191 ///CLOVER:OFF
192
193 private static class AnEntity implements RawEntity<Integer>
194 {
195 public void init()
196 {
197
198 }
199
200 public void save()
201 {
202
203 }
204
205 public EntityManager getEntityManager()
206 {
207 return null;
208 }
209
210 public void addPropertyChangeListener(PropertyChangeListener listener)
211 {
212 }
213
214 public void removePropertyChangeListener(PropertyChangeListener listener)
215 {
216 }
217
218 public <X extends RawEntity<Integer>> Class<X> getEntityType()
219 {
220 return null;
221 }
222 }
223}