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

Last change on this file since 4523 was 4523, checked in by olhsha, 10 years ago

Integrity service is adjusted and retested. Some REST methods fornotebooks are added (not tested)
File size: 54.0 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.dao.AnnotationDao;
23import eu.dasish.annotation.backend.dao.CachedRepresentationDao;
24import eu.dasish.annotation.backend.dao.NotebookDao;
25import eu.dasish.annotation.backend.dao.TargetDao;
26import eu.dasish.annotation.backend.dao.UserDao;
27import eu.dasish.annotation.schema.Annotation;
28import eu.dasish.annotation.schema.AnnotationBody;
29import eu.dasish.annotation.schema.AnnotationBody.TextBody;
30import eu.dasish.annotation.schema.AnnotationInfo;
31import eu.dasish.annotation.schema.AnnotationInfoList;
32import eu.dasish.annotation.schema.CachedRepresentationInfo;
33import eu.dasish.annotation.schema.Notebook;
34import eu.dasish.annotation.schema.NotebookInfo;
35import eu.dasish.annotation.schema.NotebookInfoList;
36import eu.dasish.annotation.schema.Permission;
37import eu.dasish.annotation.schema.ReferenceList;
38import eu.dasish.annotation.schema.Target;
39import eu.dasish.annotation.schema.TargetInfo;
40import eu.dasish.annotation.schema.User;
41import eu.dasish.annotation.schema.UserWithPermission;
42import eu.dasish.annotation.schema.UserWithPermissionList;
43import java.io.ByteArrayInputStream;
44import java.sql.SQLException;
45import java.sql.Timestamp;
46import java.util.ArrayList;
47import java.util.HashMap;
48import java.util.List;
49import java.util.Map;
50import java.util.UUID;
51import javax.sql.rowset.serial.SerialException;
52import javax.xml.datatype.DatatypeConfigurationException;
53import javax.xml.datatype.DatatypeFactory;
54import javax.xml.datatype.XMLGregorianCalendar;
55import org.jmock.Expectations;
56import org.jmock.Mockery;
57import org.junit.Test;
58import static org.junit.Assert.*;
59import org.junit.runner.RunWith;
60import org.springframework.beans.factory.annotation.Autowired;
61import org.springframework.test.context.ContextConfiguration;
62import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
63
64/**
65 *
66 * @author olhsha
67 */
68@RunWith(SpringJUnit4ClassRunner.class)
69@ContextConfiguration({"/spring-test-config/dataSource.xml", "/spring-test-config/mockeryDao.xml", "/spring-test-config/mockAnnotationDao.xml",
70    "/spring-test-config/mockUserDao.xml", "/spring-test-config/mockTargetDao.xml", "/spring-test-config/mockCachedRepresentationDao.xml",
71    "/spring-test-config/mockNotebookDao.xml",
72    "/spring-config/dbIntegrityService.xml"})
73public class DBIntegrityServiceTest {
74
75    @Autowired
76    private DBIntegrityServiceImlp dbIntegrityService;
77    @Autowired
78    private Mockery mockeryDao;
79    @Autowired
80    private UserDao userDao;
81    @Autowired
82    private CachedRepresentationDao cachedRepresentationDao;
83    @Autowired
84    private TargetDao targetDao;
85    @Autowired
86    private AnnotationDao annotationDao;
87    @Autowired
88    private NotebookDao notebookDao;
89    TestInstances testInstances = new TestInstances(TestBackendConstants._TEST_SERVLET_URI);
90
91    public DBIntegrityServiceTest() {
92    }
93
94    ///////// GETTERS /////////////
95    /**
96     * Test of getAnnotationInternalIdentifier method, of class
97     * DBIntegrityServiceImlp.
98     */
99    @Test
100    public void testGetAnnotationInternalIdentifier() {
101        System.out.println("getAnnotationInternalIdentifier");
102        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000021");
103
104        mockeryDao.checking(new Expectations() {
105            {
106                oneOf(annotationDao).getInternalID(externalID);
107                will(returnValue(1));
108            }
109        });
110        assertEquals(1, dbIntegrityService.getAnnotationInternalIdentifier(externalID));
111    }
112
113    /**
114     * Test of getAnnotationExternalIdentifier method, of class
115     * DBIntegrityServiceImlp.
116     */
117    @Test
118    public void testGetAnnotationExternalIdentifier() {
119        System.out.println("getAnnotationExternalIdentifier");
120        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000021");
121
122        mockeryDao.checking(new Expectations() {
123            {
124                oneOf(annotationDao).getExternalID(1);
125                will(returnValue(externalID));
126            }
127        });
128        assertEquals("00000000-0000-0000-0000-000000000021", dbIntegrityService.getAnnotationExternalIdentifier(1).toString());
129    }
130
131    /**
132     * Test of getUserInternalIdentifier method, of class
133     * DBIntegrityServiceImlp.
134     */
135    @Test
136    public void testGetUserInternalIdentifier() {
137        System.out.println("getUserInternalIdentifier");
138
139        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000111");
140
141        mockeryDao.checking(new Expectations() {
142            {
143                oneOf(userDao).getInternalID(externalID);
144                will(returnValue(1));
145            }
146        });
147        assertEquals(1, dbIntegrityService.getUserInternalIdentifier(externalID));
148    }
149
150    /**
151     * Test of getUserExternalIdentifier method, of class
152     * DBIntegrityServiceImlp.
153     */
154    @Test
155    public void testGetUserExternalIdentifier() {
156        System.out.println("getUserExternalIdentifier");
157        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000111");
158
159        mockeryDao.checking(new Expectations() {
160            {
161                oneOf(userDao).getExternalID(1);
162                will(returnValue(externalID));
163            }
164        });
165        assertEquals("00000000-0000-0000-0000-000000000111", dbIntegrityService.getUserExternalIdentifier(1).toString());
166    }
167
168    /**
169     * Test of getAnnotation method, of class DBIntegrityServiceImlp.
170     */
171    @Test
172    public void testGetAnnotation() throws Exception {
173        System.out.println("test getAnnotation");
174
175        final Annotation mockAnnotation = new Annotation();// corresponds to the annotation # 1
176        mockAnnotation.setURI(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021");
177        mockAnnotation.setHeadline("Sagrada Famiglia");
178        XMLGregorianCalendar mockTimeStamp = DatatypeFactory.newInstance().newXMLGregorianCalendar("2013-08-12T09:25:00.383000Z");
179        mockAnnotation.setLastModified(mockTimeStamp);
180        mockAnnotation.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000111");
181
182        AnnotationBody mockBody = new AnnotationBody();
183        TextBody textBody = new AnnotationBody.TextBody();
184        mockBody.setTextBody(textBody);
185        textBody.setMimeType("text/plain");
186        textBody.setBody("<html><body>some html 1</body></html>");
187        mockAnnotation.setBody(mockBody);
188        mockAnnotation.setTargets(null);
189
190
191        final List<Number> mockTargetIDs = new ArrayList<Number>();
192        mockTargetIDs.add(1);
193        mockTargetIDs.add(2);
194
195        final Target mockTargetOne = new Target();
196        mockTargetOne.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
197        mockTargetOne.setURI(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031");
198        mockTargetOne.setVersion("version 1.0");
199
200        final Target mockTargetTwo = new Target();
201        mockTargetTwo.setLink("http://nl.wikipedia.org/wiki/Antoni_Gaud%C3%AD");
202        mockTargetTwo.setURI(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000032");
203        mockTargetTwo.setVersion("version 1.1");
204
205        final List<Map<Number, String>> listMap = new ArrayList<Map<Number, String>>();
206        Map<Number, String> map2 = new HashMap<Number, String>();
207        map2.put(2, "writer");
208        listMap.add(map2);
209        Map<Number, String> map3 = new HashMap<Number, String>();
210        map3.put(3, "reader");
211        listMap.add(map3);
212
213        final String uri1 = TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000111";
214        final String uri2 = TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000112";
215        final String uri3 = TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113";
216
217
218        mockeryDao.checking(new Expectations() {
219            {
220                oneOf(annotationDao).getAnnotationWithoutTargetsAndPermissions(1);
221                will(returnValue(mockAnnotation));
222
223                oneOf(annotationDao).getOwner(1);
224                will(returnValue(1));
225
226                oneOf(userDao).getURIFromInternalID(1);
227                will(returnValue(uri1));
228
229                oneOf(annotationDao).retrieveTargetIDs(1);
230                will(returnValue(mockTargetIDs));
231
232                oneOf(targetDao).getTarget(1);
233                will(returnValue(mockTargetOne));
234
235                oneOf(targetDao).getTarget(2);
236                will(returnValue(mockTargetTwo));
237
238                /// getPermissionsForAnnotation
239
240                oneOf(annotationDao).getPermissions(1);
241                will(returnValue(listMap));
242
243                oneOf(userDao).getURIFromInternalID(2);
244                will(returnValue(uri2));
245
246                oneOf(userDao).getURIFromInternalID(3);
247                will(returnValue(uri3));
248            }
249        });
250
251        Annotation result = dbIntegrityService.getAnnotation(1);
252        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021", result.getURI());
253        assertEquals("text/plain", result.getBody().getTextBody().getMimeType());
254        assertEquals("<html><body>some html 1</body></html>", result.getBody().getTextBody().getBody());
255        assertEquals("Sagrada Famiglia", result.getHeadline());
256        assertEquals("2013-08-12T09:25:00.383000Z", result.getLastModified().toString());
257        assertEquals(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000111", result.getOwnerRef());
258
259        assertEquals(mockTargetOne.getLink(), result.getTargets().getTargetInfo().get(0).getLink());
260        assertEquals(mockTargetOne.getURI(), result.getTargets().getTargetInfo().get(0).getRef());
261        assertEquals(mockTargetOne.getVersion(), result.getTargets().getTargetInfo().get(0).getVersion());
262        assertEquals(mockTargetTwo.getLink(), result.getTargets().getTargetInfo().get(1).getLink());
263        assertEquals(mockTargetTwo.getURI(), result.getTargets().getTargetInfo().get(1).getRef());
264        assertEquals(mockTargetTwo.getVersion(), result.getTargets().getTargetInfo().get(1).getVersion());
265
266        assertEquals(Permission.WRITER, result.getPermissions().getUserWithPermission().get(0).getPermission());
267        assertEquals(uri2, result.getPermissions().getUserWithPermission().get(0).getRef());
268
269        assertEquals(Permission.READER, result.getPermissions().getUserWithPermission().get(1).getPermission());
270        assertEquals(uri3, result.getPermissions().getUserWithPermission().get(1).getRef());
271    }
272
273    /**
274     * Test of getFilteredAnnotationIDs method, of class DBIntegrityServiceImlp.
275     */
276    @Test
277    public void testGetFilteredAnnotationIDs() {
278        System.out.println("test getFilteredAnnotationIDs");
279
280        final List<Number> mockTargetIDs = new ArrayList<Number>();
281        mockTargetIDs.add(1);
282        mockTargetIDs.add(2);
283
284        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
285        mockAnnotationIDs1.add(1);
286
287        final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
288        mockAnnotationIDs2.add(1);
289        mockAnnotationIDs2.add(2);
290
291        final String after = (new Timestamp(0)).toString();
292        final String before = (new Timestamp(System.currentTimeMillis())).toString();
293
294        final List<Number> mockRetval = new ArrayList<Number>();
295        mockRetval.add(1);
296
297
298        mockeryDao.checking(new Expectations() {
299            {
300                oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
301                will(returnValue(mockTargetIDs));
302
303                oneOf(annotationDao).getAnnotationIDsForTargets(mockTargetIDs);
304                will(returnValue(mockAnnotationIDs2));
305
306                oneOf(annotationDao).getFilteredAnnotationIDs(null, "some html 1", null, after, before);
307                will(returnValue(mockAnnotationIDs1));
308
309                oneOf(annotationDao).getAnnotationIDsForUserWithPermission(3, "reader");
310                will(returnValue(mockAnnotationIDs1));
311
312
313
314            }
315        });
316
317
318        List result = dbIntegrityService.getFilteredAnnotationIDs(null, "nl.wikipedia.org", "some html 1", 3, "reader", null, after, before);
319        assertEquals(1, result.size());
320        assertEquals(1, result.get(0));
321    }
322
323    @Test
324    public void testGetAnnotationTargets() throws SQLException {
325        System.out.println("test getAnnotationTargets");
326        final List<Number> TargetIDs = new ArrayList<Number>();
327        TargetIDs.add(1);
328        TargetIDs.add(2);
329        mockeryDao.checking(new Expectations() {
330            {
331                oneOf(annotationDao).retrieveTargetIDs(1);
332                will(returnValue(TargetIDs));
333
334                oneOf(targetDao).getURIFromInternalID(1);
335                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031"));
336
337                oneOf(targetDao).getURIFromInternalID(2);
338                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000032"));
339
340            }
341        });
342
343        ReferenceList result = dbIntegrityService.getAnnotationTargets(1);
344        assertEquals(2, result.getRef().size());
345        assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031", result.getRef().get(0));
346        assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000032", result.getRef().get(1));
347
348    }
349
350//     @Override
351//    public AnnotationInfoList getFilteredAnnotationInfos(String link, String text, String access, String namespace, UUID
352//            owner, Timestamp after, Timestamp before){
353//        List<Number> annotationIDs = getFilteredAnnotationIDs(link, text, access, namespace, owner, after, before);
354//        List<AnnotationInfo> listAnnotationInfo = annotationDao.getAnnotationInfos(annotationIDs);
355    //       AnnotationInfoList result = new AnnotationInfoList();
356    //       result.getAnnotation().addAll(listAnnotationInfo);
357    //       return result;
358//    }
359    @Test
360    public void testGetFilteredAnnotationInfos() throws SQLException {
361        System.out.println("test getetFilteredAnnotationInfos");
362
363        final List<Number> mockTargetIDs = new ArrayList<Number>();
364        mockTargetIDs.add(1);
365        mockTargetIDs.add(2);
366
367        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
368        mockAnnotationIDs1.add(1);
369
370        final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
371        mockAnnotationIDs2.add(1);
372        mockAnnotationIDs2.add(2);
373
374        final UUID ownerUUID = UUID.fromString("00000000-0000-0000-0000-000000000111");
375        final String after = (new Timestamp(0)).toString();
376        final String before = (new Timestamp(System.currentTimeMillis())).toString();
377
378        final List<Number> mockAnnotIDs = new ArrayList<Number>();
379        mockAnnotIDs.add(1);
380
381        final AnnotationInfo mockAnnotInfo = new AnnotationInfo();
382
383        mockAnnotInfo.setHeadline("Sagrada Famiglia");
384        mockAnnotInfo.setRef(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021");
385        mockAnnotInfo.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000111");
386
387        final List<Number> targetIDs = new ArrayList<Number>();
388        targetIDs.add(1);
389        targetIDs.add(2);
390
391
392
393        mockeryDao.checking(new Expectations() {
394            {
395                oneOf(userDao).getInternalID(ownerUUID);
396                will(returnValue(1));
397
398                oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
399                will(returnValue(mockTargetIDs));
400
401                oneOf(annotationDao).getAnnotationIDsForTargets(mockTargetIDs);
402                will(returnValue(mockAnnotationIDs2));
403
404                oneOf(annotationDao).getFilteredAnnotationIDs(1, "some html 1", null, after, before);
405                will(returnValue(mockAnnotationIDs1));
406
407                oneOf(annotationDao).getAnnotationIDsForUserWithPermission(3, "reader");
408                will(returnValue(mockAnnotationIDs1));
409
410
411//                ///////////////////////////////////
412//               
413                oneOf(annotationDao).getAnnotationInfoWithoutTargets(1);
414                will(returnValue(mockAnnotInfo));
415
416                oneOf(annotationDao).getOwner(1);
417                will(returnValue(1));
418
419                oneOf(userDao).getURIFromInternalID(1);
420                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000111"));
421
422                ////
423                oneOf(annotationDao).retrieveTargetIDs(1);
424                will(returnValue(targetIDs));
425
426                oneOf(targetDao).getURIFromInternalID(1);
427                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031"));
428
429
430                oneOf(targetDao).getURIFromInternalID(2);
431                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000032"));
432
433
434            }
435        });
436
437
438        AnnotationInfoList result = dbIntegrityService.getFilteredAnnotationInfos(ownerUUID, "nl.wikipedia.org", "some html 1", 3, "reader", null, after, before);
439        assertEquals(1, result.getAnnotationInfo().size());
440        AnnotationInfo resultAnnotInfo = result.getAnnotationInfo().get(0);
441        assertEquals(mockAnnotInfo.getHeadline(), resultAnnotInfo.getHeadline());
442        assertEquals(mockAnnotInfo.getRef(), resultAnnotInfo.getRef());
443        assertEquals(mockAnnotInfo.getOwnerRef(), resultAnnotInfo.getOwnerRef());
444        assertEquals(mockAnnotInfo.getRef(), result.getAnnotationInfo().get(0).getRef());
445        assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031", resultAnnotInfo.getTargets().getRef().get(0));
446        assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000032", resultAnnotInfo.getTargets().getRef().get(1));
447
448    }
449
450    @Test
451    public void testGetTargetsWithNoCachedRepresentation() {
452        System.out.println("test getTargetsWithNoCachedRepresentation");
453        final List<Number> targetIDs = new ArrayList<Number>();
454        targetIDs.add(5);
455        targetIDs.add(7);
456
457        final List<Number> cachedIDs5 = new ArrayList<Number>();
458        cachedIDs5.add(7);
459        final List<Number> cachedIDs7 = new ArrayList<Number>();
460
461
462
463        mockeryDao.checking(new Expectations() {
464            {
465                oneOf(annotationDao).retrieveTargetIDs(3);
466                will(returnValue(targetIDs));
467
468                oneOf(targetDao).getCachedRepresentations(5);
469                will(returnValue(cachedIDs5));
470
471                oneOf(targetDao).getCachedRepresentations(7);
472                will(returnValue(cachedIDs7));
473
474                oneOf(targetDao).getURIFromInternalID(7);
475                will(returnValue("00000000-0000-0000-0000-000000000037"));
476
477            }
478        });
479
480        List<String> result = dbIntegrityService.getTargetsWithNoCachedRepresentation(3);
481        assertEquals(1, result.size());
482        assertEquals("00000000-0000-0000-0000-000000000037", result.get(0)); // Target number 7 has no cached
483    }
484
485    ////////////// ADDERS /////////////////////////
486    /**
487     * Test of addCachedForVersion method, of class DBIntegrityServiceImlp.
488     */
489    @Test
490    public void testAddCached() throws SerialException, SQLException {
491        System.out.println("addCached");
492        String mime = "text/html";
493        String type = "text";
494        String tool = "latex";
495        String externalID = UUID.randomUUID().toString();
496        final CachedRepresentationInfo newCachedInfo = new CachedRepresentationInfo();
497        newCachedInfo.setMimeType(mime);
498        newCachedInfo.setType(type);
499        newCachedInfo.setTool(tool);
500        newCachedInfo.setURI(TestBackendConstants._TEST_SERVLET_URI_cached + externalID);
501
502        String blobString = "aaa";
503        byte[] blobBytes = blobString.getBytes();
504        final ByteArrayInputStream newCachedBlob = new ByteArrayInputStream(blobBytes);
505
506        mockeryDao.checking(new Expectations() {
507            {
508
509                oneOf(cachedRepresentationDao).getInternalIDFromURI(newCachedInfo.getURI());
510                will(returnValue(null));
511
512                oneOf(cachedRepresentationDao).addCachedRepresentation(newCachedInfo, newCachedBlob);
513                will(returnValue(8));
514
515                one(targetDao).addTargetCachedRepresentation(1, 8, "#(1,2)");
516                will(returnValue(1));
517
518            }
519        });
520
521
522        Number[] result = dbIntegrityService.addCachedForTarget(1, "#(1,2)", newCachedInfo, newCachedBlob);
523        assertEquals(2, result.length);
524        assertEquals(1, result[0]);
525        assertEquals(8, result[1]);
526    }
527
528    /**
529     * Test of updateSiblingTargetClassForTarget method, of class
530     * DBIntegrityServiceImlp.
531     *
532     *
533     */
534    /**
535     * Test of addTargetsForAnnotation method, of class DBIntegrityServiceImlp.
536     */
537    @Test
538    public void testAddTargetsForAnnotation() throws Exception {
539        System.out.println("test addTargetsForAnnotation");
540
541        // test 1: adding an existing target
542        TargetInfo testTargetOne = new TargetInfo();
543        testTargetOne.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
544        testTargetOne.setRef(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031");
545        testTargetOne.setVersion("version 1.0");
546        final List<TargetInfo> mockTargetListOne = new ArrayList<TargetInfo>();
547        mockTargetListOne.add(testTargetOne);
548
549        mockeryDao.checking(new Expectations() {
550            {
551                oneOf(targetDao).getInternalIDFromURI(mockTargetListOne.get(0).getRef());
552                will(returnValue(1));
553
554                oneOf(annotationDao).addAnnotationTarget(4, 1);
555                will(returnValue(1));
556            }
557        });
558
559        Map<String, String> result = dbIntegrityService.addTargetsForAnnotation(4, mockTargetListOne);
560        assertEquals(0, result.size());
561
562        // test 2: adding a new Target
563        TargetInfo testTargetTwo = new TargetInfo();
564        final String tempTargetID = UUID.randomUUID().toString();
565        testTargetTwo.setRef(TestBackendConstants._TEST_SERVLET_URI_Targets + tempTargetID);
566        testTargetTwo.setLink("http://www.sagradafamilia.cat/docs_instit/historia.php");
567        testTargetTwo.setVersion("version 1.0");
568        final List<TargetInfo> mockTargetListTwo = new ArrayList<TargetInfo>();
569        mockTargetListTwo.add(testTargetTwo);
570
571        final UUID mockNewTargetUUID = UUID.randomUUID();
572
573        mockeryDao.checking(new Expectations() {
574            {
575                oneOf(targetDao).getInternalIDFromURI(mockTargetListTwo.get(0).getRef());
576                will(returnValue(null));
577
578                oneOf(targetDao).addTarget(with(aNonNull(Target.class)));
579                will(returnValue(8)); //# the next new number is 8, we have already 7 Targets
580
581                oneOf(targetDao).stringURItoExternalID(mockTargetListTwo.get(0).getRef());
582                will(returnValue(tempTargetID));
583
584                oneOf(targetDao).getExternalID(8);
585                will(returnValue(mockNewTargetUUID));
586
587                oneOf(annotationDao).addAnnotationTarget(1, 8);
588                will(returnValue(1));
589
590            }
591        });
592
593        Map<String, String> resultTwo = dbIntegrityService.addTargetsForAnnotation(1, mockTargetListTwo);
594        assertEquals(1, resultTwo.size());
595        assertEquals(mockNewTargetUUID.toString(), resultTwo.get(tempTargetID));
596
597    }
598
599    /**
600     * Test of addUsersAnnotation method, of class DBIntegrityServiceImlp.
601     */
602    @Test
603    public void testAddUsersAnnotation() throws Exception {
604        System.out.println("test addUsersAnnotation");
605
606        // expectations for addUsersannotation itself
607        final Annotation testAnnotation = testInstances.getAnnotationToAdd();
608
609        mockeryDao.checking(new Expectations() {
610            {
611                oneOf(annotationDao).addAnnotation(testAnnotation, 3);
612                will(returnValue(5)); // the next free number is 5
613
614                //  expectations for addTargetsForannotation
615                oneOf(targetDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031");
616                will(returnValue(1));
617
618                oneOf(annotationDao).addAnnotationTarget(5, 1);
619                will(returnValue(1));
620
621                ///////////
622
623                oneOf(annotationDao).updateAnnotationBody(5, testAnnotation.getBody().getTextBody().getBody(), testAnnotation.getBody().getTextBody().getMimeType(), false);
624                will(returnValue(1)); // the DB update will be called at perform anyway, even if the body is not changed (can be optimized)
625
626
627            }
628        });
629
630        Number result = dbIntegrityService.addUsersAnnotation(3, testAnnotation);
631        assertEquals(5, result);
632    }
633
634    @Test
635    public void testAddUser() {
636        System.out.println("test addUser");
637        final User freshUser = new User();
638        freshUser.setDisplayName("Guilherme");
639        freshUser.setEMail("Guilherme.Silva@mpi.nl");
640        mockeryDao.checking(new Expectations() {
641            {
642                oneOf(userDao).userExists(freshUser);
643                will(returnValue(false));
644
645                oneOf(userDao).addUser(freshUser, "guisil@mpi.nl");
646                will(returnValue(11));
647            }
648        });
649
650
651        assertEquals(11, dbIntegrityService.addUser(freshUser, "guisil@mpi.nl").intValue());
652
653        /// user already exists
654        final User user = new User();
655        freshUser.setDisplayName("Olha");
656        freshUser.setEMail("Olha.Shakaravska@mpi.nl");
657        mockeryDao.checking(new Expectations() {
658            {
659                oneOf(userDao).userExists(user);
660                will(returnValue(true));
661
662            }
663        });
664
665        assertTrue(null == dbIntegrityService.addUser(user, "olhsha@mpi.nl"));
666    }
667
668    //////////////////// DELETERS ////////////////
669    @Test
670    public void testDeleteUser() {
671        System.out.println("test deleteUser");
672
673        mockeryDao.checking(new Expectations() {
674            {
675                oneOf(userDao).deleteUser(1);
676                will(returnValue(0));
677
678                oneOf(userDao).deleteUser(3);
679                will(returnValue(0));
680
681                oneOf(userDao).deleteUser(10);
682                will(returnValue(1));
683
684            }
685        });
686
687        assertEquals(0, dbIntegrityService.deleteUser(1));
688        assertEquals(0, dbIntegrityService.deleteUser(3));
689        assertEquals(1, dbIntegrityService.deleteUser(10));
690    }
691
692    /**
693     * Test of deleteCachedForVersion method, of class DBIntegrityServiceImlp.
694     */
695    @Test
696    public void testDeleteCachedRepresentationForTarget() throws SQLException {
697        System.out.println("test deleteCachedRepresentationForTarget");
698        mockeryDao.checking(new Expectations() {
699            {
700                oneOf(targetDao).deleteTargetCachedRepresentation(5, 7);
701                will(returnValue(1));
702
703                oneOf(cachedRepresentationDao).deleteCachedRepresentation(7);
704                will(returnValue(1)); // cached is used by another version
705
706            }
707        });
708
709        int[] result = dbIntegrityService.deleteCachedRepresentationOfTarget(5, 7);
710        assertEquals(2, result.length);
711        assertEquals(1, result[0]);
712        assertEquals(1, result[1]);
713    }
714
715    /////////////////////////////////////////////
716    @Test
717    public void testDeleteAllCachedRepresentationsOfTarget() throws SQLException {
718        System.out.println("test deleteAllCachedRepresentationsOfTarget");
719        final List<Number> cachedList = new ArrayList<Number>();
720        cachedList.add(1);
721        cachedList.add(2);
722
723        mockeryDao.checking(new Expectations() {
724            {
725                oneOf(targetDao).getCachedRepresentations(1);
726                will(returnValue(cachedList));
727
728                oneOf(targetDao).deleteTargetCachedRepresentation(1, 1);
729                will(returnValue(1));
730
731                oneOf(cachedRepresentationDao).deleteCachedRepresentation(1);
732                will(returnValue(1));
733
734                oneOf(targetDao).deleteTargetCachedRepresentation(1, 2);
735                will(returnValue(1));
736
737                oneOf(cachedRepresentationDao).deleteCachedRepresentation(2);
738                will(returnValue(1));
739
740            }
741        });
742
743        int[] result = dbIntegrityService.deleteAllCachedRepresentationsOfTarget(1);
744        assertEquals(2, result[0]); // # affected rows in Targets_cacheds
745        assertEquals(2, result[1]); // # affected rows in cacheds
746    }
747
748    /**
749     * Test of deleteAnnotationWithTargets method, of class
750     * DBIntegrityServiceImlp.
751     */
752    @Test
753    public void testDeleteAnnotation() throws Exception {
754        System.out.println("deleteAnnotation ");
755
756        // deleting annotation 3, which has its target Target 2  (used by annotation # 1)
757        final List<Number> mockTargetIDs = new ArrayList<Number>();
758        mockTargetIDs.add(2);
759
760        final List<Number> mockCachedIDs = new ArrayList<Number>();
761        mockCachedIDs.add(3);
762
763        mockeryDao.checking(new Expectations() {
764            {
765                oneOf(annotationDao).deleteAnnotationPrincipalPermissions(2);
766                will(returnValue(2));
767
768                oneOf(annotationDao).retrieveTargetIDs(2);
769                will(returnValue(mockTargetIDs));
770
771                oneOf(annotationDao).deleteAllAnnotationTarget(2);
772                will(returnValue(1));
773
774                oneOf(annotationDao).deleteAnnotation(2);
775                will(returnValue(1));
776
777                oneOf(targetDao).getCachedRepresentations(2);
778                will(returnValue(mockCachedIDs));
779
780                oneOf(targetDao).deleteTargetCachedRepresentation(2, 3);
781                will(returnValue(1));
782
783                oneOf(cachedRepresentationDao).deleteCachedRepresentation(3);
784                will(returnValue(1));
785
786                oneOf(targetDao).deleteTarget(2);
787                will(returnValue(1));
788
789
790            }
791        });
792        int[] result = dbIntegrityService.deleteAnnotation(2);// the Target will be deleted because it is not referred by any annotation
793        assertEquals(4, result.length);
794        assertEquals(1, result[0]); // annotation 3 is deleted
795        assertEquals(2, result[1]); // 2 rows in "annotation principal permissions are deleted"
796        assertEquals(1, result[2]);  // row (3,2) in "annotations_Targets" is deleted
797        assertEquals(1, result[3]); //  Target 3 is deleted
798    }
799//    @Test
800//    public void testCreateTarget(){ 
801//        NewTargetInfo newTargetInfo = new NewTargetInfo();
802//        newTargetInfo.setLink(TestBackendConstants._TEST_NEW_Target_LINK);
803//        newTargetInfo.setVersion(null);
804//       
805//        Target result = dbIntegrityService.createTarget(newTargetInfo);
806//        assertEquals(TestBackendConstants._TEST_NEW_Target_LINK, result.getLink());
807//        assertFalse(null == result.getURI());
808//       
809//    }
810//   
811//    @Test
812//    public void testCreateVersion(){ 
813//        NewTargetInfo newTargetInfo = new NewTargetInfo();
814//        newTargetInfo.setLink(TestBackendConstants._TEST_NEW_Target_LINK);
815//        newTargetInfo.setVersion(null);
816//       
817//        Version result = dbIntegrityService.createVersion(newTargetInfo);
818//        assertFalse(null == result.getVersion()); // will be chnaged once the schema for version is fixed: ID is added
819//       
820//    }
821
822    /**
823     * NOTEBOOKS
824     */
825    /**
826     * Getters
827     */
828   
829//     public Number getNotebookInternalIdentifier(UUID externalIdentifier){
830//        return notebookDao.getInternalID(externalIdentifier);
831//    }
832   
833    @Test
834    public void testGetNotebookInternalIdentifier() {
835       
836        final UUID mockUUID = UUID.fromString("00000000-0000-0000-0000-000000000021");
837       
838        mockeryDao.checking(new Expectations() {
839            {
840                oneOf(notebookDao).getInternalID(mockUUID);
841                will(returnValue(1));
842            }
843        });
844
845       assertEquals(1, dbIntegrityService.getNotebookInternalIdentifier(mockUUID));
846   
847    } 
848       
849   
850   
851//    public NotebookInfoList getNotebooks(Number principalID, String permission) {
852//        NotebookInfoList result = new NotebookInfoList();
853//        if (permission.equalsIgnoreCase("reader") || permission.equalsIgnoreCase("writer")) {
854//            List<Number> notebookIDs = notebookDao.getNotebookIDs(principalID, Permission.fromValue(permission));
855//            for (Number notebookID : notebookIDs) {
856//                NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
857//                Number ownerID = notebookDao.getOwner(notebookID);
858//                notebookInfo.setOwnerRef(userDao.getURIFromInternalID(ownerID));
859//                result.getNotebookInfo().add(notebookInfo);
860//            }
861//        } else {
862//            if (permission.equalsIgnoreCase("owner")) {
863//                List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
864//                String ownerRef = userDao.getURIFromInternalID(principalID);
865//                for (Number notebookID : notebookIDs) {
866//                    NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
867//                    notebookInfo.setOwnerRef(ownerRef);
868//                    result.getNotebookInfo().add(notebookInfo);
869//                }
870//            } else {
871//                return null;
872//            }
873//        }
874//        return result;
875//    }
876    @Test
877    public void testGetNotebooksReaderBranch() {
878
879        final List<Number> mockNotebookIDs = new ArrayList<Number>();
880        mockNotebookIDs.add(1);
881
882        final NotebookInfo mockNotebookInfo = new NotebookInfo();
883        mockNotebookInfo.setRef("00000000-0000-0000-0000-000000000011");
884        mockNotebookInfo.setTitle("Notebook 1");
885
886        mockeryDao.checking(new Expectations() {
887            {
888                oneOf(notebookDao).getNotebookIDs(3, Permission.READER);
889                will(returnValue(mockNotebookIDs));
890
891                oneOf(notebookDao).getNotebookInfoWithoutOwner(1);
892                will(returnValue(mockNotebookInfo));
893
894                oneOf(notebookDao).getOwner(1);
895                will(returnValue(1));
896
897                oneOf(userDao).getURIFromInternalID(1);
898                will(returnValue("00000000-0000-0000-0000-000000000111"));
899
900            }
901        });
902
903        NotebookInfoList result = dbIntegrityService.getNotebooks(3, "reader");
904        assertEquals("00000000-0000-0000-0000-000000000011", result.getNotebookInfo().get(0).getRef());
905        assertEquals("00000000-0000-0000-0000-000000000111", result.getNotebookInfo().get(0).getOwnerRef());
906        assertEquals("Notebook 1", result.getNotebookInfo().get(0).getTitle());
907
908    }
909
910    @Test
911    public void testGetNotebooksOwnerBranch() {
912
913        final List<Number> mockNotebookIDs = new ArrayList<Number>();
914        mockNotebookIDs.add(3);
915        mockNotebookIDs.add(4);
916
917        final NotebookInfo mockNotebookInfo1 = new NotebookInfo();
918        mockNotebookInfo1.setRef("00000000-0000-0000-0000-000000000013");
919        mockNotebookInfo1.setTitle("Notebook 3");
920
921        final NotebookInfo mockNotebookInfo2 = new NotebookInfo();
922        mockNotebookInfo2.setRef("00000000-0000-0000-0000-000000000014");
923        mockNotebookInfo2.setTitle("Notebook 4");
924
925        mockeryDao.checking(new Expectations() {
926            {
927                oneOf(notebookDao).getNotebookIDsOwnedBy(3);
928                will(returnValue(mockNotebookIDs));
929
930                oneOf(userDao).getURIFromInternalID(3);
931                will(returnValue("00000000-0000-0000-0000-000000000113"));
932
933                oneOf(notebookDao).getNotebookInfoWithoutOwner(3);
934                will(returnValue(mockNotebookInfo1));
935
936                oneOf(notebookDao).getNotebookInfoWithoutOwner(4);
937                will(returnValue(mockNotebookInfo2));
938
939            }
940        });
941
942        NotebookInfoList result = dbIntegrityService.getNotebooks(3, "owner");
943        assertEquals("00000000-0000-0000-0000-000000000013", result.getNotebookInfo().get(0).getRef());
944        assertEquals("00000000-0000-0000-0000-000000000113", result.getNotebookInfo().get(0).getOwnerRef());
945        assertEquals("Notebook 3", result.getNotebookInfo().get(0).getTitle());
946        assertEquals("00000000-0000-0000-0000-000000000014", result.getNotebookInfo().get(1).getRef());
947        assertEquals("00000000-0000-0000-0000-000000000113", result.getNotebookInfo().get(1).getOwnerRef());
948        assertEquals("Notebook 4", result.getNotebookInfo().get(1).getTitle());
949
950    }
951
952//    public ReferenceList getNotebooksOwnedBy(Number principalID) {
953//        ReferenceList result = new ReferenceList();
954//        List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
955//        for (Number notebookID : notebookIDs) {
956//            String reference = notebookDao.getURIFromInternalID(notebookID);
957//            result.getRef().add(reference);
958//        }
959//        return result;
960//    }
961    @Test
962    public void testGetNotebooksOwnedBy() {
963
964        final List<Number> mockNotebookIDs = new ArrayList<Number>();
965        mockNotebookIDs.add(3);
966        mockNotebookIDs.add(4);
967
968        mockeryDao.checking(new Expectations() {
969            {
970                oneOf(notebookDao).getNotebookIDsOwnedBy(3);
971                will(returnValue(mockNotebookIDs));
972
973                oneOf(notebookDao).getURIFromInternalID(3);
974                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000013"));
975
976                oneOf(notebookDao).getURIFromInternalID(4);
977                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000014"));
978
979            }
980        });
981
982        ReferenceList result = dbIntegrityService.getNotebooksOwnedBy(3);
983        assertEquals(2, result.getRef().size());
984        assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000013", result.getRef().get(0));
985        assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000014", result.getRef().get(1));
986    }
987
988    /*
989     public ReferenceList getPrincipals(Number notebookID, String permission) {
990        ReferenceList result = new ReferenceList();
991        List<Number> principalIDs = notebookDao.getPrincipalIDsWithPermission(notebookID, Permission.fromValue(permission));
992        for (Number principalID : principalIDs) {
993            String reference = userDao.getURIFromInternalID(principalID);
994            result.getRef().add(reference);
995        }
996        return result;
997    }
998     }*/
999    @Test
1000    public void testGetPrincipals() {
1001        final List<Number> mockPrincipalIDs = new ArrayList<Number>();
1002        mockPrincipalIDs.add(2);
1003        mockPrincipalIDs.add(4);
1004       
1005        mockeryDao.checking(new Expectations() {
1006            {
1007                oneOf(notebookDao).getPrincipalIDsWithPermission(1, Permission.WRITER);
1008                will(returnValue(mockPrincipalIDs));
1009
1010                oneOf(userDao).getURIFromInternalID(2);
1011                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000112"));
1012
1013                oneOf(userDao).getURIFromInternalID(4);
1014                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000114"));
1015
1016
1017            }
1018        });
1019
1020        ReferenceList result = dbIntegrityService.getPrincipals(1, "writer");
1021        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000112", result.getRef().get(0).toString());
1022        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000114", result.getRef().get(1).toString());
1023
1024    }
1025
1026//   @Override
1027//    public Notebook getNotebook(Number notebookID) {
1028//        Notebook result = notebookDao.getNotebookWithoutAnnotationsAndPermissionsAndOwner(notebookID);
1029//
1030//        result.setOwnerRef(userDao.getURIFromInternalID(notebookDao.getOwner(notebookID)));
1031//
1032//        ReferenceList annotations = new ReferenceList();
1033//        List<Number> annotationIDs = notebookDao.getAnnotations(notebookID);
1034//        for (Number annotationID : annotationIDs) {
1035//            annotations.getRef().add(annotationDao.getURIFromInternalID(annotationID));
1036//        }
1037//        result.setAnnotations(annotations);
1038//
1039//        UserWithPermissionList ups = new UserWithPermissionList();
1040//        List<Permission> permissions = new ArrayList<Permission>();
1041//        permissions.add(Permission.READER);
1042//        permissions.add(Permission.WRITER);
1043//        for (Permission permission : permissions) {
1044//            List<Number> users = notebookDao.getPrincipalIDsWithPermission(notebookID, permission);
1045//            if (users != null) {
1046//                for (Number user : users) {
1047//                    UserWithPermission up = new UserWithPermission();
1048//                    up.setRef(userDao.getURIFromInternalID(user));
1049//                    up.setPermission(permission);
1050//                    ups.getUserWithPermission().add(up);
1051//                }
1052//            }
1053//        }
1054//
1055//        result.setPermissions(ups);
1056//        return result;
1057//    }
1058
1059
1060    @Test
1061    public void testGetNotebook() throws DatatypeConfigurationException{
1062
1063        final Notebook mockNotebook = new Notebook();
1064        mockNotebook.setURI("serviceURI/notebooks/00000000-0000-0000-0000-000000000012");
1065        mockNotebook.setTitle("Notebook 2");
1066        mockNotebook.setLastModified(DatatypeFactory.newInstance().newXMLGregorianCalendar("2014-02-12T09:25:00.383000Z"));
1067       
1068        final List<Number> mockAnnotations = new ArrayList<Number>();
1069        mockAnnotations.add(3);
1070       
1071        final List<Number> mockReaders = new ArrayList<Number>();
1072        mockReaders.add(1);
1073       
1074        final List<Number> mockWriters = new ArrayList<Number>();
1075        mockWriters.add(3);
1076       
1077        mockeryDao.checking(new Expectations() {
1078            {
1079                oneOf(notebookDao).getNotebookWithoutAnnotationsAndPermissionsAndOwner(2);
1080                will(returnValue(mockNotebook));
1081
1082                oneOf(notebookDao).getOwner(2);
1083                will(returnValue(2));
1084
1085                oneOf(userDao).getURIFromInternalID(2);
1086                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000112"));
1087
1088                oneOf(notebookDao).getAnnotations(2);
1089                will(returnValue(mockAnnotations));
1090               
1091                oneOf(annotationDao).getURIFromInternalID(3);
1092                will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000023"));
1093               
1094                oneOf(notebookDao).getPrincipalIDsWithPermission(2, Permission.READER);
1095                will(returnValue(mockReaders));
1096               
1097                oneOf(userDao).getURIFromInternalID(1);
1098                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000111"));
1099               
1100                oneOf(notebookDao).getPrincipalIDsWithPermission(2, Permission.WRITER);
1101                will(returnValue(mockWriters));
1102               
1103                oneOf(userDao).getURIFromInternalID(3);
1104                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000113"));
1105
1106               
1107
1108            }
1109        });
1110
1111        Notebook result = dbIntegrityService.getNotebook(2);
1112        assertEquals("serviceURI/notebooks/00000000-0000-0000-0000-000000000012", result.getURI());
1113        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000112", result.getOwnerRef());
1114        assertEquals("2014-02-12T09:25:00.383000Z", result.getLastModified().toString());
1115        assertEquals("Notebook 2", result.getTitle());
1116        assertEquals(1, result.getAnnotations().getRef().size());
1117        assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000023", result.getAnnotations().getRef().get(0));
1118        assertEquals(2, result.getPermissions().getUserWithPermission().size());
1119        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000111", result.getPermissions().getUserWithPermission().get(0).getRef());
1120        assertEquals("reader", result.getPermissions().getUserWithPermission().get(0).getPermission().value());
1121        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000113", result.getPermissions().getUserWithPermission().get(1).getRef());
1122        assertEquals("writer", result.getPermissions().getUserWithPermission().get(1).getPermission().value());
1123       
1124    }
1125
1126//    public List<UUID> getAnnotationsForNotebook(Number notebookID, int startAnnotation, int maximumAnnotations, String orderedBy, boolean desc) {
1127//        List<Number> annotationIDs = notebookDao.getAnnotations(notebookID);
1128//
1129//        if (startAnnotation < -1) {
1130//            logger.info("Variable's startAnnotation value " + startAnnotation + " is invalid. I will return null.");
1131//            return null;
1132//        }
1133//
1134//        if (maximumAnnotations < -1) {
1135//            logger.info("Variable's maximumAnnotations value " + maximumAnnotations + " is invalid. I will return null.");
1136//            return null;
1137//        }
1138//
1139//        int offset = (startAnnotation > 0) ? startAnnotation - 1 : 0;
1140//        String direction = desc ? " DESC " : " ASC ";
1141//        List<Number> selectedAnnotIDs = annotationDao.sublistOrderedAnnotationIDs(annotationIDs, offset, maximumAnnotations, orderedBy, direction);
1142//        List<UUID> annotationUUIDs = new ArrayList<UUID>();
1143//        for (Number annotationID : selectedAnnotIDs) {
1144//            annotationUUIDs.add(annotationDao.getExternalID(annotationID));
1145//        }
1146//        return annotationUUIDs;
1147//    }
1148    @Test
1149    public void testAnnotationsForNotebook() {
1150        final List<Number> mockAnnotationIDs = new ArrayList<Number>();
1151        mockAnnotationIDs.add(1);
1152        mockAnnotationIDs.add(2);
1153
1154        mockeryDao.checking(new Expectations() {
1155            {
1156                oneOf(notebookDao).getAnnotations(1);
1157                will(returnValue(mockAnnotationIDs));
1158
1159                oneOf(annotationDao).sublistOrderedAnnotationIDs(mockAnnotationIDs, 0, 3, "last_modified", "DESC");
1160                will(returnValue(mockAnnotationIDs));
1161
1162                oneOf(annotationDao).getURIFromInternalID(1);
1163                will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000021"));
1164
1165                oneOf(annotationDao).getURIFromInternalID(2);
1166                will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000022"));
1167
1168
1169
1170            }
1171        });
1172
1173        ReferenceList result = dbIntegrityService.getAnnotationsForNotebook(1, -1, 3, "last_modified", true);
1174        assertEquals(2, result.getRef().size());
1175        assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000021", result.getRef().get(0).toString());
1176        assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000022", result.getRef().get(1).toString());
1177
1178    }
1179
1180    /**
1181     * Updaters
1182     */
1183//    public boolean updateNotebookMetadata(Number notebookID, NotebookInfo upToDateNotebookInfo) {
1184//        Number ownerID = userDao.getInternalIDFromURI(upToDateNotebookInfo.getOwnerRef());
1185//        return notebookDao.updateNotebookMetadata(notebookID, upToDateNotebookInfo.getTitle(), ownerID);
1186//    }
1187    @Test
1188    public void testUpdateNotebookMetadata() {
1189
1190        final NotebookInfo mockNotebookInfo = new NotebookInfo();
1191        mockNotebookInfo.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113");
1192        mockNotebookInfo.setTitle("New Title");
1193
1194        mockeryDao.checking(new Expectations() {
1195            {
1196                oneOf(userDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113");
1197                will(returnValue(3));
1198
1199                oneOf(notebookDao).updateNotebookMetadata(1, "New Title", 3);
1200                will(returnValue(true));
1201            }
1202        });
1203
1204        boolean result = dbIntegrityService.updateNotebookMetadata(1, mockNotebookInfo);
1205        assertTrue(result);
1206    }
1207
1208//
1209//    public boolean addAnnotationToNotebook(Number notebookID, Number annotationID) {
1210//        return notebookDao.addAnnotationToNotebook(notebookID, annotationID);
1211//    }
1212    @Test
1213    public void testAddAnnotationToNotebook() {
1214
1215        mockeryDao.checking(new Expectations() {
1216            {
1217
1218                oneOf(notebookDao).addAnnotationToNotebook(1, 3);
1219                will(returnValue(true));
1220            }
1221        });
1222
1223        assertTrue(dbIntegrityService.addAnnotationToNotebook(1, 3));
1224    }
1225
1226    /**
1227     * Adders
1228     */
1229//    public Number createNotebook(Notebook notebook, Number ownerID) {
1230//        Number notebookID = notebookDao.createNotebookWithoutPermissionsAndAnnotations(notebook, ownerID);
1231//        boolean updateOwner = notebookDao.setOwner(notebookID, ownerID);
1232//        List<UserWithPermission> permissions = notebook.getPermissions().getUserWithPermission();
1233//        for (UserWithPermission principalPermission : permissions) {
1234//            Number principalID = userDao.getInternalIDFromURI(principalPermission.getRef());
1235//            Permission permission = principalPermission.getPermission();
1236//            boolean updatePermissions = notebookDao.addPermissionToNotebook(notebookID, principalID, permission);
1237//        }
1238//        return notebookID;
1239//    }
1240    @Test
1241    public void testCreateNotebook() {
1242
1243        final Notebook notebook = new Notebook();
1244        notebook.setOwnerRef("tmpXXX");
1245        notebook.setTitle("(Almost) Copy of Notebook 1");
1246        notebook.setURI("tmpYYY");
1247
1248        UserWithPermissionList permissions = new UserWithPermissionList();
1249        UserWithPermission p1 = new UserWithPermission();
1250        p1.setPermission(Permission.WRITER);
1251        p1.setRef(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000112");
1252        permissions.getUserWithPermission().add(p1);
1253        UserWithPermission p2 = new UserWithPermission();
1254        p2.setPermission(Permission.READER);
1255        p2.setRef(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113");
1256        permissions.getUserWithPermission().add(p2);
1257        notebook.setPermissions(permissions);
1258
1259        mockeryDao.checking(new Expectations() {
1260            {
1261                oneOf(notebookDao).createNotebookWithoutPermissionsAndAnnotations(notebook, 1);
1262                will(returnValue(5));
1263
1264                oneOf(notebookDao).setOwner(5, 1);
1265                will(returnValue(true));
1266
1267                oneOf(userDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000112");
1268                will(returnValue(2));
1269
1270                oneOf(userDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113");
1271                will(returnValue(3));
1272
1273                oneOf(notebookDao).addPermissionToNotebook(5, 2, Permission.WRITER);
1274                will(returnValue(true));
1275
1276                oneOf(notebookDao).addPermissionToNotebook(5, 3, Permission.READER);
1277                will(returnValue(true));
1278
1279            }
1280        });
1281
1282        Number result = dbIntegrityService.createNotebook(notebook, 1);
1283        assertEquals(5, result);
1284
1285    }
1286
1287//    public boolean createAnnotationInNotebook(Number notebookID, Annotation annotation, Number ownerID) {
1288//        Number newAnnotationID = this.addUsersAnnotation(ownerID, annotation);
1289//        return notebookDao.addAnnotationToNotebook(notebookID, newAnnotationID);
1290//    }
1291    @Test
1292    public void testCreateAnnotationInNotebook() {
1293
1294        final Annotation testAnnotation = testInstances.getAnnotationToAdd();
1295
1296        mockeryDao.checking(new Expectations() {
1297            {
1298                oneOf(annotationDao).addAnnotation(testAnnotation, 3);
1299                will(returnValue(5)); // the next free number is 5
1300
1301                //  expectations for addTargetsForannotation
1302                oneOf(targetDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031");
1303                will(returnValue(1));
1304
1305                oneOf(annotationDao).addAnnotationTarget(5, 1);
1306                will(returnValue(1));
1307
1308                oneOf(annotationDao).updateAnnotationBody(5, testAnnotation.getBody().getTextBody().getBody(), testAnnotation.getBody().getTextBody().getMimeType(), false);
1309                will(returnValue(1)); // the DB update will be called at perform anyway, even if the body is not changed (can be optimized)
1310
1311                /////////////////////////
1312
1313                oneOf(notebookDao).addAnnotationToNotebook(1, 5);
1314                will(returnValue(true));
1315            }
1316        });
1317
1318        assertTrue(dbIntegrityService.createAnnotationInNotebook(1, testAnnotation, 3));
1319
1320    }
1321
1322    /**
1323     * Deleters
1324     */
1325//      public boolean deleteNotebook(Number notebookID) {
1326//        if (notebookDao.deleteAllPermissionsForNotebook(notebookID) || notebookDao.deleteAllAnnotationsFromNotebook(notebookID)) {
1327//            return notebookDao.deleteNotebook(notebookID);
1328//        } else {
1329//            return false;
1330//        }
1331//   
1332//   }
1333    @Test
1334    public void testDeleteNotebook() {
1335
1336        mockeryDao.checking(new Expectations() {
1337            {
1338
1339                oneOf(notebookDao).deleteAllPermissionsForNotebook(1);
1340                will(returnValue(true));
1341
1342                oneOf(notebookDao).deleteAllAnnotationsFromNotebook(1);
1343                will(returnValue(true));
1344
1345                oneOf(notebookDao).deleteNotebook(1);
1346                will(returnValue(true));
1347            }
1348        });
1349
1350        assertTrue(dbIntegrityService.deleteNotebook(1));
1351    }
1352}
Note: See TracBrowser for help on using the repository browser.