Merge lp:~developer-ubuntu-com-dev/developer-ubuntu-com/hero-tour-changes into lp:developer-ubuntu-com

[Daniel Holbach]

[lp:~developer-ubuntu-com-dev/developer-ubuntu-com/hero-tour-changes]

219. By David Callé on 2016-03-08

Add first iteration of the snappy hero tour

220. By Daniel Holbach on 2016-03-09

fix unicode craziness

221. By Daniel Holbach on 2016-03-09

extend db_add_empty_page do you can define your own slug

222. By Daniel Holbach on 2016-03-10

add tests for hero tour IA

223. By Daniel Holbach on 2016-03-21

merge trunk

224. By Daniel Holbach on 2016-03-22

merge trunk

225. By Daniel Holbach on 2016-03-22

adapt url expectation to a crash David was seeing

226. By Daniel Holbach on 2016-03-22

make pep8/pyflakes happy

227. By Daniel Holbach on 2016-03-22

apply fix from David - thanks

Unmerged revisions

=== modified file 'md_importer/importer/__init__.py'
--- md_importer/importer/__init__.py	2016-01-12 11:44:04 +0000
+++ md_importer/importer/__init__.py	2016-03-08 13:25:48 +0000
@@ -1,5 +1,23 @@
 from developer_portal.settings import LANGUAGE_CODE
 
+from md_importer.models import ExternalDocsBranchImportDirective
+
 DEFAULT_LANG = LANGUAGE_CODE
 HOME_PAGE_URL = '/{}/'.format(DEFAULT_LANG)
 SUPPORTED_ARTICLE_TYPES = ['.md', '.html']
+
+# Instead of just using pymdownx.github, we go with these because of
+# https://github.com/facelessuser/pymdown-extensions/issues/11
+MARKDOWN_EXTENSIONS = [
+    'markdown.extensions.tables',
+    'pymdownx.magiclink',
+    'pymdownx.betterem',
+    'pymdownx.tilde',
+    'pymdownx.githubemoji',
+    'pymdownx.tasklist',
+    'pymdownx.superfences',
+]
+
+model_info = ExternalDocsBranchImportDirective._meta
+TEMPLATE_CHOICES = model_info.get_field('template').choices
+DEFAULT_TEMPLATE = model_info.get_field('template').default

=== modified file 'md_importer/importer/article.py'
--- md_importer/importer/article.py	2016-01-15 13:56:34 +0000
+++ md_importer/importer/article.py	2016-03-08 13:25:48 +0000
@@ -8,9 +8,10 @@
 
 from . import (
     DEFAULT_LANG,
+    MARKDOWN_EXTENSIONS,
     SUPPORTED_ARTICLE_TYPES,
 )
-from .publish import get_or_create_page, slugify
+from .publish import get_or_create_page, slugify, update_page
 
 if sys.version_info.major == 2:
     from urlparse import urlparse
@@ -19,7 +20,7 @@
 
 
 class Article:
-    def __init__(self, fn, write_to):
+    def __init__(self, fn, write_to, advertise, template):
         self.html = None
         self.page = None
         self.title = ""
@@ -27,18 +28,20 @@
         self.write_to = slugify(self.fn)
         self.full_url = write_to
         self.slug = os.path.basename(self.full_url)
+        self.links_rewritten = False
+        self.local_images = []
+        self.advertise = advertise
+        self.template = template
 
     def _find_local_images(self):
         '''Local images are currently not supported.'''
         soup = BeautifulSoup(self.html, 'html5lib')
-        local_images = []
         for img in soup.find_all('img'):
             if img.has_attr('src'):
                 (scheme, netloc, path, params, query, fragment) = \
                     urlparse(img.attrs['src'])
                 if scheme not in ['http', 'https']:
-                    local_images.extend([img.attrs['src']])
-        return local_images
+                    self.local_images.extend([img.attrs['src']])
 
     def read(self):
         if os.path.splitext(self.fn)[1] not in SUPPORTED_ARTICLE_TYPES:
@@ -50,13 +53,13 @@
                 self.html = markdown.markdown(
                     f.read(),
                     output_format='html5',
-                    extensions=['pymdownx.github'])
+                    extensions=MARKDOWN_EXTENSIONS)
             elif self.fn.endswith('.html'):
                 self.html = f.read()
