Python UserFactory.reload方法代码示例

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
class TestHamUserRestore(AdminTestCase):
    def setUp(self):
        self.user = UserFactory()
        self.request = RequestFactory().post('/fake_path')
        self.view = views.HamUserRestoreView
        self.view = setup_log_view(self.view, self.request, guid=self.user._id)

        self.spam_confirmed, created = Tag.objects.get_or_create(name='spam_confirmed')
        self.ham_confirmed, created = Tag.objects.get_or_create(name='ham_confirmed')

    def test_get_object(self):
        obj = self.view().get_object()
        nt.assert_is_instance(obj, OSFUser)

    def test_get_context(self):
        res = self.view().get_context_data(object=self.user)
        nt.assert_in('guid', res)
        nt.assert_equal(res.get('guid'), self.user._id)

    def test_enable_user(self):
        self.user.disable_account()
        self.user.save()
        nt.assert_true(self.user.is_disabled)
        self.view().delete(self.request)
        self.user.reload()

        nt.assert_false(self.user.is_disabled)
        nt.assert_false(self.user.all_tags.filter(name=self.spam_confirmed.name).exists())
        nt.assert_true(self.user.all_tags.filter(name=self.ham_confirmed.name).exists())

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
class TestDisableUser(AdminTestCase):
    def setUp(self):
        self.user = UserFactory()
        self.request = RequestFactory().post('/fake_path')
        self.view = views.UserDeleteView
        self.view = setup_log_view(self.view, self.request, guid=self.user._id)

    def test_get_object(self):
        obj = self.view().get_object()
        nt.assert_is_instance(obj, OSFUser)

    def test_get_context(self):
        res = self.view().get_context_data(object=self.user)
        nt.assert_in('guid', res)
        nt.assert_equal(res.get('guid'), self.user._id)

    def test_disable_user(self):
        settings.ENABLE_EMAIL_SUBSCRIPTIONS = False
        count = AdminLogEntry.objects.count()
        self.view().delete(self.request)
        self.user.reload()
        nt.assert_true(self.user.is_disabled)
        nt.assert_equal(AdminLogEntry.objects.count(), count + 1)

    def test_reactivate_user(self):
        settings.ENABLE_EMAIL_SUBSCRIPTIONS = False
        self.view().delete(self.request)
        count = AdminLogEntry.objects.count()
        self.view().delete(self.request)
        self.user.reload()
        nt.assert_false(self.user.is_disabled)
        nt.assert_equal(AdminLogEntry.objects.count(), count + 1)

    def test_no_user(self):
        view = setup_view(views.UserDeleteView(), self.request, guid='meh')
        with nt.assert_raises(Http404):
            view.delete(self.request)

    def test_no_user_permissions_raises_error(self):
        user = UserFactory()
        guid = user._id
        request = RequestFactory().get(reverse('users:disable', kwargs={'guid': guid}))
        request.user = user

        with self.assertRaises(PermissionDenied):
            self.view.as_view()(request, guid=guid)

    def test_correct_view_permissions(self):
        user = UserFactory()
        guid = user._id

        change_permission = Permission.objects.get(codename='change_osfuser')
        user.user_permissions.add(change_permission)
        user.save()

        request = RequestFactory().get(reverse('users:disable', kwargs={'guid': guid}))
        request.user = user

        response = self.view.as_view()(request, guid=guid)
        self.assertEqual(response.status_code, 200)

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
    def test_multiple_users_associated(self):
        # Create only one ExternalAccount for multiple OSF users
        #
        # For some providers (ex: GitHub), the act of completing the OAuth flow
        # revokes previously generated credentials. In addition, there is often no
        # way to know the user's id on the external service until after the flow
        # has completed.
        #
        # Having only one ExternalAccount instance per account on the external
        # service means that connecting subsequent OSF users to the same external
        # account will not invalidate the credentials used by the OSF for users
        # already associated.
        user_a = UserFactory()
        external_account = ExternalAccountFactory(
            provider='mock2',
            provider_id='mock_provider_id',
            provider_name='Mock Provider',
        )
        user_a.external_accounts.add(external_account)
        user_a.save()

        user_b = UserFactory()

        # Mock the exchange of the code for an access token
        _prepare_mock_oauth2_handshake_response()

        # Fake a request context for the callback
        with self.app.app.test_request_context(
                path="/oauth/callback/mock2/",
                query_string="code=mock_code&state=mock_state"
        ) as ctx:

            # make sure the user is logged in
            authenticate(user=user_b, access_token=None, response=None)

            session.data['oauth_states'] = {
                self.provider.short_name: {
                    'state': 'mock_state',
                },
            }
            session.save()

            # do the key exchange
            self.provider.auth_callback(user=user_b)

        user_a.reload()
        user_b.reload()
        external_account.reload()

        assert_equal(
            list(user_a.external_accounts.values_list('pk', flat=True)),
            list(user_b.external_accounts.values_list('pk', flat=True)),
        )

        assert_equal(
            ExternalAccount.objects.all().count(),
            1
        )

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
 def test_subscribe_fake_email_does_not_throw_validation_error(self, mock_get_mailchimp_api):
     list_name = 'foo'
     user = UserFactory(username='[email protected]')
     mock_client = mock.MagicMock()
     mock_get_mailchimp_api.return_value = mock_client
     mock_client.lists.list.return_value = {'data': [{'id': 1, 'list_name': list_name}]}
     mock_client.lists.subscribe.side_effect = mailchimp.ValidationError
     mailchimp_utils.subscribe_mailchimp(list_name, user._id)
     handlers.celery_teardown_request()
     user.reload()
     assert_false(user.mailchimp_mailing_lists[list_name])

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
    def test_disconnect_with_multiple_connected(self):
        # Disconnect an account connected to multiple users from one user
        external_account = ExternalAccountFactory(
            provider='mock2',
            provider_id='mock_provider_id',
            provider_name='Mock Provider',
        )
        self.user.external_accounts.add(external_account)
        self.user.save()

        other_user = UserFactory()
        other_user.external_accounts.add(external_account)
        other_user.save()

        response = self.app.delete(
            api_url_for('oauth_disconnect',
                        external_account_id=external_account._id),
            auth=self.user.auth
        )

        # Request succeeded
        assert_equal(
            response.status_code,
            http.OK,
        )

        self.user.reload()

        # External account has been disassociated with the user
        assert_not_in(
            external_account,
            self.user.external_accounts.all(),
        )

        # External account is still in the database
        assert_equal(ExternalAccount.objects.all().count(), 1)

        other_user.reload()

        # External account is still associated with the other user
        assert_in(
            external_account,
            other_user.external_accounts.all(),
        )

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
class TestCASTicketAuthentication(OsfTestCase):

    def setUp(self):
        OsfTestCase.setUp(self)
        self.user = UserFactory()

    @mock.patch('framework.auth.cas.get_user_from_cas_resp')
    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_success(self, mock_service_validate, mock_get_user_from_cas_resp):
        mock_service_validate.return_value = make_successful_response(self.user)
        mock_get_user_from_cas_resp.return_value = (self.user, None, 'authenticate')
        ticket = fake.md5()
        service_url = 'http://localhost:5000/'
        resp = cas.make_response_from_ticket(ticket, service_url)
        assert_equal(resp.status_code, 302)
        assert_equal(mock_service_validate.call_count, 1)
        assert_equal(mock_get_user_from_cas_resp.call_count, 1)

    @mock.patch('framework.auth.cas.get_user_from_cas_resp')
    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_failure(self, mock_service_validate, mock_get_user_from_cas_resp):
        mock_service_validate.return_value = make_failure_response()
        mock_get_user_from_cas_resp.return_value = (None, None, None)
        ticket = fake.md5()
        service_url = 'http://localhost:5000/'
        resp = cas.make_response_from_ticket(ticket, service_url)
        assert_equal(resp.status_code, 302)
        assert_equal(mock_service_validate.call_count, 1)
        assert_equal(mock_get_user_from_cas_resp.call_count, 0)

    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_invalidates_verification_key(self, mock_service_validate):
        self.user.verification_key = fake.md5()
        self.user.save()
        mock_service_validate.return_value = make_successful_response(self.user)
        ticket = fake.md5()
        service_url = 'http://localhost:5000/'
        resp = cas.make_response_from_ticket(ticket, service_url)
        self.user.reload()
        assert_true(self.user.verification_key is None)

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
class TestForgotPassword(OsfTestCase):

    def setUp(self):
        super(TestForgotPassword, self).setUp()
        self.user = UserFactory()
        self.auth_user = AuthUserFactory()
        self.get_url = web_url_for('forgot_password_get')
        self.post_url = web_url_for('forgot_password_post')
        self.user.verification_key_v2 = {}
        self.user.save()

    # log users out before they land on forgot password page
    def test_forgot_password_logs_out_user(self):
        # visit forgot password link while another user is logged in
        res = self.app.get(self.get_url, auth=self.auth_user.auth)
        # check redirection to CAS logout
        assert_equal(res.status_code, 302)
        location = res.headers.get('Location')
        assert_not_in('reauth', location)
        assert_in('logout?service=', location)
        assert_in('forgotpassword', location)

    # test that forgot password page is loaded correctly
    def test_get_forgot_password(self):
        res = self.app.get(self.get_url)
        assert_equal(res.status_code, 200)
        assert_in('Forgot Password', res.body)
        assert_in('forgotPasswordForm', res.forms)

    # test that existing user can receive reset password email
    @mock.patch('framework.auth.views.mails.send_mail')
    def test_can_receive_reset_password_email(self, mock_send_mail):
        # load forgot password page and submit email
        res = self.app.get(self.get_url)
        form = res.forms['forgotPasswordForm']
        form['forgot_password-email'] = self.user.username
        res = form.submit()

        # check mail was sent
        assert_true(mock_send_mail.called)
        # check http 200 response
        assert_equal(res.status_code, 200)
        # check request URL is /forgotpassword
        assert_equal(res.request.path, self.post_url)
        # check push notification
        assert_in_html('If there is an OSF account', res)
        assert_not_in_html('Please wait', res)

        # check verification_key_v2 is set
        self.user.reload()
        assert_not_equal(self.user.verification_key_v2, {})

    # test that non-existing user cannot receive reset password email
    @mock.patch('framework.auth.views.mails.send_mail')
    def test_cannot_receive_reset_password_email(self, mock_send_mail):
        # load forgot password page and submit email
        res = self.app.get(self.get_url)
        form = res.forms['forgotPasswordForm']
        form['forgot_password-email'] = 'fake' + self.user.username
        res = form.submit()

        # check mail was not sent
        assert_false(mock_send_mail.called)
        # check http 200 response
        assert_equal(res.status_code, 200)
        # check request URL is /forgotpassword
        assert_equal(res.request.path, self.post_url)
        # check push notification
        assert_in_html('If there is an OSF account', res)
        assert_not_in_html('Please wait', res)

        # check verification_key_v2 is not set
        self.user.reload()
        assert_equal(self.user.verification_key_v2, {})

    # test that non-existing user cannot receive reset password email
    @mock.patch('framework.auth.views.mails.send_mail')
    def test_not_active_user_no_reset_password_email(self, mock_send_mail):
        self.user.disable_account()
        self.user.save()

        # load forgot password page and submit email
        res = self.app.get(self.get_url)
        form = res.forms['forgotPasswordForm']
        form['forgot_password-email'] = self.user.username
        res = form.submit()

        # check mail was not sent
        assert_false(mock_send_mail.called)
        # check http 200 response
        assert_equal(res.status_code, 200)
        # check request URL is /forgotpassword
        assert_equal(res.request.path, self.post_url)
        # check push notification
        assert_in_html('If there is an OSF account', res)
        assert_not_in_html('Please wait', res)

        # check verification_key_v2 is not set
        self.user.reload()
        assert_equal(self.user.verification_key_v2, {})
