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

package/src/services/reviews.test.ts

@@ -1,7 +1,12 @@
 import type { Product, Review, State } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { beforeEach, describe, expect, test } from "vitest";
 import { CommercetoolsMock } from "#src/index.ts";
+import {
+	productDraftFactory,
+	productTypeDraftFactory,
+	reviewDraftFactory,
+	stateDraftFactory,
+} from "#src/testing/index.ts";
 
 describe("Review Update Actions", () => {
 	let ctMock: CommercetoolsMock;
@@ -9,68 +14,68 @@ describe("Review Update Actions", () => {
 	let product: Product;
 	let state: State;
 
+	const createProductDraft = () => productDraftFactory(ctMock);
+	const createStateDraft = () => stateDraftFactory(ctMock);
+	const createReviewDraft = () => reviewDraftFactory(ctMock);
+
 	beforeEach(async () => {
 		ctMock = new CommercetoolsMock();
 
+		// Create a product type first
+		const productType = await productTypeDraftFactory(ctMock).create({
+			key: "dummy-product-type",
+			name: "Dummy Product Type",
+			description: "Product type for testing reviews",
+		});
+
 		// Create a product to target
-		const productResponse = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send({
-				name: { en: "Test Product" },
-				slug: { en: "test-product" },
-				productType: {
-					typeId: "product-type",
-					key: "dummy-product-type",
-				},
-				masterVariant: {
-					sku: "test-sku-1",
-					prices: [
-						{
-							value: {
-								currencyCode: "EUR",
-								centAmount: 1000,
-							},
+		product = await createProductDraft().create({
+			name: { en: "Test Product" },
+			slug: { en: "test-product" },
+			productType: {
+				typeId: "product-type",
+				id: productType.id,
+			},
+			masterVariant: {
+				sku: "test-sku-1",
+				prices: [
+					{
+						value: {
+							currencyCode: "EUR",
+							centAmount: 1000,
 						},
-					],
-				},
-			});
-		expect(productResponse.status).toBe(201);
-		product = productResponse.body;
+					},
+				],
+			},
+		});
 
 		// Create a state
-		const stateResponse = await supertest(ctMock.app)
-			.post("/dummy/states")
-			.send({
-				key: "review-state",
-				type: "ReviewState",
-				name: { en: "Review State" },
-				initial: true,
-			});
-		expect(stateResponse.status).toBe(201);
-		state = stateResponse.body;
+		state = await createStateDraft().create({
+			key: "review-state",
+			type: "ReviewState",
+			name: { en: "Review State" },
+			initial: true,
+		});
 
 		// Create a review
-		const reviewResponse = await supertest(ctMock.app)
-			.post("/dummy/reviews")
-			.send({
-				key: "test-review",
-				authorName: "John Doe",
-				title: "Great product!",
-				text: "I really love this product.",
-				rating: 5,
-				target: {
-					typeId: "product",
-					id: product.id,
-				},
-			});
-		expect(reviewResponse.status).toBe(201);
-		review = reviewResponse.body;
+		review = await createReviewDraft().create({
+			key: "test-review",
+			authorName: "John Doe",
+			title: "Great product!",
+			text: "I really love this product.",
+			rating: 5,
+			target: {
+				typeId: "product",
+				id: product.id,
+			},
+		});
 	});
 
 	test("setAuthorName", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -78,17 +83,19 @@ describe("Review Update Actions", () => {
 						authorName: "Jane Smith",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.authorName).toBe("Jane Smith");
-		expect(response.body.version).toBe(2);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().authorName).toBe("Jane Smith");
+		expect(response.json().version).toBe(2);
 	});
 
 	test("setTitle", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -96,17 +103,19 @@ describe("Review Update Actions", () => {
 						title: "Amazing product!",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.title).toBe("Amazing product!");
-		expect(response.body.version).toBe(2);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().title).toBe("Amazing product!");
+		expect(response.json().version).toBe(2);
 	});
 
 	test("setText", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -114,17 +123,19 @@ describe("Review Update Actions", () => {
 						text: "This product exceeded my expectations!",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.text).toBe("This product exceeded my expectations!");
-		expect(response.body.version).toBe(2);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().text).toBe("This product exceeded my expectations!");
+		expect(response.json().version).toBe(2);
 	});
 
 	test("setRating", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -132,17 +143,19 @@ describe("Review Update Actions", () => {
 						rating: 4,
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.rating).toBe(4);
-		expect(response.body.version).toBe(2);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().rating).toBe(4);
+		expect(response.json().version).toBe(2);
 	});
 
 	test("setLocale", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -150,17 +163,19 @@ describe("Review Update Actions", () => {
 						locale: "de-DE",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.locale).toBe("de-DE");
-		expect(response.body.version).toBe(2);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().locale).toBe("de-DE");
+		expect(response.json().version).toBe(2);
 	});
 
 	test("setKey", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -168,17 +183,19 @@ describe("Review Update Actions", () => {
 						key: "updated-review-key",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.key).toBe("updated-review-key");
-		expect(response.body.version).toBe(2);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().key).toBe("updated-review-key");
+		expect(response.json().version).toBe(2);
 	});
 
 	test("transitionState", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -189,20 +206,22 @@ describe("Review Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.state).toMatchObject({
+		expect(response.statusCode).toBe(200);
+		expect(response.json().state).toMatchObject({
 			typeId: "state",
 			id: state.id,
 		});
-		expect(response.body.version).toBe(2);
+		expect(response.json().version).toBe(2);
 	});
 
 	test("multiple actions in one update", async () => {
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/reviews/${review.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/reviews/${review.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -218,13 +237,15 @@ describe("Review Update Actions", () => {
 						text: "Updated review text",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.authorName).toBe("Updated Author");
-		expect(response.body.rating).toBe(3);
-		expect(response.body.text).toBe("Updated review text");
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.authorName).toBe("Updated Author");
+		expect(body.rating).toBe(3);
+		expect(body.text).toBe("Updated review text");
 		// Version should be incremented by 3 since each action modifies the resource
-		expect(response.body.version).toBe(4);
+		expect(body.version).toBe(4);
 	});
 });

