Merge pull request #5 from monikakonieczna/Task-5-Create-API-Tests-For-Filtering-Characters

Adding API Tests for Filtering Characters.

Author: monikakonieczna

package-lock.json

@@ -16,6 +16,8 @@
     "ts-node": "^10.9.2"
   },
   "dependencies": {
+    "@types/chance": "^1.1.6",
+    "chance": "^1.1.12",
     "dotenv": "^16.4.5"
   }
 }

package.json

@@ -0,0 +1,11 @@
+import Chance from "chance";
+
+const chance = new Chance();
+
+export const generateRandomAnimal = (): string => {
+  return chance.animal();
+};
+
+export const generateRandomString = (length: number = 10): string => {
+  return chance.string({ length });
+};

src/helpers/dataGenerator.ts

@@ -0,0 +1,24 @@
+import * as fs from "fs";
+import * as path from "path";
+
+// Function to load JSON data from the file
+const loadJsonData = (fileName: string): any => {
+  const filePath = path.join(
+    __dirname,
+    "../test_data/filter_characters",
+    fileName
+  );
+  const data = fs.readFileSync(filePath, "utf-8");
+  return JSON.parse(data);
+};
+
+// Load test data
+const nonexistingCharacter = loadJsonData("not_existing_character.json");
+
+/**
+ * A helper function to verify the error response message for non-existing character
+ * @param character
+ */
+export function validateNonExistingCaharcterErrorMessage(error: Error) {
+  expect(error.message).toEqual(nonexistingCharacter.message);
+}

src/helpers/filterCharactersHelper.ts

@@ -1,5 +1,4 @@
 import request, { Response } from "supertest";
-import { App } from "supertest/types";
 /**
  * A helper function to make HTTP requests, which can be used across different tests.
  * @param method
@@ -14,17 +13,19 @@ export async function makeRequest(
   body?: any,
   headers?: Record<string, string>
 ): Promise<Response> {
-  let req = request(url)[method]("/");
+  // Call the method with the path (which is the url in this case)
+  let req = request("")[method](url);
 
+  // Set headers if provided
   if (headers) {
     Object.keys(headers).forEach((key) => {
       req = req.set(key, headers[key]);
     });
   }
 
+  // Add body if provided
   if (body) {
     req = req.send(body);
   }
-
   return req;
 }

src/helpers/makeRequest.ts

@@ -0,0 +1,3 @@
+{
+    "error": "There is nothing here"
+}

src/test_data/filter_characters/not_existing_character.json

@@ -0,0 +1,126 @@
+import request, { Response } from "supertest";
+import { API_KEY } from "../../../config";
+import { assertStatusCode } from "../../../helpers/assertionsHelper";
+import { makeRequest } from "../../../helpers/makeRequest";
+import { validateNonExistingCaharcterErrorMessage } from "../../../helpers/filterCharactersHelper";
+import { validatePage1Structure } from "../../../helpers/allCharactersHelper";
+import { generateRandomString } from "../../../helpers/dataGenerator";
+
+const BASE_URL = "https://rickandmortyapi.com/api/character";
+const randomString = generateRandomString();
+console.log(randomString);
+
+/**
+ * Tests - Rick and Morty API - Filter Characters by name
+ * @group filter_characters
+ */
+describe.each([["Rick", 200]])(
+  "Rick and Morty API - Filter Characters by name",
+  (name, statusCode) => {
+    it("should filter characters by name", async () => {
+      const response = await makeRequest("get", `${BASE_URL}/?name=${name}`);
+      assertStatusCode(response, statusCode);
+      response.body.results.forEach((character: Character) => {
+        expect(character.name).toContain(`${name}`);
+      });
+    });
+  }
+);
+
+/**
+ * Tests - Rick and Morty API - Filter Characters by status
+ * @group filter_characters
+ */
+describe.each([["Alive", 200]])(
+  "Rick and Morty API - Filter Characters by status",
+  (status, statusCode) => {
+    it("should filter characters by status", async () => {
+      const response = await makeRequest(
+        "get",
+        `${BASE_URL}/?status=${status}`
+      );
+      assertStatusCode(response, statusCode);
+      response.body.results.forEach((character: any) => {
+        expect(character.status).toBe(`${status}`);
+      });
+    });
+  }
+);
+
+/**
+ * Tests - Rick and Morty API - Filter Characters by species
+ * @group filter_characters
+ */
+describe.each([["Human", 200]])(
+  "Rick and Morty API - Filter Characters by species",
+  (species, statusCode) => {
+    it("should filter characters by species", async () => {
+      const response = await makeRequest(
+        "get",
+        `${BASE_URL}/?species=${species}`
+      );
+      assertStatusCode(response, statusCode);
+      response.body.results.forEach((character: any) => {
+        expect(character.species).toBe(`${species}`);
+      });
+    });
+  }
+);
+
+/**
+ * Tests - Rick and Morty API - Filter Characters by gender
+ * @group filter_characters
+ */
+describe.each([["Male", 200]])(
+  "Rick and Morty API - Filter Characters by gender",
+  (gender, statusCode) => {
+    it("should filter characters by gender", async () => {
+      const response = await makeRequest(
+        "get",
+        `${BASE_URL}/?gender=${gender}`
+      );
+      assertStatusCode(response, statusCode);
+      response.body.results.forEach((character: any) => {
+        expect(character.gender).toBe(`${gender}`);
+      });
+    });
+  }
+);
+
+/**
+ * Tests - Rick and Morty API - Negative Test Cases - Filter Characters by non-existing filter value
+ * @group filter_characters
+ */
+describe.each([
+  ["name", "Male", 404],
+  ["status", "Male", 404],
+  ["species", "Male", 404],
+  ["gender", "halo", 404],
+])(
+  "Rick and Morty API - Filter Characters by non-existing filter value",
+  (filter, filter_value, statusCode) => {
+    it("should filter characters by gender", async () => {
+      const response = await makeRequest(
+        "get",
+        `${BASE_URL}/?${filter}=${filter_value}`
+      );
+      assertStatusCode(response, statusCode);
+      validateNonExistingCaharcterErrorMessage(response.body);
+    });
+  }
+);
+
+/**
+ * Tests - Rick and Morty API - Filter Characters by non-existing filters
+ * @group filter_characters
+ */
+describe("Rick and Morty API - Filter Characters by non-existing filters", () => {
+  it("ignore unknown filters and return the first page", async () => {
+    const response = await makeRequest(
+      "get",
+      `${BASE_URL}/?${randomString}=${randomString}`
+    );
+    assertStatusCode(response, 200);
+    validatePage1Structure(response.body);
+  });
+});