def test_alerts_pagination_sizes(self): """Check that the correct number of alerts are generated""" # Create 2 test users user1 = create_account('user1', '*****@*****.**', 'Password') user2 = create_account('user2', '*****@*****.**', 'Password') # Generate lots of following alerts for i in xrange(101): follow_user(user2, user1) unfollow_user(user2, user1) ALERT_ITEMS_PER_PAGE = app.config.get('ALERT_ITEMS_PER_PAGE') self.assertEqual(len(get_alerts(user1).items), ALERT_ITEMS_PER_PAGE) self.assertEqual(len(get_alerts(user1, per_page=25).items), 25) self.assertEqual(len(get_alerts(user1, per_page=50).items), 50) self.assertEqual(len(get_alerts(user1, per_page=100).items), 100)
def test_approved_unapproved_is_approved(self): """Ensure a user can approve and unapprove a follower. Also test the checking of this state""" user1 = create_account('user1', '*****@*****.**', 'Password') user2 = create_account('user2', '*****@*****.**', 'Password') user3 = create_account('user3', '*****@*****.**', 'Password') # User should not be following a user self.assertFalse(is_approved(user1, user2)) # User can't approve a user he is not following self.assertFalse(approve_user(user1, user2)) # Follow wrong way round. The user to be approved must follow you follow_user(user1, user2) self.assertFalse(approve_user(user1, user2)) self.assertFalse(is_approved(user1, user2)) # Correct way round follow_user(user2, user1) self.assertTrue(approve_user(user1, user2)) self.assertTrue(is_approved(user1, user2)) # Try an un-approved a non follower self.assertFalse(is_approved(user1, user3)) self.assertFalse(unapprove_user(user1, user3)) # Try and un-approve a non approved follower follow_user(user3, user1) self.assertFalse(is_approved(user1, user3)) self.assertFalse(unapprove_user(user1, user3)) # Un-approve an approved folloer self.assertTrue(is_approved(user1, user2)) self.assertTrue(unapprove_user(user1, user2)) self.assertFalse(is_approved(user1, user2)) # Ensure a user is un-approved if they stop following you # and you had approved them self.assertTrue(approve_user(user1, user2)) self.assertTrue(is_approved(user1, user2)) unfollow_user(user2, user1) self.assertFalse(is_approved(user1, user2))
def unfollow(username): """Unfollow a user""" redirect_url = handle_next(request, url_for('users.following', username=current_user.get('username'))) user_id = get_uid(username) # If we don't get a uid from the username the page doesn't exist if user_id is None: abort(404) # Unfollow user, ensure the user doesn't unfollow themself if user_id != current_user.get('_id'): if unfollow_user(current_user.get('_id'), user_id): flash('You are no longer following %s' % username, 'success') else: flash('You can\'t follow/unfollow yourself', 'information') return redirect(redirect_url)
def unfollow(username): """Unfollow a user""" redirect_url = handle_next( request, url_for('users.following', username=current_user.get('username'))) user_id = get_uid(username) # If we don't get a uid from the username the page doesn't exist if user_id is None: abort(404) # Unfollow user, ensure the user doesn't unfollow themself if user_id != current_user.get('_id'): if unfollow_user(current_user.get('_id'), user_id): flash('You are no longer following %s' % username, 'success') else: flash('You can\'t follow/unfollow yourself', 'information') return redirect(redirect_url)
def test_follow_unfollow_get_followers_following_is_following(self): """ Test everything about following. There is not that much to it to deserve 3 seperate methods. """ # Create two test users user1 = create_account('user1', '*****@*****.**', 'Password') user2 = create_account('user2', '*****@*****.**', 'Password') # Ensure is_following() is false atm self.assertFalse(is_following(user1, user2)) self.assertFalse(is_following(user2, user1)) # Ensure user 1 can follow user 2 self.assertTrue(follow_user(user1, user2)) # Ensure the user can't follow them again self.assertFalse(follow_user(user1, user2)) # And visa-versa self.assertTrue(follow_user(user2, user1)) # Ensre the user can't follow them again self.assertFalse(follow_user(user2, user1)) # Ensure the id's are in the Redis sorted sets, followers and following self.assertIn(user2, r.zrange(k.USER_FOLLOWING.format(user1), 0, -1)) self.assertIn(user2, r.zrange(k.USER_FOLLOWERS.format(user1), 0, -1)) self.assertIn(user1, r.zrange(k.USER_FOLLOWING.format(user2), 0, -1)) self.assertIn(user1, r.zrange(k.USER_FOLLOWERS.format(user2), 0, -1)) # Ensure the get_followers and get_following functions return # the correct data self.assertEqual(len(get_following(user1).items), 1) self.assertEqual(len(get_following(user1).items), 1) self.assertEqual(len(get_following(user2).items), 1) self.assertEqual(len(get_following(user2).items), 1) # Ensure the totals are correct self.assertEqual(get_following(user1).total, 1) self.assertEqual(get_followers(user1).total, 1) self.assertEqual(get_following(user2).total, 1) self.assertEqual(get_followers(user2).total, 1) # Make sure is_following() returns correctly self.assertTrue(is_following(user1, user2)) self.assertTrue(is_following(user2, user1)) # User 1 unfollow user 2 and ensure the sorted sets are updated self.assertTrue(unfollow_user(user1, user2)) self.assertNotIn(user2, r.zrange(k.USER_FOLLOWING.format(user1), 0, -1)) self.assertNotIn(user1, r.zrange(k.USER_FOLLOWERS.format(user2), 0, -1)) # Ensure the user can't unfollow the user again self.assertFalse(unfollow_user(user1, user2)) # Ensure is_following shows correctly self.assertFalse(is_following(user1, user2)) # Test what happens when we delete an account. # Ensure user 2 is still following user1 self.assertTrue(is_following(user2, user1)) # This should clean delete_account(user1) # Ensure this has cleaned user2 following list self.assertFalse(is_following(user2, user1)) # Ensure get_followers and get_following return the correct value for # user2 self.assertEqual(len(get_following(user2).items), 0) # Ensure the totals are correct self.assertEqual(get_following(user2).total, 0) self.assertEqual(get_followers(user2).total, 0) # Make sure is_following() returns correctly self.assertFalse(is_following(user1, user2)) self.assertFalse(is_following(user2, user1)) # I don't want to play with the above testing to much. I am adding # in a test for self cleaning lists. I am going to reset this test # case by manually flushing the Redis database :) r.flushdb() # Back to normal, I don't like artificially uping the number of tests. # Test the self cleaning lists in case there is an issue with Redis # during an account deletion. We need 2 new users. user1 = create_account('user1', '*****@*****.**', 'Password') user2 = create_account('user2', '*****@*****.**', 'Password') # Follow each other. self.assertTrue(follow_user(user1, user2)) self.assertTrue(follow_user(user2, user1)) # Manually delete user1 m.db.users.remove({'_id': user1}) # Ensure user1 appears in both user2's followers and following lists self.assertIn(user1, r.zrange(k.USER_FOLLOWERS.format(user2), 0, -1)) self.assertIn(user1, r.zrange(k.USER_FOLLOWING.format(user2), 0, -1)) # Ensure if we actuallt get the lists from the backend functions user1 # is not there self.assertEqual(get_followers(user2).total, 0) self.assertEqual(get_following(user2).total, 0)
def test_alerts(self): """ Tests for the 2 functions which are used on the side to get alerts and also test FollowAlert from here. """ # Create 2 test users user1 = create_account('user1', '*****@*****.**', 'Password') user2 = create_account('user2', '*****@*****.**', 'Password') # Ensure that get_alerts pagination object is empty self.assertEqual(get_alerts(user1).total, 0) self.assertEqual(len(get_alerts(user1).items), 0) # Get user 2 to follow user 1 follow_user(user2, user1) # Check that i_has_alerts is True self.assertTrue(new_alerts(user1)) # Ensure that there is an alert in the get_alerts self.assertEqual(get_alerts(user1).total, 1) self.assertEqual(len(get_alerts(user1).items), 1) # Check that i_has_alerts is False, we have read them with get_alerts self.assertFalse(new_alerts(user1)) # Get the alert and check that the alert is the follow alert alert = get_alerts(user1).items[0] self.assertTrue(isinstance(alert, FollowAlert)) # Also check it's still a BaseAlert self.assertTrue(isinstance(alert, BaseAlert)) # Check its from test2 self.assertEqual(alert.user.get('username'), 'user2') self.assertEqual(alert.user.get('email'), '*****@*****.**') self.assertIn('has started following you', alert.prettify()) # Delete test2 and ensure we get no alerts delete_account(user2) # Ensure the alert is still inside Redis self.assertEqual(r.zcard(k.USER_ALERTS.format(user1)), 1) # Get the alerts, should be none and should also clear the alert from # Redis self.assertEqual(get_alerts(user1).total, 0) self.assertEqual(len(get_alerts(user1).items), 0) self.assertEqual(r.zcard(k.USER_ALERTS.format(user1)), 0) # Do the same as above to ensure we can delete an alert ourselves # Create another user user3 = create_account('user3', '*****@*****.**', 'Password') follow_user(user1, user3) # Check the alerts are there alert = get_alerts(user3).items[0] self.assertTrue(isinstance(alert, FollowAlert)) # Also check it's still a BaseAlert self.assertTrue(isinstance(alert, BaseAlert)) # Check its from test2 self.assertEqual(alert.user.get('username'), 'user1') self.assertEqual(alert.user.get('email'), '*****@*****.**') self.assertIn('has started following you', alert.prettify()) # Delete the alert with aid from the alert delete_alert(user3, alert.alert_id) # Get the alerts and ensure the list is empty self.assertEqual(get_alerts(user3).total, 0) self.assertEqual(len(get_alerts(user3).items), 0) self.assertEqual(r.zcard(k.USER_ALERTS.format(user3)), 0) # Unfollow the user3 and then follow them again unfollow_user(user1, user3) follow_user(user1, user3) alert = get_alerts(user3).items[0] self.assertIn('has started following you', alert.prettify()) # Manually delete the alert r.delete(k.ALERT.format(alert.alert_id)) # Get the alerts again and ensure the length is 0 # Ensure that the alert is not pulled down alerts = get_alerts(user3) self.assertEqual(len(alerts.items), 0) # Get alerts for a non-existant user # This will not fail but will have an empty pagination alerts = get_alerts(k.NIL_VALUE) self.assertEqual(len(alerts.items), 0)