Beispiel #1
0
 def test_datetime(self):
     """Expects datetime format."""
     value_test = datetime.fromordinal(733900)
     value_expected = format_datetime(value_test, locale=u'en_US')
     value_returned = datetimeformat(self.context, value_test,
                                     format='datetime')
     eq_(pq(value_returned)('time').text(), value_expected)
Beispiel #2
0
    def test_zone_url_ends_with_slash(self):
        """Ensure urls only rewrite with a '/' at the end of url_root

        bug 1189596
        """
        zone_url_root = 'Firéfox'
        zone_root_content = 'This is the Firéfox zone'

        root_rev = revision(title='Firéfox', slug='Mozilla/Firéfox',
                            content=zone_root_content,
                            is_approved=True, save=True)
        root_doc = root_rev.document

        root_zone = DocumentZone(document=root_doc)
        root_zone.url_root = zone_url_root
        root_zone.save()

        none_zone_rev = revision(title='Firéfox for iOS',
                                 slug='Mozilla/Firéfox_for_iOS',
                                 content='Page outside zone with same prefix',
                                 is_approved=True, save=True)
        non_zone_doc = none_zone_rev.document
        non_zone_doc.save()

        url = '/en-US/docs/%s' % non_zone_doc.slug
        response = self.client.get(url, follow=False)
        eq_(200, response.status_code)
Beispiel #3
0
    def test_persona_signin_captcha(self):
        persona_signup_email = '*****@*****.**'
        persona_signup_username = '******'

        with mock.patch('requests.post') as requests_mock:
            requests_mock.return_value.json.return_value = {
                'status': 'okay',
                'email': persona_signup_email,
            }
            self.client.post(reverse('persona_login'), follow=True)

        data = {'website': '',
                'username': persona_signup_username,
                'email': persona_signup_email,
                'terms': True,
                'g-recaptcha-response': 'FAILED'}
        signup_url = reverse('socialaccount_signup',
                             locale=settings.WIKI_DEFAULT_LANGUAGE)

        with mock.patch('captcha.client.request') as request_mock:
            request_mock.return_value.read.return_value = '{"success": null}'
            response = self.client.post(signup_url, data=data, follow=True)
        eq_(response.status_code, 200)
        eq_(response.context['form'].errors,
            {'captcha': [u'Incorrect, please try again.']})
Beispiel #4
0
 def test_logged_in_argument(self):
     request = self.rf.get('/foo')
     request.user = self.user_model.objects.get(username='******')
     view = logout_required('/bar')(simple_view)
     response = view(request)
     eq_(302, response.status_code)
     eq_('/bar', response['location'])
Beispiel #5
0
 def test_locale_timezone_fields(self):
     """We've added locale and timezone fields. Verify defaults."""
     user = self.user_model.objects.get(username='******')
     ok_(hasattr(user, 'locale'))
     ok_(user.locale == 'en-US')
     ok_(hasattr(user, 'timezone'))
     eq_(user.timezone, 'US/Pacific')
Beispiel #6
0
 def test_my_user_edit(self):
     u = self.user_model.objects.get(username='******')
     self.client.login(username=u.username, password=TESTUSER_PASSWORD)
     resp = self.client.get(reverse('users.my_edit_page'))
     eq_(302, resp.status_code)
     ok_(reverse('users.user_edit', args=(u.username,)) in
         resp['Location'])
Beispiel #7
0
    def test_bug_709938_interests(self):
        testuser = self.user_model.objects.get(username='******')
        self.client.login(username=testuser.username,
                          password=TESTUSER_PASSWORD)

        url = reverse('users.user_edit', args=(testuser.username,))
        response = self.client.get(url, follow=True)
        doc = pq(response.content)

        test_tags = [u'science,Technology,paradox,knowledge,modeling,big data,'
                     u'vector,meme,heuristics,harmony,mathesis universalis,'
                     u'symmetry,mathematics,computer graphics,field,chemistry,'
                     u'religion,astronomy,physics,biology,literature,'
                     u'spirituality,Art,Philosophy,Psychology,Business,Music,'
                     u'Computer Science']

        form = self._get_current_form_field_values(doc)

        form['user-interests'] = test_tags

        response = self.client.post(url, form, follow=True)
        eq_(200, response.status_code)
        doc = pq(response.content)
        eq_(1, doc.find('ul.errorlist li').length)
        assert ('Ensure this value has at most 255 characters'
                in doc.find('ul.errorlist li').text())
