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

package/src/services/discount-group.test.ts

@@ -1,13 +1,14 @@
-import type { DiscountGroupDraft } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import { discountGroupDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("DiscountGroup", () => {
+	const discountGroupDraft = discountGroupDraftFactory(ctMock);
+
 	test("Create discount group", async () => {
-		const draft: DiscountGroupDraft = {
+		const draft = discountGroupDraft.build({
 			key: "premium-discount-group",
 			name: {
 				"en-GB": "Premium Discount Group",
@@ -16,113 +17,100 @@ describe("DiscountGroup", () => {
 				"en-GB": "A discount group for premium customers",
 			},
 			sortOrder: "0.5",
-		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(response.status).toBe(201);
+		});
 
-		expect(response.body).toEqual({
-			createdAt: expect.anything(),
-			id: expect.anything(),
-			key: "premium-discount-group",
-			isActive: true,
-			lastModifiedAt: expect.anything(),
-			name: {
-				"en-GB": "Premium Discount Group",
-			},
-			description: {
-				"en-GB": "A discount group for premium customers",
-			},
-			sortOrder: "0.5",
-			version: 1,
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/discount-groups",
+			payload: draft,
 		});
+
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual(
+			expect.objectContaining({
+				key: "premium-discount-group",
+				isActive: true,
+				name: expect.objectContaining({
+					"en-GB": "Premium Discount Group",
+				}),
+				description: {
+					"en-GB": "A discount group for premium customers",
+				},
+				sortOrder: "0.5",
+				version: 1,
+			}),
+		);
 	});
 
 	test("Get discount group", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "test-discount-group",
 			name: {
 				"en-GB": "Test Discount Group",
 			},
 			sortOrder: "0.1",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/discount-groups/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/discount-groups/${discountGroup.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(discountGroup);
 	});
 
 	test("Get discount group by key", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "key-discount-group",
 			name: {
 				"en-GB": "Key Discount Group",
 			},
 			sortOrder: "0.2",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			"/dummy/discount-groups/key=key-discount-group",
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/discount-groups/key=key-discount-group",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(discountGroup);
 	});
 
 	test("Query discount groups", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "query-discount-group",
 			name: {
 				"en-GB": "Query Discount Group",
 			},
 			sortOrder: "0.3",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get("/dummy/discount-groups");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/discount-groups",
+		});
 
-		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(discountGroup);
 	});
 
 	test("Update discount group - setName", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "update-name-group",
 			name: {
 				"en-GB": "Original Name",
 			},
 			sortOrder: "0.4",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/discount-groups/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/discount-groups/${discountGroup.id}`,
+			payload: {
+				version: discountGroup.version,
 				actions: [
 					{
 						action: "setName",
@@ -132,34 +120,31 @@ describe("DiscountGroup", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.name).toEqual({
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().name).toEqual({
 			"en-GB": "Updated Name",
 			de: "Aktualisierter Name",
 		});
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Update discount group - setDescription", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "update-description-group",
 			name: {
 				"en-GB": "Test Group",
 			},
 			sortOrder: "0.5",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/discount-groups/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/discount-groups/${discountGroup.id}`,
+			payload: {
+				version: discountGroup.version,
 				actions: [
 					{
 						action: "setDescription",
@@ -169,103 +154,95 @@ describe("DiscountGroup", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.description).toEqual({
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().description).toEqual({
 			"en-GB": "New description",
 			de: "Neue Beschreibung",
 		});
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Update discount group - setKey", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "original-key",
 			name: {
 				"en-GB": "Test Group",
 			},
 			sortOrder: "0.6",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/discount-groups/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/discount-groups/${discountGroup.id}`,
+			payload: {
+				version: discountGroup.version,
 				actions: [
 					{
 						action: "setKey",
 						key: "updated-key",
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.key).toBe("updated-key");
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().key).toBe("updated-key");
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Update discount group - setSortOrder", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "sort-order-group",
 			name: {
 				"en-GB": "Sort Order Group",
 			},
 			sortOrder: "0.1",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/discount-groups/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/discount-groups/${discountGroup.id}`,
+			payload: {
+				version: discountGroup.version,
 				actions: [
 					{
 						action: "setSortOrder",
 						sortOrder: "0.9",
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.sortOrder).toBe("0.9");
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().sortOrder).toBe("0.9");
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Delete discount group", async () => {
-		const draft: DiscountGroupDraft = {
+		const discountGroup = await discountGroupDraft.create({
 			key: "delete-group",
 			name: {
 				"en-GB": "Delete Group",
 			},
 			sortOrder: "0.7",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const deleteResponse = await supertest(ctMock.app)
-			.delete(`/dummy/discount-groups/${createResponse.body.id}`)
-			.query({ version: createResponse.body.version });
+		const deleteResponse = await ctMock.app.inject({
+			method: "DELETE",
+			url: `/dummy/discount-groups/${discountGroup.id}?version=${discountGroup.version}`,
+		});
 
-		expect(deleteResponse.status).toBe(200);
-		expect(deleteResponse.body).toEqual(createResponse.body);
+		expect(deleteResponse.statusCode).toBe(200);
+		expect(deleteResponse.json()).toEqual(discountGroup);
 
-		const getResponse = await supertest(ctMock.app).get(
-			`/dummy/discount-groups/${createResponse.body.id}`,
-		);
+		const getResponse = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/discount-groups/${discountGroup.id}`,
+		});
 
-		expect(getResponse.status).toBe(404);
+		expect(getResponse.statusCode).toBe(404);
 	});
 });

package/src/services/discount-group.ts

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

package/src/services/draft-validation.test.ts

@@ -0,0 +1,255 @@
+import { describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index.ts";
+
+describe("Draft validation (strict mode)", () => {
+	const ctMock = new CommercetoolsMock({ strict: true });
+
+	describe("ZoneDraft", () => {
+		test("accepts valid draft", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/zones",
+				payload: {
+					name: "Europe",
+					key: "europe",
+					locations: [{ country: "DE" }, { country: "NL" }],
+				},
+			});
+			expect(response.statusCode).toBe(201);
+			expect(response.json().name).toBe("Europe");
+		});
+
+		test("rejects draft without required 'name' field", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/zones",
+				payload: {
+					key: "missing-name",
+				},
+			});
+			expect(response.statusCode).toBe(400);
+			const body = response.json();
+			expect(body.errors[0].code).toBe("InvalidJsonInput");
+			expect(body.errors[0].detailedErrorMessage).toBe(
+				"name: Missing required value",
+			);
+		});
+
+		test("rejects draft with wrong type for 'name'", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/zones",
+				payload: {
+					name: 123,
+				},
+			});
+			expect(response.statusCode).toBe(400);
+			const body = response.json();
+			expect(body.errors[0].code).toBe("InvalidJsonInput");
+			expect(body.errors[0].detailedErrorMessage).toBe(
+				"name: JSON String expected.",
+			);
+		});
+
+		test("accepts draft with extra fields (looseObject)", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/zones",
+				payload: {
+					name: "Test",
+					someExtraField: "should be ignored",
+				},
+			});
+			expect(response.statusCode).toBe(201);
+		});
+	});
+
+	describe("ChannelDraft", () => {
+		test("accepts valid draft", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/channels",
+				payload: {
+					key: "my-channel",
+					roles: ["InventorySupply"],
+				},
+			});
+			expect(response.statusCode).toBe(201);
+			expect(response.json().key).toBe("my-channel");
+		});
+
+		test("rejects draft without required 'key' field", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/channels",
+				payload: {
+					roles: ["InventorySupply"],
+				},
+			});
+			expect(response.statusCode).toBe(400);
+			const body = response.json();
+			expect(body.errors[0].code).toBe("InvalidJsonInput");
+			expect(body.errors[0].detailedErrorMessage).toBe(
+				"key: Missing required value",
+			);
+		});
+
+		test("rejects draft with invalid role enum value", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/channels",
+				payload: {
+					key: "bad-roles",
+					roles: ["InvalidRole"],
+				},
+			});
+			expect(response.statusCode).toBe(400);
+			const body = response.json();
+			expect(body.errors[0].code).toBe("InvalidJsonInput");
+			expect(body.errors[0].detailedErrorMessage).toContain(
+				"Invalid enum value",
+			);
+		});
+
+		test("accepts draft with localized name", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/channels",
+				payload: {
+					key: "localized-channel",
+					name: { en: "English", de: "Deutsch" },
+				},
+			});
+			expect(response.statusCode).toBe(201);
+		});
+	});
+
+	describe("InventoryEntryDraft", () => {
+		test("accepts valid draft", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/inventory",
+				payload: {
+					key: "ie-key-1",
+					sku: "sku_variant1",
+					quantityOnStock: 4,
+				},
+			});
+			expect(response.statusCode).toBe(201);
+			expect(response.json().sku).toBe("sku_variant1");
+		});
+
+		test("rejects draft with typo in required field name (quantityOnStxock)", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/inventory",
+				payload: {
+					key: "ie-key-1",
+					sku: "sku_variant1",
+					quantityOnStxock: 4, // typo — real field is quantityOnStock
+				},
+			});
+			expect(response.statusCode).toBe(400);
+			const body = response.json();
+			expect(body.errors[0].code).toBe("InvalidJsonInput");
+			expect(body.errors[0].detailedErrorMessage).toBe(
+				"quantityOnStock: Missing required value",
+			);
+		});
+
+		test("rejects draft without required 'sku' field", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/inventory",
+				payload: {
+					quantityOnStock: 10,
+				},
+			});
+			expect(response.statusCode).toBe(400);
+			const body = response.json();
+			expect(body.errors[0].code).toBe("InvalidJsonInput");
+			expect(body.errors[0].detailedErrorMessage).toBe(
+				"sku: Missing required value",
+			);
+		});
+	});
+
+	describe("CustomerDraft", () => {
+		test("accepts valid draft", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/customers",
+				payload: {
+					email: "test@example.com",
+					password: "secret123",
+				},
+			});
+			expect(response.statusCode).toBe(201);
+		});
+
+		test("rejects draft without required 'email' field", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/customers",
+				payload: {
+					password: "secret123",
+				},
+			});
+			expect(response.statusCode).toBe(400);
+			const body = response.json();
+			expect(body.errors[0].code).toBe("InvalidJsonInput");
+			expect(body.errors[0].detailedErrorMessage).toBe(
+				"email: Missing required value",
+			);
+		});
+
+		test("accepts draft with addresses", async () => {
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/customers",
+				payload: {
+					email: "address@example.com",
+					password: "secret123",
+					addresses: [
+						{
+							country: "DE",
+							city: "Berlin",
+							streetName: "Main Street",
+						},
+					],
+				},
+			});
+			expect(response.statusCode).toBe(201);
+		});
+	});
+});
+
+describe("Draft validation (non-strict mode - default)", () => {
+	const ctMock = new CommercetoolsMock();
+
+	test("allows invalid zone draft when strict is false", async () => {
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/zones",
+			payload: {
+				// missing required 'name' field
+				key: "no-name-zone",
+			},
+		});
+		// Without strict mode, validation is skipped and the
+		// repository creates the resource (name will be undefined)
+		expect(response.statusCode).toBe(201);
+	});
+
+	test("allows invalid channel draft when strict is false", async () => {
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/channels",
+			payload: {
+				// missing required 'key' field
+				roles: ["InventorySupply"],
+			},
+		});
+		expect(response.statusCode).toBe(201);
+	});
+});