From 3b557d364acd70332707acb1fd5d96831ae2a863 Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 8 Jul 2019 12:30:44 +1000
Subject: [PATCH 1/8] Add IDE and gesting artifacts to the gitignore file

---
 .gitignore | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.gitignore b/.gitignore
index b6f6775..af64cfd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+.idea/
 venv
 *.pyc
 *.pyo
@@ -10,3 +11,7 @@ feedgen/tests/tmp_Rssfeed.xml
 tmp_Atomfeed.xml
 
 tmp_Rssfeed.xml
+
+# testing artifacts
+.coverage
+*.egg-info/

From 642862bb2b5e6f9bf8b3dad6b1459d2cb17b32d1 Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 8 Jul 2019 12:31:34 +1000
Subject: [PATCH 2/8] Update simple GeoRSS to complete the specification

Originally the georss entry only contained a simple point
specification. Update to include:

- other geometries (line, polygon and box)
- additional properties (featuretypetag, relationshiptag, featurename)
- elevation (elev, floor)
- radius (radius)

This also includes basic type checking with a value error for the
elev, floor and radius tags.
---
 feedgen/ext/geo_entry.py | 173 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 172 insertions(+), 1 deletion(-)

diff --git a/feedgen/ext/geo_entry.py b/feedgen/ext/geo_entry.py
index 8c9dd15..4721e0a 100644
--- a/feedgen/ext/geo_entry.py
+++ b/feedgen/ext/geo_entry.py
@@ -9,6 +9,7 @@
 
     :license: FreeBSD and LGPL, see license.* for more details.
 '''
+import numbers
 
 from lxml import etree
 from feedgen.ext.base import BaseEntryExtension
@@ -19,8 +20,24 @@ class GeoEntryExtension(BaseEntryExtension):
     '''
 
     def __init__(self):
-        # Simple GeoRSS tag
+        '''Simple GeoRSS tag'''
+        # geometries
         self.__point = None
