def test_user_new(self):
"""Does basic model work?"""
u = User(
email="*****@*****.**",
username="******",
password="******"
)
db.session.add(u)
db.session.commit()
# User should have no messages & no followers
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
# Validate the repr function
self.assertEqual(f"<User #{u.id}: testuser, [email protected]>",u.__repr__())
# Update profile
u.update_profile("*****@*****.**", "http://pic1.com", "http://pic2.com", "bio")
self.assertEqual(f"<User #{u.id}: testuser, [email protected]>",u.__repr__())
self.assertEqual("http://pic1.com", u.image_url)
self.assertEqual("http://pic2.com", u.header_image_url)
self.assertEqual("bio", u.bio)
def test_repr(self):
"""Testing the repr method."""
self.assertEqual(
User.__repr__(
User(id=1, username='******', email='*****@*****.**')),
"<User #1: testuser, [email protected]>")
def test_repr(self):
username = '******'
email = '*****@*****.**'
user = User(username=username, email=email, id=1001)
user_id = user.id
expected_repr = f'<User #{user_id}: {username}, {email}>'
actual_repr = user.__repr__()
self.assertEqual(actual_repr, expected_repr)
def test_user_repr(self):
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
self.assertEqual(u.__repr__(),
f'<User #{u.id}: {u.username}, {u.email}>')
def test_repr_model(self):
"""Testing repr return"""
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
self.assertIn("*****@*****.**", u.__repr__())
def post(self):
r_json = request.get_json()
email = r_json['email']
password = r_json['password'].encode('utf-8')
user = User.query.filter_by(email=email).first()
if user is not None:
return '{} is already exists!'.format(email)
new_user = User(email, password)
db.session.add(new_user)
db.session.commit()
return 'create {}'.format(new_user.__repr__())
def test_user_repr(self):
"""Does the repr method work as expected?"""
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
self.assertEqual(u.__repr__(),
f"<User #{u.id}: {u.username}, {u.email}>")
def test_user_repr_method(self):
"""Does the __repr__ method work?"""
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
self.assertEqual(u.__repr__(),
f"<User #{u.id}: {u.username}, {u.email}>")
def test_repr(self):
"""Does repr work?"""
u = User(
# id=1,
email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
self.assertEqual(u.__repr__(),
f"<User #{u.id}: {u.username}, {u.email}>")
def test_user_model(self):
"""Does basic model work?"""
u = User(email="*****@*****.**", username="******", password="******")
db.session.add(u)
db.session.commit()
# test that __repr__ method on user works as expected
u_repr = u.__repr__()
self.assertIn(f"User #{u.id}: {u.username}, {u.email}", u_repr)
# User should have no messages & no followers
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
def test_user_model(self):
"""Does basic model work?"""
u = User(id=44,
email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
# User should have no messages & no followers
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
self.assertEqual(u.__repr__(),
f'<User #{u.id}: {u.username}, {u.email}>')
def test_user_model(self):
"""Does basic model work?"""
u = User(id=1,
email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
# User should have no messages & no followers
self.assertEqual(u.messages.count(), 0)
self.assertEqual(u.followers.count(), 0)
self.assertEqual(u.email, '*****@*****.**')
self.assertEqual(u.__repr__(), '<User #1: testuser, [email protected]>')
def test_user_model(self):
"""Does basic model work?"""
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
# User should have no messages & no followers
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
# check repr method
self.assertEqual(u.__repr__(),
f"<User #{u.id}: testuser, [email protected]>")
def user_add():
idvpss = request.form['idvpss'].strip()
username = request.form['username'].strip()
password = request.form['password']
mail_pass = request.form['mail_pass']
u = User(idvpss, username, password, mail_pass)
db_session.add(u)
try:db_session.commit()
except Exception as e:
db_session.rollback()
logging.error("Application did not create "+u.__repr__()+
" becouse " + e.message)
raise Exception('DB commit is not OK')
return "User created"
def user_add():
idvpss = request.form['idvpss'].strip()
username = request.form['username'].strip()
password = request.form['password']
mail_pass = request.form['mail_pass']
u = User(idvpss, username, password, mail_pass)
db_session.add(u)
try:
db_session.commit()
except Exception as e:
db_session.rollback()
logging.error("Application did not create " + u.__repr__() +
" becouse " + e.message)
raise Exception('DB commit is not OK')
return "User created"
def test_repr(self):
u = User(
id=1,
email="*****@*****.**",
username="******",
password="******"
)
db.session.add(u)
db.session.commit()
u = User.query.get(1)
repr_return = u.__repr__()
self.assertEqual(repr_return, '<User #1: testuser, [email protected]>')
self.assertNotEqual(repr_return, '<Userasdfsdfdsfdsm>')
def test_user_model(self):
"""Does basic model work?"""
u = User(
email="*****@*****.**",
username="******",
password="******"
)
db.session.add(u)
db.session.commit()
# User should have no messages, no followers, no followings, & no likes
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
self.assertEqual(len(u.following), 0)
self.assertEqual(len(u.likes), 0)
# User should have inputted fields
self.assertEqual(u.email, "*****@*****.**")
self.assertEqual(u.username, "testuser")
self.assertEqual(u.password, "HASHED_PASSWORD")
# __repr__() should return description of User
self.assertEqual(u.__repr__(), \
f"<User #{u.id}: testuser, [email protected]>")
# User should have default attributes for images URLs
self.assertEqual(u.image_url, "/static/images/default-pic.png")
self.assertEqual(u.header_image_url, "/static/images/warbler-hero.jpg")
# test adding optional attributes
u.image_url = "http://test-url.png"
u.header_image_url = "http://test-header-url.png"
u.bio = "This is a test bio for testuser"
u.location = "Test City, TS"
db.session.add(u)
db.session.commit()
self.assertEqual(u.image_url, "http://test-url.png")
self.assertEqual(u.header_image_url, "http://test-header-url.png")
self.assertEqual(u.bio, "This is a test bio for testuser")
self.assertEqual(u.location, "Test City, TS")
# verify can create user with initial image_url
u_with_image = User(
email="*****@*****.**",
username="******",
password="******",
image_url="http://test-url.png"
)
db.session.add(u_with_image)
db.session.commit()
# User should have inputted fields
self.assertEqual(u_with_image.email, "*****@*****.**")
self.assertEqual(u_with_image.username, "testuserwithimage")
self.assertEqual(u_with_image.password, "HASHED_PASSWORD")
self.assertEqual(u_with_image.image_url, "http://test-url.png")
class UserModelTestCase(TestCase):
"""Test user model."""
def setUp(self):
"""Create test client, add sample data."""
User.query.delete()
Message.query.delete()
Follows.query.delete()
self.u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(self.u)
db.session.commit()
def tearDown(self):
"""Remove any fouled transactions"""
db.session.rollback()
def test_user_model(self):
"""Does basic model work?"""
self.assertEqual(self.u.email, "*****@*****.**")
self.assertEqual(self.u.username, "testuser")
self.assertEqual(self.u.password, "HASHED_PASSWORD")
# User should have no messages & no followers
self.assertEqual(len(self.u.messages), 0)
self.assertEqual(len(self.u.followers), 0)
def test_repr_method(self):
"""Does repr method work as intended?"""
self.assertEqual(self.u.__repr__(),
f"<User #{self.u.id}: testuser, [email protected]>")
def test_is_following_true(self):
"""Does is_following method work as intended for a true result?"""
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u2)
db.session.commit()
self.u.following.append(u2)
db.session.add(self.u)
db.session.commit()
self.assertEqual(self.u.is_following(u2), True)
def test_is_following_false(self):
"""Does is_following method work as intended for a false result?"""
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u2)
db.session.commit()
self.assertEqual(self.u.is_following(u2), False)
def test_is_followed_by_true(self):
"""Does is_followed_by method work as intended for a true result?"""
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u2)
db.session.commit()
self.u.followers.append(u2)
db.session.add(self.u)
db.session.commit()
self.assertEqual(self.u.is_followed_by(u2), True)
def test_is_followed_by_false(self):
"""Does is_followed_by method work as intended for a false result?"""
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u2)
db.session.commit()
self.assertEqual(self.u.is_followed_by(u2), False)
def test_signup_successful(self):
"""Does signup class method work as intended given all the correct info is provided?"""
u2 = User.signup(
"testuser2", "*****@*****.**", "HASHED_PASSWORD2",
"https://static.toiimg.com/photo/msid-75390440/75390440.jpg?344550"
)
db.session.commit()
self.assertEqual(u2.__repr__(),
f"<User #{u2.id}: testuser2, [email protected]>")
def test_signup_fail(self):
"""Does signup class method work as intended if invalid credentials are provided?"""
try:
u2 = User.signup(
"testuser", "*****@*****.**", "HASHED_PASSWORD2",
"https://static.toiimg.com/photo/msid-75390440/75390440.jpg?344550"
)
db.session.commit()
except IntegrityError:
self.assertRaises(IntegrityError)
def test_authenticate(self):
"""Does authenticate method work as intended?"""
u2 = User.signup(
"testuser2", "*****@*****.**", "HASHED_PASSWORD2",
"https://static.toiimg.com/photo/msid-75390440/75390440.jpg?344550"
)
db.session.add(u2)
db.session.commit()
test = User.authenticate("testuser2", "HASHED_PASSWORD2")
self.assertEqual(test, u2)
try:
test2 = User.authenticate("testuser", "HASHED_PASSWORD2")
test3 = User.authenticate("testuser2", "HASHED_PASSWORD")
except ValueError:
self.assertRaises(ValueError)
def test_users_repr(self):
""" Does the User __repr__ work? """
self.assertEqual(
User.__repr__(self.u1),
f"<User #{self.u1.id}: {self.u1.username}, {self.u1.email}>")
def test_repr(self):
"""Test whether a user is following another."""
with app.test_client() as client:
self.assertEqual(User.__repr__(self.tester1), "<User #10000000: test, [email protected]>")
self.assertEqual(User.__repr__(self.tester2), "<User #10000001: tester2, [email protected]>")
def test_user_repr_method() -> None:
"""Test that user info is displayed."""
user = User(username="******", password="******")
assert user.__repr__() == r"<User: '******'>"
def test_user_model(self):
"""Does basic model work?"""
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
u_id = u.id
# User should have no messages & no followers
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
self.assertEqual(len(u.following), 0)
self.assertEqual(len(u.likes), 0)
self.assertIn(u.__repr__(), f"<User #{u_id}: testuser, [email protected]>")
# test valid sign up
signed_user = User.signup("test", "*****@*****.**", "password", None)
db.session.commit()
self.assertTrue(signed_user, 0)
test_user = User.query.get(signed_user.id)
self.assertEqual(test_user.username, "test")
self.assertEqual(test_user.email, "*****@*****.**")
self.assertNotEqual(test_user.password, "password")
self.assertEqual(test_user.image_url, "/static/images/default-pic.png")
# test invalid username sign up (referencing the solution)
invalid_1 = User.signup(None, "*****@*****.**", "password", None)
uid = 123456789
invalid_1.id = uid
with self.assertRaises(exc.IntegrityError) as context:
db.session.commit()
db.session.rollback()
# test invalid email sign up (referencing the solution)
invalid_2 = User.signup("testtest", None, "password", None)
uid = 123789
invalid_2.id = uid
with self.assertRaises(exc.IntegrityError) as context:
db.session.commit()
db.session.rollback()
# with self.assertRaises(exc.IntegrityError) as context:
# User.signup("test2", None, "password", None)
# test invalid password sign up (referencing the solution)
with self.assertRaises(ValueError) as context:
User.signup("test3", "*****@*****.**", "", None)
with self.assertRaises(ValueError) as context:
User.signup("test4", "*****@*****.**", None, None)
# test valid authentication
self.assertEqual(User.authenticate("test", "password"), signed_user)
# test invalid authentication
self.assertEqual(User.authenticate("test", "sss"), False)
self.assertEqual(User.authenticate("XXX", "password"), False)
def test_repr(self):
self.assertEqual(User.__repr__(self.u2),
"<User #2222: test2, [email protected]>")
def test_user_model(self):
"""Does basic model work?"""
u = User(
email="*****@*****.**",
username="******",
password="******"
)
db.session.add(u)
db.session.commit()
# User should have no messages & no followers & no following & no likes
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
self.assertEqual(len(u.following), 0)
self.assertEqual(len(u.likes), 0)
# Make sure the intended attributes exist
self.assertEqual(u.email, "*****@*****.**")
self.assertEqual(u.username, "testuser")
self.assertEqual(u.image_url, "/static/images/default-pic.png")
self.assertEqual(u.header_image_url, "/static/images/warbler-hero.jpg")
self.assertEqual(bool(u.bio), False)
self.assertEqual(bool(u.location), False)
self.assertEqual(u.password, "HASHED_PASSWORD")
#Test the instance methods
#Test the repr
self.assertEqual(u.__repr__(), f"<User #{u.id}: testuser, [email protected]>")
#Test the class methods
#Test signup
new_user = User.signup('second_user', '*****@*****.**', 'achooachoo', image_url = None)
db.session.commit()
self.assertEqual(new_user.username, 'second_user')
#Test authenticate
auth = User.authenticate('second_user', 'achooachoo')
self.assertEqual((auth), new_user)
auth = User.authenticate('second_user', 'wrongpassword')
self.assertEqual((auth), False)
auth = User.authenticate('notauser', 'achooachoo')
self.assertEqual((auth), False)
#Test is_followed_by
result = new_user.is_followed_by(u)
self.assertEqual(False, result)
follow = Follows(user_being_followed_id=new_user.id, user_following_id= u.id)
db.session.add(follow)
db.session.commit()
self.assertEqual(new_user.is_followed_by(u), True)
#Test is_following
self.assertEqual(new_user.is_following(u), False)
self.assertEqual(u.is_following(new_user), True)
class UserModelTestCase(TestCase):
"""Test views for messages."""
def setUp(self):
"""Create test client, add sample data."""
User.query.delete()
Follows.query.delete()
self.client = app.test_client()
self.user1 = User(email="*****@*****.**",
username="******",
password="******")
self.user2 = User(email="*****@*****.**",
username="******",
password="******")
def tearDown(self):
db.session.rollback()
def test_user_model(self):
"""Does basic model work?"""
u = self.user1
db.session.add(u)
db.session.commit()
# User should have no messages & no followers
self.assertEqual(len(u.messages), 0)
self.assertEqual(len(u.followers), 0)
def test_repr(self):
db.session.add(self.user1)
db.session.commit()
self.assertEqual(
self.user1.__repr__(), f"<User #{self.user1.id}: "
f"{self.user1.username}, {self.user1.email}>")
def test_is_followed_by(self):
db.session.add_all([self.user1, self.user2])
db.session.commit()
f1 = Follows(user_being_followed_id=self.user1.id,
user_following_id=self.user2.id)
db.session.add(f1)
db.session.commit()
self.assertFalse(self.user2.is_followed_by(self.user1))
self.assertTrue(self.user1.is_followed_by(self.user2))
def test_is_following(self):
db.session.add_all([self.user1, self.user2])
db.session.commit()
f1 = Follows(user_being_followed_id=self.user1.id,
user_following_id=self.user2.id)
db.session.add(f1)
db.session.commit()
self.assertFalse(self.user1.is_following(self.user2))
self.assertTrue(self.user2.is_following(self.user1))
def test_sign_up(self):
user = User.signup(self.user1.username, self.user1.email,
self.user1.password, None)
db.session.commit()
self.assertEqual(user, User.query.get(user.id))
def test_sign_up_null_username(self):
with self.assertRaises(IntegrityError):
user = User.signup(None, self.user1.email, self.user1.password,
None)
db.session.commit()
def test_sign_up_null_email(self):
with self.assertRaises(IntegrityError):
user = User.signup(self.user1.username, None, self.user1.password,
None)
db.session.commit()
def test_sign_up_null_password(self):
with self.assertRaises(ValueError):
user = User.signup(self.user1.username, self.user1.email, None,
None)
db.session.commit()
def test_sign_up_unique_username(self):
user = User.signup(self.user1.username, self.user1.email,
self.user1.password, None)
db.session.commit()
with self.assertRaises(IntegrityError):
user = User.signup(self.user1.username, self.user2.email,
self.user2.password, None)
db.session.commit()
def test_sign_up_unique_email(self):
user = User.signup(self.user1.username, self.user1.email,
self.user1.password, None)
db.session.commit()
with self.assertRaises(IntegrityError):
user = User.signup(self.user2.username, self.user1.email,
self.user2.password, None)
db.session.commit()
def test_sign_up_default_img_urls(self):
user = User.signup(self.user1.username, self.user1.email,
self.user1.password, None)
db.session.commit()
self.assertEqual(user.image_url, User.image_url.default.arg)
self.assertEqual(user.header_image_url,
User.header_image_url.default.arg)
def test_authenticate(self):
unhashed_password = self.user1.password
user = User.signup(self.user1.username, self.user1.email,
self.user1.password, None)
db.session.commit()
self.assertEqual(
user, User.authenticate(self.user1.username, unhashed_password))
def test_authenticate_invalid_username(self):
unhashed_password = self.user1.password
user = User.signup(self.user1.username, self.user1.email,
self.user1.password, None)
db.session.commit()
self.assertFalse(User.authenticate("invalid_user", unhashed_password))
def test_authenticate_invalid_password(self):
user = User.signup(self.user1.username, self.user1.email,
self.user1.password, None)
db.session.commit()
self.assertFalse(
User.authenticate(self.user1.username, "some_password"))