-        local_images = self._find_local_images()
-        if local_images:
+        self._find_local_images()
+        if self.local_images:
             logging.error('Found the following local image(s): {}'.format(
-                ', '.join(local_images)
+                ', '.join(self.local_images)
             ))
             return False
         self.title = self._read_title()
@@ -73,10 +76,15 @@
         return slugify(self.fn).replace('-', ' ').title()
 
     def _remove_body_and_html_tags(self):
-        self.html = re.sub(r"<html>\n\s<body>\n", "", self.html,
-                           flags=re.MULTILINE)
-        self.html = re.sub(r"\s<\/body>\n<\/html>", "", self.html,
-                           flags=re.MULTILINE)
+        for regex in [
+            # These are added by markdown.markdown
+            r'\s*<html>\s*<body>\s*',
+            r'\s*<\/body>\s*<\/html>\s*',
+            # This is added by BeautifulSoup.prettify
+            r'\s*<html>\s*<head>\s*<\/head>\s*<body>\s*',
+        ]:
+            self.html = re.sub(regex, '', self.html,
+                               flags=re.MULTILINE)
 
     def _use_developer_site_style(self):
         begin = (u"<div class=\"row no-border\">"
@@ -92,7 +100,6 @@
 
     def replace_links(self, titles, url_map):
         soup = BeautifulSoup(self.html, 'html5lib')
-        change = False
         for link in soup.find_all('a'):
             if not link.has_attr('class') or \
                'headeranchor-link' not in link.attrs['class']:
@@ -100,25 +107,35 @@
                     if title.endswith(link.attrs['href']) and \
                        link.attrs['href'] != url_map[title].full_url:
                         link.attrs['href'] = url_map[title].full_url
-                        change = True
-        if change:
+                        if not link.attrs['href'].startswith('/'):
+                            link.attrs['href'] = '/' + link.attrs['href']
+                        self.links_rewritten = True
+        if self.links_rewritten:
             self.html = soup.prettify()
-        return change
+            self._remove_body_and_html_tags()
 
     def add_to_db(self):
         '''Publishes pages in their branch alias namespace.'''
         self.page = get_or_create_page(
             title=self.title, full_url=self.full_url, menu_title=self.title,
-            html=self.html)
+            html=self.html, in_navigation=self.advertise,
+            template=self.template)
         if not self.page:
             return False
-        self.full_url = self.page.get_absolute_url()
+        self.full_url = re.sub(
+            r'^\/None\/', '/{}/'.format(DEFAULT_LANG),
+            self.page.get_absolute_url())
         return True
 
     def publish(self):
+        if self.links_rewritten:
+            update_page(self.page, title=self.title, full_url=self.full_url,
+                        menu_title=self.title, html=self.html,
+                        in_navigation=self.advertise, template=self.template)
         if self.page.is_dirty(DEFAULT_LANG):
             self.page.publish(DEFAULT_LANG)
-            self.page = self.page.get_public_object()
+            if self.page.get_public_object():
+                self.page = self.page.get_public_object()
         return self.page
 
 
@@ -128,14 +145,16 @@
     def read(self):
         if not Article.read(self):
             return False
-        self.release_alias = re.findall(r'snappy/guides/(\S+?)/\S+?',
-                                        self.full_url)[0]
+        matches = re.findall(r'snappy/guides/(\S+?)/\S+?',
+                             self.full_url)
+        if matches:
+            self.release_alias = matches[0]
         self._make_snappy_mods()
         return True
 
     def _make_snappy_mods(self):
         # Make sure the reader knows which documentation she is browsing
-        if self.release_alias != 'current':
+        if self.release_alias and self.release_alias != 'current':
             before = (u"<div class=\"row no-border\">\n"
                       "<div class=\"eight-col\">\n")
             after = (u"<div class=\"row no-border\">\n"
@@ -158,6 +177,6 @@
                 redirect="/snappy/guides/current/{}".format(self.slug))
             if not page:
                 return False
-        else:
+        elif self.release_alias:
             self.title += " (%s)" % (self.release_alias,)
         return Article.add_to_db(self)

