- Created BaseClient with default headers

- Moved create_data() into conftest file
- Introduced an assertion helper to abstract common assertions
- Added remaining methods to people_client.py
- Moved search related methods to a people_helpers.py
- Refactored these methods out of the test file
- Created APIRequest as a wrapper over requests methods (always wrap third party library if possible)

Author: Gaurav Singh

clients/people/base_client.py

@@ -0,0 +1,6 @@
+class BaseClient:
+    def __init__(self):
+        self.headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }

clients/people/people_client.py

@@ -1,36 +1,23 @@
 from json import dumps
 from uuid import uuid4
 
-import requests
-from assertpy import assert_that
-
+from clients.people.base_client import BaseClient
 from config import BASE_URI
-from utils.request import get, post
+from utils.request import APIRequest
 
 
-class PeopleClient:
+class PeopleClient(BaseClient):
     def __init__(self):
+        super().__init__()
+
         self.base_url = BASE_URI
+        self.request = APIRequest()
 
     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)
+        last_name, response = self.__create_person_with_unique_last_name(body)
         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):
+    def __create_person_with_unique_last_name(self, body=None):
         if body is None:
             last_name = f'User {str(uuid4())}'
             payload = dumps({
@@ -41,10 +28,18 @@ def create_person_with_unique_last_name(self, body=None):
             last_name = body['lname']
             payload = dumps(body)
 
-        headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        }
-
-        response = post(self.base_url, payload, headers)
+        response = self.request.post(self.base_url, payload, self.headers)
         return last_name, response
+
+    def read_one_person_by_id(self, person_id):
+        pass
+
+    def read_all_persons(self):
+        return self.request.get(self.base_url)
+
+    def update_person(self):
+        pass
+
+    def delete_person(self, person_id):
+        url = f'{BASE_URI}/{person_id}'
+        return self.request.delete(url)

endpoints/__init__.py

@@ -0,0 +1,9 @@
+from assertpy import assert_that
+
+
+def assert_people_have_person_with_first_name(response, first_name):
+    assert_that(response.as_dict).extracting('fname').is_not_empty().contains(first_name)
+
+
+def assert_person_is_present(is_new_user_created):
+    assert_that(is_new_user_created).is_not_empty()

tests/assertions/people_assertions.py

@@ -0,0 +1,16 @@
+import random
+
+import pytest
+
+from utils.file_reader import read_file
+
+
+@pytest.fixture
+def create_data():
+    payload = read_file('create_person.json')
+
+    random_no = random.randint(0, 1000)
+    last_name = f'Olabini{random_no}'
+
+    payload['lname'] = last_name
+    yield payload

tests/conftest.py

@@ -1,2 +1,10 @@
+from jsonpath_ng import parse
+
+
 def search_created_user_in(peoples, last_name):
-    return [person for person in peoples if person['lname'] == last_name]
+    return [person for person in peoples if person['lname'] == last_name][0]
+
+
+def search_nodes_using_json_path(peoples, json_path):
+    jsonpath_expr = parse(json_path)
+    return [match.value for match in jsonpath_expr.find(peoples)]

tests/helpers/people_helpers.py

@@ -1,15 +1,8 @@
-import random
-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
+from tests.assertions.people_assertions import *
+from tests.helpers.people_helpers import search_created_user_in, search_nodes_using_json_path
 
 client = PeopleClient()
 
@@ -18,50 +11,35 @@ def test_read_all_has_kent():
     response = client.read_all_persons()
 
     assert_that(response.status_code).is_equal_to(requests.codes.ok)
-    assert_that(response.as_dict).extracting('fname').is_not_empty().contains('Kent')
+    assert_people_have_person_with_first_name(response, first_name='Kent')
 
 
 def test_new_person_can_be_added():
     last_name, response = client.create_person()
-    peoples = client.read_all_persons().as_dict
+    assert_that(response.status_code, description='Person not created').is_equal_to(requests.codes.no_content)
 
+    peoples = client.read_all_persons().as_dict
     is_new_user_created = search_created_user_in(peoples, last_name)
-    assert_that(is_new_user_created).is_not_empty()
+    assert_person_is_present(is_new_user_created)
 
 
 def test_created_person_can_be_deleted():
-    persons_last_name = client.create_person()
+    persons_last_name, _ = client.create_person()
 
     peoples = client.read_all_persons().as_dict
-    new_person_id = search_created_user_in(peoples, persons_last_name)[0]['person_id']
+    new_person_id = search_created_user_in(peoples, persons_last_name)['person_id']
 
     response = client.delete_person(new_person_id)
     assert_that(response.status_code).is_equal_to(requests.codes.ok)
 
 
-@pytest.fixture
-def create_data():
-    payload = read_file('create_person.json')
-
-    random_no = random.randint(0, 1000)
-    last_name = f'Olabini{random_no}'
-
-    payload['lname'] = last_name
-    yield payload
-
-
 def test_person_can_be_added_with_a_json_template(create_data):
     client.create_person(create_data)
 
-    response = requests.get(BASE_URI)
-    peoples = loads(response.text)
+    response = client.read_all_persons()
+    peoples = response.as_dict
 
-    # Get all last names for any object in the root array
-    # Here $ = root, [*] represents any element in the array
-    # Read full syntax: https://pypi.org/project/jsonpath-ng/
-    jsonpath_expr = parse("$.[*].lname")
-    result = [match.value for match in jsonpath_expr.find(peoples)]
-    print(result)
+    result = search_nodes_using_json_path(peoples, json_path="$.[*].lname")
 
     expected_last_name = create_data['lname']
     assert_that(result).contains(expected_last_name)

tests/people_test.py

@@ -11,32 +11,30 @@ class Response:
     headers: dict
 
 
-def __get_responses(response):
-    status_code = response.status_code
-    text = response.text
+class APIRequest:
+    def get(self, url):
+        response = requests.get(url)
+        return self.__get_responses(response)
 
-    try:
-        as_dict = response.json()
-    except Exception:
-        as_dict = {}
+    def post(self, url, payload, headers):
+        response = requests.post(url, data=payload, headers=headers)
+        return self.__get_responses(response)
 
-    headers = response.headers
+    def delete(self, url):
+        response = requests.delete(url)
+        return self.__get_responses(response)
 
-    return Response(
-        status_code, text, as_dict, headers
-    )
+    def __get_responses(self, response):
+        status_code = response.status_code
+        text = response.text
 
+        try:
+            as_dict = response.json()
+        except Exception:
+            as_dict = {}
 
-def get(url):
-    response = requests.get(url)
-    return __get_responses(response)
+        headers = response.headers
 
-
-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)
+        return Response(
+            status_code, text, as_dict, headers
+        )