def _test_authorize_template(self, response_type="supported_grant", factory_ex=None, handler_ex=None): '''This method provides a template method for testing handle_authorize method from oauth2 controller.''' expected_response = Mock() client_facade = Mock() client_facade.session = Mock() request = Mock() request.params = {"response_type": response_type} request.models = Mock() request.models.Client = client_facade grant_handler = Mock() if not handler_ex: grant_handler.handle_grant = Mock(return_value=expected_response) else: grant_handler.handle_grant = Mock(side_effect=handler_ex) if not factory_ex: self._handlers_factory.get_handler = Mock(return_value=grant_handler) else: self._handlers_factory.get_handler = Mock(side_effect=factory_ex) response = self._oauth2_controller.handle_authorize(request) self.assertEqual(expected_response, response) self._handlers_factory.get_handler.assert_called_once_with("supported_grant", client_facade.session) grant_handler.handle_grant.assert_called_once_with(request)
def test_change_plan_form(self): request = Mock() request.META = {} request.session = DummySession() user = get_user_model().objects.create_user(username="******") user.set_password("eldarion") user.save() customer = CustomerProxy.objects.create( stripe_id="cus_1", user=user ) plan = PlanProxy.objects.create( amount=10, currency="usd", interval="monthly", interval_count=1, name="Pro" ) SubscriptionProxy.objects.create( customer=customer, plan=plan, quantity=1, start=timezone.now(), status="active", cancel_at_period_end=False ) user = authenticate(username="******", password="******") login(request, user) context = { "request": request } change_plan_form(context) self.assertTrue("form" in context)
def test_put_request(self): middleware = DBRoutingMiddleware() request = Mock(spec=HttpRequest, method='PUT') request.session = {} output = middleware.process_request(request) self.assertIsNone(output) self.assertTrue(is_thread_readwrite())
def test_change_plan_form(self): request = Mock() request.META = {} request.session = DummySession() user = get_user_model().objects.create_user(username="******") user.set_password("eldarion") user.save() PaymentPlan.objects.bulk_create(PLANS) customer = Customer.objects.create( stripe_id="cus_1", user=user ) CurrentSubscription.objects.create( customer=customer, plan=PaymentPlan.objects.get(key="pro"), quantity=1, start=timezone.now(), status="active", cancel_at_period_end=False, amount=decimal.Decimal("19.99") ) user = authenticate(username="******", password="******") login(request, user) context = { "request": request } change_plan_form(context) self.assertTrue("form" in context)
def test_create_new_profile(self, message_mock): """Test that a new profile is created through Firefox Accounts.""" claims = { 'email': '*****@*****.**', 'uid': 'my_unique_fxa_id', 'avatar': 'http://example.com/avatar', 'locale': 'en-US', 'displayName': 'Crazy Joe Davola', } request_mock = Mock(spec=HttpRequest) request_mock.session = {} self.backend.claims = claims self.backend.request = request_mock users = User.objects.all() eq_(users.count(), 0) self.backend.create_user(claims) users = User.objects.all() eq_(users.count(), 1) eq_(users[0].email, '*****@*****.**') eq_(users[0].username, 'bar') eq_(users[0].profile.fxa_uid, 'my_unique_fxa_id') eq_(users[0].profile.fxa_avatar, 'http://example.com/avatar') eq_(users[0].profile.locale, 'en-US') eq_(users[0].profile.name, 'Crazy Joe Davola') eq_(0, users[0].groups.count()) message_mock.success.assert_called()
def test_set_flavour_with_session_backend(self): original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND try: settings.FLAVOURS_STORAGE_BACKEND = 'session' request = Mock() request.session = {} set_flavour('mobile', request=request) self.assertEqual(request.session, {}) set_flavour('mobile', request=request, permanent=True) self.assertEqual(request.session, { settings.FLAVOURS_SESSION_KEY: u'mobile' }) self.assertEqual(get_flavour(request), 'mobile') response = self.client.get('/') self.assertFalse('sessionid' in response.cookies) response = self.client.get('/', { settings.FLAVOURS_GET_PARAMETER: 'mobile', }) self.assertTrue('sessionid' in response.cookies) sessionid = response.cookies['sessionid'].value session = Session.objects.get(session_key=sessionid) session_data = session.get_decoded() self.assertTrue(settings.FLAVOURS_SESSION_KEY in session_data) self.assertEqual(session_data[settings.FLAVOURS_SESSION_KEY], 'mobile') finally: settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def test_get(self): request = Mock(spec_set=['GET', 'session']) request.session = {} show = 10 func_name = 'func_name' name = 'name' order_by = 'Time' request.GET = { 'show': show, 'func_name': func_name, 'name': name, 'order_by': order_by } context = ProfilingView()._create_context(request) self.assertDictContainsSubset( { 'show': show, 'order_by': order_by, 'func_name': func_name, 'name': name, 'options_show': ProfilingView.show, 'options_order_by': ProfilingView.order_by, 'options_func_names': ProfilingView()._get_function_names() }, context) self.assertIn('results', context)
def test_create_new_contributor(self, message_mock): """ Test that a new contributor can be created through Firefox Accounts if is_contributor is True in session """ GroupFactory(name=CONTRIBUTOR_GROUP) claims = { 'email': '*****@*****.**', 'uid': 'abc123', 'avatar': 'http://example.com/avatar', 'locale': 'en-US' } request_mock = Mock(spec=HttpRequest) request_mock.LANGUAGE_CODE = 'en' request_mock.session = { 'is_contributor': True } self.backend.claims = claims self.backend.request = request_mock users = User.objects.all() eq_(users.count(), 0) self.backend.create_user(claims) users = User.objects.all() eq_(CONTRIBUTOR_GROUP, users[0].groups.all()[0].name) ok_('is_contributor' not in request_mock.session) message_mock.success.assert_called()
def test_login_and_store_credentials_in_session(self): # only testing custom logic, which happens on POST # everything else is handled by django.contrib.auth mockrequest = Mock() mockrequest.method = 'POST' def not_logged_in(rqst): rqst.user.is_authenticated.return_value = False def set_logged_in(rqst): rqst.user.is_authenticated.return_value = True rqst.POST.get.return_value = "TEST_PASSWORD" # failed login with patch('eulfedora.views.authviews.login', new=Mock(side_effect=not_logged_in)): mockrequest.session = dict() response = login_and_store_credentials_in_session(mockrequest) self.assert_(FEDORA_PASSWORD_SESSION_KEY not in mockrequest.session, 'user password for fedora should not be stored in session on failed login') # successful login with patch('eulfedora.views.authviews.login', new=Mock(side_effect=set_logged_in)): response = login_and_store_credentials_in_session(mockrequest) self.assert_(FEDORA_PASSWORD_SESSION_KEY in mockrequest.session, 'user password for fedora should be stored in session on successful login') # test password stored in the mock request pwd = mockrequest.POST.get() # encrypted password stored in session sessionpwd = mockrequest.session[FEDORA_PASSWORD_SESSION_KEY] self.assertNotEqual(pwd, sessionpwd, 'password should not be stored in the session without encryption') self.assertEqual(pwd, cryptutil.decrypt(sessionpwd), 'user password stored in session is encrypted')
def test_set_flavour_with_session_backend(self): original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND try: settings.FLAVOURS_STORAGE_BACKEND = "session" request = Mock() request.session = {} set_flavour("mobile", request=request) self.assertEqual(request.session, {}) set_flavour("mobile", request=request, permanent=True) self.assertEqual( request.session, {settings.FLAVOURS_SESSION_KEY: "mobile"} ) self.assertEqual(get_flavour(request), "mobile") response = self.client.get("/") self.assertFalse("sessionid" in response.cookies) response = self.client.get( "/", {settings.FLAVOURS_GET_PARAMETER: "mobile",} ) self.assertTrue("sessionid" in response.cookies) sessionid = response.cookies["sessionid"].value session = Session.objects.get(session_key=sessionid) session_data = session.get_decoded() self.assertTrue(settings.FLAVOURS_SESSION_KEY in session_data) self.assertEqual(session_data[settings.FLAVOURS_SESSION_KEY], "mobile") finally: settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def _test_request(self, domain, path, response_code=200, expected_event=True): request = Mock() request.path = path request.domain = domain request.GET = {} request.POST = {} request.META = { 'HTTP_X_FORWARDED_FOR': '10.99.100.1' } request.user = Mock() request.user.is_authenticated = True request.user.username = '******' request.couch_user = self.user request.session = Mock() request.session.session_key = uuid.uuid4().hex response = Mock() response.status_code = response_code ICDSAuditMiddleware().process_response(request, response) events = list(ICDSAuditEntryRecord.objects.all()) event = events[0] if events else None if expected_event: self.assertIsNotNone(event) self.assertEqual(event.url, path) self.assertEqual(event.response_code, response_code) else: self.assertIsNone(event)
def test_transfer_error(self, mock_vofile): vofile = MagicMock() mock_vofile.return_value = vofile vospace_url = 'https://somevospace.server/vospace' session = Mock() session.get.side_effect = [Mock(content='COMPLETED')] conn = Mock(spec=Connection) conn.session = session test_client = Client() # use the mocked connection instead of the real one test_client.conn = conn # job successfully completed vofile.read.side_effect = [b'QUEUED', b'COMPLETED'] self.assertFalse(test_client.get_transfer_error( vospace_url + '/results/transferDetails', 'vos://vospace')) session.get.assert_called_once_with(vospace_url + '/phase', allow_redirects=False) # job suspended session.reset_mock() session.get.side_effect = [Mock(content=b'COMPLETED')] vofile.read.side_effect = [b'QUEUED', b'SUSPENDED'] with self.assertRaises(OSError): test_client.get_transfer_error( vospace_url + '/results/transferDetails', 'vos://vospace') # check arguments for session.get calls self.assertEquals( [call(vospace_url + '/phase', allow_redirects=False)], session.get.call_args_list) # job encountered an internal error session.reset_mock() vofile.read.side_effect = Mock(side_effect=[b'QUEUED', b'ERROR']) session.get.side_effect = [Mock(content=b'COMPLETED'), Mock(text='InternalFault')] with self.assertRaises(OSError): test_client.get_transfer_error( vospace_url + '/results/transferDetails', 'vos://vospace') self.assertEquals([call(vospace_url + '/phase', allow_redirects=False), call(vospace_url + '/error')], session.get.call_args_list) # job encountered an unsupported link error session.reset_mock() link_file = 'testlink.fits' vofile.read.side_effect = Mock(side_effect=[b'QUEUED', b'ERROR']) session.get.side_effect = [Mock(content=b'COMPLETED'), Mock( text="Unsupported link target: " + link_file)] self.assertEquals(link_file, test_client.get_transfer_error( vospace_url + '/results/transferDetails', 'vos://vospace')) self.assertEquals([call(vospace_url + '/phase', allow_redirects=False), call(vospace_url + '/error')], session.get.call_args_list)
def test_show_failure_message_when_delete_admin_unit_fails(self): request = Mock() request.session = {} admin_unit_manager = Mock() request.method = 'POST' request.POST.side_effect = Exception response = views.delete_administrative_unit(request, admin_unit_manager) self.assertEquals(request.session['message'], "Unable to delete Admin unit")
def test_do_logout(self): registry = Mock() registry.prefs = self.prefs registry.session = "foobar" cli = self._makeit(registry) cli.onecmd('logout') self.assertEqual(None, cli.registry.session)
def test_get_request(self): # Get request uses replica DB if not pinned middleware = DBRoutingMiddleware() request = Mock(spec=HttpRequest, method='GET') request.session = {} output = middleware.process_request(request) self.assertIsNone(output) self.assertFalse(is_thread_readwrite())
def test_create_courseref_only_lti(self, mocked): """ Test that only LTI is allowed. """ request = Mock() request.session = {} res = create_courseref(request) self.assertEqual(res.content, 'Only LTI allowed')
def test_set_flavour_permanent(self): request = Mock() request.session = MagicMock() set_flavour("mobile", request=request) self.assertEqual(request.session.__setitem__.call_args, None) set_flavour("mobile", request=request, permanent=True) self.assertEqual(request.session.__setitem__.call_args, ((settings.FLAVOURS_SESSION_KEY, "mobile"), {}))
def test_delete_admin_unit(self): request = Mock() request.session = {} admin_unit_manager = Mock() request.method = 'POST' request.POST.get.return_value = 1 admin_unit_manager.get.delete.return_value = "" response = views.delete_administrative_unit(request, admin_unit_manager) self.assertEquals(request.session['message'], "Admin unit has been deleted successfully")
def test_get_default_view_smartphone(self): request = Mock() request.META = {'HTTP_USER_AGENT': ''} request.session = {} with patch('wirecloud.platform.views.ua_parse') as ua_parse_mock: ua_parse_mock.return_value = Mock(is_mobile=True) self.assertEqual(get_default_view(request), 'smartphone') self.assertEqual(request.session['default_mode'], 'smartphone')
def test_set_flavour_permanent(self): request = Mock() request.session = MagicMock() set_flavour('mobile', request=request) self.assertEqual(request.session.__setitem__.call_args, None) set_flavour('mobile', request=request, permanent=True) self.assertEqual( request.session.__setitem__.call_args, ((settings.FLAVOURS_SESSION_KEY, 'mobile',), {}))
def test_should_redirect_to_home_page_if_unauthorized(self): request = Mock() request.session = {'django_language': 'en'} user = Mock() user.is_authenticated.return_value = False request.user = user response = custom_home(request) self.assertIsNotNone(response) self.assertIsInstance(response, HttpResponseRedirect) self.assertEqual(response._headers['location'][1], '/en/home/')
def test_get_request_pinned(self): # If session is pinned, use master DB middleware = DBRoutingMiddleware() request = Mock(spec=HttpRequest, method='GET') request.session = { PINNING_KEY: datetime.now() + timedelta(seconds=30) } output = middleware.process_request(request) self.assertIsNone(output) self.assertTrue(is_thread_readwrite())
def test_mask(self): mw = MasqueradeMiddleware() request = Mock(spec=HttpRequest) request.session = {'mask_user': '******'} request.user = User.objects.get(username='******') mw.process_request(request) self.assert_(request.user.is_masked == True) self.assert_(request.user == User.objects.get(username='******'))
def test_transfer_error(self, mock_vofile): vofile = MagicMock() mock_vofile.return_value = vofile vospace_url = 'https://somevospace.server/vospace' session = Mock() session.get.side_effect = [Mock(content='COMPLETED')] conn = Mock(spec=Connection) conn.session = session test_client = Client() # use the mocked connection instead of the real one test_client.conn = conn # job successfully completed vofile.read.side_effect = [b'QUEUED', b'COMPLETED'] self.assertFalse(test_client.get_transfer_error( vospace_url +'/results/transferDetails', 'vos://vospace')) session.get.assert_called_once_with(vospace_url + '/phase', allow_redirects=False) # job suspended session.reset_mock() session.get.side_effect = [Mock(content=b'COMPLETED')] vofile.read.side_effect = [b'QUEUED', b'SUSPENDED'] with self.assertRaises(OSError): test_client.get_transfer_error( vospace_url +'/results/transferDetails', 'vos://vospace') #check arguments for session.get calls self.assertEquals([call(vospace_url + '/phase', allow_redirects=False)], session.get.call_args_list ) # job encountered an internal error session.reset_mock() vofile.read.side_effect = Mock(side_effect=[b'QUEUED', b'ERROR']) session.get.side_effect = [Mock(content=b'COMPLETED'), Mock(text='InternalFault')] with self.assertRaises(OSError): test_client.get_transfer_error( vospace_url +'/results/transferDetails', 'vos://vospace') self.assertEquals([call(vospace_url + '/phase', allow_redirects=False), call(vospace_url + '/error')], session.get.call_args_list ) # job encountered an unsupported link error session.reset_mock() link_file = 'testlink.fits' vofile.read.side_effect = Mock(side_effect=[b'QUEUED', b'ERROR']) session.get.side_effect = [Mock(content=b'COMPLETED'), Mock(text="Unsupported link target: " + link_file)] self.assertEquals(link_file, test_client.get_transfer_error( vospace_url +'/results/transferDetails', 'vos://vospace')) self.assertEquals([call(vospace_url + '/phase', allow_redirects=False), call(vospace_url + '/error')], session.get.call_args_list )
def test_should_redirect_to_login_redirect_url_if_authorized(self): request = Mock() request.session = {'django_language': 'en'} user = Mock() user.is_authenticated.return_value = True request.user = user settings.LOGIN_REDIRECT_URL = '/dashboard' response = custom_home(request) self.assertIsNotNone(response) self.assertIsInstance(response, HttpResponseRedirect) self.assertEqual(response._headers['location'][1], '/dashboard')
def test_unmask(self): mw = MasqueradeMiddleware() request = Mock(spec=HttpRequest) request.session = {} request.user = User.objects.get(username='******') mw.process_request(request) self.assert_(request.user.is_masked == False) self.assert_(request.user == User.objects.get(username='******'))
def test_unmask(self): mw = MasqueradeMiddleware() request = Mock(spec=HttpRequest) request.session = {} request.user = User.objects.get(username="******") mw.process_request(request) self.assert_(request.user.is_masked == False) self.assert_(request.user == User.objects.get(username="******"))
def test_mask(self): mw = MasqueradeMiddleware() request = Mock(spec=HttpRequest) request.session = {"mask_user": "******"} request.user = User.objects.get(username="******") mw.process_request(request) self.assert_(request.user.is_masked == True) self.assert_(request.user == User.objects.get(username="******"))
def test_post_request_without_write(self): middleware = DBRoutingMiddleware() request = Mock(spec=HttpRequest, method='POST') request.session = {} output = middleware.process_request(request) self.assertIsNone(output) self.assertTrue(is_thread_readwrite()) response = Mock() output = middleware.process_response(request, response) self.assertEqual(output, response) # No write - did not pin self.assertNotIn(PINNING_KEY, request.session)
def setUp(self): self.patch_redis_pubsub = patch("redis.Redis.pubsub") self.mock_redis_pubsub = self.patch_redis_pubsub.start() self.redis = Mock(spec=["listen", "subscribe"]) self.redis.listen.return_value = [{"type": "message", "data": '"abcd"'}] self.mock_redis_pubsub.return_value = self.redis socket = Mock() socket.session = {"rooms": Mock()} self.environ = {"socketio": socket} self.ns_name = "/event/updates" self.request = Mock()
def test_update_session_lang_not_user_preference(self): request = Mock() request.session = {} user = Mock() with self.settings(DEFAULT_LANGUAGE='invented'): with patch('wirecloud.platform.preferences.models.PlatformPreference') as platform_preference_mock: platform_preference_mock.objects.filter.return_value = [] update_session_lang(request, user) self.assertEqual(request.session[LANGUAGE_SESSION_KEY], 'invented')
def test_set_flavour_with_session_backend(self): original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND try: settings.FLAVOURS_STORAGE_BACKEND = 'session' request = Mock() request.session = {} set_flavour('mobile', request=request) self.assertEqual(request.session, {}) set_flavour('mobile', request=request, permanent=True) self.assertEqual(request.session, {settings.FLAVOURS_SESSION_KEY: 'mobile'}) self.assertEqual(get_flavour(request), 'mobile') finally: settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def test_should_switch_language_and_reload_page(self): request = Mock() request.META = { 'HTTP_REFERER': 'http://www.datawinners.com/project/subjects/2e358c46bb6c11e187d60800276384f8/' } request.session = {'django_language': 'en'} response = switch_language(request, 'fr') self.assertIsInstance(response, HttpResponseRedirect) self.assertEqual( response._headers['location'][1], '/project/subjects/2e358c46bb6c11e187d60800276384f8/') self.assertEqual(request.session['django_language'], 'fr')
def test_post_request_with_write(self): middleware = DBRoutingMiddleware() request = Mock(spec=HttpRequest, method='POST') request.session = {} output = middleware.process_request(request) self.assertIsNone(output) self.assertTrue(is_thread_readwrite()) set_db_written_flag() response = Mock() output = middleware.process_response(request, response) self.assertEqual(output, response) # Db was written, so pin self.assertTrue(request.session[PINNING_KEY] > datetime.now())
def test_update_session_lang_default_browser(self): request = Mock() request.session = {} user = Mock() with self.settings(DEFAULT_LANGUAGE='browser', LANGUAGES=(('en', 'English'),)): with patch('wirecloud.platform.preferences.models.PlatformPreference') as platform_preference_mock: lang_pref_mock = Mock() lang_pref_mock.value = 'default' platform_preference_mock.objects.filter.return_value = [lang_pref_mock] update_session_lang(request, user) self.assertNotIn(LANGUAGE_SESSION_KEY, request.session)
def test_login_existing_user_by_fxa_uid(self): """Test user filtering by FxA uid.""" user = UserFactory.create(profile__fxa_uid='my_unique_fxa_id') claims = { 'uid': 'my_unique_fxa_id', } request_mock = Mock(spec=HttpRequest) request_mock.session = {} self.backend.claims = claims self.backend.request = request_mock self.backend.request.user = user self.backend.filter_users_by_claims(claims) eq_(User.objects.all()[0].id, user.id)
def test_update_session_lang_invalid_user_preference(self): request = Mock() request.session = {LANGUAGE_SESSION_KEY: 'es'} user = Mock() with self.settings(DEFAULT_LANGUAGE='invented', LANGUAGES=(('es', 'Spanish'),)): with patch('wirecloud.platform.preferences.models.PlatformPreference') as platform_preference_mock: lang_pref_mock = Mock() lang_pref_mock.value = 'invalid' platform_preference_mock.objects.filter.return_value = [lang_pref_mock] update_session_lang(request, user) self.assertEqual(request.session[LANGUAGE_SESSION_KEY], 'invented')
def test_default(self): request = Mock(spec_set=['GET', 'session']) request.GET = {} request.session = {} context = ProfilingView()._create_context(request) self.assertDictContainsSubset({ 'show': ProfilingView.default_show, 'order_by': ProfilingView.defualt_order_by, 'options_show': ProfilingView.show, 'options_order_by': ProfilingView.order_by, 'options_func_names': ProfilingView()._get_function_names() }, context) self.assertNotIn('path', context) self.assertIn('results', context)
def test_default(self): request = Mock(spec_set=['GET', 'session']) request.session = {} request.GET = {} context = RequestsView()._create_context(request) self.assertDictContainsSubset({ 'show': RequestsView.default_show, 'order_by': RequestsView.defualt_order_by, 'options_show': RequestsView.show, 'options_order_by': RequestsView.order_by, 'options_paths': RequestsView()._get_paths() }, context) self.assertNotIn('path', context) self.assertIn('results', context)
def test_default(self): request = Mock(spec_set=['GET', 'session']) request.session = {} request.GET = {} context = RequestsView()._create_context(request) self.assertDictContainsSubset({ 'show': RequestsView.default_show, 'order_by': RequestsView.default_order_by, 'options_show': RequestsView.show, 'options_order_by': RequestsView().options_order_by, 'options_order_dir': RequestsView().options_order_dir, }, context) self.assertQuerysetEqual(context['options_paths'], RequestsView()._get_paths()) self.assertNotIn('path', context) self.assertIn('results', context)
def test_update_email_already_exists(self, message_mock): """Test updating to an email that is already used.""" UserFactory.create(email='*****@*****.**') user = UserFactory.create(email='*****@*****.**') claims = {'uid': 'my_unique_fxa_id', 'email': '*****@*****.**'} request_mock = Mock(spec=HttpRequest) request_mock.session = {} self.backend.claims = claims self.backend.request = request_mock self.backend.update_user(user, claims) message_mock.error.assert_called_with( request_mock, u'The email used with this Firefox Account is already linked in another profile.' ) eq_(User.objects.get(id=user.id).email, '*****@*****.**')
def test_create_courseref_existence(self, context_id, langing_page, mocked): """ Test for existence/non-existence of CourseRef. """ _id = self.course.id if context_id == '1' else self.course.id + 1 lti_post = {'context_id': context_id, 'context_title': 'test title', 'tool_consumer_instance_guid': 'test.dot.com', 'roles': 'Instructor'} request = Mock() request.user = self.user request.session = {'LTI_POST': lti_post, 'is_valid': True} res = create_courseref(request) self.assertEqual(res.url, reverse(langing_page, args=(_id,)))
def test_email_changed_in_FxA_match_by_uid(self, message_mock): """Test that the user email is updated successfully if it is changed in Firefox Accounts and we match users by uid. """ user = UserFactory.create(profile__fxa_uid='my_unique_fxa_id', email='*****@*****.**', profile__is_fxa_migrated=True) claims = {'uid': 'my_unique_fxa_id', 'email': '*****@*****.**'} request_mock = Mock(spec=HttpRequest) request_mock.session = {} self.backend.claims = claims self.backend.request = request_mock self.backend.update_user(user, claims) user = User.objects.get(id=user.id) eq_(user.email, '*****@*****.**') ok_(not message_mock.info.called)
def test_username_already_exists(self, message_mock): """Test account creation when username already exists.""" UserFactory.create(username='******') claims = { 'email': '*****@*****.**', 'uid': 'my_unique_fxa_id', } request_mock = Mock(spec=HttpRequest) request_mock.session = {} self.backend.claims = claims self.backend.request = request_mock self.backend.create_user(claims) user = User.objects.get(profile__fxa_uid='my_unique_fxa_id') eq_(user.username, 'bar1') message_mock.success.assert_called()
def test_create_courseref_existence(self, context_id, langing_page, mocked): """ Test for existence/non-existence of CourseRef. """ _id = self.course.id if context_id == '1' else self.course.id + 1 lti_post = { 'context_id': context_id, 'context_title': 'test title', 'tool_consumer_instance_guid': 'test.dot.com', 'roles': 'Instructor' } request = Mock() request.user = self.user request.session = {'LTI_POST': lti_post, 'is_valid': True} res = create_courseref(request) self.assertEqual(res.url, reverse(langing_page, args=(_id, )))
def test_default(self): request = Mock(spec_set=["GET", "session"]) request.session = {} request.GET = {} context = RequestsView()._create_context(request) self.assertDictContainsSubset( { "show": RequestsView.default_show, "order_by": RequestsView.default_order_by, "options_show": RequestsView.show, "options_order_by": RequestsView().options_order_by, "options_order_dir": RequestsView().options_order_dir, "options_paths": RequestsView()._get_paths(), }, context, ) self.assertNotIn("path", context) self.assertIn("results", context)
def test_get(self): request = Mock(spec_set=['GET', 'session']) request.session = {} show = 10 path = '/path/to/somewhere/' order_by = 'Path' request.GET = {'show': show, 'path': path, 'order_by': order_by} context = RequestsView()._create_context(request) self.assertDictContainsSubset({ 'show': show, 'order_by': order_by, 'path': path, 'options_show': RequestsView.show, 'options_order_by': RequestsView.order_by, 'options_paths': RequestsView()._get_paths() }, context) self.assertIn('results', context)
def setUp(self): from mock import Mock mock_request = Mock() mock_request.GET = {} mock_request.session = { 'twitter_request_token_key': 'key', 'twitter_request_token_secret': 'secret', } self.request = mock_request self.request.route_url.return_value = '/' # Setup mock oauth handler and tweepy client. self.mock_handler_factory = Mock() self.mock_handler = Mock() self.mock_handler.access_token.key = 'key' self.mock_handler.access_token.secret = 'secret' self.mock_handler_factory.return_value = self.mock_handler self.mock_api_factory = Mock() self.mock_client = Mock() self.mock_client.last_response.getheader.return_value = 'read' self.mock_api_factory.return_value = self.mock_client
def test_get(self): request = Mock(spec_set=["GET", "session"]) request.session = {} show = 10 path = "/path/to/somewhere/" order_by = "path" request.GET = {"show": show, "path": path, "order_by": order_by} context = RequestsView()._create_context(request) self.assertDictContainsSubset( { "show": show, "order_by": order_by, "path": path, "options_show": RequestsView.show, "options_order_by": RequestsView().options_order_by, "options_order_dir": RequestsView().options_order_dir, "options_paths": RequestsView()._get_paths(), }, context, ) self.assertIn("results", context)