/activeobjects-plugin/src/test/java/com/atlassian/activeobjects/osgi/DelegatingActiveObjectsTest.java

  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}