Ticket #8995: django-sitemap-protocol.diff

django/contrib/sitemaps/__init__.py

@@ -40 +40 @@
     # http://sitemaps.org/protocol.php#index.
     limit = 50000
 
+    # If protocol is None, the sitemap's URLs will be constructed
+    # using the protocol with which the sitemap was requested.
+    protocol = None
+
     def __get(self, name, obj, default=None):
         try:
             attr = getattr(self, name)
@@ -71 +75 @@
             if site is None:
                 raise ImproperlyConfigured("In order to use Sitemaps you must either use the sites framework or pass in a Site or RequestSite object in your view code.")
 
+        if self.protocol is not None:
+            protocol = self.protocol
+        elif hasattr(self, 'request'):
+            protocol = self.request.is_secure() and 'https' or 'http'
+        else:
+            protocol = 'http'
+
         urls = []
         for item in self.paginator.page(page).object_list:
-            loc = "http://%s%s" % (site.domain, self.__get('location', item))
+            loc = "%s://%s%s" % (protocol, site.domain, self.__get('location', item))
             priority = self.__get('priority', item, None)
             url_info = {
                 'item':       item,

django/contrib/sitemaps/tests/__init__.py

@@ -1 +1 @@
 from django.contrib.sitemaps.tests.basic import *
+from django.contrib.sitemaps.tests.https import *

new file django/contrib/sitemaps/tests/https.py

@@ +1 @@
+import os
+from datetime import date
+from django.conf import settings
+from django.contrib.auth.models import User
+from django.contrib.sitemaps import Sitemap, GenericSitemap
+from django.contrib.sites.models import Site
+from django.core.exceptions import ImproperlyConfigured
+from django.test import TestCase
+from django.utils.unittest import skipUnless
+from django.utils.formats import localize
+from django.utils.translation import activate, deactivate
+
+
+class HTTPSSitemapTests(TestCase):
+    urls = 'django.contrib.sitemaps.tests.urls_https'
+
+    def setUp(self):
+        if Site._meta.installed:
+            self.base_url = 'https://example.com'
+        else:
+            self.base_url = 'https://testserver'
+        self.old_USE_L10N = settings.USE_L10N
+        self.old_Site_meta_installed = Site._meta.installed
+        self.old_TEMPLATE_DIRS = settings.TEMPLATE_DIRS
+        self.old_Site_meta_installed = Site._meta.installed
+        settings.TEMPLATE_DIRS = (
+            os.path.join(os.path.dirname(__file__), 'templates'),
+        )
+        # Create a user that will double as sitemap content
+        User.objects.create_user('testuser', 'test@example.com', 's3krit')
+
+    def tearDown(self):
+        settings.USE_L10N = self.old_USE_L10N
+        Site._meta.installed = self.old_Site_meta_installed
+        settings.TEMPLATE_DIRS = self.old_TEMPLATE_DIRS
+        Site._meta.installed = self.old_Site_meta_installed
+
+    def test_simple_sitemap_index(self):
+        "A simple sitemap index can be rendered"
+        # Retrieve the sitemap.
+        response = self.client.get('/simple/index.xml')
+        # Check for all the important bits:
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap>
+</sitemapindex>
+""" % self.base_url)
+
+    def test_simple_sitemap_custom_index(self):
+        "A simple sitemap index can be rendered with a custom template"
+        # Retrieve the sitemap.
+        response = self.client.get('/simple/custom-index.xml')
+        # Check for all the important bits:
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+<!-- This is a customised template -->
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap>
+</sitemapindex>
+""" % self.base_url)
+
+    def test_simple_sitemap(self):
+        "A simple sitemap can be rendered"
+        # Retrieve the sitemap.
+        response = self.client.get('/simple/sitemap.xml')
+        # Check for all the important bits:
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
+</urlset>
+""" % (self.base_url, date.today().strftime('%Y-%m-%d')))
+
+    def test_simple_custom_sitemap(self):
+        "A simple sitemap can be rendered with a custom template"
+        # Retrieve the sitemap.
+        response = self.client.get('/simple/custom-sitemap.xml')
+        # Check for all the important bits:
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+<!-- This is a customised template -->
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
+</urlset>
+""" % (self.base_url, date.today().strftime('%Y-%m-%d')))
+
+    @skipUnless(settings.USE_I18N, "Internationalization is not enabled")
+    def test_localized_priority(self):
+        "The priority value should not be localized (Refs #14164)"
+        # Localization should be active
+        settings.USE_L10N = True
+        activate('fr')
+        self.assertEqual(u'0,3', localize(0.3))
+
+        # Retrieve the sitemap. Check that priorities
+        # haven't been rendered in localized format
+        response = self.client.get('/simple/sitemap.xml')
+        self.assertContains(response, '<priority>0.5</priority>')
+        self.assertContains(response, '<lastmod>%s</lastmod>' % date.today().strftime('%Y-%m-%d'))
+        deactivate()
+
+    def test_generic_sitemap(self):
+        "A minimal generic sitemap can be rendered"
+        # Retrieve the sitemap.
+        response = self.client.get('/generic/sitemap.xml')
+
+        expected = ''
+        for username in User.objects.values_list("username", flat=True):
+            expected += "<url><loc>%s/users/%s/</loc></url>" % (self.base_url, username)
+        # Check for all the important bits:
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+%s
+</urlset>
+""" % expected)
+
+    @skipUnless("django.contrib.flatpages" in settings.INSTALLED_APPS, "django.contrib.flatpages app not installed.")
+    def test_flatpage_sitemap(self):
+        "Basic FlatPage sitemap test"
+
+        # Import FlatPage inside the test so that when django.contrib.flatpages
+        # is not installed we don't get problems trying to delete Site
+        # objects (FlatPage has an M2M to Site, Site.delete() tries to
+        # delete related objects, but the M2M table doesn't exist.
+        from django.contrib.flatpages.models import FlatPage
+
+        public = FlatPage.objects.create(
+            url=u'/public/',
+            title=u'Public Page',
+            enable_comments=True,
+            registration_required=False,
+        )
+        public.sites.add(settings.SITE_ID)
+        private = FlatPage.objects.create(
+            url=u'/private/',
+            title=u'Private Page',
+            enable_comments=True,
+            registration_required=True
+        )
+        private.sites.add(settings.SITE_ID)
+        response = self.client.get('/flatpages/sitemap.xml')
+        # Public flatpage should be in the sitemap
+        self.assertContains(response, '<loc>%s%s</loc>' % (self.base_url, public.url))
+        # Private flatpage should not be in the sitemap
+        self.assertNotContains(response, '<loc>%s%s</loc>' % (self.base_url, private.url))
+
+    def test_requestsite_sitemap(self):
+        # Make sure hitting the flatpages sitemap without the sites framework
+        # installed doesn't raise an exception
+        Site._meta.installed = False
+        # Retrieve the sitemap.
+        response = self.client.get('/simple/sitemap.xml')
+        # Check for all the important bits:
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<url><loc>https://testserver/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
+</urlset>
+""" % date.today().strftime('%Y-%m-%d'))
+
+    @skipUnless("django.contrib.sites" in settings.INSTALLED_APPS, "django.contrib.sites app not installed.")
+    def test_sitemap_get_urls_no_site_1(self):
+        """
+        Check we get ImproperlyConfigured if we don't pass a site object to
+        Sitemap.get_urls and no Site objects exist
+        """
+        Site.objects.all().delete()
+        self.assertRaises(ImproperlyConfigured, Sitemap().get_urls)
+
+    def test_sitemap_get_urls_no_site_2(self):
+        """
+        Check we get ImproperlyConfigured when we don't pass a site object to
+        Sitemap.get_urls if Site objects exists, but the sites framework is not
+        actually installed.
+        """
+        Site._meta.installed = False
+        self.assertRaises(ImproperlyConfigured, Sitemap().get_urls)
+
+    def test_sitemap_item(self):
+        """
+        Check to make sure that the raw item is included with each
+        Sitemap.get_url() url result.
+        """
+        user_sitemap = GenericSitemap({'queryset': User.objects.all()})
+        def is_user(url):
+            return isinstance(url['item'], User)
+        item_in_url_info = all(map(is_user, user_sitemap.get_urls()))
+        self.assertTrue(item_in_url_info)

