コード例 #1
0
ファイル: test_views.py プロジェクト: ccnmtl/footprints
    def test_footprint_viewset(self):
        csrf_client = Client(enforce_csrf_checks=True)

        grp = GroupFactory(permissions=ADD_CHANGE_PERMISSIONS)
        contributor = UserFactory(group=grp)

        csrf_client.login(username=contributor.username, password="******")

        # get a csrf token
        url = reverse('create-footprint-view')
        response = csrf_client.get(url)

        footprint = FootprintFactory()
        data = {'pk': footprint.id, 'title': 'abcdefg'}
        content = encode_multipart('BoUnDaRyStRiNg', data)
        content_type = 'multipart/form-data; boundary=BoUnDaRyStRiNg'

        url = '/api/footprint/%s/' % footprint.id

        csrf_header = response.cookies['csrftoken'].value
        response = csrf_client.patch(url, content,
                                     content_type=content_type,
                                     HTTP_X_CSRFTOKEN=csrf_header)
        self.assertEquals(response.status_code, 200)

        footprint.refresh_from_db()
        self.assertEquals(footprint.title, 'abcdefg')
コード例 #2
0
ファイル: test_helper.py プロジェクト: Meghashyamt/bedrock
class TestNewsletterFunction(unittest.TestCase):
    def setUp(self):
        self.client = Client()

    def test_get_form(self):
        response = self.client.get('/en-US/base/')
        doc = pq(response.content)
        assert_false(doc('#footer-email-errors'))
        ok_(doc('form#footer-email-form'))

    @patch.object(basket, 'subscribe', Mock())
    def test_post_correct_form(self):
        data = {
            'newsletter-footer': 'Y',
            'newsletter': 'mozilla-and-you',
            'email': '*****@*****.**',
            'fmt': 'H',
            'privacy': 'Y',
        }
        response = self.client.post('/en-US/base/', data)
        doc = pq(response.content)
        assert_false(doc('form#footer-email-form'))
        ok_(doc('div#footer-email-form.thank'))

    def test_post_wrong_form(self):
        response = self.client.post('/en-US/base/', {'newsletter-footer': 'Y'})
        doc = pq(response.content)
        ok_(doc('#footer-email-errors'))
        ok_(doc('#footer-email-form.has-errors'))
コード例 #3
0
ファイル: tests.py プロジェクト: yusukemurayama/blog-samples
class TestLoginRequiredMixin1(TestCase):
    # テスト用のURLパターンを使用します。
    urls = 'myapp.test_urls'

    def setUp(self):
        super().setUp()
        self.client = Client()
        # テスト用URL(test/sample1/login_required_mixin1/)を取得します。
        self.path = reverse('test_sample1_login_required_mixin1')

    def test_logged_in(self):
        """ログイン済みのテストです。"""
        # ユーザを作成し、ログインします。
        username = '******'
        password = '******'
        User.objects.create_user(username=username, password=password)
        self.client.login(username=username, password=password)

        # テスト対象を実行します。
        res = self.client.get(self.path)

        # テスト結果を確認します。
        self.assertEqual(res.status_code, 200)

    def test_not_logged_in(self):
        """ログインしていない場合のテストです。"""
        # テスト対象を実行します。
        res = self.client.get(self.path)

        # テスト結果を確認します。
        self.assertEqual(res.status_code, 302)
コード例 #4
0
ファイル: test_views.py プロジェクト: praekelt/molo.yourwords
    def test_translated_competition_entry_stored_against_the_main_lang(self):
        client = Client()
        client.login(username='******', password='******')

        en_comp = YourWordsCompetition(
            title='Test Competition',
            description='This is the description',
            slug='test-competition')
        self.competition_index.add_child(instance=en_comp)
        en_comp.save_revision().publish()

        self.client.post(reverse(
            'add_translation', args=[en_comp.id, 'fr']))
        fr_comp = YourWordsCompetition.objects.get(
            slug='french-translation-of-test-competition')
        fr_comp.save_revision().publish()

        client.post(
            reverse('molo.yourwords:competition_entry', args=[fr_comp.slug]), {
                'story_name': 'this is a french story',
                'story_text': 'The text',
                'terms_or_conditions_approved': 'true'})

        entry = YourWordsCompetitionEntry.objects.all().first()
        self.assertEqual(entry.story_name, 'this is a french story')
        self.assertEqual(entry.competition.id, en_comp.id)
コード例 #5
0
ファイル: steps.py プロジェクト: fsouza/farmacia
def visitar_pagina_listagem():
    with Mock() as delivery:
        from delivery.models import Remedio
        Remedio.objects.all() >> scc.remedios
    client = Client()
    scc.response = client.get('/delivery/remedios')
    delivery.validate()
コード例 #6
0
ファイル: tests.py プロジェクト: UWCS/uwcs-website
class AuthTests(TestCase):
    def setUp(self):
        self.c = Client()
        self.password = User.objects.make_random_password()
        self.username = "******"
        self.email = "*****@*****.**"
        u = User.objects.create_user(self.username, self.email, self.password)
        u.is_staff = True
        u.save()

    def tearDown(self):
        User.objects.get(username=self.username).delete()
    
    def testAddUser(self):
        testcase_username = '******'
        testcase_password = User.objects.make_random_password()
        
        self.c.login(username=self.username, password=self.password)
        self.c.post('http://uwcs.co.uk/admin/auth/user/add/', {
            'username':testcase_username, 
            'password1':testcase_password, 
            'password2':testcase_password
        })
        #User.objects.get(username=testcase_username).delete()


    def testLogin(self):
       self.assertContains(self.c.post('/login/', {"username": self.username, "password": self.password, "next":""}, follow=True), "Logged in as")
コード例 #7
0
class TestComprehensiveTheming(ModuleStoreTestCase):
    """Tests for comprehensive theming of wiki pages."""

    def setUp(self):
        """Test setup."""
        super(TestComprehensiveTheming, self).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='******',
                                                           password='******')
        self.wiki_math101 = URLPath.create_article(self.wiki, 'math101', title='math101')

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

    @skip("Fails when run immediately after lms.djangoapps.course_wiki.tests.test_middleware")
    @with_comprehensive_theme('red-theme')
    def test_themed_footer(self):
        """
        Tests that theme footer is used rather than standard
        footer when comprehensive theme is enabled.
        """
        response = self.client.get('/courses/edx/math101/2014/wiki/math101/')
        self.assertEqual(response.status_code, 200)
        # This string comes from themes/red-theme/lms/templates/footer.html
        self.assertContains(response, "super-ugly")
コード例 #8
0
ファイル: test_view.py プロジェクト: JuliBakagianni/CEF-ELRC
 def test_downloadable_resource_for_organization_ms_full_members(self):
     """
     Verifies that a resource with an MS Commons license can be downloaded by
     a user of an organization which has the META-SHARE full member
     permission.
     """
     client = Client()
     client.login(username='******', password='******')
     # make sure the license page is shown:
     response = client.get(
         reverse(views.download,
                 args=(self.ms_commons_resource.storage_object.identifier,)),
         follow = True)
     self.assertTemplateUsed(response, 'repository/licence_agreement.html',
                             "license agreement page expected")
     self.assertContains(response,
         'licences/META-SHARE_COMMONS_BYNCSA_v1.0.htm', msg_prefix="the " \
             "correct license appears to not be shown in an iframe")
     # make sure the download is started after accepting the license:
     response = client.post(
         reverse(views.download,
                 args=(self.ms_commons_resource.storage_object.identifier,)),
         { 'in_licence_agree_form': 'True', 'licence_agree': 'True',
           'licence': 'MSCommons-BY-NC-SA' },
         follow = True)
     self.assertTemplateNotUsed(response,
         'repository/licence_agreement.html',
         msg_prefix="a download should have been started")
     self.assertTemplateNotUsed(response,
         'repository/licence_selection.html',
         msg_prefix="a download should have been started")
     self.assertTemplateNotUsed(response,
         'repository/lr_not_downloadable.html',
         msg_prefix="a download should have been started")
コード例 #9
0
ファイル: test_view.py プロジェクト: JuliBakagianni/CEF-ELRC
 def test_non_downloadable_resource_for_normal_organization_members(self):
     """
     Verifies that a resource with an MS Commons license cannot be downloaded
     by a user of an organization which does not have the META-SHARE full
     member permission.
     """
     test_passwd = 'secret'
     test_user = test_utils.create_organization_member(
         'organization_member_non_ms', '*****@*****.**', test_passwd,
         (Organization.objects.create(name='test_organization_non_ms'),))
     client = Client()
     client.login(username=test_user.username, password=test_passwd)
     # make sure the license page is shown:
     response = client.get(reverse(views.download,
                 args=(self.ms_commons_resource.storage_object.identifier,)),
         follow = True)
     self.assertTemplateUsed(response, 'repository/licence_agreement.html',
                             "license agreement page expected")
     self.assertContains(response,
         'licences/META-SHARE_COMMONS_BYNCSA_v1.0.htm', msg_prefix="the " \
             "correct license appears to not be shown in an iframe")
     # make sure the download cannot be started:
     response = client.post(
         reverse(views.download,
                 args=(self.ms_commons_resource.storage_object.identifier,)),
         { 'in_licence_agree_form': 'True', 'licence_agree': 'True',
           'licence': 'MSCommons-BY-NC-SA' },
         follow = True)
     self.assertTemplateUsed(response, 'repository/licence_agreement.html',
         msg_prefix="a download should not have been started")
コード例 #10
0
ファイル: tests.py プロジェクト: Winterflower/oh-mainline
 def login_with_client(self, username='******',
                       password="******"):
     client = Client()
     success = client.login(username=username,
                            password=password)
     self.assert_(success)
     return client
コード例 #11
0
ファイル: tests.py プロジェクト: brat002/ebscab
    def test_confirm(self):
        c = Client()
        acc = Account()
        acc.username='******'
        acc.password='******'
        acc.fullname='foouser'
        acc.created = datetime.datetime.now()
        acc.contract = '010001'
        acc.save()
        TransactionType.objects.create(name='EasyPay', internal_name = 'payments.easypay')
        
        response = c.post(reverse('getpaid-easypay-pay'), """<Request>
<DateTime>yyyy-MM-ddTHH:mm:ss</DateTime>
<Sign></Sign>
<Payment>
<ServiceId>1</ServiceId>
<OrderId>1</OrderId>
<Account>010001</Account>
<Amount>10.11</Amount>
</Payment>
</Request>""", content_type='text/xml')
        print response.content
        bs = BeautifulSoup(response.content)
        response = c.post(reverse('getpaid-easypay-pay'), """<Request>
<DateTime>yyyy-MM-ddTHH:mm:ss</DateTime>
<Sign></Sign>
<Confirm>
<ServiceId>1</ServiceId>
<PaymentId>%s</PaymentId>
</Confirm>
</Request>""" % bs.response.paymentid, content_type='text/xml')
        
        print 'TRANSACTION=', Transaction.objects.get(type__internal_name='payments.easypay', bill='1')
        
        print response.content
コード例 #12
0
 def testLocalLogInRedirect(self):
     c = Client()
     response = c.post('/account/?next=/foo/', {
         'email': self.userinfo['email'],
         'password': self.userinfo['password']
     })
     self.assertRedirects(response, '/foo/', status_code=302, target_status_code=200)
コード例 #13
0
ファイル: test_views.py プロジェクト: eads/panda
class TestLogin(TransactionTestCase):
    fixtures = ['init_panda.json']

    def setUp(self):
        self.user = utils.get_panda_user()
        
        self.client = Client()

    def test_login_success(self):
        response = self.client.post('/login/', { 'email': '*****@*****.**', 'password': '******' }) 

        self.assertEqual(response.status_code, 200)

        body = json.loads(response.content)

        self.assertEqual(body['email'], '*****@*****.**')
        self.assertEqual(body['api_key'], 'edfe6c5ffd1be4d3bf22f69188ac6bc0fc04c84c')
        self.assertEqual(body['notifications'], [])

    def test_login_disabled(self):
        self.user.is_active = False
        self.user.save()

        response = self.client.post('/login/', { 'email': '*****@*****.**', 'password': '******' }) 

        self.assertEqual(response.status_code, 400)

        body = json.loads(response.content)

        self.assertIn('disabled', body['__all__'])

        self.user.is_active = True
        self.user.save()

    def test_login_invalid_email(self):
        response = self.client.post('/login/', { 'email': '*****@*****.**', 'password': '******' }) 

        self.assertEqual(response.status_code, 400)

        body = json.loads(response.content)

        self.assertIn('incorrect', body['__all__'])

    def test_login_incorrect_password(self):
        response = self.client.post('/login/', { 'email': '*****@*****.**', 'password': '******' }) 

        self.assertEqual(response.status_code, 400)

        body = json.loads(response.content)

        self.assertIn('incorrect', body['__all__'])

    def test_no_get(self):
        response = self.client.get('/login/', { 'email': '*****@*****.**', 'password': '******' }) 

        self.assertEqual(response.status_code, 400)

        body = json.loads(response.content)

        self.assertEqual(body, None)
コード例 #14
0
 def testRegisterNoPreferredName(self):
     c = Client()
     _, d = test_user(create=False)
     del d['preferred_name']
     r = c.post(reverse('account:register'), d)
     self.assertTrue(r.status_code, 200)
     self.assertFalse(User.objects.filter(email=d['email']).exists())
コード例 #15
0
    def testEditChanges(self):
        user, info = test_user()
        _, change_info = test_user(create=False)

        c = Client()
        self.assertTrue(c.login(username=info['username'],
                                password=info['password']), "Can't log in?")

        c.post(reverse('account:edit'), {
            'email': change_info['email'],
            'preferred_name': change_info['preferred_name'],
            'real_name': change_info['real_name'],
        })

        # refresh the user
        # user.refresh_from_db() # we don't get this until dj1.8...
        user = User.objects.get(pk=user.pk)
        self.assertFalse(user.userdata.email_verified)
        self.assertTrue(user.emailverification_set.all().exists())
        self.assertEqual(user.first_name, user.userdata.preferred_name)
        self.assertEqual(user.last_name, '')
        self.assertEqual(user.userdata.preferred_name,
                         change_info['preferred_name'])
        self.assertEqual(user.userdata.real_name, change_info['real_name'])
        self.assertEqual(user.email, change_info['email'])
コード例 #16
0
ファイル: tests.py プロジェクト: erikrose/arecibo
 def testUnicodeTraceback(self):
     c = Client()
     assert not Error.objects.count()
     ldata = data.copy()
     ldata["traceback"] = "ɷo̚حٍ"
     c.post(reverse("error-post"), ldata)
     assert Error.objects.count() == 1
コード例 #17
0
ファイル: tests.py プロジェクト: AnneNamuli/schooldriver
    def test_teacher_attendance(self):
        """ Tests to ensure that we can take attendance. This test covers
                the submission_percentage dashlet and teacher_submission view. """
        self.setup()

        user = User.objects.get(username='******')
        user.set_password('aa') # Why is this needed?
        user.save()

        c = Client()

        c.login(username='******', password='******')

        response = c.get('/admin/')
        self.assertEqual(response.status_code, 200)

        course_section = CourseSection.objects.get(name="Homeroom FX 2011")

        response = c.get('/attendance/teacher_attendance/' + str(course_section.id), follow=True)
        self.assertEqual(response.status_code, 200)

        AttendanceLog(user=user, course_section=self.course_section1).save()
        AttendanceLog(user=user, course_section=self.course_section2).save()

        homerooms = CourseSection.objects.filter(course__homeroom=True)
        for homeroom in homerooms:
            log = AttendanceLog.objects.filter(course_section=homeroom)
            assert log.count() > 0
コード例 #18
0
ファイル: tests.py プロジェクト: erikrose/arecibo
 def testNoPriority(self):
     c = Client()
     assert not Error.objects.count()
     ldata = data.copy()
     del ldata["priority"]
     c.post(reverse("error-post"), ldata)
     assert Error.objects.count() == 1
コード例 #19
0
ファイル: tests.py プロジェクト: erikrose/arecibo
 def testGroupDelete(self):
     c = Client()
     c.post(reverse("error-post"), data)
     assert Group.objects.count() == 1, "Got %s groups, not 1" % Group.objects.count()
     assert Error.objects.count() == 1
     Error.objects.all()[0].delete()
     assert Group.objects.count() == 0
コード例 #20
0
ファイル: tests.py プロジェクト: sm00th1980/info.egs63.ru
class TVTestCase(unittest.TestCase):

    def setUp(self):
        contracts = Contract.objects.all()
        self.contracts = []
        for contract in contracts:
            if contract.is_open():
                self.contracts.append(contract)

    	self.client = Client()
            	
    def test_tv(self):      
        for contract in self.contracts:
            self.client.post('/login', {'contract': contract.contract, 'password': contract.password})
            response = self.client.get('/tv')

            service = Service(contract=contract)

            # Check that the response is 200 OK.
            self.assertEqual(response.status_code, 200)

            title_exist   = True if 'Произошла ошибка!' in response.content else False
            message_exist = True if 'Данная услуга у вас не привязана к данному логину. Предварительно осуществите привязку.' in response.content else False

            if service.is_tv_activated():
                self.assertEqual(title_exist, False)
                self.assertEqual(message_exist, False)
            else:
                self.assertEqual(title_exist, True)
                self.assertEqual(message_exist, True)                

            #logout
            self.client.post('/logout')
コード例 #21
0
ファイル: tests.py プロジェクト: ikkebr/hackinpoa
class GroupCreateTests(TestCase):
    def setUp(self):
        self.c = Client()
        self.user = User.objects.create_user('dummy', '*****@*****.**', 'dummy')
        self.user.save()

        self.user2 = User.objects.create_user('adummy', '*****@*****.**', 'adummy')
        self.user2.save()

        self.user3 = User.objects.create_user('fdummy', '*****@*****.**', 'fdummy')
        self.user3.save()

        self.grupo_a = Group.objects.create(id=1, name="abcd", is_public=0, owner=self.user)
        self.grupo_a.save()

        acesso_a = Group_Access.objects.create(group=self.grupo_a, user=self.user3)
        acesso_a.save()


    def teste_usuario_anonimo_retorna_302(self):
        response = self.c.get(reverse("group_create"))
        self.assertEqual(response.status_code, 302)

    def teste_usuario_logado_retorna_200(self):
        self.c.login(username='******', password='******')
        response = self.c.get(reverse("group_create"))
        self.assertEqual(response.status_code, 200)
