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

package/src/services/custom-object.test.ts

@@ -1,23 +1,29 @@
 import type { CustomObject } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { customObjectDraftFactory } from "#src/testing/index.ts";
 import { getBaseResourceProperties } from "../helpers.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 describe("CustomObject create", () => {
 	const ctMock = new CommercetoolsMock();
+	const customObjectDraft = customObjectDraftFactory(ctMock);
 
 	test("Create new object", async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/custom-objects")
-			.send({
-				container: "my-container",
-				key: "my-key",
-				value: "my-value",
-			});
+		const draft = customObjectDraft.build({
+			container: "my-container",
+			key: "my-key",
+			value: "my-value",
+		});
+
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/custom-objects",
+			payload: draft,
+		});
+
+		expect(response.statusCode).toBe(201);
 
-		expect(response.status).toBe(201);
-		const customObject = response.body;
+		const customObject = response.json();
 		expect(customObject.container).toBe("my-container");
 		expect(customObject.key).toBe("my-key");
 		expect(customObject.value).toBe("my-value");
@@ -26,19 +32,16 @@ describe("CustomObject create", () => {
 
 describe("CustomObject retrieve", () => {
 	const ctMock = new CommercetoolsMock();
+	const customObjectDraft = customObjectDraftFactory(ctMock);
 	let customObject: CustomObject;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/custom-objects")
-			.send({
-				container: "my-container",
-				key: "my-key",
-				value: "my-value",
-			});
+		customObject = await customObjectDraft.create({
+			container: "my-container",
+			key: "my-key",
+			value: "my-value",
+		});
 
-		expect(response.status).toBe(201);
-		customObject = response.body;
 		expect(customObject.container).toBe("my-container");
 		expect(customObject.key).toBe("my-key");
 		expect(customObject.value).toBe("my-value");
@@ -48,40 +51,44 @@ describe("CustomObject retrieve", () => {
 	});
 
 	test("exists", async () => {
-		const response = await supertest(ctMock.app)
-			.head("/dummy/custom-objects/my-container/my-key")
-			.send();
+		const response = await ctMock.app.inject({
+			method: "HEAD",
+			url: "/dummy/custom-objects/my-container/my-key",
+		});
 
-		expect(response.status).toBe(200);
+		expect(response.statusCode).toBe(200);
 	});
 
 	test("non-existent", async () => {
-		const response = await supertest(ctMock.app)
-			.head("/dummy/custom-objects/invalid-container/invalid")
-			.send();
+		const response = await ctMock.app.inject({
+			method: "HEAD",
+			url: "/dummy/custom-objects/invalid-container/invalid",
+		});
 
-		expect(response.status).toBe(404);
+		expect(response.statusCode).toBe(404);
 	});
 
 	test("get", async () => {
-		const response = await supertest(ctMock.app)
-			.get("/dummy/custom-objects/my-container/my-key")
-			.send();
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/custom-objects/my-container/my-key",
+		});
 
-		expect(response.status).toBe(200);
-		const customObject = response.body;
-		expect(customObject.container).toBe("my-container");
-		expect(customObject.key).toBe("my-key");
-		expect(customObject.value).toBe("my-value");
+		expect(response.statusCode).toBe(200);
+		const result = response.json();
+		expect(result.container).toBe("my-container");
+		expect(result.key).toBe("my-key");
+		expect(result.value).toBe("my-value");
 	});
 
 	test("query with container", async () => {
-		const response = await supertest(ctMock.app)
-			.get("/dummy/custom-objects/my-container")
-			.send();
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/custom-objects/my-container",
+		});
 
-		expect(response.status).toBe(200);
-		const customObjects = response.body;
+		expect(response.statusCode).toBe(200);
+		const customObjects = response.json();
 		expect(customObjects).toMatchObject({
 			results: [
 				{
@@ -95,29 +102,33 @@ describe("CustomObject retrieve", () => {
 	});
 
 	test("Update match current (no conflict)", async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/custom-objects")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/custom-objects",
+			payload: {
 				container: "my-container",
 				key: "my-key",
 				value: "my-value",
-			});
+			},
+		});
 
-		expect(response.status).toBe(201);
+		expect(response.statusCode).toBe(201);
 	});
 
 	test("New with version (errors)", async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/custom-objects")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/custom-objects",
+			payload: {
 				container: "my-new-container",
 				key: "my-new-key",
 				value: "my-value",
 				version: 2,
-			});
+			},
+		});
 
