def get_or_create_root():
    """
    Returns the root article, or creates it if it doesn't exist.
    """
    try:
        root = URLPath.root()
        if not root.article:
            root.delete()
            raise NoRootURL
        return root
    except NoRootURL:
        pass

    starting_content = "\n".join((
        _("Welcome to the {platform_name} Wiki").format(platform_name=get_themed_value('PLATFORM_NAME',
                                                                                       settings.PLATFORM_NAME)),
        "===",
        _("Visit a course wiki to add an article."),
    ))

    root = URLPath.create_root(title=_("Wiki"), content=starting_content)
    article = root.article
    article.group = None
    article.group_read = True
    article.group_write = False
    article.other_read = True
    article.other_write = False
    article.save()

    return root

    def test_manager(self):

        root = URLPath.create_root()
        child = URLPath.create_article(root, "child")

        self.assertEqual(root.parent, None)
        self.assertEqual(list(root.children.all().active()), [child])

def get_or_create_root():
    """
    Returns the root article, or creates it if it doesn't exist.
    """
    try:
        root = URLPath.root()
        if not root.article:
            root.delete()
            raise NoRootURL
        return root
    except NoRootURL:
        pass

    starting_content = "\n".join((
    "Welcome to the edX Wiki",
    "===",
    "Visit a course wiki to add an article."))

    root = URLPath.create_root(title="Wiki",
                        content=starting_content)
    article = root.article
    article.group = None
    article.group_read = True
    article.group_write = False
    article.other_read = True
    article.other_write = False
    article.save()

    return root

 def get_class(self, el):
     href = el.get("href")
     if not href:
         return
     # The autolinker turns email links into links with many HTML entities.
     # These entities are further escaped using markdown-specific codes.
     # First unescape the markdown-specific, then use html.unescape.
     href = AndSubstitutePostprocessor().run(href)
     href = html.unescape(href)
     try:
         url = urlparse(href)
     except ValueError:
         return
     if url.scheme == "mailto":
         return
     if url.scheme or url.netloc or url.path.startswith("/"):
         # Contains a hostname or is an absolute link => external
         return self.external_class
     # Ensure that path ends with a slash
     relpath = url.path.rstrip("/") + "/"
     target = urljoin_internal(self.my_urlpath.path, relpath)
     if target is None:
         # Relative path goes outside wiki URL space => external
         return self.external_class
     try:
         URLPath.get_by_path(target)
     except URLPath.DoesNotExist:
         return self.broken_class
     return self.internal_class

 def setUp(self):
     super(RequireRootArticleMixin, self).setUp()
     self.root = URLPath.create_root()
     self.root_article = URLPath.root().article
     rev = self.root_article.current_revision
     rev.title = "Root Article"
     rev.content = "root article content"
     rev.save()

 def get_article(self, cont):
     urlpath = URLPath.create_urlpath(
         URLPath.root(),
         "html_attach",
         title="TestAttach",
         content=cont
     )
     self._create_test_attachment(urlpath.path)
     return urlpath.article.render()

 def get_article(self, cont, image):
     urlpath = URLPath.create_urlpath(
         URLPath.root(),
         "html_image",
         title="TestImage",
         content=cont
     )
     if image:
         self._create_test_image(urlpath.path)
     return urlpath.article.render()

 def test_works_with_lazy_functions(self):
     URLPath.create_root()
     config = (
         ('base_url', reverse_lazy('wiki:get', kwargs={'path': ''})),
     )
     md = markdown.Markdown(
         extensions=['extra', WikiPathExtension(config)]
     )
     text = '[Français](wiki:/fr)'
     self.assertEqual(
         md.convert(text),
         '<p><a class="wikipath linknotfound" href="/fr">Français</a></p>',
     )

 def test_edit_save(self):
     old_revision = URLPath.root().article.current_revision
     self.get_url('wiki:edit', path='')
     self.fill({
         '#id_content': 'Something 2',
         '#id_summary': 'why edited',
         '#id_title': 'wiki test'
     })
     self.submit('#id_save')
     self.assertTextPresent('Something 2')
     self.assertTextPresent('successfully added')
     new_revision = URLPath.root().article.current_revision
     self.assertIn('Something 2', new_revision.content)
     self.assertEqual(new_revision.revision_number, old_revision.revision_number + 1)

    def test_revision_conflict(self):
        """
        Test the warning if the same article is being edited concurrently.
        """

        example_data = {
            'content': 'More modifications',
            'current_revision': str(URLPath.root().article.current_revision.id),
            'preview': '0',
            'save': '1',
            'summary': 'why edited',
            'title': 'wiki test'
        }

        response = self.client.post(
            resolve_url('wiki:edit', path=''),
            example_data
        )

        self.assertRedirects(response, resolve_url('wiki:root'))

        response = self.client.post(
            resolve_url('wiki:edit', path=''),
            example_data
        )

        self.assertContains(
            response,
            'While you were editing, someone else changed the revision.'
        )

    def test_html_removal(self):

        urlpath = URLPath.create_article(
            self.root,
            'html_removal',
            title="Test 1",
            content="</html>only_this"
        )

        self.assertEqual(urlpath.article.render(), "<p>&lt;/html&gt;only_this</p>")

    def setUp(self):
        """Test setup."""
        self.wiki = get_or_create_root()

        self.course_math101 = CourseFactory.create(org='edx', number='math101', display_name='2014', metadata={'use_unique_wiki_id': 'false'})
        self.course_math101_instructor = InstructorFactory(course_key=self.course_math101.id, username='instructor', password='secret')
        self.wiki_math101 = URLPath.create_article(self.wiki, 'math101', title='math101')

        self.client = Client()
        self.client.login(username='instructor', password='secret')

    def create(cls, user, regional_level, title, question, topics, organisation=None):
        try:
            root_path = URLPath.objects.get(parent_id=None)
        except Exception:
            pass
        else:
            # Construct arguments
            user_regional_levels = {
                '1': user.personalid.municipality,
                '2': user.personalid.province,
                '3': user.personalid.country
            }
            regional_name = user_regional_levels[regional_level]
            slug = str(regional_level) + '_' + regional_name + '_' + slugify(title)
            content = '# Context\r\n# Consequences\r\n'
            user_message = 'Initiated \'{}\''.format(title)
            article_kwargs = {
                'owner': user,
                'group': None,
                'group_read': True,
                'group_write': False,
                'other_read': False,
                'other_write': False
            }
            # Make new wiki URLPath
            new_url_path = URLPath.create_article(root_path,
                                                  slug,
                                                  title=title,
                                                  article_kwargs=article_kwargs,
                                                  content=content,
                                                  user_message=user_message,
                                                  user=user)
            new_url_path.save()

            try:
                # Make new ConstructionProposal
                construction_proposal = cls(regional_level=regional_level,
                                            regional_name=regional_name,
                                            title=title,
                                            slug=slug,
                                            question=question,
                                            creator=user,
                                            organisation=organisation,
                                            wiki=new_url_path)
                construction_proposal.save()
            except Exception:
                pass
            else:
                # Add topics
                construction_proposal.topics.add(*topics)

                # Return partially saved instance
                return construction_proposal
        return None

