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

package/src/services/as-associate-cart.ts

@@ -1,11 +1,11 @@
-import { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { CartRepository } from "../repositories/cart/index.ts";
 import AbstractService from "./abstract.ts";
 
 export class AsAssociateCartService extends AbstractService {
 	public repository: CartRepository;
 
-	constructor(parent: Router, repository: CartRepository) {
+	constructor(parent: FastifyInstance, repository: CartRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -14,20 +14,23 @@ export class AsAssociateCartService extends AbstractService {
 		return "carts";
 	}
 
-	registerRoutes(parent: Router) {
+	registerRoutes(parent: FastifyInstance) {
 		const basePath = this.getBasePath();
-		const router = Router({ mergeParams: true });
+		parent.register(
+			(instance, opts, done) => {
+				this.extraRoutes(instance);
 
-		this.extraRoutes(router);
+				instance.get("/", this.get.bind(this));
+				instance.get("/:id", this.getWithId.bind(this));
 
-		router.get("/", this.get.bind(this));
-		router.get("/:id", this.getWithId.bind(this));
+				instance.delete("/:id", this.deleteWithId.bind(this));
 
-		router.delete("/:id", this.deleteWithId.bind(this));
+				instance.post("/", this.post.bind(this));
+				instance.post("/:id", this.postWithId.bind(this));
 
-		router.post("/", this.post.bind(this));
-		router.post("/:id", this.postWithId.bind(this));
-
-		parent.use(`/${basePath}`, router);
+				done();
+			},
+			{ prefix: `/${basePath}` },
+		);
 	}
 }

package/src/services/as-associate-order.test.ts

@@ -1,64 +1,57 @@
 import assert from "node:assert";
 import type { Order } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { cartDraftFactory, orderDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 describe("Order Query", () => {
 	const ctMock = new CommercetoolsMock();
+	const cartFactory = cartDraftFactory(ctMock);
+	const orderFactory = orderDraftFactory(ctMock);
 	let order: Order | undefined;
 	const projectKey = "dummy";
 	const customerId = "5fac8fca-2484-4b14-a1d1-cfdce2f8d3c4";
 	const businessUnitKey = "business-unit";
 
 	beforeEach(async () => {
-		let response = await supertest(ctMock.app)
-			.post(
-				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/carts`,
-			)
-			.send({
-				currency: "EUR",
-				custom: {
-					type: {
-						key: "my-cart",
-					},
-					fields: {
-						description: "example description",
-					},
+		const cart = await cartFactory.create({
+			currency: "EUR",
+			custom: {
+				type: {
+					key: "my-cart",
 				},
-			});
-		expect(response.status).toBe(201);
-		const cart = response.body;
-
-		response = await supertest(ctMock.app)
-			.post(
-				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/orders`,
-			)
-			.send({
-				cart: {
-					typeId: "cart",
-					id: cart.id,
+				fields: {
+					description: "example description",
 				},
-				orderNumber: "foobar",
-			});
-		expect(response.status).toBe(201);
-		order = response.body;
+			},
+		});
+
+		order = await orderFactory.create({
+			cart: {
+				typeId: "cart",
+				id: cart.id,
+			},
+			version: cart.version,
+			orderNumber: "foobar",
+		});
 	});
 
-	afterEach(() => {
-		ctMock.clear();
+	afterEach(async () => {
+		await ctMock.clear();
 	});
 
 	test("no filter", async () => {
 		assert(order, "order not created");
 
-		const response = await supertest(ctMock.app).get(
-			`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/orders`,
-		);
-		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: `/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/orders`,
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.count).toBe(1);
+		expect(body.total).toBe(1);
+		expect(body.offset).toBe(0);
+		expect(body.limit).toBe(20);
 	});
 });

package/src/services/as-associate-order.ts

@@ -1,11 +1,11 @@
-import { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { MyOrderRepository } from "../repositories/my-order.ts";
 import AbstractService from "./abstract.ts";
 
 export class AsAssociateOrderService extends AbstractService {
 	public repository: MyOrderRepository;
 
-	constructor(parent: Router, repository: MyOrderRepository) {
+	constructor(parent: FastifyInstance, repository: MyOrderRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -14,20 +14,23 @@ export class AsAssociateOrderService extends AbstractService {
 		return "orders";
 	}
 
-	registerRoutes(parent: Router) {
+	registerRoutes(parent: FastifyInstance) {
 		const basePath = this.getBasePath();
-		const router = Router({ mergeParams: true });
+		parent.register(
+			(instance, opts, done) => {
+				this.extraRoutes(instance);
 
-		this.extraRoutes(router);
+				instance.get("/", this.get.bind(this));
+				instance.get("/:id", this.getWithId.bind(this));
 
-		router.get("/", this.get.bind(this));
-		router.get("/:id", this.getWithId.bind(this));
+				instance.delete("/:id", this.deleteWithId.bind(this));
 
-		router.delete("/:id", this.deleteWithId.bind(this));
+				instance.post("/", this.post.bind(this));
+				instance.post("/:id", this.postWithId.bind(this));
 
-		router.post("/", this.post.bind(this));
-		router.post("/:id", this.postWithId.bind(this));
-
-		parent.use(`/${basePath}`, router);
+				done();
+			},
+			{ prefix: `/${basePath}` },
+		);
 	}
 }

package/src/services/as-associate-quote-request.ts

@@ -1,11 +1,11 @@
-import { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { MyQuoteRequestRepository } from "#src/repositories/my-quote-request.ts";
 import AbstractService from "./abstract.ts";
 
 export class AsAssociateQuoteRequestService extends AbstractService {
 	public repository: MyQuoteRequestRepository;
 
-	constructor(parent: Router, repository: MyQuoteRequestRepository) {
+	constructor(parent: FastifyInstance, repository: MyQuoteRequestRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -14,20 +14,23 @@ export class AsAssociateQuoteRequestService extends AbstractService {
 		return "quote-requests";
 	}
 
-	registerRoutes(parent: Router) {
+	registerRoutes(parent: FastifyInstance) {
 		const basePath = this.getBasePath();
-		const router = Router({ mergeParams: true });
+		parent.register(
+			(instance, opts, done) => {
+				this.extraRoutes(instance);
 
-		this.extraRoutes(router);
+				instance.get("/", this.get.bind(this));
+				instance.get("/:id", this.getWithId.bind(this));
 
-		router.get("/", this.get.bind(this));
-		router.get("/:id", this.getWithId.bind(this));
+				instance.delete("/:id", this.deleteWithId.bind(this));
 
-		router.delete("/:id", this.deleteWithId.bind(this));
+				instance.post("/", this.post.bind(this));
+				instance.post("/:id", this.postWithId.bind(this));
 
-		router.post("/", this.post.bind(this));
-		router.post("/:id", this.postWithId.bind(this));
-
-		parent.use(`/${basePath}`, router);
+				done();
+			},
+			{ prefix: `/${basePath}` },
+		);
 	}
 }

package/src/services/as-associate-shopping-list.test.ts

@@ -1,5 +1,5 @@
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import { shoppingListDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
@@ -8,51 +8,41 @@ const customerId = "5fac8fca-2484-4b14-a1d1-cfdce2f8d3c4";
 const businessUnitKey = "test-business-unit";
 
 describe("AsAssociateShoppingList", () => {
+	const factory = shoppingListDraftFactory(ctMock);
+
 	test("Create shopping list", async () => {
-		const draft = {
+		const shoppingList = await factory.create({
 			name: { en: "My list" },
-		};
-		const response = await supertest(ctMock.app)
-			.post(
-				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/shopping-lists`,
-			)
-			.send(draft);
-
-		expect(response.status).toBe(201);
-		expect(response.body.id).toBeDefined();
+		});
+
+		expect(shoppingList.id).toBeDefined();
 	});
 
 	test("Get shopping list", async () => {
-		const createResponse = await supertest(ctMock.app)
-			.post(
-				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/shopping-lists`,
-			)
-			.send({ name: { en: "Groceries" } });
+		const shoppingList = await factory.create({
+			name: { en: "Groceries" },
+		});
 
-		expect(createResponse.status).toBe(201);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/shopping-lists/${shoppingList.id}`,
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/shopping-lists/${createResponse.body.id}`,
-		);
-
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(shoppingList);
 	});
 
 	test("Query shopping lists", async () => {
-		const createResponse = await supertest(ctMock.app)
-			.post(
-				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/shopping-lists`,
-			)
-			.send({ name: { en: "Errands" } });
-
-		expect(createResponse.status).toBe(201);
+		await factory.create({
+			name: { en: "Errands" },
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/shopping-lists`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/shopping-lists`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.count).toBeGreaterThan(0);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().count).toBeGreaterThan(0);
 	});
 });

package/src/services/as-associate-shopping-list.ts

@@ -1,11 +1,11 @@
-import { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { ShoppingListRepository } from "#src/repositories/shopping-list/index.ts";
 import AbstractService from "./abstract.ts";
 
 export class AsAssociateShoppingListService extends AbstractService {
 	public repository: ShoppingListRepository;
 
-	constructor(parent: Router, repository: ShoppingListRepository) {
+	constructor(parent: FastifyInstance, repository: ShoppingListRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -14,20 +14,23 @@ export class AsAssociateShoppingListService extends AbstractService {
 		return "shopping-lists";
 	}
 
-	registerRoutes(parent: Router) {
+	registerRoutes(parent: FastifyInstance) {
 		const basePath = this.getBasePath();
-		const router = Router({ mergeParams: true });
+		parent.register(
+			(instance, opts, done) => {
+				this.extraRoutes(instance);
 
-		this.extraRoutes(router);
+				instance.get("/", this.get.bind(this));
+				instance.get("/:id", this.getWithId.bind(this));
 
-		router.get("/", this.get.bind(this));
-		router.get("/:id", this.getWithId.bind(this));
+				instance.delete("/:id", this.deleteWithId.bind(this));
 
-		router.delete("/:id", this.deleteWithId.bind(this));
+				instance.post("/", this.post.bind(this));
+				instance.post("/:id", this.postWithId.bind(this));
 
-		router.post("/", this.post.bind(this));
-		router.post("/:id", this.postWithId.bind(this));
-
-		parent.use(`/${basePath}`, router);
+				done();
+			},
+			{ prefix: `/${basePath}` },
+		);
 	}
 }

package/src/services/as-associate.test.ts

@@ -1,5 +1,5 @@
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import { cartDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
@@ -8,27 +8,33 @@ const customerId = "5fac8fca-2484-4b14-a1d1-cfdce2f8d3c4";
 const businessUnitKey = "test-business-unit";
 
 describe("AsAssociate", () => {
+	const cartFactory = cartDraftFactory(ctMock);
+
 	test("Access as-associate service routes", async () => {
 		// Test that the as-associate service sets up routes correctly by testing cart endpoint
-		const response = await supertest(ctMock.app).get(
-			`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/carts`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/carts`,
+		});
 
 		// Should return 200 with empty results or 404 if not configured
-		expect([200, 404]).toContain(response.status);
+		expect([200, 404]).toContain(response.statusCode);
 	});
 
 	test("Create cart via as-associate", async () => {
-		const draft = {
+		const draft = cartFactory.build({
 			currency: "EUR",
-		};
-		const response = await supertest(ctMock.app)
-			.post(
-				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/carts`,
-			)
-			.send(draft);
-
-		expect(response.status).toBe(201);
-		expect(response.body.id).toBeDefined();
+		});
+
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/carts`,
+			payload: draft,
+		});
+
+		expect(response.statusCode).toBe(201);
+
+		const cart = response.json();
+		expect(cart.id).toBeDefined();
 	});
 });

package/src/services/as-associate.ts

@@ -1,4 +1,4 @@
-import { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type {
 	AsAssociateCartRepository,
 	AsAssociateOrderRepository,
@@ -18,33 +18,34 @@ type Repositories = {
 };
 
 export class AsAssociateService {
-	router: Router;
-
-	subServices: {
+	subServices!: {
 		cart: AsAssociateCartService;
 		order: AsAssociateOrderService;
 		"quote-request": AsAssociateQuoteRequestService;
 		"shopping-list": AsAssociateShoppingListService;
 	};
 
-	constructor(parent: Router, repositories: Repositories) {
-		this.router = Router({ mergeParams: true });
-
-		this.subServices = {
-			order: new AsAssociateOrderService(this.router, repositories.order),
-			cart: new AsAssociateCartService(this.router, repositories.cart),
-			"quote-request": new AsAssociateQuoteRequestService(
-				this.router,
-				repositories["quote-request"],
-			),
-			"shopping-list": new AsAssociateShoppingListService(
-				this.router,
-				repositories["shopping-list"],
-			),
-		};
-		parent.use(
-			"/as-associate/:associateId/in-business-unit/key=:businessUnitId",
-			this.router,
+	constructor(parent: FastifyInstance, repositories: Repositories) {
+		parent.register(
+			(instance, opts, done) => {
+				this.subServices = {
+					order: new AsAssociateOrderService(instance, repositories.order),
+					cart: new AsAssociateCartService(instance, repositories.cart),
+					"quote-request": new AsAssociateQuoteRequestService(
+						instance,
+						repositories["quote-request"],
+					),
+					"shopping-list": new AsAssociateShoppingListService(
+						instance,
+						repositories["shopping-list"],
+					),
+				};
+				done();
+			},
+			{
+				prefix:
+					"/as-associate/:associateId/in-business-unit/key=:businessUnitId",
+			},
 		);
 	}
 }

package/src/services/associate-roles.test.ts

@@ -1,41 +1,35 @@
 import type { AssociateRole } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { associateRoleDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../ctMock.ts";
 
 describe("Associate roles query", () => {
 	const ctMock = new CommercetoolsMock();
+	const associateRoleDraft = associateRoleDraftFactory(ctMock);
 	let associateRole: AssociateRole | undefined;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/associate-roles")
-			.send({
-				name: "example-role",
-				buyerAssignable: false,
-				key: "example-role-associate-role",
-				permissions: ["ViewMyQuotes", "ViewMyOrders", "ViewMyCarts"],
-			});
-
-		expect(response.status).toBe(201);
-
-		associateRole = response.body as AssociateRole;
+		associateRole = await associateRoleDraft.create({
+			name: "example-role",
+			key: "example-role-associate-role",
+		});
 	});
 
-	afterEach(() => {
-		ctMock.clear();
+	afterEach(async () => {
+		await ctMock.clear();
 	});
 
 	test("no filter", async () => {
-		const response = await supertest(ctMock.app)
-			.get("/dummy/associate-roles")
-			.query("{}")
-			.send();
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/associate-roles?{}",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.count).toBe(1);
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.count).toBe(1);
 
-		associateRole = response.body.results[0] as AssociateRole;
+		associateRole = body.results[0] as AssociateRole;
 
 		expect(associateRole.key).toBe("example-role-associate-role");
 	});

package/src/services/associate-roles.ts

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