def test_follows(self):
     u1 = User(email='*****@*****.**', password='******')
     u2 = User(email='*****@*****.**', password='******')
     db.session.add(u1)
     db.session.add(u2)
     db.session.commit()
     self.assertFalse(u1.is_following(u2))
     self.assertFalse(u1.is_followed_by(u2))
     timestamp_before = datetime.utcnow()
     u1.follow(u2)
     timestamp_after = datetime.utcnow()
     self.assertTrue(u1.is_following(u2))
     self.assertFalse(u1.is_followed_by(u2))
     self.assertTrue(u2.is_followed_by(u1))
     self.assertTrue(u1.followed.count() == 2)
     self.assertTrue(u2.followers.count() == 2)
     f = u1.followed.all()[-1]
     self.assertTrue(f.followed == u2)
     self.assertTrue(timestamp_before <= f.timestamp <= timestamp_after)
     f = u2.followers.all()[-1]
     self.assertTrue(f.follower == u1)
     u1.unfollow(u2)
     self.assertTrue(u1.followed.count() == 1)
     self.assertTrue(u2.followers.count() == 1)
     self.assertTrue(Follow.query.count() == 2)
     u2.follow(u1)
     db.session.delete(u2)
     db.session.commit()
     self.assertTrue(Follow.query.count() == 1)
Example #2
0
 def test_follow_posts(self):
     # make four users
     u1 = User(nickname='john', email='*****@*****.**')
     u2 = User(nickname='susan', email='*****@*****.**')
     u3 = User(nickname='mary', email='*****@*****.**')
     u4 = User(nickname='david', email='*****@*****.**')
     db.session.add(u1)
     db.session.add(u2)
     db.session.add(u3)
     db.session.add(u4)
     # make four posts
     utcnow = datetime.utcnow()
     p1 = Post(body="post from john",
               author=u1,
               timestamp=utcnow + timedelta(seconds=1))
     p2 = Post(body="post from susan",
               author=u2,
               timestamp=utcnow + timedelta(seconds=2))
     p3 = Post(body="post from mary",
               author=u3,
               timestamp=utcnow + timedelta(seconds=3))
     p4 = Post(body="post from david",
               author=u4,
               timestamp=utcnow + timedelta(seconds=4))
     db.session.add(p1)
     db.session.add(p2)
     db.session.add(p3)
     db.session.add(p4)
     db.session.commit()
     # setup the followers
     u1.follow(u1)  # john follows himself
     u1.follow(u2)  # john follows susan
     u1.follow(u4)  # john follows david
     u2.follow(u2)  # susan follows herself
     u2.follow(u3)  # susan follows mary
     u3.follow(u3)  # mary follows herself
     u3.follow(u4)  # mary follows david
     u4.follow(u4)  # david follows himself
     db.session.add(u1)
     db.session.add(u2)
     db.session.add(u3)
     db.session.add(u4)
     db.session.commit()
     # check the followed posts of each user
     f1 = u1.followed_posts().all()
     f2 = u2.followed_posts().all()
     f3 = u3.followed_posts().all()
     f4 = u4.followed_posts().all()
     assert len(f1) == 3
     assert len(f2) == 2
     assert len(f3) == 2
     assert len(f4) == 1
     assert f1 == [p4, p2, p1]
     assert f2 == [p3, p2]
     assert f3 == [p4, p3]
     assert f4 == [p4]
    def test_follow_unfollow_feature(self):
        user_test = User(username='******',
                         email='*****@*****.**',
                         password='******',
                         image_file='Day view.jpg')
        db.session.add(user_test)
        db.session.commit()

        self.assertFalse(self.user.is_following(user_test))
        self.user.follow(user_test)
        self.assertTrue(self.user.is_following(user_test))
        self.user.unfollow(user_test)
        self.assertFalse(self.user.is_following(user_test))

        user_test.follow(self.user)
        self.assertTrue(self.user.is_followed_by(user_test))
        user_test.unfollow(self.user)
        self.assertFalse(self.user.is_followed_by(user_test))
Example #4
0
    def test_follow(self):
        john = User(username='******', email='*****@*****.**')
        susan = User(username='******', email='*****@*****.**')
        db.session.add(john)
        db.session.add(susan)
        db.session.commit()
        self.assertEqual(john.followed.all(), [])
        self.assertEqual(john.followers.all(), [])

        john.follow(susan)
        db.session.commit()
        self.assertTrue(john.is_following(susan))
        self.assertEqual(john.followed.count(), 1)
        self.assertEqual(susan.followers.count(), 1)
        self.assertEqual(susan.followers.first().username, 'john')

        john.unfollow(susan)
        db.session.commit()
        self.assertFalse(john.is_following(susan))
        self.assertEqual(john.followed.count(), 0)
        self.assertEqual(susan.followers.count(), 0)
Example #5
0
    def test_follow(self):
        u1 = User(username='******', email='*****@*****.**')
        u2 = User(username='******', email='*****@*****.**')
        db.session.add(u1)
        db.session.add(u2)
        db.session.commit()
        self.assertEqual(u1.followed.all(), [])
        self.assertEqual(u1.followers.all(), [])

        u1.follow(u2)
        db.session.commit()
        self.assertTrue(u1.is_following(u2))
        self.assertEqual(u1.followed.count(), 1)
        self.assertEqual(u1.followed.first().username, 'susan')
        self.assertEqual(u2.followers.count(), 1)
        self.assertEqual(u2.followers.first().username, 'john')

        u1.unfollow(u2)
        db.session.commit()
        self.assertFalse(u1.is_following(u2))
        self.assertEqual(u1.followed.count(), 0)
        self.assertEqual(u2.followers.count(), 0)