+        self.__line = None
+        self.__polygon = None
+        self.__box = None
+
+        # additional properties
+        self.__featuretypetag = None
+        self.__relationshiptag = None
+        self.__featurename = None
+
+        # elevation
+        self.__elev = None
+        self.__floor = None
+
+        # radius
+        self.__radius = None
 
     def extend_file(self, entry):
         '''Add additional fields to an RSS item.
@@ -34,6 +51,42 @@ class GeoEntryExtension(BaseEntryExtension):
             point = etree.SubElement(entry, '{%s}point' % GEO_NS)
             point.text = self.__point
 
+        if self.__line:
+            line = etree.SubElement(entry, '{%s}line' % GEO_NS)
+            line.text = self.__line
+
+        if self.__polygon:
+            polygon = etree.SubElement(entry, '{%s}polygon' % GEO_NS)
+            polygon.text = self.__polygon
+
+        if self.__box:
+            box = etree.SubElement(entry, '{%s}box' % GEO_NS)
+            box.text = self.__box
+
+        if self.__featuretypetag:
+            featuretypetag = etree.SubElement(entry, '{%s}featuretypetag' % GEO_NS)
+            featuretypetag.text = self.__featuretypetag
+
+        if self.__relationshiptag:
+            relationshiptag = etree.SubElement(entry, '{%s}relationshiptag' % GEO_NS)
+            relationshiptag.text = self.__relationshiptag
+
+        if self.__featurename:
+            featurename = etree.SubElement(entry, '{%s}featurename' % GEO_NS)
+            featurename.text = self.__featurename
+
+        if self.__elev:
+            elevation = etree.SubElement(entry, '{%s}elev' % GEO_NS)
+            elevation.text = self.__elev
+
+        if self.__floor:
+            floor = etree.SubElement(entry, '{%s}floor' % GEO_NS)
+            floor.text = self.__floor
+
+        if self.__radius:
+            radius = etree.SubElement(entry, '{%s}radius' % GEO_NS)
+            radius.text = self.__radius
+
         return entry
 
     def extend_rss(self, entry):
@@ -53,3 +106,121 @@ class GeoEntryExtension(BaseEntryExtension):
             self.__point = point
 
         return self.__point
+
+    def line(self, line=None):
+        '''Get or set the georss:line of the entry
+
+        :param point: The GeoRSS formatted line (i.e. "45.256 -110.45 46.46 -109.48 43.84 -109.86")
+        :return: The current georss:line of the entry
+        '''
+        if line is not None:
+            self.__line = line
+
+        return self.__line
+
+    def polygon(self, polygon=None):
+        '''Get or set the georss:polygon of the entry
+
+        :param polygon: The GeoRSS formatted polygon (i.e. "45.256 -110.45 46.46 -109.48 43.84 -109.86 45.256 -110.45")
+        :return: The current georss:polygon of the entry
+        '''
+        if polygon is not None:
+            self.__polygon = polygon
+
+        return self.__polygon
+
+    def box(self, box=None):
+        '''
+        Get or set the georss:box of the entry
+
+        :param box: The GeoRSS formatted box (i.e. "42.943 -71.032 43.039 -69.856")
+        :return: The current georss:box of the entry
+        '''
+        if box is not None:
+            self.__box = box
+
+        return self.__box
+
+    def featuretypetag(self, featuretypetag):
+        '''
+        Get or set the georss:featuretypetag of the entry
+
+        :param featuretypetag: The GeoRSS feaaturertyptag (e.g. "city")
+        :return: The current georss:featurertypetag
+        '''
+        if featuretypetag is not None:
+            self.__featuretypetag = featuretypetag
+
+        return self.__featuretypetag
+
+    def relationshiptag(self, relationshiptag):
+        '''
+        Get or set the georss:relationshiptag of the entry
+
+        :param relationshiptag: The GeoRSS relationshiptag (e.g. "is-centred-at")
+        :return: the current georss:relationshiptag
+        '''
+        if relationshiptag is not None:
+            self.__relationshiptag = relationshiptag
+
+        return self.__relationshiptag
+
+    def featurename(self, featurename):
+        '''
+        Get or set the georss:featurename of the entry
+
+        :param featuretypetag: The GeoRSS featurename (e.g. "city")
+        :return: the current georss:featurename
+        '''
+        if featurename is not None:
+            self.__featurename = featurename
+
+        return self.__featurename
+
+    def elev(self, elev):
+        '''
+        Get or set the georss:elev of the entry
+
+        :param elev: The GeoRSS elevation (e.g. 100.3)
+        :type elev: numbers.Number
+        :return: the current georss:elev
+        '''
+        if elev is not None:
+            if not isinstance(elev, numbers.Number):
+                raise ValueError("elev tag must be numeric: {}".format(elev))
+
+            self.__elev = elev
+
+        return self.__elev
+
+    def floor(self, floor):
+        '''
+        Get or set the georss:floor of the entry
+
+        :param floor: The GeoRSS floor (e.g. 4)
+        :type floor: int
+        :return: the current georss:floor
+        '''
+        if floor is not None:
+            if not isinstance(floor, int):
+                raise ValueError("floor tag must be int: {}".format(floor))
+
+            self.__floor = floor
+
+        return self.__floor
+
+    def radius(self, radius):
+        '''
+        Get or set the georss:radius of the entry
+
+        :param radius: The GeoRSS radius (e.g. 100.3)
+        :type radius: numbers.Number
+        :return: the current georss:radius
+        '''
+        if radius is not None:
+            if not isinstance(radius, numbers.Number):
+                raise ValueError("radius tag must be numeric: {}".format(radius))
+
+            self.__radius = radius
+
+        return self.__radius

From 8d413f576f9d1c26f74365d3eb87b4b310953874 Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 8 Jul 2019 13:38:39 +1000
Subject: [PATCH 3/8] Add a geom_from_geo_interface method for GeoRSS Entry

A standard way for different geometry libraries in Python to be
interoperable is a `__geo_interface__` for the geometry (see the
specification: https://gist.github.com/sgillies/2217756). This
includes the shapely library, geometries from QGIS, and geometries in
Esri's arcpy libraries for ArcGIS desktop and ArcGIS pro.

To make it easier to generate a georss entry a simple method which
does the conversion (of the supported geometries only) and sets the
appropriate geometry type.

This includes a custom error for the geometry being incompatible and a
custom warning for a polygon with interior holes. This is done to
store the geometries on the exception / warning if required for
debugging.
---
 feedgen/ext/geo_entry.py | 96 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/feedgen/ext/geo_entry.py b/feedgen/ext/geo_entry.py
index 4721e0a..e57fc81 100644
--- a/feedgen/ext/geo_entry.py
+++ b/feedgen/ext/geo_entry.py
@@ -10,11 +10,48 @@
     :license: FreeBSD and LGPL, see license.* for more details.
 '''
 import numbers
+import warnings
 
 from lxml import etree
 from feedgen.ext.base import BaseEntryExtension
 
 