=== modified file 'md_importer/importer/process.py'
--- md_importer/importer/process.py	2016-01-16 00:36:39 +0000
+++ md_importer/importer/process.py	2016-03-08 13:25:48 +0000
@@ -22,7 +22,9 @@
     for directive in ExternalDocsBranchImportDirective.objects.filter(
             external_docs_branch=branch):
         repo.add_directive(directive.import_from,
-                           directive.write_to)
+                           directive.write_to,
+                           directive.advertise,
+                           directive.template)
     if not repo.execute_import_directives():
         return False
     if not repo.publish():

=== modified file 'md_importer/importer/publish.py'
--- md_importer/importer/publish.py	2016-01-15 13:58:39 +0000
+++ md_importer/importer/publish.py	2016-03-08 13:25:48 +0000
@@ -1,14 +1,25 @@
-from md_importer.importer import DEFAULT_LANG, HOME_PAGE_URL
+from md_importer.importer import (
+    DEFAULT_LANG,
+    DEFAULT_TEMPLATE,
+    HOME_PAGE_URL,
+)
 
 from cms.api import create_page, add_plugin
 from cms.models import Title
 from djangocms_text_ckeditor.html import clean_html
 
+from bs4 import BeautifulSoup
 import logging
 import re
 import os
 
 
+def _compare_html(html_a, html_b):
+    soup_a = BeautifulSoup(html_a, 'html5lib')
+    soup_b = BeautifulSoup(html_b, 'html5lib')
+    return (clean_html(soup_a.prettify()) == clean_html(soup_b.prettify()))
+
+
 def slugify(filename):
     return os.path.basename(filename).replace('.md', '').replace('.html', '')
 
@@ -32,44 +43,72 @@
     return parent_pages[0].page
 
 
+def find_text_plugin(page):
+    # We create the page, so we know there's just one placeholder
+    placeholder = page.placeholders.all()[0]
+    if placeholder.get_plugins():
+        return (
+            placeholder,
+            placeholder.get_plugins()[0].get_plugin_instance()[0]
+        )
+    return (placeholder, None)
+
+
+def update_page(page, title, full_url, menu_title=None,
+                in_navigation=True, redirect=None, html=None, template=None):
+    if page.get_title() != title:
+        page.title = title
+    if page.get_menu_title() != menu_title:
+        page.menu_title = menu_title
+    if page.in_navigation != in_navigation:
+        page.in_navigation = in_navigation
+    if page.get_redirect() != redirect:
+        page.redirect = redirect
+    if page.template != template:
+        page.template = template
+    if html:
+        update = True
+        (placeholder, plugin) = find_text_plugin(page)
+        if plugin:
+            if _compare_html(html, plugin.body):
+                update = False
+            elif page.get_public_object():
+                (dummy, published_plugin) = \
+                    find_text_plugin(page.get_public_object())
+                if published_plugin:
+                    if _compare_html(html, published_plugin.body):
+                        update = False
+            if update:
+                plugin.body = html
+                plugin.save()
+            else:
+                # Reset draft
+                page.get_draft_object().revert(DEFAULT_LANG)
+        else:
+            add_plugin(
+                placeholder, 'RawHtmlPlugin',
+                DEFAULT_LANG, body=html)
+
+
 def get_or_create_page(title, full_url, menu_title=None,
-                       in_navigation=True, redirect=None, html=None):
+                       in_navigation=True, redirect=None, html=None,
+                       template=DEFAULT_TEMPLATE):
     # First check if pages already exist.
     pages = Title.objects.select_related('page').filter(
         path__regex=full_url).filter(publisher_is_draft=True)
     if pages:
         page = pages[0].page
-        if page.get_title() != title:
-            page.title = title
-        if page.get_menu_title() != menu_title:
-            page.menu_title = menu_title
-        if page.in_navigation != in_navigation:
-            page.in_navigation = in_navigation
-        if page.get_redirect() != redirect:
-            page.redirect = redirect
-        if html:
-            # We create the page, so we know there's just one placeholder
-            placeholder = page.placeholders.all()[0]
-            if placeholder.get_plugins():
-                plugin = placeholder.get_plugins()[0].get_plugin_instance()[0]
-                if plugin.body != clean_html(html, full=False):
-                    plugin.body = html
-                    plugin.save()
-            else:
-                add_plugin(
-                    placeholder, 'RawHtmlPlugin',
-                    DEFAULT_LANG, body=html)
+        update_page(page, title, full_url, menu_title, in_navigation,
+                    redirect, html, template)
     else:
         parent = _find_parent(full_url)
         if not parent:
             return None
         slug = os.path.basename(full_url)
         page = create_page(
-            title, 'default.html', DEFAULT_LANG, slug=slug, parent=parent,
-            menu_title=menu_title, in_navigation=in_navigation,
+            title=title, template=template, language=DEFAULT_LANG, slug=slug,
+            parent=parent, menu_title=menu_title, in_navigation=in_navigation,
             position='last-child', redirect=redirect)