Beispiel #8
0
    def test_pre_social_login_matched_login(self):
        """
        https://bugzil.la/1063830, happy path

        A user tries to sign in with GitHub, but their GitHub email matches
        an existing Persona-backed MDN account. They follow the prompt to login
        with Persona, and the accounts are connected.
        """

        # Set up a GitHub SocialLogin in the session
        github_account = SocialAccount.objects.get(user__username='******')
        github_login = SocialLogin(account=github_account,
                                   user=github_account.user)

        request = self.rf.get('/')
        session = self.client.session
        session['sociallogin_provider'] = 'github'
        session['socialaccount_sociallogin'] = github_login.serialize()
        session.save()
        request.session = session

        # Set up an matching Persona SocialLogin for request
        persona_account = SocialAccount.objects.create(
            user=github_account.user,
            provider='persona',
            uid=github_account.user.email)
        persona_login = SocialLogin(account=persona_account)

        # Verify the social_login receiver over-writes the provider
        # stored in the session
        self.adapter.pre_social_login(request, persona_login)
        session = request.session
        eq_(session['sociallogin_provider'], 'persona')
Beispiel #9
0
 def test_main_view(self):
     response = self.client.get(reverse('dashboards.revisions',
                                        locale='en-US'))
     eq_(200, response.status_code)
     ok_('text/html' in response['Content-Type'])
     ok_('dashboards/revisions.html' in
         [template.name for template in response.templates])
Beispiel #10
0
    def test_pre_social_login_same_provider(self):
        """
        pre_social_login passes if existing provider is the same.

        I'm not sure what the real-world counterpart of this is. Logging
        in with a different GitHub account? Needed for branch coverage.
        """

        # Set up a GitHub SocialLogin in the session
        github_account = SocialAccount.objects.get(user__username='******')
        github_login = SocialLogin(account=github_account,
                                   user=github_account.user)

        request = self.rf.get('/')
        session = self.client.session
        session['sociallogin_provider'] = 'github'
        session['socialaccount_sociallogin'] = github_login.serialize()
        session.save()
        request.session = session

        # Set up an un-matching GitHub SocialLogin for request
        github2_account = SocialAccount(user=self.user_model(),
                                        provider='github',
                                        uid=github_account.uid + '2')
        github2_login = SocialLogin(account=github2_account)

        self.adapter.pre_social_login(request, github2_login)
        eq_(request.session['sociallogin_provider'], 'github')
Beispiel #11
0
    def test_pre_social_login_error_for_unmatched_login(self):
        """ https://bugzil.la/1063830 """

        # Set up a GitHub SocialLogin in the session
        github_account = SocialAccount.objects.get(user__username='******')
        github_login = SocialLogin(account=github_account,
                                   user=github_account.user)

        request = self.rf.get('/')
        session = self.client.session
        session['socialaccount_sociallogin'] = github_login.serialize()
        session.save()
        request.session = session
        messages = self.get_messages(request)

        # Set up an un-matching Persona SocialLogin for request
        persona_account = SocialAccount(user=self.user_model(),
                                        provider='persona',
                                        uid='*****@*****.**')
        persona_login = SocialLogin(account=persona_account)

        self.assertRaises(ImmediateHttpResponse,
                          self.adapter.pre_social_login, request, persona_login)
        queued_messages = list(messages)
        eq_(len(queued_messages), 1)
        eq_(django_messages.ERROR, queued_messages[0].level)
Beispiel #12
0
 def test_invalid_document_form(self):
     """Make sure we handle invalid document form without a 500."""
     translate_uri = self._translate_uri()
     data = _translation_data()
     data['slug'] = ''  # Invalid slug
     response = self.client.post(translate_uri, data)
     eq_(200, response.status_code)
Beispiel #13
0
def _test_form_maintains_based_on_rev(client, doc, view, post_data,
                                      trans_lang=None, locale=None):
    """Confirm that the based_on value set in the revision created by an edit
    or translate form is the current_revision of the document as of when the
    form was first loaded, even if other revisions have been approved in the
    meantime."""
    if trans_lang:
        translate_path = doc.slug
        uri = urllib.quote(reverse('wiki.translate',
                                   locale=trans_lang,
                                   args=[translate_path]))
    else:
        uri = reverse(view, locale=locale, args=[doc.slug])
    response = client.get(uri)
    orig_rev = doc.current_revision
    eq_(orig_rev.id,
        int(pq(response.content)('input[name=based_on]').attr('value')))

    # While Fred is editing the above, Martha approves a new rev:
    martha_rev = revision(document=doc)
    martha_rev.is_approved = True
    martha_rev.save()

    # Then Fred saves his edit:
    post_data_copy = {'based_on': orig_rev.id, 'slug': orig_rev.slug}
    post_data_copy.update(post_data)  # Don't mutate arg.
    response = client.post(uri,
                           data=post_data_copy)
    ok_(response.status_code in (200, 302))
    fred_rev = Revision.objects.all().order_by('-id')[0]
    eq_(orig_rev, fred_rev.based_on)
