Python tests.CountryFactory类代码示例

 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_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 = '[email protected]'
        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_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='[email protected]')
        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_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_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_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_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_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_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_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_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='[email protected]')
     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_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)