コード例 #22
0
def test_xblock_no_student_view():
    # Try to get a response. Will try to render via WorkbenchRuntime.render;
    # since no view is provided in the XBlock, will return a Fragment that
    # indicates there is no view available.
    client = Client()
    response = client.get("/view/xblockwithoutstudentview/")
    assert_true("No such view" in response.content)
コード例 #23
0
ファイル: test_view.py プロジェクト: leandrobraga/simplemooc
 def test_contact_form_error(self):
     data = {'nome': 'Fulano de tal', 'email': '', 'message': ''}
     client = Client()
     path = reverse('courses:detail', args=[self.course.slug])
     response = client.post(path, data)
     self.assertFormError(response, 'form', 'email', 'Este campo é obrigatório.')
     self.assertFormError(response, 'form', 'message', 'Este campo é obrigatório.')
コード例 #24
0
ファイル: tests.py プロジェクト: twidi/satchmo
class AdminTest(TestCase):
    fixtures = ['l10n-data.yaml', 'sample-store-data.yaml', 'products.yaml', 'initial_data.yaml']

    def setUp(self):
        self.client = Client()
        user = User.objects.create_user('fredsu', '*****@*****.**', 'passwd')
        user.is_staff = True
        user.is_superuser = True
        user.save()
        self.client.login(username='******', password='******')

    def tearDown(self):
        cache_delete()

    def test_index(self):
        response = self.client.get('/admin/')
        self.assertContains(response, "contact/contact/", status_code=200)

    #def test_product(self):
        response = self.client.get('/admin/product/product/1/')
        self.assertContains(response, "Django Rocks shirt", status_code=200)

    #def test_configurableproduct(self):
        response = self.client.get('/admin/configurable/configurableproduct/1/')
        self.assertContains(response, "Small, Black", status_code=200)
コード例 #25
0
ファイル: tests.py プロジェクト: iferminm/charla-tdd-joincic
class PremioTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = UserFactory()
        self.post_data = {'text': 'Esta pelicula es genial'}
        self.movie = MovieFactory()
        self.movie.save()
        self.client.login(username=self.user.username, password='******')

    def test_premio(self):
        from django.utils import simplejson
        m = mocker.Mocker()
        obj = m.replace('random')
        obj.randint(1, 200)
        m.result(22)
        k = {'movie_id': self.movie.id}
        m.replay()

        response = self.client.post(reverse('add_review', kwargs=k), self.post_data)

        self.assertEquals(response.status_code, 201)
        self.assertEquals(self.movie.moviereview_set.count(), 1)
        d = simplejson.loads(response.content)

        self.assertTrue(d.has_key('premio'))
    def test_POST_success(self):
        """
        Filling the ProfileForm with data should cause the Profile to be
        updated.
        """
        data = {
            'username': '******',
            'name': 'First Last',
            'email': '*****@*****.**',
            'description': 'New Description',
            'location': 'Where I am',
            'website': 'http://www.google.com'
            }
        c = Client()
        c.login(username='******', password='******')
        response = c.post(self.url, data)
        self.assertStatusCodeEquals(response, 302)
        self.assertEqual(response['Location'],
                          'http://%s%s' % (
                self.site_settings.site.domain,
                self.url))

        user = User.objects.get(pk=self.user.pk)
        self.assertEqual(user.username, 'newusername')
        self.assertEqual(user.first_name, 'First')
        self.assertEqual(user.last_name, 'Last')
        self.assertEqual(user.email, '*****@*****.**')
        self.assertEqual(user.get_profile().description,
                          'New Description')
        self.assertEqual(user.get_profile().location, 'Where I am')
        self.assertEqual(user.get_profile().website,
                          'http://www.google.com/')
    def test_POST_delete_logo(self):
        """
        If the 'delete_logo' POST argument is present, the logo should be
        deleted.
        """
        self.profile.logo = File(self._data_file('logo.png'))
        self.profile.save()
        self.assertTrue(self.profile.logo)

        data = {
            'username': self.user.username,
            'name': self.user.get_full_name(),
            'email': self.user.email,
            'delete_logo': 'yes'
            }

        c = Client()
        c.login(username='******', password='******')
        response = c.post(self.url, data)
        self.assertStatusCodeEquals(response, 302)
        self.assertEqual(response['Location'],
                          'http://%s%s' % (
                self.site_settings.site.domain,
                self.url))

        user = User.objects.get(pk=self.user.pk)
        profile = user.get_profile()
        self.assertFalse(profile.logo)
コード例 #28
0
def test_xblock_with_handlers():
    # Tests of handler urls.
    client = Client()

    # The view sends a list of URLs to try.
    response = client.get("/view/with-handlers/")
    parsed = response.content.split(":::")
    assert_equals(len(parsed), 3)
    urls = json.loads(parsed[1])

    # These have to correspond to the urls in XBlockWithHandlers.student_view above.
    expecteds = [
        {"suffix": "", "a": "no-a", "b": "no-b"},
        {"suffix": "with_some_suffix", "a": "no-a", "b": "no-b"},
        {"suffix": "", "a": "123", "b": "no-b"},
        {"suffix": "", "a": "123", "b": "456"},
        {"suffix": "another_suffix", "a": "123", "b": "456"},
        {"suffix": "", "a": "no-a", "b": "no-b"},
        {"suffix": "with_some_suffix", "a": "no-a", "b": "no-b"},
        {"suffix": "", "a": "123", "b": "no-b"},
        {"suffix": "", "a": "123", "b": "456"},
        {"suffix": "another_suffix", "a": "123", "b": "456"},
    ]

    for url, expected in zip(urls, expecteds):
        print url  # so we can see which one failed, if any.
        response = client.get(url)
        assert_equals(response.status_code, 200)
        actual = json.loads(response.content)
        assert_equals(actual, expected)
コード例 #29
0
ファイル: tests.py プロジェクト: jjdu/gbd
    def test_get_covariate_types(self):
        c = Client()

        url = reverse('gbd.covariate_data_server.views.get_covariate_types')
        response = c.get(url)
        self.assertRedirects(response, '/accounts/login/?next=%s'%url)
        # then login and do functional tests
        c.login(username='******', password='******')

        response = c.get(url)
        #import pdb;pdb.set_trace()
        resp_json = json.loads(response.content)['cov']
        
        self.assertEqual(resp_json[0]['slug'], 'GDP')
        self.assertEqual(resp_json[0]['uploader'], 'red')
        self.assertEqual(resp_json[0]['source'], 'web')
        self.assertEqual(resp_json[0]['notes'], 'notes')
        self.assertEqual(resp_json[0]['year range'], '1950-2010')
        self.assertEqual(resp_json[0]['region only'], 'False')
        self.assertEqual(resp_json[0]['mean'], 0.130)
        self.assertEqual(resp_json[0]['variance'], 0.004817)
        self.assertEqual(resp_json[1]['slug'], 'ABC')
        self.assertEqual(resp_json[1]['uploader'], 'red')
        self.assertEqual(resp_json[1]['source'], 'web')
        self.assertEqual(resp_json[1]['notes'], 'notes')
        self.assertEqual(resp_json[1]['year range'], '1950-2010')
        self.assertEqual(resp_json[1]['region only'], 'True')
        self.assertEqual(resp_json[1]['mean'], 0.095)
        self.assertEqual(resp_json[1]['variance'], 0.002692)
コード例 #30
0
ファイル: tests.py プロジェクト: ShaastraWebops/ERP
 def test_basic (self):
     """
     Tests that 1 + 1 always equals 2.
     """
     self.failUnlessEqual(1 + 1, 2)
     c = Client ()
     test_url_list = ['/erp/home/login/',
                      '/erp/home/login',
                      '/erp/home/',
                      '/erp/home',
                      '/erp/',
                      '/erp',
                      '/erp/h',
                      '/erp/home/',
                      '/erp/home',
                      '/erp/home/login/',
                      '/erp/home/login',
                      '/erp/home/forgot_password',
                      '/erp/home/forgot_password/',
                      '/erp/home/logout',
                      '/erp/home/logout/',
                      '/erp/ee09b001/users',
                      '/erp/ee09b001/users/',
                      '/erp/ee09b001/users/register/',
                      '/erp/ee09b001/users/register',
                      '/erp/ee09b001/users/register/new',
                      '/erp/ee09b001/users/invite/',
                      '/erp/ee09b001/users/edit_profile/',
                      ]
     for url in test_url_list:
         response = c.get (url)
         try:
             print url, response.status_code
         except:
             pass
コード例 #31
0
ファイル: badge_tests.py プロジェクト: dhirajt/askbot-devel
 def setUp(self):
     self.u1 = self.create_user(username = '******')
     self.u2 = self.create_user(username = '******')
     self.u3 = self.create_user(username = '******')
     self.client = Client()
コード例 #32
0
class PayPalPaymentTestCase(TestCase):
    """Tests paypal payments
    """
    fixtures = ['lfs_shop.xml']

    def setUp(self):

        self.uuid = "981242b5-fb0c-4563-bccb-e03033673d2a"
        self.IPN_POST_PARAMS = {
            "protection_eligibility": "Ineligible",
            "last_name": "User",
            "txn_id": "51403485VH153354B",
            "receiver_email": settings.PAYPAL_RECEIVER_EMAIL,
            "payment_status": ST_PP_COMPLETED,
            "payment_gross": "10.00",
            "tax": "0.00",
            "residence_country": "US",
            "invoice": "0004",
            "payer_status": "verified",
            "txn_type": "express_checkout",
            "handling_amount": "0.00",
            "payment_date": "23:04:06 Feb 02, 2009 PST",
            "first_name": "Test",
            "item_name": "Something from the shop",
            "charset": "windows-1252",
            "custom": self.uuid,
            "notify_version": "2.6",
            "transaction_subject": "",
            "test_ipn": "1",
            "item_number": "1",
            "receiver_id": "258DLEHY2BDK6",
            "payer_id": "BN5JZ2V7MLEV4",
            "verify_sign":
            "An5ns1Kso7MWUdW4ErQKJJJ4qi4-AqdZy6dD.sGO3sDhTf1wAbuO2IZ7",
            "payment_fee": "0.59",
            "mc_fee": "0.59",
            "mc_currency": "USD",
            "shipping": "0.00",
            "payer_email": "*****@*****.**",
            "payment_type": "instant",
            "mc_gross": "10.00",
            "quantity": "1",
        }

        # Every test needs a client.
        self.client = Client()

    def test_successful_order_transaction_created(self):
        """Tests we have a transaction associated with an order after payment
        """
        def fake_postback(self, test=True):
            """Perform a Fake PayPal IPN Postback request."""
            return 'VERIFIED'

        PayPalIPN._postback = fake_postback

        country = Country.objects.get(code="ie")
        order = Order(invoice_country=country,
                      shipping_country=country,
                      uuid=self.uuid)
        self.assertEqual(order.state, SUBMITTED)
        order.save()
        self.assertEqual(len(PayPalIPN.objects.all()), 0)
        self.assertEqual(len(PayPalOrderTransaction.objects.all()), 0)
        post_params = self.IPN_POST_PARAMS
        response = self.client.post(reverse('paypal-ipn'), post_params)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(PayPalIPN.objects.all()), 1)
        self.assertEqual(len(PayPalOrderTransaction.objects.all()), 1)
        ipn_obj = PayPalIPN.objects.all()[0]
        self.assertEqual(ipn_obj.flag, False)
        order = Order.objects.all()[0]
        self.assertEqual(order.state, PAID)

    def test_failed_order_transaction_created(self):
        """Tests a failed paypal transaction
        """
        def fake_postback(self, test=True):
            """Perform a Fake PayPal IPN Postback request."""
            return 'INVALID'

        PayPalIPN._postback = fake_postback

        country = Country.objects.get(code="ie")
        order = Order(invoice_country=country,
                      shipping_country=country,
                      uuid=self.uuid)
        self.assertEqual(order.state, SUBMITTED)
        order.save()
        self.assertEqual(len(PayPalIPN.objects.all()), 0)
        self.assertEqual(len(PayPalOrderTransaction.objects.all()), 0)
        post_params = self.IPN_POST_PARAMS
        payment_status_update = {"payment_status": ST_PP_DENIED}
        post_params.update(payment_status_update)
        response = self.client.post(reverse('paypal-ipn'), post_params)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(PayPalIPN.objects.all()), 1)
        self.assertEqual(len(PayPalOrderTransaction.objects.all()), 1)
        ipn_obj = PayPalIPN.objects.all()[0]
        self.assertEqual(ipn_obj.payment_status, ST_PP_DENIED)
        self.assertEqual(ipn_obj.flag, True)
        order = Order.objects.all()[0]
        self.assertEqual(order.state, PAYMENT_FAILED)

    def test_succesful_order_with_flagged_payment_invalid_receiver_email(self):
        """Tests a succesful paypal transaction that is flagged with an invalide receiver email
        """
        def fake_postback(self, test=True):
            """Perform a Fake PayPal IPN Postback request."""
            return 'VERIFIED'

        PayPalIPN._postback = fake_postback
        country = Country.objects.get(code="ie")
        order = Order(invoice_country=country,
                      shipping_country=country,
                      uuid=self.uuid)
        self.assertEqual(order.state, SUBMITTED)
        order.save()
        self.assertEqual(len(PayPalIPN.objects.all()), 0)
        self.assertEqual(len(PayPalOrderTransaction.objects.all()), 0)
        post_params = self.IPN_POST_PARAMS
        incorrect_receiver_email_update = {
            "receiver_email": "*****@*****.**"
        }
        post_params.update(incorrect_receiver_email_update)
        response = self.client.post(reverse('paypal-ipn'), post_params)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(PayPalIPN.objects.all()), 1)
        self.assertEqual(len(PayPalOrderTransaction.objects.all()), 1)
        ipn_obj = PayPalIPN.objects.all()[0]
        self.assertEqual(ipn_obj.payment_status, ST_PP_COMPLETED)
        self.assertEqual(ipn_obj.flag, True)
        self.assertEqual(
            ipn_obj.flag_info,
            u'Invalid receiver_email. ([email protected])')
        order = Order.objects.all()[0]
        self.assertEqual(order.state, PAYMENT_FLAGGED)

    def test_correct_address_fields_set_on_checkout(self):
        country = Country.objects.get(code="us")
        order = Order(invoice_firstname="bill",
                      invoice_lastname="blah",
                      invoice_line1="bills house",
                      invoice_line2="bills street",
                      invoice_city="bills town",
                      invoice_state="bills state",
                      invoice_code="bills zip code",
                      invoice_country=country,
                      shipping_country=country,
                      uuid=self.uuid)
        self.assertEqual(order.state, SUBMITTED)
        order.save()
        url = get_paypal_link_for_order(order)

        # test unique id
        self.assertEqual(('custom=' + self.uuid) in url, True)

        # test address stuff
        self.assertEqual('first_name=bill' in url, True)
        self.assertEqual('last_name=blah' in url, True)
        self.assertEqual('address1=bills house' in url, True)
        self.assertEqual('address2=bills street' in url, True)
        self.assertEqual('state=bills state' in url, True)
        self.assertEqual('zip=bills zip code' in url, True)
コード例 #33
0
 def setUp(self):
     super(MiddlewareTestCase, self).setUp()
     self.client = Client()
コード例 #34
0
class MiddlewareTestCase(SettingsMixin, test.TestCase):
    fixtures = ['session_security_test_user']

    def setUp(self):
        super(MiddlewareTestCase, self).setUp()
        self.client = Client()

    def test_auto_logout(self):
        self.client.login(username='******', password='******')
        response = self.client.get('/admin/')
        self.assertTrue('_auth_user_id' in self.client.session)
        time.sleep(self.max_expire_after)
        response = self.client.get('/admin/')
        self.assertFalse('_auth_user_id' in self.client.session)

    def test_last_activity_in_future(self):
        self.client.login(username='******', password='******')
        now = datetime.now()
        future = now + timedelta(0, self.max_expire_after * 2)
        set_last_activity(self.client.session, future)
        response = self.client.get('/admin/')
        self.assertTrue('_auth_user_id' in self.client.session)

    def test_non_javascript_browse_no_logout(self):
        self.client.login(username='******', password='******')
        response = self.client.get('/admin/')
        time.sleep(self.max_warn_after)
        response = self.client.get('/admin/')
        self.assertTrue('_auth_user_id' in self.client.session)
        time.sleep(self.min_warn_after)
        response = self.client.get('/admin/')
        self.assertTrue('_auth_user_id' in self.client.session)

    def test_javascript_activity_no_logout(self):
        self.client.login(username='******', password='******')
        response = self.client.get('/admin/')
        time.sleep(self.max_warn_after)
        self.client.get('/session_security/ping/?idleFor=1')
        self.assertTrue('_auth_user_id' in self.client.session)
        time.sleep(self.min_warn_after)
        self.client.get('/admin/')
        self.assertTrue('_auth_user_id' in self.client.session)

    def test_url_names(self):
        self.client.login(username='******', password='******')
        # Confirm activity is updating
        response = self.client.get('/admin/')
        activity1 = get_last_activity(self.client.session)
        time.sleep(min(2, self.min_warn_after))
        response = self.client.get('/admin/')
        activity2 = get_last_activity(self.client.session)
        self.assertTrue(activity2 > activity1)
        # Confirm activity on ignored URL is NOT updated
        time.sleep(min(2, self.min_warn_after))
        response = self.client.get('/ignore/')
        activity3 = get_last_activity(self.client.session)
        self.assertEqual(activity2, activity3)