def get_urlpath(course_id):
    """Returns url path of root wiki page for course."""
    # Offical edX way to replace slashes by dots: course_key.replace('/', '.')
    course_key = CourseKey.from_string(course_id)
    course = get_course_by_id(course_key)
    course_slug = course_wiki_slug(course)
    try:
        urlpath = URLPath.get_by_path(course_slug)
    except URLPath.DoesNotExist:
        urlpath = None
    return urlpath

 def test_preview_and_save(self):
     self.get_url('wiki:edit', path='')
     self.fill({
         '#id_content': 'Some changed stuff',
         '#id_summary': 'why edited',
         '#id_title': 'wiki test'
     })
     self.click('#id_preview')
     self.submit('#id_preview_save_changes')
     new_revision = URLPath.root().article.current_revision
     self.assertIn("Some changed stuff", new_revision.content)

    def setUp(self):

        super(ArticleWebTestBase, self).setUp()

        response = self.c.post(
            reverse('wiki:root_create'),
            {'content': 'root article content', 'title': 'Root Article'},
            follow=True
        )

        self.assertEqual(response.status_code, 200)  # sanity check
        self.root_article = URLPath.root().article

    def setUp(self):
        """Test setup."""
        self.wiki = get_or_create_root()

        self.course_math101 = CourseFactory.create(
            org="edx", number="math101", display_name="2014", metadata={"use_unique_wiki_id": "false"}
        )
        self.course_math101_instructor = InstructorFactory(
            course=self.course_math101.location, username="instructor", password="secret"
        )
        self.wiki_math101 = URLPath.create_article(self.wiki, "math101", title="math101")

        self.client = Client()
        self.client.login(username="instructor", password="secret")

 def setUp(self):
     super(ArticleTestBase, self).setUp()
     response = self.c.post(
         reverse('wiki:root_create'),
         {'content': 'root article content', 'title': 'Root Article'},
         follow=True)
     self.assertEqual(response.status_code, 200)  # sanity check
     self.root_article = URLPath.root().article
     self.example_data = {
         'content': 'The modified text',
         'current_revision': '1',
         'preview': '1',
         # 'save': '1',  # probably not too important
         'summary': 'why edited',
         'title': 'wiki test'}

    def test_article_list_update(self):
        """
        Test automatic adding and removing the new article to/from article_list.
        """

        root_data = {
            'content': '[article_list depth:2]',
            'current_revision': str(URLPath.root().article.current_revision.id),
            'preview': '1',
            'title': 'Root Article'
        }

        response = self.client.post(resolve_url('wiki:edit', path=''), root_data)
        self.assertRedirects(response, resolve_url('wiki:root'))

        # verify the new article is added to article_list
        response = self.client.post(
            resolve_url('wiki:create', path=''),
            {'title': 'Sub Article 1', 'slug': 'SubArticle1'}
        )

        self.assertRedirects(
            response,
            resolve_url('wiki:get', path='subarticle1/')
        )
        self.assertContains(self.get_by_path(''), 'Sub Article 1')
        self.assertContains(self.get_by_path(''), 'subarticle1/')

        # verify the deleted article is removed from article_list
        response = self.client.post(
            resolve_url('wiki:delete', path='SubArticle1/'),
            {'confirm': 'on',
             'purge': 'on',
             'revision': str(URLPath.objects.get(slug='subarticle1').article.current_revision.id),
             }
        )

        message = getattr(self.client.cookies['messages'], 'value')

        self.assertRedirects(
            response,
            resolve_url('wiki:get', path='')
        )
        self.assertIn(
            'This article together with all '
            'its contents are now completely gone',
            message)
        self.assertNotContains(self.get_by_path(''), 'Sub Article 1')

    def setUp(self):
        super(TestAttachmentManagementCommands, self).setUp()

        self.test_file = tempfile.NamedTemporaryFile('w', delete=False, suffix=".txt")
        self.test_file.write("test")

        self.child1 = URLPath.create_urlpath(self.root, 'test-slug', title="Test 1")

        self.attachment1 = models.Attachment.objects.create(
            article=self.child1.article
        )

        self.attachment1_revision1 = models.AttachmentRevision.objects.create(
            attachment=self.attachment1,
            file=self.test_file.name,
        )