Feature/entity-refactor

infra/api/entities/petStore/PetStore.ts

@@ -9,20 +9,20 @@ export class PetStoreApi extends ApiClient {
 
     private petStorePetEndpoint = `${ApplicationUrl.PET_STORE_URL}/${ApiEndpoints.PET}`
 
-    public async getPet(petId: number): Promise<APIResponse | undefined> {
+    async getPet(petId: number): Promise<APIResponse | undefined> {
         let response = await this.get(`${this.petStorePetEndpoint}/${petId}`)
         return response;
     }
 
-    public async createNewPet<T>(petData: { [key: string]: T }) {
+    async createNewPet<T>(petData: { [key: string]: T }) {
         let response = await this.post(this.petStorePetEndpoint, { requestData: petData })
         return response;
     }
 
     /**
      * @description this function uploads a pet image via reading a file and uploading it as a buffer file using the playwright multipart photo upload
      */
-    public async uploadPetImage<T>(petId: number, fileName: string) {
+    async uploadPetImage<T>(petId: number, fileName: string) {
         const rootDir = '.'
         const file = path.resolve(rootDir, fileName);
         const image = fs.readFileSync(file);
@@ -33,16 +33,22 @@ export class PetStoreApi extends ApiClient {
                 buffer: image,
             },
         }
-        let response = await this.post(`${this.petStorePetEndpoint}/${petId}/${ApiEndpoints.UPLOAD_IMAGE}`, { isMultiPart: true, multiPartData })
+        let response = await this.post(
+            `${this.petStorePetEndpoint}/${petId}/${ApiEndpoints.UPLOAD_IMAGE}`,
+            {
+                isMultiPart: true,
+                multiPartData
+            }
+        )
         return response;
     }
 
-    public async updatePet<T>(updatedData: { [key: string]: T }) {
+    async updatePet<T>(updatedData: { [key: string]: T }) {
         let response = await this.put(this.petStorePetEndpoint, { requestData: updatedData })
         return response;
     }
 
-    public async deletePet(petId: number) {
+    async deletePet(petId: number) {
         let response = await this.delete(`${this.petStorePetEndpoint}/${petId}`)
         return response;
     }

infra/api/entities/pokemon/PokemonApi.ts

@@ -7,15 +7,15 @@ export class PokemonApi extends ApiClient {
     private POKEMON_BASE_URL = ApplicationUrl.POKEMON_URL;
     private POKEMON_ENDPOINT = `${this.POKEMON_BASE_URL}/${ApiEndpoints.POKEMON}`;
 
-    public async getPokemon() {
+    async getPokemon() {
         let response = await this.get(this.POKEMON_ENDPOINT)
         return response;
     }
 
     /**
      * @description get all pokemon recourses by using pagination - you can choose via page or limit and offset pagination mechanism
      */
-    public async getAllPokemonRecourses(limit: number, offset: number) {
+    async getAllPokemonRecourses(limit: number, offset: number) {
         let responses = await this.paginateRequest(
             RequestMethod.GET,
             this.POKEMON_ENDPOINT,

infra/api/entities/users-api/Users.ts

@@ -6,37 +6,37 @@ import { ApiEndpoints } from "@api-endpoints";
 export class Users extends ApiClient {
     private usersEndpoint = `${ApplicationUrl.GO_REST_API}/${ApiEndpoints.USERS_ENDPOINT}`
 
-    public async getUsers() {
+    async getUsers() {
         let response = await this.get(this.usersEndpoint)
         return response;
     }
 
-    public async getGender(gender: string) {
+    async getGenderCount(gender: string) {
         let response = await this.get(this.usersEndpoint)
         let responseObject = await response?.json()
-        let genderFilter = responseObject.filter((el: any) => el.gender === gender).length
+        let genderFilter = responseObject.filter((el: { gender: string; }) => el.gender === gender).length
         return genderFilter
     }
 
     /**
      * @description make both genders even for the first default 10 records without pagination
      * @returns 
      */
-    public async makeBothGendersEven() {
+    async makeBothGendersEven() {
         let response: APIResponse | undefined
-        let maleUsers = await this.getGender('male');
-        let femaleUsers = await this.getGender('female');
+        let maleUsers = await this.getGenderCount('male');
+        let femaleUsers = await this.getGenderCount('female');
         try {
             let difference = Math.abs(maleUsers - femaleUsers)
             if (maleUsers === femaleUsers) {
                 return;
             } else if (maleUsers > femaleUsers) {
                 for (let i = 0; i < difference; i++) {
-                    response = await this.post(this.usersEndpoint, { requestData: payloads.femaleData, isAuthorizationRequired: true })
+                    response = await this.post(this.usersEndpoint, { requestData: payloads.femaleData })
                 }
             } else {
                 for (let i = 0; i < difference; i++) {
-                    response = await this.post(this.usersEndpoint, { requestData: payloads.maleData, isAuthorizationRequired: true })
+                    response = await this.post(this.usersEndpoint, { requestData: payloads.maleData })
                 }
             }
             return response;
@@ -45,23 +45,16 @@ export class Users extends ApiClient {
         }
     }
 
-    private async getUserStatus(status: string) {
-        let users = await this.get(this.usersEndpoint)
-        let usersJsonObject = await users?.json()
-        let inactiveUsers = usersJsonObject.filter((user: { status: string; }) => user.status === status)
-        return inactiveUsers
-    }
-
-    public async getInActiveUsers() {
-        let res = await this.getUserStatus('inactive')
-        return res
+    async getInactiveUsers() {
+        let response = await this.getUserStatus('inactive')
+        return response
     }
 
-    public async deleteInactiveUsers() {
+    async deleteInactiveUsers() {
         let response: APIResponse | undefined
-        let inActiveUsers = await this.getInActiveUsers()
+        let inActiveUsers = await this.getInactiveUsers()
         for (let user of inActiveUsers) {
-            response = await this.delete(`${this.usersEndpoint}/${user.id}`, { isAuthorizationRequired: true })
+            response = await this.delete(`${this.usersEndpoint}/${user.id}`)
         }
         return response;
     }
@@ -70,7 +63,7 @@ export class Users extends ApiClient {
      * @description get all of the users using page pagination
      * @returns 
      */
-    public async getAllUsers(page: number) {
+    async getAllUsers(page: number) {
         let response = await this.paginateRequest(
             RequestMethod.GET,
             this.usersEndpoint,
@@ -82,26 +75,23 @@ export class Users extends ApiClient {
         return response;
     }
 
-    public async getTypeOfUserProperties() {
-        let users = await this.getUsers();
-        let userObject = await users?.json()
-        let types: any = [];
-        for (let user of userObject) {
-            types.push([typeof user.id, typeof user.name, typeof user.email, typeof user.gender, typeof user.status]);
-        }
-        return types;
+    async getTypeOfUserProperties() {
+        const usersResponse = await this.getUsers();
+        const users = await usersResponse?.json();
+        return users.map((user: any) => [
+            typeof user.id,
+            typeof user.name,
+            typeof user.email,
+            typeof user.gender,
+            typeof user.status
+        ]);
     }
 
-    private async extractEmailExtension(email: string) {
-        let domain = email.split('@').pop()
-        let extension = domain?.split('.').pop()
-        return extension
-    }
 
     /**
      * @description replaces each email with .co.il extension
-     */
-    public async replaceEmailExtensionForUsers() {
+    */
+    async replaceEmailExtensionForUsers() {
         let users = await this.getUsers()
         let usersObject = await users?.json()
         let response: APIResponse | undefined
@@ -112,7 +102,12 @@ export class Users extends ApiClient {
                 if (emailExtension && emailExtension !== 'co.il') {
                     let newEmail = await email.replace(emailExtension, 'co.il');
                     let newEmailProperty = { email: newEmail }
-                    response = await this.patch(`${this.usersEndpoint}/${user.id}`, { requestData: newEmailProperty, isAuthorizationRequired: true })
+                    response = await this.patch(
+                        `${this.usersEndpoint}/${user.id}`,
+                        {
+                            requestData: newEmailProperty
+                        }
+                    )
                 }
             }
             return response
@@ -121,7 +116,7 @@ export class Users extends ApiClient {
         }
     }
 
-    public async getCurrentUserEmailExtension() {
+    async getCurrentUserEmailExtension() {
         let extensions: string[] = []
         let users = await this.getUsers()
         let usersJsonObject = await users?.json()
@@ -132,4 +127,17 @@ export class Users extends ApiClient {
         }
         return extensions
     }
+
+    private async getUserStatus(status: string) {
+        let users = await this.get(this.usersEndpoint)
+        let usersJsonObject = await users?.json()
+        let inactiveUsers = usersJsonObject.filter((user: { status: string; }) => user.status === status)
+        return inactiveUsers
+    }
+
+    private async extractEmailExtension(email: string) {
+        let domain = email.split('@').pop()
+        let extension = domain?.split('.').pop()
+        return extension
+    }
 }

infra/api/helpers/types/api-types.ts

@@ -41,7 +41,6 @@ export interface IPagination {
 export interface IRequestOptions<T> {
     queryParams?: { [key: string]: any },
     requestData?: { [key: string]: T },
-    isAuthorizationRequired?: boolean,
     isMultiPart?: boolean,
     multiPartData?: { [key: string]: any },
 }

tests/api_tests/users/UsersApiTests.spec.ts

@@ -22,8 +22,8 @@ test.describe('Api tests for GoRestApi endpoints', async () => {
     test('gender equality - [POST] /users', { tag: [TestTags.Users] }, async ({ usersApi }) => {
         await test.step('make an api request to make both male and female genders equal', async () => {
             await usersApi.makeBothGendersEven();
-            let maleGender = await usersApi.getGender('male')
-            let femaleGender = await usersApi.getGender('female')
+            let maleGender = await usersApi.getGenderCount('male')
+            let femaleGender = await usersApi.getGenderCount('female')
             expect(maleGender).toEqual(femaleGender)
         })
     })
@@ -44,7 +44,7 @@ test.describe('Api tests for GoRestApi endpoints', async () => {
         await test.step('make a request to delete all users that have an inactive status', async () => {
             let response = await usersApi.deleteInactiveUsers()
             expect(response?.status()).toBe(StatusCode.UNAUTHORIZED)
-            let actualInactiveUsers = await usersApi.getInActiveUsers()
+            let actualInactiveUsers = await usersApi.getInactiveUsers()
             let expectedInactiveUsersLength = actualInactiveUsers.length
             expect(expectedInactiveUsersLength).toBe(0)
         })