Beispiel #14
0
 def test_bad_parameters(self):
     """Ensure badly-formed revision parameters do not cause errors"""
     url = reverse('wiki.compare_revisions', args=[self.document.slug])
     query = {'from': '1e309', 'to': u'1e309'}
     url = urlparams(url, **query)
     response = self.client.get(url)
     eq_(404, response.status_code)
Beispiel #15
0
 def test_compare_revisions_invalid_from_int(self):
     """Provide invalid 'from' int for revision ids."""
     url = reverse('wiki.compare_revisions', args=[self.document.slug])
     query = {'from': 'invalid', 'to': ''}
     url = urlparams(url, **query)
     response = self.client.get(url)
     eq_(404, response.status_code)
Beispiel #16
0
 def test_new_document_form_defaults(self):
     """The new document form should have all all 'Relevant to' options
     checked by default."""
     self.client.login(username='******', password='******')
     response = self.client.get(reverse('wiki.create'))
     doc = pq(response.content)
     eq_("Name Your Article", doc('input#id_title').attr('placeholder'))
Beispiel #17
0
 def test_new_revision_GET_logged_out(self):
     """Creating a revision without being logged in redirects to login page.
     """
     self.client.logout()
     response = self.client.get(reverse('wiki.edit',
                                        args=[self.d.slug]))
     eq_(302, response.status_code)
Beispiel #18
0
 def test_mail_handler(self):
     self.logger.handlers = [AdminEmailHandler()]
     response = self.client.get(self.suspicous_path)
     eq_(response.status_code, 400)
     eq_(1, len(mail.outbox))
     ok_('*****@*****.**' in mail.outbox[0].to)
     ok_(self.suspicous_path in mail.outbox[0].body)
Beispiel #19
0
 def test_new_document_GET_with_perm(self):
     """HTTP GET to new document URL renders the form."""
     self.client.login(username='******', password='******')
     response = self.client.get(reverse('wiki.create'))
     eq_(200, response.status_code)
     doc = pq(response.content)
     eq_(1, len(doc('form#wiki-page-edit input[name="title"]')))
Beispiel #20
0
    def test_user_revisions_in_one_click_page_template(self):
        """The user's revisions show up in the ban and cleanup template."""
        # Create 3 revisions for testuser, titled 'Revision 1', 'Revision 2'...
        revisions_expected = self.create_revisions(
            num=3,
            creator=self.testuser,
            document=self.document)

        self.client.login(username='******', password='******')
        ban_url = reverse('users.ban_user_and_cleanup',
                          kwargs={'user_id': self.testuser.id})

        resp = self.client.get(ban_url, follow=True)
        eq_(200, resp.status_code)
        page = pq(resp.content)

        revisions_found = page.find('.dashboard-row')
        revisions_found_text = ''
        for rev in revisions_found:
            revisions_found_text += rev.text_content()

        eq_(len(revisions_found), len(revisions_expected))
        # The title for each of the created revisions shows up in the template
        for revision in revisions_expected:
            ok_(revision.title in revisions_found_text)
        # The original revision created by the admin user is not in the template
        ok_(self.original_revision.title not in revisions_found_text)
Beispiel #21
0
    def test_user_revisions_in_summary_page_template(self):
        """The user's revisions show up in ban and cleanup summary template."""
        # Create 3 revisions for self.testuser, titled 'Revision 1', 'Revision 2'...
        revisions_expected = self.create_revisions(
            num=3,
            document=self.document,
            creator=self.testuser)

        self.client.login(username='******', password='******')
        ban_url = reverse('users.ban_user_and_cleanup_summary',
                          kwargs={'user_id': self.testuser.id})
        full_ban_url = self.client.get(ban_url)['Location']

        resp = self.client.post(full_ban_url)
        eq_(200, resp.status_code)
        page = pq(resp.content)

        revisions_reverted = page.find('#revisions-reverted li')
        revisions_reverted_text = ''
        for rev in revisions_reverted:
            revisions_reverted_text += rev.text_content()

        eq_(len(revisions_reverted), len(revisions_expected))
        # The title for each of the created revisions shows up in the template
        for revision in revisions_expected:
            ok_(revision.title in revisions_reverted_text)
        # The title for the original revision is not in the template
        ok_(self.original_revision.title not in revisions_reverted_text)
Beispiel #22
0
 def test_ignore_heading_section_replace(self):
     doc_src = """
         <h1 id="s1">Head 1</h1>
         <p>test</p>
         <p>test</p>
         <h1 id="s2">Head 2</h1>
         <p>test</p>
         <p>test</p>
         <h1 id="s3">Head 3</h1>
         <p>test</p>
         <p>test</p>
     """
     replace_src = """
         <p>replacement worked yay hooray</p>
     """
     expected = """
         <h1 id="s1">Head 1</h1>
         <p>test</p>
         <p>test</p>
         <h1 id="s2">Head 2</h1>
         <p>replacement worked yay hooray</p>
         <h1 id="s3">Head 3</h1>
         <p>test</p>
         <p>test</p>
     """
     result = (kuma.wiki.content
               .parse(doc_src)
               .replaceSection(id="s2",
                               replace_src=replace_src,
                               ignore_heading=True)
               .serialize())
     eq_(normalize_html(expected), normalize_html(result))
