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

package/src/services/recurring-order.test.ts

@@ -1,81 +1,69 @@
-import type {
-	CartDraft,
-	RecurringOrderDraft,
-} from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import { cartDraftFactory } from "#src/testing/cart.ts";
+import { productDraftFactory } from "#src/testing/product.ts";
+import { productTypeDraftFactory } from "#src/testing/product-type.ts";
+import { recurringOrderDraftFactory } from "#src/testing/recurring-order.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("RecurringOrder", () => {
 	const createTestCart = async () => {
-		await supertest(ctMock.app).post("/dummy/product-types").send({
-			key: "test-product-type",
-			name: "Test Product Type",
-			description: "A test product type",
-		});
+		const productType = await productTypeDraftFactory(ctMock).create();
 
-		const productResponse = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send({
-				key: "test-product",
-				name: { en: "Test Product" },
-				productType: {
-					typeId: "product-type",
-					key: "test-product-type",
-				},
-				slug: { en: "test-product" },
-				masterVariant: {
-					id: 1,
-					sku: "test-sku",
-					prices: [
-						{
-							value: {
-								type: "centPrecision",
-								currencyCode: "EUR",
-								centAmount: 1000,
-							},
+		const product = await productDraftFactory(ctMock).create({
+			productType: {
+				typeId: "product-type",
+				id: productType.id,
+			},
+			masterVariant: {
+				sku: "test-sku",
+				prices: [
+					{
+						value: {
+							type: "centPrecision",
+							currencyCode: "EUR",
+							centAmount: 1000,
 						},
-					],
-				},
-				variants: [],
-			});
+					},
+				],
+			},
+			variants: [],
+		});
 
-		const cartDraft: CartDraft = {
+		const cart = await cartDraftFactory(ctMock).create({
 			currency: "EUR",
 			country: "NL",
-		};
-
-		const cartResponse = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send(cartDraft);
+		});
 
-		await supertest(ctMock.app)
-			.post(`/dummy/carts/${cartResponse.body.id}`)
-			.send({
-				version: cartResponse.body.version,
+		await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: cart.version,
 				actions: [
 					{
 						action: "addLineItem",
-						productId: productResponse.body.id,
+						productId: product.id,
 						variantId: 1,
 						quantity: 2,
 					},
 				],
-			});
+			},
+		});
 