-		expect(response.status).toBe(400);
-		expect(response.body).toStrictEqual({
+		expect(response.statusCode).toBe(400);
+		expect(response.json()).toStrictEqual({
 			statusCode: 400,
 			message: "version on create must be 0",
 			errors: [
@@ -130,17 +141,19 @@ describe("CustomObject retrieve", () => {
 	});
 
 	test("Update match current with version (conflict)", async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/custom-objects")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/custom-objects",
+			payload: {
 				container: "my-container",
 				key: "my-key",
 				value: "my-value",
 				version: 2,
-			});
+			},
+		});
 
-		expect(response.status).toBe(409);
-		expect(response.body).toStrictEqual({
+		expect(response.statusCode).toBe(409);
+		expect(response.json()).toStrictEqual({
 			statusCode: 409,
 			message: `Object ${customObject.id} has a different version than expected. Expected: 2 - Actual: 1.`,
 			errors: [
@@ -154,7 +167,7 @@ describe("CustomObject retrieve", () => {
 	});
 
 	test("can use the add function with the custom object name", async () => {
-		ctMock.project("dummy").add("key-value-document", {
+		ctMock.project("dummy").unsafeAdd("key-value-document", {
 			...getBaseResourceProperties(),
 			container: "my-container",
 			key: "my-key",
@@ -162,24 +175,27 @@ describe("CustomObject retrieve", () => {
 			version: 2,
 		});
 
-		const response = await supertest(ctMock.app)
-			.get("/dummy/custom-objects/my-container/my-key")
-			.send();
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/custom-objects/my-container/my-key",
+		});
 
-		expect(response.status).toEqual(200);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toEqual(200);
+		expect(response.json()).toEqual({
 			container: "my-container",
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			id: expect.anything(),
 			key: "my-key",
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			value: "my-value",
 			version: 1,
 		});
 	});
 
 	test("update with container and key", async () => {
-		ctMock.project("dummy").add("key-value-document", {
+		ctMock.project("dummy").unsafeAdd("key-value-document", {
 			...getBaseResourceProperties(),
 			container: "my-other-container",
 			key: "my-key",
@@ -187,44 +203,52 @@ describe("CustomObject retrieve", () => {
 			version: 2,
 		});
 
-		const response = await supertest(ctMock.app)
-			.post("/dummy/custom-objects/my-other-container/my-key")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/custom-objects/my-other-container/my-key",
+			payload: {
 				value: "new-value",
-			});
+			},
+		});
 
-		expect(response.status).toEqual(200);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toEqual(200);
+		expect(response.json()).toEqual({
 			container: "my-other-container",
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			id: expect.anything(),
 			key: "my-key",
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			value: "new-value",
 			version: 3,
 		});
 	});
 
 	test("delete with container and key", async () => {
-		const response = await supertest(ctMock.app)
-			.delete("/dummy/custom-objects/my-container/my-key")
-			.send();
+		const response = await ctMock.app.inject({
+			method: "DELETE",
+			url: "/dummy/custom-objects/my-container/my-key",
+		});
 
-		expect(response.status).toEqual(200);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toEqual(200);
+		expect(response.json()).toEqual({
 			container: "my-container",
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			id: expect.anything(),
 			key: "my-key",
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			value: "my-value",
 			version: 1,
 		});
 
-		const fetchRes = await supertest(ctMock.app)
-			.get("/dummy/custom-objects/my-container/my-key")
-			.send();
+		const fetchRes = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/custom-objects/my-container/my-key",
+		});
 
-		expect(fetchRes.status).toEqual(404);
+		expect(fetchRes.statusCode).toEqual(404);
 	});
 });

package/src/services/custom-object.ts

@@ -1,5 +1,9 @@
-import type { CustomObjectDraft } from "@commercetools/platform-sdk";
-import type { Request, Response, Router } from "express";
+import type {
+	CustomObjectDraft,
+	ResourceNotFoundError,
+} from "@commercetools/platform-sdk";
+import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import type { CustomObjectRepository } from "../repositories/custom-object.ts";
 import { getRepositoryContext } from "../repositories/helpers.ts";
 import AbstractService from "./abstract.ts";
@@ -7,7 +11,7 @@ import AbstractService from "./abstract.ts";
 export class CustomObjectService extends AbstractService {
 	public repository: CustomObjectRepository;
 
-	constructor(parent: Router, repository: CustomObjectRepository) {
+	constructor(parent: FastifyInstance, repository: CustomObjectRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -16,76 +20,140 @@ export class CustomObjectService extends AbstractService {
 		return "custom-objects";
 	}
 
-	extraRoutes(router: Router) {
-		router.get("/:container", this.getWithContainer.bind(this));
-		router.get("/:container/:key", this.getWithContainerAndKey.bind(this));
-		router.post("/:container/:key", this.createWithContainerAndKey.bind(this));
-		router.delete(
-			"/:container/:key",
-			this.deleteWithContainerAndKey.bind(this),
+	registerRoutes(parent: FastifyInstance) {
+		const basePath = this.getBasePath();
+		parent.register(
+			(instance, opts, done) => {
+				// Custom object specific routes
+				instance.get(
+					"/:container/:key",
+					this.getWithContainerAndKey.bind(this),
+				);
+				instance.post(
+					"/:container/:key",
+					this.createWithContainerAndKey.bind(this),
+				);
+				instance.delete(
+					"/:container/:key",
+					this.deleteWithContainerAndKey.bind(this),
+				);
+
+				// Standard routes, but use /:container instead of /:id for GET
+				// to avoid duplicate parametric route conflict in Fastify.
+				// In Express, /:container was registered first and shadowed /:id.
+				instance.get("/", this.get.bind(this));
+				instance.get("/key=:key", this.getWithKey.bind(this));
+				instance.get("/:container", this.getWithContainer.bind(this));
+
+				instance.delete("/key=:key", this.deleteWithKey.bind(this));
+				instance.delete("/:id", this.deleteWithId.bind(this));
+
+				instance.post("/", this.post.bind(this));
+				instance.post("/key=:key", this.postWithKey.bind(this));
+				instance.post("/:id", this.postWithId.bind(this));
+
+				done();
+			},
+			{ prefix: `/${basePath}` },
 		);
 	}
 
-	getWithContainer(request: Request, response: Response) {
-		const limit = this._parseParam(request.query.limit);
-		const offset = this._parseParam(request.query.offset);
+	async getWithContainer(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Querystring: Record<string, any>;
+		}>,
+		reply: FastifyReply,
+	) {
+		const params = request.params;
+		const query = request.query;
+		const limit = this._parseParam(query.limit);
+		const offset = this._parseParam(query.offset);
 
-		const result = this.repository.queryWithContainer(
+		const result = await this.repository.queryWithContainer(
 			getRepositoryContext(request),
-			request.params.container,
+			params.container,
 			{
-				expand: this._parseParam(request.query.expand),
-				where: this._parseParam(request.query.where),
+				expand: this._parseParam(query.expand),
+				where: this._parseParam(query.where),
 				limit: limit !== undefined ? Number(limit) : undefined,
 				offset: offset !== undefined ? Number(offset) : undefined,
 			},
 		);
 
-		response.status(200).send(result);
+		return reply.status(200).send(result);
 	}
 
-	getWithContainerAndKey(request: Request, response: Response) {
-		const result = this.repository.getWithContainerAndKey(
+	async getWithContainerAndKey(
+		request: FastifyRequest<{ Params: Record<string, string> }>,
+		reply: FastifyReply,
+	) {
+		const params = request.params;
+		const result = await this.repository.getWithContainerAndKey(
 			getRepositoryContext(request),
-			request.params.container,
-			request.params.key,
+			params.container,
+			params.key,
 		);
 
 		if (!result) {
-			response.status(404).send({ statusCode: 404 });
-			return;
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: `The CustomObject with container '${params.container}' and key '${params.key}' was not found.`,
+				},
+				404,
+			);
 		}
-		response.status(200).send(result);
+		return reply.status(200).send(result);
 	}
 
-	createWithContainerAndKey(request: Request, response: Response) {
+	async createWithContainerAndKey(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: CustomObjectDraft;
+		}>,
+		reply: FastifyReply,
+	) {
+		const params = request.params;
 		const draft: CustomObjectDraft = {
 			...request.body,
-			key: request.params.key,
-			container: request.params.container,
+			key: params.key,
+			container: params.container,
 		};
 
-		const result = this.repository.create(getRepositoryContext(request), draft);
-		response.status(200).send(result);
+		const result = await this.repository.create(
+			getRepositoryContext(request),
+			draft,
+		);
+		return reply.status(200).send(result);
 	}
 
-	deleteWithContainerAndKey(request: Request, response: Response) {
-		const current = this.repository.getWithContainerAndKey(
+	async deleteWithContainerAndKey(
+		request: FastifyRequest<{ Params: Record<string, string> }>,
+		reply: FastifyReply,
+	) {
+		const params = request.params;
+		const current = await this.repository.getWithContainerAndKey(
 			getRepositoryContext(request),
-			request.params.container,
-			request.params.key,
+			params.container,
+			params.key,
 		);
 
 		if (!current) {
-			response.status(404).send({ statusCode: 404 });
-			return;
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: `The CustomObject with container '${params.container}' and key '${params.key}' was not found.`,
+				},
+				404,
+			);
 		}
 
-		const result = this.repository.delete(
+		const result = await this.repository.delete(
 			getRepositoryContext(request),
 			current.id,
 		);
 
-		response.status(200).send(result);
+		return reply.status(200).send(result);
 	}
 }

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

@@ -1,85 +1,80 @@
-import type { CustomerGroupDraft } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import { customerGroupDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("CustomerGroup", () => {
+	const customerGroupDraft = customerGroupDraftFactory(ctMock);
+
 	test("Create customer group", async () => {
-		const draft: CustomerGroupDraft = {
+		const draft = customerGroupDraft.build({
 			key: "premium-customers",
 			groupName: "Premium Customers",
-		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/customer-groups")
-			.send(draft);
+		});
 
-		expect(response.status).toBe(201);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/customer-groups",
+			payload: draft,
+		});
 
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual({
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			id: expect.anything(),
 			key: "premium-customers",
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			name: "Premium Customers",
 			version: 1,
 		});
 	});
 
 	test("Get customer group", async () => {
-		const draft: CustomerGroupDraft = {
+		const customerGroup = await customerGroupDraft.create({
 			key: "test-group",
 			groupName: "Test Group",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/customer-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/customer-groups/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/customer-groups/${customerGroup.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(customerGroup);
 	});
 
 	test("Get customer group by key", async () => {
-		const draft: CustomerGroupDraft = {
+		const customerGroup = await customerGroupDraft.create({
 			key: "key-group",
 			groupName: "Key Group",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/customer-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			"/dummy/customer-groups/key=key-group",
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/customer-groups/key=key-group",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(customerGroup);
 	});
 
 	test("Query customer groups", async () => {
-		const draft: CustomerGroupDraft = {
+		const customerGroup = await customerGroupDraft.create({
 			key: "query-group",
 			groupName: "Query Group",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/customer-groups")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get("/dummy/customer-groups");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/customer-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(customerGroup);
 	});
 });

package/src/services/customer-group.ts

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