Beispiel #23
0
 def test_generate_toc_h2(self):
     doc_src = """
         <h2 id="HTML">HTML</h2>
           <h3 id="HTML5_canvas_element">HTML5 <code>canvas</code> element</h3>
         <h2 id="JavaScript">JavaScript</h2>
           JavaScript is awesome.
           <h3 id="WebGL">WebGL</h3>
           <h3 id="Audio">Audio</h3>
             <h4 id="Audio-API">Audio API</h4>
         <h2 id="CSS">CSS</h2>
             <h4 id="CSS_transforms">CSS transforms</h4>
           <h3 id="Gradients">Gradients</h3>
             <h4 id="Scaling_backgrounds">Scaling backgrounds</h4>
     """
     expected = """
         <li><a rel="internal" href="#HTML">HTML</a>
         </li>
         <li><a rel="internal" href="#JavaScript">JavaScript</a>
         </li>
         <li><a rel="internal" href="#CSS">CSS</a>
         </li>
     """
     result = (kuma.wiki.content
               .parse(doc_src)
               .filter(H2TOCFilter).serialize())
     eq_(normalize_html(expected), normalize_html(result))
Beispiel #24
0
 def test_section_edit_links(self):
     doc_src = """
         <h1 id="s1">Head 1</h1>
         <p>test</p>
         <p>test</p>
         <h2 id="s2">Head 2</h2>
         <p>test</p>
         <p>test</p>
         <h3 id="s3">Head 3</h3>
         <p>test</p>
         <p>test</p>
     """
     expected = """
         <h1 id="s1"><a class="edit-section" data-section-id="s1" data-section-src-url="/en-US/docs/some-slug?raw=true&amp;section=s1" href="/en-US/docs/some-slug$edit?section=s1&amp;edit_links=true" title="Edit section">Edit</a>Head 1</h1>
         <p>test</p>
         <p>test</p>
         <h2 id="s2"><a class="edit-section" data-section-id="s2" data-section-src-url="/en-US/docs/some-slug?raw=true&amp;section=s2" href="/en-US/docs/some-slug$edit?section=s2&amp;edit_links=true" title="Edit section">Edit</a>Head 2</h2>
         <p>test</p>
         <p>test</p>
         <h3 id="s3"><a class="edit-section" data-section-id="s3" data-section-src-url="/en-US/docs/some-slug?raw=true&amp;section=s3" href="/en-US/docs/some-slug$edit?section=s3&amp;edit_links=true" title="Edit section">Edit</a>Head 3</h3>
         <p>test</p>
         <p>test</p>
     """
     result = (kuma.wiki.content
               .parse(doc_src)
               .injectSectionEditingLinks('some-slug', 'en-US')
               .serialize())
     eq_(normalize_html(expected), normalize_html(result))
Beispiel #25
0
 def test_code_syntax_conversion(self):
     doc_src = """
         <h2>Some JavaScript</h2>:
         <pre class="deki-transform" function="syntax.JavaScript">
         function foo(){
             alert("bar");
         }
         </pre>
         <pre>Some CSS:</pre>
         <pre class="dek-trans" function="syntax.CSS">
         .dek-trans { color: red; }
         </pre>
     """
     expected = """
         <h2>Some JavaScript</h2>:
         <pre class="brush: js">
         function foo(){
             alert("bar");
         }
         </pre>
         <pre>Some CSS:</pre>
         <pre class="brush: css">
         .dek-trans { color: red; }
         </pre>
     """
     result = (kuma.wiki.content
               .parse(doc_src)
               .filter(CodeSyntaxFilter).serialize())
     eq_(normalize_html(expected), normalize_html(result))
Beispiel #26
0
 def test_keep_markup(self):
     content = """
         <h2 id="Summary">Summary</h2>
         <p>The <strong>Document Object Model </strong>
         (<strong>DOM</strong>) is an API for <a href="/en-US/docs/HTML"
         title="en-US/docs/HTML">HTML</a> and <a href="/en-US/docs/XML"
         title="en-US/docs/XML">XML</a> documents. It provides a structural
         representation of the document, enabling you to modify its content
         and visual presentation by using a scripting language such as <a
         href="/en-US/docs/JavaScript"
         title="https://developer.mozilla.org/en-US/docs/JavaScript">
         JavaScript</a>.</span></p>
      """
     expected = """
         The <strong>Document Object Model </strong>
         (<strong>DOM</strong>) is an API for <a href="/en-US/docs/HTML"
         title="en-US/docs/HTML">HTML</a> and <a href="/en-US/docs/XML"
         title="en-US/docs/XML">XML</a> documents. It provides a structural
         representation of the document, enabling you to modify its content
         and visual presentation by using a scripting language such as <a
         href="/en-US/docs/JavaScript"
         title="https://developer.mozilla.org/en-US/docs/JavaScript">
         JavaScript</a>.</span>
     """
     eq_(normalize_html(expected),
         normalize_html(get_seo_description(content, 'en-US', False)))
