def invalidate_group_pending_terms(self, mail_task):
"""Invalidate a group where a user has not yet accepted the terms.
Type is indifferent for this test.
"""
member = UserFactory.create(vouched=True)
curator = UserFactory.create(vouched=True)
group = GroupFactory.create(name='Foo', invalidation_days=5)
group.curators.add(curator.userprofile)
group.add_member(curator.userprofile)
GroupMembership.objects.create(userprofile=member.userprofile, group=group,
status=GroupMembership.PENDING_TERMS,
updated_on=datetime.now() - timedelta(days=10))
curator_membership = group.groupmembership_set.filter(userprofile=curator.userprofile)
curator_membership.update(updated_on=datetime.now() - timedelta(days=10))
eq_(curator_membership[0].status, GroupMembership.MEMBER)
invalidate_group_membership()
ok_(group.groupmembership_set.filter(userprofile=member.userprofile,
status=GroupMembership.PENDING_TERMS).exists())
ok_(group.groupmembership_set.filter(userprofile=curator.userprofile).exists())
ok_(not mail_task.called)
def test_send_renewal_notification_inviters_email(self, mock_now, mock_send_mail):
"""Test renewal notification functionality for curators"""
curator1 = UserFactory.create(email='*****@*****.**')
curator2 = UserFactory.create(email='*****@*****.**')
curator3 = UserFactory.create(email='*****@*****.**')
member = UserFactory.create(userprofile={'full_name': 'Example Name'})
group = GroupFactory.create(name='foobar', invalidation_days=365,
accepting_new_members=Group.CLOSED)
group.curators.add(curator1.userprofile)
group.curators.add(curator2.userprofile)
group.curators.add(curator3.userprofile)
group.add_member(member.userprofile)
InviteFactory.create(inviter=curator3.userprofile, redeemer=member.userprofile,
group=group)
datetime_now = now() + timedelta(days=351)
mock_now.return_value = datetime_now
notify_membership_renewal()
ok_(mock_send_mail.called)
eq_(2, len(mock_send_mail.mock_calls))
# Check email for inviter
name, args, kwargs = mock_send_mail.mock_calls[1]
subject, body, from_addr, to_list = args
eq_(subject, '[Mozillians][foobar] Membership of "Example Name" is about to expire')
eq_(from_addr, settings.FROM_NOREPLY)
eq_(list(to_list), [u'*****@*****.**'])
def invalidate_closed_group(self, mail_task):
member = UserFactory.create(vouched=True)
curator = UserFactory.create(vouched=True)
group = GroupFactory.create(name='Foo', invalidation_days=5,
accepting_new_members=Group.CLOSED)
group.curators.add(curator.userprofile)
group.add_member(curator.userprofile)
group.add_member(member.userprofile)
membership = group.groupmembership_set.filter(userprofile=member.userprofile)
curator_membership = group.groupmembership_set.filter(userprofile=curator.userprofile)
membership.update(updated_on=datetime.now() - timedelta(days=10))
curator_membership.update(updated_on=datetime.now() - timedelta(days=10))
eq_(membership[0].status, GroupMembership.MEMBER)
eq_(curator_membership[0].status, GroupMembership.MEMBER)
invalidate_group_membership()
ok_(group.groupmembership_set.filter(userprofile=member.userprofile,
status=GroupMembership.PENDING).exists())
ok_(group.groupmembership_set.filter(userprofile=curator.userprofile).exists())
mail_task.delay.assert_called_once_with(group.id, member.id, GroupMembership.MEMBER,
GroupMembership.PENDING)
def test_voucher_set_null_on_user_delete(self):
voucher = UserFactory.create()
vouchee = UserFactory.create(vouched=False)
vouchee.userprofile.vouch(voucher.userprofile)
voucher.delete()
vouch = Vouch.objects.get(vouchee=vouchee)
eq_(vouch.voucher, None)
def test_filter_all(self):
"""If they specify no filters, they get all the members"""
# Make user 1 the group curator so they can see requests
self.group.curators.add(self.user_1.userprofile)
self.group.accepting_new_members = 'by_request'
self.group.save()
# Make user 2 a full member
self.group.add_member(self.user_2.userprofile, GroupMembership.MEMBER)
member_membership = self.group.groupmembership_set.get(userprofile__user=self.user_2)
# Make user 3 a pending member
self.user_3 = UserFactory.create()
self.group.add_member(self.user_3.userprofile, GroupMembership.PENDING)
pending_membership = self.group.groupmembership_set.get(userprofile__user=self.user_3)
# Make user 4 a pending_terms member
self.user_4 = UserFactory.create()
self.group.add_member(self.user_4.userprofile, GroupMembership.PENDING_TERMS)
pending_terms_membership = self.group.groupmembership_set.get(
userprofile__user=self.user_4)
url = urlparams(self.url, filtr='all')
with self.login(self.user_1) as client:
response = client.get(url, follow=True)
people = response.context['people'].object_list
ok_(member_membership in people)
ok_(pending_membership in people)
ok_(pending_terms_membership in people)
def test_vouched(self):
vouched_user = UserFactory.create()
UserFactory.create(vouched=False)
UserFactory.create(userprofile={'full_name': ''})
queryset = UserProfile.objects.vouched()
eq_(queryset.count(), 1)
eq_(queryset[0], vouched_user.userprofile)
def test_clean_email_invalid(self):
UserFactory.create(email='*****@*****.**')
user = UserFactory.create(email='*****@*****.**')
form = UserProfileAdminForm(None, instance=user.userprofile)
form.cleaned_data = {'email': '*****@*****.**'}
with self.assertRaises(ValidationError):
form.clean_email()
def test_clean_username_invalid(self):
UserFactory.create(username='******')
user = UserFactory.create(username='******')
form = UserProfileAdminForm(None, instance=user.userprofile)
form.cleaned_data = {'username': '******'}
with self.assertRaises(ValidationError):
form.clean_username()
def test_sending_pending_email_already_sent(self):
# If a curated group has a pending membership, but it was added before the
# last time a reminder email was sent, do not send the curator an email.
# curated group:
group = GroupFactory.create()
group.curators.add(UserFactory.create().userprofile)
# Pending membership
user1 = UserFactory.create()
group.add_member(user1.userprofile, GroupMembership.PENDING)
membership = GroupMembership.objects.get(userprofile=user1.userprofile, group=group)
membership.save()
# Send email. This should update the field remembering the max pending request pk.
tasks.send_pending_membership_emails()
# Non-pending membership
user2 = UserFactory.create()
group.add_member(user2.userprofile, GroupMembership.MEMBER)
# None of this should trigger an email send
with patch('mozillians.groups.tasks.send_mail', autospec=True) as mock_send_mail:
tasks.send_pending_membership_emails()
ok_(not mock_send_mail.called)
def test_invalidate_group_accepts_all(self, mock_send_mail):
member = UserFactory.create(vouched=True)
curator = UserFactory.create(vouched=True)
group = GroupFactory.create(name='Foo', invalidation_days=5)
group.curators.add(curator.userprofile)
group.add_member(curator.userprofile)
group.add_member(member.userprofile)
membership = group.groupmembership_set.filter(userprofile=member.userprofile)
curator_membership = group.groupmembership_set.filter(userprofile=curator.userprofile)
membership.update(updated_on=datetime.now() - timedelta(days=10))
curator_membership.update(updated_on=datetime.now() - timedelta(days=10))
eq_(membership[0].status, GroupMembership.MEMBER)
eq_(curator_membership[0].status, GroupMembership.MEMBER)
invalidate_group_membership()
ok_(not group.groupmembership_set.filter(userprofile=member.userprofile).exists())
ok_(group.groupmembership_set.filter(userprofile=curator.userprofile).exists())
subject = 'Removed from Mozillians group "foo"'
mock_send_mail.assert_called_once_with(subject, ANY, '*****@*****.**',
[member.email], fail_silently=False)
def setUp(self):
voucher = UserFactory.create()
self.user = UserFactory.create(
userprofile={'is_vouched': True,
'vouched_by': voucher.userprofile})
group = GroupFactory.create()
group.add_member(self.user.userprofile)
skill = SkillFactory.create()
self.user.userprofile.skills.add(skill)
self.user.userprofile.externalaccount_set.create(type=ExternalAccount.TYPE_SUMO,
identifier='Apitest')
self.resource_url = reverse(
'api_dispatch_list',
kwargs={'api_name': 'v1', 'resource_name': 'users'})
self.mozilla_app = APIAppFactory.create(
owner=self.user, is_mozilla_app=True)
self.mozilla_resource_url = urlparams(
self.resource_url, app_name=self.mozilla_app.name,
app_key=self.mozilla_app.key)
self.community_app = APIAppFactory.create(
owner=self.user, is_mozilla_app=False)
self.community_resource_url = urlparams(
self.resource_url, app_name=self.community_app.name,
app_key=self.community_app.key)
def test_email_in_identity_belongs_to_other_user(self, jws_mock, request_post_mock,
msg_mock):
"""Test adding a stronger identity and changing the primary email."""
UserFactory.create(email='*****@*****.**')
user1 = UserFactory.create(email='*****@*****.**')
(jws_mock.from_compact.return_value).payload = json.dumps({
'email': '*****@*****.**',
'email_verified': True,
'sub': 'ad|ldap'
})
post_json_mock = Mock()
post_json_mock.json.return_value = {
'id_token': 'id_token'
}
with self.login(user1) as client:
session = client.session
session['oidc_verify_nonce'] = 'nonce'
session['oidc_verify_state'] = 'state'
session.save()
response = client.get(self.url, self.get_data, follow=True)
msg = 'The email in this identity is used by another user.'
msg_mock.error.assert_called_once_with(ANY, msg)
with override_script_prefix('/en-US/'):
url = reverse('phonebook:profile_edit')
self.assertRedirects(response, url)
def test_sending_pending_email(self):
# If a curated group has a pending membership, added since the reminder email
# was last sent, send the curator an email. It should contain the count of
# all pending memberships.
curator = UserFactory.create()
group = GroupFactory.create(curator=curator.userprofile)
# Add a couple of pending memberships
group.add_member(UserFactory.create().userprofile, GroupMembership.PENDING)
group.add_member(UserFactory.create().userprofile, GroupMembership.PENDING)
with patch('mozillians.groups.tasks.send_mail', autospec=True) as mock_send_mail:
tasks.send_pending_membership_emails()
ok_(mock_send_mail.called)
# Should only have been called once
eq_(1, len(mock_send_mail.call_args_list))
# The message body should mention that there are 2 pending memberships
subject, body, from_addr, to_list = mock_send_mail.call_args[0]
eq_('2 outstanding requests to join Mozillians group "%s"' % group.name, subject)
ok_('There are 2 outstanding requests' in body)
# Full path to group page is in the message
ok_(group.get_absolute_url() in body)
print("to_list=%s, curator.email=%s" % (to_list, curator.email))
ok_(curator.email in to_list)
# Add another pending membership
group.add_member(UserFactory.create().userprofile, GroupMembership.PENDING)
# Should send email again
with patch('mozillians.groups.tasks.send_mail', autospec=True) as mock_send_mail:
tasks.send_pending_membership_emails()
ok_(mock_send_mail.called)
def test_list_mozillians_in_location_region_vouched(self):
country = CountryFactory.create()
country2 = CountryFactory.create()
region = RegionFactory.create(country=country)
region2 = RegionFactory.create(country=country)
user_listed = UserFactory.create(
userprofile={'geo_country': country,
'geo_region': region})
UserFactory.create(
userprofile={'geo_country': country,
'geo_region': region2})
UserFactory.create()
UserFactory.create(vouched=False)
UserFactory.create(vouched=False, userprofile={'geo_country': country2})
user = UserFactory.create()
with self.login(user) as client:
url = reverse(
'phonebook:list_region',
kwargs={'country': country.name, 'region': region.name})
response = client.get(url, follow=True)
eq_(response.status_code, 200)
self.assertTemplateUsed(response, 'phonebook/location_list.html')
eq_(response.context['country_name'], country.name)
eq_(response.context['city_name'], None)
eq_(response.context['region_name'], region.name)
eq_(response.context['people'].paginator.count, 1)
eq_(response.context['people'].object_list[0], user_listed.userprofile)
def test_list_mozillians_in_location_region_n_city_vouched(self):
user_listed = UserFactory.create(userprofile={'is_vouched': True,
'country': 'it',
'region': 'Florence',
'city': 'madova'})
UserFactory.create(userprofile={'is_vouched': True,
'country': 'it',
'region': 'florence',
'city': 'foo'})
UserFactory.create(userprofile={'is_vouched': True})
UserFactory.create()
UserFactory.create(userprofile={'country': 'gr'})
user = UserFactory.create(userprofile={'is_vouched': True})
with self.login(user) as client:
url = reverse('phonebook:list_region_city', kwargs={'country': 'it',
'region': 'florence',
'city': 'Madova'})
response = client.get(url, follow=True)
eq_(response.status_code, 200)
self.assertTemplateUsed(response, 'phonebook/location-list.html')
eq_(response.context['country_name'], 'Italy')
eq_(response.context['city_name'], 'Madova')
eq_(response.context['region_name'], 'florence')
eq_(response.context['people'].count(), 1)
eq_(response.context['people'][0], user_listed.userprofile)
def setUp(self):
voucher = UserFactory.create(userprofile={'is_vouched': True})
self.user = UserFactory.create(
userprofile={'is_vouched': True,
'vouched_by': voucher.userprofile})
group = GroupFactory.create()
self.user.userprofile.groups.add(group)
skill = SkillFactory.create()
self.user.userprofile.skills.add(skill)
language = LanguageFactory.create()
self.user.userprofile.languages.add(language)
self.resource_url = reverse(
'api_dispatch_list',
kwargs={'api_name': 'v1', 'resource_name': 'users'})
self.mozilla_app = APIAppFactory.create(
owner=self.user, is_mozilla_app=True)
self.mozilla_resource_url = urlparams(
self.resource_url, app_name=self.mozilla_app.name,
app_key=self.mozilla_app.key)
self.community_app = APIAppFactory.create(
owner=self.user, is_mozilla_app=False)
self.community_resource_url = urlparams(
self.resource_url, app_name=self.community_app.name,
app_key=self.community_app.key)
def test_voucher_nonpublic(self):
voucher = UserFactory.create()
user = UserFactory.create(userprofile={"is_vouched": True, "vouched_by": voucher.userprofile})
user_profile = user.userprofile
user_profile.set_instance_privacy_level(PUBLIC)
eq_(user_profile.vouched_by, None)
def test_invalidate_open_group(self, mail_task):
member = UserFactory.create(vouched=True)
curator = UserFactory.create(vouched=True)
# Group of type Group.OPEN
group = GroupFactory.create(name='Foo', terms='Example terms.', invalidation_days=5,
accepting_new_members=Group.OPEN)
group.curators.add(curator.userprofile)
group.add_member(member.userprofile)
group.add_member(curator.userprofile)
membership = group.groupmembership_set.filter(userprofile=member.userprofile)
curator_membership = group.groupmembership_set.filter(userprofile=curator.userprofile)
membership.update(updated_on=datetime.now() - timedelta(days=10))
curator_membership.update(updated_on=datetime.now() - timedelta(days=10))
eq_(membership[0].status, GroupMembership.MEMBER)
eq_(curator_membership[0].status, GroupMembership.MEMBER)
invalidate_group_membership()
ok_(not group.groupmembership_set.filter(userprofile=member.userprofile).exists())
ok_(group.groupmembership_set.filter(userprofile=curator.userprofile).exists())
mail_task.delay.assert_called_once_with(group.id, member.id, GroupMembership.MEMBER, None)
def test_email_now_vouched_with_voucher(self, send_mail_mock):
voucher = UserFactory.create()
user = UserFactory.create(vouched=False)
user.userprofile._email_now_vouched(voucher.userprofile)
ok_(send_mail_mock.called)
eq_(send_mail_mock.call_args[0][3], [user.email])
ok_(voucher.userprofile.full_name in send_mail_mock.call_args[0][1])
def test_get_curated(self):
GroupFactory.create()
GroupFactory.create()
user_1 = UserFactory.create()
user_2 = UserFactory.create()
cgroup_1 = GroupFactory.create(steward=user_1.userprofile)
cgroup_2 = GroupFactory.create(steward=user_2.userprofile)
eq_(set(Group.get_curated()), set([cgroup_1, cgroup_2]))
def test_get_functional_areas(self):
GroupFactory.create()
GroupFactory.create()
UserFactory.create()
UserFactory.create()
cgroup_1 = GroupFactory.create(functional_area=True)
GroupFactory.create(functional_area=False)
eq_(set(Group.get_functional_areas()), set([cgroup_1]))
def test_view_profile_waiting_for_vouch_vouched(self):
unvouched_user = UserFactory.create(vouched=False)
user = UserFactory.create()
url = reverse('phonebook:profile_view',
kwargs={'username': unvouched_user.username})
with self.login(user) as client:
response = client.get(url, follow=True)
ok_('vouch_form' in response.context)
def test_vouch_no_commit(self, email_vouched_mock):
user_1 = UserFactory.create(userprofile={'is_vouched': True})
user_2 = UserFactory.create()
user_2.userprofile.vouch(user_1.userprofile, commit=False)
user_2 = User.objects.get(id=user_2.id)
ok_(not user_2.userprofile.is_vouched)
ok_(not user_2.userprofile.vouched_by)
ok_(not user_2.userprofile.date_vouched)
ok_(email_vouched_mock.called)
def test_view_profile_no_public_unvouched(self, redirect_mock, error_mock):
lookup_user = UserFactory.create()
user = UserFactory.create(vouched=False)
with self.login(user) as client:
url = reverse('phonebook:profile_view',
kwargs={'username': lookup_user.username})
client.get(url, follow=True)
ok_(redirect_mock.called)
ok_(error_mock.called)
def test_privacy_aware_iterator(self):
UserFactory.create(userprofile={'ircname': 'foo'})
s = PrivacyAwareS(UserProfileMappingType)
# Manually set privacy level in UserProfileMappingType instance
s.privacy_level(PUBLIC)
q = s.query(ircname='foo')
eq_(len(q), 1)
eq_(q[0]._privacy_level, PUBLIC)
def test_vouch_reset(self):
voucher = UserFactory.create()
user = UserFactory.create(userprofile={"vouched_by": voucher.userprofile, "date_vouched": now()})
profile = user.userprofile
profile.is_vouched = False
profile.save()
profile = UserProfile.objects.get(pk=profile.id)
eq_(profile.vouched_by, None)
eq_(profile.date_vouched, None)
def test_is_vouched_false(self):
UserFactory.create(userprofile={'is_vouched': True})
user = UserFactory.create(userprofile={'is_vouched': False})
client = Client()
url = urlparams(self.mozilla_resource_url, is_vouched='false')
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], unicode(user.userprofile.id))
def test_auto_vouching(self):
UserFactory.create(email='*****@*****.**')
user_1 = UserFactory.create(vouched=False, email='*****@*****.**')
user_1 = User.objects.get(pk=user_1.pk)
ok_(user_1.userprofile.is_vouched)
eq_(user_1.userprofile.vouches_received.all()[0].autovouch, True)
user_2 = UserFactory.create(vouched=False, email='*****@*****.**')
ok_(not user_2.userprofile.is_vouched)
def test_is_vouched_true(self):
UserFactory.create(userprofile={'is_vouched': True})
UserFactory.create(userprofile={'is_vouched': False})
client = Client()
url = urlparams(self.mozilla_resource_url, is_vouched='true')
response = client.get(url, follow=True)
data = json.loads(response.content)
for obj in data['objects']:
ok_(obj['is_vouched'])
def test_request_with_huge_offset(self):
UserFactory.create(userprofile={'is_vouched': True})
UserFactory.create(userprofile={'is_vouched': True})
client = Client()
url = urlparams(self.mozilla_resource_url, offset=100000000)
response = client.get(url, follow=True)
eq_(response.status_code, 200)
data = json.loads(response.content)
eq_(data['meta']['offset'], data['meta']['total_count'])
def test_multiple_vouches(self):
user = UserFactory.create(vouched=False)
# 9 vouches, only 2 should stick.
for i in range(1, 10):
user.userprofile.vouch(UserFactory.create().userprofile)
eq_(user.userprofile.vouches_received.all().count(), 2)
def test_get_url(self):
profile = UserFactory.create().userprofile
account = profile.externalaccount_set.create(
type=ExternalAccount.TYPE_MDN, identifier='sammy')
ok_('sammy' in account.get_identifier_url())
def test_exif_broken(self):
"""Test image with broken EXIF data."""
user = UserFactory.create()
file_path = os.path.join(os.path.dirname(__file__), "broken_exif.jpg")
self._upload_photo(user, file_path)
def test_email_now_vouched_first_vouch(self, get_template_mock,
send_mail_mock):
user = UserFactory.create()
user.userprofile._email_now_vouched(None)
eq_(get_template_mock().render.call_args[0][0]['first_vouch'], True)
def test_is_manager_when_superuser(self):
user = UserFactory.create(is_superuser=True)
ok_(user.userprofile.is_manager)
def test_is_nda_when_pending(self):
user = UserFactory.create()
group = GroupFactory.create(name='foobar')
group.add_member(user.userprofile, status='PENDING')
ok_(not user.userprofile.is_nda)
def test_tshirt_public(self):
user = UserFactory.create(userprofile={'tshirt': 9})
public_profile = user.userprofile
public_profile.set_instance_privacy_level(PUBLIC)
eq_(public_profile.tshirt, UserProfile.privacy_fields()['tshirt'])
def test_email_public(self):
user = UserFactory.create(userprofile={'privacy_email': PUBLIC})
public_profile = user.userprofile
public_profile.set_instance_privacy_level(PUBLIC)
eq_(public_profile.email, user.email)
def setUp(self):
self.group = GroupFactory.create()
self.url = reverse('groups:show_group', kwargs={'url': self.group.url})
self.user_1 = UserFactory.create()
self.user_2 = UserFactory.create()
self.group.add_member(self.user_2.userprofile)
def test_show_unvouched(self):
user = UserFactory.create(vouched=False)
with self.login(user) as client:
client.get(self.url, follow=True)
def test_set_instance_privacy_level(self):
user = UserFactory.create()
user.userprofile.set_instance_privacy_level(9)
eq_(user.userprofile._privacy_level, 9)
def test_vouch_once_per_voucher(self):
voucher = UserFactory.create()
user = UserFactory.create(vouched=False)
user.userprofile.vouch(voucher.userprofile)
user.userprofile.vouch(voucher.userprofile)
eq_(user.userprofile.vouches_received.all().count(), 1)
def test_is_nda_when_not_member(self):
user = UserFactory.create()
GroupFactory.create(name='foobar')
ok_(not user.userprofile.is_nda)
def test_privacy_level_employee(self):
user = UserFactory.create()
group, _ = Group.objects.get_or_create(name='staff')
group.add_member(user.userprofile)
eq_(user.userprofile.privacy_level, EMPLOYEES)
def test_is_nda_when_member(self):
user = UserFactory.create()
group = GroupFactory.create(name='foobar')
group.add_member(user.userprofile)
ok_(user.userprofile.is_nda)
def test_privacy_level_vouched(self):
user = UserFactory.create()
eq_(user.userprofile.privacy_level, MOZILLIANS)
def test_vouch_non_mozilla_alternate_email(self):
user = UserFactory.create(vouched=False)
user.userprofile.externalaccount_set.create(
type=ExternalAccount.TYPE_EMAIL, identifier='*****@*****.**')
eq_(Vouch.objects.filter(vouchee=user.userprofile).count(), 0)
eq_(user.userprofile.is_vouched, False)
def test_auto_vouch_on_profile_save(self, auto_vouch_mock):
UserFactory.create()
ok_(auto_vouch_mock.called)
def test_get_attribute_with_public_level(self, mock_privacy_fields):
mock_privacy_fields.return_value = {'full_name': ''}
user = UserFactory.create(userprofile={'full_name': 'foobar'})
profile = user.userprofile
profile.set_instance_privacy_level(PUBLIC)
eq_(profile.full_name, '')
def test_email_now_vouched(self, send_mail_mock):
user = UserFactory.create()
user.userprofile._email_now_vouched(None)
ok_(send_mail_mock.called)
eq_(send_mail_mock.call_args[0][3], [user.email])
def test_is_manager_when_not_manager(self):
user = UserFactory.create()
ok_(not user.userprofile.is_manager)
def test_get_attribute_with_employee_level(self, mock_privacy_fields):
mock_privacy_fields.return_value = {'full_name': ''}
user = UserFactory.create(userprofile={'full_name': 'foobar'})
profile = user.userprofile
profile.set_instance_privacy_level(EMPLOYEES)
eq_(profile.full_name, 'foobar')
def test_not_existing_idp_privacy_not_allowed(self):
userprofile_args = {'privacy_email': MOZILLIANS}
profile = UserFactory.create(email='*****@*****.**',
userprofile=userprofile_args).userprofile
profile.set_instance_privacy_level(PUBLIC)
eq_(profile.email, '')
def test_get_attribute_without_privacy_level(self, mock_privacy_fields):
mock_privacy_fields.return_value = {'full_name': ''}
user = UserFactory.create(userprofile={'full_name': 'foobar'})
eq_(user.userprofile.full_name, 'foobar')
def test_not_existing_idp_privacy_unaware(self):
profile = UserFactory.create(email='*****@*****.**').userprofile
eq_(profile.email, '*****@*****.**')
def test_get_url_unicode(self):
profile = UserFactory.create().userprofile
account = profile.externalaccount_set.create(
type=ExternalAccount.TYPE_MDN, identifier=u'sammyウ')
ok_('%E3%82%A6' in account.get_identifier_url())
def test_email_no_privacy(self):
user = UserFactory.create()
eq_(user.userprofile.email, user.email)
def test_remove_from_basket_task(self, unsubscribe_mock):
user = UserFactory.create(userprofile={'basket_token': 'foo'})
remove_from_basket_task(user.email, user.userprofile.basket_token)
unsubscribe_mock.assert_called_with(user.userprofile.basket_token,
user.email,
newsletters='newsletter')
def test_subscribe_to_basket_post_save(self, subscribe_user_mock):
user = UserFactory.create()
subscribe_user_mock.assert_called_with(user.userprofile.id, ['foo'])
def test_email_private(self):
user = UserFactory.create()
public_profile = user.userprofile
public_profile.set_instance_privacy_level(PUBLIC)
eq_(public_profile.email, UserProfile.privacy_fields()['email'])
