- Abstracted API methods into a people_client which makes use of a custom request wrapper instead of directly depending on requests

Note: This change breaks few tests.

Author: Gaurav Singh

clients/__init__.py

@@ -0,0 +1,50 @@
+from json import dumps
+from uuid import uuid4
+
+import requests
+from assertpy import assert_that
+
+from config import BASE_URI
+from utils.request import get, post
+
+
+class PeopleClient:
+    def __init__(self):
+        self.base_url = BASE_URI
+
+    def create_person(self, body=None):
+        last_name, response = self.create_person_with_unique_last_name(body)
+        assert_that(response.status_code, description='Person not created').is_equal_to(requests.codes.no_content)
+        return last_name, response
+
+    def read_one_person_by_id(self, person_id):
+        pass
+
+    def read_all_persons(self):
+        return get(self.base_url)
+
+    def update_person(self):
+        pass
+
+    def delete_person(self, person_id):
+        delete_url = f'{BASE_URI}/{person_id}'
+
+
+    def create_person_with_unique_last_name(self, body=None):
+        if body is None:
+            last_name = f'User {str(uuid4())}'
+            payload = dumps({
+                'fname': 'New',
+                'lname': last_name
+            })
+        else:
+            last_name = body['lname']
+            payload = dumps(body)
+
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+
+        response = post(self.base_url, payload, headers)
+        return last_name, response

clients/people/__init__.py

@@ -0,0 +1,2 @@
+def search_created_user_in(peoples, last_name):
+    return [person for person in peoples if person['lname'] == last_name]

clients/people/people_client.py

@@ -1,48 +1,41 @@
 import random
-from json import dumps, loads
-from uuid import uuid4
+from json import loads
 
 import pytest
 import requests
 from assertpy.assertpy import assert_that
 from jsonpath_ng import parse
 
+from clients.people.people_client import PeopleClient
 from config import BASE_URI
+from tests.helpers.people_helpers import search_created_user_in
 from utils.file_reader import read_file
 
+client = PeopleClient()
+
 
 def test_read_all_has_kent():
-    # We use requests.get() with url to make a get request
-    response = requests.get(BASE_URI)
-    # response from requests has many useful properties
-    # we can assert on the response status code
-    assert_that(response.status_code).is_equal_to(requests.codes.ok)
-    # We can get python dict as response by using .json() method
-    response_content = response.json()
+    response = client.read_all_persons()
 
-    # Use assertpy's fluent assertions to extract all fnames and then see the result is non empty and has
-    # Kent in it.
-    assert_that(response_content).extracting('fname').is_not_empty().contains('Kent')
+    assert_that(response.status_code).is_equal_to(requests.codes.ok)
+    assert_that(response.as_dict).extracting('fname').is_not_empty().contains('Kent')
 
 
 def test_new_person_can_be_added():
-    unique_last_name = create_person_with_unique_last_name()
+    last_name, response = client.create_person()
+    peoples = client.read_all_persons().as_dict
 
-    # After user is created, we read all the users and then use filter expression to find if the
-    # created user is present in the response list
-    peoples = requests.get(BASE_URI).json()
-    is_new_user_created = search_created_user_in(peoples, unique_last_name)
+    is_new_user_created = search_created_user_in(peoples, last_name)
     assert_that(is_new_user_created).is_not_empty()
 
 
 def test_created_person_can_be_deleted():
-    persons_last_name = create_person_with_unique_last_name()
+    persons_last_name = client.create_person()
 
-    peoples = requests.get(BASE_URI).json()
-    newly_created_user = search_created_user_in(peoples, persons_last_name)[0]
+    peoples = client.read_all_persons().as_dict
+    new_person_id = search_created_user_in(peoples, persons_last_name)[0]['person_id']
 
-    delete_url = f'{BASE_URI}/{newly_created_user["person_id"]}'
-    response = requests.delete(delete_url)
+    response = client.delete_person(new_person_id)
     assert_that(response.status_code).is_equal_to(requests.codes.ok)
 
 
@@ -58,7 +51,7 @@ def create_data():
 
 
 def test_person_can_be_added_with_a_json_template(create_data):
-    create_person_with_unique_last_name(create_data)
+    client.create_person(create_data)
 
     response = requests.get(BASE_URI)
     peoples = loads(response.text)
@@ -72,33 +65,3 @@ def test_person_can_be_added_with_a_json_template(create_data):
 
     expected_last_name = create_data['lname']
     assert_that(result).contains(expected_last_name)
-
-
-def create_person_with_unique_last_name(body=None):
-    if body is None:
-        # Ensure a user with a unique last name is created everytime the test runs
-        # Note: json.dumps() is used to convert python dict to json string
-        unique_last_name = f'User {str(uuid4())}'
-        payload = dumps({
-            'fname': 'New',
-            'lname': unique_last_name
-        })
-    else:
-        unique_last_name = body['lname']
-        payload = dumps(body)
-
-    # Setting default headers to show that the client accepts json
-    # And will send json in the headers
-    headers = {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json'
-    }
-
-    # We use requests.post method with keyword params to make the request more readable
-    response = requests.post(url=BASE_URI, data=payload, headers=headers)
-    assert_that(response.status_code, description='Person not created').is_equal_to(requests.codes.no_content)
-    return unique_last_name
-
-
-def search_created_user_in(peoples, last_name):
-    return [person for person in peoples if person['lname'] == last_name]

endpoints/__init__.py

@@ -1,7 +1,7 @@
 import json
 from pathlib import Path
 
-BASE_PATH = Path.cwd().joinpath('..', 'tests', 'data')
+BASE_PATH = Path.cwd().joinpath('tests', 'data')
 
 
 def read_file(file_name):

tests/assertions/__init__.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+
+import requests
+
+
+@dataclass
+class Response:
+    status_code: int
+    text: str
+    as_dict: object
+    headers: dict
+
+
+def __get_responses(response):
+    status_code = response.status_code
+    text = response.text
+
+    try:
+        as_dict = response.json()
+    except Exception:
+        as_dict = {}
+
+    headers = response.headers
+
+    return Response(
+        status_code, text, as_dict, headers
+    )
+
+
+def get(url):
+    response = requests.get(url)
+    return __get_responses(response)
+
+
+def post(url, payload, headers):
+    response = requests.post(url, data=payload, headers=headers)
+    return __get_responses(response)
+
+
+def delete(url):
+    response = requests.delete(url)
+    return __get_responses(response)