Beispiel #27
0
    def test_multilevel_implicit_section_extract(self):
        doc_src = """
            <p>test</p>

            <h1 id="s4">Head 4</h1>
            <p>test</p>
            <p>test</p>
            <h2 id="s4-1">Head 4-1</h2>
            <p>test</p>
            <p>test</p>
            <h3 id="s4-2">Head 4-1-1</h3>
            <p>test</p>
            <p>test</p>

            <h1 id="s4-next">Head</h1>
            <p>test</p>
        """
        expected = """
            <h1 id="s4">Head 4</h1>
            <p>test</p>
            <p>test</p>
            <h2 id="s4-1">Head 4-1</h1>
            <p>test</p>
            <p>test</p>
            <h3 id="s4-2">Head 4-1-1</h1>
            <p>test</p>
            <p>test</p>
        """
        result = (kuma.wiki.content.parse(doc_src)
                                   .extractSection(id="s4")
                                   .serialize())
        eq_(normalize_html(expected), normalize_html(result))
Beispiel #28
0
 def test_editor_safety_filter(self):
     """Markup that's hazardous for editing should be stripped"""
     doc_src = """
         <svg><circle onload=confirm(3)>
         <h1 class="header1">Header One</h1>
         <p>test</p>
         <section>
             <h1 class="header2">Header Two</h1>
             <p>test</p>
         </section>
         <h1 class="header3">Header Three</h1>
         <p>test</p>
     """
     expected_src = """
         <svg><circle>
         <h1 class="header1">Header One</h1>
         <p>test</p>
         <section>
             <h1 class="header2">Header Two</h1>
             <p>test</p>
         </section>
         <h1 class="header3">Header Three</h1>
         <p>test</p>
     """
     result_src = (kuma.wiki.content.parse(doc_src)
                   .filterEditorSafety()
                   .serialize())
     eq_(normalize_html(expected_src), normalize_html(result_src))
Beispiel #29
0
 def test_logged_in_default(self):
     """Active user login."""
     request = self.rf.get('/foo')
     request.user = self.user_model.objects.get(username='******')
     view = login_required(simple_view)
     response = view(request)
     eq_(200, response.status_code)
Beispiel #30
0
 def test_persona_form_present(self):
     """
     When not authenticated, the Persona authentication components,
     with correct data attributes, are present in page contents,
     and the 'next' parameter is filled in.
     """
     all_docs_url = reverse('wiki.all_documents',
                            locale=settings.WIKI_DEFAULT_LANGUAGE)
     response = self.client.get(all_docs_url, follow=True)
     parsed = pq(response.content)
     request_info = '{"siteName": "%(siteName)s", "siteLogo": "%(siteLogo)s"}' % \
                    settings.SOCIALACCOUNT_PROVIDERS['persona']['REQUEST_PARAMETERS']
     stub_attrs = (
         ('data-csrf-token-url', reverse('persona_csrf_token')),
         ('data-request', request_info),
     )
     auth_attrs = (
         ('data-service', 'Persona'),
         ('data-next', all_docs_url),
     )
     stub_persona_form = parsed.find('#_persona_login')
     ok_(len(stub_persona_form) > 0)
     for stub_attr in stub_attrs:
         ok_(stub_persona_form.attr(stub_attr[0]))
         eq_(stub_attr[1], stub_persona_form.attr(stub_attr[0]))
     auth_persona_form = parsed.find('.launch-persona-login')
     ok_(len(auth_persona_form) > 0)
     for auth_attr in auth_attrs:
         ok_(auth_persona_form.attr(auth_attr[0]))
         eq_(auth_attr[1], auth_persona_form.attr(auth_attr[0]))
Beispiel #31
0
 def test_non_existent_fallback(self):
     """Respect user's preferences as much as possible."""
     best = get_best_language('qaz-ZZ, fr-FR;q=0.5')
     eq_('fr', best)
 def test_logged_in_admin(self):
     request = self.rf.get('/foo')
     request.user = self.user_model.objects.get(username='******')
     view = permission_required('perm')(simple_view)
     response = view(request)
     eq_(200, response.status_code)
Beispiel #33
0
 def test_global_message(self):
     m = Message(message='Global', is_global=True, is_active=True, url='/')
     m.save()
     eq_(m.message, get_soapbox_messages('/')[0].message)
     eq_(m.message, get_soapbox_messages('/en-US/')[0].message)
