Python tests.document函数代码示例

    def test_deferred_translation(self):
        """Verify a translation with only a deferred revision appears."""
        d = document(title='Foo', save=True)
        untranslated = revision(is_approved=True,
                                is_ready_for_localization=True,
                                document=d,
                                save=True)

        # There should be 1.
        eq_(1, len(self.titles(locale='es')))

        translation = document(
            parent=untranslated.document, locale='es', save=True)
        deferred = revision(is_approved=False,
                            reviewed=datetime.now(),
                            document=translation,
                            save=True)

        # There should still be 1.
        eq_(1, len(self.titles(locale='es')))

        # Mark that rev as approved and there should then be 0.
        deferred.is_approved = True
        deferred.save()
        eq_(0, len(self.titles(locale='es')))

    def test_category_inheritance(self):
        """A document's categories must always be those of its parent."""
        some_category = CATEGORIES[1][0]
        other_category = CATEGORIES[0][0]

        # Notice if somebody ever changes the default on the category field,
        # which would invalidate our test:
        assert some_category != document().category

        parent = document(category=some_category)
        parent.save()
        child = document(parent=parent, locale='de')
        child.save()

        # Make sure child sees stuff set on parent:
        eq_(some_category, child.category)

        # Child'd category should revert to parent's on save:
        child.category = other_category
        child.save()
        eq_(some_category, child.category)

        # Changing the parent category should change the child's:
        parent.category = other_category

        parent.save()
        eq_(other_category,
            parent.translations.get(locale=child.locale).category)

    def test_good_visit_count(self):
        """Extract visit counts from good data.

        It has some nasty non-ASCII chars in it.

        """
        d = document(slug="hellỗ")
        d.save()
        d2 = document(slug="there")
        d2.save()
        # We get a str, not a unicode obj, out of the urllib call.
        eq_(
            {d.pk: 1037639, d2.pk: 213817},
            WikiDocumentVisits._visit_counts(
                '{"data": {"12/01/2010-12/07/2010": {"SubRows":{'
                '"http://support.mozilla.com/%s/kb/hellỗ":{"Attributes":{"Title":'
                '"Firefox Support Home Page | Firefox Support","UrlLink":'
                '"http://support.mozilla.com/en-US/home/"},"measures":'
                '{"Visits":1037639.0,"Views":3357731.0,"Average Time Viewed":23.0'
                '},"SubRows":null},"http://support.mozilla.com/%s/kb/there":'
                '{"Attributes":{"Title":"Startseite der Firefox-Hilfe | Firefox'
                'Support","UrlLink":"http://support.mozilla.com/de/home/"},'
                '"measures":{"Visits":213817.0,"Views":595329.0,"Average Time '
                'Viewed":25.0},"SubRows":null}}}}}' % ((settings.LANGUAGE_CODE,) * 2)
            ),
        )

    def test_old_revisions(self):
        """Bug 862436. Updating old revisions could cause bad WLH data."""
        d1 = document(title='D1', save=True)
        revision(document=d1, content='', is_approved=True, save=True)
        d2 = document(title='D2', save=True)
        revision(document=d2, content='', is_approved=True, save=True)

        # Make D3, then make a revision that links to D1, then a
        # revision that links to D2. Only the link to D2 should count.
        d3 = document(title='D3', save=True)
        r3_old = revision(document=d3, content='[[D1]]', is_approved=True,
                          save=True)
        r3_new = revision(document=d3, content='[[D2]]', is_approved=True,
                          save=True)

        # This could cause stale data
        r3_old.content_parsed

        # D1 is not linked to in any current revisions.
        eq_(len(d1.links_to()), 0)
        eq_(len(d1.links_from()), 0)
        eq_(len(d2.links_to()), 1)
        eq_(len(d2.links_from()), 0)
        eq_(len(d3.links_to()), 0)
        eq_(len(d3.links_from()), 1)

    def test_search_suggestions_archived_articles(self):
        """Verifies that archived articles aren't shown."""
        topic(title='Fix problems', slug='fix-problems', save=True)
        p = product(slug=u'firefox', save=True)

        d1 = document(title=u'document donut', category=10, save=True)
        d1.products.add(p)
        revision(document=d1, is_approved=True, save=True)

        d2 = document(title=u'document cupcake', category=10, is_archived=True,
                      save=True)
        d2.products.add(p)
        revision(document=d1, is_approved=True, save=True)

        self.refresh()

        url = urlparams(
            reverse('questions.aaq_step4', args=['desktop', 'fix-problems']),
            search='document')

        response = self.client.get(url, follow=True)
        eq_(200, response.status_code)

        doc = pq(response.content)
        eq_(len(doc('.result.document')), 1)
        assert 'donut' in doc('.result.document h3 a').text()
        assert 'cupcake' not in doc('.result.document h3 a').text()

    def test_wiki_topics(self):
        """Search wiki for topics, includes multiple."""
        t1 = topic(slug='doesnotexist', save=True)
        t2 = topic(slug='extant', save=True)
        t3 = topic(slug='tagged', save=True)

        doc = document(locale=u'en-US', category=10, save=True)
        doc.topics.add(t2)
        revision(document=doc, is_approved=True, save=True)

        doc = document(locale=u'en-US', category=10, save=True)
        doc.topics.add(t2)
        doc.topics.add(t3)
        revision(document=doc, is_approved=True, save=True)

        self.refresh()

        topic_vals = (
            (t1.slug, 0),
            (t2.slug, 2),
            (t3.slug, 1),
            ([t2.slug, t3.slug], 1),
        )

        qs = {'a': 1, 'w': 1, 'format': 'json'}
        for topics, number in topic_vals:
            qs.update({'topics': topics})
            response = self.client.get(reverse('search'), qs)
            eq_(number, json.loads(response.content)['total'])

    def test_update_l10n_metric_cron(self):
        """Verify the cron job creates the correct metric."""
        l10n_kind = metric_kind(code=L10N_METRIC_CODE, save=True)

        # Create the en-US document with an approved revision.
        doc = document(save=True)
        rev = revision(
            document=doc,
            is_approved=True,
            save=True)

        time.sleep(1)

        # Create an es translation
        es_doc = document(parent=doc, locale='es', save=True)
        revision(
            document=es_doc,
            is_approved=True,
            based_on=rev,
            save=True)

        # Run it and verify results.
        # Value should be 100%
        update_l10n_metric()
        metrics = Metric.objects.filter(kind=l10n_kind)
        eq_(1, len(metrics))
        eq_(100, metrics[0].value)

        # Update the en-US document
        rev2 = revision(
            document=doc,
            is_approved=True,
            save=True)

        # Run it and verify results.
        # Value should be 0%
        update_l10n_metric()
        metrics = Metric.objects.filter(kind=l10n_kind)
        eq_(1, len(metrics))
        eq_(0, metrics[0].value)

        time.sleep(1)

        # Create a pt-BR translation
        ptBR_doc = document(parent=doc, locale='pt-BR', save=True)
        revision(
            document=ptBR_doc,
            is_approved=True,
            based_on=rev,
            save=True)

        # Run it and verify results.
        # Value should be 50%
        update_l10n_metric()
        metrics = Metric.objects.filter(kind=l10n_kind)
        eq_(1, len(metrics))
        eq_(50, metrics[0].value)

 def _create_en_and_de_docs(self):
     en = settings.WIKI_DEFAULT_LANGUAGE
     en_doc = document(locale=en, slug='english-slug')
     en_doc.save()
     de_doc = document(locale='de', parent=en_doc)
     de_doc.save()
     de_rev = revision(document=de_doc, is_approved=True)
     de_rev.save()
     return en_doc, de_doc

    def test_only_localizable_allowed_children(self):
        """You can't have children for a non-localizable document."""
        # Make English rev:
        en_doc = document(is_localizable=False)
        en_doc.save()

        # Make Deutsch translation:
        de_doc = document(parent=en_doc, locale='de')
        self.assertRaises(ValidationError, de_doc.save)

    def test_what_links_here_locale_filtering(self):
        d1 = document(title='D1', save=True, locale='de')
        revision(document=d1, content='', is_approved=True, save=True)
        d2 = document(title='D2', save=True, locale='fr')
        revision(document=d2, content='[[D1]]', is_approved=True, save=True)

        url = reverse('wiki.what_links_here', args=[d1.slug], locale='de')
        resp = self.client.get(url, follow=True)
        eq_(200, resp.status_code)
        assert 'No other documents link to D1.' in resp.content

    def test_what_links_here(self):
        d1 = document(title='D1', save=True)
        revision(document=d1, content='', is_approved=True, save=True)
        d2 = document(title='D2', save=True)
        revision(document=d2, content='[[D1]]', is_approved=True, save=True)

        url = reverse('wiki.what_links_here', args=[d1.slug])
        resp = self.client.get(url, follow=True)
        eq_(200, resp.status_code)
        assert 'D2' in resp.content

 def test_indirect_recursion(self):
     """Make sure indirect recursion is caught."""
     boo = document(title="Template:Boo")
     boo.save()
     yah = document(title="Template:Yah")
     yah.save()
     revision(document=boo, content="Paper [[Template:Yah]] Cups", is_approved=True).save()
     revision(document=yah, content="Wooden [[Template:Boo]] Bats", is_approved=True).save()
     recursion_message = RECURSION_MESSAGE % "Template:Boo"
     eq_("<p>Paper Wooden %s Bats\n Cups\n</p>" % recursion_message, boo.content_parsed)

    def test_cannot_make_non_localizable_if_children(self):
        """You can't make a document non-localizable if it has children."""
        # Make English rev:
        en_doc = document(is_localizable=True)
        en_doc.save()

        # Make Deutsch translation:
        de_doc = document(parent=en_doc, locale='de')
        de_doc.save()
        en_doc.is_localizable = False
        self.assertRaises(ValidationError, en_doc.save)

 def test_new_doc_does_not_update_categories(self):
     """Make sure that creating a new document doesn't change the
     category of all the other documents."""
     d1 = document(category=10)
     d1.save()
     assert d1.pk
     d2 = document(category=00)
     assert not d2.pk
     d2._clean_category()
     d1prime = Document.objects.get(pk=d1.pk)
     eq_(10, d1prime.category)

 def test_template_locale(self):
     """Localized template is returned."""
     py_doc, p = doc_parse_markup("English content", "[[Template:test]]")
     parent = document()
     d = document(parent=parent, title="Template:test", locale="fr")
     d.save()
     r = revision(content="French content", document=d, is_approved=True)
     r.save()
     eq_("English content", py_doc.text())
     py_doc = pq(p.parse("[[T:test]]", locale="fr"))
     eq_("French content", py_doc.text())