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)

 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 setUp(self):
     self.user = UserFactory.create(email='[email protected]')
     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_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="[email protected]", 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")