def test_user_logged_in(self, get, now): # user requests email change user = Mock() token_object = Mock() token_object.token = 'sometokencontent' token_object.user = user get.return_value = token_object # user is logged in request = Mock() request.user = user # user clicks link in his email result = change_email(request, token_object.token) self.assertEquals(result.status_code, 302) get.assert_called_once_with( token=token_object.token, valid_until__gte=now()) # user stays logged in self.assertTrue(request.user.is_authenticated()) # token is deleted token_object.delete.assert_called_once_with() user.save.assert_called_once_with() # user email gets changed self.assertEqual(user.email, token_object.email)
def test_user_logged_in(self, get, now): # user requests email change user = Mock() token_object = Mock() token_object.token = 'sometokencontent' token_object.user = user get.return_value = token_object # user is logged in request = Mock() request.user = user # user clicks link in his email result = change_email(request, token_object.token) self.assertEquals(result.status_code, 302) get.assert_called_once_with(token=token_object.token, valid_until__gte=now()) # user stays logged in self.assertTrue(request.user.is_authenticated()) # token is deleted token_object.delete.assert_called_once_with() user.save.assert_called_once_with() # user email gets changed self.assertEqual(user.email, token_object.email)
def prepare_request_mock(self, data, referer='http://localhost/user_with_workspaces/Public Workspace', user=None, extra_headers={}, GET=''): request = Mock() request.method = 'POST' request.get_host.return_value = 'localhost' GET_PARAMETERS = parse_qsl(GET) request.GET = MagicMock() request.GET.__len__.side_effect = lambda: len(GET_PARAMETERS) request.GET.__getitem__.side_effect = lambda key: GET_PARAMETERS[key] request.GET.urlencode.side_effect = lambda: GET request.COOKIES = { settings.SESSION_COOKIE_NAME: 'test', } request.META = { 'HTTP_ACCEPT': 'application/json', 'SERVER_PROTOCOL': 'http', 'REMOTE_ADDR': '127.0.0.1', 'content_type': 'application/json', 'content_length': len(data), 'HTTP_HOST': 'localhost', 'HTTP_REFERER': referer, 'HTTP_X_FI_WARE_OAUTH_TOKEN': 'true', } request.META.update(extra_headers) request.read.return_value = data if user is None: request.user = self.admin_mock else: request.user = user return request
def test_car_has_object_permission(self): car = Mock() user = Mock() request = Mock() request.user = user car.user = user permission = CarOwnerPermission() self.assertTrue( permission.has_object_permission(request, Mock(), car) )
def login(self, adapter, provider_name): del adapter, provider_name response = Mock() response.error = self.error if self.error: response.user = False else: user = Mock() user.name = self.name user.email = self.email response.user = user return response
def test_treatment_has_object_permission(self): car = Mock() user = Mock() request = Mock() request.user = user car.user = user treatment = Mock() treatment.car = car permission = TreatmentOwnerPermission() self.assertTrue( permission.has_object_permission(request, Mock(), treatment) )
def prepare_request_mock( self, data=None, referer='http://localhost/user_with_workspaces/public-workspace', user=None, extra_headers={}, GET='', use_deprecated_code=False): request = Mock() request.get_host.return_value = 'localhost' GET_PARAMETERS = parse_qsl(GET) request.GET = MagicMock() request.GET.__len__.side_effect = lambda: len(GET_PARAMETERS) request.GET.__getitem__.side_effect = lambda key: GET_PARAMETERS[key] request.GET.urlencode.side_effect = lambda: GET request.COOKIES = { settings.SESSION_COOKIE_NAME: 'test', } request.META = { 'HTTP_ACCEPT': 'application/json', 'SERVER_PROTOCOL': 'http', 'REMOTE_ADDR': '127.0.0.1', 'HTTP_HOST': 'localhost', 'HTTP_REFERER': referer, } if data is not None: request.method = 'POST' data = data.encode('utf-8') request.META['content_type'] = 'application/json' request.META['content_length'] = len(data) request.read.return_value = data else: request.method = 'GET' if use_deprecated_code: request.META['HTTP_X_FI_WARE_OAUTH_TOKEN'] = 'true' extra_headers = { self.deprecation_mapping[key]: value for key, value in six.iteritems(extra_headers) } else: request.META['HTTP_FIWARE_OAUTH_TOKEN'] = 'true' request.META.update(extra_headers) if user is None: request.user = self.admin_mock else: request.user = user return request
def has_perm(self, method, obj, auth=None, user=None): perm = TeamPermission() request = Mock() request.auth = auth request.user = user request.method = method return perm.has_object_permission(request, None, obj)
def test_geo_manager(self): request = Mock() request.user = self.user request.allowed_data_set_ids = set([self.data_set1.id]) print request.allowed_data_set_ids geo_manager.request = request self.assertEqual(len(GeoContent.objects.all()), 2)
def test_photo_too_big(self, mock_is_image_check, mock_is_animated_check): # Mock the ImageCheck object to pass checks on the uploaded image mock_is_image_check.return_value = True mock_is_image_check.return_value = False mock_is_animated_check.returned_value = False request = Mock() request.user = self.user data = {'username': self.user_profile.username, 'email': self.user_profile.email} files = {'photo': get_uploaded_file('transparent.png')} form = UserEditForm(data, files=files, instance=self.user_profile, request=request) # Creating the mock object instead of the uploaded file, # with a specific size over the limit upload_mock = MagicMock(spec=SimpleUploadedFile) upload_mock._name = 'transparent.png' upload_mock.size = 4 * 1024 * 1024 + 1 upload_mock.content_type = 'image/png' # Injecting the mock object form.files['photo'] = upload_mock assert not form.is_valid() mock_is_image_check.assert_called() mock_is_animated_check.assert_called() assert form.errors == { 'photo': [u'Please use images smaller than 4MB.'] }
def test_not_staff(self): """ If the user is not staff, raise a PermissionDenied exception. """ request = Mock() request.user = UserFactory.create(is_staff=False) self.view.dispatch(request)
def test_valid_user(self): address = Mock() address.country = Mock() address.country.code = 'AT' address.line4 = 'Vienna' address.postcode = '1010' address.phone_number = '+43 1 234 5678' address.line1 = 'hastexo Professional Services GmbH' address.vatin = '' request = Mock() request.user = Mock() request.user.addresses = Mock() request.user.addresses.order_by = Mock(return_value=[address]) request.user.is_authenticated = Mock(return_value=True) selector = PerUserVATSelector() strategy = selector.strategy(request=request) result_rate = strategy.get_rate(None, None) self.assertEqual(result_rate, D('0.20')) address.vatin = 'ATU66688202' result_rate = strategy.get_rate(None, None) self.assertEqual(result_rate, D('0.00'))
def test_addon_sharing(self): addon = Addon.objects.get(id=7172) jingo.load_helpers() request = Mock() request.user = DjangoUser() request.APP = amo.FIREFOX ctx = {'request': request, 'APP': request.APP, 'LANG': translation.get_language()} # disable cake csrf token cake_csrf_token = lambda: '' cake_csrf_token.__name__ = 'cake_csrf_token' jingo.register.function(cake_csrf_token) doc = pq(addon_sharing(ctx, addon)) self.assert_(doc.html()) self.assertEquals(doc('li').length, len(sharing.SERVICES_LIST)) # Make sure services are in the right order. for i in range(len(sharing.SERVICES_LIST)): self.assertEquals(doc('li').eq(i).attr('class'), sharing.SERVICES_LIST[i].shortname) assert doc('li a').eq(i).attr('target') in ('_blank', '_self'), ( 'Sharing link target must either be blank or self.')
def test_owner_or_mod_required_passes_url_parameters(self): @owner_or_moderator_required def mock_view(request, user, context): return None request = Mock(spec=('path', 'POST', 'user', 'method')) request.method = "POST" request.user = AnonymousUser() request.POST = {'abra': 'cadabra', 'foo': 'bar'} request.path = '/some/path/' user = self.create_user('user') response = mock_view(request, user, {}) self.assertEqual(isinstance(response, HttpResponseRedirect), True) url = response['location'] parsed_url = urllib.parse.urlparse(url) self.assertEqual(parsed_url.path, reverse('user_signin')) next_jwt = dict(urllib.parse.parse_qsl(parsed_url.query))['next'] next_url = decode_jwt(next_jwt).get('next_url') parsed_url = urllib.parse.urlparse(next_url) self.assertEqual(parsed_url.path, request.path) query = dict(urllib.parse.parse_qsl(parsed_url.query)) self.assertEqual(set(query.keys()), set(['foo', 'abra'])) self.assertEqual(set(query.values()), set(['bar', 'cadabra'])) self.assertEqual(query['abra'], 'cadabra')
def test_list_packages_filters(self): """ The package list must be stripped from inherited packages and [*redirected] messages """ devpi_listing = [ '*redirected: http://localhost:2414/user/index2/delete_me', 'http://localhost:2414/user/index2/+f/70e/3bc67b3194143/delete_me-0.2-py2.py3-none-any.whl', 'http://localhost:2414/user/index2/+f/313/8642d2b43a764/delete_me-0.2.tar.gz', 'http://localhost:2414/other_user/index1/+f/70e/3bc67b3194143/delete_me-0.2-py2.py3-none-any.whl', 'http://localhost:2414/other_user/index1/+f/313/8642d2b43a764/delete_me-0.2.tar.gz' ] expected_packages = {'user/index2': {Package(devpi_listing[1])}} devpi_client = Mock(spec=DevpiCommandWrapper) devpi_client.user = '******' devpi_client.url = 'http://localhost:2414/user/index2' devpi_client.list_indices.return_value = ['user/index2'] devpi_client.list.return_value = devpi_listing actual_packages = list_packages_by_index(devpi_client, 'user', 'delete_me', only_dev=False, version_filter=None) self.assertDictEqual(expected_packages, actual_packages) devpi_client.list.assert_called_once_with( '--index', 'user/index2', '--all', 'delete_me' ) # `--all` is important as otherwise not all packages will be returned
def get_mock_review(): r = Mock(); r.product = get_product_mock() r.user = get_auth_user_mock() r.score = 4 r.date_created = datetime.utcfromtimestamp(100) return r
def get_mock_review(): r = Mock() r.product = get_product_mock() r.user = get_auth_user_mock() r.score = 4 r.date_created = datetime.utcfromtimestamp(100) return r
def has_object_perm(self, auth, user, obj, method="GET"): perm = OrganizationPermission() request = Mock() request.auth = auth request.user = user request.method = method return perm.has_object_permission(request, None, obj)
def test_get_openedx_user(self, get_user_mock): """Testing _get_openedx_user method.""" self.assertEqual({}, self.base._get_openedx_user(data={})) # pylint: disable=protected-access data = { 'supported_lines': [ { 'user_email': 'test-email' }, ], } expected_user = { 'FirstName': 'Peter', 'LastName': 'Parker', 'Email': 'test-email', } profile_mock = Mock() profile_mock.name = 'Peter Parker' user_mock = Mock() user_mock.first_name = 'Peter' user_mock.last_name = 'Parker' profile_mock.user = user_mock get_user_mock.return_value = (Mock(), profile_mock) self.assertEqual(self.base._get_openedx_user(data), expected_user) # pylint: disable=protected-access get_user_mock.assert_called_once_with(email='test-email') get_user_mock.side_effect = Exception('test') self.assertEqual(self.base._get_openedx_user(data), {}) # pylint: disable=protected-access
def test_addon_sharing(self): addon = Addon.objects.get(id=7172) jingo.load_helpers() # mock helpers locale_url = lambda url: url locale_url.__name__ = 'locale_url' jingo.register.function(locale_url) request = Mock() request.user = DjangoUser() request.APP = amo.FIREFOX ctx = {'request': request} # disable cake csrf token cake_csrf_token = lambda: '' cake_csrf_token.__name__ = 'cake_csrf_token' jingo.register.function(cake_csrf_token) doc = pq(addon_sharing(ctx, addon)) self.assert_(doc.html()) self.assertEquals(doc('li').length, len(sharing.SERVICES_LIST)) # Make sure services are in the right order. for i in range(len(sharing.SERVICES_LIST)): self.assertEquals(doc('li').eq(i).attr('class'), sharing.SERVICES_LIST[i].shortname)
def test_add_a_new_email_identity(self, mocked_message): """Test to add a new email in an authenticated user.""" user = UserFactory.create(email='*****@*****.**') IdpProfile.objects.create( profile=user.userprofile, auth0_user_id='email|', email=user.email, primary=True ) claims = { 'email': '*****@*****.**', 'user_id': 'ad|ldap' } request_mock = Mock(spec=HttpRequest) request_mock.user = user self.backend.claims = claims self.backend.request = request_mock email_q = IdpProfile.objects.filter(profile=user.userprofile, email='*****@*****.**') ok_(not email_q.exists()) returned_user = self.backend.check_authentication_method(user) email_q = IdpProfile.objects.filter(profile=user.userprofile, email='*****@*****.**') ok_(email_q.exists()) eq_(returned_user, user) ok_(not mocked_message.called)
def test_vote_captcha_first_vote_loggedin(self): # first vote does not require captcha if user is logged in # even if no prior votes have been cast by the logged in user mock_request_loggedin = Mock(spec=object) mock_request_loggedin.user = Mock() mock_request_loggedin.user.is_authenticated = lambda: True self.assertFalse(vote_needs_captcha(mock_request_loggedin))
def test_identity_single_auth0_id_multiple_emails(self, mocked_message): """Test to add an email that already exists.""" user = UserFactory.create(email='*****@*****.**') IdpProfile.objects.create( profile=user.userprofile, auth0_user_id='github|12345', email='*****@*****.**', primary=True ) claims = { 'email': '*****@*****.**', 'user_id': 'github|12345' } request_mock = Mock(spec=HttpRequest) request_mock.user = user self.backend.claims = claims self.backend.request = request_mock self.backend.check_authentication_method(user) eq_(IdpProfile.objects.filter( profile=user.userprofile, primary=True, email='*****@*****.**').count(), 1) eq_(IdpProfile.objects.filter( profile=user.userprofile, primary=False, email='*****@*****.**').count(), 1)
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 has_object_perm(self, auth, user, obj, method='GET'): perm = ProjectPermission() request = Mock() request.auth = auth request.user = user request.method = method return perm.has_object_permission(request, None, obj)
def test_create_move_publishes_to_redis(self): """ Tests that we are publishing to redis when we create moves """ request = Mock(name='request') request.user = self.player1 redis = Mock(name='redis') redis.publish = Mock() self.game.board = pickle.dumps(['X', '', '', '', 'X', '', '', '', '']) self.game.save() with patch('core.views.Redis') as mock_redis: mock_redis.return_value = redis move = 8 player = 'X' response = self.client.post('/create_move/%d/' % self.game.id, {'move': move}) redis.publish.assert_called_with( self.player2.id, ['game_over', self.game.id, player]) _pop_last_call(redis.publish) redis.publish.assert_called_with( self.player1.id, ['game_over', self.game.id, player]) _pop_last_call(redis.publish) redis.publish.assert_called_with( self.player2.id, ['opponent_moved', self.game.id, player, move])
def test_user_logged_in(self, get, now): # user requests email change user = Mock() token_object = Mock() token_object.token = 'sometokencontent' token_object.user = user get.return_value = token_object # user is logged in request = MagicMock(HttpRequest) request._messages = Mock() request.user = user # user clicks link in his email result = change_email(request, token_object.token) assert result.status_code == 302 get.assert_called_once_with( token=token_object.token, valid_until__gte=now()) # user stays logged in assert request.user.is_authenticated() # token is deleted token_object.delete.assert_called_once_with() user.save.assert_called_once_with() # user email gets changed assert user.email == token_object.email
def test_owner_or_mod_required_passes_url_parameters(self): @owner_or_moderator_required def mock_view(request, user, context): return None request = Mock(spec=('path', 'REQUEST', 'user')) request.user = AnonymousUser() request.REQUEST = {'abra': 'cadabra', 'foo': 'bar'} request.path = '/some/path/' user = self.create_user('user') response = mock_view(request, user, {}) self.assertEqual(isinstance(response, HttpResponseRedirect), True) url = response['location'] parsed_url = urlparse.urlparse(url) self.assertEqual(parsed_url.path, reverse('user_signin')) next = dict(urlparse.parse_qsl(parsed_url.query))['next'] next_url = urllib.unquote(next) parsed_url = urlparse.urlparse(next_url) self.assertEqual(parsed_url.path, request.path) query = dict(urlparse.parse_qsl(parsed_url.query)) self.assertEqual(set(query.keys()), set(['foo', 'abra'])) self.assertEqual(set(query.values()), set(['bar', 'cadabra'])) self.assertEqual(query['abra'], 'cadabra')
def test_contact_create(self): # POST with no existing contact creates a new one name = u'A BRAND NEW CONTACT' data = { u'name': name, u'language': u'wxyz', u'submit': u'Save Contact', u'connection_set-0-id': u'', u'connection_set-0-DELETE': u'', u'connection_set-0-backend': u'1', u'connection_set-0-contact': u'', u'connection_set-0-identity': u'4567', u'connection_set-1-id': u'', u'connection_set-1-contact': u'', u'connection_set-1-identity': u'', u'connection_set-1-backend': u'', u'connection_set-INITIAL_FORMS': u'0', u'connection_set-TOTAL_FORMS': u'2', u'connection_set-MAX_NUM_FORMS': u'10', } with patch('rapidsms.contrib.registration.views.render'): request = Mock(method="POST", POST=data) request.__class__ = HttpRequest self.login() request.user = self.user retval = views.contact(request) self.assertTrue(isinstance(retval, HttpResponseRedirect)) self.assertEqual(302, retval.status_code) Contact.objects.get(name=name)
def test_tag_list(self): addon = Addon.objects.get(id=3615) request = Mock() request.user = addon.authors.all()[0] request.groups = () tags = addon.tags.not_blacklisted() ctx = { 'APP': amo.FIREFOX, 'LANG': 'en-us', 'request': request, 'addon': addon, 'tags': tags } # no tags, no list s = render('{{ tag_list(addon) }}', ctx) self.assertEqual(s.strip(), "") s = render('{{ tag_list(addon, tags=tags) }}', ctx) assert s, "Non-empty tags must return tag list." doc = pq(s) eq_(doc('li').length, len(tags))
def test_sharing_box(self): request = Mock() request.user = DjangoUser() request.APP = amo.FIREFOX ctx = { 'request': request, 'APP': request.APP, 'LANG': translation.get_language() } # disable cake csrf token cake_csrf_token = lambda: '' cake_csrf_token.__name__ = 'cake_csrf_token' jingo.register.function(cake_csrf_token) doc = pq(sharing_box(ctx)) self.assert_(doc.html()) self.assertEquals(doc('li').length, len(sharing.SERVICES_LIST)) # Make sure services are in the right order. for i in range(len(sharing.SERVICES_LIST)): self.assertEquals( doc('li').eq(i).attr('class'), sharing.SERVICES_LIST[i].shortname) assert doc('li a').eq(i).attr('target') in ('_blank', '_self'), ( 'Sharing link target must either be blank or self.')
def test_should_add_imported_data_senders_to_trial_organization(self): self.org_id = "QZJ729195" with patch.object(User, "get_profile") as get_profile: get_profile.return_value = dict(org_id=self.org_id) request = Mock() request.user = Mock(spec=User) ds_mobile_numbers = ["0333333333", "0333733333"] with patch( "datawinners.entity.helper._add_data_sender_to_trial_organization" ) as add_ds_to_trial: with patch( "datawinners.accountmanagement.models.Organization.objects.get" ) as get_organization_mock: get_organization_mock.return_value = self.get_organization( org_id=self.org_id) org = Organization.objects.get(org_id="AK29") self.assertEqual(org.org_id, self.org_id) all_data_senders = [ dict(cols=[mobile_number], short_code="rep%d" % key) for key, mobile_number in enumerate(ds_mobile_numbers) ] add_imported_data_sender_to_trial_organization( request, ['rep0', 'rep1'], all_data_senders) self.assertEqual(add_ds_to_trial.call_count, 2)
def test_has_object_permission_user(self): self.request.user = self.user self.request.user = self.request.user obj = Mock() obj.user = self.user eq_(self.permission.has_object_permission(self.request, 'myview', obj), True)
def test_add_idp_wrong_flow(self, mocked_message): """Test logging in with a weaker provider compared to the current one""" user = UserFactory.create(email='*****@*****.**') IdpProfile.objects.create( profile=user.userprofile, auth0_user_id='ad|foobar', primary=True, email='*****@*****.**' ) claims = { 'email': '*****@*****.**', 'user_id': 'foobar' } request_mock = Mock(spec=HttpRequest) request_mock.user = user self.backend.claims = claims self.backend.request = request_mock returned_user = self.backend.check_authentication_method(user) msg = 'Please use LDAP Provider as the login method to authenticate' mocked_message.error.assert_called_once_with(request_mock, msg) eq_(returned_user, None)
def test_group_finder_no_groups(self): from pyramid_signup import groupfinder from pyramid_signup.models import User from pyramid_signup.models import UserGroup from pyramid_signup.models import Organization group = UserGroup('foo', 'bar') user1 = User(username='******', first_name='john') user2 = User(username='******', first_name='john') organization = Organization('foo', user1) group.users.append(user1) self.session.add(organization) self.session.add(group) self.session.add(user1) self.session.add(user2) self.session.flush() request = Mock() request.user = user2 results = groupfinder(2, request) assert len(results) == 1 assert 'user:%s' % (user2.pk) in results
def test_filter_users_with_a_non_existing_identity(self): """Test filter users with a non primary identity.""" user = UserFactory.create(email='*****@*****.**') IdpProfile.objects.create( profile=user.userprofile, auth0_user_id='email|1', email='*****@*****.**', primary=True ) claims = { 'email': '*****@*****.**', 'user_id': 'email|2' } request_mock = Mock(spec=HttpRequest) request_mock.user = user self.backend.claims = claims self.backend.request = request_mock users = self.backend.filter_users_by_claims(claims) idp_q = IdpProfile.objects.filter(auth0_user_id='email|1', email='*****@*****.**', profile=user.userprofile) eq_(idp_q.count(), 1) eq_(list(users), [])
def test_has_object_permission_different_user(self): self.request.user = User.objects.get(pk=999) self.request.amo_user = self.request.user.get_profile() obj = Mock() obj.user = self.user eq_(self.permission.has_object_permission(self.request, 'myview', obj), False)
def test_identity_already_exists(self, mocked_message): """Test to add an email that already exists.""" user = UserFactory.create(email='*****@*****.**') IdpProfile.objects.create( profile=user.userprofile, auth0_user_id='email|', email=user.email, primary=True ) claims = { 'email': '*****@*****.**', 'user_id': 'email|' } request_mock = Mock(spec=HttpRequest) request_mock.user = user self.backend.claims = claims self.backend.request = request_mock self.backend.check_authentication_method(user) idp_q = IdpProfile.objects.filter(auth0_user_id='email|', email=user.email, profile=user.userprofile) eq_(idp_q.count(), 1) ok_(not mocked_message.called)
def test_parse_status(self): self.maxDiff = None status = Mock( user_name='@fake_user_name', user_location='fake_location', coordinates='fake_coordinates', text='fake_test', # symbols_in_text='fake_symbols_in_fake_text', # hashtags='fake_hashtags', created_at='fake_created_date', #lead_score=3, ) status.user = Mock( screen_name='@fake_user_name', location='fake_location' ) expected_result = { "user_name": status.user_name, "user_location": status.user_location, "tweet_coordinates": status.coordinates, "text": status.text, # "symbols_in_text": status.symbols_in_text, # "hashtags": status.hashtags, "created_date": status.created_at, # "lead_score": lead_score, } test_fields = tweepy_scraper.parse_status(status) self.assertEqual(test_fields, expected_result)
def test_photo_too_big(self, mock_is_image_check, mock_is_animated_check): # Mock the ImageCheck object to pass checks on the uploaded image mock_is_image_check.return_value = True mock_is_image_check.return_value = False mock_is_animated_check.returned_value = False request = Mock() request.user = self.user data = { 'username': self.user_profile.username, 'email': self.user_profile.email } files = {'photo': get_uploaded_file('transparent.png')} form = UserEditForm(data, files=files, instance=self.user_profile, request=request) # Creating the mock object instead of the uploaded file, # with a specific size over the limit upload_mock = MagicMock(spec=SimpleUploadedFile) upload_mock._name = 'transparent.png' upload_mock.size = 4 * 1024 * 1024 + 1 upload_mock.content_type = 'image/png' # Injecting the mock object form.files['photo'] = upload_mock assert not form.is_valid() mock_is_image_check.assert_called() mock_is_animated_check.assert_called() assert form.errors == { 'photo': [u'Please use images smaller than 4MB.'] }
def test_valid_user_noreverse_charge(self): address = Mock() address.country = Mock() address.country.code = 'AT' address.line4 = 'Vienna' address.postcode = '1010' address.phone_number = '+43 1 234 5678' address.line1 = 'hastexo Professional Services GmbH' address.vatin = '' request = Mock() request.user = Mock() request.user.addresses = Mock() request.user.addresses.order_by = Mock(return_value=[address]) request.user.is_authenticated = Mock(return_value=True) selector = PerUserVATSelector() strategy = selector.strategy(request=request) result_rate = strategy.get_rate(None, None) self.assertEqual(result_rate, D('0.20')) address.vatin = 'ATU66688202' # Valid VATIN, but same country as store: should return normal # VAT rate. result_rate = strategy.get_rate(None, None) self.assertEqual(result_rate, D('0.20'))
def test_list_only_dev_packages(self): devpi_listing = [ 'http://localhost:2414/user/index1/+f/70e/3bc67b3194143/delete_me-0.2-py2.py3-none-any.whl', 'http://localhost:2414/user/index1/+f/313/8642d2b43a764/delete_me-0.2.tar.gz', 'http://localhost:2414/user/index1/+f/bab/f9b37c9d0d192/delete_me-0.2a1.tar.gz', 'http://localhost:2414/user/index1/+f/e8e/d9cfe14d2ef65/delete_me-0.2a1-py2.py3-none-any.whl', 'http://localhost:2414/user/index1/+f/842/84d1283874110/delete_me-0.2.dev2.tar.gz', 'http://localhost:2414/user/index1/+f/636/95eef6ac86c76/delete_me-0.2.dev2-py2.py3-none-any.whl', 'http://localhost:2414/user/index1/+f/c22/cdec16d5ddc3a/delete_me-0.1-py2.py3-none-any.whl', 'http://localhost:2414/user/index1/+f/45b/301745c6d8bbf/delete_me-0.1.tar.gz', ] expected_packages = { 'user/index1': {Package(devpi_listing[5])}, } devpi_client = Mock(spec=DevpiCommandWrapper) devpi_client.user = '******' devpi_client.url = 'http://localhost:2414/user/index1' devpi_client.list_indices.return_value = ['user/index1'] devpi_client.list.return_value = devpi_listing actual_packages = list_packages_by_index(devpi_client, 'user', 'delete_me', only_dev=True, version_filter=None) self.assertDictEqual(expected_packages, actual_packages)
def test_get_correct_web_submission_link(self): request = Mock() request.user = Mock(spec=User) manager = Mock(spec=DatabaseManager) manager.database = dict() raw_project = dict( value=dict(_id="pid", devices=["sms", "web"], name="Project Name", created="2012-05-23T02:57:09.788294+00:00")) project = Project(dbm=manager, name="Project Name") profile = Mock(spec=NGOUserProfile) questionnaire = Mock() questionnaire.form_code = "q01" with patch("datawinners.project.models.Project.get") as get_project: get_project.return_value = project with patch.object(DatabaseManager, "get") as db_manager: db_manager.return_value = questionnaire with patch("django.contrib.auth.models.User.get_profile" ) as get_profile: get_profile.return_value = profile profile.reporter = False project_info = get_project_info(manager, raw_project) self.assertEqual(project_info["web_submission_link"], "/project/testquestionnaire/pid/")
def test_contact_update(self): # POST to contact view updates the contact and connections contact = self.contacts[0] data = { u'name': u'The Contact', u'language': u'wxyz', u'submit': u'Save Contact', u'connection_set-0-id': u'2', u'connection_set-0-DELETE': u'', u'connection_set-0-backend': u'1', u'connection_set-0-contact': u'1', u'connection_set-0-identity': u'4567', u'connection_set-1-id': u'', u'connection_set-1-contact': u'1', u'connection_set-1-identity': u'', u'connection_set-1-backend': u'', u'connection_set-INITIAL_FORMS': u'1', u'connection_set-TOTAL_FORMS': u'2', u'connection_set-MAX_NUM_FORMS': u'10', } with patch('rapidsms.contrib.registration.views.render'): request = Mock(method="POST", POST=data) request.__class__ = HttpRequest self.login() request.user = self.user retval = views.contact(request, pk=contact.pk) self.assertTrue(isinstance(retval, HttpResponseRedirect)) self.assertEqual(302, retval.status_code) new_contact = Contact.objects.get(pk=contact.pk) self.assertEqual(data['name'], new_contact.name) self.assertEqual(data['language'], new_contact.language) identities = [c.identity for c in contact.connection_set.all()] self.assertIn(data['connection_set-0-identity'], identities)
def test_contact_delete(self): # Submitting with Delete button deletes the contact contact = self.contacts[0] data = { u'name': u'The Contact', u'language': u'wxyz', u'delete_contact': u"dontcare", u'connection_set-0-id': u'2', u'connection_set-0-DELETE': u'', u'connection_set-0-backend': u'1', u'connection_set-0-contact': u'1', u'connection_set-0-identity': u'4567', u'connection_set-1-id': u'', u'connection_set-1-contact': u'1', u'connection_set-1-identity': u'987654', u'connection_set-1-backend': u'1', u'connection_set-INITIAL_FORMS': u'1', u'connection_set-TOTAL_FORMS': u'2', u'connection_set-MAX_NUM_FORMS': u'10', } with patch('rapidsms.contrib.registration.views.render'): request = Mock(method="POST", POST=data) request.__class__ = HttpRequest self.login() request.user = self.user retval = views.contact(request, pk=contact.pk) self.assertTrue(isinstance(retval, HttpResponseRedirect)) self.assertEqual(302, retval.status_code) self.assertFalse(Contact.objects.filter(pk=contact.pk).exists())
def test_has_object_permission_user(self): self.request.user = self.user self.request.amo_user = self.request.user obj = Mock() obj.user = self.user eq_(self.permission.has_object_permission(self.request, 'myview', obj), True)
def test_bulk_add(self): # We can upload a CSV file to create contacts & connections backend1 = self.create_backend() backend2 = self.create_backend() # Include a unicode name to make sure that works uname = u'Name 1 ḀḂḈ ᵺ' data = [ (uname, backend1.name, u'11111'), (u'Name 2', backend2.name, u'22222'), (u'Name 3', backend1.name, u'33333'), (u'Name 4', backend2.name, u'44444'), ] # Create test file testfile = u"\n".join([u",".join(parts) for parts in data]) + u"\n" testfile_data = testfile.encode('utf-8') with patch('rapidsms.contrib.registration.views.render') as render: request = Mock(method="POST", FILES={'bulk': StringIO(testfile_data)}) request.__class__ = HttpRequest self.login() request.user = self.user retval = views.contact_bulk_add(request) if not isinstance(retval, HttpResponseRedirect): context = render.call_args[0][2] self.fail(context['bulk_form'].errors + context['csv_errors']) self.assertTrue(isinstance(retval, HttpResponseRedirect)) self.assertEqual(302, retval.status_code) contacts = Contact.objects.all() self.assertEqual(4, contacts.count()) names = [contact.name for contact in contacts] self.assertIn(uname, names)