コード例 #35
0
ファイル: tests.py プロジェクト: youen/djity
 def setUp(self):
     # Every test needs a client.
     self.client = Client()
コード例 #36
0
 def fetch_response(self, url_name, group):
     url = reverse(url_name)
     client = Client()
     return client.get('%s?week=%s&group=%s' %
                       (url, group.week, group.group))
コード例 #37
0
ファイル: badge_tests.py プロジェクト: dhirajt/askbot-devel
class BadgeTests(AskbotTestCase):

    def setUp(self):
        self.u1 = self.create_user(username = '******')
        self.u2 = self.create_user(username = '******')
        self.u3 = self.create_user(username = '******')
        self.client = Client()

    def assert_have_badge(self, badge_key, recipient = None, expected_count = 1):
        """note - expected_count matches total number of
        badges within test, not the one that was awarded between the calls
        to this assertion"""
        filters = {'badge__slug': badge_key, 'user': recipient}
        count = models.Award.objects.filter(**filters).count()
        self.assertEquals(count, expected_count)

    def assert_accepted_answer_badge_works(self,
                                    badge_key = None,
                                    min_score = None,
                                    expected_count = 1,
                                    previous_count = 0,
                                    trigger = None
                                ):
        assert(trigger in ('accept_best_answer', 'upvote_answer'))
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u2, question = question)
        answer.score = min_score - 1
        answer.save()

        recipient = answer.author

        if trigger == 'accept_best_answer':
            self.u1.upvote(answer)
            self.assert_have_badge(badge_key, recipient, previous_count)
            self.u1.accept_best_answer(answer)
        else:
            self.u1.accept_best_answer(answer)
            self.assert_have_badge(badge_key, recipient, previous_count)
            self.u1.upvote(answer)
        self.assert_have_badge(badge_key, recipient, expected_count)

    def assert_upvoted_answer_badge_works(self, 
                                    badge_key = None,
                                    min_score = None,
                                    multiple = False
                                ):
        """test answer badge where answer author is the recipient
        where badge award is triggered by upvotes
        * min_score - minimum # of upvotes required
        * multiple - multiple award or not
        * badge_key - key on askbot.models.badges.Badge object
        """
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u2, question = question)
        answer.score = min_score - 1
        answer.save()
        self.u1.upvote(answer)
        self.assert_have_badge(badge_key, recipient = self.u2)
        self.u3.upvote(answer)
        self.assert_have_badge(badge_key, recipient = self.u2, expected_count = 1)
        
        #post another question and check that there are no new badges
        question2 = self.post_question(user = self.u1)
        answer2 = self.post_answer(user = self.u2, question = question2)
        answer2.score = min_score - 1
        answer2.save()
        self.u1.upvote(answer2)

        if multiple == True:
            expected_count = 2
        else:
            expected_count = 1

        self.assert_have_badge(
                badge_key,
                recipient = self.u2,
                expected_count = expected_count
            )

    def assert_upvoted_question_badge_works(self, 
                                    badge_key = None,
                                    min_score = None,
                                    multiple = False
                                ):
        """test question badge where question author is the recipient
        where badge award is triggered by upvotes
        * min_score - minimum # of upvotes required
        * multiple - multiple award or not
        * badge_key - key on askbot.models.badges.Badge object
        """
        question = self.post_question(user = self.u1)
        question.score = min_score - 1
        question.save()
        self.u2.upvote(question)
        self.assert_have_badge(badge_key, recipient = self.u1)
        self.u3.upvote(question)
        self.assert_have_badge(badge_key, recipient = self.u1, expected_count = 1)
        
        #post another question and check that there are no new badges
        question2 = self.post_question(user = self.u1)
        question2.score = min_score - 1
        question2.save()
        self.u2.upvote(question2)

        if multiple == True:
            expected_count = 2
        else:
            expected_count = 1

        self.assert_have_badge(
                        badge_key,
                        recipient = self.u1,
                        expected_count = expected_count
                    )

    def test_disciplined_badge(self):
        question = self.post_question(user = self.u1)
        question.score = settings.DISCIPLINED_BADGE_MIN_UPVOTES
        question.save()
        self.u1.delete_question(question)
        self.assert_have_badge('disciplined', recipient = self.u1)

        question2 = self.post_question(user = self.u1)
        question2.score = settings.DISCIPLINED_BADGE_MIN_UPVOTES
        question2.save()
        self.u1.delete_question(question2)
        self.assert_have_badge('disciplined', recipient = self.u1, expected_count = 2)

    def test_peer_pressure_badge(self):
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u1, question = question)
        answer.score = -1*settings.PEER_PRESSURE_BADGE_MIN_DOWNVOTES
        answer.save()
        self.u1.delete_answer(answer)
        self.assert_have_badge('peer-pressure', recipient = self.u1)

    def test_teacher_badge(self):
        self.assert_upvoted_answer_badge_works(
            badge_key = 'teacher',
            min_score = settings.TEACHER_BADGE_MIN_UPVOTES,
            multiple = False
        )

    def test_nice_answer_badge(self):
        self.assert_upvoted_answer_badge_works(
            badge_key = 'nice-answer',
            min_score = settings.NICE_ANSWER_BADGE_MIN_UPVOTES,
            multiple = True
        )

    def test_nice_question_badge(self):
        self.assert_upvoted_question_badge_works(
            badge_key = 'nice-question',
            min_score = settings.NICE_QUESTION_BADGE_MIN_UPVOTES,
            multiple = True
        )

    def test_popular_question_badge(self):
        question = self.post_question(user = self.u1)
        min_views = settings.POPULAR_QUESTION_BADGE_MIN_VIEWS
        question.thread.view_count = min_views - 1
        question.thread.save()

        #patch not_a_robot_request to return True
        from askbot.utils import functions
        functions.not_a_robot_request = lambda v: True

        url = question.get_absolute_url()

        self.client.login(method='force', user_id = self.u2.id)
        self.client.get(url)
        self.assert_have_badge('popular-question', recipient = self.u1)

        self.client.login(method='force', user_id = self.u3.id)
        self.client.get(url)
        self.assert_have_badge('popular-question', recipient = self.u1, expected_count = 1)

        question2 = self.post_question(user = self.u1)
        question2.thread.view_count = min_views - 1
        question2.thread.save()
        self.client.login(method='force', user_id = self.u2.id)
        self.client.get(question2.get_absolute_url())
        self.assert_have_badge('popular-question', recipient = self.u1, expected_count = 2)

    def test_student_badge(self):
        question = self.post_question(user = self.u1)
        self.u2.upvote(question)
        self.assert_have_badge('student', recipient = self.u1)
        self.u3.upvote(question)
        self.assert_have_badge('student', recipient = self.u1, expected_count = 1)

        question2 = self.post_question(user = self.u1)
        self.u2.upvote(question)
        self.assert_have_badge('student', recipient = self.u1, expected_count = 1)

    def test_supporter_badge(self):
        question = self.post_question(user = self.u1)
        self.u2.upvote(question)
        self.assert_have_badge('supporter', recipient = self.u2)

        answer = self.post_answer(user = self.u1, question = question)
        self.u3.upvote(answer)
        self.assert_have_badge('supporter', recipient = self.u3)
        self.u2.upvote(answer)
        self.assert_have_badge('supporter', recipient = self.u2, expected_count = 1)

    def test_critic_badge(self):
        question = self.post_question(user = self.u1)
        self.u2.downvote(question)
        self.assert_have_badge('critic', recipient = self.u2)

        answer = self.post_answer(user = self.u1, question = question)
        self.u3.downvote(answer)
        self.assert_have_badge('critic', recipient = self.u3)
        self.u2.downvote(answer)
        self.assert_have_badge('critic', recipient = self.u2, expected_count = 1)

    def test_self_learner_badge(self):
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u1, question = question)
        min_votes = settings.SELF_LEARNER_BADGE_MIN_UPVOTES
        answer.score = min_votes - 1
        answer.save()
        self.u2.upvote(answer)
        self.assert_have_badge('self-learner', recipient = self.u1)

        #copy-paste of the first question, except expect second badge
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u1, question = question)
        answer.score = min_votes - 1
        answer.save()
        self.u2.upvote(answer)
        self.assert_have_badge('self-learner', recipient = self.u1, expected_count = 2)

        question = self.post_question(user = self.u2)
        answer = self.post_answer(user = self.u1, question = question)
        answer.score = min_votes - 1
        answer.save()
        self.u2.upvote(answer)
        #no badge when asker != answerer
        self.assert_have_badge(
            'self-learner',
            recipient = self.u1,
            expected_count = 2
        )

    def test_civic_duty_badge(self):
        settings.update('CIVIC_DUTY_BADGE_MIN_VOTES', 2)
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u2, question = question)
        answer2 = self.post_answer(user = self.u1, question = question)
        self.u3.upvote(question)
        self.u3.downvote(answer)
        self.assert_have_badge('civic-duty', recipient = self.u3)
        self.u3.upvote(answer2)
        self.assert_have_badge('civic-duty', recipient = self.u3, expected_count = 1)
        self.u3.downvote(answer)
        self.assert_have_badge('civic-duty', recipient = self.u3, expected_count = 1)

    def test_scholar_badge(self):
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u2, question = question)
        self.u1.accept_best_answer(answer)
        self.assert_have_badge('scholar', recipient = self.u1)
        question2 = self.post_question(user = self.u1)
        answer2 = self.post_answer(user = self.u2, question = question2)
        self.u1.accept_best_answer(answer2)
        self.assert_have_badge(
            'scholar',
            recipient = self.u1,
            expected_count=1
        )

    def assert_enlightened_badge_works(self, trigger):
        self.assert_accepted_answer_badge_works(
            'enlightened',
            min_score = settings.ENLIGHTENED_BADGE_MIN_UPVOTES,
            expected_count = 1,
            trigger = trigger
        )
        self.assert_accepted_answer_badge_works(
            'enlightened',
            min_score = settings.ENLIGHTENED_BADGE_MIN_UPVOTES,
            expected_count = 1,
            previous_count = 1,
            trigger = trigger
        )

    def assert_guru_badge_works(self, trigger):
        self.assert_accepted_answer_badge_works(
            'guru',
            min_score = settings.GURU_BADGE_MIN_UPVOTES,
            expected_count = 1,
            trigger = trigger
        )
        self.assert_accepted_answer_badge_works(
            'guru',
            min_score = settings.GURU_BADGE_MIN_UPVOTES,
            previous_count = 1,
            expected_count = 2,
            trigger = trigger
        )

    def test_enlightened_badge1(self):
        self.assert_enlightened_badge_works('upvote_answer')

    def test_enlightened_badge2(self):
        self.assert_enlightened_badge_works('accept_best_answer')

    def test_guru_badge1(self):
        self.assert_guru_badge_works('upvote_answer')

    def test_guru_badge1(self):
        self.assert_guru_badge_works('accept_best_answer')

    def test_necromancer_badge(self):
        question = self.post_question(user = self.u1)
        now = datetime.datetime.now()
        delta = datetime.timedelta(settings.NECROMANCER_BADGE_MIN_DELAY + 1)
        future = now + delta
        answer = self.post_answer(
                        user = self.u2,
                        question = question,
                        timestamp = future
                    ) 
        answer.score = settings.NECROMANCER_BADGE_MIN_UPVOTES - 1
        answer.save()
        self.assert_have_badge('necromancer', self.u2, expected_count = 0)
        self.u1.upvote(answer)
        self.assert_have_badge('necromancer', self.u2, expected_count = 1)

    def test_citizen_patrol_question(self):
        self.u2.set_status('m')
        question = self.post_question(user = self.u1)
        self.u2.flag_post(question)
        self.assert_have_badge('citizen-patrol', self.u2)
        question = self.post_question(user = self.u1)
        self.u2.flag_post(question)
        self.assert_have_badge('citizen-patrol', self.u2, 1)

    def test_citizen_patrol_answer(self):
        self.u2.set_status('m')
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u1, question = question)
        self.u2.flag_post(answer)
        self.assert_have_badge('citizen-patrol', self.u2)
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u1, question = question)
        self.u2.flag_post(answer)
        self.assert_have_badge('citizen-patrol', self.u2, 1)

    def test_editor_badge_question(self):
        self.u2.set_status('m')
        question = self.post_question(user = self.u1)
        self.u2.edit_question(
            question = question,
            title = 'hahaha',
            body_text = 'heheeh',
            revision_comment = 'ihihih'
        )
        self.assert_have_badge('editor', self.u2, 1)
        #double check that its not multiple
        question = self.post_question(user = self.u1)
        self.u2.edit_question(
            question = question,
            title = 'hahaha',
            body_text = 'heheeh',
            revision_comment = 'ihihih'
        )
        self.assert_have_badge('editor', self.u2, 1)

    def test_editor_badge_answer(self):
        self.u2.set_status('m')
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u1, question = question)
        self.u2.edit_answer(answer = answer, body_text = 'hahaha')
        self.assert_have_badge('editor', self.u2, 1)
        #double check that its not multiple
        question = self.post_question(user = self.u1)
        answer = self.post_answer(user = self.u1, question = question)
        self.u2.edit_answer(answer = answer, body_text = 'hahaha')
        self.assert_have_badge('editor', self.u2, 1)

    def test_associate_editor_badge(self):
        self.u2.set_status('m')
        question = self.post_question(user = self.u1)
        settings.update('ASSOCIATE_EDITOR_BADGE_MIN_EDITS', 2)
        self.u2.edit_question(
            question = question,
            title = 'hahaha',
            body_text = 'sdgsdjghsldkfshd',
            revision_comment = 'sdgdfgsgfs'
        )
        self.assert_have_badge('strunk-and-white', self.u2, 0)
        self.u2.edit_question(
            question = question,
            title = 'hahaha',
            body_text = 'sdgsdjghsldkfshd',
            revision_comment = 'sdgdfgsgfs'
        )
        self.assert_have_badge('strunk-and-white', self.u2, 1)
        self.u2.edit_question(
            question = question,
            title = 'hahaha',
            body_text = 'sdgsdjghsldkfshd',
            revision_comment = 'sdgdfgsgfs'
        )
        self.assert_have_badge('strunk-and-white', self.u2, 1)

    def test_organizer_badge(self):
        question = self.post_question(user = self.u1)
        self.u1.retag_question(question = question, tags = 'blah boom')
        self.assert_have_badge('organizer', self.u1, 1)
        self.u1.retag_question(question = question, tags = 'blah pooh')
        self.assert_have_badge('organizer', self.u1, 1)

    def test_autobiographer_badge(self):
        self.u1.real_name = 'blah'
        self.u1.website = 'cnn.com'
        self.u1.location = 'irvine'
        self.u1.about = 'blah'
        self.u1.save()
        award_badges_signal.send(None,
            event = 'update_user_profile',
            actor = self.u1,
            context_object = self.u1
        )
        self.assert_have_badge('autobiographer', self.u1, 1)
        award_badges_signal.send(None,
            event = 'update_user_profile',
            actor = self.u1,
            context_object = self.u1
        )
        self.assert_have_badge('autobiographer', self.u1, 1)

    def test_stellar_badge1(self):
        question = self.post_question(user = self.u1)
        settings.update('STELLAR_QUESTION_BADGE_MIN_STARS', 2)
        self.u2.toggle_favorite_question(question)
        self.assert_have_badge('stellar-question', self.u1, 0)
        self.u3.toggle_favorite_question(question)
        self.assert_have_badge('stellar-question', self.u1, 1)

    def test_stellar_badge2(self):
        question = self.post_question(user = self.u1)
        settings.update('STELLAR_QUESTION_BADGE_MIN_STARS', 2)
        self.u2.toggle_favorite_question(question)
        self.assert_have_badge('stellar-question', self.u1, 0)
        self.u1.toggle_favorite_question(question)
        """no gaming"""
        self.assert_have_badge('stellar-question', self.u1, 0)
    
    def test_stellar_badge3(self):
        question = self.post_question(user = self.u1)
        settings.update('STELLAR_QUESTION_BADGE_MIN_STARS', 2)
        self.u2.toggle_favorite_question(question)
        self.assert_have_badge('stellar-question', self.u1, 0)
        self.u3.toggle_favorite_question(question)
        #award now
        self.assert_have_badge('stellar-question', self.u1, 1)
        self.u3.toggle_favorite_question(question)
        #dont take back
        self.assert_have_badge('stellar-question', self.u1, 1)
        self.u3.toggle_favorite_question(question)
        #dont reaward
        self.assert_have_badge('stellar-question', self.u1, 1)

    def test_commentator_badge(self):
        question = self.post_question(user = self.u1)
        min_comments = settings.COMMENTATOR_BADGE_MIN_COMMENTS
        for i in xrange(min_comments - 1):
            self.post_comment(user = self.u1, parent_post = question)

        self.assert_have_badge('commentator', self.u1, 0)
        self.post_comment(user = self.u1, parent_post = question) 
        self.assert_have_badge('commentator', self.u1, 1)
        self.post_comment(user = self.u1, parent_post = question) 
        self.assert_have_badge('commentator', self.u1, 1)

    def test_taxonomist_badge(self):
        self.post_question(user = self.u1, tags = 'test')
        min_use = settings.TAXONOMIST_BADGE_MIN_USE_COUNT
        for i in xrange(min_use - 2):
            self.post_question(user = self.u2, tags = 'test')
        self.assert_have_badge('taxonomist', self.u1, 0)
        self.post_question(user = self.u2, tags = 'test')
        self.assert_have_badge('taxonomist', self.u1, 1)

    def test_enthusiast_badge(self):
        yesterday = datetime.datetime.now() - datetime.timedelta(1)
        self.u1.last_seen = yesterday
        prev_visit_count = settings.ENTHUSIAST_BADGE_MIN_DAYS - 1
        self.u1.consecutive_days_visit_count = prev_visit_count
        self.u1.save()
        self.assert_have_badge('enthusiast', self.u1, 0)
        self.client.login(method = 'force', user_id = self.u1.id)
        self.client.get('/' + django_settings.ASKBOT_URL)
        self.assert_have_badge('enthusiast', self.u1, 1)