package/src/services/reviews.ts

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

package/src/services/shipping-method.test.ts

@@ -1,72 +1,64 @@
-import type {
-	Cart,
-	CartDraft,
-	ShippingMethodDraft,
-	TaxCategoryDraft,
-	ZoneDraft,
-} from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import {
+	cartDraftFactory,
+	shippingMethodDraftFactory,
+	taxCategoryDraftFactory,
+	zoneDraftFactory,
+} from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
-import { isType } from "../types.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("Shipping method", () => {
+	const taxCategoryDraft = taxCategoryDraftFactory(ctMock);
+	const zoneDraft = zoneDraftFactory(ctMock);
+	const shippingMethodDraft = shippingMethodDraftFactory(ctMock);
+	const cartDraft = cartDraftFactory(ctMock);
+
 	beforeEach(async () => {
-		await supertest(ctMock.app)
-			.post("/dummy/tax-categories")
-			.send(
-				isType<TaxCategoryDraft>({
-					name: "foo",
-					key: "standard",
-					rates: [],
-				}),
-			)
-			.then((res) => {
-				expect(res.status).toEqual(201);
-			});
-
-		await supertest(ctMock.app)
-			.post("/dummy/zones")
-			.send(
-				isType<ZoneDraft>({
-					name: "The Netherlands",
-					key: "NL",
-					locations: [
-						{
-							country: "NL",
-						},
-					],
-				}),
-			)
-			.then((res) => {
-				expect(res.status).toEqual(201);
-			});
+		await taxCategoryDraft.create({
+			name: "foo",
+			key: "standard",
+			rates: [],
+		});
+
+		await zoneDraft.create({
+			name: "The Netherlands",
+			key: "NL",
+			locations: [
+				{
+					country: "NL",
+				},
+			],
+		});
 	});
 
 	afterEach(async () => {
-		ctMock.clear();
+		await ctMock.clear();
 	});
 
 	test("Create shipping method", async () => {
-		const draft: ShippingMethodDraft = {
+		const draft = shippingMethodDraft.build({
 			name: "foo",
 			taxCategory: { typeId: "tax-category", key: "standard" },
 			isDefault: true,
 			zoneRates: [],
-		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/shipping-methods")
-			.send(draft);
+		});
 
-		expect(response.status).toBe(201);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/shipping-methods",
+			payload: draft,
+		});
 
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual({
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			id: expect.anything(),
 			isDefault: true,
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			name: "foo",
 			taxCategory: {
 				id: expect.anything(),
@@ -79,103 +71,82 @@ describe("Shipping method", () => {
 	});
 
 	test("Get shipping method", async () => {
-		const draft: ShippingMethodDraft = {
+		const shippingMethod = await shippingMethodDraft.create({
 			name: "foo",
 			taxCategory: { typeId: "tax-category", key: "standard" },
 			isDefault: true,
 			zoneRates: [],
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/shipping-methods")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/shipping-methods/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/shipping-methods/${shippingMethod.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(shippingMethod);
 	});
 
 	test("Get shipping methods matching cart", async () => {
-		const cart = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send(
-				isType<CartDraft>({
-					currency: "EUR",
-					shippingAddress: {
-						country: "NL",
+		const cart = await cartDraft.create({
+			currency: "EUR",
+			shippingAddress: {
+				country: "NL",
+			},
+		});
+
+		await shippingMethodDraft.create({
+			name: "NL",
+			taxCategory: { typeId: "tax-category", key: "standard" },
+			isDefault: true,
+			zoneRates: [
+				{
+					zone: {
+						typeId: "zone",
+						key: "NL",
 					},
-				}),
-			)
-			.then((res) => res.body as Cart);
-
-		await supertest(ctMock.app)
-			.post("/dummy/shipping-methods")
-			.send(
-				isType<ShippingMethodDraft>({
-					name: "NL",
-					taxCategory: { typeId: "tax-category", key: "standard" },
-					isDefault: true,
-					zoneRates: [
+					shippingRates: [
 						{
-							zone: {
-								typeId: "zone",
-								key: "NL",
+							price: {
+								currencyCode: "EUR",
+								centAmount: 495,
 							},
-							shippingRates: [
-								{
-									price: {
-										currencyCode: "EUR",
-										centAmount: 495,
-									},
-								},
-							],
 						},
 					],
-				}),
-			)
-			.then((res) => {
-				expect(res.status).toEqual(201);
-			});
-
-		await supertest(ctMock.app)
-			.post("/dummy/shipping-methods")
-			.send(
-				isType<ShippingMethodDraft>({
-					name: "NL/GBP",
-					taxCategory: { typeId: "tax-category", key: "standard" },
-					isDefault: true,
-					zoneRates: [
+				},
+			],
+		});
+
+		await shippingMethodDraft.create({
+			name: "NL/GBP",
+			taxCategory: { typeId: "tax-category", key: "standard" },
+			isDefault: true,
+			zoneRates: [
+				{
+					zone: {
+						typeId: "zone",
+						key: "NL",
+					},
+					shippingRates: [
 						{
-							zone: {
-								typeId: "zone",
-								key: "NL",
+							price: {
+								currencyCode: "GBP",
+								centAmount: 495,
 							},
-							shippingRates: [
-								{
-									price: {
-										currencyCode: "GBP",
-										centAmount: 495,
-									},
-								},
-							],
 						},
 					],
-				}),
-			)
-			.then((res) => {
-				expect(res.status).toEqual(201);
-			});
-
-		const response = await supertest(ctMock.app).get(
-			`/dummy/shipping-methods/matching-cart?cartId=${cart.id}`,
-		);
-
-		expect(response.status, JSON.stringify(response.body)).toBe(200);
-		expect(response.body).toMatchObject({
+				},
+			],
+		});
+
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/shipping-methods/matching-cart?cartId=${cart.id}`,
+		});
+
+		const body = response.json();
+		expect(response.statusCode, JSON.stringify(body)).toBe(200);
+		expect(body).toMatchObject({
 			count: 1,
 			limit: 20,
 			offset: 0,