+class GeoRSSPolygonInteriorWarning(Warning):
+    """
+    Simple placeholder for warning about ignored polygon interiors.
+
+    Stores the original geom on a ``geom`` attribute (if required warnings are
+    raised as errors).
+    """
+
+    def __init__(self, geom, *args, **kwargs):
+        self.geom = geom
+        super(GeoRSSPolygonInteriorWarning, self).__init__(*args, **kwargs)
+
+    def __str__(self):
+        return '{:d} interiors of polygon ignored'.format(
+            len(self.geom.__geo_interface__['coordinates']) - 1  # ignore exterior in count
+        )
+
+class GeoRSSGeometryError(ValueError):
+    """
+    Subclass of ValueError for a GeoRSS geometry error
+
+    Only some geometries are supported in Simple GeoRSS, so if not raise an
+    error. Offending geometry is stored on the ``geom`` attribute.
+
+    """
+
+    def __init__(self, geom, *args, **kwargs):
+        self.geom = geom
+        super(GeoRSSGeometryError, self).__init__(*args, **kwargs)
+
+    def __str__(self):
+        return "Geometry of type '{}' not in Point, Linestring or Polygon".format(
+            self.geom.__geo_interface__['type']
+        )
+
+
 class GeoEntryExtension(BaseEntryExtension):
     '''FeedEntry extension for Simple GeoRSS.
     '''
@@ -224,3 +261,62 @@ class GeoEntryExtension(BaseEntryExtension):
             self.__radius = radius
 
         return self.__radius
+
+    def geom_from_geo_interface(self, geom):
+        '''
+        Generate a georss geometry from some Python object with a
+        ``__geo_interface__`` property (see the `geo_interface specification by
+        Sean Gillies`_geointerface )
+
+        Note only a subset of GeoJSON (see `geojson.org`_geojson ) can be easily
+        converted to GeoRSS:
+
+        - Point
+        - LineString
+        - Polygon (if there are holes / donuts in the polygons a warning will be
+          generaated
+
+        Other GeoJson types will raise a ``ValueError``.
+
+        .. note:: The geometry is assumed to be x, y as longitude, latitude in
+           the WGS84 projection.
+
+        .. _geointerface: https://gist.github.com/sgillies/2217756
+        .. _geojson: https://geojson.org/
+
+        :param geom: Geometry object with a __geo_interface__ property
+        :return: the formatted GeoRSS geometry
+        '''
+        geojson = geom.__geo_interface__
+
+        if geojson['type'] not in ('Point', 'LineString', 'Polygon'):
+            raise GeoRSSGeometryError(geom)
+
+        if geojson['type'] == 'Point':
+
+            coords = '%f %f'.format(
+                geojson['coordinates'][1],  # latitude is y
+                geojson['coordinates'][0]
+            )
+            return self.point(coords)
+
+        elif geojson['type'] == 'LineString':
+
+            coords = ' '.join(
+                '%f %f'.format(vertex[1], vertex[0])
+                for vertex in
+                geojson['coordinates']
+            )
+            return self.line(coords)
+
+        elif geojson['type'] == 'Polygon':
+
+            if len(geojson['coordinates']) > 1:
+                warnings.warn(GeoRSSPolygonInteriorWarning(geom))
+
+            coords = ' '.join(
+                '%f %f'.format(vertex[1], vertex[0])
+                for vertex in
+                geojson['coordinates'][0]
+            )
+            return self.polygon(coords)

From d32487f2edad0120c7eb4efc86ff53caa78ef114 Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 8 Jul 2019 13:49:56 +1000
Subject: [PATCH 4/8] Separate extensions as their own files

Give each extension its own test file. Primarily this is done to make
it easier to add some fixtures and extend the geo tests.
---
 tests/test_extension.py                   | 300 ----------------------
 tests/test_extensions/__init__.py         |   0
 tests/test_extensions/test_dc.py          |  31 +++
 tests/test_extensions/test_geo.py         |  29 +++
 tests/test_extensions/test_media.py       |  83 ++++++
 tests/test_extensions/test_podcast.py     |  96 +++++++
 tests/test_extensions/test_syndication.py |  40 +++
 tests/test_extensions/test_torrent.py     |  38 +++
 8 files changed, 317 insertions(+), 300 deletions(-)
 delete mode 100644 tests/test_extension.py
 create mode 100644 tests/test_extensions/__init__.py
 create mode 100644 tests/test_extensions/test_dc.py
 create mode 100644 tests/test_extensions/test_geo.py
 create mode 100644 tests/test_extensions/test_media.py
 create mode 100644 tests/test_extensions/test_podcast.py
 create mode 100644 tests/test_extensions/test_syndication.py
 create mode 100644 tests/test_extensions/test_torrent.py