コード例 #38
0
 def setUp(self):
     """Setup test case by adding primary user."""
     super(SSLClientTest, self).setUp()
     self.client = Client()
     self.factory = RequestFactory()
     self.mock = Mock()
コード例 #39
0
ファイル: test_payu.py プロジェクト: anncza/django-getpaid
class PayUBackendTestCase(TestCase):
    maxDiff = True

    def setUp(self):
        self.client = Client()

    def test_parse_text_result(self):
        t1 = u'''status:OK

trans_id:349659572
trans_pos_id:105664
trans_session_id:48:1379695300.48
trans_ts:1379695309225
trans_sig:e4e981bfa780fa78fb077ca1f9295f2a

        '''
        self.assertEqual(
            getpaid.backends.payu.PaymentProcessor._parse_text_response(t1),
            {
                'status': 'OK',
                'trans_id': '349659572',
                'trans_pos_id': '105664',
                'trans_session_id': '48:1379695300.48',
                'trans_ts': '1379695309225',
                'trans_sig': 'e4e981bfa780fa78fb077ca1f9295f2a',
            }
        )

    def test_online_malformed(self):
        response = self.client.post(reverse('getpaid:payu:online'), {})
        self.assertEqual(response.content, b'MALFORMED')
        self.assertEqual(response.status_code, 400)

    def test_online_sig_err(self):
        response = self.client.post(reverse('getpaid:payu:online'), {
            'pos_id': 'wrong',
            'session_id': '10:11111',
            'ts': '1111',
            'sig': 'wrong sig',
        })
        self.assertEqual(response.content, b'SIG ERR')
        self.assertEqual(response.status_code, 400)

    def test_online_wrong_pos_id_err(self):
        response = self.client.post(reverse('getpaid:payu:online'), {
            'pos_id': '12345',
            'session_id': '10:11111',
            'ts': '1111',
            'sig': '0d6129738c0aee9d4eb56f2a1db75ab4',
        })
        self.assertEqual(response.content, b'POS_ID ERR')
        self.assertEqual(response.status_code, 400)

    def test_online_wrong_session_id_err(self):
        response = self.client.post(reverse('getpaid:payu:online'), {
            'pos_id': '123456789',
            'session_id': '111111',
            'ts': '1111',
            'sig': 'fcf3db081d5085b45fe86ed0c6a9aa5e',
        })
        self.assertEqual(response.content, b'SESSION_ID ERR')
        self.assertEqual(response.status_code, 400)

    def test_online_ok(self):
        response = self.client.post(reverse('getpaid:payu:online'), {
            'pos_id': '123456789',
            'session_id': '1:11111',
            'ts': '1111',
            'sig': '2a78322c06522613cbd7447983570188',
        })
        self.assertEqual(response.content, b'OK')
        self.assertEqual(response.status_code, 200)

    @mock.patch("getpaid.backends.payu.Request", autospec=True)
    @mock.patch("getpaid.backends.payu.urlopen", fake_payment_get_response_success)
    def test_payment_get_paid(self, mock_Request):
        Payment = apps.get_model('getpaid', 'Payment')
        order = Order(name='Test PLN order', total='123.45', currency='PLN')
        order.save()
        payment = Payment(pk=99, order=order, amount=order.total, currency=order.currency,
                          backend='getpaid.backends.payu')
        payment.save(force_insert=True)
        payment = Payment.objects.get(
            pk=99)  # this line is because django bug https://code.djangoproject.com/ticket/5903
        processor = getpaid.backends.payu.PaymentProcessor(payment)
        processor.get_payment_status(u'99:1342616247.41')
        self.assertEqual(payment.status, u'paid')
        self.assertNotEqual(payment.paid_on, None)
        self.assertNotEqual(payment.amount_paid, Decimal('0'))

        url = 'https://secure.payu.com/paygw/UTF/Payment/get/txt'
        callargs = mock_Request.call_args_list
        self.assertEqual(url, callargs[0][0][0])
        if six.PY3:
            self.assertIsInstance(callargs[0][0][1], bytes)
            self.assertTrue(b'pos_id=123456789' in callargs[0][0][1])
            self.assertTrue(b'session_id=99%3A1342616247.41' in callargs[0][0][1])
        else:
            self.assertIsInstance(callargs[0][0][1], str)
            self.assertTrue('pos_id=123456789' in callargs[0][0][1])
            self.assertTrue('session_id=99%3A1342616247.41' in callargs[0][0][1])

    @mock.patch("getpaid.backends.payu.urlopen", fake_payment_get_response_failure)
    def test_payment_get_failed(self):
        Payment = apps.get_model('getpaid', 'Payment')
        order = Order(name='Test EUR order', total='123.45', currency='PLN')
        order.save()
        payment = Payment(pk=98, order=order, amount=order.total, currency=order.currency,
                          backend='getpaid.backends.payu')
        payment.save(force_insert=True)
        payment = Payment.objects.get(
            pk=98)  # this line is because django bug https://code.djangoproject.com/ticket/5903
        processor = getpaid.backends.payu.PaymentProcessor(payment)
        processor.get_payment_status(u'98:1342616247.41')
        self.assertEqual(payment.status, u'failed')
        self.assertEqual(payment.paid_on, None)
        self.assertEqual(payment.amount_paid, Decimal('0'))
コード例 #40
0
 def setUp(self):
     self.c = Client()
     self.user = User.objects.create_user(password='******', email='*****@*****.**')
     self.c.login(username='******', password='******')
コード例 #41
0
 def test_simple_search_without_pass_string(self):
     mock()
     response = Client().get(reverse('people_filter'))
     
     self.assertEquals('Enter a valid string to search', response.content)
コード例 #42
0
ファイル: test_payu.py プロジェクト: anncza/django-getpaid
 def setUp(self):
     self.client = Client()
コード例 #43
0
    def test_open_now(self):
        dummy_cache = cache.get_cache(
            'django.core.cache.backends.dummy.DummyCache')
        with patch.object(models, 'cache', dummy_cache):
            open_in_range_spot = Spot.objects.create(
                name="This spot is open now",
                latitude=Decimal('40.0000898315'),
                longitude=Decimal('-50.0'))
            closed_in_range_spot = Spot.objects.create(
                name="This spot is closed now",
                latitude=Decimal('40.0000898315'),
                longitude=Decimal('-50.0'))

            open_outof_range_spot = Spot.objects.create(
                name="This spot is open now",
                latitude=Decimal('45.0000898315'),
                longitude=Decimal('-55.0'))
            closed_outof_range_spot = Spot.objects.create(
                name="This spot is closed now",
                latitude=Decimal('45.0000898315'),
                longitude=Decimal('-55.0'))

            now = datetime.time(datetime.now())

            open_start = alternate_date.time(now.hour - 1, now.minute)
            open_end = alternate_date.time(now.hour + 1, now.minute)

            closed_start = alternate_date.time(now.hour + 1, now.minute)
            closed_end = alternate_date.time(now.hour + 2, now.minute)

            day_lookup = ["su", "m", "t", "w", "th", "f", "sa"]
            day_num = int(strftime("%w", localtime()))
            today = day_lookup[day_num]

            open_hours1 = SpotAvailableHours.objects.create(
                spot=open_in_range_spot,
                day=today,
                start_time=open_start,
                end_time=open_end)
            closed_hours1 = SpotAvailableHours.objects.create(
                spot=closed_in_range_spot,
                day=today,
                start_time=closed_start,
                end_time=closed_end)

            open_hours2 = SpotAvailableHours.objects.create(
                spot=open_outof_range_spot,
                day=today,
                start_time=open_start,
                end_time=open_end)
            closed_hours2 = SpotAvailableHours.objects.create(
                spot=closed_outof_range_spot,
                day=today,
                start_time=closed_start,
                end_time=closed_end)

            c = Client()
            response = c.get(
                "/api/v1/spot", {
                    'center_latitude': "40",
                    'center_longitude': -50,
                    'distance': 100,
                    'open_now': True
                })
            spots = json.loads(response.content)

            has_open_in_range = False
            has_open_outof_range = False
            has_closed_in_range = False
            has_closed_outof_range = False

            for spot in spots:
                if spot['id'] == open_in_range_spot.pk:
                    has_open_in_range = True
                if spot['id'] == closed_in_range_spot.pk:
                    has_closed_in_range = True
                if spot['id'] == open_outof_range_spot.pk:
                    has_open_outof_range = True
                if spot['id'] == closed_outof_range_spot.pk:
                    has_closed_outof_range = True

            self.assertEquals(has_open_in_range, True,
                              "Found the open spot in range")
            self.assertEquals(has_closed_in_range, False,
                              "Did not find the closed spot in range")
            self.assertEquals(has_open_outof_range, False,
                              "Did not find the open spot out of range")
            self.assertEquals(has_closed_outof_range, False,
                              "Did not find the closed spot out of range")
コード例 #44
0
ファイル: tests.py プロジェクト: dixon-che/edx-platform
class DashboardTest(ModuleStoreTestCase):
    """
    Tests for dashboard utility functions
    """
    def setUp(self):
        super(DashboardTest, self).setUp()
        self.course = CourseFactory.create()
        self.user = UserFactory.create(username="******",
                                       email="*****@*****.**",
                                       password='******')
        self.client = Client()
        cache.clear()

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    def _check_verification_status_on(self, mode, value):
        """
        Check that the css class and the status message are in the dashboard html.
        """
        CourseModeFactory(mode_slug=mode, course_id=self.course.id)
        CourseEnrollment.enroll(self.user,
                                self.course.location.course_key,
                                mode=mode)

        if mode == 'verified':
            # Simulate a successful verification attempt
            attempt = SoftwareSecurePhotoVerification.objects.create(
                user=self.user)
            attempt.mark_ready()
            attempt.submit()
            attempt.approve()

        response = self.client.get(reverse('dashboard'))
        if mode in ['professional', 'no-id-professional']:
            self.assertContains(response, 'class="course professional"')
        else:
            self.assertContains(response, 'class="course {0}"'.format(mode))
        self.assertContains(response, value)

    @patch.dict("django.conf.settings.FEATURES",
                {'ENABLE_VERIFIED_CERTIFICATES': True})
    def test_verification_status_visible(self):
        """
        Test that the certificate verification status for courses is visible on the dashboard.
        """
        self.client.login(username="******", password="******")
        self._check_verification_status_on(
            'verified', 'You\'re enrolled as a verified student')
        self._check_verification_status_on(
            'honor', 'You\'re enrolled as an honor code student')
        self._check_verification_status_on('audit',
                                           'You\'re auditing this course')
        self._check_verification_status_on(
            'professional',
            'You\'re enrolled as a professional education student')
        self._check_verification_status_on(
            'no-id-professional',
            'You\'re enrolled as a professional education student')

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    def _check_verification_status_off(self, mode, value):
        """
        Check that the css class and the status message are not in the dashboard html.
        """
        CourseModeFactory(mode_slug=mode, course_id=self.course.id)
        CourseEnrollment.enroll(self.user,
                                self.course.location.course_key,
                                mode=mode)

        if mode == 'verified':
            # Simulate a successful verification attempt
            attempt = SoftwareSecurePhotoVerification.objects.create(
                user=self.user)
            attempt.mark_ready()
            attempt.submit()
            attempt.approve()

        response = self.client.get(reverse('dashboard'))
        self.assertNotContains(response, "class=\"course {0}\"".format(mode))
        self.assertNotContains(response, value)

    @patch.dict("django.conf.settings.FEATURES",
                {'ENABLE_VERIFIED_CERTIFICATES': False})
    def test_verification_status_invisible(self):
        """
        Test that the certificate verification status for courses is not visible on the dashboard
        if the verified certificates setting is off.
        """
        self.client.login(username="******", password="******")
        self._check_verification_status_off(
            'verified', 'You\'re enrolled as a verified student')
        self._check_verification_status_off(
            'honor', 'You\'re enrolled as an honor code student')
        self._check_verification_status_off('audit',
                                            'You\'re auditing this course')

    def test_course_mode_info(self):
        verified_mode = CourseModeFactory.create(
            course_id=self.course.id,
            mode_slug='verified',
            mode_display_name='Verified',
            expiration_datetime=datetime.now(pytz.UTC) + timedelta(days=1))
        enrollment = CourseEnrollment.enroll(self.user, self.course.id)
        course_mode_info = complete_course_mode_info(self.course.id,
                                                     enrollment)
        self.assertTrue(course_mode_info['show_upsell'])
        self.assertEquals(course_mode_info['days_for_upsell'], 1)

        verified_mode.expiration_datetime = datetime.now(
            pytz.UTC) + timedelta(days=-1)
        verified_mode.save()
        course_mode_info = complete_course_mode_info(self.course.id,
                                                     enrollment)
        self.assertFalse(course_mode_info['show_upsell'])
        self.assertIsNone(course_mode_info['days_for_upsell'])

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    def test_refundable(self):
        verified_mode = CourseModeFactory.create(
            course_id=self.course.id,
            mode_slug='verified',
            mode_display_name='Verified',
            expiration_datetime=datetime.now(pytz.UTC) + timedelta(days=1))
        enrollment = CourseEnrollment.enroll(self.user,
                                             self.course.id,
                                             mode='verified')

        self.assertTrue(enrollment.refundable())

        verified_mode.expiration_datetime = datetime.now(
            pytz.UTC) - timedelta(days=1)
        verified_mode.save()
        self.assertFalse(enrollment.refundable())

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    @patch('courseware.views.log.warning')
    @patch.dict('django.conf.settings.FEATURES',
                {'ENABLE_PAID_COURSE_REGISTRATION': True})
    def test_blocked_course_scenario(self, log_warning):

        self.client.login(username="******", password="******")

        #create testing invoice 1
        sale_invoice_1 = shoppingcart.models.Invoice.objects.create(
            total_amount=1234.32,
            company_name='Test1',
            company_contact_name='Testw',
            company_contact_email='*****@*****.**',
            customer_reference_number='2Fwe23S',
            recipient_name='Testw_1',
            recipient_email='*****@*****.**',
            internal_reference="A",
            course_id=self.course.id,
            is_valid=False)
        invoice_item = shoppingcart.models.CourseRegistrationCodeInvoiceItem.objects.create(
            invoice=sale_invoice_1,
            qty=1,
            unit_price=1234.32,
            course_id=self.course.id)
        course_reg_code = shoppingcart.models.CourseRegistrationCode(
            code="abcde",
            course_id=self.course.id,
            created_by=self.user,
            invoice=sale_invoice_1,
            invoice_item=invoice_item,
            mode_slug='honor')
        course_reg_code.save()

        cart = shoppingcart.models.Order.get_cart_for_user(self.user)
        shoppingcart.models.PaidCourseRegistration.add_to_order(
            cart, self.course.id)
        resp = self.client.post(reverse('shoppingcart.views.use_code'),
                                {'code': course_reg_code.code})
        self.assertEqual(resp.status_code, 200)

        redeem_url = reverse('register_code_redemption',
                             args=[course_reg_code.code])
        response = self.client.get(redeem_url)
        self.assertEquals(response.status_code, 200)
        # check button text
        self.assertTrue('Activate Course Enrollment' in response.content)

        #now activate the user by enrolling him/her to the course
        response = self.client.post(redeem_url)
        self.assertEquals(response.status_code, 200)

        response = self.client.get(reverse('dashboard'))
        self.assertIn(
            'You can no longer access this course because payment has not yet been received',
            response.content)
        optout_object = Optout.objects.filter(user=self.user,
                                              course_id=self.course.id)
        self.assertEqual(len(optout_object), 1)

        # Direct link to course redirect to user dashboard
        self.client.get(
            reverse(
                'courseware',
                kwargs={"course_id": self.course.id.to_deprecated_string()}))
        log_warning.assert_called_with(
            u'User %s cannot access the course %s because payment has not yet been received',
            self.user, self.course.id.to_deprecated_string())

        # Now re-validating the invoice
        invoice = shoppingcart.models.Invoice.objects.get(id=sale_invoice_1.id)
        invoice.is_valid = True
        invoice.save()

        response = self.client.get(reverse('dashboard'))
        self.assertNotIn(
            'You can no longer access this course because payment has not yet been received',
            response.content)

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    def test_refundable_of_purchased_course(self):

        self.client.login(username="******", password="******")
        CourseModeFactory.create(course_id=self.course.id,
                                 mode_slug='honor',
                                 min_price=10,
                                 currency='usd',
                                 mode_display_name='honor',
                                 expiration_datetime=datetime.now(pytz.UTC) +
                                 timedelta(days=1))
        enrollment = CourseEnrollment.enroll(self.user,
                                             self.course.id,
                                             mode='honor')

        # TODO: Until we can allow course administrators to define a refund period for paid for courses show_refund_option should be False. # pylint: disable=fixme
        self.assertFalse(enrollment.refundable())

        resp = self.client.post(reverse('student.views.dashboard', args=[]))
        self.assertIn('You will not be refunded the amount you paid.',
                      resp.content)

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    def test_refundable_when_certificate_exists(self):
        CourseModeFactory.create(course_id=self.course.id,
                                 mode_slug='verified',
                                 mode_display_name='Verified',
                                 expiration_datetime=datetime.now(pytz.UTC) +
                                 timedelta(days=1))

        enrollment = CourseEnrollment.enroll(self.user,
                                             self.course.id,
                                             mode='verified')

        self.assertTrue(enrollment.refundable())

        GeneratedCertificateFactory.create(
            user=self.user,
            course_id=self.course.id,
            status=CertificateStatuses.downloadable,
            mode='verified')

        self.assertFalse(enrollment.refundable())

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    def test_linked_in_add_to_profile_btn_not_appearing_without_config(self):
        # Without linked-in config don't show Add Certificate to LinkedIn button
        self.client.login(username="******", password="******")

        CourseModeFactory.create(course_id=self.course.id,
                                 mode_slug='verified',
                                 mode_display_name='verified',
                                 expiration_datetime=datetime.now(pytz.UTC) -
                                 timedelta(days=1))

        CourseEnrollment.enroll(self.user, self.course.id, mode='honor')

        self.course.start = datetime.now(pytz.UTC) - timedelta(days=2)
        self.course.end = datetime.now(pytz.UTC) - timedelta(days=1)
        self.course.display_name = u"Omega"
        self.course = self.update_course(self.course, self.user.id)

        download_url = 'www.edx.org'
        GeneratedCertificateFactory.create(
            user=self.user,
            course_id=self.course.id,
            status=CertificateStatuses.downloadable,
            mode='honor',
            grade='67',
            download_url=download_url)
        response = self.client.get(reverse('dashboard'))

        self.assertEquals(response.status_code, 200)
        self.assertNotIn('Add Certificate to LinkedIn', response.content)

        response_url = 'http://www.linkedin.com/profile/add?_ed='
        self.assertNotContains(response, response_url)

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    @patch.dict('django.conf.settings.FEATURES',
                {'CERTIFICATES_HTML_VIEW': False})
    def test_linked_in_add_to_profile_btn_with_certificate(self):
        # If user has a certificate with valid linked-in config then Add Certificate to LinkedIn button
        # should be visible. and it has URL value with valid parameters.
        self.client.login(username="******", password="******")
        LinkedInAddToProfileConfiguration(
            company_identifier='0_mC_o2MizqdtZEmkVXjH4eYwMj4DnkCWrZP_D9',
            enabled=True).save()

        CourseModeFactory.create(course_id=self.course.id,
                                 mode_slug='verified',
                                 mode_display_name='verified',
                                 expiration_datetime=datetime.now(pytz.UTC) -
                                 timedelta(days=1))

        CourseEnrollment.enroll(self.user, self.course.id, mode='honor')

        self.course.start = datetime.now(pytz.UTC) - timedelta(days=2)
        self.course.end = datetime.now(pytz.UTC) - timedelta(days=1)
        self.course.display_name = u"Omega"
        self.course = self.update_course(self.course, self.user.id)

        download_url = 'www.edx.org'
        GeneratedCertificateFactory.create(
            user=self.user,
            course_id=self.course.id,
            status=CertificateStatuses.downloadable,
            mode='honor',
            grade='67',
            download_url=download_url)
        response = self.client.get(reverse('dashboard'))

        self.assertEquals(response.status_code, 200)
        self.assertIn('Add Certificate to LinkedIn', response.content)

        expected_url = (
            'http://www.linkedin.com/profile/add'
            '?_ed=0_mC_o2MizqdtZEmkVXjH4eYwMj4DnkCWrZP_D9&'
            'pfCertificationName=edX+Honor+Code+Certificate+for+Omega&'
            'pfCertificationUrl=www.edx.org&'
            'source=o')
        self.assertContains(response, expected_url)

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    @ddt.data((ModuleStoreEnum.Type.mongo, 1), (ModuleStoreEnum.Type.split, 3))
    @ddt.unpack
    def test_dashboard_metadata_caching(self, modulestore_type,
                                        expected_mongo_calls):
        """
        Check that the student dashboard makes use of course metadata caching.

        The first time the student dashboard displays a specific course, it will
        make a call to the module store. After that first request, though, the
        course's metadata should be cached as a CourseOverview.

        Arguments:
            modulestore_type (ModuleStoreEnum.Type): Type of modulestore to create
                test course in.
            expected_mongo_calls (int >=0): Number of MongoDB queries expected for
                a single call to the module store.

        Note to future developers:
            If you break this test so that the "check_mongo_calls(0)" fails,
            please do NOT change it to "check_mongo_calls(n>1)". Instead, change
            your code to not load courses from the module store. This may
            involve adding fields to CourseOverview so that loading a full
            CourseDescriptor isn't necessary.
        """
        # Create a course, log in the user, and enroll them in the course.
        test_course = CourseFactory.create(default_store=modulestore_type)
        self.client.login(username="******", password="******")
        CourseEnrollment.enroll(self.user, test_course.id)

        # The first request will result in a modulestore query.
        with check_mongo_calls(expected_mongo_calls):
            response_1 = self.client.get(reverse('dashboard'))
            self.assertEquals(response_1.status_code, 200)

        # Subsequent requests will only result in SQL queries to load the
        # CourseOverview object that has been created.
        with check_mongo_calls(0):
            response_2 = self.client.get(reverse('dashboard'))
            self.assertEquals(response_2.status_code, 200)
            response_3 = self.client.get(reverse('dashboard'))
            self.assertEquals(response_3.status_code, 200)

    @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                         'Test only valid in lms')
    @patch.dict(settings.FEATURES, {"IS_EDX_DOMAIN": True})
    def test_dashboard_header_nav_has_find_courses(self):
        self.client.login(username="******", password="******")
        response = self.client.get(reverse("dashboard"))

        # "Find courses" is shown in the side panel
        self.assertContains(response, "Find courses")

        # But other links are hidden in the navigation
        self.assertNotContains(response, "How it Works")
        self.assertNotContains(response, "Schools & Partners")