-        placeholder = page.placeholders.get()
+        placeholder = page.placeholders.all()[0]
         add_plugin(placeholder, 'RawHtmlPlugin', DEFAULT_LANG, body=html)
-        placeholder = page.placeholders.all()[0]
-        plugin = placeholder.get_plugins()[0].get_plugin_instance()[0]
     return page

=== modified file 'md_importer/importer/repo.py'
--- md_importer/importer/repo.py	2016-01-15 18:54:50 +0000
+++ md_importer/importer/repo.py	2016-03-08 13:25:48 +0000
@@ -6,6 +6,8 @@
 from .publish import get_or_create_page, slugify
 from .source import SourceCode
 
+from md_importer.models import ExternalDocsBranchImportDirective
+
 import glob
 import logging
 import os
@@ -56,12 +58,18 @@
             return 1
         return 0
 
-    def add_directive(self, import_from, write_to):
+    def add_directive(self, import_from, write_to, advertise=True,
+                      template=None):
+        if template is None:
+            model_info = ExternalDocsBranchImportDirective._meta
+            template = model_info.get_field('template').default
         self.directives += [
             {
                 'import_from': os.path.join(self.checkout_location,
                                             import_from),
-                'write_to': write_to
+                'write_to': write_to,
+                'advertise': advertise,
+                'template': template,
             }
         ]
 
@@ -71,7 +79,8 @@
         for directive in [d for d in self.directives
                           if os.path.isfile(d['import_from'])]:
             import_list += [
-                (directive['import_from'], directive['write_to'])
+                (directive['import_from'], directive['write_to'],
+                 directive['advertise'], directive['template'])
             ]
         # Import directories next
         for directive in [d for d in self.directives
@@ -79,7 +88,8 @@
             for fn in glob.glob('{}/*'.format(directive['import_from'])):
                 if fn not in [a[0] for a in import_list]:
                     import_list += [
-                        (fn, os.path.join(directive['write_to'], slugify(fn)))
+                        (fn, os.path.join(directive['write_to'], slugify(fn)),
+                         directive['advertise'], directive['template'])
                     ]
             # If we import into a namespace and don't have an index doc,
             # we need to write one.
@@ -91,7 +101,8 @@
                 return False
         # The actual import
         for entry in import_list:
-            article = self._read_article(entry[0], entry[1])
+            article = self._read_article(
+                entry[0], entry[1], entry[2], entry[3])
             if article:
                 self.imported_articles += [article]
                 self.titles[article.fn] = article.title
@@ -106,8 +117,8 @@
             self._write_fake_index_doc()
         return True
 
-    def _read_article(self, fn, write_to):
-        article = self.article_class(fn, write_to)
+    def _read_article(self, fn, write_to, advertise, template):
+        article = self.article_class(fn, write_to, advertise, template)
         if article.read():
             return article
         return None
@@ -118,7 +129,6 @@
                 logging.error('Publishing of {} aborted.'.format(self.origin))
                 return False
             article.replace_links(self.titles, self.url_map)
-        self.pages = []
         for article in self.imported_articles:
             self.pages.extend([article.publish()])
         if self.index_page:

=== added file 'md_importer/migrations/0002_hero_tour_changes.py'
--- md_importer/migrations/0002_hero_tour_changes.py	1970-01-01 00:00:00 +0000
+++ md_importer/migrations/0002_hero_tour_changes.py	2016-03-08 13:25:48 +0000
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('md_importer', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='externaldocsbranchimportdirective',
+            name='advertise',
+            field=models.BooleanField(default=True, help_text='Should the imported articles be listed in the navigation? Default: yes.'),
+        ),
+        migrations.AddField(
+            model_name='externaldocsbranchimportdirective',
+            name='template',
+            field=models.CharField(default=b'default.html', help_text='Django CMS template to use for the imported articles. Default: default.html', max_length=50, choices=[(b'default.html', b'Default'), (b'landing_page.html', b'Landing Page'), (b'no_subnav.html', b'Without Subnav'), (b'with_hero.html', b'With Hero')]),
+        ),
+    ]

