def setUp(self):
self.user1 = User.objects.create_user("a", "*****@*****.**", "a")
self.famille = models.Famille(user=self.user1, email="*****@*****.**")
self.famille.save()
self.user2 = User.objects.create_user("b", "*****@*****.**", "b")
self.presta = models.Prestataire(user=self.user2, description="Une description", email="*****@*****.**")
self.presta.save()
self.user3 = User.objects.create_user("c", "*****@*****.**", "c")
self.famille_fav = FamilleFavorite(
object_type="Prestataire", object_id=self.presta.pk, famille=self.famille
)
self.famille_fav.save()
self.prestataire_fav = PrestataireFavorite(
object_type="Famille", object_id=self.famille.pk, prestataire=self.presta
)
self.prestataire_fav.save()
self.keygroup = KeyGroup(name='activate_account', generator="sha1-hex")
self.keygroup.save()
class ModelsTestCase(TestCase):
def setUp(self):
self.user1 = User.objects.create_user("a", "*****@*****.**", "a")
self.famille = models.Famille(user=self.user1, email="*****@*****.**")
self.famille.save()
self.user2 = User.objects.create_user("b", "*****@*****.**", "b")
self.presta = models.Prestataire(user=self.user2, description="Une description", email="*****@*****.**")
self.presta.save()
self.user3 = User.objects.create_user("c", "*****@*****.**", "c")
self.famille_fav = FamilleFavorite(
object_type="Prestataire", object_id=self.presta.pk, famille=self.famille
)
self.famille_fav.save()
self.prestataire_fav = PrestataireFavorite(
object_type="Famille", object_id=self.famille.pk, prestataire=self.presta
)
self.prestataire_fav.save()
self.keygroup = KeyGroup(name='activate_account', generator="sha1-hex")
self.keygroup.save()
def tearDown(self):
User.objects.all().delete()
models.Famille.objects.all().delete()
models.Prestataire.objects.all().delete()
models.Geolocation.objects.all().delete()
FamilleFavorite.objects.all().delete()
PrestataireFavorite.objects.all().delete()
self.keygroup.delete()
def test_simple_id(self):
self.assertEqual(self.famille.simple_id, "famille__%s" % self.famille.pk)
self.assertEqual(self.presta.simple_id, "prestataire__%s" % self.presta.pk)
def test_get_user_related(self):
self.assertIsInstance(models.get_user_related(self.user1), models.Famille)
self.assertIsInstance(models.get_user_related(self.user2), models.Prestataire)
self.assertRaises(ObjectDoesNotExist, models.get_user_related, self.user3)
def test_has_user_related(self):
self.assertTrue(models.has_user_related(self.user1))
self.assertTrue(models.has_user_related(self.user2))
self.assertFalse(models.has_user_related(self.user3))
anonymous = AnonymousUser()
self.assertFalse(models.has_user_related(anonymous))
def test_is_geolocated(self):
geoloc = models.Geolocation(lat=33.01, lon=2.89)
geoloc.save()
self.assertFalse(self.famille.is_geolocated)
self.famille.geolocation = geoloc
self.famille.save()
self.assertTrue(self.famille.is_geolocated)
geoloc.has_error = True
geoloc.save()
self.assertFalse(self.famille.is_geolocated)
@patch("famille.utils.geolocation.geolocate")
def test_geolocate(self, geolocate):
geolocate.return_value = 48.895603, 2.322858
self.famille.street = "32 rue des Epinettes"
self.famille.postal_code = "75017"
self.famille.city = "Paris"
self.famille.country = "France"
self.famille.save()
self.famille.geolocate()
geolocate.assert_called_with("32 rue des Epinettes 75017 Paris, France")
self.assertIsNotNone(models.Geolocation.objects.filter(lat=48.895603, lon=2.322858).first())
self.assertEqual(self.famille.geolocation.lat, 48.895603)
self.assertEqual(self.famille.geolocation.lon, 2.322858)
@patch("famille.models.users.UserInfo.geolocate")
def test_manage_geolocation(self, mock):
self.famille.country = "France" # not enough
self.famille.save()
self.famille.manage_geolocation(["country"])
self.assertFalse(mock.called)
self.famille.street = "32 rue des Epinettes" # not enough
self.famille.save()
self.famille.manage_geolocation(["street"])
self.assertFalse(mock.called)
self.famille.city = "Paris" # enough info to geolocate
self.famille.save()
self.famille.manage_geolocation(["city"])
self.assertTrue(mock.called)
mock.reset_mock()
self.famille.city = ""
self.famille.postal_code = "75017" # enough info to geolocate
self.famille.save()
self.famille.manage_geolocation(["city"])
self.assertTrue(mock.called)
def test_add_favorite(self):
uri = "/api/v1/prestataires/%s" % self.presta.pk
self.famille.add_favorite(uri)
self.assertEqual(self.famille.favorites.all().count(), 1)
qs = FamilleFavorite.objects.filter(
famille=self.famille, object_id=self.presta.pk, object_type="Prestataire"
)
self.assertEqual(qs.count(), 1)
# cannot add same favorite
self.famille.add_favorite(uri)
self.assertEqual(self.famille.favorites.all().count(), 1)
qs = FamilleFavorite.objects.filter(
famille=self.famille, object_id=self.presta.pk, object_type="Prestataire"
)
self.assertEqual(qs.count(), 1)
def test_remove_favorite(self):
uri = "/api/v1/prestataires/%s" % self.presta.pk
FamilleFavorite(famille=self.famille, object_id=self.presta.pk, object_type="Prestataire").save()
self.famille.remove_favorite(uri)
self.assertEqual(self.famille.favorites.all().count(), 0)
def test_get_favorites_data_presta(self):
favs = self.famille.get_favorites_data()
self.assertIsInstance(favs, collections.OrderedDict)
self.assertIn("Prestataire", favs)
self.assertEqual(len(favs["Prestataire"]), 1)
self.assertIsInstance(favs["Prestataire"][0], models.Prestataire)
self.assertEqual(favs["Prestataire"][0].description, self.presta.description)
def test_get_favorites_data_famille(self):
favs = self.presta.get_favorites_data()
self.assertIsInstance(favs, collections.OrderedDict)
self.assertIn("Famille", favs)
self.assertEqual(len(favs["Famille"]), 1)
self.assertIsInstance(favs["Famille"][0], models.Famille)
self.assertEqual(favs["Famille"][0].description, self.famille.description)
def test_get_resource_uri(self):
out = "/api/v1/familles/%s" % self.famille.pk
self.assertEqual(self.famille.get_resource_uri(), out)
out = "/api/v1/prestataires/%s" % self.presta.pk
self.assertEqual(self.presta.get_resource_uri(), out)
def test_get_user(self):
self.assertEqual(self.famille_fav.get_user(), self.presta)
self.assertEqual(self.prestataire_fav.get_user(), self.famille)
def test_create_user(self):
user = models.UserInfo.create_user(self.user3, "prestataire")
self.assertIsInstance(user, models.Prestataire)
self.assertEqual(user.email, self.user3.email)
user.delete()
user = models.UserInfo.create_user(self.user3, "famille")
self.assertIsInstance(user, models.Famille)
self.assertEqual(user.email, self.user3.email)
def test_create_user_free_plan(self):
user = models.UserInfo.create_user(self.user3, "famille")
self.assertTrue(user.is_premium)
self.assertEqual(user.plan_expires_at, models.Famille.FREE_PLAN_EXPIRATION)
models.Famille.FREE_PLAN_LIMIT = datetime(2013, 7, 1, tzinfo=utc)
user = models.UserInfo.create_user(self.user2, "famille")
self.assertFalse(user.is_premium)
def test_profile_access_is_authorized(self):
request = MagicMock()
self.assertTrue(self.presta.profile_access_is_authorized(request))
# no global
self.famille.visibility_global = False
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_global = True
request.user = AnonymousUser()
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_prestataire = False
request.user = self.user2
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_prestataire = True
self.assertTrue(self.famille.profile_access_is_authorized(request))
self.famille.visibility_family = False
request.user = self.famille.user
self.assertTrue(self.famille.profile_access_is_authorized(request))
request.user = User.objects.create_user("d", "*****@*****.**", "d")
models.Famille(user=request.user, email="*****@*****.**").save()
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_family = True
self.assertTrue(self.famille.profile_access_is_authorized(request))
def test_user_is_located(self):
user = AnonymousUser()
self.assertFalse(models.user_is_located(user))
user = self.user1
self.assertFalse(models.user_is_located(user))
geoloc = models.Geolocation(lat=12.2, lon=12.2)
geoloc.save()
self.famille.geolocation = geoloc
self.famille.save()
self.assertTrue(models.user_is_located(user))
geoloc.has_error = True
geoloc.save()
self.assertFalse(models.user_is_located(user))
def test_get_pseudo(self):
self.assertEqual(self.presta.get_pseudo(), "b")
self.presta.first_name = "Joe"
self.assertEqual(self.presta.get_pseudo(), "Joe")
self.presta.name = "Jack"
self.assertEqual(self.presta.get_pseudo(), "Joe J.")
self.assertEqual(self.famille.get_pseudo(), "a")
self.famille.first_name = "Mick"
self.assertEqual(self.famille.get_pseudo(), "Mick")
self.famille.name = "Down"
self.assertEqual(self.famille.get_pseudo(), "Mick D.")
def test_compute_user_visibility_filters(self):
user = AnonymousUser()
f = models.compute_user_visibility_filters(user)
self.assertEqual(f.children, [('visibility_global', True)])
f = models.compute_user_visibility_filters(self.user1)
self.assertEqual(f.children, [('visibility_global', True), ('visibility_family', True)])
f = models.compute_user_visibility_filters(self.user2)
self.assertEqual(f.children, [('visibility_global', True), ('visibility_prestataire', True)])
@patch("django.core.mail.message.EmailMessage.send")
def test_send_verification_email(self, send):
req = HttpRequest()
req.META = {"HTTP_HOST": "toto.com"}
self.presta.send_verification_email(req)
self.assertTrue(send.called)
self.assertEqual(Key.objects.filter(claimed_by=self.presta.user, claimed=None).count(), 1)
def test_verify_user(self):
self.presta.verify_user(claimant=self.presta.user)
presta = User.objects.get(pk=self.presta.user.pk)
self.assertTrue(self.presta.user.is_active)
def test_enfant_display_only_name(self):
e = models.Enfant(e_name="John")
self.assertEqual(e.display, "John")
def test_enfant_display_no_birthday(self):
e = models.Enfant(e_name="John", e_school="Best school in the World")
self.assertEqual(e.display, u"John, scolarisé à Best school in the World")
def test_enfant_display_no_school(self):
today = datetime.now()
bday = today - timedelta(days=360*10)
e = models.Enfant(e_name="John", e_birthday=bday)
self.assertEqual(e.display, "John, 9 ans")
def test_enfant_display_all(self):
today = datetime.now()
bday = today - timedelta(days=360*10)
e = models.Enfant(e_name="John", e_school="Best school in the World", e_birthday=bday)
self.assertEqual(e.display, u"John, 9 ans, scolarisé à Best school in the World")
def test_decode_users_ok(self):
data = "---".join([self.famille.encoded, self.presta.encoded])
expected = [self.famille, self.presta]
self.assertEquals(UserInfo.decode_users(data), expected)
def test_decode_users_notok(self):
data = base64.urlsafe_b64encode(json.dumps({"type": "Prestataire", "pk": 118926}))
self.assertRaises(ValueError, UserInfo.decode_users, data)
data = "eaziouehazoenuazehazpoieybazioueh"
self.assertRaises(ValueError, UserInfo.decode_users, data)
@patch("django.core.mail.EmailMessage.send")
def test_check_plan_expiration_basic(self, send):
self.famille.plan = "basic"
self.famille.save()
check_plan_expiration(None, None, self.famille.user)
f = models.Famille.objects.get(pk=self.famille.pk)
self.assertEquals(f.plan, "basic")
self.assertFalse(send.called)
@patch("django.core.mail.EmailMessage.send")
def test_check_plan_expiration_no_exp(self, send):
self.famille.plan = "premium"
self.famille.plan_expires_at = None
self.famille.save()
check_plan_expiration(None, None, self.famille.user)
f = models.Famille.objects.get(pk=self.famille.pk)
self.assertEquals(f.plan, "basic")
self.assertIsNone(f.plan_expires_at)
self.assertTrue(send.called)
@patch("django.core.mail.EmailMessage.send")
def test_check_plan_expiration_expired(self, send):
self.famille.plan = "premium"
self.famille.plan_expires_at = datetime(2000, 1, 1)
self.famille.save()
check_plan_expiration(None, None, self.famille.user)
f = models.Famille.objects.get(pk=self.famille.pk)
self.assertEquals(f.plan, "basic")
self.assertIsNone(f.plan_expires_at)
self.assertTrue(send.called)
@patch("django.core.mail.EmailMessage.send")
def test_check_plan_expiration_not_expired(self, send):
self.famille.plan = "premium"
self.famille.plan_expires_at = datetime(2500, 1, 1)
self.famille.save()
check_plan_expiration(None, None, self.famille.user)
f = models.Famille.objects.get(pk=self.famille.pk)
self.assertEquals(f.plan, "premium")
self.assertEquals(f.plan_expires_at.replace(tzinfo=None), datetime(2500, 1, 1))
self.assertFalse(send.called)
def test_visibility_score_empty(self):
p = models.Prestataire()
self.assertEquals(p.visibility_score, 0)
def test_visibility_score_not_empty(self):
p = models.Prestataire(type="baby", name="To", first_name="Tou", street="Rue des Moines", city="Paris")
self.assertEquals(p.visibility_score, 0.625)
def test_visibility_score_is_enough_zero(self):
p = models.Prestataire()
p.MIN_VISIBILITY_SCORE = 0.9
self.assertFalse(p.visibility_score_is_enough)
def test_visibility_score_is_not_enough(self):
p = models.Prestataire(type="baby", name="To", first_name="Tou", street="Rue des Moines", city="Paris")
p.MIN_VISIBILITY_SCORE = 0.9
self.assertFalse(p.visibility_score_is_enough)
def test_visibility_score_is_enough(self):
p = models.Prestataire(
type="baby", name="To", first_name="Tou", street="Rue des Moines", city="Paris",
postal_code="75017", birthday=datetime.now(), profile_pic="/dumbfile.txt"
)
p.MIN_VISIBILITY_SCORE = 0.9
self.assertTrue(p.visibility_score_is_enough)