Changeset 4464


Ignore:
Timestamp:
02/06/14 14:32:36 (10 years ago)
Author:
olhsha
Message:

Updating unit test for the Integrity Service class

Location:
DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/TestInstances.java

    r4461 r4464  
    5353   
    5454    private Annotation makeAnnotationToAdd(String baseURI){
    55        Annotation result = makeAnnotation(baseURI, "<html><body>some html 1</body></html>", "text/plain", "Annotation to add to test DAO", "00000000-0000-0000-0000-000000000111");
     55       Annotation result = makeAnnotation(baseURI, "<html><body>some html 3</body></html>", "text/plain", "Annotation to add to test DAO", "00000000-0000-0000-0000-000000000113");
    5656       
    5757       TargetInfo TargetInfo =  new TargetInfo();
    5858       TargetInfo.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
    59        TargetInfo.setRef("00000000-0000-0000-0000-000000000031");
     59       TargetInfo.setRef(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031");
    6060       TargetInfo.setVersion("version 1.0");
    6161       

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/DBIntegrityServiceTest.java

    r4461 r4464  
    167167        System.out.println("test getAnnotation");
    168168
    169         final Annotation mockAnnotation = new Annotation();// corresponds to the annotation # 2
     169        final Annotation mockAnnotation = new Annotation();// corresponds to the annotation # 1
    170170        mockAnnotation.setURI(TestBackendConstants._TEST_SERVLET_URI_annotations +"00000000-0000-0000-0000-000000000021");
    171171        mockAnnotation.setHeadline("Sagrada Famiglia");
    172172        XMLGregorianCalendar mockTimeStamp = DatatypeFactory.newInstance().newXMLGregorianCalendar("2013-08-12T09:25:00.383000Z");
    173173        mockAnnotation.setLastModified(mockTimeStamp);
    174         mockAnnotation.setOwnerRef("3");
     174        mockAnnotation.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_annotations +"00000000-0000-0000-0000-000000000111");
    175175
    176176        AnnotationBody mockBody = new AnnotationBody();
    … …  
    190190        mockTargetOne.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
    191191        mockTargetOne.setURI(TestBackendConstants._TEST_SERVLET_URI_Targets +"00000000-0000-0000-0000-000000000031");
    192         mockTargetOne.setVersion("00000000-0000-0000-0000-000000000031");
     192        mockTargetOne.setVersion("version 1.0");
    193193
    194194        final Target mockTargetTwo = new Target();
    195195        mockTargetTwo.setLink("http://nl.wikipedia.org/wiki/Antoni_Gaud%C3%AD");
    196196        mockTargetTwo.setURI(TestBackendConstants._TEST_SERVLET_URI_Targets +"00000000-0000-0000-0000-000000000032");
    197         mockTargetTwo.setVersion("00000000-0000-0000-0000-000000000032");
     197        mockTargetTwo.setVersion("version 1.1");
    198198
    199199        final List<Map<Number, String>> listMap = new ArrayList<Map<Number, String>>();
     200        Map<Number, String> map2 = new HashMap<Number, String>();
     201        map2.put(2, "writer");
     202        listMap.add(map2);
    200203        Map<Number, String> map3 = new HashMap<Number, String>();
    201         map3.put(3, "owner");
     204        map3.put(3, "reader");
    202205        listMap.add(map3);
    203         Map<Number, String> map4 = new HashMap<Number, String>();
    204         map4.put(4, "writer");
    205         listMap.add(map4);
    206         Map<Number, String> map5 = new HashMap<Number, String>();
    207         map5.put(5, "reader");
    208         listMap.add(map5);
    209 
    210         final String uri3 = TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000111";
    211         final String uri4 = TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000112";
    212         final String uri5 = TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000113";
    213 
    214        
    215         mockeryDao.checking(new Expectations() {
    216             {
    217                 oneOf(annotationDao).getAnnotationWithoutTargetsAndPermissions(2);
     206
     207        final String uri1 = TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000111";
     208        final String uri2 = TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000112";
     209        final String uri3 = TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000113";
     210
     211       
     212        mockeryDao.checking(new Expectations() {
     213            {
     214                oneOf(annotationDao).getAnnotationWithoutTargetsAndPermissions(1);
    218215                will(returnValue(mockAnnotation));
    219216               
    220                  oneOf(annotationDao).getOwner(2);
    221                 will(returnValue(3));
     217                oneOf(annotationDao).getOwner(1);
     218                will(returnValue(1));
     219
     220                oneOf(userDao).getURIFromInternalID(1);
     221                will(returnValue(uri1));
     222               
     223                oneOf(annotationDao).retrieveTargetIDs(1);
     224                will(returnValue(mockTargetIDs));
     225
     226                oneOf(targetDao).getTarget(1);
     227                will(returnValue(mockTargetOne));
     228
     229                oneOf(targetDao).getTarget(2);
     230                will(returnValue(mockTargetTwo));
     231
     232                /// getPermissionsForAnnotation
     233
     234                oneOf(annotationDao).getPermissions(1);
     235                will(returnValue(listMap));
     236
     237                oneOf(userDao).getURIFromInternalID(2);
     238                will(returnValue(uri2));
    222239
    223240                oneOf(userDao).getURIFromInternalID(3);
    224241                will(returnValue(uri3));
    225                
    226                 oneOf(annotationDao).retrieveTargetIDs(2);
    227                 will(returnValue(mockTargetIDs));
    228 
    229                 oneOf(targetDao).getTarget(1);
    230                 will(returnValue(mockTargetOne));
    231 
    232                 oneOf(targetDao).getTarget(2);
    233                 will(returnValue(mockTargetTwo));
    234 
    235                 /// getPermissionsForAnnotation
    236 
    237                 oneOf(annotationDao).getPermissions(2);
    238                 will(returnValue(listMap));
    239 
    240                 oneOf(userDao).getURIFromInternalID(3);
    241                 will(returnValue(uri3));
    242 
    243                 oneOf(userDao).getURIFromInternalID(4);
    244                 will(returnValue(uri4));
    245 
    246                  oneOf(userDao).getURIFromInternalID(5);
    247                 will(returnValue(uri5));
    248             }
    249         });
    250 
    251         Annotation result = dbIntegrityService.getAnnotation(2);
     242            }
     243        });
     244
     245        Annotation result = dbIntegrityService.getAnnotation(1);
    252246        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000021", result.getURI());
    253247        assertEquals("text/plain", result.getBody().getTextBody().getMimeType());
    … …  
    264258        assertEquals(mockTargetTwo.getVersion(), result.getTargets().getTargetInfo().get(1).getVersion());
    265259
    266         assertEquals(Permission.OWNER, result.getPermissions().getUserWithPermission().get(0).getPermission());
    267         assertEquals(uri3, result.getPermissions().getUserWithPermission().get(0).getRef());
    268 
    269         assertEquals(Permission.WRITER, result.getPermissions().getUserWithPermission().get(1).getPermission());
    270         assertEquals(uri4, result.getPermissions().getUserWithPermission().get(1).getRef());
    271 
    272         assertEquals(Permission.READER, result.getPermissions().getUserWithPermission().get(2).getPermission());
    273         assertEquals(uri5, result.getPermissions().getUserWithPermission().get(2).getRef());
     260        assertEquals(Permission.WRITER, result.getPermissions().getUserWithPermission().get(0).getPermission());
     261        assertEquals(uri2, result.getPermissions().getUserWithPermission().get(0).getRef());
     262
     263        assertEquals(Permission.READER, result.getPermissions().getUserWithPermission().get(1).getPermission());
     264        assertEquals(uri3, result.getPermissions().getUserWithPermission().get(1).getRef());
    274265    }
    275266
    … …  
    281272        System.out.println("test getFilteredAnnotationIDs");
    282273
    283         final String word = "nl.wikipedia.org";
    284 
    285274        final List<Number> mockTargetIDs = new ArrayList<Number>();
    286275        mockTargetIDs.add(1);
    … …  
    288277
    289278        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    290         mockAnnotationIDs1.add(3);
    291         mockAnnotationIDs1.add(4);
    292         mockAnnotationIDs1.add(5);
     279        mockAnnotationIDs1.add(1);
     280        mockAnnotationIDs1.add(2);
    293281       
    294282        final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
     283        mockAnnotationIDs2.add(1);
    295284        mockAnnotationIDs2.add(2);
    296         mockAnnotationIDs2.add(3);
    297285       
    298286        final String after = (new Timestamp(0)).toString();
    … …  
    300288
    301289        final List<Number> mockRetval = new ArrayList<Number>();
    302         mockRetval.add(3);
     290        mockRetval.add(1);
    303291       
    304292        final String[] accessModes = new String[2];
    … …  
    308296        mockeryDao.checking(new Expectations() {
    309297            {
    310                 oneOf(targetDao).getTargetsReferringTo(word);
     298                oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
    311299                will(returnValue(mockTargetIDs));
    312300
    … …  
    319307
    320308               
    321                 oneOf(annotationDao).getFilteredAnnotationIDs(mockAnnotationIDs1, null, "some html", null, after, before);
     309                oneOf(annotationDao).getFilteredAnnotationIDs(mockAnnotationIDs1, null, "some html 1", null, after, before);
    322310                will(returnValue(mockRetval));
    323311
    … …  
    326314
    327315
    328         List result = dbIntegrityService.getFilteredAnnotationIDs(null, word, "some html", 3, accessModes, null, after, before);
     316        List result = dbIntegrityService.getFilteredAnnotationIDs(null, "nl.wikipedia.org", "some html 1", 3, accessModes, null, after, before);
    329317        assertEquals(1, result.size());
    330         assertEquals(3, result.get(0));
     318        assertEquals(1, result.get(0));
    331319    }
    332320
    … …  
    335323    public void testGetAnnotationTargets() throws SQLException{
    336324        System.out.println("test getAnnotationTargets");
    337         final Number annotationID = 2;
    338325        final List<Number> TargetIDs = new ArrayList<Number>();
    339326        TargetIDs.add(1);
    … …  
    341328        mockeryDao.checking(new Expectations() {
    342329            {
    343                 oneOf(annotationDao).retrieveTargetIDs(annotationID);
     330                oneOf(annotationDao).retrieveTargetIDs(1);
    344331                will(returnValue(TargetIDs));
    345332
    … …  
    353340        });
    354341       
    355         ReferenceList result = dbIntegrityService.getAnnotationTargets(annotationID);
     342        ReferenceList result = dbIntegrityService.getAnnotationTargets(1);
    356343        assertEquals(2, result.getRef().size());
    357344        assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets+"00000000-0000-0000-0000-000000000031", result.getRef().get(0));
    … …  
    375362        System.out.println("test getetFilteredAnnotationInfos");
    376363       
    377         final String word = "nl.wikipedia.org";
    378 
    379364        final List<Number> mockTargetIDs = new ArrayList<Number>();
    380365        mockTargetIDs.add(1);
    … …  
    382367
    383368        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    384         mockAnnotationIDs1.add(3);
    385         mockAnnotationIDs1.add(4);
    386         mockAnnotationIDs1.add(5);
     369        mockAnnotationIDs1.add(1);
     370        mockAnnotationIDs1.add(2);
    387371       
    388372        final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
     373        mockAnnotationIDs2.add(1);
    389374        mockAnnotationIDs2.add(2);
    390         mockAnnotationIDs2.add(3);
    391 
    392 
    393         final String text = "some html";
    394         final UUID ownerUUID = UUID.fromString("00000000-0000-0000-0000-000000000112");
     375
     376        final UUID ownerUUID = UUID.fromString("00000000-0000-0000-0000-000000000111");
    395377        final String after = (new Timestamp(0)).toString();
    396378        final String before = (new Timestamp(System.currentTimeMillis())).toString();
    397379
    398380        final List<Number> mockAnnotIDs = new ArrayList<Number>();
    399         mockAnnotIDs.add(3);
     381        mockAnnotIDs.add(1);
    400382       
    401383        final AnnotationInfo mockAnnotInfo = new AnnotationInfo();
    402384       
    403         mockAnnotInfo.setHeadline("Gaudi");       
    404         mockAnnotInfo.setRef(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000022");
    405        
    406         final List<Number> TargetIDs = new ArrayList<Number>();
    407         TargetIDs.add(2);
    408        
     385        mockAnnotInfo.setHeadline("Sagrada Famiglia");       
     386        mockAnnotInfo.setRef(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021");
     387        mockAnnotInfo.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000111");
     388       
     389        final List<Number> targetIDs = new ArrayList<Number>();
     390        targetIDs.add(1);
     391        targetIDs.add(2);
    409392       
    410393        final String[] accessModes = new String[2];
    … …  
    415398            {
    416399                oneOf(userDao).getInternalID(ownerUUID);
    417                 will(returnValue(4));
     400                will(returnValue(1));
    418401               
    419402                oneOf(annotationDao).getAnnotationIDsForUserWithPermission(3, accessModes);
    420403                will(returnValue(mockAnnotationIDs1));
    421 
    422                
    423404             
    424405                // getFilteredAnnotationIds
    425                 oneOf(targetDao).getTargetsReferringTo(word);
     406                oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
    426407                will(returnValue(mockTargetIDs));
    427408               
    … …  
    430411               
    431412               
    432                 oneOf(annotationDao).getFilteredAnnotationIDs(mockAnnotationIDs1, 4, text, null, after, before);
     413                oneOf(annotationDao).getFilteredAnnotationIDs(mockAnnotationIDs1, 1, "some html 1", null, after, before);
    433414                will(returnValue(mockAnnotIDs));
    434415               
    … …  
    436417//                ///////////////////////////////////
    437418//               
    438                 oneOf(annotationDao).getAnnotationInfoWithoutTargets(3);
     419                oneOf(annotationDao).getAnnotationInfoWithoutTargets(1);
    439420                will(returnValue(mockAnnotInfo));
    440421               
    441                 oneOf(annotationDao).getOwner(3);
    442                 will(returnValue(4));
    443                
    444                 oneOf(userDao).getURIFromInternalID(4);
    445                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_users+"00000000-0000-0000-0000-000000000112"));
     422                oneOf(annotationDao).getOwner(1);
     423                will(returnValue(1));
     424               
     425                oneOf(userDao).getURIFromInternalID(1);
     426                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_users+"00000000-0000-0000-0000-000000000111"));
    446427               
    447428                ////
    448                 oneOf(annotationDao).retrieveTargetIDs(3);
    449                 will(returnValue(TargetIDs));
    450                
     429                oneOf(annotationDao).retrieveTargetIDs(1);
     430                will(returnValue(targetIDs));
     431               
     432                oneOf(targetDao).getURIFromInternalID(1);
     433                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets +"00000000-0000-0000-0000-000000000031"));
     434             
    451435               
    452436                oneOf(targetDao).getURIFromInternalID(2);
    … …  
    458442       
    459443     
    460         AnnotationInfoList result = dbIntegrityService.getFilteredAnnotationInfos(ownerUUID, word, text, 3, accessModes, null, after, before);
     444        AnnotationInfoList result = dbIntegrityService.getFilteredAnnotationInfos(ownerUUID, "nl.wikipedia.org", "some html 1", 3, accessModes, null, after, before);
    461445        assertEquals(1, result.getAnnotationInfo().size());
    462446        AnnotationInfo resultAnnotInfo = result.getAnnotationInfo().get(0);
    463447        assertEquals(mockAnnotInfo.getHeadline(), resultAnnotInfo.getHeadline());
    464         assertEquals(TestBackendConstants._TEST_SERVLET_URI_users +"00000000-0000-0000-0000-000000000112", resultAnnotInfo.getOwnerRef());
     448        assertEquals(mockAnnotInfo.getRef(), resultAnnotInfo.getRef());
     449        assertEquals(mockAnnotInfo.getOwnerRef(), resultAnnotInfo.getOwnerRef());
    465450        assertEquals(mockAnnotInfo.getRef(),result.getAnnotationInfo().get(0).getRef() );
    466         assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets +"00000000-0000-0000-0000-000000000032", resultAnnotInfo.getTargets().getRef().get(0));
     451        assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets +"00000000-0000-0000-0000-000000000031", resultAnnotInfo.getTargets().getRef().get(0));
     452        assertEquals(TestBackendConstants._TEST_SERVLET_URI_Targets +"00000000-0000-0000-0000-000000000032", resultAnnotInfo.getTargets().getRef().get(1));
    467453         
    468454    }
    … …  
    471457    public void testGetTargetsWithNoCachedRepresentation(){
    472458        System.out.println("test getTargetsWithNoCachedRepresentation");
    473         final Number annotationID = 4;
    474         final List<Number> TargetIDs = new ArrayList<Number>();
    475         TargetIDs.add(5);
    476         TargetIDs.add(7);
     459        final List<Number> targetIDs = new ArrayList<Number>();
     460        targetIDs.add(5);
     461        targetIDs.add(7);
    477462       
    478463        final List<Number> cachedIDs5 = new ArrayList<Number>();
    … …  
    484469        mockeryDao.checking(new Expectations() {
    485470            {
    486                 oneOf(annotationDao).retrieveTargetIDs(annotationID);
    487                 will(returnValue(TargetIDs));
     471                oneOf(annotationDao).retrieveTargetIDs(3);
     472                will(returnValue(targetIDs));
    488473
    489474                oneOf(targetDao).getCachedRepresentations(5);
    … …  
    499484        });
    500485       
    501         List<String> result = dbIntegrityService.getTargetsWithNoCachedRepresentation(annotationID);
     486        List<String> result = dbIntegrityService.getTargetsWithNoCachedRepresentation(3);
    502487        assertEquals(1, result.size());
    503488        assertEquals("00000000-0000-0000-0000-000000000037", result.get(0)); // Target number 7 has no cached
    … …  
    510495     */
    511496    @Test   
    512     public void testAddCachedForVersion() throws SerialException, SQLException {
    513         System.out.println("addCachedForVersion");
     497    public void testAddCached() throws SerialException, SQLException {
     498        System.out.println("addCached");
    514499        String mime = "text/html";
    515500        String type = "text";
    … …  
    525510        byte[] blobBytes = blobString.getBytes();
    526511        final ByteArrayInputStream newCachedBlob = new ByteArrayInputStream(blobBytes);
    527         final Number newCachedID = 8;
    528         final Number versionID = 1;
     512       
    529513        mockeryDao.checking(new Expectations() {
    530514            {
    … …  
    534518
    535519                oneOf(cachedRepresentationDao).addCachedRepresentation(newCachedInfo, newCachedBlob);
    536                 will(returnValue(newCachedID));
    537 
    538                 one(targetDao).addTargetCachedRepresentation(versionID, newCachedID, "#(1,2)");
    539                 will(returnValue(1));
    540 
    541             }
    542         });
    543 
    544 
    545         Number[] result = dbIntegrityService.addCachedForTarget(versionID, "#(1,2)", newCachedInfo, newCachedBlob);
     520                will(returnValue(8));
     521
     522                one(targetDao).addTargetCachedRepresentation(1, 8, "#(1,2)");
     523                will(returnValue(1));
     524
     525            }
     526        });
     527
     528
     529        Number[] result = dbIntegrityService.addCachedForTarget(1, "#(1,2)", newCachedInfo, newCachedBlob);
    546530        assertEquals(2, result.length);
    547531        assertEquals(1, result[0]);
    548         assertEquals(newCachedID, result[1]);
     532        assertEquals(8, result[1]);
    549533    }
    550534
    … …  
    564548        System.out.println("test addTargetsForAnnotation");
    565549
    566 //        @Override
    567 //        public Map<String, String> addTargetsForAnnotation(Number annotationID, List<TargetInfo> Targets) throws SQLException {
    568 //        Map<String, String> result = new HashMap<String, String>();
    569 //        Number TargetIDRunner;
    570 //        for (TargetInfo TargetInfo : Targets) {
    571 //            TargetIDRunner = TargetDao.getInternalIDFromURI(TargetInfo.getRef());
    572 //            if (TargetIDRunner != null) {
    573 //                int affectedRows = annotationDao.addAnnotationTarget(annotationID, TargetIDRunner);
    574 //            } else {
    575 //                Target newTarget = createFreshTarget(TargetInfo);
    576 //                Number TargetID = TargetDao.addTarget(newTarget);
    577 //                String TargetTemporaryID = TargetDao.stringURItoExternalID(TargetInfo.getRef());
    578 //                result.put(TargetTemporaryID, TargetDao.getExternalID(TargetID).toString());
    579 //                int affectedRows = annotationDao.addAnnotationTarget(annotationID, TargetID);
    580 //            }
    581 //        }
    582 //        return result;
    583 //    }
    584        
    585         // test 1: adding an existing Target
     550        // test 1: adding an existing target
    586551        TargetInfo testTargetOne = new TargetInfo();
    587552        testTargetOne.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
    588553        testTargetOne.setRef(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031");
    589         testTargetOne.setVersion("version 1.1");
     554        testTargetOne.setVersion("version 1.0");
    590555        final List<TargetInfo> mockTargetListOne = new ArrayList<TargetInfo>();
    591556        mockTargetListOne.add(testTargetOne);
    … …  
    596561                will(returnValue(1));
    597562
    598                 oneOf(annotationDao).addAnnotationTarget(1, 1);
    599                 will(returnValue(1));
    600             }
    601         });
    602 
    603         Map<String, String> result = dbIntegrityService.addTargetsForAnnotation(1, mockTargetListOne);
     563                oneOf(annotationDao).addAnnotationTarget(4, 1);
     564                will(returnValue(1));
     565            }
     566        });
     567
     568        Map<String, String> result = dbIntegrityService.addTargetsForAnnotation(4, mockTargetListOne);
    604569        assertEquals(0, result.size());
    605570       
    606         //        @Override
    607 //        public Map<String, String> addTargetsForAnnotation(Number annotationID, List<TargetInfo> Targets) throws SQLException {
    608 //        Map<String, String> result = new HashMap<String, String>();
    609 //        Number TargetIDRunner;
    610 //        for (TargetInfo TargetInfo : Targets) {
    611 //            TargetIDRunner = TargetDao.getInternalIDFromURI(TargetInfo.getRef());
    612 //            if (TargetIDRunner != null) {
    613 //                int affectedRows = annotationDao.addAnnotationTarget(annotationID, TargetIDRunner);
    614 //            } else {
    615 //                Target newTarget = createFreshTarget(TargetInfo);
    616 //                Number TargetID = TargetDao.addTarget(newTarget);
    617 //                String TargetTemporaryID = TargetDao.stringURItoExternalID(TargetInfo.getRef());
    618 //                result.put(TargetTemporaryID, TargetDao.getExternalID(TargetID).toString());
    619 //                int affectedRows = annotationDao.addAnnotationTarget(annotationID, TargetID);
    620 //            }
    621 //        }
    622 //        return result;
    623 //    }
    624        
    625 
    626571        // test 2: adding a new Target
    627572        TargetInfo testTargetTwo = new TargetInfo();
    … …  
    674619        mockeryDao.checking(new Expectations() {
    675620            {
    676                 oneOf(annotationDao).addAnnotation(testAnnotation, 5);
    677                 will(returnValue(6)); // the next free number is 6
     621                oneOf(annotationDao).addAnnotation(testAnnotation, 3);
     622                will(returnValue(5)); // the next free number is 5
    678623
    679624                //  expectations for addTargetsForannotation
    680                 oneOf(targetDao).getInternalIDFromURI(with(aNonNull(String.class)));
    681                 will(returnValue(1));
    682 
    683                 oneOf(annotationDao).addAnnotationTarget(6, 1);
     625                oneOf(targetDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_Targets + "00000000-0000-0000-0000-000000000031");
     626                will(returnValue(1));
     627
     628                oneOf(annotationDao).addAnnotationTarget(5, 1);
    684629                will(returnValue(1));
    685630
    686631                ///////////
    687632
    688                 oneOf(annotationDao).updateAnnotationBody(6, testAnnotation.getBody().getTextBody().getBody(), testAnnotation.getBody().getTextBody().getMimeType(), false);
     633                oneOf(annotationDao).updateAnnotationBody(5, testAnnotation.getBody().getTextBody().getBody(), testAnnotation.getBody().getTextBody().getMimeType(), false);
    689634                will(returnValue(1)); // the DB update will be called at perform anyway, even if the body is not changed (can be optimized)
    690635
    … …  
    693638        });
    694639
    695         Number result = dbIntegrityService.addUsersAnnotation(5, testAnnotation);
    696         assertEquals(6, result);
     640        Number result = dbIntegrityService.addUsersAnnotation(3, testAnnotation);
     641        assertEquals(5, result);
    697642    }
    698643
    … …  
    703648        final User freshUser = new User();
    704649        freshUser.setDisplayName("Guilherme");
    705         freshUser.setEMail("guisil@mpi.nl");
     650        freshUser.setEMail("Guilherme.Silva@mpi.nl");
    706651        mockeryDao.checking(new Expectations() {
    707652            {
    … …  
    709654                will(returnValue(false));
    710655
    711                 oneOf(userDao).addUser(freshUser, "xx");
    712                 will(returnValue(7));
    713             }
    714         });
    715 
    716 
    717         assertEquals(7, dbIntegrityService.addUser(freshUser, "xx").intValue());
     656                oneOf(userDao).addUser(freshUser, "guisil@mpi.nl");
     657                will(returnValue(11));
     658            }
     659        });
     660
     661
     662        assertEquals(11, dbIntegrityService.addUser(freshUser, "guisil@mpi.nl").intValue());
    718663
    719664        /// user already exists
    720665        final User user = new User();
    721666        freshUser.setDisplayName("Olha");
    722         freshUser.setEMail("olhsha@mpi.nl");
     667        freshUser.setEMail("Olha.Shakaravska@mpi.nl");
    723668        mockeryDao.checking(new Expectations() {
    724669            {
    … …  
    729674        });
    730675
    731         assertTrue(null == dbIntegrityService.addUser(user, "yy"));
     676        assertTrue(null == dbIntegrityService.addUser(user, "olhsha@mpi.nl"));
    732677    }
    733678
    … …  
    740685        mockeryDao.checking(new Expectations() {
    741686            {
    742                 oneOf(userDao).deleteUser(2);
     687                oneOf(userDao).deleteUser(1);
    743688                will(returnValue(0));
    744689
    745                 oneOf(userDao).deleteUser(5);
     690                oneOf(userDao).deleteUser(3);
    746691                will(returnValue(0));
    747692
    748                 oneOf(userDao).deleteUser(6);
    749                 will(returnValue(1));
    750 
    751             }
    752         });
    753 
    754         assertEquals(0, dbIntegrityService.deleteUser(2));
    755         assertEquals(0, dbIntegrityService.deleteUser(5));
    756         assertEquals(1, dbIntegrityService.deleteUser(6));
     693                oneOf(userDao).deleteUser(10);
     694                will(returnValue(1));
     695
     696            }
     697        });
     698
     699        assertEquals(0, dbIntegrityService.deleteUser(1));
     700        assertEquals(0, dbIntegrityService.deleteUser(3));
     701        assertEquals(1, dbIntegrityService.deleteUser(10));
    757702    }
    758703
    … …  
    835780        mockeryDao.checking(new Expectations() {
    836781            {
    837                 oneOf(annotationDao).deleteAnnotationPrincipalPermissions(3);
    838                 will(returnValue(3));
    839 
    840                 oneOf(annotationDao).retrieveTargetIDs(3);
     782                oneOf(annotationDao).deleteAnnotationPrincipalPermissions(2);
     783                will(returnValue(2));
     784
     785                oneOf(annotationDao).retrieveTargetIDs(2);
    841786                will(returnValue(mockTargetIDs));               
    842787             
    843                 oneOf(annotationDao).deleteAllAnnotationTarget(3);
    844                 will(returnValue(1));
    845 
    846                 oneOf(annotationDao).deleteAnnotation(3);
     788                oneOf(annotationDao).deleteAllAnnotationTarget(2);
     789                will(returnValue(1));
     790
     791                oneOf(annotationDao).deleteAnnotation(2);
    847792                will(returnValue(1));
    848793               
    … …  
    862807            }
    863808        });
    864         int[] result = dbIntegrityService.deleteAnnotation(3);// the Target will be deleted because it is not referred by any annotation
     809        int[] result = dbIntegrityService.deleteAnnotation(2);// the Target will be deleted because it is not referred by any annotation
    865810        assertEquals(4, result.length);
    866811        assertEquals(1, result[0]); // annotation 3 is deleted
    867         assertEquals(3, result[1]); // 3 rows in "annotation principal permissions are deleted"
     812        assertEquals(2, result[1]); // 2 rows in "annotation principal permissions are deleted"
    868813        assertEquals(1, result[2]);  // row (3,2) in "annotations_Targets" is deleted
    869814        assertEquals(1, result[3]); //  Target 3 is deleted
Note: See TracChangeset for help on using the changeset viewer.