Beispiel #34
0
 def test_yesno(self):
     eq_('Yes', yesno(True))
     eq_('No', yesno(False))
     eq_('Yes', yesno(1))
     eq_('No', yesno(0))
Beispiel #35
0
 def test_json_helper(self):
     eq_('false', jsonencode(False))
     eq_('{"foo": "bar"}', jsonencode({'foo': 'bar'}))
Beispiel #36
0
    def test_url_root_internal_redirect(self):
        """Ensure document zone with URL root results in internal redirect"""

        url = '/en-US/{0!s}?raw'.format(self.zone_root)
        response = self.client.get(url, follow=False)
        eq_(200, response.status_code)
        eq_(self.zone_root_content, response.content)

        url = '/en-US/{0!s}/Middle/SubPage?raw'.format(self.zone_root)
        response = self.client.get(url, follow=False)
        eq_(200, response.status_code)
        eq_(self.sub_doc.html, response.content)

        self.root_zone.url_root = 'NewRoot'
        self.root_zone.save()

        url = '/en-US/{0!s}/Middle/SubPage?raw'.format('NewRoot')
        response = self.client.get(url, follow=False)
        eq_(200, response.status_code)
        eq_(self.sub_doc.html, response.content)
Beispiel #37
0
 def test_blank_url_root(self):
     """Ensure a blank url_root does not trigger URL remap"""
     url = '/en-US/docs/{0!s}?raw=1'.format(self.other_doc.slug)
     response = self.client.get(url, follow=False)
     eq_(200, response.status_code)
Beispiel #38
0
 def test_prefix_fallback(self):
     """No matches during the first pass. Fall back to prefix."""
     best = get_best_language('fr-FR, de-DE;q=0.5')
     eq_('fr', best)
Beispiel #39
0
 def test_non_existent(self):
     """If we don't have any matches, return false."""
     best = get_best_language('qaz-ZZ, qaz;q=0.5')
     eq_(False, best)
Beispiel #40
0
 def test_english_fallback(self):
     """Fall back to our canonical English locale, 'en-US'."""
     best = get_best_language('en-GB, fr-FR;q=0.5')
     eq_('en-US', best)
Beispiel #41
0
 def test_prefix_alias(self):
     """A generic request for Portuguese should go to 'pt-PT'."""
     best = get_best_language('pt, fr;q=0.5')
     eq_('pt-PT', best)
Beispiel #42
0
 def test_second_choice(self):
     """Respect the user's preferences during the first pass."""
     best = get_best_language('fr-FR, de;q=0.5')
     eq_('de', best)
Beispiel #43
0
 def test_english_alias(self):
     """Our canonical English locale is 'en-US'."""
     best = get_best_language('en, fr;q=0.5')
     eq_('en-US', best)
Beispiel #44
0
 def test_script_alias(self):
     """Our traditional Chinese locale is 'zh-TW'."""
     best = get_best_language('zh-Hant, fr;q=0.5')
     eq_('zh-TW', best)
Beispiel #45
0
 def test_exact_match_language(self):
     """Exact match of a locale with only a language subtag."""
     best = get_best_language('fr, en-US;q=0.5')
     eq_('fr', best)
Beispiel #46
0
 def test_overspecific_alias(self):
     """Our Irish locale is 'ga-IE'."""
     best = get_best_language('ga, fr;q=0.5')
     eq_('ga-IE', best)
Beispiel #47
0
    def test_new_key(self):
        data = {"description": "This is meant for a test app"}
        url = reverse('authkeys.new', locale='en-US')

        # Check out the creation page, look for the form.
        resp = self.client.get(url)
        eq_(200, resp.status_code)
        page = pq(resp.content)
        eq_(1, page.find('form.key').length)

        # We don't have this key yet, right?
        keys = Key.objects.filter(description=data['description'])
        eq_(0, keys.count())

        # Okay, create it.
        resp = self.client.post(url, data, follow=False)
        eq_(200, resp.status_code)

        # We have the key now, right?
        keys = Key.objects.filter(description=data['description'])
        eq_(1, keys.count())

        # Okay, and it should belong to the logged-in user
        key = keys[0]
        eq_(key.user, self.user)

        # Take a look at the description and key shown on the result page.
        page = pq(resp.content)
        ok_(data['description'], page.find('.key .description').text())
        ok_(key.key, page.find('.key .key').text())

        # Ensure the secret on the page checks out.
        secret = page.find('.key .secret').text()
        ok_(key.check_secret(secret))
Beispiel #48
0
 def test_exact_match_region(self):
     """Exact match of a locale with language and region subtags."""
     best = get_best_language('pt-BR, en-US;q=0.5')
     eq_('pt-BR', best)
 def test_redirect_to_mozilla_org(self):
     url = '/en-US/events'
     response = self.client.get(url)
     eq_(302, response.status_code)
     eq_('https://mozilla.org/contribute/events', response['Location'])
