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'])