def test_training_is_saved_in_db(self):
"""Test if the training has been successfully saved in the database"""
training = TrainingModel(
name="test training",
user_id=self.user.id,
distance=10,
time_in_seconds=3600,
)
training.save_to_db()
found_training = TrainingModel.find_by_name("test training")
self.assertIsNotNone(found_training)
def put(cls, training_id: int):
"""Put method"""
current_user_id = get_jwt_identity()
user_profile = UserProfileModel.find_by_user_id(current_user_id)
training = TrainingModel.find_by_id(training_id)
if not training:
return {"message": "Training not found."}, 404
if training.user_id != current_user_id:
return (
{
"message":
"You don't have permission to perform this action."
},
403,
)
user_profile.kilometers_run -= training.distance
training_data = training_schema.load(request.get_json())
if (TrainingModel.find_by_name_and_user_id(
training_data.name, current_user_id) != training):
return (
{
"message":
f"You have already created a training "
f"called {training_data.name}. "
f"Choose another name."
},
400,
) # bad request
training.name = training_data.name
training.distance = training_data.distance
user_profile.kilometers_run += training.distance
training.time_in_seconds = training_data.time_in_seconds
training.calculate_average_tempo()
training.calculate_calories_burnt()
try:
training.save_to_db()
user_profile.save_to_db()
except:
return (
{
"message": "An error has occurred updating the training."
},
500,
)
return training_schema.dump(training), 200
def delete(cls, training_id: int):
"""Delete method"""
current_user_id = get_jwt_identity()
user_profile = UserProfileModel.find_by_user_id(current_user_id)
training = TrainingModel.find_by_id(training_id)
if not training:
return {"message": "Training not found."}, 404
if training.user_id != current_user_id:
return (
{
"message":
"You don't have permission to perform this action."
},
403,
)
user_profile.trainings_number -= 1
user_profile.kilometers_run -= training.distance
try:
training.delete_from_db()
user_profile.save_to_db()
except:
return (
{
"message": "An error has occurred deleting the training."
},
500,
)
return {"message": "Training deleted"}, 200
def get(cls, training_id: int):
"""Get method"""
current_user_id = get_jwt_identity()
training = TrainingModel.find_by_id(training_id)
if training and current_user_id == training.user_id:
return training_schema.dump(training), 200
return {"message": "Training not found."}, 404
def test_training_is_deleted_from_db(self):
"""Test if the training
has been successfully deleted from the database"""
training = self._create_sample_training(self.user)
training.delete_from_db()
found_training = TrainingModel.find_by_name("test training")
self.assertIsNone(found_training)
def test_find_by_name(self):
"""Test if the training is found"""
training = self._create_sample_training(
user=self.user, name="test training"
)
found_training = TrainingModel.find_by_name("test training")
self.assertEqual(found_training, training)
def test_find_by_name_and_user_id_no_training(self):
"""Test if None is returned if the training with the given name doesn't exist
among the given user's trainings"""
found_training = TrainingModel.find_by_name_and_user_id(
"test training", self.user.id
)
self.assertIsNone(found_training)
def test_find_all_by_user_id(self):
"""Test if all the user's trainings are found"""
self._create_sample_training(self.user, "test training1")
self._create_sample_training(self.user, "test training2")
found_trainings = TrainingModel.find_all_by_user_id(
user_id=self.user.id
)
self.assertEqual(len(found_trainings), 2)
def test_find_all_by_user_id_current_user_only(self):
"""Test if only trainings which belong to the given user are returned"""
training1 = self._create_sample_training(self.user, "test training1")
training2 = self._create_sample_training(self.user, "test training2")
user2 = self._create_sample_user("user2")
training3 = self._create_sample_training(user2, "test training3")
found_trainings = TrainingModel.find_all_by_user_id(self.user.id)
self.assertIn(training1, found_trainings)
self.assertIn(training2, found_trainings)
self.assertNotIn(training3, found_trainings)
def test_find_all(self):
"""Test if all trainings which exist in the database are returned"""
training1 = self._create_sample_training(self.user, "test training1")
training2 = self._create_sample_training(self.user, "test training2")
user2 = self._create_sample_user("user2")
training3 = self._create_sample_training(user2, "test training3")
found_trainings = TrainingModel.find_all()
self.assertIn(training1, found_trainings)
self.assertIn(training2, found_trainings)
self.assertIn(training3, found_trainings)
def get(cls):
"""Get method"""
current_user_id = get_jwt_identity()
return (
{
"trainings":
training_list_schema.dump(
TrainingModel.find_all_by_user_id(current_user_id))
},
200,
)
def test_find_by_name_and_user_id(self):
"""Test if the training is found"""
training = self._create_sample_training(
user=self.user, name="test training"
)
found_training = TrainingModel.find_by_name_and_user_id(
"test training", self.user.id
)
self.assertEqual(found_training.name, training.name)
self.assertEqual(found_training.user_id, self.user.id)
def test_delete_method_deletes_training_from_db(self):
"""Test if delete method deletes the training from the database"""
self.client.delete(
path=f"trainings/{self.training.id}",
headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {self.access_token}",
},
)
training = TrainingModel.find_by_id(self.training.id)
self.assertIsNone(training)
def test_get_total_kilometers(self):
"""Test if correct total kilometers number is returned"""
self._create_sample_training(
user=self.user, name="test training1", distance=10
)
self._create_sample_training(
user=self.user, name="test training2", distance=7
)
kilometers_number = TrainingModel.get_total_kilometers()
expected_number = 17
self.assertEqual(kilometers_number, expected_number)
def test_calculate_total_calories(self):
"""Test if correct total calories number is returned"""
training1 = self._create_sample_training(
user=self.user, name="test training1", distance=10
)
training2 = self._create_sample_training(
user=self.user, name="test training2", distance=7
)
training1.calculate_calories_burnt()
training2.calculate_calories_burnt()
expected_number = training1.calories + training2.calories
total_calories = TrainingModel.calculate_total_calories()
self.assertEqual(total_calories, expected_number)
def test_get_trainings_data(self):
"""Test if the correct data is returned"""
response = self.client.get(
path="trainings/",
headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {self.access_token}",
},
)
trainings_data = training_list_schema.dump(
TrainingModel.find_all_by_user_id(self.user.id))
expected_trainings_num = 2
self.assertEqual(len(response.json["trainings"]),
expected_trainings_num)
self.assertEqual(response.json["trainings"], trainings_data)
def test_post_training_data_in_db(self):
"""Test if the correct data is saved in the database"""
data = {
"name": "test3",
"distance": 10,
"time_in_seconds": 3600,
}
self.client.post(
path="trainings/",
data=json.dumps(data),
headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {self.access_token}",
},
)
training = TrainingModel.find_by_name(data["name"])
self.assertEqual(training.name, data["name"])
self.assertEqual(training.distance, data["distance"])
self.assertEqual(training.time_in_seconds, data["time_in_seconds"])
def _create_sample_training(
cls,
user: "******",
name: str = "test",
distance: int = 10,
time_in_seconds=3600,
) -> "TrainingModel":
"""Create a sample training"""
training = TrainingModel(
name=name,
user_id=user.id,
distance=distance,
time_in_seconds=time_in_seconds,
)
training.calculate_average_tempo()
training.save_to_db()
return training
def test_put_method_updates_training_in_db(self):
"""Test if put method updates the training in the database"""
data = {
"name": self.training.name,
"distance": 7,
"time_in_seconds": 3700,
}
self.client.put(
path=f"trainings/{self.training.id}",
data=json.dumps(data),
headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {self.access_token}",
},
)
training = TrainingModel.find_by_id(self.training.id)
expected_avg_tempo = 6.8
self.assertEqual(training.distance, data["distance"])
self.assertEqual(training.time_in_seconds, data["time_in_seconds"])
self.assertEqual(training.avg_tempo, expected_avg_tempo)
def post(cls):
"""Post method"""
training_json = request.get_json()
current_user_id = get_jwt_identity()
user_profile = UserProfileModel.find_by_user_id(current_user_id)
training = TrainingModel.find_by_name_and_user_id(
training_json["name"], current_user_id)
if training:
return (
{
"message":
f"You have already created a training "
f"called {training_json['name']}. "
f"Choose another name."
},
400,
) # bad request
training = training_schema.load(training_json)
training.user_id = current_user_id
training.calculate_average_tempo()
training.calculate_calories_burnt()
user_profile.trainings_number += 1
user_profile.kilometers_run += training.distance
try:
training.save_to_db()
user_profile.save_to_db()
except:
return (
{
"message": "An error has occurred inserting the training."
},
500,
) # internal server error
return training_schema.dump(training), 201
def get(cls):
kilometers_number = TrainingModel.get_total_kilometers()
return {"kilometers_number": kilometers_number}, 200
def test_find_by_id_no_training(self):
"""Test if None is returned
if the training with the given id doesn't exist"""
found_training = TrainingModel.find_by_id(1)
self.assertIsNone(found_training)
def test_find_by_id(self):
"""Test if the training is found"""
training = self._create_sample_training(self.user)
found_training = TrainingModel.find_by_id(1)
self.assertEqual(training, found_training)
def test_find_by_name_no_training(self):
"""Test if None is returned
if the training with the given name doesn't exist"""
found_training = TrainingModel.find_by_name("test training")
self.assertIsNone(found_training)
def test_find_all_by_user_id_no_trainings(self):
"""Test if an empty list is returned if the user has no trainings"""
found_trainings = TrainingModel.find_all_by_user_id(self.user.id)
self.assertEqual(found_trainings, [])
def get(cls):
calories_number = TrainingModel.calculate_total_calories()
return {"calories_number": calories_number}, 200
def __then_expected_calories_data_will_be_returned(self):
expected_calories = TrainingModel.calculate_total_calories()
self.assertEqual(
expected_calories, self.response.json["calories_number"]
)
def test_find_all_no_trainings(self):
"""Test if an empty list is returned
if there are no trainings in the database"""
found_trainings = TrainingModel.find_all()
self.assertEqual(found_trainings, [])
