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