diff --git a/tests/test_extension.py b/tests/test_extension.py
deleted file mode 100644
index db85c08..0000000
--- a/tests/test_extension.py
+++ /dev/null
@@ -1,300 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Tests for extensions
-"""
-
-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)
-            assert 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)
-            assert 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)
-        assert a[0].text == base
-
-
-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)
-        assert cat[0] == 'Technology'
-        assert 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)
-        assert cat[0] == 'Technology'
-        assert 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')
-        assert fg.podcast.itunes_author() == 'Lars Kiesow'
-        assert fg.podcast.itunes_block() == 'x'
-        assert fg.podcast.itunes_complete() == 'no'
-        assert fg.podcast.itunes_explicit() == 'no'
-        assert fg.podcast.itunes_image() == 'x.png'
-        assert fg.podcast.itunes_subtitle() == 'x'
-        assert fg.podcast.itunes_summary() == 'x'
-
-        # 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)
-        assert 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')
-        assert fe.podcast.itunes_author() == 'Lars Kiesow'
-        assert fe.podcast.itunes_block() == 'x'
-        assert fe.podcast.itunes_duration() == '00:01:30'
-        assert fe.podcast.itunes_explicit() == 'no'
-        assert fe.podcast.itunes_image() == 'x.png'
-        assert fe.podcast.itunes_is_closed_captioned()
-        assert fe.podcast.itunes_order() == 1
-        assert fe.podcast.itunes_subtitle() == 'x'
-        assert fe.podcast.itunes_summary() == 'x'
-
-        # 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)
-        assert author == ['Lars Kiesow']
-
-
-class TestExtensionGeo(unittest.TestCase):
-
-    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_geoEntryItems(self):
-        fe = self.fg.add_item()
-        fe.title('y')
-        fe.geo.point('42.36 -71.05')
-
-        assert fe.geo.point() == '42.36 -71.05'
-
-        # 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)
-        assert point == ['42.36 -71.05']
-
-
-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)
-                assert m() == [method]
-
-        self.fg.id('123')
-        assert self.fg.atom_str()
-        assert self.fg.rss_str()
-
-
-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')
-        assert fe.torrent.filename() == 'file.xy'
-        assert fe.torrent.infohash() == '123'
-        assert fe.torrent.contentlength() == '23'
-        assert fe.torrent.seeds() == '1'
-        assert fe.torrent.peers() == '2'
-        assert 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)
-        assert filename == ['file.xy']
-
-
-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)
-        assert url == ['file1.xy', 'file1.xy']
-
-        # There is one without a group
-        url = root.xpath('/rss/channel/item/media:content[1]/@url',
-                         namespaces=ns)
-        assert 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)
-        assert url == ['file1.xy', 'file1.xy']
-
-        fe.media.content(content=[], replace=True)
-        assert 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)
-        assert url == ['file1.xy', 'file1.xy']
-
-        # There is one without a group
-        url = root.xpath('/rss/channel/item/media:thumbnail[1]/@url',
-                         namespaces=ns)
-        assert 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)
-        assert url == ['file1.xy', 'file1.xy']
-
-        fe.media.thumbnail(thumbnail=[], replace=True)
-        assert fe.media.thumbnail() == []
diff --git a/tests/test_extensions/__init__.py b/tests/test_extensions/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_extensions/test_dc.py b/tests/test_extensions/test_dc.py
new file mode 100644
index 0000000..1623804
--- /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)
+                assert m() == [method]
+
+        self.fg.id('123')
+        assert self.fg.atom_str()
+        assert 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..6665a74
--- /dev/null
+++ b/tests/test_extensions/test_geo.py
@@ -0,0 +1,29 @@
+import unittest
+
+from lxml import etree
+
+from feedgen.feed import FeedGenerator
+
+
+class TestExtensionGeo(unittest.TestCase):
+
+    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_geoEntryItems(self):
+        fe = self.fg.add_item()
+        fe.title('y')
+        fe.geo.point('42.36 -71.05')
+
+        assert fe.geo.point() == '42.36 -71.05'
+
+        # 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)
+        assert point == ['42.36 -71.05']
diff --git a/tests/test_extensions/test_media.py b/tests/test_extensions/test_media.py
new file mode 100644
index 0000000..7fd9e40
--- /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)
+        assert url == ['file1.xy', 'file1.xy']
+
+        # There is one without a group
+        url = root.xpath('/rss/channel/item/media:content[1]/@url',
+                         namespaces=ns)
+        assert 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)
+        assert url == ['file1.xy', 'file1.xy']
+
+        fe.media.content(content=[], replace=True)
+        assert 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)
+        assert url == ['file1.xy', 'file1.xy']
+
+        # There is one without a group
+        url = root.xpath('/rss/channel/item/media:thumbnail[1]/@url',
+                         namespaces=ns)
+        assert 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)
+        assert url == ['file1.xy', 'file1.xy']
+
+        fe.media.thumbnail(thumbnail=[], replace=True)
+        assert 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..a41c96c
--- /dev/null
+++ b/tests/test_extensions/test_podcast.py
@@ -0,0 +1,96 @@
+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)
+        assert cat[0] == 'Technology'
+        assert 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)
+        assert cat[0] == 'Technology'
+        assert 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')
+        assert fg.podcast.itunes_author() == 'Lars Kiesow'
+        assert fg.podcast.itunes_block() == 'x'
+        assert fg.podcast.itunes_complete() == 'no'
+        assert fg.podcast.itunes_explicit() == 'no'
+        assert fg.podcast.itunes_image() == 'x.png'
+        assert fg.podcast.itunes_subtitle() == 'x'
+        assert fg.podcast.itunes_summary() == 'x'
+
+        # 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)
+        assert 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')
+        assert fe.podcast.itunes_author() == 'Lars Kiesow'
+        assert fe.podcast.itunes_block() == 'x'
+        assert fe.podcast.itunes_duration() == '00:01:30'
+        assert fe.podcast.itunes_explicit() == 'no'
+        assert fe.podcast.itunes_image() == 'x.png'
+        assert fe.podcast.itunes_is_closed_captioned()
+        assert fe.podcast.itunes_order() == 1
+        assert fe.podcast.itunes_subtitle() == 'x'
+        assert fe.podcast.itunes_summary() == 'x'
+
+        # 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)
+        assert 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..7a187d7
--- /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)
+            assert 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)
+            assert 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)
+        assert 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..e996fde
--- /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')
+        assert fe.torrent.filename() == 'file.xy'
+        assert fe.torrent.infohash() == '123'
+        assert fe.torrent.contentlength() == '23'
+        assert fe.torrent.seeds() == '1'
+        assert fe.torrent.peers() == '2'
+        assert 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)
+        assert filename == ['file.xy']

From 8cd50bf768def7e50754496e7ed48a533ec38252 Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 8 Jul 2019 14:58:21 +1000
Subject: [PATCH 5/8] Add unit tests for simple GeoRSS

Also fix a couple of bugs that came up during testing - mostly making
sure that elevation, floor and radius are actually set as strings in
the XML
---
 feedgen/ext/geo_entry.py          |  20 +-
 tests/test_extensions/test_geo.py | 347 +++++++++++++++++++++++++++++-
 2 files changed, 353 insertions(+), 14 deletions(-)

diff --git a/feedgen/ext/geo_entry.py b/feedgen/ext/geo_entry.py
index e57fc81..03e8f41 100644
--- a/feedgen/ext/geo_entry.py
+++ b/feedgen/ext/geo_entry.py
@@ -114,15 +114,15 @@ class GeoEntryExtension(BaseEntryExtension):
 
         if self.__elev:
             elevation = etree.SubElement(entry, '{%s}elev' % GEO_NS)
-            elevation.text = self.__elev
+            elevation.text = str(self.__elev)
 
         if self.__floor:
             floor = etree.SubElement(entry, '{%s}floor' % GEO_NS)
-            floor.text = self.__floor
+            floor.text = str(self.__floor)
 
         if self.__radius:
             radius = etree.SubElement(entry, '{%s}radius' % GEO_NS)
-            radius.text = self.__radius
+            radius.text = str(self.__radius)
 
         return entry
 
@@ -178,7 +178,7 @@ class GeoEntryExtension(BaseEntryExtension):
 
         return self.__box
 
-    def featuretypetag(self, featuretypetag):
+    def featuretypetag(self, featuretypetag=None):
         '''
         Get or set the georss:featuretypetag of the entry
 
@@ -190,7 +190,7 @@ class GeoEntryExtension(BaseEntryExtension):
 
         return self.__featuretypetag
 
-    def relationshiptag(self, relationshiptag):
+    def relationshiptag(self, relationshiptag=None):
         '''
         Get or set the georss:relationshiptag of the entry
 
@@ -202,11 +202,11 @@ class GeoEntryExtension(BaseEntryExtension):
 
         return self.__relationshiptag
 
-    def featurename(self, featurename):
+    def featurename(self, featurename=None):
         '''
         Get or set the georss:featurename of the entry
 
-        :param featuretypetag: The GeoRSS featurename (e.g. "city")
+        :param featuretypetag: The GeoRSS featurename (e.g. "Footscray")
         :return: the current georss:featurename
         '''
         if featurename is not None:
@@ -214,7 +214,7 @@ class GeoEntryExtension(BaseEntryExtension):
 
         return self.__featurename
 
-    def elev(self, elev):
+    def elev(self, elev=None):
         '''
         Get or set the georss:elev of the entry
 
@@ -230,7 +230,7 @@ class GeoEntryExtension(BaseEntryExtension):
 
         return self.__elev
 
-    def floor(self, floor):
+    def floor(self, floor=None):
         '''
         Get or set the georss:floor of the entry
 
@@ -246,7 +246,7 @@ class GeoEntryExtension(BaseEntryExtension):
 
         return self.__floor
 
-    def radius(self, radius):
+    def radius(self, radius=None):
         '''
         Get or set the georss:radius of the entry
 
diff --git a/tests/test_extensions/test_geo.py b/tests/test_extensions/test_geo.py
index 6665a74..3855bf4 100644
--- a/tests/test_extensions/test_geo.py
+++ b/tests/test_extensions/test_geo.py
@@ -1,12 +1,104 @@
 import unittest
+import warnings
 
 from lxml import etree
 
 from feedgen.feed import FeedGenerator
+from feedgen.ext.geo_entry import GeoRSSPolygonInteriorWarning, GeoRSSGeometryError
+
+
+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')
@@ -14,16 +106,263 @@ class TestExtensionGeo(unittest.TestCase):
         self.fg.link(href='http://example.com', rel='self')
         self.fg.description('description')
 
-    def test_geoEntryItems(self):
+    def test_point(self):
         fe = self.fg.add_item()
         fe.title('y')
-        fe.geo.point('42.36 -71.05')
+        fe.geo.point(str(self.point))
 
-        assert fe.geo.point() == '42.36 -71.05'
+        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)
-        assert point == ['42.36 -71.05']
+        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)])
+
+    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)])
+
+    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)])
+
+    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
+            assert len(w) == 1
+            assert 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)])

From b02278e536f09d19ceb93de0e196a00d06bb4af9 Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 8 Jul 2019 15:16:20 +1000
Subject: [PATCH 6/8] Fix a really dumb formatting issue for the geom_interface

Use the old formatting tag instead of the new when creating geom text
from the geo_interface. Tests updated as well
---
 feedgen/ext/geo_entry.py          | 6 +++---
 tests/test_extensions/test_geo.py | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/feedgen/ext/geo_entry.py b/feedgen/ext/geo_entry.py
index 03e8f41..2fcc409 100644
--- a/feedgen/ext/geo_entry.py
+++ b/feedgen/ext/geo_entry.py
@@ -294,7 +294,7 @@ class GeoEntryExtension(BaseEntryExtension):
 
         if geojson['type'] == 'Point':
 
-            coords = '%f %f'.format(
+            coords = '{:f} {:f}'.format(
                 geojson['coordinates'][1],  # latitude is y
                 geojson['coordinates'][0]
             )
@@ -303,7 +303,7 @@ class GeoEntryExtension(BaseEntryExtension):
         elif geojson['type'] == 'LineString':
 
             coords = ' '.join(
-                '%f %f'.format(vertex[1], vertex[0])
+                '{:f} {:f}'.format(vertex[1], vertex[0])
                 for vertex in
                 geojson['coordinates']
             )
@@ -315,7 +315,7 @@ class GeoEntryExtension(BaseEntryExtension):
                 warnings.warn(GeoRSSPolygonInteriorWarning(geom))
 
             coords = ' '.join(
-                '%f %f'.format(vertex[1], vertex[0])
+                '{:f} {:f}'.format(vertex[1], vertex[0])
                 for vertex in
                 geojson['coordinates'][0]
             )
diff --git a/tests/test_extensions/test_geo.py b/tests/test_extensions/test_geo.py
index 3855bf4..35dfa84 100644
--- a/tests/test_extensions/test_geo.py
+++ b/tests/test_extensions/test_geo.py
@@ -26,7 +26,7 @@ class Geom(object):
     def __str__(self):
         if self.geom_type == 'Point':
 
-            coords = '%f %f'.format(
+            coords = '{:f} {:f}'.format(
                 self.coords[1],  # latitude is y
                 self.coords[0]
             )
@@ -35,7 +35,7 @@ class Geom(object):
         elif self.geom_type == 'LineString':
 
             coords = ' '.join(
-                '%f %f'.format(vertex[1], vertex[0])
+                '{:f} {:f}'.format(vertex[1], vertex[0])
                 for vertex in
                 self.coords
             )
@@ -44,7 +44,7 @@ class Geom(object):
         elif self.geom_type == 'Polygon':
 
             coords = ' '.join(
-                '%f %f'.format(vertex[1], vertex[0])
+                '{:f} {:f}'.format(vertex[1], vertex[0])
                 for vertex in
                 self.coords[0]
             )
@@ -54,7 +54,7 @@ class Geom(object):
             # box not really supported by GeoJSON, but it's a handy cheat here
             # for testing
             coords = ' '.join(
-                '%f %f'.format(vertex[1], vertex[0])
+                '{:f} {:f}'.format(vertex[1], vertex[0])
                 for vertex in
                 self.coords
             )

From 9586e7bcf18de04d1d6b436340b11b7ea2f59609 Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 8 Jul 2019 15:39:33 +1000
Subject: [PATCH 7/8] Add a unit test to confirm all coordinates

Make sure that all the required coordinates are in the GeoRSS string,
to avoid the mistake made earlier.
---
 tests/test_extensions/test_geo.py | 56 +++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/tests/test_extensions/test_geo.py b/tests/test_extensions/test_geo.py
index 35dfa84..01990a6 100644
--- a/tests/test_extensions/test_geo.py
+++ b/tests/test_extensions/test_geo.py
@@ -1,3 +1,4 @@
+from itertools import chain
 import unittest
 import warnings
 
@@ -296,6 +297,21 @@ class TestExtensionGeo(unittest.TestCase):
                            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,
+                list(chain.from_iterable(self.point.coords))
+            )
+
+
+
     def test_geom_from_geointerface_line(self):
         fe = self.fg.add_item()
         fe.title('y')
@@ -310,6 +326,20 @@ class TestExtensionGeo(unittest.TestCase):
                           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')
@@ -324,6 +354,19 @@ class TestExtensionGeo(unittest.TestCase):
                           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')
@@ -366,3 +409,16 @@ class TestExtensionGeo(unittest.TestCase):
         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]))
+            )

From 66f8bdb45ec6973efca3c712678a88a4ef020a2e Mon Sep 17 00:00:00 2001
From: Henry Walshaw <henry.walshaw@gmail.com>
Date: Mon, 29 Jul 2019 10:24:02 +1000
Subject: [PATCH 8/8] Fix errors from make test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

One Python 2.7 error in the test (didn’t work for points)

Also fixed all the formatting errors raised by flake8
---
 feedgen/ext/geo_entry.py          | 43 ++++++++++++++++++++-----------
 tests/test_extensions/test_geo.py | 35 ++++++++++++++-----------
 2 files changed, 48 insertions(+), 30 deletions(-)

diff --git a/feedgen/ext/geo_entry.py b/feedgen/ext/geo_entry.py
index 2fcc409..2ad6611 100644
--- a/feedgen/ext/geo_entry.py
+++ b/feedgen/ext/geo_entry.py
@@ -30,8 +30,9 @@ class GeoRSSPolygonInteriorWarning(Warning):
 
     def __str__(self):
         return '{:d} interiors of polygon ignored'.format(
-            len(self.geom.__geo_interface__['coordinates']) - 1  # ignore exterior in count
-        )
+            len(self.geom.__geo_interface__['coordinates']) - 1
+        )  # ignore exterior in count
+
 
 class GeoRSSGeometryError(ValueError):
     """
