def follow(request):
"""
This method is used to follow a particular user.
'request.user' represents username of logged in user.
'request.body' contains username of person in JSON format
who is to be followed.
"""
to_follow = request.data.get("follow")
if to_follow is None:
return Response({'error':'Please provide username to be followed with key follow'},
status=HTTP_400_BAD_REQUEST)
if str(to_follow) == str(request.user):
return Response({'Error':'You cannot follow/unfollow yourself'},
status=HTTP_400_BAD_REQUEST)
l = User.objects.filter(username = to_follow).first()
if l is None:
return Response({'Error':'The user you wish to follow does not exist.'},
status=HTTP_400_BAD_REQUEST)
obj = Follows.objects.filter(follower = request.user, following = str(l.username))
if len(obj) == 0:
user = Follows(follower = request.user, following = str(l.username))
user.save()
note = 'Follow request Successfull. ' + str(request.user) + ' started following ' + str(l.username)
return Response({'Note': note}, status=HTTP_200_OK)
else:
return Response({'Error': 'You are already following this user'}, status=HTTP_400_BAD_REQUEST)
def test_followers(self):
"""Tests that a user's followers page works correctly."""
follow1 = Follows(
user_being_followed_id = self.testuser.id,
user_following_id = self.testuser2.id
)
follow2 = Follows(
user_being_followed_id = self.testuser3.id,
user_following_id = self.testuser.id
)
db.session.add_all((follow1, follow2))
db.session.commit()
with self.client as c:
with c.session_transaction() as session:
session[CURR_USER_KEY] = self.testuser.id
response = c.get(f"/users/{self.testuser.id}/followers")
data = str(response.data)
self.assertEqual(response.status_code, 200)
self.assertIn("@bob", data)
self.assertNotIn("@carl", data)
self.assertNotIn("@alvin", data)
def setup_followers(self):
f1 = Follows(user_being_followed_id=self.uid1, user_following_id=self.test_id)
f2 = Follows(user_being_followed_id=self.uid2, user_following_id=self.test_id)
f3 = Follows(user_being_followed_id=self.test_id, user_following_id=self.uid1)
sess.add_all([f1, f2, f3])
sess.commit()
def setup_followers(self):
f1 = Follows(user_being_followed_id=self.testuser.id, user_following_id=self.u1.id)
f2 = Follows(user_being_followed_id=self.testuser.id, user_following_id=self.u2.id)
f3 = Follows(user_being_followed_id=self.u4.id, user_following_id=self.testuser.id)
db.session.add_all([f1,f2,f3])
db.session.commit()
def test_show_following(self):
with self.client as client:
# No user is logged in; this should redirect to '/'
resp = client.get('/users/100/following')
self.assertEqual(resp.status_code, 302)
# Ok, now let's log in and check that show_following works:
data = {'username': '******', 'password': '******'}
resp = client.post('/login', data=data, follow_redirects=True)
html = resp.get_data(as_text=True)
# Quickly check to make sure login succeeded before testing show_following:
self.assertEqual(resp.status_code, 200)
self.assertIn('Hello, testuser1!', html)
self.assertEqual(session['curr_user'], 100)
# Add some follows between out test users:
f1 = Follows(user_being_followed_id=self.u2_id,
user_following_id=self.u1_id)
f2 = Follows(user_being_followed_id=self.u3_id,
user_following_id=self.u1_id)
db.session.add_all([f1, f2])
db.session.commit()
resp = client.get('/users/100/following')
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn('testuser2', html)
def setup_followers(self):
f1 = Follows(following_id=self.u1_id, followed_by_id=self.testuser_id)
f2 = Follows(following_id=self.u2_id, followed_by_id=self.testuser_id)
f3 = Follows(following_id=self.testuser_id, followed_by_id=self.u1_id)
db.session.add_all([f1,f2,f3])
db.session.commit()
def test_user_model(self):
"""Does basic model work?"""
# create 1st test user
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)
# check __repr__ operation
self.assertEqual(repr(u), f"<User #{u.id}: testuser, [email protected]>")
# create 2nd test user
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u2)
db.session.commit()
# Check not follow
# u2 has to be user object
self.assertEqual(u.is_following(u2), False)
self.assertEqual(u.is_followed_by(u2), False)
# create 2 entries in follows table pointed to each other
follow = Follows(user_being_followed_id=u.id, user_following_id=u2.id)
db.session.add(follow)
db.session.commit()
follow = Follows(user_being_followed_id=u2.id, user_following_id=u.id)
db.session.add(follow)
db.session.commit()
# check follows
# parameter u2 has to be a user object
self.assertEqual(u.is_followed_by(u2), True)
self.assertEqual(u2.is_followed_by(u), True)
# create signed in user
u3 = User.signup("testuser3", "*****@*****.**", "HASHED_PASSWORD", "")
db.session.commit()
# check authenticate of signed in user
good_user = User.authenticate(u3.username, "HASHED_PASSWORD")
self.assertTrue(good_user)
# check authenticate of incorrect user name
good_user = User.authenticate("bad-user-name", "HASHED_PASSWORD")
self.assertFalse(good_user)
# check authenticate of incorrect password
good_user = User.authenticate(u3.username, "bad-password")
self.assertFalse(good_user)
def setup_followers(self):
"""Set up followers for testing"""
f1 = Follows(user_being_followed_id=self.u1_id, user_following_id=self.testuser_id)
f2 = Follows(user_being_followed_id=self.u2_id, user_following_id=self.testuser_id)
f3 = Follows(user_being_followed_id=self.testuser_id, user_following_id=self.u1_id)
db.session.add_all([f1,f2,f3])
db.session.commit()
def setup_followers(self):
"""Set up follower & followings"""
follows = Follows(user_being_followed_id=self.new_user_id,
user_following_id=self.user_two_id)
follows_again = Follows(user_being_followed=self.user_two,
user_following_id=self.new_user_id)
db.session.add([follows, follows_again])
db.session.commit
def setup_followers(self):
"""This is a helper method used to set up followers
to be used in the next few test methods.
"""
f1 = Follows(user_being_followed_id=self.u1id, user_following_id=self.testuser_id)
f2 = Follows(user_being_followed_id=self.u2id, user_following_id=self.testuser_id)
f3 = Follows(user_being_followed_id=self.testuser_id, user_following_id=self.u1id)
db.session.add_all([f1, f2, f3])
db.session.commit()
def setup_followers(self):
'''Set up users follow other users.'''
f1 = Follows(user_being_followed_id=self.user1_id,
user_following_id=self.user1_id)
f2 = Follows(user_being_followed_id=self.u2_id,
user_following_id=self.user1_id)
f3 = Follows(user_being_followed_id=self.user1_id,
user_following_id=self.user_id)
db.session.add_all([f1, f2, f3])
db.session.commit()
def setup_followers(self):
"""Helper function for creating followers."""
f1 = Follows(user_being_followed_id=self.u1_id,
user_following_id=self.testuser_id)
f2 = Follows(user_being_followed_id=self.u2_id,
user_following_id=self.testuser_id)
f3 = Follows(user_being_followed_id=self.testuser_id,
user_following_id=self.u1_id)
db.session.add_all([f1, f2, f3])
db.session.commit()
def test_unlike_message(self):
"""Does unliking a message move star and show thumbs up?"""
f = Follows(user_being_followed_id=self.u1.id,
user_following_id=self.u2.id)
db.session.add(f)
db.session.commit()
m = Message(text="I am being followed by somebody", user_id=self.u1.id)
m.id = 2121
db.session.add(m)
db.session.commit()
l = Likes(user_id=self.u2.id, message_id=2121)
db.session.add(l)
db.session.commit()
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.u2.id
resp = c.post('/users/unlike/2121', follow_redirects=True)
html = resp.get_data(as_text=True)
l_cnt = Likes.query.filter_by(user_id=self.u2.id).count()
self.assertEqual(resp.status_code, 200)
self.assertEqual(l_cnt, 0)
self.assertIn('fa fa-thumbs-up', html)
self.assertNotIn('fa fa-star', html)
def test_follows_model(self):
"""test the Follows model"""
u1 = User.signup("test1", "*****@*****.**", "password", None)
u2 = User.signup("test2", "*****@*****.**", "password", None)
db.session.commit()
u1_id = u1.id
u2_id = u2.id
follow1 = Follows(user_being_followed_id=u1_id,
user_following_id=u2_id)
db.session.add(follow1)
db.session.commit()
self.assertEqual(len(u1.followers), 1)
self.assertEqual(u1.followers[0], u2)
self.assertEqual(len(u1.following), 0)
self.assertEqual(len(u2.following), 1)
self.assertEqual(u2.following[0], u1)
self.assertEqual(len(u2.followers), 0)
# test function is_followed_by
self.assertEqual(u1.is_followed_by(u2), True)
self.assertEqual(u2.is_following(u1), True)
def setUp(self):
"""Create test client, add sample data."""
db.create_all()
u = User.signup(email="*****@*****.**",
username="******",
password="******",
image_url='')
u2 = User.signup(email="*****@*****.**",
username="******",
password="******",
image_url='')
db.session.add(u)
db.session.add(u2)
db.session.commit()
newFollow = Follows(user_being_followed_id=2, user_following_id=1)
db.session.add(newFollow)
db.session.commit()
self.client = app.test_client()
def follow(user_id):
if request.method=="POST":
follow=Follows(user_id,current_user.id)
db.session.add(follow)
db.session.commit()
user=Users.query.filter_by(id=user_id).first()
return jsonify(response=[{'message':'You are now following '+user.username}])
def test_delete_messages_likes(self):
"""test if message got deleted by the user and it deletes from likes table"""
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u2)
db.session.commit()
follow = Follows(user_being_followed_id=u.id, user_following_id=u2.id)
db.session.add(follow)
db.session.commit()
m = Message(text="warblewarble", user_id=u.id)
db.session.add(m)
db.session.commit()
l = Likes(user_that_liked=u2.id, message_liked=m.id)
db.session.add(l)
db.session.commit()
self.assertEqual(len(u2.likes), 1)
db.session.delete(m)
db.session.commit()
self.assertEqual(len(u2.likes), 0)
self.assertEqual(len(u.messages), 0)
def test_stop_following(self):
follow = Follows(user_being_followed_id=self.testuser2.id,
user_following_id=self.testuser1.id)
db.session.add(follow)
db.session.commit()
self.assertIsNotNone(
Follows.query.filter(
Follows.user_being_followed_id == self.testuser2.id,
Follows.user_following_id == self.testuser1.id).one())
with self.client as c:
# log in
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser1.id
resp = c.post(f"/users/stop-following/{self.testuser2.id}")
self.assertEqual(resp.status_code, 302)
self.assertEqual(
resp.location,
f"http://localhost/users/{self.testuser1.id}/following")
self.assertIsNone(
Follows.query.filter(
Follows.user_being_followed_id == self.testuser2.id,
Follows.user_following_id ==
self.testuser1.id).one_or_none())
def setUp(self):
"""Create test client, add sample data."""
db.session.rollback()
User.query.delete()
Follows.query.delete()
Message.query.delete()
self.client = app.test_client()
# insert a user in the db
# put that user on self.user = user
self.user5 = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url="")
self.user6 = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url="")
db.session.commit()
follow = Follows(
user_being_followed_id=self.user5.id,
user_following_id=self.user6.id
)
db.session.add(follow)
db.session.commit()
def test_user_follow(self):
""" Does the is_following and is_followed_by work?"""
u1 = User(email="*****@*****.**",
username="******",
password="******")
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add_all([u1, u2])
db.session.commit()
#u1 follows u2, u2 doesn't follow u1
follow = Follows(user_being_followed_id=u2.id, user_following_id=u1.id)
db.session.add(follow)
db.session.commit()
self.assertEqual(u1.is_following(u2), True)
self.assertEqual(u2.is_following(u1), False)
self.assertEqual(u2.is_followed_by(u1), True)
self.assertEqual(u1.is_followed_by(u2), False)
# delete u1 following u2
# print(type(u1.id), u1.id)
follow = Follows.query.get((u2.id, u1.id))
db.session.delete(follow)
db.session.commit()
self.assertEqual(u1.is_following(u2), False)
self.assertEqual(u2.is_following(u1), False)
self.assertEqual(u2.is_followed_by(u1), False)
self.assertEqual(u1.is_followed_by(u2), False)
def test_is_followed_by(self):
"""Testing is_followed_by method"""
user = User(email="*****@*****.**",
username="******",
password="******")
patrick = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(user)
db.session.add(patrick)
db.session.commit()
# patrick is following user
f = Follows(user_being_followed_id=user.id,
user_following_id=patrick.id)
db.session.add(f)
db.session.commit()
self.assertEqual(user.is_followed_by(patrick), True)
self.assertEqual(patrick.is_followed_by(user), False)
self.assertEqual(len(user.followers), 1)
def setUp(self):
"""Create test client, add sample data."""
self.client = app.test_client()
# seed_data()
u = User.signup(
email="*****@*****.**",
username="******",
password=PASSWORD,
image_url=None
)
u.id = 1
db.session.add(u)
db.session.commit()
u_two = User.signup(
email="*****@*****.**",
username="******",
password=PASSWORD,
image_url=None
)
u_two.id = 2
db.session.add(u_two)
db.session.commit()
test_follow = Follows(user_being_followed_id=u.id,
user_following_id=u_two.id)
db.session.add(test_follow)
db.session.commit()
def test_is_following(self):
"""Testing is_following method"""
user = User(email="*****@*****.**",
username="******",
password="******")
patrick = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(user)
db.session.add(patrick)
db.session.commit()
# Create relationships on follows
f = Follows(user_being_followed_id=user.id,
user_following_id=patrick.id)
db.session.add(f)
db.session.commit()
# Test if user is following method works
self.assertEqual(patrick.is_following(user), True)
self.assertEqual(len(patrick.following), 1)
# Test if user is not following method works
self.assertEqual(user.is_following(patrick), False)
def test_message_like_logged_in_already_liked(self):
"""A logged in user should be able to stop liking a message."""
user1 = User(username="******", password="******", email="*****@*****.**")
db.session.add(user1)
db.session.commit()
message = Message(text='Like me.', user_id=user1.id)
db.session.add(message)
db.session.commit()
follow = Follows(user_being_followed_id=user1.id, user_following_id=self.testuser.id)
db.session.add(follow)
db.session.commit()
like = Likes(user_id=self.testuser.id, message_id=message.id)
db.session.add(like)
db.session.commit()
message_id = message.id
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
resp = c.post(f'/users/add_like/{message_id}', follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertNotIn('btn-primary', html)
def test_is_following(self):
u1 = User(
email="*****@*****.**",
username="******",
password="******"
)
u2 = User(
email="*****@*****.**",
username="******",
password="******"
)
db.session.add(u1)
db.session.add(u2)
db.session.commit()
f = Follows(
user_being_followed_id = u2.id,
user_following_id = u1.id
)
db.session.add(f)
db.session.commit()
self.assertTrue(u1.is_following(u2))
self.assertFalse(u2.is_following(u1))
self.assertTrue(u2.is_followed_by(u1))
self.assertFalse(u1.is_followed_by(u2))
def test_user_follow(self):
"""Does following model work?"""
u1 = User(
email="*****@*****.**",
username="******",
password="******"
)
u2 = User(
email="*****@*****.**",
username="******",
password="******"
)
db.session.add(u1)
db.session.add(u2)
db.session.commit()
follow = Follows(user_following_id=u1.id, user_being_followed_id=u2.id)
db.session.add(follow)
db.session.commit()
#
self.assertEqual(len(Follows.query.all()), 1)
self.assertTrue(u2.is_followed_by(u1))
self.assertFalse(u1.is_followed_by(u2))
self.assertTrue(u1.is_following(u2))
self.assertFalse(u2.is_following(u1))
self.assertEqual(len(u2.followers), 1)
self.assertEqual(len(u1.followers), 0)
def setUp(self):
"""Create test client, add sample data."""
User.query.delete()
Message.query.delete()
Follows.query.delete()
# Test User 0
test_user0 = User(email='*****@*****.**',
username='******',
password='******')
db.session.add(test_user0)
db.session.commit()
self.test_user0 = test_user0
# Test User 1
test_user1 = User(email='*****@*****.**',
username='******',
password='******')
db.session.add(test_user1)
db.session.commit()
self.test_user1 = test_user1
# Test Follow (User 0 follows User 1)
user0_follows_user1 = Follows(
user_being_followed_id=self.test_user1.id,
user_following_id=self.test_user0.id)
db.session.add(user0_follows_user1)
db.session.commit()
self.user0_follows_user1 = user0_follows_user1
self.client = app.test_client()
def setUp(self):
"""Create test client, add sample data."""
db.drop_all()
db.create_all()
# add user data
user = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url=None)
user.id = 1000
self.user_id = user.id
user2 = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url=None)
user2.id = 2000
self.user2_id = user2.id
db.session.commit()
# add message data
message = Message(text="Test Message", user_id=self.user2_id)
message.id = 2000
self.message_id = message.id
db.session.add(message)
db.session.commit()
# add following data
follow = Follows(user_being_followed_id=self.user2_id,
user_following_id=self.user_id)
db.session.add(follow)
db.session.commit()
def setUp(self):
"""Create test client, add sample data."""
User.query.delete()
Message.query.delete()
Follows.query.delete()
self.client = app.test_client()
user1 = User(
email="*****@*****.**",
username="******",
password=bcrypt.generate_password_hash("HASHED_PASSWORD").decode(
'UTF-8'),
)
user2 = User(
email="*****@*****.**",
username="******",
password="******",
)
self.user1 = user1
self.user2 = user2
db.session.add(user1)
db.session.add(user2)
db.session.commit()
follow1 = Follows(
user_being_followed_id=self.user1.id,
user_following_id=self.user2.id,
)
self.follow1 = follow1
db.session.add(follow1)
db.session.commit()
def test_is_following(self):
"""Test is_following method"""
user1 = User(
email="*****@*****.**",
username="******",
password="******"
)
user2 = User(
email="*****@*****.**",
username="******",
password="******"
)
db.session.add(user1)
db.session.add(user2)
db.session.commit()
#Create follow relationship
follows = Follows(user_being_followed_id=user1.id,
user_following_id=user2.id)
db.session.add(follows)
db.session.commit()
#Test if user2 is following user1
self.assertEqual(user2.is_following(user1), True)
self.assertEqual(len(user2.following), 1)
#Test if user1 is following user2
self.assertEqual(user1.is_following(user2), False)
self.assertEqual(len(user2.following), 1)
