def test_user_create_user_with_same_mail(self):
user = UserModel(user_schema.load(self.user1))
user.save()
res = UserService.create(user_schema.load(self.user1))
self.assertEqual(res.status_code, 400)
def test_login_wrong_password(self):
user = UserModel(user_schema.load(self.user1))
user.save()
wrong_password = {
'email': '*****@*****.**',
'password': '******'
}
res = UserService.login(user_schema.load(wrong_password, partial=True))
self.assertEqual(res.status_code, 400)
def test_user_update(self):
user = UserModel(user_schema.load(self.user1))
user.save()
res = UserService.update(
user_schema.load({'name': 'test'}, partial=True))
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data.get('name'), 'test')
def test_login_no_email_or_password(self):
user = UserModel(user_schema.load(self.user1))
user.save()
res = UserService.login(
user_schema.load({'email': '*****@*****.**'}, partial=True))
self.assertEqual(res.status_code, 400)
res = UserService.login(
user_schema.load({'password': '******'}, partial=True))
self.assertEqual(res.status_code, 400)
def setUp(self):
self.app = create_app("testing")
self.client = self.app.test_client
self.user = UserModel({
'name': 'user',
'email': '*****@*****.**',
'password': '******'
})
self.movie = MovieModel({'title': 'Star Wars'})
with self.app.app_context():
# create all tables
db.create_all()
self.user.save()
self.movie.save()
def create(data):
user_in_db = UserModel.get_user_by_email(data.get('email'))
if user_in_db:
message = {
'error':
'User already exist, please supply another email address'
}
return custom_response(message, 400)
user = UserModel(data)
user.save()
ser_data = user_schema.dump(user)
token = Auth.generate_token(ser_data.get('id'))
return custom_response({'jwt_token': token}, 201)
def login(data):
if not data.get('email') or not data.get('password'):
return custom_response(
{'error': 'you need email and password to sign in'}, 400)
user = UserModel.get_user_by_email(data.get('email'))
if not user:
return custom_response({'error': 'invalid credentials'}, 400)
if not user.check_hash(data.get('password')):
return custom_response({'error': 'invalid credentials'}, 400)
ser_data = user_schema.dump(user)
token = Auth.generate_token(ser_data.get('id'))
return custom_response({'jwt_token': token}, 200)
def seed_things():
genre_names = [
{"name": "Horror"},
{"name": "Action"},
{"name": "Romance"},
{"name": "Comedy"},
{"name": "Adventure"}
]
genres = []
for genre in genre_names:
g = GenreModel(genre)
g.save()
genres.append(g)
m = MovieModel({"title": "Saw"})
m.genres.extend([genres[0], genres[3]])
m.save()
m = MovieModel({"title": "Hitman"})
m.genres.append(genres[1])
m.save()
m = MovieModel({"title": "Notebook"})
m.genres.append(genres[2])
m.save()
m = MovieModel({"title": "Star Wars"})
m.genres.extend([genres[1], genres[4]])
m.save()
users = [
{"name": "user1", "email": "*****@*****.**", "password": "******"},
{"name": "user2", "email": "*****@*****.**", "password": "******"},
]
for user in users:
u = UserModel(user)
u.save()
class RentalModelTest(unittest.TestCase):
def setUp(self):
self.app = create_app("testing")
self.client = self.app.test_client
self.user = UserModel({
'name': 'user',
'email': '*****@*****.**',
'password': '******'
})
self.movie = MovieModel({'title': 'Star Wars'})
with self.app.app_context():
# create all tables
db.create_all()
self.user.save()
self.movie.save()
def create_rental(self):
rental = RentalModel({'user_id': 1, 'movie_id': 1})
db.session.add(rental)
db.session.commit()
return rental
@patch('src.model.RentalModel.get_now')
def test_return_same_day(self, mock_now):
mock_now.return_value = rent_day
rental = self.create_rental()
self.assertIsNotNone(rental)
mock_now.return_value = day0
rental.return_movie()
self.assertEqual(1, rental.fee)
self.assertEqual(day0, rental.returned_at)
@patch('src.model.RentalModel.get_now')
def test_return_after_two_days(self, mock_now):
mock_now.return_value = rent_day
rental = self.create_rental()
self.assertIsNotNone(rental)
mock_now.return_value = day2
rental.return_movie()
self.assertEqual(2, rental.fee)
self.assertEqual(day2, rental.returned_at)
@patch('src.model.RentalModel.get_now')
def test_return_after_three_days(self, mock_now):
mock_now.return_value = rent_day
rental = self.create_rental()
self.assertIsNotNone(rental)
mock_now.return_value = day3
rental.return_movie()
self.assertEqual(3, rental.fee)
self.assertEqual(day3, rental.returned_at)
@patch('src.model.RentalModel.get_now')
def test_return_after_four_days(self, mock_now):
mock_now.return_value = rent_day
rental = self.create_rental()
self.assertIsNotNone(rental)
mock_now.return_value = day4
rental.return_movie()
self.assertEqual(3.5, rental.fee)
self.assertEqual(day4, rental.returned_at)
@patch('src.model.RentalModel.get_now')
def test_return_after_five_days(self, mock_now):
mock_now.return_value = rent_day
rental = self.create_rental()
self.assertIsNotNone(rental)
mock_now.return_value = day5
rental.return_movie()
self.assertEqual(4, rental.fee)
self.assertEqual(day5, rental.returned_at)
def tearDown(self):
with self.app.app_context():
db.session.remove()
db.drop_all()
def test_user_retrieve(self):
u = UserModel(self.user)
db.session.add(u)
db.session.commit()
s = UserModel.query.first()
self.assertEqual(s, u)
def test_user_create(self):
u = UserModel(self.user)
self.assertIsNotNone(u)
def delete():
user = UserModel.get_one_user(UserService.get_user())
user.delete()
return custom_response({'message': 'deleted'}, 204)
def update(data):
user = UserModel.get_one_user(UserService.get_user())
user.update(data)
ser_user = user_schema.dump(user)
return custom_response(ser_user, 200)
def get_logged_in_user():
user = UserModel.get_one_user(UserService.get_user())
ser_user = user_schema.dump(user)
return custom_response(ser_user, 200)
def test_login(self):
user = UserModel(user_schema.load(self.user1))
user.save()
partial_user = {'email': '*****@*****.**', 'password': '******'}
res = UserService.login(user_schema.load(partial_user, partial=True))
self.assertEqual(res.status_code, 200)
def test_delete_user(self):
user = UserModel(user_schema.load(self.user1))
user.save()
res = UserService.delete()
self.assertEqual(res.status_code, 204)