new file django/contrib/sitemaps/tests/urls_https.py

@@ +1 @@
+from datetime import datetime
+from django.conf.urls.defaults import *
+from django.contrib.sitemaps import Sitemap, GenericSitemap, FlatPageSitemap
+from django.contrib.auth.models import User
+
+class HTTPSSimpleSitemap(Sitemap):
+    changefreq = "never"
+    priority = 0.5
+    location = '/location/'
+    lastmod = datetime.now()
+    protocol = 'https'
+
+    def items(self):
+        return [object()]
+
+class HTTPSGenericSitemap(GenericSitemap):
+    protocol = 'https'
+
+class HTTPSFlatPageSitemap(FlatPageSitemap):
+    protocol = 'https'
+
+simple_sitemaps = {
+    'simple': HTTPSSimpleSitemap,
+}
+
+generic_sitemaps = {
+    'generic': HTTPSGenericSitemap({
+        'queryset': User.objects.all()
+    }),
+}
+
+flatpage_sitemaps = {
+    'flatpages': HTTPSFlatPageSitemap,
+}
+
+urlpatterns = patterns('django.contrib.sitemaps.views',
+    (r'^simple/index\.xml$', 'index', {'sitemaps': simple_sitemaps}),
+    (r'^simple/custom-index\.xml$', 'index', {'sitemaps': simple_sitemaps, 'template_name': 'custom_sitemap_index.xml'}),
+    (r'^simple/sitemap-(?P<section>.+)\.xml$', 'sitemap', {'sitemaps': simple_sitemaps}),
+    (r'^simple/sitemap\.xml$', 'sitemap', {'sitemaps': simple_sitemaps}),
+    (r'^simple/custom-sitemap\.xml$', 'sitemap', {'sitemaps': simple_sitemaps, 'template_name': 'custom_sitemap.xml'}),
+    (r'^generic/sitemap\.xml$', 'sitemap', {'sitemaps': generic_sitemaps}),
+    (r'^flatpages/sitemap\.xml$', 'sitemap', {'sitemaps': flatpage_sitemaps}),
+)