-		const updatedCartResponse = await supertest(ctMock.app).get(
-			`/dummy/carts/${cartResponse.body.id}`,
-		);
+		const updatedCartResponse = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/carts/${cart.id}`,
+		});
 
-		return updatedCartResponse.body;
+		return updatedCartResponse.json();
 	};
 
 	test("Create recurring order", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const draft = recurringOrderDraftFactory(ctMock).build({
 			key: "weekly-order",
 			cart: {
 				typeId: "cart",
@@ -84,19 +72,23 @@ describe("RecurringOrder", () => {
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
 			expiresAt: "2025-12-31T23:59:59.000Z",
-		};
+		});
 
-		const response = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/recurring-orders",
+			payload: draft,
+		});
 
-		expect(response.status).toBe(201);
+		expect(response.statusCode).toBe(201);
 
-		expect(response.body).toEqual({
+		expect(response.json()).toEqual({
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			id: expect.anything(),
 			key: "weekly-order",
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			cart: {
 				typeId: "cart",
 				id: cart.id,
@@ -120,7 +112,7 @@ describe("RecurringOrder", () => {
 	test("Get recurring order", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "get-test-order",
 			cart: {
 				typeId: "cart",
@@ -128,26 +120,21 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/recurring-orders/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/recurring-orders/${recurringOrder.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(recurringOrder);
 	});
 
 	test("Get recurring order by key", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "key-test-order",
 			cart: {
 				typeId: "cart",
@@ -155,26 +142,21 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			"/dummy/recurring-orders/key=key-test-order",
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/recurring-orders/key=key-test-order",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(recurringOrder);
 	});
 
 	test("Query recurring orders", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "query-test-order",
 			cart: {
 				typeId: "cart",
@@ -182,25 +164,22 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get("/dummy/recurring-orders");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/recurring-orders",
+		});
 
-		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(recurringOrder);
 	});
 
 	test("Update recurring order - setKey", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "original-key",
 			cart: {
 				typeId: "cart",
@@ -208,35 +187,31 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/recurring-orders/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/recurring-orders/${recurringOrder.id}`,
+			payload: {
+				version: recurringOrder.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 recurring order - setStartsAt", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "starts-at-test",
 			cart: {
 				typeId: "cart",
@@ -244,35 +219,31 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/recurring-orders/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/recurring-orders/${recurringOrder.id}`,
+			payload: {
+				version: recurringOrder.version,
 				actions: [
 					{
 						action: "setStartsAt",
 						startsAt: "2025-02-01T10:00:00.000Z",
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.startsAt).toBe("2025-02-01T10:00:00.000Z");
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().startsAt).toBe("2025-02-01T10:00:00.000Z");
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Update recurring order - setExpiresAt", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "expires-at-test",
 			cart: {
 				typeId: "cart",
@@ -280,35 +251,31 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/recurring-orders/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/recurring-orders/${recurringOrder.id}`,
+			payload: {
+				version: recurringOrder.version,
 				actions: [
 					{
 						action: "setExpiresAt",
 						expiresAt: "2026-01-01T00:00:00.000Z",
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.expiresAt).toBe("2026-01-01T00:00:00.000Z");
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().expiresAt).toBe("2026-01-01T00:00:00.000Z");
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Update recurring order - setRecurringOrderState to paused", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "state-test",
 			cart: {
 				typeId: "cart",
@@ -316,18 +283,13 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/recurring-orders/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/recurring-orders/${recurringOrder.id}`,
+			payload: {
+				version: recurringOrder.version,
 				actions: [
 					{
 						action: "setRecurringOrderState",
@@ -336,17 +298,18 @@ describe("RecurringOrder", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.recurringOrderState).toBe("Paused");
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().recurringOrderState).toBe("Paused");
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Update recurring order - setOrderSkipConfiguration", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "skip-test",
 			cart: {
 				typeId: "cart",
@@ -354,45 +317,41 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const updateResponse = await supertest(ctMock.app)
-			.post(`/dummy/recurring-orders/${createResponse.body.id}`)
-			.send({
-				version: createResponse.body.version,
+		const updateResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/recurring-orders/${recurringOrder.id}`,
+			payload: {
+				version: recurringOrder.version,
 				actions: [
 					{
 						action: "setOrderSkipConfiguration",
-						skipConfiguration: {
+						skipConfigurationInputDraft: {
 							type: "totalSkip",
 							totalToSkip: 2,
 						},
 						updatedExpiresAt: "2025-06-01T00:00:00.000Z",
 					},
 				],
-			});
+			},
+		});
 
-		expect(updateResponse.status).toBe(200);
-		expect(updateResponse.body.skipConfiguration).toEqual({
+		expect(updateResponse.statusCode).toBe(200);
+		expect(updateResponse.json().skipConfiguration).toEqual({
 			type: "totalSkip",
 			totalToSkip: 2,
 			skipped: 0,
 			lastSkippedAt: undefined,
 		});
-		expect(updateResponse.body.expiresAt).toBe("2025-06-01T00:00:00.000Z");
-		expect(updateResponse.body.version).toBe(2);
+		expect(updateResponse.json().expiresAt).toBe("2025-06-01T00:00:00.000Z");
+		expect(updateResponse.json().version).toBe(2);
 	});
 
 	test("Delete recurring order", async () => {
 		const cart = await createTestCart();
 
-		const draft: RecurringOrderDraft = {
+		const recurringOrder = await recurringOrderDraftFactory(ctMock).create({
 			key: "delete-test",
 			cart: {
 				typeId: "cart",
@@ -400,25 +359,21 @@ describe("RecurringOrder", () => {
 			},
 			cartVersion: cart.version,
 			startsAt: "2025-01-01T10:00:00.000Z",
-		};
-
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/recurring-orders")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const deleteResponse = await supertest(ctMock.app)
-			.delete(`/dummy/recurring-orders/${createResponse.body.id}`)
-			.query({ version: createResponse.body.version });
+		const deleteResponse = await ctMock.app.inject({
+			method: "DELETE",
+			url: `/dummy/recurring-orders/${recurringOrder.id}?version=${recurringOrder.version}`,
+		});
 
-		expect(deleteResponse.status).toBe(200);
-		expect(deleteResponse.body).toEqual(createResponse.body);
+		expect(deleteResponse.statusCode).toBe(200);
+		expect(deleteResponse.json()).toEqual(recurringOrder);
 
-		const getResponse = await supertest(ctMock.app).get(
-			`/dummy/recurring-orders/${createResponse.body.id}`,
-		);
+		const getResponse = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/recurring-orders/${recurringOrder.id}`,
+		});
 
-		expect(getResponse.status).toBe(404);
+		expect(getResponse.statusCode).toBe(404);
 	});
 });

package/src/services/recurring-order.ts

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