weblogmanagertest.java

这个weblogging 设计得比较精巧

        assertEquals("THIS FAILS RANDOMLY, TRY AGAIN", entry1.getPubTime(),updateTime);
    }

    /** Count weblog entries in a weblogEntry map */
    private int countEntries( Map entryMap ) 
    {
        int count = 0;
        Iterator days = entryMap.values().iterator();
        while (days.hasNext())
        {
            List dayEntries = (List) days.next();
            Iterator entries = dayEntries.iterator();
            while (entries.hasNext())
            {
                entries.next();
                count++;
            }
        }
        return count;
    }
          
    public void testIsWeblogCategoryInUse() throws Exception
    {
        WeblogManager wmgr = getRoller().getWeblogManager();
        UserManager umgr = getRoller().getUserManager();
                    
        getRoller().begin(UserData.SYSTEM_USER);
        
        WebsiteData website = umgr.retrieveWebsite(mWebsite.getId());
        WeblogEntryData entry = (WeblogEntryData)mEntriesCreated.get(2);
        WeblogCategoryData rootCat = wmgr.getRootWeblogCategory(website);
        
        WeblogCategoryData usedCat = 
            wmgr.retrieveWeblogCategory(entry.getCategory().getId()); 
                         
        WeblogCategoryData unusedCat = wmgr.createWeblogCategory(
            website, rootCat, "testy", "tasty", "testy.gif");
        unusedCat.save();
            
        getRoller().commit();
        
        getRoller().begin(UserData.SYSTEM_USER);
        usedCat = wmgr.retrieveWeblogCategory(usedCat.getId());
        assertTrue(usedCat.isInUse());
        
        unusedCat = wmgr.retrieveWeblogCategory(unusedCat.getId());
        assertFalse(unusedCat.isInUse());       
        getRoller().commit();
    }

    public void testStoreComment() throws Exception
    {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogManager wmgr = getRoller().getWeblogManager();
        
        // Get entry to which comment will be added
        WeblogEntryData entry1 = (WeblogEntryData)mEntriesCreated.get(1);
        
        // Ensure that entry is a persistent instance
        entry1 = getRoller().getWeblogManager().retrieveWeblogEntry(
            entry1.getId());
        
        CommentData comment = new CommentData(
            null, 
            entry1, 
            "TestCommentUser", 
            "[e-mail]", 
            "", 
            "This is a test", 
            new Timestamp(new Date().getTime()), 
            Boolean.FALSE,   // spam
            Boolean.FALSE);  // notify
            
        comment.save();
        getRoller().commit();
        
        List comments = wmgr.getComments(entry1.getId());
        assertTrue(comments.size() > mCommentCount);
        
        getRoller().begin(UserData.SYSTEM_USER);
        wmgr.removeComment(comment.getId());
        getRoller().commit();
    }   
    
    public void testMoveCategoryContents() throws RollerException
    {
        WeblogManager wmgr = getRoller().getWeblogManager();
        
        WeblogCategoryData c1 = wmgr.retrieveWeblogCategory(c1_id);       
        //WeblogCategoryData c2 = wmgr.retrieveWeblogCategory(c2_id);       
        //WeblogCategoryData c3 = wmgr.retrieveWeblogCategory(c3_id);       
        WeblogCategoryData dest = wmgr.retrieveWeblogCategory(dest_id);              
        
        getRoller().begin(UserData.SYSTEM_USER);
               
        // verify number of entries in each category
        dest = wmgr.retrieveWeblogCategory(dest.getId());
        c1 = wmgr.retrieveWeblogCategory(c1.getId());
        assertEquals(0, dest.retrieveWeblogEntries(true).size());
        assertEquals(0, dest.retrieveWeblogEntries(false).size());
        assertEquals(1, c1.retrieveWeblogEntries(false).size());
        assertEquals(3, c1.retrieveWeblogEntries(true).size());
        
        // move contents of source category c1 to destination catetory dest
        c1.moveContents(dest);
        
        getRoller().commit(); 
        
        getRoller().begin(UserData.SYSTEM_USER);
        
        // after move, verify number of entries in each category
        dest = wmgr.retrieveWeblogCategory(dest.getId());
        c1 = wmgr.retrieveWeblogCategory(c1.getId());
        assertEquals(3, dest.retrieveWeblogEntries(true).size());
        assertEquals(3, dest.retrieveWeblogEntries(false).size());        
        assertEquals(0, c1.retrieveWeblogEntries(true).size());
        assertEquals(0, c1.retrieveWeblogEntries(false).size());
        
        getRoller().commit();      
    }
    
    public void testMoveCategoryProtection() throws RollerException
    {
        boolean safe = false;
        try 
        {
            getRoller().begin(UserData.SYSTEM_USER);
            WeblogManager wmgr = getRoller().getWeblogManager();        
                   
            // Move category into one of it's children
            WeblogCategoryData c1 = wmgr.retrieveWeblogCategory(c1_id);       
            WeblogCategoryData c3 = wmgr.retrieveWeblogCategory(c3_id);       
            wmgr.moveWeblogCategoryContents(c1.getId(), c3.getId());
            c3.save();
            c1.save();
            getRoller().commit(); 
        }
        catch (RollerException e)
        {
            safe = true;
        }
        assertTrue(safe);
    }
    
    public void testMoveCategory() throws RollerException
    {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogManager wmgr = getRoller().getWeblogManager();
        
        WeblogCategoryData c1 = wmgr.retrieveWeblogCategory(c1_id);       
        WeblogCategoryData c2 = wmgr.retrieveWeblogCategory(c2_id);       
        WeblogCategoryData c3 = wmgr.retrieveWeblogCategory(c3_id);       
        WeblogCategoryData dest = wmgr.retrieveWeblogCategory(dest_id);              
               
        // verify number of entries in each category
        dest = wmgr.retrieveWeblogCategory(dest.getId());
        c1 = wmgr.retrieveWeblogCategory(c1.getId());
        assertEquals(0, dest.retrieveWeblogEntries(true).size());
        assertEquals(0, dest.retrieveWeblogEntries(false).size());
        assertEquals(1, c1.retrieveWeblogEntries(false).size());
        assertEquals(3, c1.retrieveWeblogEntries(true).size());
        
        // move contents of source category c1 to destination catetory dest
        c1.setParent(dest);
        c1.save();
        
        getRoller().commit(); 
        
        getRoller().begin(UserData.SYSTEM_USER);
        
        // after move, verify number of entries in each category
        dest = wmgr.retrieveWeblogCategory(dest.getId());
        c1 = wmgr.retrieveWeblogCategory(c1_id);       
        c2 = wmgr.retrieveWeblogCategory(c2_id);       
        c3 = wmgr.retrieveWeblogCategory(c3_id);
               
        assertEquals(3, dest.retrieveWeblogEntries(true).size());
        assertEquals(0, dest.retrieveWeblogEntries(false).size());
                
        assertEquals(dest, c1.getParent());
        assertEquals(c1,   c2.getParent());
        assertEquals(c2,   c3.getParent());

        assertEquals(1, c1.retrieveWeblogEntries(false).size());
        assertEquals(1, c2.retrieveWeblogEntries(false).size());
        assertEquals(1, c3.retrieveWeblogEntries(false).size()); 
        
        List entries = c1.retrieveWeblogEntries(true);
        assertEquals(3, entries.size());
        
        getRoller().commit();      
    }
    
    public void testNextPrevPost() throws RollerException
    {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogManager wmgr = getRoller().getWeblogManager();
        
        // category: root
        WeblogEntryData entry0 = (WeblogEntryData)mEntriesCreated.get(0);
        WeblogEntryData entry1 = (WeblogEntryData)mEntriesCreated.get(1);
        WeblogEntryData entry2 = (WeblogEntryData)mEntriesCreated.get(2);
        WeblogEntryData entry3 = (WeblogEntryData)mEntriesCreated.get(3);
        WeblogEntryData entry4 = (WeblogEntryData)mEntriesCreated.get(4);
        WeblogEntryData entry5 = (WeblogEntryData)mEntriesCreated.get(5);
        WeblogEntryData entry6 = (WeblogEntryData)mEntriesCreated.get(6);
        WeblogEntryData entry7 = (WeblogEntryData)mEntriesCreated.get(7);
        
        // next and prev only get published entries
        
        // entry0 is the first published entry
        assertEquals(null, wmgr.getPreviousEntry(entry0, null));
        
        // next published entry is entry2
        assertEquals(entry1, wmgr.getNextEntry(entry0, null));
        
        // prev to entry2 is entry 0
        assertEquals(entry0, wmgr.getPreviousEntry(entry2, null));
        
        // constrain prev/next by category
        
        WeblogCategoryData cat = (WeblogCategoryData)mCategoriesCreated.get(1);
        
        assertEquals(null, wmgr.getPreviousEntry(entry5, "/root-cat1/root-cat1-cat0"));
        assertEquals(entry7, wmgr.getNextEntry(entry5, "/root-cat1/root-cat1-cat0"));
        assertEquals(entry5, wmgr.getPreviousEntry(entry7, "/root-cat1/root-cat1-cat0"));
        
        getRoller().rollback();
    }
    
    public void testGetComments() throws RollerException
    {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogEntryData entry0 = (WeblogEntryData)mEntriesCreated.get(0);
        WeblogManager wmgr = getRoller().getWeblogManager();
        assertEquals(mCommentCount, wmgr.getComments(entry0.getId()).size());
        getRoller().commit();
    }
    
    public void testQueryWeblogEntries() throws RollerException
    {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogManager wmgr = getRoller().getWeblogManager();
        UserManager umgr = getRoller().getUserManager();
        
        WebsiteData website = (WebsiteData)mWebsites.get(0);
        website = umgr.retrieveWebsite(website.getId());

        // PUBLISHISHED ONLY
        List publishedEntries = wmgr.getWeblogEntries(
                        website,                 // userName
                        null,                    // startDate
                        new Date(),              // endDate
                        null,                    // catName
                        WeblogManager.PUB_ONLY,  // status
                        null);                   // maxEntries
        assertEquals(mExpectedPublishedEntryCount, publishedEntries.size());
                    
        // DRAFT ONLY
        List draftEntries = wmgr.getWeblogEntries(
                        website,                 // userName
                        null,                    // startDate
                        new Date(),              // endDate
                        null,                    // catName
                        WeblogManager.DRAFT_ONLY,  // status
                        null);                   // maxEntries
        assertEquals(mExpectedEntryCount-mExpectedPublishedEntryCount, draftEntries.size());
                          
        // PUBLISHED and DRAFT
        List allEntries = wmgr.getWeblogEntries(
                        website,                 // userName
                        null,                    // startDate
                        new Date(),              // endDate
                        null,                    // catName
                        WeblogManager.ALL,       // status
                        null);                   // maxEntries
        assertEquals(mExpectedEntryCount, allEntries.size());

        // no status specified      
        List allEntries2 = wmgr.getWeblogEntries(
                        website,                 // userName
                        null,                    // startDate
                        new Date(),              // endDate
                        null,                    // catName
                        null,                    // status
                        null);                   // maxEntries
        assertEquals(mExpectedEntryCount, allEntries2.size());
                                            
        getRoller().commit();
    }
    
    public void testGetRecentComments() throws Exception
    {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogManager wmgr = getRoller().getWeblogManager();
        UserManager umgr = getRoller().getUserManager();
        
        WebsiteData website = (WebsiteData)mWebsites.get(0);
        website = umgr.retrieveWebsite(website.getId());
        List comments = wmgr.getRecentComments(website, 2);
        assertTrue(comments.size() > 1);
        // Comment 0 should be named 'name1' and Comment 1 'name0'
        /*
        System.out.println(((CommentData)comments.get(0)).getName());
        System.out.println(((CommentData)comments.get(1)).getName());
        */
        assertTrue("name1".compareTo("name0") >0);
        assertTrue(
            ((CommentData)comments.get(0)).getName().compareTo(
                ((CommentData)comments.get(1)).getName()) > 0);
       /*
        System.out.println(((CommentData)comments.get(0)).getPostTime());
        System.out.println(((CommentData)comments.get(1)).getPostTime());
        */
        assertTrue(
               ((CommentData)comments.get(0)).getPostTime().compareTo(
                   ((CommentData)comments.get(1)).getPostTime()) > 0);
    }
    
    public void testGetLastPublishTime() throws Exception
    {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogManager wmgr = getRoller().getWeblogManager();
        WebsiteData website = (WebsiteData)mWebsites.get(0);
        
        Date lastPub = wmgr.getWeblogLastPublishTime(
                           website.getUser().getUserName());
        //System.out.println(lastPub);
        assertTrue(lastPub.compareTo(new Date()) <= 0);
    }
    
    public void testEntryAttributes() throws Exception {
        getRoller().begin(UserData.SYSTEM_USER);
        WeblogManager wmgr = getRoller().getWeblogManager();
        WebsiteData website = (WebsiteData)mWebsites.get(0); 
        
        WeblogCategoryData cat = wmgr.getRootWeblogCategory(website);       

        WeblogEntryData entry = new WeblogEntryData(
                null, cat, website, "title2", null, "text2", "attributetest", 
                new Timestamp(0), new Timestamp(0), Boolean.FALSE);
        entry.save();
        assertNotNull(entry.getId());
                
        entry.putEntryAttribute("testname", "testvalue");
        entry.putEntryAttribute("testname2", "testvalue2");
        entry.save();
        
        getRoller().commit();
       
        WeblogEntryData fetchedEntry = wmgr.retrieveWeblogEntry(entry.getId());
        assertNotNull(fetchedEntry.getEntryAttributes());
        assertEquals(2, fetchedEntry.getEntryAttributes().size());
        
        assertEquals(fetchedEntry.findEntryAttribute("testname"), "testvalue");
        assertEquals(fetchedEntry.findEntryAttribute("testname2"), "testvalue2");
    }


    public void testPermissions() throws Exception
    {
        getRoller().begin(UserData.ANONYMOUS_USER);
        
        // evil testuser
        UserData testuser = getRoller().getUserManager().getUser("testuser");       
        assertNotNull(testuser);
        
        // gets hold of testuser0's entry
        WebsiteData website0 = getRoller().getUserManager().getWebsite("testuser0");
        assertNotNull(website0);
        List entries = getRoller().getWeblogManager().getWeblogEntries(
                website0,
                null,       // start
                new Date(), // end
                null,       // cat
                WeblogManager.ALL,
                new Integer(1));
        WeblogEntryData entry = (WeblogEntryData)entries.get(0);
        assertNotNull(entry);
        
        // and tries to save it
        getRoller().setUser(testuser);
        boolean denied = false; 
        try 
        {
            entry.save();
        }
        catch (RollerPermissionsException e)
        {
            // permission denied!
            denied = true;
        }       
        assertTrue(denied);
        getRoller().rollback();
    }
}