def test_follows(self):
user_one = User.create_one(
username="******", email="*****@*****.**", password="******"
)
user_two = User.create_one(
username="******", email="*****@*****.**", password="******"
)
self.assertFalse(user_one.is_following(user_two))
self.assertFalse(user_two.is_followed_by(user_one))
user_one.follow(user_two)
db.session.commit()
self.assertTrue(user_one.is_following(user_two))
self.assertTrue(user_two.is_followed_by(user_one))
self.assertFalse(user_one.is_followed_by(user_two))
self.assertTrue(user_two.is_followed_by(user_one))
self.assertTrue(user_one.followed.count() == 1)
self.assertTrue(user_two.followers.count() == 1)
f = user_one.followed.all()[-1]
self.assertTrue(f == user_two)
f = user_two.followers.all()[-1]
self.assertTrue(f == user_one)
notification = Notification.query.first()
self.assertEqual(user_one, notification.send_user)
self.assertEqual(user_two, notification.receiver_user)
user_one.unfollow(user_two)
db.session.commit()
self.assertFalse(user_one.is_following(user_two))
self.assertFalse(user_two.is_followed_by(user_one))
notification = Notification.query.first()
self.assertIsNone(notification)
def test_password_salts_are_random(self):
user_one = User.create_one(
username=fake.name(), email=fake.email(), password="******"
)
user_two = User.create_one(
username=fake.name(), email=fake.email(), password="******"
)
self.assertFalse(user_one.password_hash == user_two.password_hash)
def test_username_and_email_unique(self):
user = User.create_one(
username="******", email="*****@*****.**", password="******"
)
self.assertIsNotNone(user)
user_two = User.create_one(
username="******", email="*****@*****.**", password="******"
)
self.assertIsNone(user_two)
db.session.delete(user)
user = User.create_one(
username="******", email="*****@*****.**", password="******"
)
self.assertIsNotNone(user)
def test_user_role(self):
admin_user = User.create_one(
username="******",
email=current_app.config["ADMIN_EMAIL"],
password="******",
)
user = User.create_one(
username="******", email=fake.email(), password="******"
)
for permission_name in ROLES_PERMISSIONS_MAP["Administrator"]:
self.assertTrue(admin_user.check_permission(permission_name))
for permission_name in ROLES_PERMISSIONS_MAP["User"]:
self.assertTrue(user.check_permission(permission_name))
self.assertFalse(user.check_permission("DELETE_MOVIE"))
def test_password_setter(self):
"""test
"""
u = User.create_one(
username=fake.name(), email=fake.email(), password=fake.password()
)
self.assertTrue(u.password_hash is not None)
def test_lock_user(self):
user = User.create_one(
username="******", email=fake.email(), password="******"
)
user.lock_this_user()
for permission_name in ROLES_PERMISSIONS_MAP["User"]:
self.assertFalse(user.check_permission(permission_name))
def test_password_check(self):
password = fake.password()
username = fake.name()
u = User.create_one(username=username, email=fake.email(), password=password)
db.session.add(u)
db.session.commit()
query_user = User.query.filter_by(username=username).first()
self.assertTrue(query_user.validate_password(password))
def test_auth_token_check(self):
user_one = User.create_one(
username="******", email=fake.email(), password="******"
)
db.session.add(user_one)
db.session.commit()
token = user_one.generate_token()
current_user = User.verity_auth_token(token)
self.assertIsNotNone(current_user)
self.assertEqual(current_user.username, "user_one")
self.assertEqual(g.current_user, current_user)
g.current_user.revoke_auth_token()
current_user = User.verity_auth_token(token)
self.assertIsNone(current_user)
self.assertIsNone(g.current_user)
user_one = User.create_one(
username="******", email=fake.email(), password="******"
)
self.assertNotEqual(g.current_user, user_one)
token = user_one.generate_token(expiration=2)
time.sleep(3)
current_user = User.verity_auth_token(token)
self.assertIsNone(current_user)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument(
"cate",
required=True,
choices=["movie", "people", "celebrity"],
location="args",
)
parser.add_argument("q", required=True, type=str, location="args")
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if args.cate == "movie":
items, total = Movie.search(args.q, args.page, args.per_page)
elif args.cate == "people":
items, total = User.search(args.q, args.page, args.per_page)
else:
items, total = Celebrity.search(args.q, args.page, args.per_page)
pagination = Pagination("", args.page, args.per_page, total, items)
p = get_item_pagination(pagination,
"api.Search",
cate=args.cate,
q=args.q)
if args.cate == "movie":
return ok(
"ok",
marshal(
p,
get_pagination_resource_fields(
movie_summary_resource_fields)),
)
elif args.cate == "people":
return ok(
"ok",
marshal(p,
get_pagination_resource_fields(user_resource_fields)))
else:
return ok(
"ok",
marshal(
p,
get_pagination_resource_fields(
celebrity_summary_resource_fields)),
)
def test_change_user_role(self):
user = User.create_one(
username="******", email=fake.email(), password="******"
)
for permission_name in ROLES_PERMISSIONS_MAP["User"]:
self.assertTrue(user.check_permission(permission_name))
self.assertFalse(user.check_permission("DELETE_MOVIE"))
db.session.add(user)
db.session.commit()
query_user = User.query.filter_by(username="******").first()
query_user.change_role("Administrator")
for permission_name in ROLES_PERMISSIONS_MAP["Administrator"]:
self.assertTrue(query_user.check_permission(permission_name))
self.assertEqual(
len(query_user.roles), len(ROLES_PERMISSIONS_MAP["Administrator"])
)
def post(self):
parser = reqparse.RequestParser(trim=True)
parser.add_argument(
"username",
type=inputs.regex("^[a-zA-Z0-9\_]{6,16}$"),
required=True,
help="username is not formatted",
location="form",
)
parser.add_argument(
"password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
help="password is not formatted",
location="form",
)
parser.add_argument(
"email",
type=inputs.regex("[^@]+@[^@]+\.[^@]+"),
required=True,
help="email is not formatted",
location="form",
)
args = parser.parse_args()
user = UserModel.create_one(args["username"], args["email"],
args["password"])
if not user:
return error(ErrorCode.USER_ALREADY_EXISTS, 403)
sql_db.session.add(user)
sql_db.session.commit()
token = generate_email_confirm_token(user.username,
AccountOperations.CONFIRM,
email=user.email)
send_confirm_email.delay(token, user.email, user.username)
return ok(
"register user succeed",
http_status_code=201,
username=user.username,
role_name=user.role_name,
)
def test_rating(self):
celebrity_one = Celebrity.create_one(
name="成龙",
gender=GenderType.MALE,
douban_id="1",
imdb_id="imdb1",
born_place="HonKong",
name_en="ChengLong",
aka_list=["a", "aa", "aaa"],
aka_en_list=["A", "AA", "AAA"],
)
celebrity_two = Celebrity.create_one(
name="成龙",
gender=GenderType.MALE,
douban_id="2",
imdb_id="imdb2",
born_place="HonKong",
name_en="ChengLong",
aka_list=["a", "aa", "aaa"],
aka_en_list=["A", "AA", "AAA"],
)
movie_one = Movie.create_one(
title="当幸福来敲门",
subtype=MovieType.TV,
year=2006,
douban_id=1,
imdb_id="imdb2",
original_title="dang xingfu lai qiaomen",
seasons_count=1,
episodes_count=1,
current_season=1,
summary="Good",
cinema_status=MovieCinemaStatus.FINISHED,
aka_list=["a", "b", "c"],
genres_name=["励志", "美国"],
countries_name=["美国", "英国"],
directors_obj=[celebrity_one],
celebrities_obj=[celebrity_two],
)
db.session.add(movie_one)
db.session.commit()
self.assertEqual(movie_one.score, 0)
user_one = User.create_one(
username="******", email=fake.email(), password="******"
)
user_two = User.create_one(
username="******", email=fake.email(), password="******"
)
user_three = User.create_one(
username="******", email=fake.email(), password="******"
)
user_one.wish_movie(movie_one, "Good", tags_name=["G", "O", "D"])
self.assertEqual(user_one.id, 1)
self.assertEqual(user_two.id, 2)
self.assertEqual(user_three.id, 3)
self.assertEqual(Movie.query.first().score, 0)
self.assertEqual(Tag.query.count(), 3)
f = user_two.do_movie(movie_one, 7, "Very Good", tags_name=["V"])
db.session.commit()
self.assertTrue(f)
self.assertEqual(Movie.query.first().score, 0)
self.assertEqual(Tag.query.count(), 4)
user_three.collect_movie(movie_one, 6, "Bad", tags_name=["B"])
db.session.commit()
self.assertEqual(Movie.query.first().score, 6)
self.assertEqual(Tag.query.count(), 5)
self.assertEqual(Rating.query.count(), 3)
self.assertEqual(user_three.ratings.count(), 1)
rating_one = movie_one.ratings.first()
rating_one.like_by(user_two)
rating_one.report_by(user_three)
self.assertEqual(user_two.like_ratings.count(), 1)
self.assertEqual(user_three.report_ratings.count(), 1)
self.assertEqual(user_one.notifications_received.count(), 1)
self.assertEqual(user_two.notifications_sent.count(), 1)
user_one.delete_rating_on(movie_one)
user_two.delete_rating_on(movie_one)
user_three.delete_rating_on(movie_one)
db.session.commit()
self.assertEqual(Rating.query.count(), 0)
user_a = User.query.get(1)
user_b = User.query.get(2)
m = Movie.query.get(1)
user_a.collect_movie(m, 6, "Bad", tags_name=["B"])
user_b.collect_movie(m, 6, "Bad", tags_name=["B"])
self.assertEqual(Rating.query.count(), 2)
Movie.query.delete()
db.session.commit()
self.assertEqual(Rating.query.count(), 0)
self.assertEqual(user_three.ratings.count(), 0)
def verify_token(token):
if User.verity_auth_token(token):
return True
return False