#.........这里部分代码省略.........

# 需要导入模块: from osf_tests.factories import UserFactory [as 别名]
# 或者: from osf_tests.factories.UserFactory import reload [as 别名]
class TestCASExternalLogin(OsfTestCase):

    def setUp(self):
        super(TestCASExternalLogin, self).setUp()
        self.user = UserFactory()

    def test_get_user_from_cas_resp_already_authorized(self):
        mock_response = make_external_response()
        validated_creds = cas.validate_external_credential(mock_response.user)
        self.user.external_identity = {
            validated_creds['provider']: {
                validated_creds['id']: 'VERIFIED'
            }
        }
        self.user.save()
        user, external_credential, action = cas.get_user_from_cas_resp(mock_response)
        assert_equal(user._id, self.user._id)
        assert_equal(external_credential, validated_creds)
        assert_equal(action, 'authenticate')

    def test_get_user_from_cas_resp_not_authorized(self):
        user, external_credential, action = cas.get_user_from_cas_resp(make_external_response())
        assert_equal(user, None)
        assert_true(external_credential is not None)
        assert_equal(action, 'external_first_login')

    @mock.patch('framework.auth.cas.get_user_from_cas_resp')
    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_with_user(self, mock_service_validate, mock_get_user_from_cas_resp):
        mock_response = make_external_response()
        mock_service_validate.return_value = mock_response
        validated_creds = cas.validate_external_credential(mock_response.user)
        self.user.external_identity = {
            validated_creds['provider']: {
                validated_creds['id']: 'VERIFIED'
            }
        }
        self.user.save()
        mock_get_user_from_cas_resp.return_value = (self.user, validated_creds, 'authenticate')
        ticket = fake.md5()
        service_url = 'http://localhost:5000/'
        resp = cas.make_response_from_ticket(ticket, service_url)
        assert_equal(mock_service_validate.call_count, 1)
        assert_true(mock_get_user_from_cas_resp.call_count, 1)
        assert_equal(resp.status_code, 302)
        assert_in('/logout?service=', resp.headers['Location'])
        assert_in('/login?service=', resp.headers['Location'])

    @mock.patch('framework.auth.cas.get_user_from_cas_resp')
    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_no_user(self, mock_service_validate, mock_get_user_from_cas_resp):
        mock_response = make_external_response()
        mock_service_validate.return_value = mock_response
        validated_creds = cas.validate_external_credential(mock_response.user)
        mock_get_user_from_cas_resp.return_value = (None, validated_creds, 'external_first_login')
        ticket = fake.md5()
        service_url = 'http://localhost:5000/'
        resp = cas.make_response_from_ticket(ticket, service_url)
        assert_equal(mock_service_validate.call_count, 1)
        assert_true(mock_get_user_from_cas_resp.call_count, 1)
        assert_equal(resp.status_code, 302)
        assert_equal(resp.location, '/external-login/email')

    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_generates_new_verification_key(self, mock_service_validate):
        self.user.verification_key = fake.md5()
        self.user.save()
        mock_response = make_external_response()
        validated_creds = cas.validate_external_credential(mock_response.user)
        self.user.external_identity = {
            validated_creds['provider']: {
                validated_creds['id']: 'VERIFIED'
            }
        }
        self.user.save()
        mock_service_validate.return_value = mock_response
        ticket = fake.md5()
        service_url = 'http://localhost:5000/'
        verification_key = self.user.verification_key
        resp = cas.make_response_from_ticket(ticket, service_url)
        self.user.reload()
        assert_not_equal(self.user.verification_key, verification_key)

    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_handles_unicode(self, mock_service_validate):
        mock_response = make_external_response(unicode=True)
        mock_service_validate.return_value = mock_response
        ticket = fake.md5()
        service_url = 'http://localhost:5000/'
        resp = cas.make_response_from_ticket(ticket, service_url)
        assert_equal(resp.status_code, 302)
        assert_equal(mock_service_validate.call_count, 1)
        first_call_args = mock_service_validate.call_args[0]
        assert_equal(first_call_args[0], ticket)
        assert_equal(first_call_args[1], 'http://localhost:5000/')

    @mock.patch('framework.auth.cas.CasClient.service_validate')
    def test_make_response_from_ticket_handles_non_unicode(self, mock_service_validate):
        mock_response = make_external_response()
        mock_service_validate.return_value = mock_response
#.........这里部分代码省略.........