def setUp(self):
voucher = UserFactory.create()
country = CountryFactory()
region = RegionFactory()
city = CityFactory()
self.user = UserFactory.create(
userprofile={'vouched': False,
'geo_country': country,
'geo_region': region,
'geo_city': city})
self.user.userprofile.vouch(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_get_detail_mozilla_app(self):
client = Client()
url = reverse('api_dispatch_detail',
kwargs={'api_name': 'v1', 'resource_name': 'users',
'pk': self.user.userprofile.id})
url = urlparams(url, app_name=self.mozilla_app.name,
app_key=self.mozilla_app.key)
response = client.get(url, follow=True)
data = json.loads(response.content)
profile = self.user.userprofile
eq_(response.status_code, 200)
eq_(data['id'], profile.id)
eq_(data['full_name'], profile.full_name)
eq_(data['is_vouched'], profile.is_vouched)
eq_(data['vouched_by'], profile.vouched_by.id)
# eq_(data['date_vouched'], profile.date_vouched)
eq_(data['groups'], list(profile.groups.values_list('name', flat=True)))
eq_(data['skills'], list(profile.skills.values_list('name', flat=True)))
eq_(data['accounts'],
[{'identifier': a.identifier, 'type': a.type}
for a in profile.externalaccount_set.all()])
eq_(data['bio'], profile.bio)
eq_(data['photo'], profile.photo)
eq_(data['photo_thumbnail'], profile.get_photo_url())
eq_(data['ircname'], profile.ircname)
eq_(data['country'], profile.geo_country.code)
eq_(data['region'], profile.geo_region.name)
eq_(data['city'], profile.geo_city.name)
eq_(data['date_mozillian'], profile.date_mozillian)
eq_(data['timezone'], profile.timezone)
eq_(data['email'], profile.email)
eq_(data['url'],
absolutify(reverse('phonebook:profile_view',
args=[profile.user.username])))
def test_request_with_huge_limit(self):
client = Client()
url = urlparams(self.mozilla_resource_url, limit=200000000000000000000)
response = client.get(url, follow=True)
eq_(response.status_code, 200)
data = json.loads(response.content)
eq_(data['meta']['limit'], 1)
def test_search_no_ajax(self):
user = UserFactory.create()
group = GroupFactory.create()
url = urlparams(reverse("groups:search_groups"), term=group.name)
with self.login(user) as client:
response = client.get(url, follow=True)
ok_(isinstance(response, HttpResponseBadRequest))
def process_request(self, request):
prefixer = urlresolvers.Prefixer(request)
urlresolvers.set_url_prefix(prefixer)
full_path = prefixer.fix(prefixer.shortened_path)
if self._is_lang_change(request):
# Blank out the locale so that we can set a new one. Remove lang
# from the query params so we don't have an infinite loop.
prefixer.locale = ""
new_path = prefixer.fix(prefixer.shortened_path)
query = dict((smart_str(k), request.GET[k]) for k in request.GET)
query.pop("lang")
return HttpResponsePermanentRedirect(urlparams(new_path, **query))
if full_path != request.path:
query_string = request.META.get("QUERY_STRING", "")
full_path = urllib.quote(full_path.encode("utf-8"))
if query_string:
full_path = "%s?%s" % (full_path, query_string)
response = HttpResponsePermanentRedirect(full_path)
# Vary on Accept-Language if we changed the locale
old_locale = prefixer.locale
new_locale, _ = urlresolvers.split_path(full_path)
if old_locale != new_locale:
response["Vary"] = "Accept-Language"
return response
request.path_info = "/" + prefixer.shortened_path
request.locale = prefixer.locale
tower.activate(prefixer.locale)
def test_community_app_does_not_allow_community_sites(self):
user = UserFactory.create(userprofile={'allows_community_sites': False})
client = Client()
url = urlparams(self.community_resource_url, email=user.email)
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(response.status_code, 200)
eq_(len(data['objects']), 0)
def test_search_username(self):
user = UserFactory.create()
url = urlparams(self.mozilla_resource_url, username=user.username)
client = Client()
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], user.userprofile.id)
def test_search_incomplete_profile(self):
user = UserFactory.create(vouched=False, userprofile={"full_name": ""})
group = GroupFactory.create(visible=True)
url = urlparams(reverse("groups:search_skills"), term=group.name)
with self.login(user) as client:
response = client.get(url, follow=True, **{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
eq_(response.status_code, 200)
eq_(response.get("content-type"), "application/json")
def test_mozilla_app_does_allows_mozilla_sites(self):
user = UserFactory.create(userprofile={'allows_mozilla_sites': True})
client = Client()
url = urlparams(self.mozilla_resource_url, email=user.email)
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(response.status_code, 200)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['email'], user.email)
def test_search_incomplete_profile(self):
user = UserFactory.create(vouched=True, userprofile={'full_name': ''})
group = GroupFactory.create(visible=True)
url = urlparams(reverse('groups:skills-autocomplete'), q=group.name)
with self.login(user) as client:
response = client.get(url, follow=True,
**{'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'})
eq_(response.status_code, 200)
eq_(response.get('content-type'), 'application/json')
def test_search_name(self):
user = UserFactory.create(userprofile={'full_name': u'Νίκος Κούκος'})
client = Client()
url = urlparams(self.mozilla_resource_url,
name=user.userprofile.full_name)
request = client.get(url, follow=True)
data = json.loads(request.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], user.userprofile.id)
def test_query_with_space(self):
city = CityFactory.create(name='Mountain View')
user = UserFactory.create(userprofile={'geo_city': city})
client = Client()
url = urlparams(self.mozilla_resource_url, city='mountain view')
request = client.get(url, follow=True)
data = json.loads(request.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], user.userprofile.id)
def test_is_vouched_false(self):
UserFactory.create()
user = UserFactory.create(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'], user.userprofile.id)
def test_is_vouched_true(self):
UserFactory.create()
UserFactory.create(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()
UserFactory.create()
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_search_unvouched(self):
user = UserFactory.create(vouched=False)
group = GroupFactory.create(visible=True)
url = urlparams(reverse('groups:search_groups'), term=group.name)
with self.login(user) as client:
response = client.get(url, follow=True,
**{'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'})
eq_(response.status_code, 200)
eq_(response.get('content-type'), 'application/json')
def test_get_detail_community_app(self):
client = Client()
url = reverse('api_dispatch_detail',
kwargs={'api_name': 'v1', 'resource_name': 'users',
'pk': self.user.userprofile.id})
url = urlparams(url, app_name=self.community_app.name,
app_key=self.community_app.key)
response = client.get(url, follow=True)
eq_(response.status_code, 403)
def test_search_country(self):
country = CountryFactory.create(code='fr')
user = UserFactory.create(userprofile={'geo_country': country})
url = urlparams(self.mozilla_resource_url,
country=user.userprofile.geo_country.code)
client = Client()
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], user.userprofile.id)
def setUp(self):
self.resource_url = reverse(
'api_dispatch_list',
kwargs={'api_name': 'v1', 'resource_name': 'skills'})
self.user = UserFactory.create()
self.app = APIAppFactory.create(owner=self.user,
is_mozilla_app=True)
self.resource_url = urlparams(self.resource_url,
app_name=self.app.name,
app_key=self.app.key)
def test_search_region(self):
region = RegionFactory.create(name='la lo')
user = UserFactory.create(userprofile={'geo_region': region})
url = urlparams(self.mozilla_resource_url,
region=user.userprofile.geo_region.name)
client = Client()
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], user.userprofile.id)
def test_search_invalid_group(self):
user = UserFactory.create()
url = urlparams(reverse("groups:search_groups"), term="invalid")
with self.login(user) as client:
response = client.get(url, follow=True, **{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
eq_(response.status_code, 200)
eq_(response.get("content-type"), "application/json")
data = json.loads(response.content)
eq_(len(data), 0)
def test_search_city(self):
city = CityFactory.create(name=u'αθήνα')
user = UserFactory.create(userprofile={'geo_city': city})
url = urlparams(self.mozilla_resource_url,
city=user.userprofile.geo_city.name)
client = Client()
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], user.userprofile.id)
def test_search_invalid_group(self):
user = UserFactory.create()
url = urlparams(reverse('groups:search_groups'), term='invalid')
with self.login(user) as client:
response = client.get(url, follow=True,
**{'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'})
eq_(response.status_code, 200)
eq_(response.get('content-type'), 'application/json')
data = json.loads(response.content)
eq_(len(data), 0)
def test_register_unvouched(self, redeem_invite_mock):
user = UserFactory.create(vouched=False)
inviter = UserFactory.create()
invite = InviteFactory.create(inviter=inviter.userprofile)
url = urlparams(reverse('phonebook:register'), code=invite.code)
with self.login(user) as client:
response = client.get(url, follow=True)
user = User.objects.get(id=user.id)
ok_(user.userprofile.is_vouched)
ok_(redeem_invite_mock.called)
self.assertTemplateUsed(response, 'phonebook/home.html')
def test_list_mozillians_in_location_country_invalid_page(self):
country = CountryFactory.create()
UserFactory.create(userprofile={'geo_country': country})
UserFactory.create(userprofile={'geo_country': country})
user = UserFactory.create()
with self.login(user) as client:
url = reverse('phonebook:list_country', kwargs={'country': country.name})
url = urlparams(url, page='invalid')
response = client.get(url, follow=True)
eq_(response.status_code, 200)
eq_(response.context['people'].number, 1)
def test_view_profile_mine_as_privileged(self):
user = UserFactory.create()
url = reverse('phonebook:profile_view',
kwargs={'username': user.username})
url = urlparams(url, view_as='privileged')
with self.login(user) as client:
response = client.get(url, follow=True)
self.assertTemplateUsed(response, 'phonebook/profile.html')
eq_(response.context['shown_user'], user)
eq_(response.context['profile'], user.userprofile)
eq_(response.context['profile']._privacy_level, PRIVILEGED)
eq_(response.context['privacy_mode'], 'privileged')
def test_search_groups_pending_membership(self):
client = Client()
group = GroupFactory.create()
user_1 = UserFactory.create()
user_2 = UserFactory.create()
group.add_member(user_1.userprofile, GroupMembership.PENDING)
group.add_member(user_2.userprofile, GroupMembership.PENDING)
url = urlparams(self.mozilla_resource_url, groups=group.name)
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 0)
def test_search_combined_skills_country(self):
country = CountryFactory.create(code='fr')
user_1 = UserFactory.create(userprofile={'geo_country': country})
UserFactory.create(userprofile={'geo_country': country})
skill = SkillFactory.create()
user_1.userprofile.skills.add(skill)
client = Client()
url = urlparams(self.mozilla_resource_url,
skills=skill.name, country=country.code)
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], user_1.userprofile.id)
def test_distinct_results(self):
user = UserFactory.create()
group_1 = GroupFactory.create()
group_2 = GroupFactory.create()
group_1.add_member(user.userprofile)
group_2.add_member(user.userprofile)
client = Client()
url = urlparams(self.mozilla_resource_url,
groups=','.join([group_1.name, group_2.name]))
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(response.status_code, 200)
eq_(len(data['objects']), 1)
def test_search_skills(self):
user = UserFactory.create()
skill_1 = SkillFactory.create()
SkillFactory.create()
url = urlparams(reverse("groups:search_skills"), term=skill_1.name)
with self.login(user) as client:
response = client.get(url, follow=True, **{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
eq_(response.status_code, 200)
eq_(response.get("content-type"), "application/json")
data = json.loads(response.content)
eq_(len(data), 1, "Non autocomplete skills are included in search")
eq_(data[0], skill_1.name)
def test_search_accounts(self):
client = Client()
user_1 = UserFactory.create()
user_1.userprofile.externalaccount_set.create(
type=ExternalAccount.TYPE_SUMO, identifier='AccountTest')
user_2 = UserFactory.create()
user_2.userprofile.externalaccount_set.create(
type=ExternalAccount.TYPE_SUMO, identifier='AccountTest')
url = urlparams(self.mozilla_resource_url, accounts='count')
response = client.get(url, follow=True)
data = json.loads(response.content)
eq_(len(data['objects']), 2)
eq_(data['objects'][0]['accounts'][0]['identifier'], 'AccountTest')
def test_search_existing_group(self):
user = UserFactory.create()
group_1 = GroupFactory.create(visible=True)
GroupFactory.create()
url = urlparams(reverse('groups:search_groups'), term=group_1.name)
with self.login(user) as client:
response = client.get(url, follow=True,
**{'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'})
eq_(response.status_code, 200)
eq_(response.get('content-type'), 'application/json')
data = json.loads(response.content)
eq_(len(data), 1, 'Non autocomplete groups are included in search')
eq_(data[0], group_1.name)
def test_search_skills(self):
user = UserFactory.create()
skill_1 = SkillFactory.create()
SkillFactory.create()
url = urlparams(reverse('groups:skills-autocomplete'), q=skill_1.name)
with self.login(user) as client:
response = client.get(url, follow=True,
**{'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'})
eq_(response.status_code, 200)
eq_(response.get('content-type'), 'application/json')
data = json.loads(response.content)
eq_(len(data['results']), 1, 'Non autocomplete skills are included in search')
eq_(data['results'][0]['id'], skill_1.id)
def setUp(self):
voucher = UserFactory.create()
country = CountryFactory()
region = RegionFactory()
city = CityFactory()
self.user = UserFactory.create(
userprofile={
'vouched': False,
'geo_country': country,
'geo_region': region,
'geo_city': city
})
self.user.userprofile.vouch(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_list_mozillians_in_location_country_second_page(self):
country = CountryFactory.create()
UserFactory.create(userprofile={'geo_country': country})
user_listed_2 = (UserFactory.create(
userprofile={'geo_country': country}))
user = UserFactory.create()
with self.login(user) as client:
url = reverse('phonebook:list_country',
kwargs={'country': country.name})
url = urlparams(url, page=2)
response = client.get(url, follow=True)
eq_(response.status_code, 200)
eq_(response.context['people'].paginator.count, 2)
eq_(response.context['people'].paginator.num_pages, 2)
eq_(response.context['people'].number, 2)
eq_(response.context['people'].object_list[0],
user_listed_2.userprofile)
def test_get_detail_mozilla_app(self):
client = Client()
url = reverse('api_dispatch_detail',
kwargs={
'api_name': 'v1',
'resource_name': 'users',
'pk': self.user.userprofile.id
})
url = urlparams(url,
app_name=self.mozilla_app.name,
app_key=self.mozilla_app.key)
response = client.get(url, follow=True)
data = json.loads(response.content)
profile = self.user.userprofile
eq_(response.status_code, 200)
eq_(data['id'], profile.id)
eq_(data['full_name'], profile.full_name)
eq_(data['is_vouched'], profile.is_vouched)
eq_(data['vouched_by'], profile.vouched_by.id)
# eq_(data['date_vouched'], profile.date_vouched)
eq_(data['groups'], list(profile.groups.values_list('name',
flat=True)))
eq_(data['skills'], list(profile.skills.values_list('name',
flat=True)))
eq_(data['accounts'], [{
'identifier': a.identifier,
'type': a.type
} for a in profile.externalaccount_set.all()])
eq_(data['bio'], profile.bio)
eq_(data['photo'], profile.photo)
eq_(data['photo_thumbnail'], profile.get_photo_url())
eq_(data['ircname'], profile.ircname)
eq_(data['country'], profile.geo_country.code)
eq_(data['region'], profile.geo_region.name)
eq_(data['city'], profile.geo_city.name)
eq_(data['date_mozillian'], profile.date_mozillian)
eq_(data['timezone'], profile.timezone)
eq_(data['email'], profile.email)
eq_(
data['url'],
absolutify(
reverse('phonebook:profile_view',
args=[profile.user.username])))
def edit_profile(request):
"""Edit user profile view."""
# Don't use request.user
user = User.objects.get(pk=request.user.id)
profile = user.userprofile
user_groups = profile.groups.all().order_by('name')
emails = ExternalAccount.objects.filter(type=ExternalAccount.TYPE_EMAIL)
accounts_qs = ExternalAccount.objects.exclude(
type=ExternalAccount.TYPE_EMAIL)
sections = {
'registration_section': ['user_form', 'registration_form'],
'basic_section': ['user_form', 'basic_information_form'],
'groups_section': ['groups_privacy_form'],
'skills_section': ['skills_form'],
'email_section': ['email_privacy_form', 'alternate_email_formset'],
'languages_section': ['language_privacy_form', 'language_formset'],
'accounts_section': ['accounts_formset'],
'irc_section': ['irc_form'],
'location_section': ['location_form'],
'contribution_section': ['contribution_form'],
'tshirt_section': ['tshirt_form'],
'developer_section': ['developer_form']
}
curr_sect = next((s for s in sections.keys() if s in request.POST), None)
def get_request_data(form):
if curr_sect and form in sections[curr_sect]:
return request.POST
return None
ctx = {}
ctx['user_form'] = forms.UserForm(get_request_data('user_form'),
instance=user)
ctx['registration_form'] = forms.RegisterForm(
get_request_data('registration_form'),
request.FILES or None,
instance=profile)
basic_information_data = get_request_data('basic_information_form')
ctx['basic_information_form'] = forms.BasicInformationForm(
basic_information_data, request.FILES or None, instance=profile)
ctx['accounts_formset'] = forms.AccountsFormset(
get_request_data('accounts_formset'),
instance=profile,
queryset=accounts_qs)
ctx['language_formset'] = forms.LanguagesFormset(
get_request_data('language_formset'),
instance=profile,
locale=request.locale)
language_privacy_data = get_request_data('language_privacy_form')
ctx['language_privacy_form'] = forms.LanguagesPrivacyForm(
language_privacy_data, instance=profile)
ctx['skills_form'] = forms.SkillsForm(get_request_data('skills_form'),
instance=profile)
location_initial = {
'saveregion': True if profile.geo_region else False,
'savecity': True if profile.geo_city else False,
'lat': profile.lat,
'lng': profile.lng
}
ctx['location_form'] = forms.LocationForm(
get_request_data('location_form'),
instance=profile,
initial=location_initial)
ctx['contribution_form'] = forms.ContributionForm(
get_request_data('contribution_form'), instance=profile)
ctx['tshirt_form'] = forms.TshirtForm(get_request_data('tshirt_form'),
instance=profile)
ctx['groups_privacy_form'] = forms.GroupsPrivacyForm(
get_request_data('groups_privacy_form'), instance=profile)
ctx['irc_form'] = forms.IRCForm(get_request_data('irc_form'),
instance=profile)
ctx['developer_form'] = forms.DeveloperForm(
get_request_data('developer_form'), instance=profile)
ctx['email_privacy_form'] = forms.EmailPrivacyForm(
get_request_data('email_privacy_form'), instance=profile)
alternate_email_formset_data = get_request_data('alternate_email_formset')
ctx['alternate_email_formset'] = forms.AlternateEmailFormset(
alternate_email_formset_data, instance=profile, queryset=emails)
forms_valid = True
if request.POST:
if not curr_sect:
raise Http404
curr_forms = map(lambda x: ctx[x], sections[curr_sect])
forms_valid = all(map(lambda x: x.is_valid(), curr_forms))
if forms_valid:
old_username = request.user.username
for f in curr_forms:
f.save()
next_section = request.GET.get('next')
next_url = urlparams(reverse('phonebook:profile_edit'),
next_section)
if curr_sect == 'registration_section':
settings_url = reverse('phonebook:profile_edit')
settings_link = '<a href="{0}">settings</a>'.format(
settings_url)
msg = _(u'Your registration is complete. '
u'Feel free to visit the {0} page to add '
u'additional information to your profile.'.format(
settings_link))
messages.info(request, mark_safe(msg))
redeem_invite(profile, request.session.get('invite-code'))
next_url = reverse('phonebook:profile_view',
args=[user.username])
elif user.username != old_username:
msg = _(u'You changed your username; '
u'please note your profile URL has also changed.')
messages.info(request, _(msg))
return HttpResponseRedirect(next_url)
ctx.update({
'user_groups': user_groups,
'profile': request.user.userprofile,
'vouch_threshold': settings.CAN_VOUCH_THRESHOLD,
'mapbox_id': settings.MAPBOX_PROFILE_ID,
'apps': user.apiapp_set.filter(is_active=True),
'appsv2': profile.apps.filter(enabled=True),
'forms_valid': forms_valid
})
return render(request, 'phonebook/edit_profile.html', ctx)
def get_url(self, absolute=True):
"""A url that can be used to redeem this invite."""
return absolutify(
urlparams(reverse('phonebook:register'), code=self.code))
def test_search_anonymous(self):
url = urlparams(reverse('groups:search_groups'), term='invalid')
client = Client()
client.get(url, follow=True)