コード例 #45
0
ファイル: test_views.py プロジェクト: mrcrymnd/capsim
class BasicViewTest(TestCase):
    def setUp(self):
        self.c = Client()
        self.u = User.objects.create(username='******')
        self.u.set_password('test')
        self.u.save()
        self.c.login(username="******", password="******")
        Flag.objects.create(name='simulation', everyone=True)

    def test_root(self):
        response = self.c.get("/run/new/")
        self.assertEquals(response.status_code, 200)

    def test_root_post_invalid(self):
        response = self.c.post("/run/new/")
        self.assertEquals(response.status_code, 200)
        self.assertTrue("errorlist" in response.content)

    def test_root_post_valid(self):
        response = self.c.post(
            "/run/new/",
            dict(
                ticks=10,
                number_agents=10,
                gamma_1=1.0,
                gamma_2=1.0,
                gamma_3=1.0,
                gamma_4=1.0,
                gamma_5=1.0,
                gamma_6=1.0,
                sigma_1=6.2,
                sigma_2=5.,
                agent_initial_mass_mean=100.,
                agent_initial_mass_sigma=20.,
                agent_base_output_mean=100.,
                agent_base_output_sigma=5.,
                recreation_activity_alpha=0.5,
                recreation_activity_lambda=0.1,
                domestic_activity_alpha=0.5,
                domestic_activity_lambda=0.1,
                transport_activity_alpha=0.5,
                transport_activity_lambda=0.1,
                education_activity_alpha=0.5,
                education_activity_lambda=0.1,
                food_exposure_alpha=0.5,
                food_exposure_lambda=0.1,
                energy_density_alpha=0.5,
                energy_density_lambda=0.1,
                food_advertising_alpha=0.5,
                food_advertising_lambda=0.1,
                food_convenience_alpha=0.5,
                food_convenience_lambda=0.1,
                food_literacy_alpha=0.5,
                food_literacy_lambda=0.1,
                recreation_activity_weight=1.0,
                domestic_activity_weight=1.0,
                transport_activity_weight=1.0,
                education_activity_weight=1.0,
                food_exposure_weight=1.0,
                energy_density_weight=1.0,
                food_advertising_weight=1.0,
                food_convenience_weight=1.0,
                food_literacy_weight=1.0,
            ))
        self.assertEquals(response.status_code, 302)

    def test_demo_mode(self):
        Flag.objects.create(name='demo_mode', everyone=True)
        response = self.c.post(
            "/run/new/",
            dict(
                ticks=10,
                number_agents=10,
                gamma_1=1.0,
                gamma_2=1.0,
                gamma_3=1.0,
                gamma_4=1.0,
                gamma_5=1.0,
                gamma_6=1.0,
                sigma_1=6.2,
                sigma_2=5.,
                agent_initial_mass_mean=100.,
                agent_initial_mass_sigma=20.,
                agent_base_output_mean=100.,
                agent_base_output_sigma=5.,
                recreation_activity_alpha=0.5,
                recreation_activity_lambda=0.1,
                domestic_activity_alpha=0.5,
                domestic_activity_lambda=0.1,
                transport_activity_alpha=0.5,
                transport_activity_lambda=0.1,
                education_activity_alpha=0.5,
                education_activity_lambda=0.1,
                food_exposure_alpha=0.5,
                food_exposure_lambda=0.1,
                energy_density_alpha=0.5,
                energy_density_lambda=0.1,
                food_advertising_alpha=0.5,
                food_advertising_lambda=0.1,
                food_convenience_alpha=0.5,
                food_convenience_lambda=0.1,
                food_literacy_alpha=0.5,
                food_literacy_lambda=0.1,
                recreation_activity_weight=1.0,
                domestic_activity_weight=1.0,
                transport_activity_weight=1.0,
                education_activity_weight=1.0,
                food_exposure_weight=1.0,
                energy_density_weight=1.0,
                food_advertising_weight=1.0,
                food_convenience_weight=1.0,
                food_literacy_weight=1.0,
                intervention_increase_physical_activity='high',
            ))
        self.assertEquals(response.status_code, 302)

    def test_smoketest(self):
        response = self.c.get("/smoketest/")
        self.assertEquals(response.status_code, 200)
コード例 #46
0
 def test_simple_search(self):
     mock()
     response = Client().get(reverse('people_filter'), {'s': 'ric'})
     
     peoples = response.context['peoples']
     self.assertEquals(1, len(peoples))
コード例 #47
0
 def setUp(self):
     self.client = Client(enforce_csrf_checks=False)
コード例 #48
0
ファイル: auth.py プロジェクト: xbryanc/commcare-hq
class AuthenticationTestCase(TestCase):
    def setUp(self):
        super(AuthenticationTestCase, self).setUp()
        if hasattr(_thread_locals, 'user'):
            delattr(_thread_locals, 'user')
        User.objects.all().delete()
        delete_all(AuditEvent, 'auditcare/all_events')
        self.client = Client()
        self._createUser()

    def _createUser(self):
        model_count = ModelActionAudit.view("auditcare/model_actions_by_id", include_docs=True, reduce=False).count()
        total_count = AuditEvent.view("auditcare/all_events").count()
        
        usr = User()
        usr.username = '******'
        usr.set_password('mockmock')
        usr.first_name='mocky'
        usr.last_name = 'mock'
        usr.save()

        model_count2 = ModelActionAudit.view("auditcare/model_actions_by_id", include_docs=True, reduce=False).count()
        total_count2 = AuditEvent.view("auditcare/all_events").count()
        
        self.assertEqual(model_count+1, model_count2)    
        self.assertEqual(total_count+1, total_count2)
    
    def testModifyUser(self):
        model_count = ModelActionAudit.view("auditcare/model_actions_by_id", include_docs=True, reduce=False).count()
        total_count = AuditEvent.view("auditcare/all_events").count()
        
        usr = User.objects.get(username='******')
        usr.first_name='aklsjfl'
        time.sleep(1)
        usr.save()
        time.sleep(1)

        model_count2 = ModelActionAudit.view("auditcare/model_actions_by_id", include_docs=True, reduce=False).count()
        total_count2 = AuditEvent.view("auditcare/all_events").count()
                
        self.assertEqual(model_count+1, model_count2)    
        self.assertEqual(total_count+1, total_count2)
    
    
    def testLogin(self):

        #login
        start_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**']).count()
        response = self.client.post(reverse('auth_login'), {'username': '******', 'password': '******'})
        login_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**']).count()
        self.assertEqual(start_count+1, login_count)

        latest_audit = get_latest_access(['user', '*****@*****.**'])
        self.assertEquals(latest_audit.access_type, models.ACCESS_LOGIN)

        #django test client doesn't seem to like logout for some reason
        #logout
#        response = self.client.get('/accounts/logout')
#        logging.error(response.content)
#        #self.client.logout()
#        logout_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**'], include_docs=True).count()
#        self.assertEqual(start_count+2, logout_count)
        
        
    def testSingleFailedLogin(self):
        start_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**']).count()
        response = self.client.post(reverse('auth_login'), {'username': '******', 'password': '******'})

        login_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**']).count()
        self.assertEquals(start_count+1, login_count)
        #got the basic count, now let's inspect this value to see what kind of result it is.

        latest_audit = get_latest_access(['user', '*****@*****.**'])
        self.assertEquals(latest_audit.access_type, models.ACCESS_FAILED)
        self.assertEquals(latest_audit.failures_since_start, 1)


    def testRepeatedFailedLogin(self):
        from auditcare.decorators import login
        login.FAILURE_LIMIT = 3
        login.LOCK_OUT_AT_FAILURE=True
        login.COOLOFF_TIME = timedelta(seconds=4)

        start_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**']).count()
        response = self.client.post(reverse('auth_login'), {'username': '******', 'password': '******'})

        firstlogin_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**']).count()
        self.assertEquals(start_count+1, firstlogin_count)


        first_audit = get_latest_access(['user', '*****@*****.**'])
        self.assertEquals(first_audit.access_type, models.ACCESS_FAILED)
        self.assertEquals(first_audit.failures_since_start, 1)
        start_failures = first_audit.failures_since_start

        for n in range(1, 3):
            #we are logging in within the cooloff period, so let's check to see if it doesn't increment.
            response = self.client.post(reverse('auth_login'), {'username': '******', 'password': '******'})
            next_count = AccessAudit.view('auditcare/login_events', key=['user', '*****@*****.**']).count()
            self.assertEquals(firstlogin_count, next_count)

            next_audit = get_latest_access(['user', '*****@*****.**'])
            self.assertEquals(next_audit.access_type, models.ACCESS_FAILED)
            self.assertEquals(next_audit.failures_since_start, n+start_failures)
            time.sleep(1)
        time.sleep(3)
        response = self.client.post(reverse('auth_login'), {'username': '******', 'password': '******'})
        cooled_audit = get_latest_access(['user', '*****@*****.**'])
        self.assertEquals(cooled_audit.failures_since_start, 1)



    def testAuditViews(self):
        for v in settings.AUDIT_VIEWS:
            pass
コード例 #49
0
ファイル: tests.py プロジェクト: nimbis/slowish
class TokensViewTest(TestCase):

    def setUp(self):
        self.client = Client()

    def test_tokens_invalid(self):
        """Verify that tokens view responds correctly to an invalid post."""

        # This post does not supply any of the required
        # credentials. It should receive a response indicating that
        # authentication failed.
        response = self.client.post(reverse('tokens'))
        self.assertEquals(response.status_code, 401)
        self.assertJSONEqual(
            response.content,
            '{"unauthorized":{"code":401,"message":'
            '"Unable to authenticate user with credentials provided."}}')

    def test_tokens_authorized(self):
        """Verify that the tokens view gives a token to an authorized user."""

        self.user = create_user()

        # Test the __unicode__ methods in SlowishAccount and SlowishUser
        self.assertEquals(str(self.user.account), "1234")
        self.assertEquals(str(self.user), "user (in account 1234)")

        data = user_data

        # Ensure we get a succesful return with valid credentials
        response = self.client.post(
            reverse('tokens'),
            json.dumps(data),
            content_type="application/json")
        self.assertEquals(response.status_code, 200)
        content = json.loads(response.content)
        url = (content['access']['serviceCatalog'][0]
               ['endpoints'][0]['publicURL'])
        self.assertEquals(url, "http://testserver/slowish/files/1234")
        self.assertEquals(content['access']['token']['id'], self.user.token)

        # Try again, but this time with an invalid password, which
        # should yield an authorization failure
        data["auth"]["passwordCredentials"]["password"] = "******"
        response = self.client.post(
            reverse('tokens'),
            json.dumps(data),
            content_type="application/json")
        self.assertEquals(response.status_code, 401)

    def test_tokens_with_tenant_name(self):
        """Verify that we can authenticate with a 'tenantName' entry."""

        self.user = create_user()

        # Drop the tenantId from the data
        data = user_data.copy()
        del data["auth"]["tenantId"]

        # Ensure that we can't authenticate that way
        response = self.client.post(
            reverse('tokens'),
            json.dumps(data),
            content_type="application/json")
        self.assertEquals(response.status_code, 401)

        # Add a tenantName instead
        data["auth"]["tenantName"] = "1234"

        # And verify that that works
        response = self.client.post(
            reverse('tokens'),
            json.dumps(data),
            content_type="application/json")
        self.assertEquals(response.status_code, 200)
