import unittest
import Blogger

class testBlogger(unittest.TestCase):
    """
    A test class for the Blogger module.
    """
    def __init__(self, test):
        unittest.TestCase.__init__(self, test)
        self.assertTrue = self.assert_
    
    def setUp(self):
        """
        set up data used in the tests.
        setUp is called before each test function execution.
        """
        #blog_params = Blogger.BlogParams
        #self.blogger = Blogger.Blogger(blog_params)
        self.blogger = Blogger.get_blog()
       
    def tearDown(self):
        """
        tear down any data used in tests
        tearDown is called after each test function execution.
        """
        pass
        
    def testGetFeedTitle(self):
        title = "fitnessetesting"
        self.assertEqual(self.blogger.get_title(), title)

    def testGetFeedPostingURL(self):
        posting_url = "http://www.blogger.com/atom/9276918"
        self.assertEqual(self.blogger.get_feed_posting_url(), posting_url)

    def testGetFeedPostingHost(self):
        posting_host = "www.blogger.com"
        self.assertEqual(self.blogger.get_feed_posting_host(), posting_host)
        
    def testPostNewEntry(self):
        init_num_entries = self.blogger.get_num_entries()
        title = "testPostNewEntry"
        content = "testPostNewEntry"
        self.assertTrue(self.blogger.post_new_entry(title, content))
        
        self.assertEqual(self.blogger.get_num_entries(), init_num_entries+1)
        # Entries are ordered most-recent first
        # Newest entry should be first
        self.assertEqual(title, self.blogger.get_nth_entry_title(1))

    def testPostSingleEntry(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)
        
        title = "testPostOneEntry"
        content ="testPostOneEntry"
        self.assertTrue(self.blogger.post_new_entry(title, content))
        self.assertEqual(self.blogger.get_num_entries(), 1)
        self.assertEqual(title, self.blogger.get_nth_entry_title(1))
        self.assertEqual(content, self.blogger.get_nth_entry_content_strip_html(1))

    def testPostTwoEntries(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)
        
        title1 = "testPostTwoEntries #1"
        content1 ="testPostTwoEntries #1"
        self.assertTrue(self.blogger.post_new_entry(title1, content1))
        self.assertEqual(self.blogger.get_num_entries(), 1)

        title2 = "testPostTwoEntries #2"
        content2 = "testPostTwoEntries #2"
        self.assertTrue(self.blogger.post_new_entry(title2, content2))
        self.assertEqual(self.blogger.get_num_entries(), 2)

        # Entries are ordered most-recent first
        # Entry #2 should be first, Entry #1 should be second
        self.assertEqual(title2, self.blogger.get_nth_entry_title(1))
        self.assertEqual(content2, self.blogger.get_nth_entry_content_strip_html(1))

        self.assertEqual(title1, self.blogger.get_nth_entry_title(2))
        self.assertEqual(content1, self.blogger.get_nth_entry_content_strip_html(2))

    def testDeleteSingleEntry(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)

        title = "testDeleteSingleEntry"
        content = "testDeleteSingleEntry"
        self.assertTrue(self.blogger.post_new_entry(title, content))

        self.assertTrue(self.blogger.delete_nth_entry(1))
        self.assertEqual(self.blogger.get_num_entries(), 0)

    def testDeleteFirstOfTwoEntries(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)

        title1 = "testDeleteFirstOfTwoEntries #1"
        content1 = "testDeleteFirstOfTwoEntries #1"
        self.assertTrue(self.blogger.post_new_entry(title1, content1))

        title2 = "testDeleteFirstOfTwoEntries #2"
        content2 = "testDeleteFirstOfTwoEntries #2"
        self.assertTrue(self.blogger.post_new_entry(title2, content2))

        self.assertEqual(self.blogger.get_num_entries(), 2)

        # Entries are ordered most-recent first, so Entry #2 should be deleted
        self.assertTrue(self.blogger.delete_nth_entry(1))
        self.assertEqual(self.blogger.get_num_entries(), 1)
        self.assertEqual(title1, self.blogger.get_nth_entry_title(1))
        self.assertEqual(content1, self.blogger.get_nth_entry_content_strip_html(1))

    def testDeleteSecondOfTwoEntries(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)

        title1 = "testDeleteSecondOfTwoEntries #1"
        content1 = "testDeleteSecondOfTwoEntries #1"
        self.assertTrue(self.blogger.post_new_entry(title1, content1))

        title2 = "testDeleteSecondOfTwoEntries #2"
        content2 = "testDeleteSecondOfTwoEntries #2"
        self.assertTrue(self.blogger.post_new_entry(title2, content2))

        self.assertEqual(self.blogger.get_num_entries(), 2)

        # Entries are ordered most-recent first, so Entry #1 should be deleted
        self.assertTrue(self.blogger.delete_nth_entry(2))
        self.assertEqual(self.blogger.get_num_entries(), 1)
        self.assertEqual(title2, self.blogger.get_nth_entry_title(1))
        self.assertEqual(content2, self.blogger.get_nth_entry_content_strip_html(1))

    def testDeleteFirstOfThreeEntries(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)

        title1 = "testDeleteFirstOfThreeEntries #1"
        content1 = "testDeleteFirstOfThreeEntries #1"
        self.assertTrue(self.blogger.post_new_entry(title1, content1))

        title2 = "testDeleteFirstOfThreeEntries #2"
        content2 = "testDeleteFirstOfThreeEntries #2"
        self.assertTrue(self.blogger.post_new_entry(title2, content2))

        title3 = "testDeleteFirstOfThreeEntries #3"
        content3 = "testDeleteFirstOfThreeEntries #3"
        self.assertTrue(self.blogger.post_new_entry(title3, content3))

        self.assertEqual(self.blogger.get_num_entries(), 3)

        # Entries are ordered most-recent first
        # Entry #3 should be deleted
        # Entries #2 and #1 should be first and second
        self.assertTrue(self.blogger.delete_nth_entry(1))
        self.assertEqual(self.blogger.get_num_entries(), 2)

        self.assertEqual(title2, self.blogger.get_nth_entry_title(1))
        self.assertEqual(content2, self.blogger.get_nth_entry_content_strip_html(1))
        
        self.assertEqual(title1, self.blogger.get_nth_entry_title(2))
        self.assertEqual(content1, self.blogger.get_nth_entry_content_strip_html(2))

    def testDeleteSecondOfThreeEntries(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)

        title1 = "testDeleteSecondOfThreeEntries #1"
        content1 = "testDeleteSecondOfThreeEntries #1"
        self.assertTrue(self.blogger.post_new_entry(title1, content1))

        title2 = "testDeleteSecondOfThreeEntries #2"
        content2 = "testDeleteSecondOfThreeEntries #2"
        self.assertTrue(self.blogger.post_new_entry(title2, content2))

        title3 = "testDeleteSecondOfThreeEntries #3"
        content3 = "testDeleteSecondOfThreeEntries #3"
        self.assertTrue(self.blogger.post_new_entry(title3, content3))

        self.assertEqual(self.blogger.get_num_entries(), 3)

        # Entries are ordered most-recent first
        # Entry #2 should be deleted
        # Entries #3 and #1 should be first and second
        self.assertTrue(self.blogger.delete_nth_entry(2))
        self.assertEqual(self.blogger.get_num_entries(), 2)

        self.assertEqual(title3, self.blogger.get_nth_entry_title(1))
        self.assertEqual(content3, self.blogger.get_nth_entry_content_strip_html(1))
        
        self.assertEqual(title1, self.blogger.get_nth_entry_title(2))
        self.assertEqual(content1, self.blogger.get_nth_entry_content_strip_html(2))

    def testDeleteThirdOfThreeEntries(self):
        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)

        title1 = "testDeleteThirdOfThreeEntries #1"
        content1 = "testDeleteThirdOfThreeEntries #1"
        self.assertTrue(self.blogger.post_new_entry(title1, content1))

        title2 = "testDeleteThirdOfThreeEntries #2"
        content2 = "testDeleteThirdOfThreeEntries #2"
        self.assertTrue(self.blogger.post_new_entry(title2, content2))

        title3 = "testDeleteThirdOfThreeEntries #3"
        content3 = "testDeleteThirdOfThreeEntries #3"
        self.assertTrue(self.blogger.post_new_entry(title3, content3))

        self.assertEqual(self.blogger.get_num_entries(), 3)

        # Entries are ordered most-recent first
        # Entry #1 should be deleted
        # Entries #3 and #2 should be first and second
        self.assertTrue(self.blogger.delete_nth_entry(3))
        self.assertEqual(self.blogger.get_num_entries(), 2)

        self.assertEqual(title3, self.blogger.get_nth_entry_title(1))
        self.assertEqual(content3, self.blogger.get_nth_entry_content_strip_html(1))

        self.assertEqual(title2, self.blogger.get_nth_entry_title(2))
        self.assertEqual(content2, self.blogger.get_nth_entry_content_strip_html(2))

    def testDeleteAllEntries(self):
        title = "testDeleteAllEntries #1"
        content = "testDeleteAllEntries #1"
        self.blogger.post_new_entry(title, content)
        
        title = "testDeleteAllEntries #2"
        content = "testDeleteAllEntries #2"
        self.blogger.post_new_entry(title, content)

        self.blogger.delete_all_entries()
        self.assertEqual(self.blogger.get_num_entries(), 0)
        
        
if __name__ == '__main__':
    #unittest.main()
    suiteAll = unittest.TestSuite()
    suiteAll.addTest(unittest.makeSuite(testBlogger))

    suiteFew = unittest.TestSuite()
    suiteFew.addTest(testBlogger("testDeleteAllEntries"))
    suiteFew.addTest(testBlogger("testDeleteFirstOfThreeEntries"))
    suiteFew.addTest(testBlogger("testDeleteSecondOfThreeEntries"))
    suiteFew.addTest(testBlogger("testDeleteThirdOfThreeEntries"))
    
    #unittest.TextTestRunner(verbosity=2).run(suiteFew)
    unittest.TextTestRunner(verbosity=2).run(suiteAll)