django/contrib/sitemaps/views.py

@@ -9 +9 @@
         template_name='sitemap_index.xml', mimetype='application/xml'):
     current_site = get_current_site(request)
     sites = []
-    protocol = request.is_secure() and 'https' or 'http'
+    request_protocol = request.is_secure() and 'https' or 'http'
     for section, site in sitemaps.items():
-        site.request = request
         if callable(site):
-            pages = site().paginator.num_pages
+            site = site()
+        if site.protocol is not None:
+            protocol = site.protocol
         else:
-            pages = site.paginator.num_pages
+            protocol = request_protocol
+        site.request = request
+        pages = site.paginator.num_pages
         sitemap_url = urlresolvers.reverse('django.contrib.sitemaps.views.sitemap', kwargs={'section': section})
         sites.append('%s://%s%s' % (protocol, current_site.domain, sitemap_url))
         if pages > 1:
@@ -43 +46 @@
             raise Http404("Page %s empty" % page)
         except PageNotAnInteger:
             raise Http404("No page '%s'" % page)
-    return TemplateResponse(request, template_name, {'urlset': urls}, mimetype=mimetype)
- No newline at end of file
+    return TemplateResponse(request, template_name, {'urlset': urls}, mimetype=mimetype)

docs/ref/contrib/sitemaps.txt

@@ -161 +161 @@
         the ``get_absolute_url()`` method on each object as returned by
         :attr:`~Sitemap.items()`.
 
+        To specify a protocol other than http use
+        :attr:`~Sitemap.protocol` below.
+
     .. attribute:: Sitemap.lastmod
 
         **Optional.** Either a method or attribute.
@@ -193 +196 @@
             * ``'yearly'``
             * ``'never'``
 
+    .. attribute:: Sitemap.protocol
+
+        **Optional.** The protocol to use in the sitemap URLs.
+
+        If specified, the protocol attribute will be used to construct the
+        sitemap URLs. If not, the protocol with which the sitemap was
+        requested will be used. If the sitemap is built outside the context
+        of a request, the default is ``'http'``.
+
+        .. versionadded:: 1.4
+
+
     .. method:: Sitemap.priority
 
         **Optional.** Either a method or attribute.

docs/releases/1.4.txt

@@ -340 +340 @@
   be able to retrieve a translation string without displaying it but setting
   a template context variable instead.
 
+* The :doc:`Sitemaps <ref/contrib/sitemaps>` framework can now handle links
+  that use https protocol using the new class attribute
+  :attr:`Sitemap.protocol` attribute.
+
 .. _backwards-incompatible-changes-1.4:
 
 Backwards incompatible changes in 1.4