コード例 #50
0
class TestPhotoVerificationResultsCallback(ModuleStoreTestCase):
    """
    Tests for the results_callback view.
    """
    def setUp(self):
        self.course = CourseFactory.create(org='Robot', number='999', display_name='Test Course')
        self.course_id = self.course.id
        self.user = UserFactory.create()
        self.attempt = SoftwareSecurePhotoVerification(
            status="submitted",
            user=self.user
        )
        self.attempt.save()
        self.receipt_id = self.attempt.receipt_id
        self.client = Client()

    def mocked_has_valid_signature(method, headers_dict, body_dict, access_key, secret_key):
        return True

    def test_invalid_json(self):
        """
        Test for invalid json being posted by software secure.
        """
        data = {"Testing invalid"}
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB: testing',
            HTTP_DATE='testdate'
        )
        self.assertIn('Invalid JSON', response.content)
        self.assertEqual(response.status_code, 400)

    def test_invalid_dict(self):
        """
        Test for invalid dictionary being posted by software secure.
        """
        data = '"\\"Test\\tTesting"'
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB:testing',
            HTTP_DATE='testdate'
        )
        self.assertIn('JSON should be dict', response.content)
        self.assertEqual(response.status_code, 400)

    @mock.patch('verify_student.ssencrypt.has_valid_signature', mock.Mock(side_effect=mocked_has_valid_signature))
    def test_invalid_access_key(self):
        """
        Test for invalid access key.
        """
        data = {
            "EdX-ID": self.receipt_id,
            "Result": "Testing",
            "Reason": "Testing",
            "MessageType": "Testing"
        }
        json_data = json.dumps(data)
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=json_data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test testing:testing',
            HTTP_DATE='testdate'
        )
        self.assertIn('Access key invalid', response.content)
        self.assertEqual(response.status_code, 400)

    @mock.patch('verify_student.ssencrypt.has_valid_signature', mock.Mock(side_effect=mocked_has_valid_signature))
    def test_wrong_edx_id(self):
        """
        Test for wrong id of Software secure verification attempt.
        """
        data = {
            "EdX-ID": "Invalid-Id",
            "Result": "Testing",
            "Reason": "Testing",
            "MessageType": "Testing"
        }
        json_data = json.dumps(data)
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=json_data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB:testing',
            HTTP_DATE='testdate'
        )
        self.assertIn('edX ID Invalid-Id not found', response.content)
        self.assertEqual(response.status_code, 400)

    @mock.patch('verify_student.ssencrypt.has_valid_signature', mock.Mock(side_effect=mocked_has_valid_signature))
    def test_pass_result(self):
        """
        Test for verification passed.
        """
        data = {
            "EdX-ID": self.receipt_id,
            "Result": "PASS",
            "Reason": "",
            "MessageType": "You have been verified."
        }
        json_data = json.dumps(data)
        response = self.client.post(
            reverse('verify_student_results_callback'), data=json_data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB:testing',
            HTTP_DATE='testdate'
        )
        attempt = SoftwareSecurePhotoVerification.objects.get(receipt_id=self.receipt_id)
        self.assertEqual(attempt.status, u'approved')
        self.assertEquals(response.content, 'OK!')

    @mock.patch('verify_student.ssencrypt.has_valid_signature', mock.Mock(side_effect=mocked_has_valid_signature))
    def test_fail_result(self):
        """
        Test for failed verification.
        """
        data = {
            "EdX-ID": self.receipt_id,
            "Result": 'FAIL',
            "Reason": 'Invalid photo',
            "MessageType": 'Your photo doesn\'t meet standards.'
        }
        json_data = json.dumps(data)
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=json_data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB:testing',
            HTTP_DATE='testdate'
        )
        attempt = SoftwareSecurePhotoVerification.objects.get(receipt_id=self.receipt_id)
        self.assertEqual(attempt.status, u'denied')
        self.assertEqual(attempt.error_code, u'Your photo doesn\'t meet standards.')
        self.assertEqual(attempt.error_msg, u'"Invalid photo"')
        self.assertEquals(response.content, 'OK!')

    @mock.patch('verify_student.ssencrypt.has_valid_signature', mock.Mock(side_effect=mocked_has_valid_signature))
    def test_system_fail_result(self):
        """
        Test for software secure result system failure.
        """
        data = {"EdX-ID": self.receipt_id,
                "Result": 'SYSTEM FAIL',
                "Reason": 'Memory overflow',
                "MessageType": 'You must retry the verification.'}
        json_data = json.dumps(data)
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=json_data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB:testing',
            HTTP_DATE='testdate'
        )
        attempt = SoftwareSecurePhotoVerification.objects.get(receipt_id=self.receipt_id)
        self.assertEqual(attempt.status, u'must_retry')
        self.assertEqual(attempt.error_code, u'You must retry the verification.')
        self.assertEqual(attempt.error_msg, u'"Memory overflow"')
        self.assertEquals(response.content, 'OK!')

    @mock.patch('verify_student.ssencrypt.has_valid_signature', mock.Mock(side_effect=mocked_has_valid_signature))
    def test_unknown_result(self):
        """
        test for unknown software secure result
        """
        data = {
            "EdX-ID": self.receipt_id,
            "Result": 'Unknown',
            "Reason": 'Unknown reason',
            "MessageType": 'Unknown message'
        }
        json_data = json.dumps(data)
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=json_data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB:testing',
            HTTP_DATE='testdate'
        )
        self.assertIn('Result Unknown not understood', response.content)

    @mock.patch('verify_student.ssencrypt.has_valid_signature', mock.Mock(side_effect=mocked_has_valid_signature))
    def test_reverification(self):
        """
         Test software secure result for reverification window.
        """
        data = {
            "EdX-ID": self.receipt_id,
            "Result": "PASS",
            "Reason": "",
            "MessageType": "You have been verified."
        }
        window = MidcourseReverificationWindowFactory(course_id=self.course_id)
        self.attempt.window = window
        self.attempt.save()
        json_data = json.dumps(data)
        self.assertEqual(CourseEnrollment.objects.filter(course_id=self.course_id).count(), 0)
        response = self.client.post(
            reverse('verify_student_results_callback'),
            data=json_data,
            content_type='application/json',
            HTTP_AUTHORIZATION='test BBBBBBBBBBBBBBBBBBBB:testing',
            HTTP_DATE='testdate'
        )
        self.assertEquals(response.content, 'OK!')
        self.assertIsNotNone(CourseEnrollment.objects.get(course_id=self.course_id))