Example #6
0
 def test_follow(self):
     u1 = User(nickname='john', email='*****@*****.**')
     u2 = User(nickname='susan', email='*****@*****.**')
     db.session.add(u1)
     db.session.add(u2)
     db.session.commit()
     assert u1.unfollow(u2) is None
     u = u1.follow(u2)
     db.session.add(u)
     db.session.commit()
     assert u1.follow(u2) is None
     assert u1.is_following(u2)
     assert u1.followed.count() == 1
     assert u1.followed.first().nickname == 'susan'
     assert u2.followers.count() == 1
     assert u2.followers.first().nickname == 'john'
     u = u1.unfollow(u2)
     assert u is not None
     db.session.add(u)
     db.session.commit()
     assert u1.is_following(u2) is False
     assert u1.followed.count() == 0
     assert u2.followers.count() == 0
Example #7
0
    def test_follow_posts(self):
        # create four users
        u1 = User(username='******', email='*****@*****.**')
        u2 = User(username='******', email='*****@*****.**')
        u3 = User(username='******', email='*****@*****.**')
        u4 = User(username='******', email='*****@*****.**')
        db.session.add_all([u1, u2, u3, u4])

        # create four posts
        now = datetime.utcnow()
        p1 = Post(body="post from john",
                  author=u1,
                  timestamp=now + timedelta(seconds=1))
        p2 = Post(body="post from susan",
                  author=u2,
                  timestamp=now + timedelta(seconds=4))
        p3 = Post(body="post from mary",
                  author=u3,
                  timestamp=now + timedelta(seconds=3))
        p4 = Post(body="post from david",
                  author=u4,
                  timestamp=now + timedelta(seconds=2))
        db.session.add_all([p1, p2, p3, p4])
        db.session.commit()

        # setup the followers
        u1.follow(u2)  # john follows susan
        u1.follow(u4)  # john follows david
        u2.follow(u3)  # susan follows mary
        u3.follow(u4)  # mary follows david
        db.session.commit()

        # check the followed posts of each user
        f1 = u1.followed_posts().all()
        f2 = u2.followed_posts().all()
        f3 = u3.followed_posts().all()
        f4 = u4.followed_posts().all()
        self.assertEqual(f1, [p2, p4, p1])
        self.assertEqual(f2, [p2, p3])
        self.assertEqual(f3, [p3, p4])
        self.assertEqual(f4, [p4])
class UserTest(unittest.TestCase):
    def setUp(self):
        self.app = create_app(config['testDB'])
        self.app_context = self.app.app_context()
        self.app_context.push()
        db.create_all()
        self.user = User(username='******',
                         email='*****@*****.**',
                         password='******',
                         image_file='Night view.png')
        db.session.add(self.user)
        db.session.commit()

    def tearDown(self):
        db.session.remove()
        db.drop_all()
        self.app_context.pop()

    def test_model_repr(self):
        self.assertEqual(repr(self.user),
                         "User: Haruka, [email protected], Night view.png")

    def test_token_valid(self):
        token = self.user.generate_confirmation_token()
        self.assertTrue(self.user.verify_token(token))

    def test_token_invalid(self):
        token = self.user.generate_confirmation_token(expires_sec=0.2)
        sleep(1)
        self.assertFalse(self.user.verify_token(token))

    def test_token_difference(self):
        user_test = User(username='******',
                         email='*****@*****.**',
                         password='******',
                         image_file='Day view.jpg')
        db.session.add(user_test)
        db.session.commit()
        token1 = self.user.get_reset_token()
        token2 = user_test.get_reset_token()
        self.assertNotEqual(token1, token2)

    def test_token_from_another_user(self):
        user_test = User(username='******',
                         email='*****@*****.**',
                         password='******',
                         image_file='Day view.jpg')
        db.session.add(user_test)
        db.session.commit()
        token = user_test.get_reset_token()
        self.assertFalse(self.user.verify_token(token))

    def test_follow_unfollow_feature(self):
        user_test = User(username='******',
                         email='*****@*****.**',
                         password='******',
                         image_file='Day view.jpg')
        db.session.add(user_test)
        db.session.commit()

        self.assertFalse(self.user.is_following(user_test))
        self.user.follow(user_test)
        self.assertTrue(self.user.is_following(user_test))
        self.user.unfollow(user_test)
        self.assertFalse(self.user.is_following(user_test))

        user_test.follow(self.user)
        self.assertTrue(self.user.is_followed_by(user_test))
        user_test.unfollow(self.user)
        self.assertFalse(self.user.is_followed_by(user_test))

    @patch('blog.models.User.to_json')
    def test_json(self, mock_obj):
        mock_obj.return_value = {
            'url': '/api/v1/users/',
            'username': '******',
            'posts_url': None
        }
        expected_keys = ['url', 'username', 'posts_url']
        self.assertEqual(sorted(mock_obj.return_value.keys()),
                         sorted(expected_keys))
        self.assertEqual(sorted((self.user.to_json())), sorted(expected_keys))