Beispiel #50
0
 def test_english_only(self):
     """Any way you slice it, this should be 'en-US'."""
     best = get_best_language('en-US, en;q=0.5')
     eq_('en-US', best)
Beispiel #51
0
 def test_list_files(self):
     list_files_url = reverse('attachments.list_files',
                              locale=settings.WIKI_DEFAULT_LANGUAGE)
     resp = self.client.get(list_files_url)
     eq_(200, resp.status_code)
     ok_('All Files' in resp.content)
 def test_no_mail_handler(self):
     self.logger.handlers = [logging.NullHandler()]
     response = self.client.get(self.suspicous_path)
     eq_(response.status_code, 400)
     eq_(0, len(mail.outbox))
Beispiel #53
0
 def test_querystring(self):
     path = '/one/two?something'
     request = self.rf.get(path)
     eq_(next_url(request)['next_url'], path)
Beispiel #54
0
    def test_edit_attachment(self):
        file_for_upload = make_test_file(
            content='I am a test file for editing.')

        post_data = {
            'title': 'Test editing file',
            'description': 'A test file for editing.',
            'comment': 'Initial upload',
            'file': file_for_upload,
        }

        resp = self.client.post(reverse('attachments.new_attachment'),
                                data=post_data)

        tdir = tempfile.gettempdir()
        edited_file_for_upload = tempfile.NamedTemporaryFile(suffix=".txt",
                                                             dir=tdir)
        edited_file_for_upload.write(
            'I am a new version of the test file for editing.')
        edited_file_for_upload.seek(0)

        post_data = {
            'title': 'Test editing file',
            'description': 'A test file for editing.',
            'comment': 'Second revision.',
            'file': edited_file_for_upload,
        }

        attachment = Attachment.objects.get(title='Test editing file')

        resp = self.client.post(reverse('attachments.edit_attachment',
                                        kwargs={
                                            'attachment_id': attachment.id,
                                        }),
                                data=post_data)

        eq_(302, resp.status_code)

        # Re-fetch because it's been updated.
        attachment = Attachment.objects.get(title='Test editing file')
        eq_(resp['Location'],
            'http://testserver{0!s}'.format(attachment.get_absolute_url()))

        eq_(2, attachment.revisions.count())

        rev = attachment.current_revision
        eq_('admin', rev.creator.username)
        eq_('Second revision.', rev.comment)
        ok_(rev.is_approved)

        url = attachment.get_file_url()
        resp = self.client.get(url, HTTP_HOST=settings.ATTACHMENT_HOST)
        eq_('text/plain', rev.mime_type)
        ok_('I am a new version of the test file for editing.'
            in resp.streaming_content)
Beispiel #55
0
    def test_find_roots(self):
        """Ensure sub pages can find the content zone root"""
        root_rev = revision(title='ZoneRoot',
                            slug='ZoneRoot',
                            content='This is the Zone Root',
                            is_approved=True,
                            save=True)
        root_doc = root_rev.document

        middle_rev = revision(title='Zonemiddle',
                              slug='Zonemiddle',
                              content='This is the Zone middle',
                              is_approved=True,
                              save=True)
        middle_doc = middle_rev.document
        middle_doc.parent_topic = root_doc
        middle_doc.save()

        sub_rev = revision(title='SubPage',
                           slug='SubPage',
                           content='This is a subpage',
                           is_approved=True,
                           save=True)
        sub_doc = sub_rev.document
        sub_doc.parent_topic = middle_doc
        sub_doc.save()

        sub_sub_rev = revision(title='SubSubPage',
                               slug='SubSubPage',
                               content='This is a subsubpage',
                               is_approved=True,
                               save=True)
        sub_sub_doc = sub_sub_rev.document
        sub_sub_doc.parent_topic = sub_doc
        sub_sub_doc.save()

        other_rev = revision(title='otherPage',
                             slug='otherPage',
                             content='This is an otherpage',
                             is_approved=True,
                             save=True)
        other_doc = other_rev.document

        root_zone = DocumentZone(document=root_doc)
        root_zone.save()

        middle_zone = DocumentZone(document=middle_doc)
        middle_zone.save()

        eq_(self.get_zone_stack(root_doc)[0], root_zone)
        eq_(self.get_zone_stack(middle_doc)[0], middle_zone)
        eq_(self.get_zone_stack(sub_doc)[0], middle_zone)
        eq_(0, len(self.get_zone_stack(other_doc)))

        zone_stack = self.get_zone_stack(sub_sub_doc)
        eq_(zone_stack[0], middle_zone)
        eq_(zone_stack[1], root_zone)
