def test_list_mozillians_in_location_country_vouched(self):
country = CountryFactory.create()
country2 = CountryFactory.create()
user_listed_1 = UserFactory.create(
userprofile={'geo_country': country})
UserFactory.create(userprofile={'geo_country': country})
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_country',
kwargs={'country': country.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'], None)
eq_(response.context['people'].paginator.count, 2)
eq_(response.context['people'].paginator.num_pages, 2)
eq_(response.context['people'].number, 1)
eq_(response.context['people'].object_list[0],
user_listed_1.userprofile)
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 setUp(self):
self.user = UserFactory.create(email='*****@*****.**',
userprofile={
'geo_country': None,
'geo_region': None,
'geo_city': None
})
self.data = {
'full_name': self.user.userprofile.full_name,
'email': self.user.email,
'username': self.user.username,
'lat': 40.005814,
'lng': -3.42071,
'externalaccount_set-MAX_NUM_FORMS': '1000',
'externalaccount_set-INITIAL_FORMS': '0',
'externalaccount_set-TOTAL_FORMS': '0',
'language_set-MAX_NUM_FORMS': '1000',
'language_set-INITIAL_FORMS': '0',
'language_set-TOTAL_FORMS': '0',
'location_section': ''
}
self.country = CountryFactory.create(mapbox_id='country1',
name='Petoria')
self.region = RegionFactory.create(country=self.country,
mapbox_id='reg1',
name='Ontario')
self.city = CityFactory.create(region=self.region,
mapbox_id='city1',
name='Toronto')
def test_update_basket_task(self, mock_basket):
# When a user is created or added to a group, the appropriate
# calls to update basket are made
email = '*****@*****.**'
token = 'footoken'
mock_basket.lookup_user.return_value = {
'email': email,
}
mock_basket.subscribe.return_value = {
'token': token,
}
country = CountryFactory.create(name='Greece', code='gr')
city = CityFactory.create(name='Athens', country=country)
user = UserFactory.create(
email=email,
userprofile={'geo_country': country,
'geo_city': city})
mock_basket.subscribe.reset_mock() # forget that subscribe was called
group = GroupFactory.create(name='Web Development',
functional_area=True)
GroupFactory.create(name='Marketing', functional_area=True)
data = {'country': 'gr',
'city': 'Athens',
'WEB_DEVELOPMENT': 'Y',
'MARKETING': 'N'}
group.add_member(user.userprofile)
# We just added a group, we should not need to subscribe anything
ok_(not mock_basket.subscribe.called)
# But we do need to update their phonebook record
mock_basket.request.assert_called_with(
'post', 'custom_update_phonebook', token=token, data=data)
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_with_region(self):
country = CountryFactory.create()
result = {'province': {'name': 'NC', 'id': 'ID'}}
region = result_to_region(result, country)
eq_('NC', region.name)
eq_('ID', region.mapbox_id)
eq_(country, region.country)
def test_duplicate_results(self):
"""Test that in case mapbox API returns a country already stored in DB
with diferrent mapbox_id, we gracefully update all entries and foreign keys
with the latest mapbox data."""
country = CountryFactory.create(mapbox_id='42')
user = UserFactory.create(userprofile={'geo_country': country})
result = {
'country': {
'name': country.name,
'id': '24'
}
}
result_to_country(result)
country_qs = Country.objects.filter(name=country.name)
eq_(country_qs.count(), 1)
eq_(country_qs[0].mapbox_id, '24')
ok_(not Country.objects.filter(mapbox_id='42').exists())
userprofile = UserProfile.objects.get(pk=user.userprofile.id)
eq_(userprofile.geo_country.name, country.name)
eq_(userprofile.geo_country.mapbox_id, '24')
def test_location_city_region_optout(self, mock_reverse_geocode):
country = CountryFactory.create(mapbox_id='country1', name='Petoria')
region = RegionFactory.create(country=country, mapbox_id='region1', name='Ontario')
city = CityFactory.create(region=region, mapbox_id='city1', name='Toronto')
mock_reverse_geocode.return_value = (country, region, city)
user = UserFactory.create(email='*****@*****.**')
data = {'full_name': user.userprofile.full_name,
'email': user.email,
'username': user.username,
'lat': 40.005814,
'lng': -3.42071,
'externalaccount_set-MAX_NUM_FORMS': '1000',
'externalaccount_set-INITIAL_FORMS': '0',
'externalaccount_set-TOTAL_FORMS': '0',
'language_set-MAX_NUM_FORMS': '1000',
'language_set-INITIAL_FORMS': '0',
'language_set-TOTAL_FORMS': '0',
}
data.update(_get_privacy_fields(MOZILLIANS))
form = ProfileForm(data=data)
eq_(form.is_valid(), True)
eq_(form.instance.geo_country, country)
eq_(form.instance.geo_region, None)
eq_(form.instance.geo_city, None)
def test_get_country(self):
context = {'request': self.factory.get('/')}
country = CountryFactory.create(name='LA', code='IO')
user = UserFactory.create(userprofile={'geo_country': country})
serializer = UserProfileDetailedSerializer(user.userprofile,
context=context)
country = {'code': 'IO', 'value': 'LA', 'privacy': 'Mozillians'}
eq_(serializer.data['country'], country)
def test_get_country(self):
country = CountryFactory.create(name='LA', code='IO')
user = UserFactory.create(userprofile={'geo_country': country})
data = UserProfileDetailedSerializer(user.userprofile).data
country = {'code': 'IO',
'value': 'LA',
'privacy': 'Mozillians'}
eq_(data['country'], country)
def test_get_country(self):
country = CountryFactory.create(name='LA', code='IO')
user = UserFactory.create(userprofile={'geo_country': country})
data = UserProfileDetailedSerializer(user.userprofile).data
country = {'code': 'IO',
'value': 'LA',
'privacy': 'Mozillians'}
eq_(data['country'], country)
def test_list_mozillians_in_location_region_n_city_vouched(self):
"""
Test that only vouched users with the correct country, city
and region show up in the list view.
"""
country = CountryFactory.create()
country2 = CountryFactory.create()
region = RegionFactory.create(country=country)
city = CityFactory(country=country, region=region)
city2 = CityFactory(country=country)
user_listed = UserFactory.create(userprofile={
'geo_country': country,
'geo_region': region,
'geo_city': city
})
UserFactory.create(userprofile={
'geo_country': country,
'geo_region': region,
'geo_city': city2
})
UserFactory.create()
UserFactory.create(vouched=False)
UserFactory.create(vouched=False,
userprofile={'geo_country': country2})
UserFactory.create(userprofile={'geo_country': country})
UserFactory.create(userprofile={
'geo_country': country,
'geo_region': region
})
user = UserFactory.create()
with self.login(user) as client:
url = reverse('phonebook:list_region_city',
kwargs={
'country': country.name,
'region': region.name,
'city': city.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'], city.name)
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_update_country_name(self):
# If country name has changed, we update our database
country = CountryFactory.create()
# Mapbox returns same country ID, but new improved country name
new_name = 'Democratic Republic of %s' % country.name
result = {'country': {'id': country.mapbox_id, 'name': new_name}}
country = result_to_country(result)
country = Country.objects.get(pk=country.pk)
eq_(new_name, country.name)
def test_get_country(self):
context = {'request': self.factory.get('/')}
country = CountryFactory.create(name='LA', code='IO')
user = UserFactory.create(userprofile={'geo_country': country})
serializer = UserProfileDetailedSerializer(user.userprofile, context=context)
country = {'code': 'IO',
'value': 'LA',
'privacy': 'Mozillians'}
eq_(serializer.data['country'], country)
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 test_update_country_name(self):
# If country name has changed, we update our database
country = CountryFactory.create()
# Mapbox returns same country ID, but new improved country name
new_name = 'Democratic Republic of %s' % country.name
result = {'country': {'id': country.mapbox_id,
'name': new_name}}
country = result_to_country(result)
country = Country.objects.get(pk=country.pk)
eq_(new_name, country.name)
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 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_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_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_with_region(self):
country = CountryFactory.create()
result = {
'province': {
'name': 'NC',
'id': 'ID'
}
}
region = result_to_region(result, country)
eq_('NC', region.name)
eq_('ID', region.mapbox_id)
eq_(country, region.country)
def test_lat_lng_does_point_to_country(self):
# If form includes lat/lng, must point to some country; succeeds if so
user = UserFactory.create(email='*****@*****.**')
data = model_to_dict(user.userprofile)
# Try again, with valid data
data['lng'] = 35.918596
data['lat'] = -79.083799
country = CountryFactory.create()
form = LocationForm(data=data, instance=user.userprofile)
with patch('mozillians.users.models.UserProfile.reverse_geocode'):
# Pretend that geocoding does come up with a country
user.userprofile.geo_country = country
ok_(form.is_valid())
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_lat_lng_does_point_to_country(self):
# If form includes lat/lng, must point to some country; succeeds if so
user = UserFactory.create(email='*****@*****.**')
data = model_to_dict(user.userprofile)
# Try again, with valid data
data['lng'] = 35.918596
data['lat'] = -79.083799
country = CountryFactory.create()
form = ProfileForm(data=data, instance=user.userprofile)
with patch('mozillians.users.models.UserProfile.reverse_geocode'):
# Pretend that geocoding does come up with a country
user.userprofile.geo_country = country
ok_(form.is_valid())
def test_update_name(self):
# If region name has changed, we update our database
country = CountryFactory.create()
region = RegionFactory.create(country=country)
new_name = 'New %s' % region.name
result = {
'province': {
'name': new_name,
'id': region.mapbox_id,
}
}
result_to_region(result, country)
region = Region.objects.get(pk=region.pk)
eq_(new_name, region.name)
def test_update_name(self):
# If region name has changed, we update our database
country = CountryFactory.create()
region = RegionFactory.create(country=country)
new_name = 'New %s' % region.name
result = {
'province': {
'name': new_name,
'id': region.mapbox_id,
}
}
result_to_region(result, country)
region = Region.objects.get(pk=region.pk)
eq_(new_name, region.name)
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_list_mozillians_in_location_region_n_city_vouched(self):
"""
Test that only vouched users with the correct country, city
and region show up in the list view.
"""
country = CountryFactory.create()
country2 = CountryFactory.create()
region = RegionFactory.create(country=country)
city = CityFactory(country=country, region=region)
city2 = CityFactory(country=country)
user_listed = UserFactory.create(
userprofile={'geo_country': country,
'geo_region': region,
'geo_city': city})
UserFactory.create(
userprofile={'geo_country': country,
'geo_region': region,
'geo_city': city2})
UserFactory.create()
UserFactory.create(vouched=False)
UserFactory.create(vouched=False, userprofile={'geo_country': country2})
UserFactory.create(userprofile={'geo_country': country})
UserFactory.create(userprofile={'geo_country': country, 'geo_region': region})
user = UserFactory.create()
with self.login(user) as client:
url = reverse('phonebook:list_region_city',
kwargs={'country': country.name, 'region': region.name,
'city': city.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'], city.name)
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_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_with_city(self):
country = CountryFactory.create()
region = RegionFactory.create(country=country)
result = {
'city': {
'name': 'Carrboro',
'id': '1234',
'lat': 0.0,
'lon': 0.0,
}
}
city = result_to_city(result, country, region)
eq_('Carrboro', city.name)
eq_('1234', city.mapbox_id)
eq_(region, city.region)
eq_(country, city.country)
def test_country(self, mock_result_to_region, mock_result_to_country):
# If country in results, builds a Country object, passes result to result_to_region
result = {
'country': {'id': 'mapbox_id', 'name': 'Petoria'},
}
mock_result_to_country.return_value = CountryFactory.create(mapbox_id='mapbox_id',
name='Petoria')
mock_result_to_region.return_value = None
country, region, city = result_to_country_region_city(result)
ok_(region is None)
ok_(city is None)
ok_(country is not None)
ok_(isinstance(country, Country))
eq_('mapbox_id', country.mapbox_id)
eq_('Petoria', country.name)
mock_result_to_region.assert_called_with(result, country)
def test_with_city(self):
country = CountryFactory.create()
region = RegionFactory.create(country=country)
result = {
'city': {
'name': 'Carrboro',
'id': '1234',
'lat': 0.0,
'lon': 0.0,
}
}
city = result_to_city(result, country, region)
eq_('Carrboro', city.name)
eq_('1234', city.mapbox_id)
eq_(region, city.region)
eq_(country, city.country)
def test_extract_document(self):
country = CountryFactory.create(name='Greece', code='gr')
region = RegionFactory.create(name='attika', country=country)
city = CityFactory.create(name='athens',
region=region,
country=country)
user = UserFactory.create(
userprofile={
'geo_city': city,
'geo_region': region,
'allows_community_sites': False,
'allows_mozilla_sites': False,
'geo_country': country,
'full_name': 'Nikos Koukos',
'bio': 'This is my bio'
})
profile = user.userprofile
group_1 = GroupFactory.create()
group_2 = GroupFactory.create()
skill_1 = SkillFactory.create()
skill_2 = SkillFactory.create()
LanguageFactory.create(code='fr', userprofile=profile)
LanguageFactory.create(code='en', userprofile=profile)
group_1.add_member(profile)
group_2.add_member(profile)
profile.skills.add(skill_1)
profile.skills.add(skill_2)
result = UserProfile.extract_document(user.userprofile.id)
ok_(isinstance(result, dict))
eq_(result['id'], profile.id)
eq_(result['is_vouched'], profile.is_vouched)
eq_(result['region'], region.name)
eq_(result['city'], city.name)
eq_(result['allows_community_sites'], profile.allows_community_sites)
eq_(result['allows_mozilla_sites'], profile.allows_mozilla_sites)
eq_(set(result['country']), set(['gr', 'Greece']))
eq_(result['fullname'], profile.full_name.lower())
eq_(result['name'], profile.full_name.lower())
eq_(result['bio'], profile.bio)
eq_(result['has_photo'], False)
eq_(result['groups'], [group_1.name, group_2.name])
eq_(result['skills'], [skill_1.name, skill_2.name])
eq_(set(result['languages']),
set([u'en', u'fr', u'english', u'french', u'français']))
def setUp(self):
self.user = UserFactory.create(email='*****@*****.**')
self.data = {
'full_name': self.user.userprofile.full_name,
'email': self.user.email,
'username': self.user.username,
'lat': 40.005814,
'lng': -3.42071,
'externalaccount_set-MAX_NUM_FORMS': '1000',
'externalaccount_set-INITIAL_FORMS': '0',
'externalaccount_set-TOTAL_FORMS': '0',
'language_set-MAX_NUM_FORMS': '1000',
'language_set-INITIAL_FORMS': '0',
'language_set-TOTAL_FORMS': '0',
}
self.country = CountryFactory.create(mapbox_id='country1', name='Petoria')
self.region = RegionFactory.create(country=self.country, mapbox_id='reg1', name='Ontario')
self.city = CityFactory.create(region=self.region, mapbox_id='city1', name='Toronto')
def test_change_email(self, mock_basket):
# When a user's email is changed, their old email is unsubscribed
# from all newsletters and their new email is subscribed to them.
# Create a new user
email = '*****@*****.**'
token = 'first token'
mock_basket.lookup_user.return_value = {
'email': email, # the old value
'token': token,
'newsletters': ['foo', 'bar']
}
mock_basket.subscribe.return_value = {
'token': token,
}
country = CountryFactory.create(name='Greece', code='gr')
city = CityFactory.create(name='Athens', country=country)
user = UserFactory.create(email=email,
userprofile={
'geo_country': country,
'geo_city': city
})
up = UserProfile.objects.get(pk=user.userprofile.pk)
eq_(token, up.basket_token)
new_email = '*****@*****.**'
new_token = 'NEW token'
mock_basket.subscribe.return_value = {
'token': new_token,
}
user.email = new_email
user.save()
mock_basket.lookup_user.assert_called_with(token=token)
mock_basket.unsubscribe.assert_called_with(
token=token,
email=email,
optout='Y',
newsletters=[settings.BASKET_NEWSLETTER])
mock_basket.subscribe.assert_called_with(new_email,
[settings.BASKET_NEWSLETTER],
trigger_welcome='N',
sync='Y')
up = UserProfile.objects.get(pk=user.userprofile.pk)
eq_(new_token, up.basket_token)
def test_country(self, mock_result_to_region, mock_result_to_country):
# If country in results, builds a Country object, passes result to result_to_region
result = {
'country': {
'id': 'mapbox_id',
'name': 'Petoria'
},
}
mock_result_to_country.return_value = CountryFactory.create(
mapbox_id='mapbox_id', name='Petoria')
mock_result_to_region.return_value = None
country, region, city = result_to_country_region_city(result)
ok_(region is None)
ok_(city is None)
ok_(country is not None)
ok_(isinstance(country, Country))
eq_('mapbox_id', country.mapbox_id)
eq_('Petoria', country.name)
mock_result_to_region.assert_called_with(result, country)
def test_extract_document(self):
country = CountryFactory.create(name="Greece", code="gr")
region = RegionFactory.create(name="attika", country=country)
city = CityFactory.create(name="athens", region=region, country=country)
user = UserFactory.create(
userprofile={
"geo_city": city,
"geo_region": region,
"allows_community_sites": False,
"allows_mozilla_sites": False,
"geo_country": country,
"full_name": "Nikos Koukos",
"bio": "This is my bio",
}
)
profile = user.userprofile
group_1 = GroupFactory.create()
group_2 = GroupFactory.create()
skill_1 = SkillFactory.create()
skill_2 = SkillFactory.create()
LanguageFactory.create(code="fr", userprofile=profile)
LanguageFactory.create(code="en", userprofile=profile)
group_1.add_member(profile)
group_2.add_member(profile)
profile.skills.add(skill_1)
profile.skills.add(skill_2)
result = UserProfile.extract_document(user.userprofile.id)
ok_(isinstance(result, dict))
eq_(result["id"], profile.id)
eq_(result["is_vouched"], profile.is_vouched)
eq_(result["region"], region.name)
eq_(result["city"], city.name)
eq_(result["allows_community_sites"], profile.allows_community_sites)
eq_(result["allows_mozilla_sites"], profile.allows_mozilla_sites)
eq_(result["country"], country.name)
eq_(result["fullname"], profile.full_name.lower())
eq_(result["name"], profile.full_name.lower())
eq_(result["bio"], profile.bio)
eq_(result["has_photo"], False)
eq_(result["groups"], [group_1.name, group_2.name])
eq_(result["skills"], [skill_1.name, skill_2.name])
eq_(set(result["languages"]), set([u"en", u"fr", u"english", u"french", u"français"]))
def setUp(self):
self.user = UserFactory.create(
email="*****@*****.**", userprofile={"geo_country": None, "geo_region": None, "geo_city": None}
)
self.data = {
"full_name": self.user.userprofile.full_name,
"email": self.user.email,
"username": self.user.username,
"lat": 40.005814,
"lng": -3.42071,
"externalaccount_set-MAX_NUM_FORMS": "1000",
"externalaccount_set-INITIAL_FORMS": "0",
"externalaccount_set-TOTAL_FORMS": "0",
"language_set-MAX_NUM_FORMS": "1000",
"language_set-INITIAL_FORMS": "0",
"language_set-TOTAL_FORMS": "0",
}
self.country = CountryFactory.create(mapbox_id="country1", name="Petoria")
self.region = RegionFactory.create(country=self.country, mapbox_id="reg1", name="Ontario")
self.city = CityFactory.create(region=self.region, mapbox_id="city1", name="Toronto")
def test_duplicate_results(self):
"""Test that in case mapbox API returns a country already stored in DB
with diferrent mapbox_id, we gracefully update all entries and foreign keys
with the latest mapbox data."""
country = CountryFactory.create(mapbox_id='42')
user = UserFactory.create(userprofile={'geo_country': country})
result = {'country': {'name': country.name, 'id': '24'}}
result_to_country(result)
country_qs = Country.objects.filter(name=country.name)
eq_(country_qs.count(), 1)
eq_(country_qs[0].mapbox_id, '24')
ok_(not Country.objects.filter(mapbox_id='42').exists())
userprofile = UserProfile.objects.get(pk=user.userprofile.id)
eq_(userprofile.geo_country.name, country.name)
eq_(userprofile.geo_country.mapbox_id, '24')
def test_change_email(self, mock_basket):
# When a user's email is changed, their old email is unsubscribed
# from all newsletters and their new email is subscribed to them.
# Create a new user
email = '*****@*****.**'
token = 'first token'
mock_basket.lookup_user.return_value = {
'email': email, # the old value
'token': token,
'newsletters': ['foo', 'bar']
}
mock_basket.subscribe.return_value = {
'token': token,
}
country = CountryFactory.create(name='Greece', code='gr')
city = CityFactory.create(name='Athens', country=country)
user = UserFactory.create(email=email, userprofile={'geo_country': country,
'geo_city': city})
up = UserProfile.objects.get(pk=user.userprofile.pk)
eq_(token, up.basket_token)
new_email = '*****@*****.**'
new_token = 'NEW token'
mock_basket.subscribe.return_value = {
'token': new_token,
}
user.email = new_email
user.save()
mock_basket.lookup_user.assert_called_with(token=token)
mock_basket.unsubscribe.assert_called_with(
token=token, email=email, optout='Y', newsletters=[settings.BASKET_NEWSLETTER]
)
mock_basket.subscribe.assert_called_with(
new_email,
[settings.BASKET_NEWSLETTER],
trigger_welcome='N',
sync='Y'
)
up = UserProfile.objects.get(pk=user.userprofile.pk)
eq_(new_token, up.basket_token)
def test_extract_document(self):
country = CountryFactory.create(name='Greece', code='gr')
region = RegionFactory.create(name='attika', country=country)
city = CityFactory.create(name='athens', region=region, country=country)
user = UserFactory.create(userprofile={'geo_city': city,
'geo_region': region,
'allows_community_sites': False,
'allows_mozilla_sites': False,
'geo_country': country,
'full_name': 'Nikos Koukos',
'bio': 'This is my bio'})
profile = user.userprofile
group_1 = GroupFactory.create()
group_2 = GroupFactory.create()
skill_1 = SkillFactory.create()
skill_2 = SkillFactory.create()
LanguageFactory.create(code='fr', userprofile=profile)
LanguageFactory.create(code='en', userprofile=profile)
group_1.add_member(profile)
group_2.add_member(profile)
profile.skills.add(skill_1)
profile.skills.add(skill_2)
result = UserProfile.extract_document(user.userprofile.id)
ok_(isinstance(result, dict))
eq_(result['id'], profile.id)
eq_(result['is_vouched'], profile.is_vouched)
eq_(result['region'], region.name)
eq_(result['city'], city.name)
eq_(result['allows_community_sites'], profile.allows_community_sites)
eq_(result['allows_mozilla_sites'], profile.allows_mozilla_sites)
eq_(set(result['country']), set(['gr', 'Greece']))
eq_(result['fullname'], profile.full_name.lower())
eq_(result['name'], profile.full_name.lower())
eq_(result['bio'], profile.bio)
eq_(result['has_photo'], False)
eq_(result['groups'], [group_1.name, group_2.name])
eq_(result['skills'], [skill_1.name, skill_2.name])
eq_(set(result['languages']),
set([u'en', u'fr', u'english', u'french', u'français']))
def test_update_basket_task(self, mock_basket):
# When a user is created or added to a group, the appropriate
# calls to update basket are made
email = '*****@*****.**'
token = 'footoken'
mock_basket.lookup_user.return_value = {
'email': email,
}
mock_basket.subscribe.return_value = {
'token': token,
}
country = CountryFactory.create(name='Greece', code='gr')
city = CityFactory.create(name='Athens', country=country)
user = UserFactory.create(email=email,
userprofile={
'geo_country': country,
'geo_city': city
})
mock_basket.subscribe.reset_mock() # forget that subscribe was called
group = GroupFactory.create(name='Web Development',
functional_area=True)
GroupFactory.create(name='Marketing', functional_area=True)
data = {
'country': 'gr',
'city': 'Athens',
'WEB_DEVELOPMENT': 'Y',
'MARKETING': 'N'
}
group.add_member(user.userprofile)
# We just added a group, we should not need to subscribe anything
ok_(not mock_basket.subscribe.called)
# But we do need to update their phonebook record
mock_basket.request.assert_called_with('post',
'custom_update_phonebook',
token=token,
data=data)
def test_no_region(self):
country = CountryFactory.create()
eq_(None, result_to_region({}, country))
def test_no_region(self):
country = CountryFactory.create()
eq_(None, result_to_region({}, country))