コード例 #51
0
ファイル: test_login.py プロジェクト: ririfat750/edx-platform
class LoginTest(SiteMixin, CacheIsolationTestCase):
    """
    Test login_user() view
    """

    ENABLED_CACHES = ['default']
    LOGIN_FAILED_WARNING = 'Email or password is incorrect'
    ACTIVATE_ACCOUNT_WARNING = 'In order to sign in, you need to activate your account'
    username = '******'
    user_email = '*****@*****.**'
    password = '******'

    def setUp(self):
        """Setup a test user along with its registration and profile"""
        super(LoginTest, self).setUp()
        self.user = self._create_user(self.username, self.user_email)

        RegistrationFactory(user=self.user)
        UserProfileFactory(user=self.user)

        self.client = Client()
        cache.clear()

        self.url = reverse('login_api')

    def _create_user(self, username, user_email):
        user = UserFactory.build(username=username, email=user_email)
        user.set_password(self.password)
        user.save()
        return user

    def test_login_success(self):
        response, mock_audit_log = self._login_response(
            self.user_email, self.password, patched_audit_log='common.djangoapps.student.models.AUDIT_LOG'
        )
        self._assert_response(response, success=True)
        self._assert_audit_log(mock_audit_log, 'info', [u'Login success', self.user_email])

    FEATURES_WITH_LOGIN_MFE_ENABLED = settings.FEATURES.copy()
    FEATURES_WITH_LOGIN_MFE_ENABLED['ENABLE_LOGISTRATION_MICROFRONTEND'] = True

    @ddt.data(
        # Default redirect is dashboard.
        {
            'next_url': None,
            'course_id': None,
            'expected_redirect': settings.LMS_ROOT_URL + '/dashboard',
        },
        # Added root url in next .
        {
            'next_url': '/harmless-relative-page',
            'course_id': None,
            'expected_redirect': settings.LMS_ROOT_URL + '/harmless-relative-page',
        },
        # An absolute URL to a non-whitelisted domain is not an acceptable redirect.
        {
            'next_url': 'https://evil.sketchysite',
            'course_id': None,
            'expected_redirect': settings.LMS_ROOT_URL + '/dashboard',
        },
        # An absolute URL to a whitelisted domain is acceptable.
        {
            'next_url': 'https://openedx.service/coolpage',
            'course_id': None,
            'expected_redirect': 'https://openedx.service/coolpage',
        },
        # If course_id is provided, redirect to finish_auth with dashboard as next.
        {
            'next_url': None,
            'course_id': 'coursekey',
            'expected_redirect': (
                '{root_url}/account/finish_auth?course_id=coursekey&next=%2Fdashboard'.
                format(root_url=settings.LMS_ROOT_URL)
            ),
        },
        # If valid course_id AND next_url are provided, redirect to finish_auth with
        # provided next URL.
        {
            'next_url': 'freshpage',
            'course_id': 'coursekey',
            'expected_redirect': (
                settings.LMS_ROOT_URL + '/account/finish_auth?course_id=coursekey&next=freshpage'
            )
        },
        # If course_id is provided with invalid next_url, redirect to finish_auth with
        # course_id and dashboard as next URL.
        {
            'next_url': 'http://scam.scam',
            'course_id': 'coursekey',
            'expected_redirect': (
                '{root_url}/account/finish_auth?course_id=coursekey&next=%2Fdashboard'.
                format(root_url=settings.LMS_ROOT_URL)
            ),
        },
    )
    @ddt.unpack
    @override_settings(LOGIN_REDIRECT_WHITELIST=['openedx.service'])
    @override_settings(FEATURES=FEATURES_WITH_LOGIN_MFE_ENABLED)
    @skip_unless_lms
    def test_login_success_with_redirect(self, next_url, course_id, expected_redirect):
        post_params = {}

        if next_url:
            post_params['next'] = next_url
        if course_id:
            post_params['course_id'] = course_id

        response, _ = self._login_response(
            self.user_email,
            self.password,
            extra_post_params=post_params,
            HTTP_ACCEPT='*/*',
        )
        self._assert_response(response, success=True)
        self._assert_redirect_url(response, expected_redirect)

    @patch.dict("django.conf.settings.FEATURES", {'SQUELCH_PII_IN_LOGS': True})
    def test_login_success_no_pii(self):
        response, mock_audit_log = self._login_response(
            self.user_email, self.password, patched_audit_log='common.djangoapps.student.models.AUDIT_LOG'
        )
        self._assert_response(response, success=True)
        self._assert_audit_log(mock_audit_log, 'info', [u'Login success'])
        self._assert_not_in_audit_log(mock_audit_log, 'info', [self.user_email])

    def test_login_success_unicode_email(self):
        unicode_email = u'test' + six.unichr(40960) + u'@edx.org'
        self.user.email = unicode_email
        self.user.save()

        response, mock_audit_log = self._login_response(
            unicode_email, self.password, patched_audit_log='common.djangoapps.student.models.AUDIT_LOG'
        )
        self._assert_response(response, success=True)
        self._assert_audit_log(mock_audit_log, 'info', [u'Login success', unicode_email])

    def test_login_fail_no_user_exists(self):
        nonexistent_email = u'*****@*****.**'
        response, mock_audit_log = self._login_response(
            nonexistent_email,
            self.password,
        )
        self._assert_response(
            response, success=False, value=self.LOGIN_FAILED_WARNING, status_code=400
        )
        self._assert_audit_log(mock_audit_log, 'warning', [u'Login failed', u'Unknown user email', nonexistent_email])

    @patch.dict("django.conf.settings.FEATURES", {'SQUELCH_PII_IN_LOGS': True})
    def test_login_fail_no_user_exists_no_pii(self):
        nonexistent_email = u'*****@*****.**'
        response, mock_audit_log = self._login_response(
            nonexistent_email,
            self.password,
        )
        self._assert_response(response, success=False, value=self.LOGIN_FAILED_WARNING)
        self._assert_audit_log(mock_audit_log, 'warning', [u'Login failed', u'Unknown user email'])
        self._assert_not_in_audit_log(mock_audit_log, 'warning', [nonexistent_email])

    def test_login_fail_wrong_password(self):
        response, mock_audit_log = self._login_response(
            self.user_email,
            'wrong_password',
        )
        self._assert_response(response, success=False, value=self.LOGIN_FAILED_WARNING)
        self._assert_audit_log(mock_audit_log, 'warning',
                               [u'Login failed', u'password for', self.user_email, u'invalid'])

    @patch.dict("django.conf.settings.FEATURES", {'SQUELCH_PII_IN_LOGS': True})
    def test_login_fail_wrong_password_no_pii(self):
        response, mock_audit_log = self._login_response(self.user_email, 'wrong_password')
        self._assert_response(response, success=False, value=self.LOGIN_FAILED_WARNING)
        self._assert_audit_log(mock_audit_log, 'warning', [u'Login failed', u'password for', u'invalid'])
        self._assert_not_in_audit_log(mock_audit_log, 'warning', [self.user_email])

    @patch.dict("django.conf.settings.FEATURES", {'SQUELCH_PII_IN_LOGS': True})
    def test_login_not_activated_no_pii(self):
        # De-activate the user
        self.user.is_active = False
        self.user.save()

        # Should now be unable to login
        response, mock_audit_log = self._login_response(
            self.user_email,
            self.password
        )
        self._assert_response(response, success=False, error_code="inactive-user")
        self._assert_audit_log(mock_audit_log, 'warning', [u'Login failed', u'Account not active for user'])
        self._assert_not_in_audit_log(mock_audit_log, 'warning', [u'test'])

    def test_login_not_activated_with_correct_credentials(self):
        """
        Tests that when user login with the correct credentials but with an inactive
        account, the system, send account activation email notification to the user.
        """
        self.user.is_active = False
        self.user.save()

        response, mock_audit_log = self._login_response(
            self.user_email,
            self.password,
        )
        self._assert_response(response, success=False, error_code="inactive-user")
        self._assert_audit_log(mock_audit_log, 'warning', [u'Login failed', u'Account not active for user'])

    @patch('openedx.core.djangoapps.user_authn.views.login._log_and_raise_inactive_user_auth_error')
    def test_login_inactivated_user_with_incorrect_credentials(self, mock_inactive_user_email_and_error):
        """
        Tests that when user login with incorrect credentials and an inactive account,
        the system does *not* send account activation email notification to the user.
        """
        nonexistent_email = '*****@*****.**'
        self.user.is_active = False
        self.user.save()
        response, mock_audit_log = self._login_response(nonexistent_email, 'incorrect_password')

        self.assertFalse(mock_inactive_user_email_and_error.called)
        self._assert_response(response, success=False, value=self.LOGIN_FAILED_WARNING)
        self._assert_audit_log(mock_audit_log, 'warning', [u'Login failed', u'Unknown user email', nonexistent_email])

    def test_login_unicode_email(self):
        unicode_email = self.user_email + six.unichr(40960)
        response, mock_audit_log = self._login_response(
            unicode_email,
            self.password,
        )
        self._assert_response(response, success=False)
        self._assert_audit_log(mock_audit_log, 'warning', [u'Login failed', unicode_email])

    def test_login_unicode_password(self):
        unicode_password = self.password + six.unichr(1972)
        response, mock_audit_log = self._login_response(
            self.user_email,
            unicode_password,
        )
        self._assert_response(response, success=False)
        self._assert_audit_log(mock_audit_log, 'warning',
                               [u'Login failed', u'password for', self.user_email, u'invalid'])

    def test_logout_logging(self):
        response, _ = self._login_response(self.user_email, self.password)
        self._assert_response(response, success=True)
        logout_url = reverse('logout')
        with patch('common.djangoapps.student.models.AUDIT_LOG') as mock_audit_log:
            response = self.client.post(logout_url)
        self.assertEqual(response.status_code, 200)
        self._assert_audit_log(mock_audit_log, 'info', [u'Logout', u'test'])

    def test_login_user_info_cookie(self):
        response, _ = self._login_response(self.user_email, self.password)
        self._assert_response(response, success=True)

        # Verify the format of the "user info" cookie set on login
        cookie = self.client.cookies[settings.EDXMKTG_USER_INFO_COOKIE_NAME]
        user_info = json.loads(cookie.value)

        self.assertEqual(user_info["version"], settings.EDXMKTG_USER_INFO_COOKIE_VERSION)
        self.assertEqual(user_info["username"], self.user.username)

        # Check that the URLs are absolute
        for url in user_info["header_urls"].values():
            self.assertIn("http://testserver/", url)

    def test_logout_deletes_mktg_cookies(self):
        response, _ = self._login_response(self.user_email, self.password)
        self._assert_response(response, success=True)

        # Check that the marketing site cookies have been set
        self.assertIn(settings.EDXMKTG_LOGGED_IN_COOKIE_NAME, self.client.cookies)
        self.assertIn(settings.EDXMKTG_USER_INFO_COOKIE_NAME, self.client.cookies)

        # Log out
        logout_url = reverse('logout')
        response = self.client.post(logout_url)

        # Check that the marketing site cookies have been deleted
        # (cookies are deleted by setting an expiration date in 1970)
        for cookie_name in [settings.EDXMKTG_LOGGED_IN_COOKIE_NAME, settings.EDXMKTG_USER_INFO_COOKIE_NAME]:
            cookie = self.client.cookies[cookie_name]
            self.assertIn("01 Jan 1970", cookie.get('expires').replace('-', ' '))

    @override_settings(
        EDXMKTG_LOGGED_IN_COOKIE_NAME=u"unicode-logged-in",
        EDXMKTG_USER_INFO_COOKIE_NAME=u"unicode-user-info",
    )
    def test_unicode_mktg_cookie_names(self):
        # When logged in cookie names are loaded from JSON files, they may
        # have type `unicode` instead of `str`, which can cause errors
        # when calling Django cookie manipulation functions.
        response, _ = self._login_response(self.user_email, self.password)
        self._assert_response(response, success=True)

        response = self.client.post(reverse('logout'))
        expected = {
            'target': '/',
        }
        self.assertDictContainsSubset(expected, response.context_data)

    @patch.dict("django.conf.settings.FEATURES", {'SQUELCH_PII_IN_LOGS': True})
    def test_logout_logging_no_pii(self):
        response, _ = self._login_response(self.user_email, self.password)
        self._assert_response(response, success=True)
        logout_url = reverse('logout')
        with patch('common.djangoapps.student.models.AUDIT_LOG') as mock_audit_log:
            response = self.client.post(logout_url)
        self.assertEqual(response.status_code, 200)
        self._assert_audit_log(mock_audit_log, 'info', [u'Logout'])
        self._assert_not_in_audit_log(mock_audit_log, 'info', [u'test'])

    @override_settings(RATELIMIT_ENABLE=False)
    def test_excessive_login_attempts_success(self):
        # Try (and fail) logging in with fewer attempts than the limit of 30
        # and verify that you can still successfully log in afterwards.
        for i in range(20):
            password = u'test_password{0}'.format(i)
            response, _audit_log = self._login_response(self.user_email, password)
            self._assert_response(response, success=False)
        # now try logging in with a valid password
        response, _audit_log = self._login_response(self.user_email, self.password)
        self._assert_response(response, success=True)

    @override_settings(RATELIMIT_ENABLE=False)
    def test_excessive_login_attempts(self):
        # try logging in 30 times, the default limit in the number of failed
        # login attempts in one 5 minute period before the rate gets limited
        for i in range(30):
            password = u'test_password{0}'.format(i)
            self._login_response(self.user_email, password)
        # check to see if this response indicates that this was ratelimited
        response, _audit_log = self._login_response(self.user_email, 'wrong_password')
        self._assert_response(response, success=False, value='Too many failed login attempts')

    @patch.dict("django.conf.settings.FEATURES", {"DISABLE_SET_JWT_COOKIES_FOR_TESTS": False})
    def test_login_refresh(self):
        def _assert_jwt_cookie_present(response):
            self.assertEqual(response.status_code, 200)
            self.assertIn(jwt_cookies.jwt_cookie_header_payload_name(), self.client.cookies)

        setup_login_oauth_client()
        response, _ = self._login_response(self.user_email, self.password)
        _assert_jwt_cookie_present(response)

        response = self.client.post(reverse('login_refresh'))
        _assert_jwt_cookie_present(response)

    @patch.dict("django.conf.settings.FEATURES", {"DISABLE_SET_JWT_COOKIES_FOR_TESTS": False})
    def test_login_refresh_anonymous_user(self):
        response = self.client.post(reverse('login_refresh'))
        self.assertEqual(response.status_code, 401)
        self.assertNotIn(jwt_cookies.jwt_cookie_header_payload_name(), self.client.cookies)

    @patch.dict("django.conf.settings.FEATURES", {'PREVENT_CONCURRENT_LOGINS': True})
    def test_single_session(self):
        creds = {'email': self.user_email, 'password': self.password}
        client1 = Client()
        client2 = Client()

        response = client1.post(self.url, creds)
        self._assert_response(response, success=True)

        # Reload the user from the database
        self.user = User.objects.get(pk=self.user.pk)

        self.assertEqual(self.user.profile.get_meta()['session_id'], client1.session.session_key)

        # second login should log out the first
        response = client2.post(self.url, creds)
        self._assert_response(response, success=True)

        try:
            # this test can be run with either lms or studio settings
            # since studio does not have a dashboard url, we should
            # look for another url that is login_required, in that case
            url = reverse('dashboard')
        except NoReverseMatch:
            url = reverse('upload_transcripts')
        response = client1.get(url)
        # client1 will be logged out
        self.assertEqual(response.status_code, 302)

    @patch.dict("django.conf.settings.FEATURES", {'PREVENT_CONCURRENT_LOGINS': True})
    def test_single_session_with_no_user_profile(self):
        """
        Assert that user login with cas (Central Authentication Service) is
        redirect to dashboard in case of lms or upload_transcripts in case of
        cms
        """
        user = UserFactory.build(username='******', email='*****@*****.**')
        user.set_password(self.password)
        user.save()

        # Assert that no profile is created.
        self.assertFalse(hasattr(user, 'profile'))

        creds = {'email': '*****@*****.**', 'password': self.password}
        client1 = Client()
        client2 = Client()

        response = client1.post(self.url, creds)
        self._assert_response(response, success=True)

        # Reload the user from the database
        user = User.objects.get(pk=user.pk)

        # Assert that profile is created.
        self.assertTrue(hasattr(user, 'profile'))

        # second login should log out the first
        response = client2.post(self.url, creds)
        self._assert_response(response, success=True)

        try:
            # this test can be run with either lms or studio settings
            # since studio does not have a dashboard url, we should
            # look for another url that is login_required, in that case
            url = reverse('dashboard')
        except NoReverseMatch:
            url = reverse('upload_transcripts')
        response = client1.get(url)
        # client1 will be logged out
        self.assertEqual(response.status_code, 302)

    @patch.dict("django.conf.settings.FEATURES", {'PREVENT_CONCURRENT_LOGINS': True})
    def test_single_session_with_url_not_having_login_required_decorator(self):
        # accessing logout url as it does not have login-required decorator it will avoid redirect
        # and go inside the enforce_single_login

        creds = {'email': self.user_email, 'password': self.password}
        client1 = Client()
        client2 = Client()

        response = client1.post(self.url, creds)
        self._assert_response(response, success=True)

        # Reload the user from the database
        self.user = User.objects.get(pk=self.user.pk)

        self.assertEqual(self.user.profile.get_meta()['session_id'], client1.session.session_key)

        # second login should log out the first
        response = client2.post(self.url, creds)
        self._assert_response(response, success=True)

        url = reverse('logout')

        response = client1.get(url)
        self.assertEqual(response.status_code, 200)

    @override_settings(PASSWORD_POLICY_COMPLIANCE_ROLLOUT_CONFIG={'ENFORCE_COMPLIANCE_ON_LOGIN': True})
    def test_check_password_policy_compliance(self):
        """
        Tests _enforce_password_policy_compliance succeeds when no exception is thrown
        """
        enforce_compliance_path = 'openedx.core.djangoapps.password_policy.compliance.enforce_compliance_on_login'
        with patch(enforce_compliance_path) as mock_check_password_policy_compliance:
            mock_check_password_policy_compliance.return_value = HttpResponse()
            response, _ = self._login_response(self.user_email, self.password)
            response_content = json.loads(response.content.decode('utf-8'))
        self.assertTrue(response_content.get('success'))

    @override_settings(PASSWORD_POLICY_COMPLIANCE_ROLLOUT_CONFIG={'ENFORCE_COMPLIANCE_ON_LOGIN': True})
    def test_check_password_policy_compliance_exception(self):
        """
        Tests _enforce_password_policy_compliance fails with an exception thrown
        """
        enforce_compliance_on_login = '******'
        with patch(enforce_compliance_on_login) as mock_enforce_compliance_on_login:
            mock_enforce_compliance_on_login.side_effect = NonCompliantPasswordException()
            response, _ = self._login_response(
                self.user_email,
                self.password
            )
            response_content = json.loads(response.content.decode('utf-8'))
        self.assertFalse(response_content.get('success'))
        self.assertEqual(len(mail.outbox), 1)
        self.assertIn('Password reset', mail.outbox[0].subject)

    @override_settings(PASSWORD_POLICY_COMPLIANCE_ROLLOUT_CONFIG={'ENFORCE_COMPLIANCE_ON_LOGIN': True})
    def test_check_password_policy_compliance_warning(self):
        """
        Tests _enforce_password_policy_compliance succeeds with a warning thrown
        """
        enforce_compliance_on_login = '******'
        with patch(enforce_compliance_on_login) as mock_enforce_compliance_on_login:
            mock_enforce_compliance_on_login.side_effect = NonCompliantPasswordWarning('Test warning')
            response, _ = self._login_response(self.user_email, self.password)
            response_content = json.loads(response.content.decode('utf-8'))
            self.assertIn('Test warning', self.client.session['_messages'])
        self.assertTrue(response_content.get('success'))

    @ddt.data(
        ('test_password', 'test_password', True),
        (unicodedata.normalize('NFKD', u'Ṗŕệṿïệẅ Ṯệẍt'),
         unicodedata.normalize('NFKC', u'Ṗŕệṿïệẅ Ṯệẍt'), False),
        (unicodedata.normalize('NFKC', u'Ṗŕệṿïệẅ Ṯệẍt'),
         unicodedata.normalize('NFKD', u'Ṗŕệṿïệẅ Ṯệẍt'), True),
        (unicodedata.normalize('NFKD', u'Ṗŕệṿïệẅ Ṯệẍt'),
         unicodedata.normalize('NFKD', u'Ṗŕệṿïệẅ Ṯệẍt'), False),
    )
    @ddt.unpack
    def test_password_unicode_normalization_login(self, password, password_entered, login_success):
        """
        Tests unicode normalization on user's passwords on login.
        """
        self.user.set_password(password)
        self.user.save()
        response, _ = self._login_response(self.user.email, password_entered)
        self._assert_response(response, success=login_success)

    def _login_response(
            self, email, password, patched_audit_log=None, extra_post_params=None, **extra
    ):
        """
        Post the login info
        """
        if patched_audit_log is None:
            patched_audit_log = 'openedx.core.djangoapps.user_authn.views.login.AUDIT_LOG'
        post_params = {'email': email, 'password': password}
        if extra_post_params is not None:
            post_params.update(extra_post_params)
        with patch(patched_audit_log) as mock_audit_log:
            result = self.client.post(self.url, post_params, **extra)
        return result, mock_audit_log

    def _assert_response(self, response, success=None, value=None, status_code=None, error_code=None):
        """
        Assert that the response has the expected status code and returned a valid
        JSON-parseable dict.

        If success is provided, assert that the response had that
        value for 'success' in the JSON dict.

        If value is provided, assert that the response contained that
        value for 'value' in the JSON dict.
        """
        expected_status_code = status_code or (400 if success is False else 200)
        self.assertEqual(response.status_code, expected_status_code)

        try:
            response_dict = json.loads(response.content.decode('utf-8'))
        except ValueError:
            self.fail(u"Could not parse response content as JSON: %s"
                      % str(response.content))

        if success is not None:
            self.assertEqual(response_dict['success'], success)

        if error_code is not None:
            self.assertEqual(response_dict['error_code'], error_code)

        if value is not None:
            msg = (u"'%s' did not contain '%s'" %
                   (six.text_type(response_dict['value']), six.text_type(value)))
            self.assertIn(value, response_dict['value'], msg)

    def _assert_redirect_url(self, response, expected_redirect_url):
        """
        Assert that the redirect URL is in the response and has the expected value.

        Assumes that response content is well-formed JSON
        (you can call `_assert_response` first to assert this).
        """
        response_dict = json.loads(response.content.decode('utf-8'))
        assert 'redirect_url' in response_dict, (
            "Response JSON unexpectedly does not have redirect_url: {!r}".format(
                response_dict
            )
        )
        assert response_dict['redirect_url'] == expected_redirect_url

    def _assert_audit_log(self, mock_audit_log, level, log_strings):
        """
        Check that the audit log has received the expected call as its last call.
        """
        method_calls = mock_audit_log.method_calls
        name, args, _kwargs = method_calls[-1]
        self.assertEqual(name, level)
        self.assertEqual(len(args), 1)
        format_string = args[0]
        for log_string in log_strings:
            self.assertIn(log_string, format_string)

    def _assert_not_in_audit_log(self, mock_audit_log, level, log_strings):
        """
        Check that the audit log has received the expected call as its last call.
        """
        method_calls = mock_audit_log.method_calls
        name, args, _kwargs = method_calls[-1]
        self.assertEqual(name, level)
        self.assertEqual(len(args), 1)
        format_string = args[0]
        for log_string in log_strings:
            self.assertNotIn(log_string, format_string)

    @ddt.data(
        {
            'switch_enabled': False,
            'whitelisted': False,
            'allowed_domain': 'edx.org',
            'user_domain': 'edx.org',
            'success': True,
            'is_third_party_authenticated': False
        },
        {
            'switch_enabled': False,
            'whitelisted': True,
            'allowed_domain': 'edx.org',
            'user_domain': 'edx.org',
            'success': True,
            'is_third_party_authenticated': False
        },
        {
            'switch_enabled': True,
            'whitelisted': False,
            'allowed_domain': 'edx.org',
            'user_domain': 'edx.org',
            'success': False,
            'is_third_party_authenticated': False
        },
        {
            'switch_enabled': True,
            'whitelisted': False,
            'allowed_domain': 'fake.org',
            'user_domain': 'edx.org',
            'success': True,
            'is_third_party_authenticated': False
        },
        {
            'switch_enabled': True,
            'whitelisted': True,
            'allowed_domain': 'edx.org',
            'user_domain': 'edx.org',
            'success': True,
            'is_third_party_authenticated': False
        },
        {
            'switch_enabled': True,
            'whitelisted': False,
            'allowed_domain': 'batman.gotham',
            'user_domain': 'batman.gotham',
            'success': False,
            'is_third_party_authenticated': False
        },
        {
            'switch_enabled': True,
            'whitelisted': True,
            'allowed_domain': 'edx.org',
            'user_domain': 'edx.org',
            'success': True,
            'is_third_party_authenticated': True
        },
        {
            'switch_enabled': False,
            'whitelisted': False,
            'allowed_domain': 'edx.org',
            'user_domain': 'fake.org',
            'success': True,
            'is_third_party_authenticated': True
        },
    )
    @ddt.unpack
    @skip_unless_lms
    def test_login_for_user_auth_flow(
        self,
        switch_enabled,
        whitelisted,
        allowed_domain,
        user_domain,
        success,
        is_third_party_authenticated
    ):
        """
        Verify that `login._check_user_auth_flow` works as expected.
        """
        provider = 'Google'
        provider_tpa_hint = 'saml-test'
        username = '******'
        user_email = '{username}@{domain}'.format(username=username, domain=user_domain)
        user = self._create_user(username, user_email)
        default_site_configuration_values = {
            'SITE_NAME': allowed_domain,
            'THIRD_PARTY_AUTH_ONLY_DOMAIN': allowed_domain,
            'THIRD_PARTY_AUTH_ONLY_PROVIDER': provider,
            'THIRD_PARTY_AUTH_ONLY_HINT': provider_tpa_hint,
        }

        with override_waffle_switch(ENABLE_LOGIN_USING_THIRDPARTY_AUTH_ONLY, switch_enabled):
            if not is_third_party_authenticated:
                site = self.set_up_site(allowed_domain, default_site_configuration_values)

                if whitelisted:
                    AllowedAuthUser.objects.create(site=site, email=user.email)
                else:
                    AllowedAuthUser.objects.filter(site=site, email=user.email).delete()

                if success:
                    value = None
                else:
                    value = u'As {0} user, You must login with your {0} <a href=\'{1}\'>{2} account</a>.'.format(
                        allowed_domain,
                        '{}?tpa_hint={}'.format(reverse("dashboard"), provider_tpa_hint),
                        provider,
                    )
                response, __ = self._login_response(user.email, self.password)
                self._assert_response(
                    response,
                    success=success,
                    value=value,
                )
            else:
                default_site_configuration_values.update({'ENABLE_THIRD_PARTY_AUTH': True})
                self.set_up_site(allowed_domain, default_site_configuration_values)
                with patch('openedx.core.djangoapps.user_authn.views.login.pipeline'):
                    with patch(
                        'openedx.core.djangoapps.user_authn.views.login._check_user_auth_flow'
                    ) as mock_check_user_auth_flow:
                        # user is already authenticated by third_party_auth then
                        # we should by-pass _check_user_auth_flow function
                        response, __ = self._login_response(user.email, self.password)
                        self._assert_response(
                            response,
                            success=success
                        )
                        self.assertFalse(mock_check_user_auth_flow.called)

    def test_check_user_auth_flow_bad_email(self):
        """Regression Exception was thrown on missing @ char in TPA."""
        provider = 'Google'
        provider_tpa_hint = 'saml-test'
        username = '******'
        invalid_email_user = self._create_user(username, username)
        allowed_domain = 'edx.org'
        default_site_configuration_values = {
            'SITE_NAME': allowed_domain,
            'THIRD_PARTY_AUTH_ONLY_DOMAIN': allowed_domain,
            'THIRD_PARTY_AUTH_ONLY_PROVIDER': provider,
            'THIRD_PARTY_AUTH_ONLY_HINT': provider_tpa_hint,
        }

        with override_waffle_switch(ENABLE_LOGIN_USING_THIRDPARTY_AUTH_ONLY, True):
            site = self.set_up_site(allowed_domain, default_site_configuration_values)

            with self.assertLogs(level='WARN') as log:
                _check_user_auth_flow(site, invalid_email_user)
                assert len(log.output) == 1
                assert "Shortcircuiting THIRD_PART_AUTH_ONLY_DOMAIN check." in log.output[0]
コード例 #52
0
 def __init__(self, *args, **kwargs):
     Transport.__init__(self, *args, **kwargs)
     self.client = Client()
コード例 #53
0
 def test_no_integration_api(self, db):
     url = self.BASE_URL + f"/rasa-conversations/integrations/?domain={TEST_DOMAIN}"
     client = Client()
     response = client.get(url)
     assert response.status_code == 200
     assert response.data == {}
コード例 #54
0
ファイル: test_admin.py プロジェクト: zhangqin/w3af-webui
class TestModelAdmin(unittest.TestCase):
    def setUp(self):
        # Every test needs a client.
        User.objects.all().delete()
        self.user_smb = User.objects.create_user('somebody__else',
                                                 '*****@*****.**',
                                                 'somebody__else')
        self.user_smb.is_staff = True
        self.user_smb.save()
        self.user = User.objects.create_user('new_unittest',
                                             '*****@*****.**',
                                             'new_test_password')
        init_user_group('w3af_webui')
        call_command('set_role_for_user', 'new_unittest')
        self.user.is_staff = True
        self.user.is_superuser = True
        self.user.save()
        self.client = Client()
        self.client.login(username=self.user.username,
                          password='******')
        self.profile = any_model(ScanProfile, user=self.user)
        self.target = any_model(Target, user=self.user)
        self.not_mine_target = any_model(Target, user=self.user_smb)
        self.scan_task = any_model(
            ScanTask,
            user=self.user,
            status=settings.TASK_STATUS['free'],
            target=self.target,
            last_updated='0',
        )
        self.scan = Scan.objects.create(
            scan_task=self.scan_task,
            data='test',
        )

    def tearDown(self):
        self.user.delete()
        self.user_smb.delete()
        self.profile.delete()
        Target.objects.all().delete()
        self.scan_task.delete()
        self.scan.delete()

    def test_scan_list(self):
        # Issue a GET request.
        response = self.client.get('/w3af_webui/scan/')
        # Check that the response is 200 OK.
        self.assertEqual(response.status_code, 200)

    def test_scantask_list(self):
        # ScanTask: Issue a GET request.
        response = self.client.get('/w3af_webui/scantask/')
        # Check that the response is 200 OK.
        self.assertEqual(response.status_code, 200)

    def test_edit_scantask(self):
        # Issue a GET request.
        response = self.client.get(
            '/w3af_webui/scantask/%s/' % self.scan_task.id,
            follow=True,
        )
        # Check that the response is 200 OK.
        self.assertEqual(response.status_code, 200)

    def test_target_list(self):
        # Target: Issue a GET request.
        response = self.client.get('/w3af_webui/target/')
        # Check that the response is 200 OK.
        self.assertEqual(response.status_code, 200)

    def test_edit_target(self):
        # My Target: Issue a GET request.
        response = self.client.get(
            '/w3af_webui/target/%s/' % self.target.id,
            follow=True,
        )
        # Check that the response is 200 OK.
        self.assertEqual(response.status_code, 200)
        return

    def test_scanprofile_list(self):
        # Target: Issue a GET request.
        response = self.client.get('/w3af_webui/scanprofile/')
        # Check that the response is 200 OK.
        self.assertEqual(response.status_code, 200)

    def test_edit_scanprofile(self):
        # Target: Issue a GET request.
        response = self.client.get(
            '/w3af_webui/scanprofile/%s/' % self.profile.id,
            follow=True,
        )
        # Check that the response is 200 OK.
        self.assertEqual(response.status_code, 200)
