def test_partisans(self):
u1 = Utilisateur(nom='patate', courriel='*****@*****.**')
u2 = Utilisateur(nom='tomate', courriel='*****@*****.**')
db.session.add(u1)
db.session.add(u2)
db.session.commit()
self.assertEqual(u1.les_partisans.all(), [])
self.assertEqual(u1.partisans.all(), [])
u1.devenir_partisan(u2)
db.session.commit()
self.assertTrue(u1.est_partisan(u2))
self.assertEqual(u1.les_partisans.count(), 1)
self.assertTrue(u1.est_partisan(u2))
self.assertEqual(u1.les_partisans.count(), 1)
self.assertEqual(u1.les_partisans.first().nom, 'tomate')
self.assertEqual(u2.partisans.count(), 1)
self.assertEqual(u2.partisans.first().nom, 'patate')
u1.ne_plus_etre_partisan(u2)
db.session.commit()
self.assertFalse(u1.est_partisan(u2))
self.assertEqual(u1.les_partisans.count(), 0)
self.assertEqual(u2.partisans.count(), 0)
def enregistrer():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
formulaire = FormulaireEnregistrement()
if formulaire.validate_on_submit():
utilisateur = Utilisateur(nom=formulaire.nom.data,
courriel=formulaire.courriel.data)
utilisateur.enregistrer_mot_de_passe(formulaire.mot_de_passe.data)
fnt = ImageFont.load_default()
image = Image.new('RGB', (128, 128), color='black')
for i in range(20):
x = random.randint(0, 128)
y = random.randint(0, 128)
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
h = random.randint(10, 20)
fnt = ImageFont.load_default()
d = ImageDraw.Draw(image)
d.text((x, y), utilisateur.nom, font=fnt, fill=(r, g, g))
tampon = BytesIO()
db.session.add(utilisateur)
db.session.commit()
flash('Félicitations, vous êtes maintenant enregistré!')
return redirect(url_for('etablir_session'))
return render_template('enregistrement.html',
title='Enregistrer',
formulaire=formulaire)
def test_subbedPubs(self):
usertb = []
for i in range(4):
usertb.append(
Utilisateur(nom='u' + str(i),
email='u' + str(i) + '@info.cgg'))
db.session.add_all(usertb)
now = datetime.utcnow()
pubstb = []
for u in usertb:
pubstb.append(
Publication(body='Publication de ' + u.nom,
auteur=u,
creation=now + timedelta(seconds=1)))
db.session.add_all(pubstb)
usertb[0].userSub(usertb[1])
usertb[0].userSub(usertb[3])
usertb[1].userSub(usertb[2])
usertb[2].userSub(usertb[3])
db.session.commit()
substb = []
for u in usertb:
substb.append(u.getPartisansPubs().all())
self.assertEqual(substb[0], [pubstb[0], pubstb[1], pubstb[3]])
self.assertEqual(substb[1], [pubstb[1], pubstb[2]])
self.assertEqual(substb[2], [pubstb[2], pubstb[3]])
self.assertEqual(substb[3], [pubstb[3]])
def get_utilisateurs():
page = request.args.get('page', 1, type=int)
par_page = min(request.args.get('par_page', 10, type=int), 100)
data = Utilisateur.to_collection_dict(Utilisateur.query, page, par_page,
'api.get_utilisateurs',
"utilisateurs")
return jsonify(data)
def register():
print(request.method)
if current_user.is_authenticated:
return redirect(url_for('main.index'))
print('not logged')
formulaire = FormRegister()
if formulaire.validate_on_submit():
print('validated')
flash('Validation complete!')
Utilisateur.create_user(formulaire.nom.data, formulaire.email.data,
formulaire.password.data)
flash('Félicitations, vous êtes maintenant enregistré!')
return redirect(url_for('login'))
#flash('Inscription en cours...')
if request.method == "GET":
return render_template('register.html',
title="Enregistrement",
form=formulaire)
def suivre(nom):
user = Utilisateur.load_username(nom)
if user is None:
return redirect(url_for('index'))
if user != current_user:
if not current_user.isPartisan(user):
current_user.userSub(user)
flash('Vous suivez maintenant ' + nom)
else:
current_user.userUnsub(user)
flash('Vous ne suivez plus ' + nom)
db.session.commit()
socketio.emit('actualiser', {'bison': 'vide'}, namespace='/chat')
return redirect(url_for('profile', nom=nom))
def test_Subs(self):
u1 = Utilisateur(nom='patate', email='*****@*****.**')
u2 = Utilisateur(nom='tomate', email='*****@*****.**')
db.session.add_all([u1, u2])
db.session.commit()
self.assertEqual(u1.partisans.all(), [])
self.assertEqual(u1.tbpartisans.all(), [])
u1.userSub(u2)
db.session.commit()
self.assertTrue(u1.isPartisan(u2))
self.assertEqual(u1.partisans.count(), 1)
self.assertEqual(u1.partisans.first().nom, 'tomate')
self.assertEqual(u2.tbpartisans.count(), 1)
self.assertEqual(u2.tbpartisans.first().nom, 'patate')
u1.userUnsub(u2)
db.session.commit()
self.assertFalse(u1.isPartisan(u2))
self.assertEqual(u1.partisans.count(), 0)
self.assertEqual(u2.tbpartisans.count(), 0)
def profile(nom):
user = Utilisateur.load_username(nom)
return render_template('profile.html',
user=user,
pubs=user.publications.all())
def verify_token(token):
return Utilisateur.verifier_jeton(token) if token else None
def validate_nom(self, nom):
if nom.data != self.nom_original and Utilisateur.load_username(nom=self.nom.data).first() is not None:
raise ValidationError('Ce nom existe déjà dans la base de données')
def validate_nom(self, nom):
user = Utilisateur.load_username(nom=nom.data)
if user is not None:
raise ValidationError('Ce nom existe déjà...')
def get_utilisateurs():
page = request.args.get('page', 1, type=int)
perp = min(request.args.get('par_page', 10, type=int), 100)
return jsonify(
Utilisateur.to_collection_dict(Utilisateur.query, page, perp,
'api.get_publications'))
def test_pwdHashing(self):
u = Utilisateur(nom='patate')
pwd = 'Password1'
u.enregisrter_mot_de_passe(pwd)
self.assertFalse(u.valider_mot_de_passe(pwd[::-1]))
self.assertTrue(u.valider_mot_de_passe(pwd))
def test_publications_suivies(self):
# create four users
u1 = Utilisateur(nom='patate', courriel='*****@*****.**')
u2 = Utilisateur(nom='tomate', courriel='*****@*****.**')
u3 = Utilisateur(nom='salade', courriel='*****@*****.**')
u4 = Utilisateur(nom='radis', courriel='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
# create four posts
maintenant = datetime.utcnow()
p1 = Publication(corps="publication from patate",
auteur=u1,
horodatage=maintenant + timedelta(seconds=1))
p2 = Publication(corps="publication from tomate",
auteur=u2,
horodatage=maintenant + timedelta(seconds=4))
p3 = Publication(corps="publication from salade",
auteur=u3,
horodatage=maintenant + timedelta(seconds=3))
p4 = Publication(corps="publication from radis",
auteur=u4,
horodatage=maintenant + timedelta(seconds=2))
db.session.add_all([p1, p2, p3, p4])
db.session.commit()
# setup the followers
u1.devenir_partisan(u2) # john follows susan
u1.devenir_partisan(u4) # john follows david
u2.devenir_partisan(u3) # susan follows mary
u3.devenir_partisan(u4) # mary follows david
db.session.commit()
# check the followed posts of each user
f1 = u1.liste_publications_dont_je_suis_partisan().all()
f2 = u2.liste_publications_dont_je_suis_partisan().all()
f3 = u3.liste_publications_dont_je_suis_partisan().all()
f4 = u4.liste_publications_dont_je_suis_partisan().all()
self.assertEqual(f1, [p2, p4, p1])
self.assertEqual(f2, [p2, p3])
self.assertEqual(f3, [p3, p4])
self.assertEqual(f4, [p4])
def test_mot_de_passe_hashing(self):
u = Utilisateur(nom='patate')
u.enregistrer_mot_de_passe('Password1')
self.assertFalse(u.valider_mot_de_passe('Mot de passe invalide'))
self.assertTrue(u.valider_mot_de_passe('Password1'))
def verify_password(un, pwd):
user = Utilisateur.load_username(un)
if user and user.valider_mot_de_passe(pwd):
return user
