コード例 #1
0
ファイル: testsuite.py プロジェクト: narfdotpl/interssection
    def test_update_template_cache_if_feed_id_was_changed(self):
        feed = Feed(atom)

        str(feed)
        template1 = feed._xml

        feed.id = uuid4().urn
        str(feed)
        template2 = feed._xml

        self.assertIsNot(template1, template2)
コード例 #2
0
ファイル: testsuite.py プロジェクト: narfdotpl/interssection
 def setUp(self):
     self.feed12 = Feed(atom12)
     self.feed23 = Feed(atom23)
     self.feed34 = Feed(atom34)
コード例 #3
0
ファイル: testsuite.py プロジェクト: narfdotpl/interssection
 def test_allow_to_change_feed_title(self):
     feed = Feed(atom)
     new_title = feed.title + 'foo'
     feed.title = new_title
     self.assertEqual(feed.title, new_title)
     self.assertEqual(parse(str(feed)).feed.title, new_title)
コード例 #4
0
ファイル: testsuite.py プロジェクト: narfdotpl/interssection
class TestSetOperations(TestCase):

    def setUp(self):
        self.feed12 = Feed(atom12)
        self.feed23 = Feed(atom23)
        self.feed34 = Feed(atom34)


    def test_support___and__(self):
        feed = self.feed12 & self.feed23
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 1)
        self.assertEqual(parsed.entries[0].title, '2')

        feed = self.feed12 & self.feed23 & self.feed34
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 0)

    def test_support__ge__(self):
        self.assertTrue(self.feed12 >= self.feed12)
        self.assertTrue((self.feed12 | self.feed23) >= self.feed12)
        self.assertFalse(self.feed12 >= (self.feed12 | self.feed23))

    def test_support__gt__(self):
        self.assertFalse(self.feed12 > self.feed12)
        self.assertTrue((self.feed12 | self.feed23) > self.feed12)
        self.assertFalse(self.feed12 > (self.feed12 | self.feed23))

    def test_support__le__(self):
        self.assertTrue(self.feed12 <= self.feed12)
        self.assertTrue(self.feed12 <= self.feed12 | self.feed23)
        self.assertFalse(self.feed12 <= self.feed23)

    def test_support___len__(self):
        self.assertEqual(len(self.feed12), 2)
        self.assertEqual(len(self.feed12 & self.feed23), 1)

    def test_support__lt__(self):
        self.assertFalse(self.feed12 < self.feed12)
        self.assertTrue(self.feed12 < self.feed12 | self.feed23)
        self.assertFalse(self.feed12 < self.feed23)

    def test_support___or__(self):
        feed = self.feed12 | self.feed23
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 3)
        self.assertItemsEqual([entry.title for entry in parsed.entries],
                              ['1', '2', '3'])

        feed = self.feed12 | self.feed23 | self.feed34
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 4)
        self.assertItemsEqual([entry.title for entry in parsed.entries],
                              ['1', '2', '3', '4'])

    def test_support___sub__(self):
        feed = self.feed12 - self.feed23
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 1)
        self.assertEqual(parsed.entries[0].title, '1')

        feed = self.feed23 - self.feed12 - self.feed34
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 0)

    def test_support___xor__(self):
        feed = self.feed12 ^ self.feed23
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 2)
        self.assertItemsEqual([entry.title for entry in parsed.entries],
                              ['1', '3'])

    def test_support_difference(self):
        feed = self.feed12.difference(self.feed23)
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 1)
        self.assertEqual(parsed.entries[0].title, '1')

        feed = self.feed23.difference(self.feed12, self.feed34)
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 0)

    def test_support_intersection(self):
        feed = self.feed12.intersection(self.feed23)
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 1)
        self.assertEqual(parsed.entries[0].title, '2')

        feed = self.feed12.intersection(self.feed23, self.feed34)
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 0)

    def test_support_isdisjoint(self):
        self.assertFalse(self.feed12.isdisjoint(self.feed23))
        self.assertTrue(self.feed12.isdisjoint(self.feed34))

    def test_support_issubset(self):
        self.assertTrue(self.feed12.issubset(self.feed12))
        self.assertTrue(self.feed12.issubset(self.feed12 | self.feed23))
        self.assertFalse(self.feed12.issubset(self.feed23))

    def test_support_issuperset(self):
        self.assertTrue(self.feed12.issuperset(self.feed12))
        self.assertTrue((self.feed12 | self.feed23).issuperset(self.feed12))
        self.assertFalse(self.feed12.issuperset(self.feed12 | self.feed23))

    def test_support_symmetric_difference(self):
        feed = self.feed12.symmetric_difference(self.feed23)
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 2)
        self.assertItemsEqual([entry.title for entry in parsed.entries],
                              ['1', '3'])

    def test_support_union(self):
        feed = self.feed12.union(self.feed23)
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 3)
        self.assertItemsEqual([entry.title for entry in parsed.entries],
                              ['1', '2', '3'])

        feed = self.feed12.union(self.feed23, self.feed34)
        parsed = parse(str(feed))
        self.assertEqual(len(parsed.entries), 4)
        self.assertItemsEqual([entry.title for entry in parsed.entries],
                              ['1', '2', '3', '4'])

    def test_dont_support___contains__(self):
        with self.assertRaises(TypeError):
            'foo' in Feed(atom)

    def test_dont_support_copy(self):
        with self.assertRaises(AttributeError):
            Feed(atom).copy()
コード例 #5
0
ファイル: testsuite.py プロジェクト: narfdotpl/interssection
 def test_allow_to_change_feed_id(self):
     feed = Feed(atom)
     new_id = uuid4().urn
     feed.id = new_id
     self.assertEqual(feed.id, new_id)
     self.assertEqual(parse(str(feed)).feed.id, new_id)