Changeset 5838 for DASISH


Ignore:
Timestamp:
11/19/14 17:21:25 (10 years ago)
Author:
olhsha@mpi.nl
Message:

units tests updating and adding (all-access)

Location:
DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/AnnotationDao.java

    r5836 r5838  
    5252     *
    5353     */
    54     public Annotation getAnnotationWithoutTargetsAndPemissions(Number annotationID);
     54    public Annotation getAnnotationWithoutTargetsAndPemissionList(Number annotationID);
    5555   
    5656     

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

    r5836 r5838  
    127127    @Override
    128128    public Annotation getAnnotation(Number annotationID) {
    129         Annotation result = annotationDao.getAnnotationWithoutTargetsAndPemissions(annotationID);
     129        Annotation result = annotationDao.getAnnotationWithoutTargetsAndPemissionList(annotationID);
    130130        result.setOwnerHref(principalDao.getHrefFromInternalID(annotationDao.getOwner(annotationID)));
    131131        List<Number> targetIDs = targetDao.getTargetIDs(annotationID);
    … …  
    136136        }
    137137        result.setTargets(sis);
    138         result.setPermissions(this.getPermissions(annotationID, Resource.ANNOTATION));
     138        this.fillInPermissionList(result.getPermissions().getPermission(), annotationID, Resource.ANNOTATION);
    139139        return result;
    140140    }
    … …  
    152152
    153153    ///////////////////////////////////////////////////
    154     // TODO UNIT tests
    155     @Override
    156     public PermissionList getPermissions(Number resourceID, Resource resource) {
     154   
     155    private void fillInPermissionList(List<Permission> listPermissions, Number resourceID, Resource resource) {
    157156        List<Map<Number, String>> principalsAccesss = this.getDao(resource).getPermissions(resourceID);
    158         PermissionList result = new PermissionList();
    159         result.setPublic(this.getDao(resource).getPublicAttribute(resourceID));
    160         List<Permission> list = result.getPermission();
    161157        for (Map<Number, String> principalAccess : principalsAccesss) {
    162158            Number[] principal = new Number[1];
    … …  
    165161            permission.setPrincipalHref(principalDao.getHrefFromInternalID(principal[0]));
    166162            permission.setLevel(Access.fromValue(principalAccess.get(principal[0])));
    167             list.add(permission);
    168         }
     163            listPermissions.add(permission);
     164        }
     165    }
     166   
     167    @Override
     168    public PermissionList getPermissions(Number resourceID, Resource resource) {
     169        PermissionList result = new PermissionList();
     170        result.setPublic(this.getDao(resource).getPublicAttribute(resourceID));
     171        this.fillInPermissionList(result.getPermission(), resourceID, resource);
    169172        return result;
    170173    }
    … …  
    733736            int deletedPrinsipalsAccesss = annotationDao.deletePermissions(annotationID);
    734737            int addedPrincipalsAccesss = this.addPermissions(annotation.getPermissions().getPermission(), annotationID);
    735             //int updatedPublicAttribute = annotationDao.updatePublicAccess(annotationID, annotation.getPermissions().getPublic());
     738               
    736739        };
    737740        return updatedAnnotations;
    … …  
    822825        int affectedAnnotRows = this.addTargets(annotation, annotationID);
    823826        int addedPrincipalsAccesss = this.addPermissions(annotation.getPermissions().getPermission(), annotationID);
    824         //int updatedPublic = annotationDao.updatePublicAccess(annotationID, annotation.getPermissions().getPublic());
    825827        return annotationID;
    826828    }

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

    r5836 r5838  
    2727import eu.dasish.annotation.schema.AnnotationInfo;
    2828import eu.dasish.annotation.schema.Access;
     29import eu.dasish.annotation.schema.PermissionList;
    2930import java.io.IOException;
    3031import java.lang.String;
    … …  
    190191                accessConstraint.append(" OR ").append(column).append("  = '").append(Access.ALL.value()).append("')");
    191192            } else if (access.equals(Access.ALL)) {
    192                 accessConstraint.append("(").append(column).append("  = '").append(Access.ALL.value()).append("')");
     193                accessConstraint.append(column).append("  = '").append(Access.ALL.value()).append("'");
    193194            } else {
    194                 accessConstraint.append("(").append(column).append("  = '").append(Access.NONE.value()).append("')");
     195                accessConstraint.append(column).append("  = '").append(Access.NONE.value()).append("'");
    195196            }
    196197        }
    … …  
    285286    //////////////////////////////////////////////////////////////////////////
    286287    @Override
    287     public Annotation getAnnotationWithoutTargetsAndPemissions(Number annotationID) {
     288    public Annotation getAnnotationWithoutTargetsAndPemissionList(Number annotationID) {
    288289
    289290        StringBuilder sql = new StringBuilder("SELECT ");
    … …  
    328329            }
    329330            annotation.setBody(body);
    330 
     331           
     332            PermissionList permissions = new PermissionList();
     333            permissions.setPublic(Access.fromValue(rs.getString(public_)));
     334            annotation.setPermissions(permissions);
     335                   
    331336            annotation.setTargets(null);
    332337            String externalId = rs.getString(external_id);

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/webapp/WEB-INF/web.xml

    r5774 r5838  
    4040    <context-param>
    4141        <param-name>eu.dasish.annotation.backend.isShibbolethSession</param-name>
    42         <param-value>true</param-value>
     42        <param-value>false</param-value>
    4343    </context-param>
    4444    <context-param>
    … …  
    111111   
    112112    <!-- Spring security -->
    113      <!-- <filter>
     113      <filter>
    114114        <filter-name>springSecurityFilterChain</filter-name>
    115115        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    … …  
    118118        <filter-name>springSecurityFilterChain</filter-name>
    119119        <url-pattern>/*</url-pattern>
    120     </filter-mapping> -->
     120    </filter-mapping>
    121121   
    122122    <!--  Shibboleth filter -->
    123   <filter>
     123  <!-- <filter>
    124124        <filter-name>AAIFilter</filter-name>
    125125        <filter-class>de.mpg.aai.shhaa.AuthFilter</filter-class>
    … …  
    128128        <filter-name>AAIFilter</filter-name>
    129129        <url-pattern>/*</url-pattern>
    130     </filter-mapping>
     130    </filter-mapping> -->
    131131   
    132132  </web-app> 

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

    r5393 r5838  
    101101        permissions.setPublic(Access.WRITE);
    102102        result.setPermissions(permissions);
     103        Permission p = new Permission();
     104        p.setLevel(Access.ALL);
     105        p.setPrincipalHref(relativePath +"/principals/00000000-0000-0000-0000-000000000111");
     106        permissions.getPermission().add(p);
    103107
    104108        return result;

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

    r5836 r5838  
    197197        textBody.setBody("<html><body>some html 1</body></html>");
    198198        mockAnnotation.setBody(mockBody);
     199        PermissionList permissions = new PermissionList();
     200        permissions.setPublic(Access.WRITE);
     201        mockAnnotation.setPermissions(permissions);
    199202        mockAnnotation.setTargets(null);
    200203
    … …  
    235238        mockeryDao.checking(new Expectations() {
    236239            {
    237                 oneOf(annotationDao).getAnnotationWithoutTargetsAndPemissions(1);
     240                oneOf(annotationDao).getAnnotationWithoutTargetsAndPemissionList(1);
    238241                will(returnValue(mockAnnotation));
    239242
    … …  
    257260                oneOf(annotationDao).getPermissions(1);
    258261                will(returnValue(listMap));
    259 
    260                 oneOf(annotationDao).getPublicAttribute(1);
    261                 will(returnValue(Access.WRITE));
    262262
    263263                oneOf(principalDao).getHrefFromInternalID(2);
    … …  
    12531253                will(returnValue(1));
    12541254
    1255                 ///////////
     1255                ///
    12561256
    12571257                oneOf(annotationDao).updateAnnotationBody(5, testAnnotation.getBody().getTextBody().getBody(), testAnnotation.getBody().getTextBody().getMimeType(), false);
    12581258                will(returnValue(1)); // the DB update will be called at perform anyway, even if the body is not changed (can be optimized)
    12591259
    1260                 oneOf(annotationDao).updatePublicAccess(5, Access.WRITE);
     1260                //////
     1261               
     1262               
     1263                oneOf(principalDao).getInternalIDFromHref("/api/principals/00000000-0000-0000-0000-000000000111");
     1264                will(returnValue(1));
     1265               
     1266                oneOf(annotationDao).addPermission(5, 1, Access.ALL);
    12611267                will(returnValue(1));
    12621268            }
    … …  
    12651271        Number result = dbDispatcher.addPrincipalsAnnotation(3, testAnnotation);
    12661272        assertEquals(5, result);
    1267 
    1268 //        Annotation newAnnotation = dbDispatcher.getAnnotation(5);
    1269 //        assertEquals("/api/principals/00000000-0000-0000-0000-000000000113", newAnnotation.getOwnerHref());
    1270 //        assertEquals(testAnnotation.getHeadline(), newAnnotation.getHeadline());
    1271 //        assertEquals(testAnnotation.getBody().getTextBody().getBody(), newAnnotation.getBody().getTextBody().getBody());
    1272 //        assertEquals(testAnnotation.getBody().getTextBody().getMimeType(), newAnnotation.getBody().getTextBody().getMimeType());
    1273 //        assertEquals(testAnnotation.getPermissions().getPermission().size(), newAnnotation.getPermissions().getPermission().size());
    1274 //        assertEquals(Access.WRITE, newAnnotation.getPermissions().getPublic());
    1275 //        assertEquals(testAnnotation.getTargets().getTargetInfo().size(), newAnnotation.getTargets().getTargetInfo().size());
    1276 
    12771273    }
    12781274
    … …  
    19551951                oneOf(annotationDao).updatePublicAccess(5, Access.WRITE);
    19561952                will(returnValue(1));
     1953               
     1954                ////               
     1955                   
     1956                oneOf(principalDao).getInternalIDFromHref("/api/principals/00000000-0000-0000-0000-000000000111");
     1957                will(returnValue(1));
    19571958
    19581959                /////////////////////////
    … …  
    19601961                oneOf(notebookDao).addAnnotationToNotebook(1, 5);
    19611962                will(returnValue(true));
     1963               
     1964                oneOf(annotationDao).addPermission(5, 1, Access.ALL);
     1965                will(returnValue(1));
    19621966            }
    19631967        });
    … …  
    20912095        final Annotation annotation = (new TestInstances("/api")).getAnnotationOne();
    20922096        final NotInDataBaseException e = new NotInDataBaseException("annotation", "external ID", "00000000-0000-0000-0000-000000000031");
    2093         final String mockTempID = "00000000-0000-0000-0000-000000000031";
    20942097        final UUID mockNewID = Helpers.generateUUID();
    20952098        final PermissionList permissions = annotation.getPermissions();
    … …  
    21592162                oneOf(annotationDao).updateAnnotationBody(1, annotation.getBody().getTextBody().getBody(), "text/html", false);
    21602163                will(returnValue(1));
    2161 
    2162                 ///
    2163 
    2164                 oneOf(annotationDao).updatePublicAccess(1, permissions.getPublic());
    2165                 will(returnValue(1));
    2166 
    21672164
    21682165            }
    … …  
    22162213                oneOf(annotationDao).addPermission(1, 4, Access.WRITE);
    22172214                will(returnValue(1));
     2215               
     2216                oneOf(annotationDao).deletePermission(1, 2);
     2217                will(returnValue(1));
    22182218
    22192219            }
    … …  
    22222222        assertEquals(1, dbDispatcher.updatePermission(1, 2, Access.READ));
    22232223        assertEquals(1, dbDispatcher.updatePermission(1, 4, Access.WRITE));
     2224        assertEquals(1, dbDispatcher.updatePermission(1, 2, null));
    22242225    }
    22252226
    … …  
    23072308
    23082309    }
     2310   
     2311    @Test
     2312    public void testCanDo(){
     2313        System.out.println("test canDo");
     2314       
     2315        mockeryDao.checking(new Expectations() {            {
     2316                /////
     2317                oneOf(annotationDao).getOwner(1);
     2318                will(returnValue(1));
     2319                oneOf(principalDao).getTypeOfPrincipalAccount(1);
     2320                will(returnValue("developer"));
     2321            }
     2322        });
     2323        assertTrue(dbDispatcher.canDo(Access.ALL, 1, 1, Resource.ANNOTATION));
     2324       
     2325        mockeryDao.checking(new Expectations() {            {
     2326                /////
     2327                oneOf(annotationDao).getOwner(2);
     2328                will(returnValue(2));
     2329                oneOf(principalDao).getTypeOfPrincipalAccount(2);
     2330                will(returnValue("developer"));
     2331               
     2332                oneOf(annotationDao).getAccess(2, 1);
     2333                will(returnValue(Access.READ));
     2334                oneOf(annotationDao).getPublicAttribute(2);
     2335                will(returnValue(Access.READ));
     2336            }
     2337        });
     2338        assertFalse(dbDispatcher.canDo(Access.WRITE, 1, 2, Resource.ANNOTATION));
     2339       
     2340        mockeryDao.checking(new Expectations() {            {
     2341                /////
     2342                oneOf(annotationDao).getOwner(3);
     2343                will(returnValue(3));
     2344                oneOf(principalDao).getTypeOfPrincipalAccount(1);
     2345                will(returnValue("developer"));
     2346               
     2347                oneOf(annotationDao).getAccess(3, 1);
     2348                will(returnValue(Access.READ));
     2349                oneOf(annotationDao).getPublicAttribute(3);
     2350                will(returnValue(Access.ALL));
     2351            }
     2352        });
     2353        assertTrue(dbDispatcher.canDo(Access.WRITE, 1, 3, Resource.ANNOTATION));
     2354       
     2355        mockeryDao.checking(new Expectations() {            {
     2356                /////
     2357                oneOf(annotationDao).getOwner(4);
     2358                will(returnValue(3));
     2359                oneOf(principalDao).getTypeOfPrincipalAccount(11);
     2360                will(returnValue("user"));
     2361               
     2362                oneOf(annotationDao).getAccess(4, 11);
     2363                will(returnValue(Access.NONE));
     2364                oneOf(annotationDao).getPublicAttribute(4);
     2365                will(returnValue(Access.NONE));
     2366            }
     2367        });
     2368        assertFalse(dbDispatcher.canDo(Access.READ, 11, 4, Resource.ANNOTATION));
     2369    }
    23092370}

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

    r5836 r5838  
    202202        System.out.println("test getAnnotationWithoutTargetsAndPermissions");
    203203        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    204         final Annotation result = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(1);
     204        final Annotation result = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissionList(1);
    205205
    206206        assertEquals("Sagrada Famiglia", result.getHeadline());
    … …  
    210210        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", result.getHref());
    211211        assertEquals(DatatypeFactory.newInstance().newXMLGregorianCalendar("2013-08-12T09:25:00.383000Z"), result.getLastModified());
     212        assertEquals(Access.WRITE, result.getPermissions().getPublic());
    212213    }
    213214
    … …  
    245246
    246247        // checking
    247         Annotation addedAnnotation = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(5);
     248        Annotation addedAnnotation = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissionList(5);
    248249        assertEquals(addedAnnotation.getHref(), "/api/annotations/"+addedAnnotation.getId());
    249250        assertFalse(null == addedAnnotation.getLastModified());
    … …  
    251252        assertEquals(annotationToAdd.getBody().getTextBody().getBody(), addedAnnotation.getBody().getTextBody().getBody());
    252253        assertEquals(annotationToAdd.getHeadline(), addedAnnotation.getHeadline());
     254        assertEquals(annotationToAdd.getPermissions().getPublic(), addedAnnotation.getPermissions().getPublic());
    253255        System.out.println("creation time " + addedAnnotation.getLastModified());
    254256    }
    … …  
    306308        assertEquals("read", result.get(1).get(3));
    307309        assertEquals("read", result.get(2).get(11));
    308 
     310       
     311        List<Map<Number, String>> result2 = jdbcAnnotationDao.getPermissions(4);
     312        assertEquals(4, result2.size());       
     313        assertEquals("all", result2.get(0).get(1));
     314        assertEquals("write", result2.get(1).get(2));
     315        assertEquals("none", result2.get(2).get(3));
     316        assertEquals("none", result2.get(3).get(11));
    309317    }
    310318
    311319    // getAnnotationIDsForPermission(Number principalID, Access access)
    312320    @Test
    313     public void testAnnotationIDsForPermission() {
    314         System.out.println("test getAnnotationIDsForPermission");
     321    public void testAnnotationIDsForPermissionAtLeast() {
     322        System.out.println("test getAnnotationIDsForPermissionAtLeast");
    315323        List<Number> result = jdbcAnnotationDao.getAnnotationIDsPermissionAtLeast(1, Access.READ);
    316324        assertEquals(3, result.size());
    … …  
    319327        assertEquals(4, result.get(2));
    320328
    321         List<Number> resultTwo = jdbcAnnotationDao.getAnnotationIDsPermissionAtLeast(1, Access.WRITE);
    322         assertEquals(1, resultTwo.size());
    323         assertEquals(4, resultTwo.get(0));
    324 
    325         List<Number> resultThree = jdbcAnnotationDao.getAnnotationIDsPermissionAtLeast(1, Access.NONE);
    326         assertEquals(0, resultThree.size());
    327 
     329        List<Number> resultWrite = jdbcAnnotationDao.getAnnotationIDsPermissionAtLeast(1, Access.WRITE);
     330        assertEquals(1, resultWrite.size());
     331        assertEquals(4, resultWrite.get(0));
     332       
     333        List<Number> resultAll = jdbcAnnotationDao.getAnnotationIDsPermissionAtLeast(1, Access.ALL);
     334        assertEquals(1, resultAll.size());
     335        assertEquals(4, resultAll.get(0));
     336
     337        List<Number> resultNone= jdbcAnnotationDao.getAnnotationIDsPermissionAtLeast(1, Access.NONE);
     338        assertEquals(0, resultNone.size());
     339       
     340        List<Number> resultNone1 = jdbcAnnotationDao.getAnnotationIDsPermissionAtLeast(3, Access.NONE);
     341        assertEquals(1, resultNone1.size());
     342        assertEquals(4, resultWrite.get(0));
    328343    }
    329344
    330345    // getAnnotationIDsForPublicAccess
    331346    @Test
    332     public void testAnnotationIDsForPublicAccess() {
     347    public void testAnnotationIDsForPublicAtLeast() {
    333348        System.out.println("test getAnnotationIDsForPublicAccess");
    334349        List<Number> result = jdbcAnnotationDao.getAnnotationIDsPublicAtLeast(Access.READ);
    335         assertEquals(2, result.size());
     350        assertEquals(3, result.size());
    336351        assertTrue(result.contains(1));
    337352        assertTrue(result.contains(2));
    338 
     353        assertTrue(result.contains(3));
     354       
    339355        List<Number> resultTwo = jdbcAnnotationDao.getAnnotationIDsPublicAtLeast(Access.WRITE);
    340         assertEquals(1, resultTwo.size());
    341         assertEquals(1, resultTwo.get(0));
    342 
    343 
    344         List<Number> resultThree = jdbcAnnotationDao.getAnnotationIDsPublicAtLeast(Access.NONE);
    345         assertEquals(2, resultThree.size());
     356        assertEquals(2, resultTwo.size());
     357        assertTrue(result.contains(1));
     358        assertTrue(resultTwo.contains(3));
     359       
     360        List<Number> resultThree = jdbcAnnotationDao.getAnnotationIDsPublicAtLeast(Access.ALL);
     361        assertEquals(1, resultThree.size());
    346362        assertTrue(resultThree.contains(3));
    347         assertTrue(resultThree.contains(4));
     363
     364        List<Number> resultNone = jdbcAnnotationDao.getAnnotationIDsPublicAtLeast(Access.NONE);
     365        assertEquals(1, resultNone.size());
     366        assertTrue(resultNone.contains(4));
    348367
    349368    }
    … …  
    354373        assertEquals(Access.WRITE, jdbcAnnotationDao.getPublicAttribute(1));
    355374        assertEquals(Access.READ, jdbcAnnotationDao.getPublicAttribute(2));
    356         assertEquals(Access.NONE, jdbcAnnotationDao.getPublicAttribute(3));
     375        assertEquals(Access.ALL, jdbcAnnotationDao.getPublicAttribute(3));
     376        assertEquals(Access.NONE, jdbcAnnotationDao.getPublicAttribute(4));
    357377    }
    358378
    … …  
    363383        assertEquals(Access.WRITE, jdbcAnnotationDao.getAccess(2, 3));
    364384        assertEquals(Access.NONE, jdbcAnnotationDao.getAccess(3, 3));
     385        assertEquals(Access.NONE, jdbcAnnotationDao.getAccess(2, 2)); // implicit none, no row in the table
     386    }
     387   
     388    @Test
     389    public void testHasExplicitAccess() {
     390        System.out.println("test getAccess");
     391        assertTrue(jdbcAnnotationDao.hasExplicitAccess(1, 3));
     392        assertFalse(jdbcAnnotationDao.hasExplicitAccess(2, 2)); // implicit none, no row in the table
    365393    }
    366394
    … …  
    422450        int result = jdbcAnnotationDao.updateAnnotationBody(1, "some html 1 updated", "text/plain", false);
    423451        assertEquals(1, result);
    424         Annotation check = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(1);
     452        Annotation check = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissionList(1);
    425453        assertEquals("some html 1 updated", check.getBody().getTextBody().getBody());
    426454        assertEquals("text/plain", check.getBody().getTextBody().getMimeType());
    … …  
    429457        int result2 = jdbcAnnotationDao.updateAnnotationBody(1, testXml, "application/xml", true);
    430458        assertEquals(1, result2);
    431         Annotation check2 = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(1);
     459        Annotation check2 = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissionList(1);
    432460        assertEquals("xhtml:span", check2.getBody().getXmlBody().getAny().getNodeName());
    433461        assertTrue(check2.getBody().getXmlBody().getAny().hasAttribute("style"));
    … …  
    441469        int result = jdbcAnnotationDao.updateAnnotationHeadline(1, "new Header");
    442470        assertEquals(1, result);
    443         Annotation check = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(1);
     471        Annotation check = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissionList(1);
    444472        assertEquals("new Header", check.getHeadline());
    445473    }
    … …  
    509537        annotation.getBody().getTextBody().setBody("updated some html 1");
    510538        annotation.getBody().getTextBody().setMimeType("text/plain");
     539        annotation.getPermissions().setPublic(Access.ALL);
    511540
    512541       
    … …  
    514543        assertEquals(1, result);
    515544        System.out.println(" annotation updated");
    516         Annotation check = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(1);
     545        Annotation check = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissionList(1);
    517546        assertEquals("updated some html 1", check.getBody().getTextBody().getBody());
    518547        assertEquals("text/plain", check.getBody().getTextBody().getMimeType());
    … …  
    520549        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", check.getHref());
    521550        assertEquals("00000000-0000-0000-0000-000000000021", check.getId());
     551        assertEquals(Access.ALL, check.getPermissions().getPublic());
    522552    }
    523553   

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

    r5774 r5838  
    205205        assertEquals("text/plain", entityA.getBody().getTextBody().getMimeType());
    206206        assertEquals("Annotation to add to test DAO", entityA.getHeadline());
    207         assertEquals(0, entityA.getPermissions().getPermission().size());
     207        assertEquals(1, entityA.getPermissions().getPermission().size());
     208        assertEquals(Access.ALL, entityA.getPermissions().getPermission().get(0).getLevel());
     209        assertEquals(_relativePath + "/principals/00000000-0000-0000-0000-000000000111", entityA.getPermissions().getPermission().get(0).getPrincipalHref());
    208210        assertEquals(Access.WRITE, entityA.getPermissions().getPublic());
    209211        assertEquals(_relativePath + "/principals/00000000-0000-0000-0000-000000000113", entityA.getOwnerHref());

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/resources/test-data/InsertTestData.sql

    r5393 r5838  
    2525INSERT INTO access(access_mode) VALUES ('read');
    2626INSERT INTO access(access_mode) VALUES ('none');
     27INSERT INTO access(access_mode) VALUES ('all');
    2728
    2829INSERT INTO principal (principal_name, external_id, remote_id, e_mail, account) VALUES ('Twan', '00000000-0000-0000-0000-000000000111', 'twagoo@mpi.nl', 'Twan.Goosen@mpi.nl', 'developer'); --1
    … …  
    4647INSERT INTO annotation (owner_id, headline,body_text, body_mimetype, external_id, last_modified, is_xml, public_) VALUES (1, 'Sagrada Famiglia','<html><body>some html 1</body></html>', 'text/html' , '00000000-0000-0000-0000-000000000021', '2013-08-12 09:25:00.383', false, 'write'); --1
    4748INSERT INTO annotation (owner_id, headline,body_text, body_mimetype, external_id, last_modified, is_xml, public_) VALUES (2, 'Gaudi','<html><body>some html 2</body></html>', 'text/html' , '00000000-0000-0000-0000-000000000022', '2013-08-12 10:30:00.383', false, 'read'); --2
    48 INSERT INTO annotation (owner_id, headline,body_text, body_mimetype, external_id, last_modified, is_xml) VALUES (3, 'Art Nuveau','some plain text', 'text/plain' , '00000000-0000-0000-0000-000000000023', '2013-08-12 11:30:00.383', false); --3
     49INSERT INTO annotation (owner_id, headline,body_text, body_mimetype, external_id, last_modified, is_xml, public_) VALUES (3, 'Art Nuveau','some plain text', 'text/plain' , '00000000-0000-0000-0000-000000000023', '2013-08-12 11:30:00.383', false, 'all'); --3
    4950INSERT INTO annotation (owner_id, headline,body_text, body_mimetype, external_id, is_xml) VALUES (3, 'Annotation to delete','<html><body>some html 4</body></html>', 'text/html' , '00000000-0000-0000-0000-000000000024',false); --4
    5051
    … …  
    119120
    120121INSERT INTO annotations_principals_accesses (annotation_id, principal_id, access_) VALUES (4, 2, 'write');
    121 INSERT INTO annotations_principals_accesses (annotation_id, principal_id, access_) VALUES (4, 1, 'write');
     122INSERT INTO annotations_principals_accesses (annotation_id, principal_id, access_) VALUES (4, 1, 'all');
     123INSERT INTO annotations_principals_accesses (annotation_id, principal_id, access_) VALUES (4, 3, 'none');
     124INSERT INTO annotations_principals_accesses (annotation_id, principal_id, access_) VALUES (4, 11, 'none');
    122125-- checking integrity control:
    123126-- INSERT INTO annotations_principals_accesses (annotation_id, principal_id, access_) VALUES (5, 5, 'read');
Note: See TracChangeset for help on using the changeset viewer.