=== modified file 'md_importer/models.py'
--- md_importer/models.py	2016-01-11 08:10:08 +0000
+++ md_importer/models.py	2016-03-08 13:25:48 +0000
@@ -1,9 +1,18 @@
+from django.conf import settings
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 
 from cms.models import Page
 
 
+if settings.CMS_TEMPLATES:
+    cms_templates = settings.CMS_TEMPLATES
+else:
+    cms_templates = (
+        ('default.html', 'Default'),
+    )
+
+
 class ExternalDocsBranch(models.Model):
     origin = models.CharField(
         max_length=200,
@@ -43,6 +52,18 @@
         help_text=_('Article URL (for a specific file) or article namespace '
                     'for a directory or a set of files.'),
         blank=True)
+    advertise = models.BooleanField(
+        default=True,
+        help_text=_('Should the imported articles be listed in the '
+                    'navigation? Default: yes.'),
+    )
+    template = models.CharField(
+        max_length=50,
+        default=cms_templates[0][0],
+        choices=cms_templates,
+        help_text=_('Django CMS template to use for the imported articles. '
+                    'Default: {}'.format(cms_templates[0][0])),
+    )
 
     def __str__(self):
         return "{} -- {}".format(self.external_docs_branch,

=== modified file 'md_importer/tests/test_branch_import.py'
--- md_importer/tests/test_branch_import.py	2016-01-15 13:59:32 +0000
+++ md_importer/tests/test_branch_import.py	2016-03-08 13:25:48 +0000
@@ -2,9 +2,15 @@
 import pytz
 import shutil
 
-from cms.models import CMSPlugin, Page
+from cms.models import Page
 
+from md_importer.importer import (
+    DEFAULT_TEMPLATE,
+    TEMPLATE_CHOICES,
+)
 from md_importer.importer.article import Article
+from md_importer.importer.publish import find_text_plugin
+
 from .utils import TestLocalBranchImport
 
 
@@ -66,6 +72,71 @@
                 self.assertEqual(page.parent_id, self.root.id)
 
 
+class TestArticleHTMLTagsAfterImport(TestLocalBranchImport):
+    def runTest(self):
+        self.create_repo('data/snapcraft-test')
+        self.repo.add_directive('docs', '')
+        self.assertEqual(len(self.repo.directives), 1)
+        self.assertTrue(self.repo.execute_import_directives())
+        self.assertGreater(len(self.repo.imported_articles), 3)
+        self.assertTrue(self.repo.publish())
+        pages = Page.objects.all()
+        self.assertGreater(pages.count(), len(self.repo.imported_articles))
+        for article in self.repo.imported_articles:
+            self.assertIsInstance(article, Article)
+            self.assertNotIn('<body>', article.html)
+            self.assertNotIn('&lt;body&gt;', article.html)
+
+
+class TestNoneInURLAfterImport(TestLocalBranchImport):
+    def runTest(self):
+        self.create_repo('data/snapcraft-test')
+        self.repo.add_directive('docs', '')
+        self.assertEqual(len(self.repo.directives), 1)
+        self.assertTrue(self.repo.execute_import_directives())
+        self.assertGreater(len(self.repo.imported_articles), 3)
+        self.assertTrue(self.repo.publish())
+        pages = Page.objects.all()
+        self.assertGreater(pages.count(), len(self.repo.imported_articles))
+        for article in self.repo.imported_articles:
+            self.assertIsInstance(article, Article)
+            self.assertNotIn('/None/', article.full_url)
+        for page in pages:
+            self.assertIsNotNone(page.get_slug())
+
+
+class TestAdvertiseImport(TestLocalBranchImport):
+    '''Check if all imported articles are advertised in the navigation when
+       using defaults.'''
+    def runTest(self):
+        self.create_repo('data/snapcraft-test')
+        self.repo.add_directive('docs', '')
+        self.assertTrue(self.repo.execute_import_directives())
+        for article in self.repo.imported_articles:
+            self.assertTrue(article.advertise)
+        self.assertTrue(self.repo.publish())
+        for page in Page.objects.filter(publisher_is_draft=False):
+            if page.parent is not None:
+                self.assertEqual(page.parent_id, self.root.id)
+                self.assertTrue(page.in_navigation)
+
+
+class TestNoAdvertiseImport(TestLocalBranchImport):
+    '''Check if all imported articles are advertised in the navigation when
+       using defaults.'''
+    def runTest(self):
+        self.create_repo('data/snapcraft-test')
+        self.repo.add_directive('docs', '', advertise=False)
+        self.assertTrue(self.repo.execute_import_directives())
+        for article in self.repo.imported_articles:
+            self.assertFalse(article.advertise)
+        self.assertTrue(self.repo.publish())
+        for page in Page.objects.filter(publisher_is_draft=False):
+            if page.parent is not None:
+                self.assertEqual(page.parent_id, self.root.id)
+                self.assertFalse(page.in_navigation)
+
+
 class TestTwiceImport(TestLocalBranchImport):
     '''Run import on the same contents twice, make sure we don't
        add new pages over and over again.'''
@@ -101,9 +172,9 @@
         self.assertEqual(
             Page.objects.filter(publisher_is_draft=False).count(),
             len(self.repo.imported_articles)+1)  # articles + root
+        shutil.rmtree(self.tempdir)
         # Take the time before publishing the second import
         now = datetime.now(pytz.utc)
-        shutil.rmtree(self.tempdir)
         # Run second import
         self.create_repo('data/snapcraft-test')
         self.repo.add_directive('docs', '')
@@ -112,7 +183,36 @@
         self.assertTrue(self.repo.execute_import_directives())
         self.assertTrue(self.repo.publish())
         # Check the page's plugins
-        for plugin_change in CMSPlugin.objects.filter(
-            plugin_type='RawHtmlPlugin').order_by(
-                '-changed_date'):
-            self.assertGreater(now, plugin_change.changed_date)
+        for page in Page.objects.filter(publisher_is_draft=False):
+            if page != self.root:
+                (dummy, plugin) = find_text_plugin(page)
+                self.assertGreater(now, plugin.changed_date)
+
+
+class TestImportNoTemplateChange(TestLocalBranchImport):
+    '''Check if all imported articles use the default template.'''
+    def runTest(self):
+        self.create_repo('data/snapcraft-test')
+        self.repo.add_directive('docs', '')
+        self.assertTrue(self.repo.execute_import_directives())
+        for article in self.repo.imported_articles:
+            self.assertEqual(article.template, DEFAULT_TEMPLATE)
+        self.assertTrue(self.repo.publish())
+        for page in Page.objects.filter(publisher_is_draft=False):
+            if page.parent is not None:
+                self.assertEqual(page.template, DEFAULT_TEMPLATE)
+
+
+class TestImportTemplateChange(TestLocalBranchImport):
+    '''Check if all imported articles use the desired template.'''
+    def runTest(self):
+        self.create_repo('data/snapcraft-test')
+        template_to_use = TEMPLATE_CHOICES[1][0]
+        self.repo.add_directive('docs', '', template=template_to_use)
+        self.assertTrue(self.repo.execute_import_directives())
+        for article in self.repo.imported_articles:
+            self.assertEqual(article.template, template_to_use)
+        self.assertTrue(self.repo.publish())
+        for page in Page.objects.filter(publisher_is_draft=False):
+            if page.parent is not None:
+                self.assertEqual(page.template, template_to_use)

=== modified file 'md_importer/tests/test_link_rewrite.py'
--- md_importer/tests/test_link_rewrite.py	2016-01-11 14:38:51 +0000
+++ md_importer/tests/test_link_rewrite.py	2016-03-08 13:25:48 +0000
@@ -30,6 +30,11 @@
                         link.attrs['href'],
                         ', '.join([p.get_absolute_url() for p in pages])))
                 self.assertIn(page, pages)
