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, [])