summaryrefslogtreecommitdiffstats
path: root/tests/test_extensions
diff options
context:
space:
mode:
Diffstat (limited to 'tests/test_extensions')
-rw-r--r--tests/test_extensions/__init__.py0
-rw-r--r--tests/test_extensions/test_dc.py31
-rw-r--r--tests/test_extensions/test_geo.py430
-rw-r--r--tests/test_extensions/test_media.py83
-rw-r--r--tests/test_extensions/test_podcast.py106
-rw-r--r--tests/test_extensions/test_syndication.py40
-rw-r--r--tests/test_extensions/test_torrent.py38
7 files changed, 728 insertions, 0 deletions
diff --git a/tests/test_extensions/__init__.py b/tests/test_extensions/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/test_extensions/__init__.py
diff --git a/tests/test_extensions/test_dc.py b/tests/test_extensions/test_dc.py
new file mode 100644
index 0000000..af7dd94
--- /dev/null
+++ b/tests/test_extensions/test_dc.py
@@ -0,0 +1,31 @@
+import unittest
+
+from feedgen.feed import FeedGenerator
+
+
+class TestExtensionDc(unittest.TestCase):
+
+ def setUp(self):
+ self.fg = FeedGenerator()
+ self.fg.load_extension('dc')
+ self.fg.title('title')
+ self.fg.link(href='http://example.com', rel='self')
+ self.fg.description('description')
+
+ def test_entryLoadExtension(self):
+ fe = self.fg.add_item()
+ try:
+ fe.load_extension('dc')
+ except ImportError:
+ pass # Extension already loaded
+
+ def test_elements(self):
+ for method in dir(self.fg.dc):
+ if method.startswith('dc_'):
+ m = getattr(self.fg.dc, method)
+ m(method)
+ self.assertEqual(m(), [method])
+
+ self.fg.id('123')
+ self.assertTrue(self.fg.atom_str())
+ self.assertTrue(self.fg.rss_str())
diff --git a/tests/test_extensions/test_geo.py b/tests/test_extensions/test_geo.py
new file mode 100644
index 0000000..5de1f80
--- /dev/null
+++ b/tests/test_extensions/test_geo.py
@@ -0,0 +1,430 @@
+from itertools import chain
+import unittest
+import warnings
+
+from lxml import etree
+
+from feedgen.feed import FeedGenerator
+from feedgen.ext.geo_entry import GeoRSSPolygonInteriorWarning, GeoRSSGeometryError # noqa: E501
+
+
+class Geom(object):
+ """
+ Dummy geom to make testing easier
+
+ When we use the geo-interface we need a class with a `__geo_interface__`
+ property. Makes it easier for the other tests as well.
+
+ Ultimately this could be used to generate dummy geometries for testing
+ a wider variety of values (e.g. with the faker library, or the hypothesis
+ library)
+ """
+
+ def __init__(self, geom_type, coords):
+ self.geom_type = geom_type
+ self.coords = coords
+
+ def __str__(self):
+ if self.geom_type == 'Point':
+
+ coords = '{:f} {:f}'.format(
+ self.coords[1], # latitude is y
+ self.coords[0]
+ )
+ return coords
+
+ elif self.geom_type == 'LineString':
+
+ coords = ' '.join(
+ '{:f} {:f}'.format(vertex[1], vertex[0])
+ for vertex in
+ self.coords
+ )
+ return coords
+
+ elif self.geom_type == 'Polygon':
+
+ coords = ' '.join(
+ '{:f} {:f}'.format(vertex[1], vertex[0])
+ for vertex in
+ self.coords[0]
+ )
+ return coords
+
+ elif self.geom_type == 'Box':
+ # box not really supported by GeoJSON, but it's a handy cheat here
+ # for testing
+ coords = ' '.join(
+ '{:f} {:f}'.format(vertex[1], vertex[0])
+ for vertex in
+ self.coords
+ )
+ return coords[:2]
+
+ else:
+ return 'Not a supported geometry'
+
+ @property
+ def __geo_interface__(self):
+ return {
+ 'type': self.geom_type,
+ 'coordinates': self.coords
+ }
+
+
+class TestExtensionGeo(unittest.TestCase):
+
+ @classmethod
+ def setUpClass(cls):
+ cls.point = Geom('Point', [-71.05, 42.36])
+ cls.line = Geom('LineString', [[-71.05, 42.36], [-71.15, 42.46]])
+ cls.polygon = Geom(
+ 'Polygon',
+ [[[-71.05, 42.36], [-71.15, 42.46], [-71.15, 42.36]]]
+ )
+ cls.box = Geom('Box', [[-71.05, 42.36], [-71.15, 42.46]])
+ cls.polygon_with_interior = Geom(
+ 'Polygon',
+ [
+ [ # exterior
+ [0, 0],
+ [0, 1],
+ [1, 1],
+ [1, 0],
+ [0, 0]
+ ],
+ [ # interior
+ [0.25, 0.25],
+ [0.25, 0.75],
+ [0.75, 0.75],
+ [0.75, 0.25],
+ [0.25, 0.25]
+ ]
+ ]
+ )
+
+ def setUp(self):
+ self.fg = FeedGenerator()
+ self.fg.load_extension('geo')
+ self.fg.title('title')
+ self.fg.link(href='http://example.com', rel='self')
+ self.fg.description('description')
+
+ def test_point(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.point(str(self.point))
+
+ self.assertEqual(fe.geo.point(), str(self.point))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ point = root.xpath('/rss/channel/item/georss:point/text()',
+ namespaces=ns)
+ self.assertEqual(point, [str(self.point)])
+
+ def test_line(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.line(str(self.line))
+
+ self.assertEqual(fe.geo.line(), str(self.line))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ line = root.xpath(
+ '/rss/channel/item/georss:line/text()',
+ namespaces=ns
+ )
+ self.assertEqual(line, [str(self.line)])
+
+ def test_polygon(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.polygon(str(self.polygon))
+
+ self.assertEqual(fe.geo.polygon(), str(self.polygon))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ poly = root.xpath(
+ '/rss/channel/item/georss:polygon/text()',
+ namespaces=ns
+ )
+ self.assertEqual(poly, [str(self.polygon)])
+
+ def test_box(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.box(str(self.box))
+
+ self.assertEqual(fe.geo.box(), str(self.box))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ box = root.xpath(
+ '/rss/channel/item/georss:box/text()',
+ namespaces=ns
+ )
+ self.assertEqual(box, [str(self.box)])
+
+ def test_featuretypetag(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.featuretypetag('city')
+
+ self.assertEqual(fe.geo.featuretypetag(), 'city')
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ featuretypetag = root.xpath(
+ '/rss/channel/item/georss:featuretypetag/text()',
+ namespaces=ns
+ )
+ self.assertEqual(featuretypetag, ['city'])
+
+ def test_relationshiptag(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.relationshiptag('is-centred-at')
+
+ self.assertEqual(fe.geo.relationshiptag(), 'is-centred-at')
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ relationshiptag = root.xpath(
+ '/rss/channel/item/georss:relationshiptag/text()',
+ namespaces=ns
+ )
+ self.assertEqual(relationshiptag, ['is-centred-at'])
+
+ def test_featurename(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.featurename('Footscray')
+
+ self.assertEqual(fe.geo.featurename(), 'Footscray')
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ featurename = root.xpath(
+ '/rss/channel/item/georss:featurename/text()',
+ namespaces=ns
+ )
+ self.assertEqual(featurename, ['Footscray'])
+
+ def test_elev(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.elev(100.3)
+
+ self.assertEqual(fe.geo.elev(), 100.3)
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ elev = root.xpath(
+ '/rss/channel/item/georss:elev/text()',
+ namespaces=ns
+ )
+ self.assertEqual(elev, ['100.3'])
+
+ def test_elev_fails_nonnumeric(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+
+ with self.assertRaises(ValueError):
+ fe.geo.elev('100.3')
+
+ def test_floor(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.floor(4)
+
+ self.assertEqual(fe.geo.floor(), 4)
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ floor = root.xpath(
+ '/rss/channel/item/georss:floor/text()',
+ namespaces=ns
+ )
+ self.assertEqual(floor, ['4'])
+
+ def test_floor_fails_nonint(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+
+ with self.assertRaises(ValueError):
+ fe.geo.floor(100.3)
+
+ with self.assertRaises(ValueError):
+ fe.geo.floor('4')
+
+ def test_radius(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.radius(100.3)
+
+ self.assertEqual(fe.geo.radius(), 100.3)
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ radius = root.xpath(
+ '/rss/channel/item/georss:radius/text()',
+ namespaces=ns
+ )
+ self.assertEqual(radius, ['100.3'])
+
+ def test_radius_fails_nonnumeric(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+
+ with self.assertRaises(ValueError):
+ fe.geo.radius('100.3')
+
+ def test_geom_from_geointerface_point(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.geom_from_geo_interface(self.point)
+
+ self.assertEqual(fe.geo.point(), str(self.point))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ point = root.xpath('/rss/channel/item/georss:point/text()',
+ namespaces=ns)
+ self.assertEqual(point, [str(self.point)])
+
+ coords = [float(c) for c in point[0].split()]
+
+ try:
+ self.assertCountEqual(
+ coords,
+ self.point.coords
+ )
+ except AttributeError: # was assertItemsEqual in Python 2.7
+ self.assertItemsEqual(
+ coords,
+ self.point.coords
+ )
+
+ def test_geom_from_geointerface_line(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.geom_from_geo_interface(self.line)
+
+ self.assertEqual(fe.geo.line(), str(self.line))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ line = root.xpath('/rss/channel/item/georss:line/text()',
+ namespaces=ns)
+ self.assertEqual(line, [str(self.line)])
+
+ coords = [float(c) for c in line[0].split()]
+
+ try:
+ self.assertCountEqual(
+ coords,
+ list(chain.from_iterable(self.line.coords))
+ )
+ except AttributeError: # was assertItemsEqual in Python 2.7
+ self.assertItemsEqual(
+ coords,
+ list(chain.from_iterable(self.line.coords))
+ )
+
+ def test_geom_from_geointerface_poly(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.geo.geom_from_geo_interface(self.polygon)
+
+ self.assertEqual(fe.geo.polygon(), str(self.polygon))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ poly = root.xpath('/rss/channel/item/georss:polygon/text()',
+ namespaces=ns)
+ self.assertEqual(poly, [str(self.polygon)])
+
+ coords = [float(c) for c in poly[0].split()]
+
+ try:
+ self.assertCountEqual(
+ coords,
+ list(chain.from_iterable(self.polygon.coords[0]))
+ )
+ except AttributeError: # was assertItemsEqual in Python 2.7
+ self.assertItemsEqual(
+ coords,
+ list(chain.from_iterable(self.polygon.coords[0]))
+ )
+
+ def test_geom_from_geointerface_fail_other_geom(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+
+ with self.assertRaises(GeoRSSGeometryError):
+ fe.geo.geom_from_geo_interface(self.box)
+
+ def test_geom_from_geointerface_fail_requires_geo_interface(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+
+ with self.assertRaises(AttributeError):
+ fe.geo.geom_from_geo_interface(str(self.box))
+
+ def test_geom_from_geointerface_warn_poly_interior(self):
+ """
+ Test complex polygons warn as expected. Taken from
+
+ https://stackoverflow.com/a/3892301/379566 and
+ https://docs.python.org/2.7/library/warnings.html#testing-warnings
+ """
+ fe = self.fg.add_item()
+ fe.title('y')
+
+ with warnings.catch_warnings(record=True) as w:
+ # Cause all warnings to always be triggered.
+ warnings.simplefilter("always")
+ # Trigger a warning.
+ fe.geo.geom_from_geo_interface(self.polygon_with_interior)
+ # Verify some things
+ self.assertEqual(len(w), 1)
+ self.assertTrue(issubclass(w[-1].category,
+ GeoRSSPolygonInteriorWarning))
+
+ self.assertEqual(fe.geo.polygon(), str(self.polygon_with_interior))
+
+ # Check that we have the item in the resulting XML
+ ns = {'georss': 'http://www.georss.org/georss'}
+ root = etree.fromstring(self.fg.rss_str())
+ poly = root.xpath('/rss/channel/item/georss:polygon/text()',
+ namespaces=ns)
+ self.assertEqual(poly, [str(self.polygon_with_interior)])
+
+ coords = [float(c) for c in poly[0].split()]
+
+ try:
+ self.assertCountEqual(
+ coords,
+ list(chain.from_iterable(self.polygon_with_interior.coords[0]))
+ )
+ except AttributeError: # was assertItemsEqual in Python 2.7
+ self.assertItemsEqual(
+ coords,
+ list(chain.from_iterable(self.polygon_with_interior.coords[0]))
+ )
diff --git a/tests/test_extensions/test_media.py b/tests/test_extensions/test_media.py
new file mode 100644
index 0000000..1f5a349
--- /dev/null
+++ b/tests/test_extensions/test_media.py
@@ -0,0 +1,83 @@
+import unittest
+
+from lxml import etree
+
+from feedgen.feed import FeedGenerator
+
+
+class TestExtensionMedia(unittest.TestCase):
+
+ def setUp(self):
+ self.fg = FeedGenerator()
+ self.fg.load_extension('media')
+ self.fg.id('id')
+ self.fg.title('title')
+ self.fg.link(href='http://example.com', rel='self')
+ self.fg.description('description')
+
+ def test_media_content(self):
+ fe = self.fg.add_item()
+ fe.id('id')
+ fe.title('title')
+ fe.content('content')
+ fe.media.content(url='file1.xy')
+ fe.media.content(url='file2.xy')
+ fe.media.content(url='file1.xy', group=2)
+ fe.media.content(url='file2.xy', group=2)
+ fe.media.content(url='file.xy', group=None)
+
+ ns = {'media': 'http://search.yahoo.com/mrss/',
+ 'a': 'http://www.w3.org/2005/Atom'}
+ # Check that we have the item in the resulting RSS
+ root = etree.fromstring(self.fg.rss_str())
+ url = root.xpath('/rss/channel/item/media:group/media:content[1]/@url',
+ namespaces=ns)
+ self.assertEqual(url, ['file1.xy', 'file1.xy'])
+
+ # There is one without a group
+ url = root.xpath('/rss/channel/item/media:content[1]/@url',
+ namespaces=ns)
+ self.assertEqual(url, ['file.xy'])
+
+ # Check that we have the item in the resulting Atom feed
+ root = etree.fromstring(self.fg.atom_str())
+ url = root.xpath('/a:feed/a:entry/media:group/media:content[1]/@url',
+ namespaces=ns)
+ self.assertEqual(url, ['file1.xy', 'file1.xy'])
+
+ fe.media.content(content=[], replace=True)
+ self.assertEqual(fe.media.content(), [])
+
+ def test_media_thumbnail(self):
+ fe = self.fg.add_item()
+ fe.id('id')
+ fe.title('title')
+ fe.content('content')
+ fe.media.thumbnail(url='file1.xy')
+ fe.media.thumbnail(url='file2.xy')
+ fe.media.thumbnail(url='file1.xy', group=2)
+ fe.media.thumbnail(url='file2.xy', group=2)
+ fe.media.thumbnail(url='file.xy', group=None)
+
+ ns = {'media': 'http://search.yahoo.com/mrss/',
+ 'a': 'http://www.w3.org/2005/Atom'}
+ # Check that we have the item in the resulting RSS
+ root = etree.fromstring(self.fg.rss_str())
+ url = root.xpath(
+ '/rss/channel/item/media:group/media:thumbnail[1]/@url',
+ namespaces=ns)
+ self.assertEqual(url, ['file1.xy', 'file1.xy'])
+
+ # There is one without a group
+ url = root.xpath('/rss/channel/item/media:thumbnail[1]/@url',
+ namespaces=ns)
+ self.assertEqual(url, ['file.xy'])
+
+ # Check that we have the item in the resulting Atom feed
+ root = etree.fromstring(self.fg.atom_str())
+ url = root.xpath('/a:feed/a:entry/media:group/media:thumbnail[1]/@url',
+ namespaces=ns)
+ self.assertEqual(url, ['file1.xy', 'file1.xy'])
+
+ fe.media.thumbnail(thumbnail=[], replace=True)
+ self.assertEqual(fe.media.thumbnail(), [])
diff --git a/tests/test_extensions/test_podcast.py b/tests/test_extensions/test_podcast.py
new file mode 100644
index 0000000..84c8c96
--- /dev/null
+++ b/tests/test_extensions/test_podcast.py
@@ -0,0 +1,106 @@
+import unittest
+
+from lxml import etree
+
+from feedgen.feed import FeedGenerator
+
+
+class TestExtensionPodcast(unittest.TestCase):
+
+ def setUp(self):
+ self.fg = FeedGenerator()
+ self.fg.load_extension('podcast')
+ self.fg.title('title')
+ self.fg.link(href='http://example.com', rel='self')
+ self.fg.description('description')
+
+ def test_category_new(self):
+ self.fg.podcast.itunes_category([{'cat': 'Technology',
+ 'sub': 'Podcasting'}])
+ self.fg.podcast.itunes_explicit('no')
+ self.fg.podcast.itunes_complete('no')
+ self.fg.podcast.itunes_new_feed_url('http://example.com/new-feed.rss')
+ self.fg.podcast.itunes_owner('John Doe', 'john@example.com')
+ ns = {'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'}
+ root = etree.fromstring(self.fg.rss_str())
+ cat = root.xpath('/rss/channel/itunes:category/@text', namespaces=ns)
+ scat = root.xpath('/rss/channel/itunes:category/itunes:category/@text',
+ namespaces=ns)
+ self.assertEqual(cat[0], 'Technology')
+ self.assertEqual(scat[0], 'Podcasting')
+
+ def test_category(self):
+ self.fg.podcast.itunes_category('Technology', 'Podcasting')
+ self.fg.podcast.itunes_explicit('no')
+ self.fg.podcast.itunes_complete('no')
+ self.fg.podcast.itunes_new_feed_url('http://example.com/new-feed.rss')
+ self.fg.podcast.itunes_owner('John Doe', 'john@example.com')
+ ns = {'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'}
+ root = etree.fromstring(self.fg.rss_str())
+ cat = root.xpath('/rss/channel/itunes:category/@text', namespaces=ns)
+ scat = root.xpath('/rss/channel/itunes:category/itunes:category/@text',
+ namespaces=ns)
+ self.assertEqual(cat[0], 'Technology')
+ self.assertEqual(scat[0], 'Podcasting')
+
+ def test_podcastItems(self):
+ fg = self.fg
+ fg.podcast.itunes_author('Lars Kiesow')
+ fg.podcast.itunes_block('x')
+ fg.podcast.itunes_complete(False)
+ fg.podcast.itunes_explicit('no')
+ fg.podcast.itunes_image('x.png')
+ fg.podcast.itunes_subtitle('x')
+ fg.podcast.itunes_summary('x')
+ fg.podcast.itunes_type('episodic')
+ self.assertEqual(fg.podcast.itunes_author(), 'Lars Kiesow')
+ self.assertEqual(fg.podcast.itunes_block(), 'x')
+ self.assertEqual(fg.podcast.itunes_complete(), 'no')
+ self.assertEqual(fg.podcast.itunes_explicit(), 'no')
+ self.assertEqual(fg.podcast.itunes_image(), 'x.png')
+ self.assertEqual(fg.podcast.itunes_subtitle(), 'x')
+ self.assertEqual(fg.podcast.itunes_summary(), 'x')
+ self.assertEqual(fg.podcast.itunes_type(), 'episodic')
+
+ # Check that we have the item in the resulting XML
+ ns = {'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'}
+ root = etree.fromstring(self.fg.rss_str())
+ author = root.xpath('/rss/channel/itunes:author/text()', namespaces=ns)
+ self.assertEqual(author, ['Lars Kiesow'])
+
+ def test_podcastEntryItems(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.podcast.itunes_author('Lars Kiesow')
+ fe.podcast.itunes_block('x')
+ fe.podcast.itunes_duration('00:01:30')
+ fe.podcast.itunes_explicit('no')
+ fe.podcast.itunes_image('x.png')
+ fe.podcast.itunes_is_closed_captioned('yes')
+ fe.podcast.itunes_order(1)
+ fe.podcast.itunes_subtitle('x')
+ fe.podcast.itunes_summary('x')
+ fe.podcast.itunes_season(1)
+ fe.podcast.itunes_episode(1)
+ fe.podcast.itunes_title('Podcast Title')
+ fe.podcast.itunes_episode_type('full')
+ self.assertEqual(fe.podcast.itunes_author(), 'Lars Kiesow')
+ self.assertEqual(fe.podcast.itunes_block(), 'x')
+ self.assertEqual(fe.podcast.itunes_duration(), '00:01:30')
+ self.assertEqual(fe.podcast.itunes_explicit(), 'no')
+ self.assertEqual(fe.podcast.itunes_image(), 'x.png')
+ self.assertTrue(fe.podcast.itunes_is_closed_captioned())
+ self.assertEqual(fe.podcast.itunes_order(), 1)
+ self.assertEqual(fe.podcast.itunes_subtitle(), 'x')
+ self.assertEqual(fe.podcast.itunes_summary(), 'x')
+ self.assertEqual(fe.podcast.itunes_season(), 1)
+ self.assertEqual(fe.podcast.itunes_episode(), 1)
+ self.assertEqual(fe.podcast.itunes_title(), 'Podcast Title')
+ self.assertEqual(fe.podcast.itunes_episode_type(), 'full')
+
+ # Check that we have the item in the resulting XML
+ ns = {'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'}
+ root = etree.fromstring(self.fg.rss_str())
+ author = root.xpath('/rss/channel/item/itunes:author/text()',
+ namespaces=ns)
+ self.assertEqual(author, ['Lars Kiesow'])
diff --git a/tests/test_extensions/test_syndication.py b/tests/test_extensions/test_syndication.py
new file mode 100644
index 0000000..029e100
--- /dev/null
+++ b/tests/test_extensions/test_syndication.py
@@ -0,0 +1,40 @@
+import unittest
+
+from lxml import etree
+
+from feedgen.feed import FeedGenerator
+
+
+class TestExtensionSyndication(unittest.TestCase):
+
+ SYN_NS = {'sy': 'http://purl.org/rss/1.0/modules/syndication/'}
+
+ def setUp(self):
+ self.fg = FeedGenerator()
+ self.fg.load_extension('syndication')
+ self.fg.title('title')
+ self.fg.link(href='http://example.com', rel='self')
+ self.fg.description('description')
+
+ def test_update_period(self):
+ for period_type in ('hourly', 'daily', 'weekly', 'monthly', 'yearly'):
+ self.fg.syndication.update_period(period_type)
+ root = etree.fromstring(self.fg.rss_str())
+ a = root.xpath('/rss/channel/sy:UpdatePeriod',
+ namespaces=self.SYN_NS)
+ self.assertEqual(a[0].text, period_type)
+
+ def test_update_frequency(self):
+ for frequency in (1, 100, 2000, 100000):
+ self.fg.syndication.update_frequency(frequency)
+ root = etree.fromstring(self.fg.rss_str())
+ a = root.xpath('/rss/channel/sy:UpdateFrequency',
+ namespaces=self.SYN_NS)
+ self.assertEqual(a[0].text, str(frequency))
+
+ def test_update_base(self):
+ base = '2000-01-01T12:00+00:00'
+ self.fg.syndication.update_base(base)
+ root = etree.fromstring(self.fg.rss_str())
+ a = root.xpath('/rss/channel/sy:UpdateBase', namespaces=self.SYN_NS)
+ self.assertEqual(a[0].text, base)
diff --git a/tests/test_extensions/test_torrent.py b/tests/test_extensions/test_torrent.py
new file mode 100644
index 0000000..230ec1a
--- /dev/null
+++ b/tests/test_extensions/test_torrent.py
@@ -0,0 +1,38 @@
+import unittest
+
+from lxml import etree
+
+from feedgen.feed import FeedGenerator
+
+
+class TestExtensionTorrent(unittest.TestCase):
+
+ def setUp(self):
+ self.fg = FeedGenerator()
+ self.fg.load_extension('torrent')
+ self.fg.title('title')
+ self.fg.link(href='http://example.com', rel='self')
+ self.fg.description('description')
+
+ def test_podcastEntryItems(self):
+ fe = self.fg.add_item()
+ fe.title('y')
+ fe.torrent.filename('file.xy')
+ fe.torrent.infohash('123')
+ fe.torrent.contentlength('23')
+ fe.torrent.seeds('1')
+ fe.torrent.peers('2')
+ fe.torrent.verified('1')
+ self.assertEqual(fe.torrent.filename(), 'file.xy')
+ self.assertEqual(fe.torrent.infohash(), '123')
+ self.assertEqual(fe.torrent.contentlength(), '23')
+ self.assertEqual(fe.torrent.seeds(), '1')
+ self.assertEqual(fe.torrent.peers(), '2')
+ self.assertEqual(fe.torrent.verified(), '1')
+
+ # Check that we have the item in the resulting XML
+ ns = {'torrent': 'http://xmlns.ezrss.it/0.1/dtd/'}
+ root = etree.fromstring(self.fg.rss_str())
+ filename = root.xpath('/rss/channel/item/torrent:filename/text()',
+ namespaces=ns)
+ self.assertEqual(filename, ['file.xy'])
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-18 11:09:12 +0100