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

package/src/services/my-business-unit.test.ts

@@ -1,199 +1,169 @@
-import type { BusinessUnitDraft } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, describe, expect, test } from "vitest";
+import { businessUnitDraftFactory } from "#src/testing/business-unit.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("MyBusinessUnit", () => {
-	afterEach(() => {
-		ctMock.clear();
+	const businessUnitFactory = businessUnitDraftFactory(ctMock);
+
+	afterEach(async () => {
+		await ctMock.clear();
 	});
 
 	test("Get my business units", async () => {
-		// First create a business unit
-		const draft: BusinessUnitDraft = {
+		await businessUnitFactory.create({
 			key: "my-business-unit",
 			unitType: "Company",
 			name: "My Business Unit",
 			contactEmail: "contact@example.com",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/business-units")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			"/dummy/me/business-units/",
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/me/business-units",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.count).toBeGreaterThanOrEqual(0);
-		expect(response.body.results).toBeDefined();
+		expect(response.statusCode).toBe(200);
+		expect(response.json().count).toBeGreaterThanOrEqual(0);
+		expect(response.json().results).toBeDefined();
 	});
 
 	test("Get my business unit by ID", async () => {
-		// First create a business unit
-		const draft: BusinessUnitDraft = {
+		const businessUnit = await businessUnitFactory.create({
 			key: "my-business-unit",
 			unitType: "Company",
 			name: "My Business Unit",
 			contactEmail: "contact@example.com",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/business-units")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/me/business-units/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/me/business-units/${businessUnit.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(businessUnit);
 	});
 
 	test("Get my business unit by key", async () => {
-		// First create a business unit
-		const draft: BusinessUnitDraft = {
+		const businessUnit = await businessUnitFactory.create({
 			key: "my-business-unit",
 			unitType: "Company",
 			name: "My Business Unit",
 			contactEmail: "contact@example.com",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/business-units")
-			.send(draft);
+		});
 
-		expect(createResponse.status).toBe(201);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/me/business-units/key=${businessUnit.key}`,
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/me/business-units/key=${createResponse.body.key}`,
-		);
-
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(businessUnit);
 	});
 
 	test("Delete my business unit", async () => {
-		// First create a business unit
-		const draft: BusinessUnitDraft = {
+		const businessUnit = await businessUnitFactory.create({
 			key: "my-business-unit",
 			unitType: "Company",
 			name: "My Business Unit",
 			contactEmail: "contact@example.com",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/business-units")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
 		// Now delete the business unit
-		const deleteResponse = await supertest(ctMock.app).delete(
-			`/dummy/me/business-units/${createResponse.body.id}`,
-		);
+		const deleteResponse = await ctMock.app.inject({
+			method: "DELETE",
+			url: `/dummy/me/business-units/${businessUnit.id}`,
+		});
 
-		expect(deleteResponse.status).toBe(200);
-		expect(deleteResponse.body).toEqual(createResponse.body);
+		expect(deleteResponse.statusCode).toBe(200);
+		expect(deleteResponse.json()).toEqual(businessUnit);
 
 		// Verify that the business unit is deleted
-		const newResponse = await supertest(ctMock.app).get(
-			`/dummy/me/business-units/${createResponse.body.id}`,
-		);
-		expect(newResponse.status).toBe(404);
+		const newResponse = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/me/business-units/${businessUnit.id}`,
+		});
+		expect(newResponse.statusCode).toBe(404);
 	});
 
 	test("Delete my business unit by key", async () => {
-		// First create a business unit
-		const draft: BusinessUnitDraft = {
+		const businessUnit = await businessUnitFactory.create({
 			key: "my-business-unit",
 			unitType: "Company",
 			name: "My Business Unit",
 			contactEmail: "contact@example.com",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/business-units")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
 		// Now delete the business unit
-		const deleteResponse = await supertest(ctMock.app).delete(
-			`/dummy/me/business-units/key=${createResponse.body.key}`,
-		);
+		const deleteResponse = await ctMock.app.inject({
+			method: "DELETE",
+			url: `/dummy/me/business-units/key=${businessUnit.key}`,
+		});
 
-		expect(deleteResponse.status).toBe(200);
-		expect(deleteResponse.body).toEqual(createResponse.body);
+		expect(deleteResponse.statusCode).toBe(200);
+		expect(deleteResponse.json()).toEqual(businessUnit);
 
 		// Verify that the business unit is deleted
-		const newResponse = await supertest(ctMock.app).get(
-			`/dummy/me/business-units/key=${createResponse.body.key}`,
-		);
-		expect(newResponse.status).toBe(404);
+		const newResponse = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/me/business-units/key=${businessUnit.key}`,
+		});
+		expect(newResponse.statusCode).toBe(404);
 	});
 
 	test("Update my business unit", async () => {
-		// First create a business unit
-		const draft: BusinessUnitDraft = {
+		const businessUnit = await businessUnitFactory.create({
 			key: "my-business-unit",
 			unitType: "Company",
 			name: "My Business Unit",
 			contactEmail: "contact@example.com",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/business-units")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
-
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/me/business-units/${createResponse.body.id}`)
-			.send({
-				id: createResponse.body.id,
-				version: createResponse.body.version,
+		});
+
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/me/business-units/${businessUnit.id}`,
+			payload: {
+				id: businessUnit.id,
+				version: businessUnit.version,
 				actions: [
 					{
 						action: "changeName",
 						name: "Updated Business Unit Name",
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.name).toBe("Updated Business Unit Name");
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().name).toBe("Updated Business Unit Name");
 	});
 
 	test("Update my business unit by key", async () => {
-		// First create a business unit
-		const draft: BusinessUnitDraft = {
+		const businessUnit = await businessUnitFactory.create({
 			key: "my-business-unit",
 			unitType: "Company",
 			name: "My Business Unit",
 			contactEmail: "contact@example.com",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/business-units")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
-
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/me/business-units/key=${createResponse.body.key}`)
-			.send({
-				id: createResponse.body.id,
-				version: createResponse.body.version,
+		});
+
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/me/business-units/key=${businessUnit.key}`,
+			payload: {
+				id: businessUnit.id,
+				version: businessUnit.version,
 				actions: [
 					{
 						action: "changeName",
 						name: "Updated Business Unit Name",
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.name).toBe("Updated Business Unit Name");
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().name).toBe("Updated Business Unit Name");
 	});
 });

package/src/services/my-business-unit.ts

@@ -1,11 +1,11 @@
-import { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { BusinessUnitRepository } from "#src/repositories/business-unit.ts";
 import AbstractService from "./abstract.ts";
 
 export class MyBusinessUnitService extends AbstractService {
 	public repository: BusinessUnitRepository;
 
-	constructor(parent: Router, repository: BusinessUnitRepository) {
+	constructor(parent: FastifyInstance, repository: BusinessUnitRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -14,24 +14,30 @@ export class MyBusinessUnitService extends AbstractService {
 		return "me";
 	}
 
-	registerRoutes(parent: Router) {
+	registerRoutes(parent: FastifyInstance) {
 		// Overwrite this function to be able to handle /me/business-units path.
 		const basePath = this.getBasePath();
-		const router = Router({ mergeParams: true });
-
-		this.extraRoutes(router);
-
-		router.get("/business-units/", this.get.bind(this));
-		router.get("/business-units/key=:key", this.getWithKey.bind(this));
-		router.get("/business-units/:id", this.getWithId.bind(this));
-
-		router.delete("/business-units/key=:key", this.deleteWithKey.bind(this));
-		router.delete("/business-units/:id", this.deleteWithId.bind(this));
-
-		router.post("/business-units/", this.post.bind(this));
-		router.post("/business-units/key=:key", this.postWithKey.bind(this));
-		router.post("/business-units/:id", this.postWithId.bind(this));
-
-		parent.use(`/${basePath}`, router);
+		parent.register(
+			(instance, opts, done) => {
+				this.extraRoutes(instance);
+
+				instance.get("/business-units", this.get.bind(this));
+				instance.get("/business-units/key=:key", this.getWithKey.bind(this));
+				instance.get("/business-units/:id", this.getWithId.bind(this));
+
+				instance.delete(
+					"/business-units/key=:key",
+					this.deleteWithKey.bind(this),
+				);
+				instance.delete("/business-units/:id", this.deleteWithId.bind(this));
+
+				instance.post("/business-units", this.post.bind(this));
+				instance.post("/business-units/key=:key", this.postWithKey.bind(this));
+				instance.post("/business-units/:id", this.postWithId.bind(this));
+
+				done();
+			},
+			{ prefix: `/${basePath}` },
+		);
 	}
 }

package/src/services/my-cart.test.ts

@@ -1,42 +1,46 @@
-import type { Cart, MyCartDraft } from "@commercetools/platform-sdk";
-import supertest from "supertest";
+import type { Cart } from "@commercetools/platform-sdk";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { cartDraftFactory, typeDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("MyCart", () => {
+	const cartDraft = cartDraftFactory(ctMock);
+	const typeDraft = typeDraftFactory(ctMock);
+
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "custom-payment",
-				name: {
-					"nl-NL": "custom-payment",
-				},
-				resourceTypeIds: ["payment"],
-			});
-		expect(response.status).toBe(201);
+		await typeDraft.create({
+			key: "custom-payment",
+			name: {
+				"nl-NL": "custom-payment",
+			},
+			resourceTypeIds: ["payment"],
+		});
 	});
 
-	afterEach(() => {
-		ctMock.clear();
+	afterEach(async () => {
+		await ctMock.clear();
 	});
 
 	test("Create my cart", async () => {
-		const draft: MyCartDraft = {
+		const draft = cartDraft.build({
 			currency: "EUR",
-		};
+		});
 
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/carts")
-			.send(draft);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/carts",
+			payload: draft,
+		});
 
-		expect(response.status).toBe(201);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual({
 			id: expect.anything(),
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			version: 1,
 			cartState: "Active",
 			discountCodes: [],
@@ -63,38 +67,39 @@ describe("MyCart", () => {
 	});
 
 	test("Get my cart by ID", async () => {
-		const draft: MyCartDraft = {
+		const cart = await cartDraft.create({
 			currency: "EUR",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/me/carts")
-			.send(draft);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/me/carts/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/me/carts/${cart.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(cart);
 	});
 
 	test("Get my active cart", async () => {
-		const draft: MyCartDraft = {
+		const cart = await cartDraft.create({
 			currency: "EUR",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/me/carts")
-			.send(draft);
+		});
 
-		const response = await supertest(ctMock.app).get("/dummy/me/active-cart");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/me/active-cart",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(cart);
 	});
 
 	test("Get my active cart which doesnt exists", async () => {
-		const response = await supertest(ctMock.app).get("/dummy/me/active-cart");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/me/active-cart",
+		});
 
-		expect(response.status).toBe(404);
+		expect(response.statusCode).toBe(404);
 	});
 });

package/src/services/my-cart.ts

@@ -1,12 +1,13 @@
-import type { Request, Response } from "express";
-import { Router } from "express";
+import type { ResourceNotFoundError } from "@commercetools/platform-sdk";
+import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import type { CartRepository } from "../repositories/cart/index.ts";
 import AbstractService from "./abstract.ts";
 
 export class MyCartService extends AbstractService {
 	public repository: CartRepository;
 
-	constructor(parent: Router, repository: CartRepository) {
+	constructor(parent: FastifyInstance, repository: CartRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -15,40 +16,43 @@ export class MyCartService extends AbstractService {
 		return "me";
 	}
 
-	registerRoutes(parent: Router) {
+	registerRoutes(parent: FastifyInstance) {
 		// Overwrite this function to be able to handle /me/active-cart path.
 		const basePath = this.getBasePath();
-		const router = Router({ mergeParams: true });
+		parent.register(
+			(instance, opts, done) => {
+				this.extraRoutes(instance);
 
-		this.extraRoutes(router);
+				instance.get("/active-cart", this.activeCart.bind(this));
+				instance.get("/carts", this.get.bind(this));
+				instance.get("/carts/:id", this.getWithId.bind(this));
 
-		router.get("/active-cart", this.activeCart.bind(this));
-		router.get("/carts/", this.get.bind(this));
-		router.get("/carts/:id", this.getWithId.bind(this));
+				instance.delete("/carts/:id", this.deleteWithId.bind(this));
 
-		router.delete("/carts/:id", this.deleteWithId.bind(this));
+				instance.post("/carts", this.post.bind(this));
+				instance.post("/carts/:id", this.postWithId.bind(this));
 
-		router.post("/carts/", this.post.bind(this));
-		router.post("/carts/:id", this.postWithId.bind(this));
-
-		parent.use(`/${basePath}`, router);
+				done();
+			},
+			{ prefix: `/${basePath}` },
+		);
 	}
 
-	activeCart(request: Request, response: Response) {
-		const resource = this.repository.getActiveCart(request.params.projectKey);
+	async activeCart(
+		request: FastifyRequest<{ Params: Record<string, string> }>,
+		reply: FastifyReply,
+	) {
+		const params = request.params;
+		const resource = await this.repository.getActiveCart(params.projectKey);
 		if (!resource) {
-			response.status(404).send({
-				statusCode: 404,
-				message: "No active cart exists.",
-				errors: [
-					{
-						code: "ResourceNotFound",
-						message: "No active cart exists.",
-					},
-				],
-			});
-			return;
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: "No active cart exists.",
+				},
+				404,
+			);
 		}
-		response.status(200).send(resource);
+		return reply.status(200).send(resource);
 	}
 }