Changeset 4506


Ignore:
Timestamp:
02/13/14 10:50:48 (10 years ago)
Author:
olhsha
Message:

NotebookDao? Unit test is finished. Passes.

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

Legend:

Unmodified
Added
Removed

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

    r4495 r4506  
    256256            annotationInfo.setRef(externalIDtoURI(rs.getString(external_id)));
    257257            annotationInfo.setHeadline(rs.getString(headline));
    258             annotationInfo.setLastModified(timeStampToXMLGregorianCalendar(rs));
     258            annotationInfo.setLastModified(timeStampToXMLGregorianCalendar(rs.getString(last_modified)));
    259259            return annotationInfo;
    260260        }
    … …  
    327327            annotation.setTargets(null);
    328328            annotation.setURI(externalIDtoURI(rs.getString(external_id)));
    329             annotation.setLastModified(timeStampToXMLGregorianCalendar(rs));
     329            annotation.setLastModified(timeStampToXMLGregorianCalendar(rs.getString(last_modified)));
    330330            return annotation;
    331331        }

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

    r4495 r4506  
    6565        sql.append(owner_id).append(" FROM ").append(notebookTableName).append(" WHERE ").
    6666                append(notebook_id).append(" = ?");
    67         List<Number> result = getSimpleJdbcTemplate().query(sql.toString(), principalIDRowMapper, notebookID);
     67        List<Number> result = getSimpleJdbcTemplate().query(sql.toString(), ownerIDRowMapper, notebookID);
    6868        if (result.isEmpty()) {
    6969            return null;
    … …  
    9191        StringBuilder sql = new StringBuilder("SELECT ");
    9292        sql.append(notebook_id).append(" FROM ").append(notebookPermissionsTableName).append(" WHERE ").
    93                 append(principal_id).append(" = :principalID AND ").append(permission).append(" = :accessMode");
     93                append(principal_id).append(" = :principalID AND ").append(this.permission).append(" = :accessMode");
    9494        return getSimpleJdbcTemplate().query(sql.toString(), internalIDRowMapper, params);
    9595    }
    … …  
    175175            Notebook notebook = new Notebook();
    176176            notebook.setTitle(rs.getString(title));
    177             GregorianCalendar calendar = new GregorianCalendar();
    178             calendar.setTime(rs.getTimestamp(last_modified));
    179             try {
    180                 XMLGregorianCalendar gregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar);
    181                 notebook.setLastModified(gregorianCalendar);
    182             } catch (DatatypeConfigurationException exception) {
    183                 throw new SQLException(exception);
    184             }
     177            notebook.setLastModified(timeStampToXMLGregorianCalendar(rs.getString(last_modified)));
    185178            notebook.setURI(externalIDtoURI(rs.getString(external_id)));
    186179            return notebook;
    … …  
    321314        StringBuilder sql = new StringBuilder("UPDATE ");
    322315        sql.append(notebookPermissionsTableName).append(" SET ").
    323                 append(notebook_id).append("= :notebookID, ").
    324                 append(principal_id).append("= :principalID").
    325                 append(this.permission).append("= :permission").
    326                 append(" WHERE ").append(notebook_id).append("= :notebookID");
     316                append(this.permission).append("= :permission ").
     317                append(" WHERE ").append(notebook_id).append("= :notebookID AND ").
     318                append(principal_id).append("= :principalID");
    327319        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
    328320        if (affectedRows <= 0) {
    … …  
    390382        StringBuilder sql = new StringBuilder("INSERT INTO ");
    391383        sql.append(notebooksAnnotationsTableName).append("(").append(notebook_id).append(",").append(annotation_id);
    392         sql.append(",").append(" ) VALUES (:notebookID, :annotationID)");
     384        sql.append(" ) VALUES (:notebookID, :annotationID)");
    393385        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
    394386        return (affectedRows > 0);

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

    r4495 r4506  
    8686    final static protected String targetStar = targetTableName + ".*";
    8787    final static protected String principalStar = principalTableName + ".*";
    88    
    8988    ////////////////////////////////
    90    
    91    
    9289    ///////////////////////////////////////////////////
    9390    protected String internalIdName = null;
    … …  
    168165        @Override
    169166        public XMLGregorianCalendar mapRow(ResultSet rs, int rowNumber) throws SQLException {
    170             return timeStampToXMLGregorianCalendar(rs);
     167            return timeStampToXMLGregorianCalendar(rs.getString(last_modified));
    171168        }
    172169    };
    … …  
    216213        }
    217214    };
    218    
    219215    protected final RowMapper<Number> ownerIDRowMapper = new RowMapper<Number>() {
    220216        @Override
    … …  
    223219        }
    224220    };
    225    
    226 
    227221
    228222    @Override
    … …  
    266260
    267261    /////////////////////////
    268     protected XMLGregorianCalendar timeStampToXMLGregorianCalendar(ResultSet rs) {
     262    protected XMLGregorianCalendar timeStampToXMLGregorianCalendar(String ts) {
     263        String tsAdjusted = ts.replace(' ', 'T') + "Z";
    269264        try {
    270             String ts = rs.getString(last_modified).replace(' ', 'T') + "Z";
    271             try {
    272                 return DatatypeFactory.newInstance().newXMLGregorianCalendar(ts);
    273             } catch (DatatypeConfigurationException dtce) {
    274                 _logger.error(" ", dtce);
    275                 return null;
    276             }
    277         } catch (SQLException sqle) {
    278             _logger.error(" ", sqle);
    279             return null;
    280         }
     265            return DatatypeFactory.newInstance().newXMLGregorianCalendar(tsAdjusted);
     266        } catch (DatatypeConfigurationException dtce) {
     267            _logger.error(" ", dtce);
     268            return null;
     269        }
     270
    281271    }
    282272}

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

    r4281 r4506  
    7171        @Override
    7272        public Target mapRow(ResultSet rs, int rowNumber) throws SQLException {
    73             XMLGregorianCalendar xmlDate = timeStampToXMLGregorianCalendar(rs);
     73            XMLGregorianCalendar xmlDate = timeStampToXMLGregorianCalendar(rs.getString(last_modified));
    7474            Target result =
    7575                    constructTarget(rs.getString(external_id), rs.getString(link_uri), rs.getString(version), xmlDate, rs.getString(fragment_descriptor));

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

    r4461 r4506  
    1818package eu.dasish.annotation.backend.dao.impl;
    1919
     20import eu.dasish.annotation.schema.Notebook;
     21import eu.dasish.annotation.schema.NotebookInfo;
     22import eu.dasish.annotation.schema.Permission;
     23import java.util.ArrayList;
     24import java.util.List;
     25import javax.xml.datatype.DatatypeConfigurationException;
     26import javax.xml.datatype.DatatypeFactory;
    2027import org.junit.Test;
     28import static org.junit.Assert.*;
     29import org.junit.Ignore;
    2130import org.junit.runner.RunWith;
    2231import org.springframework.beans.factory.annotation.Autowired;
    … …  
    2635/**
    2736 *
    28  * @author Peter Withers <peter.withers@mpi.nl>
     37 * @author olhsha
    2938 */
    30 // TODO: Move integrating methods from JdbcNotebookDao to DaoDispatcher, and move corresponding tests to DaoDistatcherTest.class, 
    31 //remove from here all the  mockery and retest.
    3239@RunWith(SpringJUnit4ClassRunner.class)
    33 @ContextConfiguration({"/spring-test-config/dataSource.xml","/spring-config/notebookDao.xml"})
    34 public class JdbcNotebookDaoTest extends JdbcResourceDaoTest{
     40@ContextConfiguration({"/spring-test-config/dataSource.xml", "/spring-config/notebookDao.xml"})
     41public class JdbcNotebookDaoTest extends JdbcResourceDaoTest {
    3542
    3643    @Autowired
    3744    JdbcNotebookDao jdbcNotebookDao;
    38    
    39     @Test
    40     public void Dummy() {
    41     }
    42    
    43     /**
    44      * Test of stringURItoExternalID method
    45      * public String stringURItoExternalID(String uri);
    46      */
    47 //    @Test
    48 //    @Ignore
    49 //    public void testStringURItoExternalID() {
    50 //        System.out.println("test stringURItoExternalID");
    51 //        jdbcNotebookDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_notebooks);
    52 //        String randomUUID = UUID.randomUUID().toString();
    53 //        String uri = TestBackendConstants._TEST_SERVLET_URI_notebooks + randomUUID;
    54 //        String externalID = jdbcNotebookDao.stringURItoExternalID(uri);
    55 //        assertEquals(randomUUID, externalID);
    56 //    }
    57 //   
    58 //    /**
    59 //     * Test of externalIDtoURI method
    60 //     * public String externalIDtoURI(String externalID);
    61 //     */
    62 //    @Test
    63 //    @Ignore
    64 //    public void testExternalIDtoURI() {
    65 //        System.out.println("test stringURItoExternalID");
    66 //        jdbcNotebookDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_notebooks);
    67 //        String randomUUID = UUID.randomUUID().toString();
    68 //        String uri = TestBackendConstants._TEST_SERVLET_URI_notebooks+randomUUID;
    69 //        String uriResult = jdbcNotebookDao.externalIDtoURI(randomUUID);
    70 //        assertEquals(uri, uriResult);
    71 //    }
    72 //   
    73 //    /**
    74 //     * Test of getNotebookInfos method, of class JdbcNotebookDao.
    75 //     */
    76 //    @Test
    77 //    @Ignore
    78 //    public void testGetNotebookInfos() {
    79 //        final List<NotebookInfo> notebookInfoList = jdbcNotebookDao.getNotebookInfos(UUID.fromString(TestBackendConstants._TEST_UID_2_));
    80 //        assertEquals(2, notebookInfoList.size());
    81 //        assertEquals("a notebook", notebookInfoList.get(0).getTitle());
    82 //    }
    83 //
    84 //    /**
    85 //     * Test of getUsersNotebooks method, of class JdbcNotebookDao.
    86 //     */
    87 //    @Test
    88 //    @Ignore
    89 //    public void testGetUsersNotebooks() {
    90 //        int year = Calendar.getInstance().get(Calendar.YEAR);
    91 //        int month = Calendar.getInstance().get(Calendar.MONTH);
    92 //        int day = Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
    93 //       
    94 //        ReTargetREF testRef = new ReTargetREF();
    95 //        testRef.setRef(TestBackendConstants._TEST_SERVLET_URI_notebooks+TestBackendConstants._TEST_AID_1_);
    96 //        final List<ReTargetREF> testResult = Arrays.asList(new ReTargetREF[] {testRef});
    97 //       
    98 //        mockery.checking(new Expectations() {
    99 //            {
    100 //                exactly(2).of(annotationDao).getAnnotationREFs(Arrays.asList(new Number[] {1}));// exactly 2 notebooks (their id-s 1 and 2) contain the annotation 1
    101 //                will(returnValue(testResult));
    102 //                // necessary to set annotations reference lists in the notebook
    103 //            }
    104 //        });
    105 //       
    106 //        jdbcNotebookDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_notebooks);
    107 //        final List<Notebook> notebooks = jdbcNotebookDao.getUsersNotebooks(UUID.fromString(TestBackendConstants._TEST_UID_2_));
    108 //
    109 //
    110 //        assertEquals(2, notebooks.size());
    111 //        assertEquals("a notebook", notebooks.get(0).getTitle());
    112 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks+TestBackendConstants._TEST_NOTEBOOK_1_EXT_ID, notebooks.get(0).getURI());
    113 //        assertNotNull(notebooks.get(0).getTimeStamp());
    114 //        assertEquals(year, notebooks.get(0).getTimeStamp().getYear());
    115 //        assertEquals(month + 1, notebooks.get(0).getTimeStamp().getMonth());
    116 //        assertEquals(day, notebooks.get(0).getTimeStamp().getDay());
    117 //       
    118 //       
    119 //        mockery.checking(new Expectations() {
    120 //            {
    121 //                oneOf(annotationDao).getAnnotationREFs(new ArrayList<Number>());
    122 //                will(returnValue(new ArrayList<ReTargetREF>()));
    123 //            }
    124 //        });
    125 //       
    126 //        final List<Notebook> notebooksEmpty = jdbcNotebookDao.getUsersNotebooks(UUID.fromString(TestBackendConstants._TEST_UID_1_));
    127 //        assertEquals(0, notebooksEmpty.size());
    128 //    }
    129 //
    130 //    /**
    131 //     * Test of addNotebook method, of class JdbcNotebookDao.
    132 //     */
    133 //    @Test   
    134 //    @Ignore
    135 //    public void testAddNotebook() throws URISyntaxException {
    136 //        final UUID addedNotebookId = jdbcNotebookDao.addNotebook(UUID.fromString(TestBackendConstants._TEST_UID_2_), "a title");
    137 //        assertEquals(36, addedNotebookId.toString().length());
    138 //    }
    139 //
    140 //    /**
    141 //     * Test of deleteNotebook method, of class JdbcNotebookDao.
    142 //     */
    143 //    @Test   
    144 //    @Ignore
    145 //    public void testDeleteNotebook() {
    146 //        System.out.println("deleteNotebook");
    147 //        UUID notebookId = UUID.fromString(TestBackendConstants._TEST_NOTEBOOK_2_EXT_ID);
    148 //        int result = jdbcNotebookDao.deleteNotebook(notebookId);
    149 //        assertEquals(1, result);
    150 //    }
    151 //   
    152 //      /**
    153 //     * Test of getAnnotationIDs method, of class JdbcAnnotationDao.
    154 //     * List<Number> getAnnotationIDs(Number notebookID)
    155 //     */
    156 //    @Test   
    157 //    @Ignore
    158 //    public void testGetAnnotationIDs() {
    159 //        System.out.println("getAnnotationIDs");
    160 //       
    161 //        // test one, 2-element notebook
    162 //        final List<Number> annotationIDs = jdbcNotebookDao.getAnnotationIDs(3);
    163 //        assertEquals(2, annotationIDs.size());
    164 //        assertEquals(2, annotationIDs.get(0).intValue());
    165 //        assertEquals(3, annotationIDs.get(1).intValue());
    166 //       
    167 //        // test two, 1-element notebook
    168 //        final List<Number> annotationIDsTwo = jdbcNotebookDao.getAnnotationIDs(4);
    169 //        assertEquals(1, annotationIDsTwo.size());
    170 //        assertEquals(4, annotationIDsTwo.get(0).intValue());
    171 //       
    172 //        // test three, empty notebook
    173 //        final List<Number> annotationIDsThree = jdbcNotebookDao.getAnnotationIDs(6);
    174 //        assertEquals(0, annotationIDsThree.size());
    175 //       
    176 //        // test four, null-notebook
    177 //        final List<Number> annotationIDsFour = jdbcNotebookDao.getAnnotationIDs(null);
    178 //        assertEquals(0, annotationIDsFour.size());
    179 //       
    180 //       
    181 //    }
    182 //   
    183 //   
    184 //   
    185 //    /**
    186 //     * Test of getAnnotationREFsOfNotebook method, of class JdbcAnnotationDao.
    187 //     * List<ReTargetREF> getAnnotationREFsOfNotebook(Number notebookID)
    188 //     */
    189 //    @Test
    190 //    @Ignore   
    191 //    public void testGetAnnotationREFsOfNotebook() {
    192 //        System.out.println("getAnnotationREFsOfNotebook");
    193 //       
    194 //        jdbcNotebookDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_notebooks);
    195 //        annotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
    196 //        // test One         
    197 //        setMockeryNotebookOne();
    198 //        List<ReTargetREF> testList = jdbcNotebookDao.getAnnotationREFsOfNotebook(3);
    199 //        assertEquals(2, testList.size());       
    200 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000021", testList.get(0).getRef());
    201 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000022", testList.get(1).getRef());
    202 //       
    203 //        // test Two
    204 //        setMockeryNotebookTwo();
    205 //        List<ReTargetREF> testListTwo = jdbcNotebookDao.getAnnotationREFsOfNotebook(4);
    206 //        assertEquals(1, testListTwo.size());       
    207 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000023", testListTwo.get(0).getRef());
    208 //       
    209 //        // test Three  "empty"
    210 //        setMockeryNotebookThreeEmpty();         
    211 //        List<ReTargetREF> testListThree = jdbcNotebookDao.getAnnotationREFsOfNotebook(6);
    212 //        assertEquals(0, testListThree.size());
    213 //       
    214 //        // test Five Null-notebook
    215 //        setMockeryNotebookNonExisting();
    216 //        List<ReTargetREF> testListFive = jdbcNotebookDao.getAnnotationREFsOfNotebook(null);
    217 //        assertEquals(0, testListFive.size());
    218 //    }
    219 //
    220 //    /**
    221 //     * Test of getAnnotations method, of class JdbcNotebookDao.
    222 //     * Annotations getAnnotations(Number notebookID)
    223 //     */
    224 //    @Test   
    225 //    @Ignore
    226 //    public void testGetAnnotations() {
    227 //        System.out.println("getAnnotations");
    228 //       
    229 //        jdbcNotebookDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_notebooks);
    230 //       
    231 //         // test One
    232 //        setMockeryNotebookOne();
    233 //        AnnotationList annotations = jdbcNotebookDao.getAnnotations(3);
    234 //        assertEquals(2, annotations.getAnnotation().size());       
    235 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000021", annotations.getAnnotation().get(0).getRef());
    236 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000022", annotations.getAnnotation().get(1).getRef());
    237 //       
    238 //        // test Two
    239 //        setMockeryNotebookTwo();
    240 //        AnnotationList annotationsTwo = jdbcNotebookDao.getAnnotations(4);
    241 //        assertEquals(1, annotationsTwo.getAnnotation().size());       
    242 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000023", annotationsTwo.getAnnotation().get(0).getRef());
    243 //       
    244 //        // test Three  "empty" list of annotations
    245 //        // according to dasish.xsd if an Annotation is created then its list of annotations must contain at least one element!
    246 //        // therefore: no annotations in the notebook ==> Annotations-pbject must be null :(
    247 //        setMockeryNotebookThreeEmpty();
    248 //        AnnotationList annotationsThree = jdbcNotebookDao.getAnnotations(6);
    249 //        assertEquals(null, annotationsThree);
    250 //       
    251 //       
    252 //        // test Five Null-notebook
    253 //        setMockeryNotebookNonExisting();
    254 //        AnnotationList annotationsFive = jdbcNotebookDao.getAnnotations(null);
    255 //        assertEquals(null, annotationsFive);
    256 //    }
    257 //   
    258 //    /** Test of getNotebookInfo method, of class JdbcNotebookDao.
    259 //     *
    260 //     */
    261 //    @Test     
    262 //    @Ignore
    263 //    public void testGetNotebookInfo() {
    264 //        System.out.println("test getNotebookInfo");
    265 //       
    266 //        jdbcNotebookDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_notebooks);
    267 //       
    268 //         // test One       
    269 //        NotebookInfo info = jdbcNotebookDao.getNotebookInfo(3);
    270 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks+"/"+TestBackendConstants._TEST_NOTEBOOK_3_EXT, info.getRef());
    271 //        assertEquals(TestBackendConstants._TEST_NOTEBOOK_3_TITLE, info.getTitle());
    272 //       
    273 //               
    274 //        // test Three Null-notebook
    275 //       NotebookInfo infoThree = jdbcNotebookDao.getNotebookInfo(null);
    276 //       assertEquals(null, infoThree);
    277 //    }
    278 //   
    279 //    /** Test of getNotebookID method, of class JdbcNotebookDao.
    280 //     *
    281 //     */
    282 //    @Test
    283 //    @Ignore   
    284 //    public void testGetNotebookID() {
    285 //        System.out.println("test getNotebookID");
    286 //       
    287 //         // test One       
    288 //        Number resultOne= jdbcNotebookDao.getInternalID(UUID.fromString(TestBackendConstants._TEST_NOTEBOOK_3_EXT));
    289 //        assertEquals(3, resultOne.intValue());
    290 //       
    291 //     
    292 //        // test Three Null-notebook
    293 //       Number resultThree= jdbcNotebookDao.getInternalID(null);
    294 //       assertEquals(null, resultThree);
    295 //    }
    296 //   
    297 //   
    298 //    @Test   
    299 //    @Ignore
    300 //    public void testGetAnnotationExternalIDs() {
    301 //        System.out.println("test getExternalAnnotationIds");
    302 //       
    303 //         // test One
    304 //        mockery.checking(new Expectations() {
    305 //            {
    306 //              oneOf(annotationDao).getExternalID(2);
    307 //              will(returnValue(UUID.fromString("00000000-0000-0000-0000-000000000021")));
    308 //             
    309 //              oneOf(annotationDao).getExternalID(3);
    310 //              will(returnValue(UUID.fromString("00000000-0000-0000-0000-000000000022")));
    311 //            }
    312 //        });
    313 //       
    314 //        List<UUID> resultOne= jdbcNotebookDao.getAnnotationExternalIDs(UUID.fromString(TestBackendConstants._TEST_NOTEBOOK_3_EXT));
    315 //        assertEquals("00000000-0000-0000-0000-000000000021", resultOne.get(0).toString());
    316 //        assertEquals("00000000-0000-0000-0000-000000000022", resultOne.get(1).toString());
    317 //       
    318 //       
    319 //     
    320 //        // test Two, non-existing notebook
    321 //        List<UUID> resultThree= jdbcNotebookDao.getAnnotationExternalIDs(null);
    322 //        assertEquals(0, resultThree.size());
    323 //       
    324 //    }
    325 //   
    326 //   
    327 //    ////////////////////////////////////////////////////////////////////
    328 //    //////// Setting Mockeries /////////////////////////////////////////
    329 //    ///////////////////////////////////////////////////////////////////
    330 //   
    331 //    private void setMockeryNotebookOne(){       
    332 //        ReTargetREF testRefOne = new ReTargetREF();
    333 //        testRefOne.setRef(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000021");
    334 //        ReTargetREF testRefTwo = new ReTargetREF();
    335 //        testRefTwo.setRef(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000022");
    336 //        final List<ReTargetREF> testResult = Arrays.asList(new ReTargetREF[] {testRefOne, testRefTwo});
    337 //       
    338 //        mockery.checking(new Expectations() {
    339 //            {
    340 //              oneOf(annotationDao).getAnnotationREFs(Arrays.asList(new Number[] {2, 3}));
    341 //              will(returnValue(testResult));
    342 //            }
    343 //        });   
    344 //    }
    345 //
    346 //     private void setMockeryNotebookTwo(){
    347 //        ReTargetREF testRef = new ReTargetREF();
    348 //        testRef.setRef(String.valueOf(TestBackendConstants._TEST_SERVLET_URI_annotations+"00000000-0000-0000-0000-000000000023"));
    349 //        final List<ReTargetREF> testResultTwo = Arrays.asList(new ReTargetREF[] {testRef});
    350 //       
    351 //        mockery.checking(new Expectations() {
    352 //            {
    353 //              oneOf(annotationDao).getAnnotationREFs(Arrays.asList(new Number[] {4}));
    354 //              will(returnValue(testResultTwo));
    355 //            }
    356 //        });
    357 //     }   
    358 //     
    359 //     private void setMockeryNotebookThreeEmpty(){
    360 //         mockery.checking(new Expectations() {
    361 //            {
    362 //              oneOf(annotationDao).getAnnotationREFs(new ArrayList<Number>());
    363 //              will(returnValue(new ArrayList<ReTargetREF>()));
    364 //            }
    365 //        });       
    366 //     }
    367 //     
    368 //     private void setMockeryNotebookNonExisting() {         
    369 //         mockery.checking(new Expectations() {
    370 //            {
    371 //              oneOf(annotationDao).getAnnotationREFs(null);
    372 //              will(returnValue(null));
    373 //            }
    374 //        });
    375 //     }
    376 //       
    377      
     45
     46    /**
     47     * Test of getOwner method, of class JdbcNotebookDao.
     48     */
     49    @Test
     50    public void testGetOwner() {
     51        System.out.println("test getOwner");
     52        assertEquals(3, jdbcNotebookDao.getOwner(4));
     53    }
     54
     55    /**
     56     * Test of getNotebookIDs method, of class JdbcNotebookDao.
     57     */
     58    @Test
     59    public void testGetNotebookIDs() {
     60        System.out.println("test getNotebookIDs for a principal with Permission");
     61        List<Number> expResult = new ArrayList<Number>();
     62        expResult.add(1);
     63        expResult.add(4);
     64        List<Number> result = jdbcNotebookDao.getNotebookIDs(2, Permission.WRITER);
     65        assertEquals(expResult, result);
     66    }
     67
     68    /**
     69     * Test of getNotebookIDsOwnedBy method, of class JdbcNotebookDao.
     70     */
     71    @Test
     72    public void testGetNotebookIDsOwnedBy() {
     73        System.out.println("test getNotebookIDsOwnedBy");
     74        List<Number> expResult = new ArrayList<Number>();
     75        expResult.add(3);
     76        expResult.add(4);
     77        List<Number> result = jdbcNotebookDao.getNotebookIDsOwnedBy(3);
     78        assertEquals(expResult, result);
     79    }
     80
     81    /**
     82     * Test of getPrincipalIDsWithPermission method, of class JdbcNotebookDao.
     83     */
     84    @Test
     85    public void testGetPrincipalIDsWithPermission() {
     86        System.out.println("gtest getPrincipalIDsWithPermission");
     87        List<Number> expResult = new ArrayList<Number>();
     88        expResult.add(2);
     89        expResult.add(4);
     90        List result = jdbcNotebookDao.getPrincipalIDsWithPermission(1, Permission.WRITER);
     91        assertEquals(expResult, result);
     92    }
     93
     94    /**
     95     * Test of getNotebookInfoWithoutOwner method, of class JdbcNotebookDao.
     96     */
     97    @Test
     98    public void testGetNotebookInfoWithoutOwner() {
     99        System.out.println("test getNotebookInfoWithoutOwner");
     100        NotebookInfo result = jdbcNotebookDao.getNotebookInfoWithoutOwner(1);
     101        assertEquals("00000000-0000-0000-0000-000000000011", result.getRef());
     102        assertEquals("Notebook 1", result.getTitle());
     103        assertEquals(null, result.getOwnerRef());
     104    }
     105
     106    /**
     107     * Test of getNotebookWithoutAnnotationsAndPermissionsAndOwner method, of
     108     * class JdbcNotebookDao.
     109     */
     110    @Test
     111    public void testGetNotebookWithoutAnnotationsAndPermissionsAndOwner() {
     112        System.out.println("test getNotebookWithoutAnnotationsAndPermissionsAndOwner");
     113        Notebook result = jdbcNotebookDao.getNotebookWithoutAnnotationsAndPermissionsAndOwner(1);
     114        assertEquals("00000000-0000-0000-0000-000000000011", result.getURI());
     115        assertEquals("Notebook 1", result.getTitle());
     116        assertEquals("2013-08-12T09:25:00.383000Z", result.getLastModified().toString());
     117    }
     118
     119    /**
     120     * Test of getAnnotations method, of class JdbcNotebookDao.
     121     */
     122    @Test
     123    public void testGetAnnotations() {
     124        System.out.println("test getAnnotations");
     125        List<Number> expResult = new ArrayList<Number>();
     126        expResult.add(1);
     127        expResult.add(2);
     128        List<Number> result = jdbcNotebookDao.getAnnotations(1);
     129        assertEquals(expResult, result);
     130    }
     131
     132    /**
     133     * Test of updateNotebookMetadata method, of class JdbcNotebookDao.
     134     */
     135    @Test
     136    public void testUpdateNotebookMetadata() {
     137        System.out.println("test updateNotebookMetadata");
     138        boolean result = jdbcNotebookDao.updateNotebookMetadata(1, "Gaudi and his work", 3);
     139        assertEquals(true, result);
     140        assertEquals("Gaudi and his work", jdbcNotebookDao.getNotebookWithoutAnnotationsAndPermissionsAndOwner(1).getTitle());
     141        assertEquals(3, jdbcNotebookDao.getOwner(1));
     142    }
     143
     144    /**
     145     * Test of setOwner method, of class JdbcNotebookDao.
     146     */
     147    @Test
     148    public void testSetOwner() {
     149        System.out.println("test setOwner");
     150        boolean result = jdbcNotebookDao.setOwner(1, 2);
     151        assertTrue(result);
     152        assertEquals(2, jdbcNotebookDao.getOwner(2));
     153    }
     154
     155    /**
     156     * Test of updateUserPermissionForNotebook method, of class JdbcNotebookDao.
     157     */
     158    @Test
     159    public void testUpdateUserPermissionForNotebook() {
     160        System.out.println("test updateUserPermissionForNotebook");
     161        boolean result = jdbcNotebookDao.updateUserPermissionForNotebook(1, 2, Permission.READER);
     162        assertTrue(result);
     163        assertTrue(jdbcNotebookDao.getPrincipalIDsWithPermission(1, Permission.READER).contains(2));
     164
     165        // in the next test the update should fail
     166        //assertFalse(jdbcNotebookDao.updateUserPermissionForNotebook(1, 2, Permission.OWNER));
     167        //SQL throws an error, which is good
     168    }
     169
     170    /**
     171     * Test of createNotebookWithoutPermissionsAndAnnotations method, of class
     172     * JdbcNotebookDao.
     173     */
     174    @Test
     175    public void testCreateNotebookWithoutPermissionsAndAnnotations() throws DatatypeConfigurationException {
     176        System.out.println("test createNotebookWithoutPermissionsAndAnnotations");
     177        Notebook notebook = new Notebook();
     178        notebook.setTitle("New test notebook");
     179        notebook.setLastModified(DatatypeFactory.newInstance().newXMLGregorianCalendar("2014-02-12T09:25:00.383000Z"));
     180        Number result = jdbcNotebookDao.createNotebookWithoutPermissionsAndAnnotations(notebook, 3);
     181        assertEquals(5, result);
     182        assertEquals(3, jdbcNotebookDao.getOwner(result));
     183        assertNotNull(jdbcNotebookDao.getExternalID(result));
     184        assertEquals("New test notebook", jdbcNotebookDao.getNotebookWithoutAnnotationsAndPermissionsAndOwner(result).getTitle());
     185    }
     186
     187    /**
     188     * Test of addAnnotationToNotebook method, of class JdbcNotebookDao.
     189     */
     190    @Test
     191    public void testAddAnnotationToNotebook() {
     192        System.out.println("test addAnnotationToNotebook");
     193        boolean result = jdbcNotebookDao.addAnnotationToNotebook(2, 4);
     194        assertTrue(result);
     195        assertTrue(jdbcNotebookDao.getAnnotations(2).contains(4));
     196    }
     197
     198    /**
     199     * Test of addPermissionToNotebook method, of class JdbcNotebookDao.
     200     */
     201    @Test
     202    public void testAddPermissionToNotebook() {
     203        System.out.println("test addPermissionToNotebook");
     204        boolean result = jdbcNotebookDao.addPermissionToNotebook(2, 4, Permission.WRITER);
     205        assertTrue(result);
     206        assertTrue(jdbcNotebookDao.getPrincipalIDsWithPermission(2, Permission.WRITER).contains(4));
     207    }
     208
     209    /**
     210     * Test of deleteAnnotationFromNotebook method, of class JdbcNotebookDao.
     211     */
     212    @Test
     213    public void testDeleteAnnotationFromNotebook() {
     214        System.out.println("test deleteAnnotationFromNotebook");
     215        boolean result = jdbcNotebookDao.deleteAnnotationFromNotebook(1, 2);
     216        assertTrue(result);
     217        assertFalse(jdbcNotebookDao.getAnnotations(1).contains(2));
     218    }
     219
     220    /**
     221     * Test of deleteNotebookPrincipalPermission method, of class
     222     * JdbcNotebookDao.
     223     */
     224    @Test
     225    public void testDeleteNotebookPrincipalPermission() {
     226        System.out.println("deleteNotebookPrincipalPermission");
     227        boolean result = jdbcNotebookDao.deleteNotebookPrincipalPermission(1, 2);
     228        assertTrue(result);
     229        assertFalse(jdbcNotebookDao.getPrincipalIDsWithPermission(1, Permission.READER).contains(2));
     230        assertFalse(jdbcNotebookDao.getPrincipalIDsWithPermission(1, Permission.WRITER).contains(2));
     231    }
     232
     233    /**
     234     * Test of deleteAllAnnotationsFromNotebook method, of class
     235     * JdbcNotebookDao.
     236     */
     237    @Test
     238    public void testDeleteAllAnnotationsFromNotebook() {
     239        System.out.println("test deleteAllAnnotationsFromNotebook");
     240        boolean result = jdbcNotebookDao.deleteAllAnnotationsFromNotebook(1);
     241        assertTrue(result);
     242        assertTrue(jdbcNotebookDao.getAnnotations(1).isEmpty());
     243    }
     244
     245    /**
     246     * Test of deleteAllPermissionsForNotebook method, of class JdbcNotebookDao.
     247     */
     248    @Test
     249    public void testDeleteAllPermissionsForNotebook() {
     250        System.out.println("test deleteAllPermissionsForNotebook");
     251        boolean result = jdbcNotebookDao.deleteAllPermissionsForNotebook(1);
     252        assertTrue(result);
     253        assertTrue(jdbcNotebookDao.getPrincipalIDsWithPermission(1, Permission.READER).isEmpty());
     254        assertTrue(jdbcNotebookDao.getPrincipalIDsWithPermission(1, Permission.WRITER).isEmpty());
     255    }
     256
     257    /**
     258     * Test of deleteNotebook method, of class JdbcNotebookDao.
     259     */
     260    @Test
     261    public void testDeleteNotebook() {
     262        System.out.println("test deleteNotebook");
     263        boolean result = jdbcNotebookDao.deleteNotebook(3);
     264        assertTrue(result);
     265        assertNull(jdbcNotebookDao.getExternalID(3));
     266    }
    378267}

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

    r4461 r4506  
    1818package eu.dasish.annotation.backend.dao.impl;
    1919
    20 import eu.dasish.annotation.backend.TestBackendConstants;
    2120import java.io.File;
    2221import java.io.FileNotFoundException;
    … …  
    2423import java.net.URL;
    2524import java.util.Scanner;
    26 import java.util.UUID;
    2725import org.junit.After;
    2826import org.junit.Before;
    … …  
    3129import org.springframework.dao.DataAccessException;
    3230import org.springframework.jdbc.core.JdbcTemplate;
    33 import static org.junit.Assert.*;
    34 import org.junit.Ignore;
    3531import org.junit.runner.RunWith;
    3632import org.springframework.test.context.ContextConfiguration;

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

    r4465 r4506  
    3333
    3434
    35 INSERT INTO notebook (title, owner_id, external_id) VALUES ('Notebook 3', 1, '00000000-0000-0000-0000-000000000011'); -- 1
    36 INSERT INTO notebook (title, owner_id, external_id) VALUES ('Notebook 4', 2, '00000000-0000-0000-0000-000000000012'); --2
    37 INSERT INTO notebook (title, owner_id, external_id) VALUES ('Notebook 5', 3, '00000000-0000-0000-0000-000000000013'); --3
    38 INSERT INTO notebook (title, owner_id, external_id) VALUES ('Notebook 6', 3, '00000000-0000-0000-0000-000000000014'); --4
     35INSERT INTO notebook (title, owner_id, external_id, last_modified) VALUES ('Notebook 1', 1, '00000000-0000-0000-0000-000000000011', '2013-08-12 09:25:00.383'); -- 1
     36INSERT INTO notebook (title, owner_id, external_id) VALUES ('Notebook 2', 2, '00000000-0000-0000-0000-000000000012'); --2
     37INSERT INTO notebook (title, owner_id, external_id) VALUES ('Notebook 3', 3, '00000000-0000-0000-0000-000000000013'); --3
     38INSERT INTO notebook (title, owner_id, external_id) VALUES ('Notebook 4', 3, '00000000-0000-0000-0000-000000000014'); --4
    3939
    4040INSERT INTO annotation (owner_id, headline,body_text, body_mimetype, external_id, last_modified, is_xml) 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); --1
    … …  
    117117-- checking integrity control:
    118118-- INSERT INTO annotations_principals_permissions (annotation_id, principal_id, permission_) VALUES (5, 5, 'reader');
     119
     120INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (1, 2, 'writer');
     121INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (1, 3, 'reader');
     122INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (1, 4, 'writer');
     123INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (1, 5, 'reader');
     124
     125
     126INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (2, 1, 'reader');
     127INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (2, 3, 'writer');
     128
     129INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (4, 2, 'writer');
     130INSERT INTO notebooks_principals_permissions (notebook_id, principal_id, permission_) VALUES (4, 1, 'writer');
     131
Note: See TracChangeset for help on using the changeset viewer.