+            if article.slug == 'file1':
+                for link in soup.find_all('a'):
+                    if not link.has_attr('class') or \
+                       'headeranchor-link' not in link.attrs['class']:
+                        self.assertEqual(link.attrs['href'], '/file2')
 
 
 class TestLinkBrokenRewrite(TestLocalBranchImport):
@@ -45,12 +50,33 @@
             self.assertEqual(article.page.parent, self.root)
             soup = BeautifulSoup(article.html, 'html5lib')
             for link in soup.find_all('a'):
-                if link.has_attr('class') and \
-                   'headeranchor-link' in link.attrs['class']:
-                    break
-                page = self.check_local_link(link.attrs['href'])
-                self.assertIsNone(page)
-                self.assertNotIn(page, pages)
+                if not link.has_attr('class') or \
+                   'headeranchor-link' not in link.attrs['class']:
+                    page = self.check_local_link(link.attrs['href'])
+                    self.assertIsNone(page)
+                    self.assertNotIn(page, pages)
+
+
+class TestNoneNotInLinks(TestLocalBranchImport):
+    def runTest(self):
+        self.create_repo('data/snapcraft-test')
+        snappy_page = db_add_empty_page('Snappy', self.root)
+        self.assertFalse(snappy_page.publisher_is_draft)
+        build_apps = db_add_empty_page('Build Apps', snappy_page)
+        self.assertFalse(build_apps.publisher_is_draft)
+        self.assertEqual(
+            3, Page.objects.filter(publisher_is_draft=False).count())
+        self.repo.add_directive('docs/intro.md', 'snappy/build-apps/current')
+        self.repo.add_directive('docs', 'snappy/build-apps/current')
+        self.assertTrue(self.repo.execute_import_directives())
+        self.assertTrue(self.repo.publish())
+        for article in self.repo.imported_articles:
+            self.assertTrue(isinstance(article, Article))
+            self.assertGreater(len(article.html), 0)
+            soup = BeautifulSoup(article.html, 'html5lib')
+            for link in soup.find_all('a'):
+                if is_local_link(link):
+                    self.assertFalse(link.attrs['href'].startswith('/None/'))
 
 
 class TestSnapcraftLinkRewrite(TestLocalBranchImport):
