source: DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/JdbcAnnotationDaoTest.java @ 3407

Last change on this file since 3407 was 3407, checked in by olhsha, 11 years ago

refactored DAO-s: resource dao do not call each-other methods any more. Only the new Dispatcher method can do it. Not tested.
File size: 17.3 KB
Line 
1/*
2 * Copyright (C) 2013 DASISH
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17 */
18package eu.dasish.annotation.backend.dao.impl;
19
20import eu.dasish.annotation.backend.TestBackendConstants;
21import eu.dasish.annotation.backend.TestInstances;
22import eu.dasish.annotation.backend.identifiers.AnnotationIdentifier;
23import eu.dasish.annotation.backend.identifiers.UserIdentifier;
24import eu.dasish.annotation.schema.Annotation;
25import eu.dasish.annotation.schema.AnnotationInfo;
26import eu.dasish.annotation.schema.NewOrExistingSourceInfo;
27import eu.dasish.annotation.schema.NewOrExistingSourceInfos;
28import eu.dasish.annotation.schema.ResourceREF;
29import eu.dasish.annotation.schema.SourceInfo;
30import java.sql.SQLException;
31import java.sql.Timestamp;
32import java.util.ArrayList;
33import java.util.List;
34import java.util.Map;
35import org.jmock.Expectations;
36import static org.junit.Assert.*;
37import org.junit.Test;
38import org.junit.runner.RunWith;
39import org.springframework.beans.factory.annotation.Autowired;
40import org.springframework.test.context.ContextConfiguration;
41import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
42
43/**
44 *
45 * @author olhsha
46 */
47@RunWith(SpringJUnit4ClassRunner.class)
48@ContextConfiguration({"/spring-test-config/dataSource.xml", "/spring-config/annotationDao.xml"})
49public class JdbcAnnotationDaoTest extends JdbcResourceDaoTest {
50
51    @Autowired
52    JdbcAnnotationDao jdbcAnnotationDao;   
53    TestInstances testInstances = new TestInstances();
54
55    /**
56     * Test of getAnnotationInfos method, of class JdbcAnnotationDao.
57     * List<AnnotationInfo> getAnnotationInfos(List<Number> annotationIDs)
58     */
59   
60      /**
61     * Test of retrieveSourceIDs method, of class JdbcSourceDao.
62     */
63    @Test
64    public void testRetrieveSourceIDs() {
65        System.out.println("retrieveSourceIDs");
66        Number annotationID = 2;
67        List<Number> result = jdbcAnnotationDao.retrieveSourceIDs(annotationID);
68        assertEquals(2, result.size());
69        assertEquals(1, result.get(0));
70        assertEquals(2, result.get(1));
71    }
72   
73    @Test
74    public void testGetAnnotationInfos() {
75        System.out.println("getAnnotationInfos");
76        List<Number> annotIds = new ArrayList<Number>();
77        annotIds.add(2);
78        annotIds.add(3);
79        annotIds.add(4);
80
81        final List<AnnotationInfo> annotationInfos = jdbcAnnotationDao.getAnnotationInfos(annotIds);
82        assertEquals(3, annotationInfos.size());
83
84        assertEquals(TestBackendConstants._TEST_ANNOT_2_HEADLINE, annotationInfos.get(0).getHeadline());
85        assertEquals(String.valueOf(TestBackendConstants._TEST_ANNOT_2_OWNER), annotationInfos.get(0).getOwner().getRef());
86        //assertEquals(TestBackendConstants._TEST_ANNOT_1_TARGETS, annotationInfos.get(0).getTargetSources());
87
88        assertEquals(TestBackendConstants._TEST_ANNOT_3_HEADLINE, annotationInfos.get(1).getHeadline());
89        assertEquals(String.valueOf(TestBackendConstants._TEST_ANNOT_3_OWNER), annotationInfos.get(1).getOwner().getRef());
90        //assertEquals(TestBackendConstants._TEST_ANNOT_2_TARGETS, annotationInfos.get(1).getTargetSources());
91
92        assertEquals(TestBackendConstants._TEST_ANNOT_4_HEADLINE, annotationInfos.get(2).getHeadline());
93        assertEquals(String.valueOf(TestBackendConstants._TEST_ANNOT_4_OWNER), annotationInfos.get(2).getOwner().getRef());
94        //assertEquals(TestBackendConstants._TEST_ANNOT_3_TARGETS, annotationInfos.get(2).getTargetSources());
95
96        final List<AnnotationInfo> annotationInfosNull = jdbcAnnotationDao.getAnnotationInfos(null);
97        assertEquals(null, annotationInfosNull);
98
99        final List<AnnotationInfo> annotationInfosZeroSize = jdbcAnnotationDao.getAnnotationInfos(new ArrayList<Number>());
100        assertEquals(0, annotationInfosZeroSize.size());
101
102
103    }
104
105    /**
106     * Test of getAnnotationREFs method, of class JdbcAnnotationDao.
107     * List<ResourceREF> getAnnotationREFs(List<Number> annotationIDs)
108     */
109    @Test
110    public void testGetAnnotationREFs() {
111        System.out.println("getAnnotationREFs");
112        List<Number> annotIds = new ArrayList<Number>();
113        annotIds.add(2);
114        annotIds.add(3);
115        annotIds.add(4);
116
117        final List<ResourceREF> testList = jdbcAnnotationDao.getAnnotationREFs(annotIds);
118        assertEquals(3, testList.size());
119        assertEquals(String.valueOf(2), testList.get(0).getRef());
120        assertEquals(String.valueOf(3), testList.get(1).getRef());
121        assertEquals(String.valueOf(4), testList.get(2).getRef());
122
123        final List<ResourceREF> testListTwo = jdbcAnnotationDao.getAnnotationREFs(new ArrayList<Number>());
124        assertEquals(0, testListTwo.size());
125
126        final List<ResourceREF> testListThree = jdbcAnnotationDao.getAnnotationREFs(null);
127        assertEquals(null, testListThree);
128
129    }
130
131    /**
132     *
133     * Test of getAnnotationID method, of class JdbcAnnotationDao. Integer
134     * getAnnotationID(AnnotationIdentifier externalID)
135     */
136    @Test
137    public void getInternalID() throws SQLException {
138        System.out.println("test getInternalID");
139
140        final Number annotaionId = jdbcAnnotationDao.getInternalID(new AnnotationIdentifier(TestBackendConstants._TEST_ANNOT_2_EXT));
141        assertEquals(2, annotaionId.intValue());
142
143        final Number annotaionIdNE = jdbcAnnotationDao.getInternalID(new AnnotationIdentifier(TestBackendConstants._TEST_ANNOT_7_EXT_NOT_IN_DB));
144        assertEquals(null, annotaionIdNE);
145
146        final Number annotaionIdNull = jdbcAnnotationDao.getInternalID(null);
147        assertEquals(null, annotaionIdNull);
148    }
149
150    /**
151     *
152     * Test of getAnnotation method, of class JdbcAnnotationDao. Annotation
153     * getAnnotation(Number annotationlID)
154     */
155    @Test
156    public void getAnnotation() throws SQLException {
157        System.out.println("test getAnnotation");
158
159        /// dummy test
160        final Annotation annotaionNull = jdbcAnnotationDao.getAnnotationWithoutSources(null);
161        assertEquals(null, annotaionNull);
162        ////
163
164        final Number testAnnotationID = 2;
165        final Annotation annotation = jdbcAnnotationDao.getAnnotationWithoutSources(testAnnotationID);
166        assertEquals(TestBackendConstants._TEST_ANNOT_2_HEADLINE, annotation.getHeadline());
167        assertEquals(String.valueOf(TestBackendConstants._TEST_ANNOT_2_OWNER), annotation.getOwner().getRef());
168        assertEquals(TestBackendConstants._TEST_ANNOT_2_BODY, annotation.getBody().getAny().get(0)); // when the body is elaborated it may be changed
169        assertEquals(TestBackendConstants._TEST_ANNOT_2_EXT, annotation.getURI());
170        assertEquals(TestBackendConstants._TEST_ANNOT_2_TIME_STAMP, annotation.getTimeStamp().toString());
171    }
172
173    /**
174     * Test of deletAnnotation method, of class JdbcAnnotationDao.
175     */
176    @Test
177    public void testDeleteAnnotation() throws SQLException {
178        System.out.println("deleteAnnotation"); 
179        // result[0] = # removed "annotations_principals_perissions" rows
180        // result[1] = # removed "annotatiobs_target_sources" rows
181        // result[2] = # removed annotation rows (should be 1)
182       
183        int[] result = jdbcAnnotationDao.deleteAnnotation(5);
184        assertEquals(3, result[0]);
185        assertEquals(2, result[1]);
186        assertEquals(1, result[2]);
187       
188        // now, try to delete the same annotation one more time
189        // if it has been already deleted then the method under testing should return 0
190   
191        result = jdbcAnnotationDao.deleteAnnotation(5);
192        assertEquals(0, result[0]);
193        assertEquals(0, result[1]);
194        assertEquals(0, result[2]);
195    }
196
197    /**
198     * Test of addAnnotation method, of class JdbcAnnotationDao.
199     */
200    @Test
201    public void testAddAnnotation() throws SQLException {
202        System.out.println("test_addAnnotation ");
203
204        final Annotation annotationToAdd = testInstances.getAnnotationToAdd();// existing sources
205        assertEquals(null, annotationToAdd.getURI());
206        assertEquals(null, annotationToAdd.getTimeStamp());
207       
208        Number newAnnotationID = jdbcAnnotationDao.addAnnotation(annotationToAdd, 5);
209        assertEquals(6, newAnnotationID);
210       
211        Annotation addedAnnotation= jdbcAnnotationDao.getAnnotationWithoutSources(6);
212        assertFalse(null == addedAnnotation.getURI());
213        assertFalse(null == addedAnnotation.getTimeStamp());
214        assertEquals(5, addedAnnotation.getOwner().getRef());
215        assertEquals(annotationToAdd.getBody().getAny().get(0), addedAnnotation.getBody().getAny().get(0)); // TODO: to be changed after serialization is fixed
216        assertEquals(annotationToAdd.getHeadline(), addedAnnotation.getHeadline());
217    }
218
219 
220
221
222//        NewOrExistingSourceInfo noesi = new NewOrExistingSourceInfo();
223//        NewSourceInfo nsi = new NewSourceInfo();
224//        nsi.setLink(TestBackendConstants._TEST_NEW_SOURCE_LINK);
225//        nsi.setId(TestBackendConstants._TEST_TEMP_SOURCE_ID);
226//        nsi.setVersion(null);
227//        noesi.setNewSource(nsi);
228//
229//
230//        NewOrExistingSourceInfo noesiTwo = new NewOrExistingSourceInfo();
231//        SourceInfo si = new SourceInfo();
232//        si.setLink(TestBackendConstants._TEST_NEW_SOURCE_LINK);
233//        si.setRef((new SourceIdentifier()).toString());
234//        si.setVersion(null);
235//        noesiTwo.setSource(si);
236//
237//        final Map<NewOrExistingSourceInfo, NewOrExistingSourceInfo> map = new HashMap<NewOrExistingSourceInfo, NewOrExistingSourceInfo>();
238//        map.put(noesi, noesiTwo);
239//
240//
241//        mockery.checking(new Expectations() {
242//            {
243//                oneOf(sourceDao).addTargetSources(with(aNonNull(Number.class)), with(aNonNull(List.class)));
244//                will(returnValue(map));
245//            }
246//        });
247
248 
249    /**
250     * testing public List<Number> getAnnotationIDsForSources(List<Number> sourceIDs);
251   
252    **/
253    @Test   
254    public void testGetAnnotationIDsForSources() {
255        System.out.println("test getAnnotationIDs for sources");
256        List<Number> sources = new ArrayList<Number>();
257        sources.add(1);
258        sources.add(2);
259        List<Number> result = jdbcAnnotationDao.retrieveAnnotationList(sources);
260        assertEquals (2, result.size());
261        assertEquals(2, result.get(0));
262        assertEquals(3, result.get(1));
263    }
264   
265    @Test   
266    public void testGetExternalID() {
267        System.out.println("getExternalID");
268
269        final AnnotationIdentifier externalId = jdbcAnnotationDao.getExternalID(2);
270        assertEquals(new AnnotationIdentifier(TestBackendConstants._TEST_ANNOT_2_EXT), externalId);
271
272
273        final AnnotationIdentifier externalIdThree = jdbcAnnotationDao.getExternalID(null);
274        assertEquals(null, externalIdThree.getUUID());
275
276    }
277   
278   
279    /** test
280     * public List<Number> getFilteredAnnotationIDs(String link, String text, String access, String namespace, UserIdentifier owner, Timestamp after, Timestamp before) {
281  **/
282   
283    @Test   
284    public void testGetFilteredAnnotationIDs(){
285        System.out.println(" test getFilteredAnnotationIDs");
286       
287       
288        //////////////////////////////////////////
289        // TEST 1
290        //final String link = "nl.wikipedia.org";
291        final List<Number> annotationIDs = new ArrayList<Number>();
292        annotationIDs.add(2);
293        annotationIDs.add(3);
294       
295        List<Number> result_1 = jdbcAnnotationDao.getFilteredAnnotationIDs(annotationIDs, null, null, null, null, null, null);       
296        assertEquals(2, result_1.size());
297        assertEquals(2, result_1.get(0));
298        assertEquals(3, result_1.get(1));
299       
300       
301        List<Number> result_2 = jdbcAnnotationDao.getFilteredAnnotationIDs(annotationIDs, "some html", null, null, null, null, null);       
302        assertEquals(2, result_2.size());
303        assertEquals(2, result_2.get(0));
304        assertEquals(3, result_2.get(1));
305       
306       
307       
308        List<Number> result_3 = jdbcAnnotationDao.getFilteredAnnotationIDs(annotationIDs, "some html", null, null, 1, null, null);       
309        assertEquals(1, result_3.size());
310        assertEquals(2, result_3.get(0));
311       
312       
313        Timestamp after = new Timestamp(0); 
314        Timestamp before = new Timestamp(System.currentTimeMillis()); 
315        List<Number> result_4 = jdbcAnnotationDao.getFilteredAnnotationIDs(annotationIDs, "some html", null, null, 1, after, before);       
316        assertEquals(1, result_4.size());
317        assertEquals(2, result_4.get(0));
318       
319       
320        Timestamp after_1 = new Timestamp(System.currentTimeMillis());       
321        List<Number> result_5 = jdbcAnnotationDao.getFilteredAnnotationIDs(annotationIDs, "some html", null, null, 1, after_1, null);       
322        assertEquals(0, result_5.size());
323       
324       
325    }
326   
327     /**
328     * Test of contructNewOrExistingSourceInfo method, of class JdbcSourceDao.
329     */
330    @Test
331    public void testContructNewOrExistingSourceInfo() {
332        System.out.println("contructNewOrExistingSourceInfo");
333
334        List<SourceInfo> sourceInfoList = new ArrayList<SourceInfo>();
335
336        SourceInfo sourceInfoOne = new SourceInfo();
337        sourceInfoOne.setLink(TestBackendConstants._TEST_SOURCE_1_LINK);
338        sourceInfoOne.setRef(TestBackendConstants._TEST_SOURCE_1_EXT_ID);
339        sourceInfoOne.setRef(TestBackendConstants._TEST_VERSION_1_EXT_ID);
340
341        SourceInfo sourceInfoTwo = new SourceInfo();
342        sourceInfoTwo.setLink(TestBackendConstants._TEST_SOURCE_2_LINK);
343        sourceInfoTwo.setRef(TestBackendConstants._TEST_SOURCE_2_EXT_ID);
344        sourceInfoTwo.setRef(TestBackendConstants._TEST_VERSION_3_EXT_ID);
345
346        sourceInfoList.add(sourceInfoOne);
347        sourceInfoList.add(sourceInfoTwo);
348
349//        NewOrExistingSourceInfos result = jdbcSourceDao.contructNewOrExistingSourceInfo(sourceInfoList);
350//        assertEquals(2, result.getTarget().size());
351//        assertEquals(sourceInfoOne, result.getTarget().get(0).getSource());
352//        assertEquals(sourceInfoTwo, result.getTarget().get(1).getSource());
353
354    }
355
356//    /**
357//     * Test of addTargetSources method, of class JdbcSourceDao. public
358//     * Map<NewOrExistingSourceInfo, NewOrExistingSourceInfo>
359//     * addTargetSources(Number annotationID, List<NewOrExistingSourceInfo>
360//     * sources)
361//     */
362//    @Test
363//    public void testAddTargetSourcesOnExistingSource() {
364//        System.out.println("addTargetSources : adding the old source");
365//
366//        NewOrExistingSourceInfo noesi = new NewOrExistingSourceInfo();
367//        SourceInfo si = new SourceInfo();
368//        si.setLink(TestBackendConstants._TEST_SOURCE_1_LINK);
369//        si.setRef(TestBackendConstants._TEST_SOURCE_1_EXT_ID);
370//        si.setVersion(TestBackendConstants._TEST_VERSION_1_EXT_ID);
371//        noesi.setSource(si);
372//
373//        List<NewOrExistingSourceInfo> listnoesi = new ArrayList<NewOrExistingSourceInfo>();
374//        listnoesi.add(noesi);
375//
376//        try {
377//            Map<String, String> result = jdbcSourceDao.addTargetSources(5, listnoesi);
378//            assertEquals(0, result.size()); // no new peristsent source IDs are produced
379//        } catch (SQLException e) {
380//            System.out.println(e);
381//        }
382//    }
383//
384//    /**
385//     * Test of addTargetSources method, of class JdbcSourceDao. public
386//     * Map<NewOrExistingSourceInfo, NewOrExistingSourceInfo>
387//     * addTargetSources(Number annotationID, List<NewOrExistingSourceInfo>
388//     * sources)
389//     */
390//    @Test
391//    public void testAddTargetSourcesOnNewSource() {
392//        System.out.println("addTargetSources : adding the new source");
393//
394//        NewOrExistingSourceInfo noesi = new NewOrExistingSourceInfo();
395//        NewSourceInfo nsi = new NewSourceInfo();
396//        nsi.setLink(TestBackendConstants._TEST_NEW_SOURCE_LINK);
397//        nsi.setId(TestBackendConstants._TEST_TEMP_SOURCE_ID);
398//        nsi.setVersion(TestBackendConstants._TEST_VERSION_1_EXT_ID);
399//        noesi.setNewSource(nsi);
400//
401//        List<NewOrExistingSourceInfo> listnoesiTwo = new ArrayList<NewOrExistingSourceInfo>();
402//        listnoesiTwo.add(noesi);
403//       
404//        mockery.checking(new Expectations() {
405//            {
406//                oneOf(versionDao).getInternalID(new VersionIdentifier(TestBackendConstants._TEST_VERSION_1_EXT_ID));
407//                will(returnValue(1));
408//            }
409//        });
410//
411//        try {
412//            Map<String, String> result = jdbcSourceDao.addTargetSources(5, listnoesiTwo);
413//            assertEquals(1, result.size());// a new identifier must be produced
414//            SourceIdentifier sourceIdentifier = new SourceIdentifier(result.get(TestBackendConstants._TEST_TEMP_SOURCE_ID));
415//            assertFalse(null == sourceIdentifier.getUUID()); // check if a proper uuid has been assigned
416//        } catch (SQLException e) {
417//            System.out.print(e);
418//        }
419//
420//    }
421//   
422}
Note: See TracBrowser for help on using the repository browser.