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 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 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 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_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_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_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_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_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)
