@labdigital/commercetools-mock 2.66.0 → 3.0.0-beta.0

package/src/services/extension.test.ts

@@ -1,13 +1,14 @@
-import type { ExtensionDraft } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import { extensionDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("Extension", () => {
+	const extensionDraft = extensionDraftFactory(ctMock);
+
 	test("Create extension", async () => {
-		const draft: ExtensionDraft = {
+		const draft = extensionDraft.build({
 			key: "order-validation",
 			destination: {
 				type: "HTTP",
@@ -19,15 +20,18 @@ describe("Extension", () => {
 					actions: ["Create"],
 				},
 			],
-		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/extensions")
-			.send(draft);
+		});
 
-		expect(response.status).toBe(201);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/extensions",
+			payload: draft,
+		});
 
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual({
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			destination: {
 				type: "HTTP",
 				url: "https://example.com/webhook",
@@ -35,6 +39,7 @@ describe("Extension", () => {
 			id: expect.anything(),
 			key: "order-validation",
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			triggers: [
 				{
 					actions: ["Create"],
@@ -46,7 +51,7 @@ describe("Extension", () => {
 	});
 
 	test("Get extension", async () => {
-		const draft: ExtensionDraft = {
+		const extension = await extensionDraft.create({
 			key: "test-extension",
 			destination: {
 				type: "HTTP",
@@ -58,23 +63,19 @@ describe("Extension", () => {
 					actions: ["Update"],
 				},
 			],
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/extensions")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/extensions/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/extensions/${extension.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(extension);
 	});
 
 	test("Get extension by key", async () => {
-		const draft: ExtensionDraft = {
+		const extension = await extensionDraft.create({
 			key: "key-extension",
 			destination: {
 				type: "HTTP",
@@ -86,23 +87,19 @@ describe("Extension", () => {
 					actions: ["Create", "Update"],
 				},
 			],
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/extensions")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			"/dummy/extensions/key=key-extension",
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/extensions/key=key-extension",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(extension);
 	});
 
 	test("Query extensions", async () => {
-		const draft: ExtensionDraft = {
+		const extension = await extensionDraft.create({
 			key: "query-extension",
 			destination: {
 				type: "HTTP",
@@ -114,17 +111,15 @@ describe("Extension", () => {
 					actions: ["Delete"],
 				},
 			],
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/extensions")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get("/dummy/extensions");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/extensions",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.count).toBeGreaterThan(0);
-		expect(response.body.results).toContainEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().count).toBeGreaterThan(0);
+		expect(response.json().results).toContainEqual(extension);
 	});
 });

package/src/services/extension.ts

@@ -1,11 +1,11 @@
-import type { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { ExtensionRepository } from "../repositories/extension.ts";
 import AbstractService from "./abstract.ts";
 
 export class ExtensionServices extends AbstractService {
 	public repository: ExtensionRepository;
 
-	constructor(parent: Router, repository: ExtensionRepository) {
+	constructor(parent: FastifyInstance, repository: ExtensionRepository) {
 		super(parent);
 		this.repository = repository;
 	}

package/src/services/inventory-entry.test.ts

@@ -1,120 +1,130 @@
 import assert from "node:assert";
 import type { InventoryEntry, Type } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import {
+	inventoryEntryDraftFactory,
+	typeDraftFactory,
+} from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 describe("Inventory Entry Query", () => {
 	const ctMock = new CommercetoolsMock();
+	const inventoryEntryDraft = inventoryEntryDraftFactory(ctMock);
 	let inventoryEntry: InventoryEntry | undefined;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app).post("/dummy/inventory").send({
+		inventoryEntry = await inventoryEntryDraft.create({
 			sku: "1337",
 			quantityOnStock: 100,
 		});
-		expect(response.status).toBe(201);
-		inventoryEntry = response.body;
 	});
 
-	afterEach(() => {
-		ctMock.clear();
+	afterEach(async () => {
+		await ctMock.clear();
 	});
 
 	test("no filter", async () => {
 		assert(inventoryEntry, "inventory entry not created");
 
-		const response = await supertest(ctMock.app).get("/dummy/inventory");
-		expect(response.status).toBe(200);
-		expect(response.body.count).toBe(1);
-		expect(response.body.total).toBe(1);
-		expect(response.body.offset).toBe(0);
-		expect(response.body.limit).toBe(20);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/inventory",
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().count).toBe(1);
+		expect(response.json().total).toBe(1);
+		expect(response.json().offset).toBe(0);
+		expect(response.json().limit).toBe(20);
 	});
 
 	test("filter sku", async () => {
 		assert(inventoryEntry, "inventory entry not created");
 
 		{
-			const response = await supertest(ctMock.app)
-				.get("/dummy/inventory")
-				.query({ where: 'sku="unknown"' });
-			expect(response.status).toBe(200);
-			expect(response.body.count).toBe(0);
+			const response = await ctMock.app.inject({
+				method: "GET",
+				url: "/dummy/inventory",
+				query: { where: 'sku="unknown"' },
+			});
+			expect(response.statusCode).toBe(200);
+			expect(response.json().count).toBe(0);
 		}
 		{
-			const response = await supertest(ctMock.app)
-				.get("/dummy/inventory")
-				.query({ where: 'sku="1337"' });
-			expect(response.status).toBe(200);
-			expect(response.body.count).toBe(1);
+			const response = await ctMock.app.inject({
+				method: "GET",
+				url: "/dummy/inventory",
+				query: { where: 'sku="1337"' },
+			});
+			expect(response.statusCode).toBe(200);
+			expect(response.json().count).toBe(1);
 		}
 	});
 });
 
 describe("Inventory Entry Update Actions", () => {
 	const ctMock = new CommercetoolsMock();
+	const inventoryEntryDraft = inventoryEntryDraftFactory(ctMock);
+	const typeDraft = typeDraftFactory(ctMock);
 	let inventoryEntry: InventoryEntry | undefined;
 	let customType: Type | undefined;
 
 	beforeEach(async () => {
-		let response = await supertest(ctMock.app).post("/dummy/inventory").send({
+		inventoryEntry = await inventoryEntryDraft.create({
 			sku: "1337",
 			quantityOnStock: 100,
 		});
-		expect(response.status).toBe(201);
-		inventoryEntry = response.body;
-
-		response = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "custom-inventory",
-				name: {
-					"nl-NL": "custom-inventory",
-				},
-				resourceTypeIds: ["inventory-entry"],
-			});
-		expect(response.status).toBe(201);
-		customType = response.body;
+
+		customType = await typeDraft.create({
+			key: "custom-inventory",
+			name: {
+				"nl-NL": "custom-inventory",
+			},
+			resourceTypeIds: ["inventory-entry"],
+		});
 	});
 
 	test("changeQuantity", async () => {
 		assert(inventoryEntry, "inventory entry not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/inventory/${inventoryEntry.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/inventory/${inventoryEntry.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "changeQuantity", quantity: 300 }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.availableQuantity).toBe(300);
-		expect(response.body.quantityOnStock).toBe(300);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().availableQuantity).toBe(300);
+		expect(response.json().quantityOnStock).toBe(300);
 	});
 
 	test("removeQuantity", async () => {
 		assert(inventoryEntry, "inventory entry not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/inventory/${inventoryEntry.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/inventory/${inventoryEntry.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "removeQuantity", quantity: 15 }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.availableQuantity).toBe(85);
-		expect(response.body.quantityOnStock).toBe(85);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().availableQuantity).toBe(85);
+		expect(response.json().quantityOnStock).toBe(85);
 	});
 
 	test("set custom type", async () => {
 		assert(inventoryEntry, "inventory entry not created");
 		assert(customType, "custom type not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/inventory/${inventoryEntry.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/inventory/${inventoryEntry.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -122,33 +132,37 @@ describe("Inventory Entry Update Actions", () => {
 						type: { typeId: "type", id: customType.id },
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.custom.type.id).toBe(customType.id);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().custom.type.id).toBe(customType.id);
 	});
 
 	test("set expected delivery", async () => {
 		assert(inventoryEntry, "inventory entry not created");
 		const expectedDelivery = "2021-04-02T15:06:19.700Z";
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/inventory/${inventoryEntry.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/inventory/${inventoryEntry.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "setExpectedDelivery", expectedDelivery }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.expectedDelivery).toBe(expectedDelivery);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().expectedDelivery).toBe(expectedDelivery);
 	});
 
 	test("set custom field", async () => {
 		assert(inventoryEntry, "inventory entry not created");
 		assert(customType, "custom type not created");
 
-		const setCustomTypeResponse = await supertest(ctMock.app)
-			.post(`/dummy/inventory/${inventoryEntry.id}`)
-			.send({
+		const setCustomTypeResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/inventory/${inventoryEntry.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -157,32 +171,37 @@ describe("Inventory Entry Update Actions", () => {
 						fields: { lol: "bar" },
 					},
 				],
-			});
-		expect(setCustomTypeResponse.status).toBe(200);
-		expect(setCustomTypeResponse.body.custom.type.id).toBe(customType.id);
+			},
+		});
+		expect(setCustomTypeResponse.statusCode).toBe(200);
+		expect(setCustomTypeResponse.json().custom.type.id).toBe(customType.id);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/inventory/${inventoryEntry.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/inventory/${inventoryEntry.id}`,
+			payload: {
 				version: 2,
 				actions: [{ action: "setCustomField", name: "foo", value: "bar" }],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(3);
-		expect(response.body.custom.fields.foo).toBe("bar");
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(3);
+		expect(response.json().custom.fields.foo).toBe("bar");
 	});
 
 	test("set restockable in days", async () => {
 		assert(inventoryEntry, "inventory entry not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/inventory/${inventoryEntry.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/inventory/${inventoryEntry.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "setRestockableInDays", restockableInDays: 0 }],
-			});
-		expect(response.status).toEqual(200);
-		expect(response.body.version).toEqual(2);
-		expect(response.body.restockableInDays).toEqual(0);
+			},
+		});
+		expect(response.statusCode).toEqual(200);
+		expect(response.json().version).toEqual(2);
+		expect(response.json().restockableInDays).toEqual(0);
 	});
 });

package/src/services/inventory-entry.ts

@@ -1,11 +1,11 @@
-import type { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { InventoryEntryRepository } from "../repositories/inventory-entry/index.ts";
 import AbstractService from "./abstract.ts";
 
 export class InventoryEntryService extends AbstractService {
 	public repository: InventoryEntryRepository;
 
-	constructor(parent: Router, repository: InventoryEntryRepository) {
+	constructor(parent: FastifyInstance, repository: InventoryEntryRepository) {
 		super(parent);
 		this.repository = repository;
 	}