chore(tests): add missing docstrings

Author: nanotaboada

tests/player_stub.py

@@ -32,7 +32,7 @@ def __init__(
 
 def existing_player():
     """
-    Creates a test stub for a valid and existing Player.
+    Creates a test stub for an existing Player.
     """
     return Player(
         id=1,
@@ -49,9 +49,9 @@ def existing_player():
     )
 
 
-def non_existing_player():
+def nonexistent_player():
     """
-    Creates a test stub for a valid but non-existing Player.
+    Creates a test stub for a nonexistent (new) Player.
     """
     return Player(
         id=12,
@@ -70,7 +70,7 @@ def non_existing_player():
 
 def unknown_player():
     """
-    Creates a test stub for a valid but non-existing Player.
+    Creates a test stub for an unknown Player.
     """
     return Player(
         id=999,

tests/test_main.py

@@ -3,19 +3,29 @@
 # ------------------------------------------------------------------------------
 
 import json
-from tests.player_stub import existing_player, non_existing_player, unknown_player
+from tests.player_stub import existing_player, nonexistent_player, unknown_player
 
 PATH = "/players/"
 
 # GET /players/ ----------------------------------------------------------------
 
 
 def test_given_get_when_request_path_has_no_id_then_response_status_code_should_be_200_ok(client):
+    """
+        Given   GET /players/
+        when    request path has no ID
+        then    response Status Code should be 200 OK
+    """
     response = client.get(PATH)
     assert response.status_code == 200
 
 
 def test_given_get_when_request_path_has_no_id_then_response_body_should_be_collection_of_players(client):
+    """
+        Given   GET /players/
+        when    request path has no ID
+        then    response Status Code should be collection of players
+    """
     response = client.get(PATH)
     players = response.json()
     player_id = 0
@@ -26,41 +36,71 @@ def test_given_get_when_request_path_has_no_id_then_response_body_should_be_coll
 # GET /players/{player_id} -----------------------------------------------------
 
 
-def test_given_get_when_request_path_is_non_existing_id_then_response_status_code_should_be_404_not_found(client):
-    player_id = 999
+def test_given_get_when_request_path_is_nonexistent_id_then_response_status_code_should_be_404_not_found(client):
+    """
+        Given   GET /players/{player_id}
+        when    request path is nonexistent ID
+        then    response Status Code should be 404 (Not Found)
+    """
+    player_id = nonexistent_player().id
     response = client.get(PATH + str(player_id))
     assert response.status_code == 404
 
 
 def test_given_get_when_request_path_is_existing_id_then_response_status_code_should_be_200_ok(client):
-    player_id = 1
+    """
+        Given   GET /players/{player_id}
+        when    request path is existing ID
+        then    response Status Code should be 200 (OK)
+    """
+    player_id = existing_player().id
     response = client.get(PATH + str(player_id))
     assert response.status_code == 200
 
 
 def test_given_get_when_request_path_is_existing_id_then_response_body_should_be_matching_player(client):
-    player_id = 1
+    """
+        Given   GET /players/{player_id}
+        when    request path is existing ID
+        then    response body should be matching Player
+    """
+    player_id = existing_player().id
     response = client.get(PATH + str(player_id))
     player = response.json()
     assert player["id"] == player_id
 
 # GET /players/squadnumber/{squad_number} --------------------------------------
 
 
-def test_given_get_when_request_path_is_non_existing_squad_number_then_response_status_code_should_be_404_not_found(client):
-    squad_number = 999
+def test_given_get_when_request_path_is_nonexistent_squad_number_then_response_status_code_should_be_404_not_found(client):
+    """
+        Given   GET /players/squadnumber/{squad_number}
+        when    request path is nonexistent Squad Number
+        then    response Status Code should be 404 (Not Found)
+    """
+    squad_number = nonexistent_player().squad_number
     response = client.get(PATH + "squadnumber" + "/" + str(squad_number))
     assert response.status_code == 404
 
 
 def test_given_get_when_request_path_is_existing_squad_number_then_response_status_code_should_be_200_ok(client):
-    squad_number = 10
+    """
+        Given   GET /players/squadnumber/{squad_number}
+        when    request path is existing Squad Number
+        then    response Status Code should be 200 (OK)
+    """
+    squad_number = existing_player().squad_number
     response = client.get(PATH + "squadnumber" + "/" + str(squad_number))
     assert response.status_code == 200
 
 
 def test_given_get_when_request_path_is_existing_squad_number_then_response_body_should_be_matching_player(client):
-    squad_number = 10
+    """
+        Given   GET /players/squadnumber/{squad_number}
+        when    request path is existing Squad Number
+        then    response body should be matching Player
+    """
+    squad_number = existing_player().squad_number
     response = client.get(PATH + "squadnumber" + "/" + str(squad_number))
     player = response.json()
     assert player["squadNumber"] == squad_number
@@ -69,20 +109,35 @@ def test_given_get_when_request_path_is_existing_squad_number_then_response_body
 
 
 def test_given_post_when_request_body_is_empty_then_response_status_code_should_be_422_unprocessable_entity(client):
-    body = json.dumps({})
+    """
+        Given   POST /players/
+        when    request body is empty
+        then    response Status Code should be 422 (Unprocessable Entity)
+    """
+    body = {}
     response = client.post(PATH, data=body)
     assert response.status_code == 422
 
 
 def test_given_post_when_request_body_is_existing_player_then_response_status_code_should_be_409_conflict(client):
+    """
+        Given   POST /players/
+        when    request body is existing Player
+        then    response Status Code should be 409 (Conflict)
+    """
     player = existing_player()
     body = json.dumps(player.__dict__)
     response = client.post(PATH, data=body)
     assert response.status_code == 409
 
 
-def test_given_post_when_request_body_is_non_existing_player_then_response_status_code_should_be_201_created(client):
-    player = non_existing_player()
+def test_given_post_when_request_body_is_nonexistent_player_then_response_status_code_should_be_201_created(client):
+    """
+        Given   POST /players/
+        when    request body is nonexistent Player
+        then    response Status Code should be 201 (Created)
+    """
+    player = nonexistent_player()
     body = json.dumps(player.__dict__)
     response = client.post(PATH, data=body)
     assert response.status_code == 201
@@ -91,22 +146,37 @@ def test_given_post_when_request_body_is_non_existing_player_then_response_statu
 
 
 def test_given_put_when_request_body_is_empty_then_response_status_code_should_be_422_unprocessable_entity(client):
-    player_id = 1
+    """
+        Given   PUT /players/{player_id}
+        when    request body is empty
+        then    response Status Code should be 422 (Unprocessable Entity)
+    """
+    player_id = existing_player().id
     body = {}
     response = client.put(PATH + str(player_id), data=body)
     assert response.status_code == 422
 
 
-def test_given_put_when_request_body_is_unknown_player_then_response_status_code_should_be_404_not_found(client):
-    player_id = 999
+def test_given_put_when_request_path_is_unknown_id_then_response_status_code_should_be_404_not_found(client):
+    """
+        Given   PUT /players/{player_id}
+        when    request path is unknown ID
+        then    response Status Code should be 404 (Not Found)
+    """
+    player_id = unknown_player().id
     player = unknown_player()
     body = json.dumps(player.__dict__)
     response = client.put(PATH + str(player_id), data=body)
     assert response.status_code == 404
 
 
-def test_given_put_when_request_body_is_existing_player_then_response_status_code_should_be_204_no_content(client):
-    player_id = 1
+def test_given_put_when_request_path_is_existing_id_then_response_status_code_should_be_204_no_content(client):
+    """
+        Given   PUT /players/{player_id}
+        when    request path is existing ID
+        then    response Status Code should be 204 (No Content)
+    """
+    player_id = existing_player().id
     player = existing_player()
     player.first_name = "Emiliano"
     player.middle_name = ""
@@ -117,13 +187,23 @@ def test_given_put_when_request_body_is_existing_player_then_response_status_cod
 # DELETE /players/{player_id} --------------------------------------------------
 
 
-def test_given_delete_when_request_path_is_non_existing_id_then_response_status_code_should_be_404_not_found(client):
-    player_id = 999
+def test_given_delete_when_request_path_is_unknown_id_then_response_status_code_should_be_404_not_found(client):
+    """
+        Given   DELETE /players/{player_id}
+        when    request path is unknown ID
+        then    response Status Code should be 404 (Not Found)
+    """
+    player_id = unknown_player().id
     response = client.delete(PATH + str(player_id))
     assert response.status_code == 404
 
 
 def test_given_delete_when_request_path_is_existing_id_then_response_status_code_should_be__204_no_content(client):
-    player_id = 12
+    """
+        Given   DELETE /players/{player_id}
+        when    request path is existing ID
+        then    response Status Code should be 204 (No Content)
+    """
+    player_id = 12  # nonexistent_player() previously created
     response = client.delete(PATH + str(player_id))
     assert response.status_code == 204