Beispiel #56
0
    def test_files_dict(self):
        doc = document(locale='en', slug='attachment-test-files-dict')
        doc.save()
        rev = revision(document=doc, is_approved=True)
        rev.save()

        test_file_1 = make_test_file(
            content='A file for testing the files dict')

        post_data = {
            'title': 'Files dict test file',
            'description': 'Files dict test file',
            'comment': 'Initial upload',
            'file': test_file_1,
        }

        add_url = urlparams(reverse('attachments.new_attachment'),
                            document_id=doc.id)
        self.client.post(add_url, data=post_data)

        test_file_2 = make_test_file(
            content='Another file for testing the files dict')

        post_data = {
            'title': 'Files dict test file 2',
            'description': 'Files dict test file 2',
            'comment': 'Initial upload',
            'file': test_file_2,
        }

        self.client.post(add_url, data=post_data)

        doc = Document.objects.get(pk=doc.id)

        files_dict = doc.files_dict()

        file1 = files_dict[test_file_1.name.split('/')[-1]]
        eq_('admin', file1['attached_by'])
        eq_('Files dict test file', file1['description'])
        eq_('text/plain', file1['mime_type'])
        ok_(test_file_1.name.split('/')[-1] in file1['url'])

        file2 = files_dict[test_file_2.name.split('/')[-1]]
        eq_('admin', file2['attached_by'])
        eq_('Files dict test file 2', file2['description'])
        eq_('text/plain', file2['mime_type'])
        ok_(test_file_2.name.split('/')[-1] in file2['url'])
Beispiel #57
0
 def test_tojson(self):
     eq_(
         tojson({'title': '<script>alert("Hi!")</script>'}),
         '{"title": "&lt;script&gt;alert(&quot;Hi!&quot;)&lt;/script&gt;"}')
Beispiel #58
0
 def test_basic(self):
     path = '/one/two'
     request = self.rf.get(path)
     eq_(next_url(request)['next_url'], path)
Beispiel #59
0
    def test_user_edit(self):
        testuser = self.user_model.objects.get(username='******')
        url = reverse('users.user_detail', args=(testuser.username, ))
        response = self.client.get(url, follow=True)
        doc = pq(response.content)
        eq_(0, doc.find('#user-head .edit .button').length)

        self.client.login(username=testuser.username,
                          password=TESTUSER_PASSWORD)

        url = reverse('users.user_detail', args=(testuser.username, ))
        response = self.client.get(url, follow=True)
        doc = pq(response.content)

        edit_button = doc.find('#user-head .user-buttons #edit-user')
        eq_(1, edit_button.length)

        url = edit_button.attr('href')
        response = self.client.get(url, follow=True)
        doc = pq(response.content)

        eq_(testuser.fullname,
            doc.find('#user-edit input[name="user-fullname"]').val())
        eq_(testuser.title,
            doc.find('#user-edit input[name="user-title"]').val())
        eq_(testuser.organization,
            doc.find('#user-edit input[name="user-organization"]').val())
        eq_(testuser.location,
            doc.find('#user-edit input[name="user-location"]').val())
        eq_(testuser.irc_nickname,
            doc.find('#user-edit input[name="user-irc_nickname"]').val())

        new_attrs = {
            'user-username': testuser.username,
            'user-email': '*****@*****.**',
            'user-fullname': "Another Name",
            'user-title': "Another title",
            'user-organization': "Another org",
        }

        response = self.client.post(url, new_attrs, follow=True)
        doc = pq(response.content)

        eq_(1, doc.find('#user-head').length)
        eq_(new_attrs['user-fullname'], doc.find('#user-head .fn').text())
        eq_(new_attrs['user-title'],
            doc.find('#user-head .user-info .title').text())
        eq_(new_attrs['user-organization'],
            doc.find('#user-head .user-info .org').text())

        testuser = self.user_model.objects.get(username=testuser.username)
        eq_(new_attrs['user-fullname'], testuser.fullname)
        eq_(new_attrs['user-title'], testuser.title)
        eq_(new_attrs['user-organization'], testuser.organization)
Beispiel #60
0
    def test_absolutify(self, get_current):
        get_current.return_value.domain = 'testserver'

        eq_(absolutify(''), 'https://testserver/')
        eq_(absolutify('/'), 'https://testserver/')
        eq_(absolutify('//'), 'https://testserver/')
        eq_(absolutify('/foo/bar'), 'https://testserver/foo/bar')
        eq_(absolutify('http://domain.com'), 'http://domain.com')

        site = Site(domain='otherserver')
        eq_(absolutify('/woo', site), 'https://otherserver/woo')

        eq_(absolutify('/woo?var=value'), 'https://testserver/woo?var=value')
        eq_(absolutify('/woo?var=value#fragment'),
            'https://testserver/woo?var=value#fragment')