@@ -39,7 +40,6 @@ class GeoRSSGeometryError(ValueError):
 
     Only some geometries are supported in Simple GeoRSS, so if not raise an
     error. Offending geometry is stored on the ``geom`` attribute.
-
     """
 
     def __init__(self, geom, *args, **kwargs):
@@ -47,7 +47,8 @@ class GeoRSSGeometryError(ValueError):
         super(GeoRSSGeometryError, self).__init__(*args, **kwargs)
 
     def __str__(self):
-        return "Geometry of type '{}' not in Point, Linestring or Polygon".format(
+        msg = "Geometry of type '{}' not in Point, Linestring or Polygon"
+        return msg.format(
             self.geom.__geo_interface__['type']
         )
 
@@ -101,11 +102,17 @@ class GeoEntryExtension(BaseEntryExtension):
             box.text = self.__box
 
         if self.__featuretypetag:
-            featuretypetag = etree.SubElement(entry, '{%s}featuretypetag' % GEO_NS)
+            featuretypetag = etree.SubElement(
+                entry,
+                '{%s}featuretypetag' % GEO_NS
+            )
             featuretypetag.text = self.__featuretypetag
 
         if self.__relationshiptag:
-            relationshiptag = etree.SubElement(entry, '{%s}relationshiptag' % GEO_NS)
+            relationshiptag = etree.SubElement(
+                entry,
+                '{%s}relationshiptag' % GEO_NS
+            )
             relationshiptag.text = self.__relationshiptag
 
         if self.__featurename:
@@ -147,7 +154,8 @@ class GeoEntryExtension(BaseEntryExtension):
     def line(self, line=None):
         '''Get or set the georss:line of the entry
 
-        :param point: The GeoRSS formatted line (i.e. "45.256 -110.45 46.46 -109.48 43.84 -109.86")
+        :param point: The GeoRSS formatted line (i.e. "45.256 -110.45 46.46
+                      -109.48 43.84 -109.86")
         :return: The current georss:line of the entry
         '''
         if line is not None:
@@ -158,7 +166,8 @@ class GeoEntryExtension(BaseEntryExtension):
     def polygon(self, polygon=None):
         '''Get or set the georss:polygon of the entry
 
-        :param polygon: The GeoRSS formatted polygon (i.e. "45.256 -110.45 46.46 -109.48 43.84 -109.86 45.256 -110.45")
+        :param polygon: The GeoRSS formatted polygon (i.e. "45.256 -110.45
+                        46.46 -109.48 43.84 -109.86 45.256 -110.45")
         :return: The current georss:polygon of the entry
         '''
         if polygon is not None:
@@ -170,7 +179,8 @@ class GeoEntryExtension(BaseEntryExtension):
         '''
         Get or set the georss:box of the entry
 
-        :param box: The GeoRSS formatted box (i.e. "42.943 -71.032 43.039 -69.856")
+        :param box: The GeoRSS formatted box (i.e. "42.943 -71.032 43.039
+                    -69.856")
         :return: The current georss:box of the entry
         '''
         if box is not None:
@@ -194,7 +204,8 @@ class GeoEntryExtension(BaseEntryExtension):
         '''
         Get or set the georss:relationshiptag of the entry
 
-        :param relationshiptag: The GeoRSS relationshiptag (e.g. "is-centred-at")
+        :param relationshiptag: The GeoRSS relationshiptag (e.g.
+                                "is-centred-at")
         :return: the current georss:relationshiptag
         '''
         if relationshiptag is not None:
@@ -256,7 +267,9 @@ class GeoEntryExtension(BaseEntryExtension):
         '''
         if radius is not None:
             if not isinstance(radius, numbers.Number):
-                raise ValueError("radius tag must be numeric: {}".format(radius))
+                raise ValueError(
+                    "radius tag must be numeric: {}".format(radius)
+                )
 
             self.__radius = radius
 
@@ -268,13 +281,13 @@ class GeoEntryExtension(BaseEntryExtension):
         ``__geo_interface__`` property (see the `geo_interface specification by
         Sean Gillies`_geointerface )
 
-        Note only a subset of GeoJSON (see `geojson.org`_geojson ) can be easily
-        converted to GeoRSS:
+        Note only a subset of GeoJSON (see `geojson.org`_geojson ) can be
+        easily converted to GeoRSS:
 
         - Point
         - LineString
-        - Polygon (if there are holes / donuts in the polygons a warning will be
-          generaated
+        - Polygon (if there are holes / donuts in the polygons a warning will
+          be generaated
 
         Other GeoJson types will raise a ``ValueError``.
 
diff --git a/tests/test_extensions/test_geo.py b/tests/test_extensions/test_geo.py
index 01990a6..6dd401b 100644
--- a/tests/test_extensions/test_geo.py
+++ b/tests/test_extensions/test_geo.py
@@ -5,7 +5,7 @@ import warnings
 from lxml import etree
 
 from feedgen.feed import FeedGenerator
-from feedgen.ext.geo_entry import GeoRSSPolygonInteriorWarning, GeoRSSGeometryError
+from feedgen.ext.geo_entry import GeoRSSPolygonInteriorWarning, GeoRSSGeometryError  # noqa: E501
 
 
 class Geom(object):
@@ -78,19 +78,22 @@ class TestExtensionGeo(unittest.TestCase):
     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.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
+                [  # exterior
                     [0, 0],
                     [0, 1],
                     [1, 1],
                     [1, 0],
                     [0, 0]
                 ],
-                [ # interior
+                [  # interior
                     [0.25, 0.25],
                     [0.25, 0.75],
                     [0.75, 0.75],
@@ -131,8 +134,10 @@ class TestExtensionGeo(unittest.TestCase):
         # 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)
+        line = root.xpath(
+            '/rss/channel/item/georss:line/text()',
+            namespaces=ns
+        )
         self.assertEqual(line, [str(self.line)])
 
     def test_polygon(self):
@@ -145,8 +150,10 @@ class TestExtensionGeo(unittest.TestCase):
         # 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)
+        poly = root.xpath(
+            '/rss/channel/item/georss:polygon/text()',
+            namespaces=ns
+        )
         self.assertEqual(poly, [str(self.polygon)])
 
     def test_box(self):
@@ -159,8 +166,10 @@ class TestExtensionGeo(unittest.TestCase):
         # 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)
+        box = root.xpath(
+            '/rss/channel/item/georss:box/text()',
+            namespaces=ns
+        )
         self.assertEqual(box, [str(self.box)])
 
     def test_featuretypetag(self):
@@ -307,11 +316,9 @@ class TestExtensionGeo(unittest.TestCase):
         except AttributeError:  # was assertItemsEqual in Python 2.7
             self.assertItemsEqual(
                 coords,
-                list(chain.from_iterable(self.point.coords))
+                self.point.coords
             )
 
-
-
     def test_geom_from_geointerface_line(self):
         fe = self.fg.add_item()
         fe.title('y')
@@ -339,7 +346,6 @@ class TestExtensionGeo(unittest.TestCase):
                 list(chain.from_iterable(self.line.coords))
             )
 
-
     def test_geom_from_geointerface_poly(self):
         fe = self.fg.add_item()
         fe.title('y')
@@ -381,7 +387,6 @@ class TestExtensionGeo(unittest.TestCase):
         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