コード例 #55
0
ファイル: tests.py プロジェクト: renderbox/django-permafrost
class PermafrostViewTests(TestCase):
    fixtures = ['unit_test']

    def setUp(self):
        self.client = Client()
        self.pf_role = PermafrostRole.objects.create(category="staff", name="Test Role", site=Site.objects.get_current())
        PermafrostRole.objects.create(category="staff", name="Test Role", site=Site.objects.get(pk=2))
        self.super_user = get_user_model().objects.get(pk=1)
        self.client.force_login(self.super_user)

    def test_permafrost_base_url_resolves(self):
        found = resolve("/permafrost/")
        self.assertEqual(found.view_name, "permafrost:role-list")
        self.assertEqual(found.func.view_class, PermafrostRoleListView)
    
    def test_permafrost_manage_base_url_resolves(self):
        found = resolve("/permafrost/manage/")
        self.assertEqual(found.view_name, "permafrost:roles-manage")
        self.assertEqual(found.func.view_class, PermafrostRoleManageView)
    
    def test_permaforst_manage_single_role_object_in_context(self):
        uri = reverse('permafrost:roles-manage')
        response = self.client.get(uri)
        self.assertIn('object', response.context)
        self.assertEqual(response.context['object'], PermafrostRole.on_site.all().first())
    
    def test_manage_permafrost_roles_returns_correct_template(self):
        uri = reverse('permafrost:roles-manage')
        response = self.client.get(uri)
        objects = PermafrostRole.on_site.all()
        default_role = objects.first()
        self.assertTemplateUsed(response, 'permafrost/base.html')
        self.assertTemplateUsed(response, 'permafrost/permafrostrole_manage.html')

    def test_permafrostrole_manage_template_displays_list_of_roles_on_site(self):
        uri = reverse('permafrost:roles-manage')
        import html
        response = self.client.get(uri)
        objects = PermafrostRole.on_site.all()
        
        self.assertTrue(len(objects))
        
        for object in objects:
            self.assertContains(response, html.escape(f'{object}'))
    
    def test_permafrostrole_manage_template_displays_selected_role_details(self):
        uri = reverse('permafrost:roles-manage')
        response = self.client.get(uri)
        default_role = PermafrostRole.on_site.first()  
        self.assertContains(response, f'<h2>{default_role.name}</h2>')
        self.assertContains(response, f'<p>Role Type: <span class="font-weight-bold">{default_role.get_category_display()}</span></p>')
        self.assertContains(response, f'<p>{default_role.description}</p>')

    def test_permafrostrole_manage_template_displays_selected_role_permissions(self):
        ## arrange 
        default_role = PermafrostRole.on_site.first()
        optional_permission = Permission.objects.get_by_natural_key(*('view_permafrostrole', 'permafrost', 'permafrostrole')) 
        default_role.permissions_add(optional_permission)
        ## act
        uri = reverse('permafrost:roles-manage')
        response = self.client.get(uri)
        ## assert
        self.assertEqual(len(default_role.permissions().all()), 2)

        for permission in default_role.permissions().all():
            if permission.id in default_role.all_perm_ids():
                self.assertContains(response, f'{permission.name}')

    def test_permafrostrole_manage_template_hides_selected_role_permissions_not_in_permafrost_categories(self):
        ## arrange 
        default_role = PermafrostRole.on_site.first()
        ## act
        uri = reverse('permafrost:roles-manage')
        response = self.client.get(uri)
        ## assert
        self.assertEqual(len(default_role.permissions().all()), 1)

        for permission in default_role.permissions().all():
            if permission.id not in default_role.all_perm_ids():
                self.assertNotContains(response, f'{permission.name}')

    def test_list_view_returns_roles_on_current_site(self):
        uri = reverse('permafrost:role-list')
        response = self.client.get(uri)
        site_id = get_current_site()

        try:
            roles = response.context['object_list']
            self.assertTrue(all(role.site.id == site_id for role in roles))
        except:
            print("Returned site ids")
            print([role.site.id for role in response.context['object_list']])
            print("")
            pass
        pass
    
    def test_administration_create_url_resolves(self):
        found = resolve("/permafrost/role/create/")
        self.assertEqual(found.view_name, "permafrost:role-create")
        self.assertEqual(found.func.view_class, PermafrostRoleCreateView)
    
    def test_administration_create_url_response_with_correct_template(self):
        url = reverse("permafrost:role-create")
        response = self.client.get(url)
        ## ensure _create.html extends the base template
        self.assertTemplateUsed(response, "permafrost/base.html")
        
        self.assertTemplateUsed(response, "permafrost/permafrostrole_form.html")

    def test_select_role_type_form_renders_on_GET(self):
        url = reverse("permafrost:role-create")
        response = self.client.get(url)
        try:
            self.assertContains(response, "Create Role")
            self.assertContains(response, 'id="role_form"')
            self.assertContains(response, 'name="name"')
            self.assertContains(response, 'name="description"')
            self.assertContains(response, 'name="category"')

            self.assertIsInstance(response.context['form'], SelectPermafrostRoleTypeForm)
        except:
            print("")
            print(response.content.decode())
            raise
    
    def test_role_edit_url_resolves(self):
        found = resolve(f"/permafrost/role/{self.pf_role.slug}/update/")
        self.assertEqual(found.view_name, "permafrost:role-update")
        self.assertEqual(found.func.view_class, PermafrostRoleUpdateView)
    
    def test_administration_edit_url_response_with_correct_template(self):
        url = reverse("permafrost:role-update", kwargs={'slug': self.pf_role.slug})
        response = self.client.get(url)
        ## ensure _create.html extends the base template
        self.assertTemplateUsed(response, "permafrost/base.html")
        
        self.assertTemplateUsed(response, "permafrost/permafrostrole_form.html")
    
    def test_update_role_form_renders_on_GET(self):
        url = reverse("permafrost:role-update",  kwargs={'slug': self.pf_role.slug})
        response = self.client.get(url)
        try:
            self.assertContains(response, "Edit Permissions: Test Role")
            self.assertContains(response, 'id="role_form"')
            self.assertContains(response, 'name="name"')
            self.assertContains(response, 'name="description"')
            self.assertContains(response, 'name="category"')
            self.assertContains(response, 'name="permissions"')
            
            ## add deleted field down the line
            # self.assertContains(response, 'name="deleted"')
            
            self.assertIsInstance(response.context['form'], PermafrostRoleUpdateForm)
        except:
            print("")
            print(response.content.decode())
            raise
    
    def test_role_update_resolves(self):
        found = resolve('/permafrost/role/test-role/update/')
        self.assertEqual(found.view_name, "permafrost:role-update")
        self.assertEqual(found.func.view_class, PermafrostRoleUpdateView)

    def test_role_update_GET_returns_correct_template(self):
        uri = reverse('permafrost:role-update', kwargs={'slug': 'test-role'})
        response = self.client.get(uri)
        self.assertTemplateUsed(response, 'permafrost/base.html')
        self.assertTemplateUsed(response, 'permafrost/permafrostrole_form.html')

    def test_update_form_has_selected_optional_permission(self):
        ## add optional permissions
        self.pf_role.permissions_set(Permission.objects.filter(codename__in=['add_permafrostrole', 'change_permafrostrole']))
        
        uri = reverse('permafrost:role-update', kwargs={'slug': 'test-role'})
        response = self.client.get(uri)
        try:
            self.assertContains(response, """<input 
                                class="ml-auto" 
                                type="checkbox" 
                                name="permissions" 
                                value="37"
                                 checked
                            >""")
            self.assertContains(response, """<input 
                                class="ml-auto" 
                                type="checkbox" 
                                name="permissions" 
                                value="38"
                                 checked
                            >""")
        except:
            print("")
            print(response.content.decode())
            print("")
            raise
    
    def test_role_detail_GET_returns_404_if_not_on_current_site(self):
        uri = reverse('permafrost:role-update', kwargs={'slug': 'administrator'})
        response = self.client.get(uri)
        try:
            self.assertContains(response, "Not Found", status_code=404)
        except:
            print("")
            print(response.content.decode())
            raise

    def test_role_update_POST_updates_name(self):
        uri = reverse('permafrost:role-update', kwargs={'slug': 'test-role'})
        response = self.client.post(uri, data={'name': 'Test Change'}, follow=True)
        self.assertContains(response, "Test Change")
        updated_role = PermafrostRole.objects.get(pk=self.pf_role.pk)
        self.assertEqual(updated_role.name, "Test Change")
    
    def test_role_update_POST_updates_when_no_values_are_changed(self):
        uri = reverse('permafrost:role-update', kwargs={'slug': 'test-role'})
       
        request = RequestFactory().post(uri, data={'name': 'Test Role'}, follow=True)

        request.user = self.super_user
        request.site = Site.objects.get(pk=2)
        response = PermafrostRoleUpdateView.as_view()(request, slug='test-role')
        response.client = self.client
        self.assertRedirects(response, '/permafrost/role/test-role/')
        updated_role = PermafrostRole.objects.get(pk=self.pf_role.pk)

    
    def test_optional_permissions_are_updated_on_POST(self):
        ## ensure role currently has no optional permissions
        allowed_optional_permission_ids =[permission.id for permission in self.pf_role.optional_permissions()]
        current_permission_ids = [permission.id for permission in self.pf_role.permissions().all()]
        current_optional_permission_ids = [id for id in current_permission_ids if id in allowed_optional_permission_ids]
        
        self.assertFalse(current_optional_permission_ids)
        
        uri = reverse('permafrost:role-update', kwargs={'slug': 'test-role'})
        data = model_to_dict(self.pf_role)
        data.update({'permissions': ['37','38']})
        ## listcomp below used to remove 'description': None
        post_data = {k: v for k, v in data.items() if v is not None}
        self.client.post(uri, data=post_data, follow=True)
        
        updated_permission_ids_1 = [permission.id for permission in self.pf_role.permissions().all() if permission.id in allowed_optional_permission_ids]
        
        self.assertEqual(updated_permission_ids_1, [37, 38])
        
        ## remove one permission
        
        data.update({'permissions': ['37']})
        ## listcomp below used to remove 'description': None
        post_data = {k: v for k, v in data.items() if v is not None}
        self.client.post(uri, data=post_data, follow=True)

        updated_permission_ids_2 = [permission.id for permission in self.pf_role.permissions().all() if permission.id in allowed_optional_permission_ids]
        
        self.assertEqual(updated_permission_ids_2, [37])

    def test_optional_permissions_are_removed_when_empty_array_submitted_to_POST(self):
        ## arrange: add optional permissions
        self.pf_role.permissions_set(Permission.objects.filter(codename__in=['add_permafrostrole', 'change_permafrostrole']))
        
        ## ensure optional role count is 2
        allowed_optional_permission_ids =[permission.id for permission in self.pf_role.optional_permissions()]
        current_permission_ids = [permission.id for permission in self.pf_role.permissions().all()]
        current_optional_permission_ids = [id for id in current_permission_ids if id in allowed_optional_permission_ids]
        self.assertEqual(len(current_optional_permission_ids), 2)
        
        uri = reverse('permafrost:role-update', kwargs={'slug': 'test-role'})
        data = model_to_dict(self.pf_role)
        data.update({'optional_staff_perms': []})
        ## iterator below used to remove 'description': None
        data = {k: v for k, v in data.items() if v is not None}
        response = self.client.post(uri, data=data, follow=True)
        
        updated_permission_ids = [permission.id for permission in self.pf_role.permissions().all() if permission.id in allowed_optional_permission_ids]
        try:
            self.assertEqual(updated_permission_ids, [])
        except:
            print("")
            print(response.content.decode())
            print("")
            raise

    def test_delete_role_POST(self):
        uri = reverse('permafrost:role-update', kwargs={'slug': 'test-role'})
        data = model_to_dict(self.pf_role)
        data.update({'deleted': True})
        ## iterator below used to remove 'description': None
        data = {k: v for k, v in data.items() if v is not None}
        response = self.client.post(uri, data=data, follow=True)
        
        try:
            updated_role = PermafrostRole.objects.get(slug=self.pf_role.slug, site__id=1)
            self.assertEqual(updated_role.deleted, True)
        except:
            print("")
            print(model_to_dict(PermafrostRole.objects.get(slug=self.pf_role.slug, site__id=1)))
            print("")
            raise
    
    def test_site_added_on_create_POST(self):
        site = get_current_site()
        data = {
            'name': 'Test Site Role',
            'description': 'Test guaranteed site added on create',
            'category': 'user'
        }
        uri = reverse('permafrost:role-create')
        response = self.client.post(uri , data=data)
        try:
            role = PermafrostRole.objects.get(name='Test Site Role')
            self.assertEqual(role.site.id, site)
        except:
            print("")
            print(response.content.decode())
            print("")
            raise
コード例 #56
0
ファイル: _pythonrc.py プロジェクト: WoodNFern/dotfiles
# If we're working with a Django project, set up the environment
if 'DJANGO_SETTINGS_MODULE' in os.environ:
    from django.db.models.loading import get_models
    from django.test.client import Client
    from django.test.utils import setup_test_environment, teardown_test_environment
    from django.conf import settings as S

    class DjangoModels(object):
        """Loop through all the models in INSTALLED_APPS and import them."""
        def __init__(self):
            for m in get_models():
                setattr(self, m.__name__, m)

    A = DjangoModels()
    C = Client()

    WELCOME += """%(Green)s
    Django environment detected.
* Your INSTALLED_APPS models are available as `A`.
* Your project settings are available as `S`.
* The Django test client is available as `C`.
%(Normal)s""" % _c

    setup_test_environment()
    S.DEBUG_PROPAGATE_EXCEPTIONS = True

    WELCOME += """%(LightPurple)s
Warning: the Django test environment has been set up; to restore the
normal environment call `teardown_test_environment()`.
コード例 #57
0
 def test_empty_guns(self):
     client = Client()
     response = client.get('/guns/')
     self.assertIsInstance(response, HttpResponse)
     self.assertEquals(('Content-Type', 'application/json'),
                       response._headers['content-type'])
コード例 #58
0
ファイル: tests.py プロジェクト: renderbox/django-permafrost
 def setUp(self):
     self.client = Client()
     self.pf_role = PermafrostRole.objects.create(category="staff", name="Test Role", site=Site.objects.get_current())
     PermafrostRole.objects.create(category="staff", name="Test Role", site=Site.objects.get(pk=2))
     self.super_user = get_user_model().objects.get(pk=1)
     self.client.force_login(self.super_user)
コード例 #59
0
ファイル: tests.py プロジェクト: Golls/wikimedia-cz-tracker
 def test_access_rights(self):
     user = {'user': User.objects.create(username='******'), 'password': '******'}
     staffer = {'user': User.objects.create(username='******', is_staff=True), 'password': '******'}
     superuser = {'user': User.objects.create(username='******', is_staff=True, is_superuser=True), 'password': '******'}
     for u in (user, staffer, superuser):
         u['user'].set_password(u['password'])
         u['user'].save()
     testConfigurations = [
         {
             'type': 'grant',
             'normal': 403,
             'staffer': 302,
             'superuser': 302,
         },
         {
             'type': 'topic',
             'normal': 403,
             'staffer': 302,
             'superuser': 302,
         },
         {
             'type': 'user',
             'normal': 403,
             'staffer': 403,
             'superuser': 302,
         },
         {
             'type': 'ticket',
             'normal': 302,
             'staffer': 302,
             'superuser': 302
         },
     ]
     for testConfiguration in testConfigurations:
         c = Client()
         c.login(username=user['user'].username, password=user['password'])  # Login with normal user account
         response = c.post(reverse('importcsv'), {
             'type': testConfiguration['type'],
             'csvfile': self.get_test_data(testConfiguration['type'])
         })
         self.assertEqual(testConfiguration['normal'], response.status_code)
         self.reset_attempt(testConfiguration['type'])
         c = Client()
         c.login(username=staffer['user'].username, password=staffer['password'])  # Login with staffer user account
         response = c.post(reverse('importcsv'), {
             'type': testConfiguration['type'],
             'csvfile': self.get_test_data(testConfiguration['type'])
         })
         self.assertEqual(testConfiguration['staffer'], response.status_code)
         self.reset_attempt(testConfiguration['type'])
         c = Client()
         c.login(username=superuser['user'].username, password=superuser['password'])  # Login with superuser user account
         response = c.post(reverse('importcsv'), {
             'type': testConfiguration['type'],
             'csvfile': self.get_test_data(testConfiguration['type'])
         })
         self.assertEqual(testConfiguration['superuser'], response.status_code)
コード例 #60
0
 def test_gun_doesnt_exist(self):
     client = Client()
     response = client.get('/guns/7654/')
     self.assertEquals(404, response.status_code)