testdb4ostorage.java

lucene2.2.0版本

        try {

            storage.updateEntry(null);
            fail("entry is null");
        } catch (StorageException e) {
            //
        }

        try {

            storage.updateEntry(exEntry);
            fail("entry id is null");
        } catch (StorageException e) {
            //
        }
        exEntry.setId("someID");
        try {

            storage.updateEntry(exEntry);
            fail("feed id is null");
        } catch (StorageException e) {
            //
        }
        
        
        
        ServerBaseEntry e = createServerBaseEntry();
        ServerBaseEntry e1 = createServerBaseEntry();
        try {
            storage.updateEntry(e);
            fail("entry does not exist");
        } catch (StorageException ex) {
            ex.printStackTrace();
        }
        storage.storeEntry(e);

        storage = this.controller.getStorage();

        storage.storeEntry(e1);
        ServerBaseEntry e2 = createServerBaseEntry();
        e2.setId(e.getId());
        e2.setTitle(new PlainTextConstruct("new"));
        e2.setUpdated(DateTime.now());
        storage.updateEntry(e2);
        ObjectContainer container = getContainer();
        Query query = container.query();
        query.constrain(BaseEntry.class);
        query.descend("id").constrain(e.getId());
        ObjectSet resultSet = query.execute();
        assertEquals(1, resultSet.size());
        BaseEntry result = (BaseEntry) resultSet.next();
        assertEquals("new", result.getTitle().getPlainText());
        assertEquals("2", result.getVersionId());

        ServerBaseFeed bFeed = new ServerBaseFeed();
        bFeed.setItemsPerPage(25);
        bFeed.setId(FEEDID);
        bFeed.setStartIndex(1);
        bFeed.setServiceType(SERVICENAME);
        storage = this.controller.getStorage();
        BaseFeed<BaseFeed, BaseEntry> feed = storage.getFeed(bFeed);

        assertEquals(2, feed.getEntries().size());
        assertEquals(e.getId(), feed.getEntries().get(0).getId());
        assertEquals(feed.getUpdated(), feed.getEntries().get(0).getUpdated());

        storage = this.controller.getStorage();
        storage.storeEntry(e);

        e2.setVersion(5);
        try {
            storage.updateEntry(e2);
            fail("version does not match");
        } catch (Exception ex) {
            // TODO: handle exception
        }

        // ############ test concurrency
        Object monitor = new Object();
        AtomicBoolean reached = new AtomicBoolean(false);

        MultiThreadEntryStub concuEntry = new MultiThreadEntryStub();
        concuEntry.setId(System.currentTimeMillis() + "");
        ProvidedServiceConfig conf = new ProvidedServiceConfig();
        conf.setName(SERVICENAME);
        concuEntry.setServiceConfig(conf);
        concuEntry.setUpdated(DateTime.now());
        concuEntry.setFeedId(FEEDID);

        storage = this.controller.getStorage();

        storage.storeEntry(concuEntry);
        storage.close();
        concuEntry.acceptGetEntryVisitor(getMonitorVisitor(monitor, reached));

        Thread t1 = getUpdThread(controller, concuEntry, false);

        Thread t2 = getUpdThread(controller, concuEntry, true);
        t1.start();
        /*
         * Wait active -- not nice but works fine here wait until thread parked
         */

        while (true) {
            synchronized (monitor) {
                if (reached.get())
                    break;
                monitor.wait(10);
            }
        }
        t2.start();
        t2.join(800);
        /*
         * Wait active -- not nice but works fine here wake up the waiting
         * thread
         */
        while (true) {
            synchronized (monitor) {
                if (!reached.get())
                    break;
                monitor.notifyAll();
            }
        }
        t1.join(300);
        if (fail)
            fail("thread failed -- see stacktrace");
        container.close();
    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.getFeed(ServerBaseFeed)'
     */
    public void testGetFeed() throws StorageException {
        storeServerBaseFeed();
        Storage storage = this.controller.getStorage();
        ServerBaseFeed feed = new ServerBaseFeed();
        feed.setItemsPerPage(25);
        feed.setStartIndex(1);
        feed.setServiceType(SERVICENAME);
        try{
        storage.getFeed(feed);
        fail("feedid is null");
        }catch (StorageException e) {
            // 
        }
        
        feed.setId(FEEDID);
        BaseFeed result = storage.getFeed(feed);
        assertNotNull(result);
        assertEquals(0, result.getEntries().size());
        List<String> idlist = new ArrayList<String>(30);
        ServerBaseEntry e1 = null;
        for (int i = 0; i < 30; i++) {
            e1 = createServerBaseEntry();
            storage.storeEntry(e1);
            idlist.add(0, e1.getId());
        }
        String firstId = e1.getId();

        storage = this.controller.getStorage();
        result = storage.getFeed(feed);
        assertNotNull(result);
        assertEquals(25, result.getEntries().size());
        for (int i = 0; i < 25; i++) {
            assertEquals(idlist.get(i),
                    ((BaseEntry) result.getEntries().get(i)).getId());
        }

        storage = this.controller.getStorage();
        feed.setItemsPerPage(5);
        result = storage.getFeed(feed);
        assertNotNull(result);
        assertEquals(5, result.getEntries().size());
        for (int i = 0; i < 5; i++) {
            assertEquals(idlist.get(i),
                    ((BaseEntry) result.getEntries().get(i)).getId());
        }

        storage = this.controller.getStorage();
        feed.setItemsPerPage(1);
        feed.setStartIndex(1);
        result = storage.getFeed(feed);
        assertNotNull(result);
        assertEquals(1, result.getEntries().size());

        assertEquals(idlist.get(0), ((BaseEntry) result.getEntries().get(0))
                .getId());

        storage = this.controller.getStorage();
        feed.setItemsPerPage(50);
        feed.setStartIndex(28);
        result = storage.getFeed(feed);
        assertNotNull(result);
        assertEquals(3, result.getEntries().size());

        assertEquals(idlist.get(27), ((BaseEntry) result.getEntries().get(0))
                .getId());
        assertEquals(idlist.get(28), ((BaseEntry) result.getEntries().get(1))
                .getId());
        assertEquals(idlist.get(29), ((BaseEntry) result.getEntries().get(2))
                .getId());

        storage = this.controller.getStorage();
        feed.setItemsPerPage(50);
        feed.setStartIndex(30);
        result = storage.getFeed(feed);
        assertNotNull(result);
        assertEquals(1, result.getEntries().size());

        assertEquals(idlist.get(29), ((BaseEntry) result.getEntries().get(0))
                .getId());

        // assertNotSame(firstId,((BaseEntry)result.getEntries().get(0)).getId());
    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.getEntry(ServerBaseEntry)'
     */
    public void testGetEntry() throws StorageException {
        storeServerBaseFeed();
        Storage storage = this.controller.getStorage();
        ServerBaseEntry exEntry = createServerBaseEntry();
        exEntry.setId(null);
        try{
        storage.getEntry(exEntry);
        fail("id is null");
        }catch (StorageException e) {

        }
        ServerBaseEntry e = createServerBaseEntry();
        storage.storeEntry(e);
        ServerBaseEntry e1 = createServerBaseEntry();
        storage.storeEntry(e1);
        
        storage = this.controller.getStorage();
        BaseEntry result = storage.getEntry(e);
        assertNotNull(result);
        assertEquals(e.getId(), result.getId());
        try {
            e1.setId("hello");
            result = storage.getEntry(e1);
            fail("no such entry");
        } catch (StorageException ex) {
            ex.printStackTrace();
        }

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.storeAccount(GDataAccount)'
     */
    public void testStoreAccount() throws StorageException {
        GDataAccount account = new GDataAccount();
        account.setName("simon");
        account.setPassword("somepass");
        Storage storage = this.controller.getStorage();
        storage.storeAccount(account);
        ObjectContainer container = getContainer();
        Query q = container.query();
        q.constrain(GDataAccount.class);
        q.descend("name").constrain(account.getName());
        ObjectSet set = q.execute();
        assertEquals(1, set.size());
        assertEquals(account.getPassword(), ((GDataAccount) set.next())
                .getPassword());
        try {
            storage.storeAccount(account);
            fail("Account already stored");
        } catch (Exception e) {

        }
        container.close();
    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.updateAccount(GDataAccount)'
     */
    public void testUpdateAccount() throws StorageException {
        GDataAccount account = new GDataAccount();
        account.setName("simon");
        account.setPassword("somepass");

        Storage storage = this.controller.getStorage();
        try {
            storage.updateAccount(account);
            fail("Account does not exist");
        } catch (Exception e) {
            //
        }
        try {
            storage.updateAccount(null);
            fail("Account is null");
        } catch (Exception e) {
            //
        }
        storage.storeAccount(account);
        ObjectContainer container = getContainer();
        Query q = container.query();
        q.constrain(GDataAccount.class);
        q.descend("name").constrain(account.getName());
        ObjectSet set = q.execute();
        assertEquals(1, set.size());
        assertEquals(account.getPassword(), ((GDataAccount) set.next())
                .getPassword());
        account = new GDataAccount();
        account.setName("simon");
        account.setPassword("newPass");
        storage.updateAccount(account);
        container.close();
        container = getContainer();
        q = container.query();
        q.constrain(GDataAccount.class);
        q.descend("name").constrain(account.getName());
        set = q.execute();
        assertEquals(1, set.size());
        assertEquals(account.getPassword(), ((GDataAccount) set.next())
                .getPassword());
        container.close();
    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.deleteAccount(String)'
     */
    public void testDeleteAccount() throws StorageException {
        GDataAccount account = new GDataAccount();
        account.setName("simon");
        account.setPassword("somepass");
        Storage storage = this.controller.getStorage();
        storage.storeAccount(account);
        ObjectContainer container = getContainer();
        Query q = container.query();
        q.constrain(GDataAccount.class);
        q.descend("name").constrain(account.getName());
        ObjectSet set = q.execute();
        assertEquals(1, set.size());

        storage.deleteAccount(account.getName());
        container.close();
        container = getContainer();
        q = container.query();
        q.constrain(GDataAccount.class);