@@ -62,25 +88,21 @@
         self.assertFalse(build_apps.publisher_is_draft)
         self.assertEqual(
             3, Page.objects.filter(publisher_is_draft=False).count())
-        self.repo.add_directive('docs', 'snappy/build-apps/devel')
-        self.repo.add_directive('README.md', 'snappy/build-apps/devel')
-        self.repo.add_directive(
-            'HACKING.md', 'snappy/build-apps/devel/hacking')
+        self.repo.add_directive('docs/intro.md', 'snappy/build-apps/current')
+        self.repo.add_directive('docs', 'snappy/build-apps/current')
         self.assertTrue(self.repo.execute_import_directives())
         self.assertTrue(self.repo.publish())
         pages = Page.objects.all()
         for article in self.repo.imported_articles:
             self.assertTrue(isinstance(article, Article))
             self.assertGreater(len(article.html), 0)
-        for article in self.repo.imported_articles:
             soup = BeautifulSoup(article.html, 'html5lib')
             for link in soup.find_all('a'):
-                if not is_local_link(link):
-                    break
-                page = self.check_local_link(link.attrs['href'])
-                self.assertIsNotNone(
-                    page,
-                    msg='Link {} not found. Available pages: {}'.format(
-                        link.attrs['href'],
-                        ', '.join([p.get_absolute_url() for p in pages])))
-                self.assertIn(page, pages)
+                if is_local_link(link):
+                    page = self.check_local_link(link.attrs['href'])
+                    self.assertIsNotNone(
+                        page,
+                        msg='Link {} not found. Available pages: {}'.format(
+                            link.attrs['href'],
+                            ', '.join([p.get_absolute_url() for p in pages])))
+                    self.assertIn(page, pages)

=== modified file 'md_importer/tests/utils.py'
--- md_importer/tests/utils.py	2016-01-11 14:38:51 +0000
+++ md_importer/tests/utils.py	2016-03-08 13:25:48 +0000
@@ -55,8 +55,10 @@
         self.assertEqual(self.fetch_retcode, 0)
 
     def check_local_link(self, url):
+        if not url.startswith('/'):
+            url = '/' + url
         if not url.startswith('/{}/'.format(DEFAULT_LANG)):
-            url = '/{}/{}/'.format(DEFAULT_LANG, url)
+            url = '/{}'.format(DEFAULT_LANG) + url
         request = self.get_request(url)
         page = get_page_from_request(request)
         return page