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

package/src/services/cart.ts

@@ -1,5 +1,12 @@
-import type { Cart, CartDraft, Order } from "@commercetools/platform-sdk";
-import type { Request, Response, Router } from "express";
+import type {
+	Cart,
+	CartDraft,
+	InvalidInputError,
+	Order,
+	ReplicaCartDraft,
+} 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 { getRepositoryContext } from "../repositories/helpers.ts";
 import type { OrderRepository } from "../repositories/order/index.ts";
@@ -11,7 +18,7 @@ export class CartService extends AbstractService {
 	public orderRepository: OrderRepository;
 
 	constructor(
-		parent: Router,
+		parent: FastifyInstance,
 		cartRepository: CartRepository,
 		orderRepository: OrderRepository,
 	) {
@@ -24,21 +31,33 @@ export class CartService extends AbstractService {
 		return "carts";
 	}
 
-	extraRoutes(parent: Router) {
+	extraRoutes(parent: FastifyInstance) {
 		parent.post("/replicate", this.replicate.bind(this));
 	}
 
-	replicate(request: Request, response: Response) {
+	async replicate(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: ReplicaCartDraft;
+		}>,
+		reply: FastifyReply,
+	) {
 		const context = getRepositoryContext(request);
+		const body = request.body;
 
 		const cartOrOrder: Cart | Order | null =
-			request.body.reference.typeId === "order"
-				? this.orderRepository.get(context, request.body.reference.id)
-				: this.repository.get(context, request.body.reference.id);
+			body.reference.typeId === "order"
+				? await this.orderRepository.get(context, body.reference.id)
+				: await this.repository.get(context, body.reference.id);
 
 		if (!cartOrOrder) {
-			response.status(400).send();
-			return;
+			throw new CommercetoolsError<InvalidInputError>(
+				{
+					code: "InvalidInput",
+					message: `The referenced ${body.reference.typeId} with ID '${body.reference.id}' was not found.`,
+				},
+				400,
+			);
 		}
 
 		const cartDraft: CartDraft = {
@@ -53,8 +72,8 @@ export class CartService extends AbstractService {
 			})),
 		};
 
-		const newCart = this.repository.create(context, cartDraft);
+		const newCart = await this.repository.create(context, cartDraft);
 
-		response.status(200).send(newCart);
+		return reply.status(200).send(newCart);
 	}
 }

package/src/services/category.test.ts

@@ -4,45 +4,41 @@ import type {
 	CategoryAddAssetAction,
 	CategoryRemoveAssetAction,
 } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { categoryDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 describe("Categories Query", () => {
 	const ctMock = new CommercetoolsMock();
+	const categoryDraft = categoryDraftFactory(ctMock);
 	let category: Category | undefined;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/categories")
-			.send({
-				name: {
-					en: "Top hat",
-				},
-				slug: {
-					en: "top-hat",
-				},
-				orderHint: "0.1",
-			});
-		expect(response.status).toBe(201);
-
-		category = response.body as Category;
+		category = await categoryDraft.create({
+			name: {
+				en: "Top hat",
+			},
+			slug: {
+				en: "top-hat",
+			},
+			orderHint: "0.1",
+		});
 	});
 
-	afterEach(() => {
-		ctMock.clear();
+	afterEach(async () => {
+		await ctMock.clear();
 	});
 
 	test("no filter", async () => {
-		const response = await supertest(ctMock.app)
-			.get("/dummy/categories")
-			.query({})
-			.send();
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/categories",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.count).toBe(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().count).toBe(1);
 
-		category = response.body.results[0] as Category;
+		category = response.json().results[0] as Category;
 
 		expect(category.name.en).toBe("Top hat");
 	});
@@ -50,28 +46,26 @@ describe("Categories Query", () => {
 
 describe("categories changeName", () => {
 	const ctMock = new CommercetoolsMock();
+	const categoryDraft = categoryDraftFactory(ctMock);
 	let category: Category | undefined;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/categories")
-			.send({
-				name: {
-					en: "Top hat",
-				},
-				slug: {
-					en: "top-hat",
-				},
-				orderHint: "0.1",
-			});
-		expect(response.status).toBe(201);
-		category = response.body as Category;
+		category = await categoryDraft.create({
+			name: {
+				en: "Top hat",
+			},
+			slug: {
+				en: "top-hat",
+			},
+			orderHint: "0.1",
+		});
 	});
 
 	test("changeName", async () => {
-		const changeNameResponse = await supertest(ctMock.app)
-			.post(`/dummy/categories/${category?.id}`)
-			.send({
+		const changeNameResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/categories/${category?.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -81,52 +75,133 @@ describe("categories changeName", () => {
 						},
 					},
 				],
-			});
+			},
+		});
+
+		expect(changeNameResponse.statusCode).toBe(200);
+		expect(changeNameResponse.json().name.en).toBe("Top hat - new name");
+	});
+});
+
+describe("Categories create with parent by key", () => {
+	const ctMock = new CommercetoolsMock();
+	const categoryDraft = categoryDraftFactory(ctMock);
+
+	afterEach(async () => {
+		await ctMock.clear();
+	});
+
+	test("create child category with parent specified by key", async () => {
+		const parentCategory = await categoryDraft.create({
+			key: "parent-key",
+			name: {
+				en: "Parent",
+			},
+			slug: {
+				en: "parent",
+			},
+			orderHint: "0.1",
+		});
+
+		const childCategory = await categoryDraft.create({
+			name: {
+				en: "Child",
+			},
+			slug: {
+				en: "child",
+			},
+			orderHint: "0.2",
+			parent: {
+				typeId: "category",
+				key: "parent-key",
+			},
+		});
+
+		expect(childCategory.parent).toEqual({
+			typeId: "category",
+			id: parentCategory.id,
+		});
+		expect(childCategory.ancestors).toHaveLength(1);
+		expect(childCategory.ancestors[0].id).toEqual(parentCategory.id);
+	});
+
+	test("get child category by key resolves ancestors from parent specified by key", async () => {
+		const parentCategory = await categoryDraft.create({
+			key: "parent-key",
+			name: {
+				en: "Parent",
+			},
+			slug: {
+				en: "parent",
+			},
+			orderHint: "0.1",
+		});
+
+		await categoryDraft.create({
+			key: "child-key",
+			name: {
+				en: "Child",
+			},
+			slug: {
+				en: "child",
+			},
+			orderHint: "0.2",
+			parent: {
+				typeId: "category",
+				key: "parent-key",
+			},
+		});
 
-		expect(changeNameResponse.status).toBe(200);
-		expect(changeNameResponse.body.name.en).toBe("Top hat - new name");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/categories/key=child-key",
+		});
+
+		expect(response.statusCode).toBe(200);
+
+		const result = response.json();
+		expect(result.parent).toEqual({
+			typeId: "category",
+			id: parentCategory.id,
+		});
+		expect(result.ancestors).toHaveLength(1);
+		expect(result.ancestors[0].id).toEqual(parentCategory.id);
 	});
 });
 
 describe("categories changeParent", () => {
 	const ctMock = new CommercetoolsMock();
+	const categoryDraft = categoryDraftFactory(ctMock);
 	let category1: Category | undefined;
 	let category2: Category | undefined;
 
 	beforeEach(async () => {
-		const response1 = await supertest(ctMock.app)
-			.post("/dummy/categories")
-			.send({
-				name: {
-					en: "Top hat",
-				},
-				slug: {
-					en: "top-hat",
-				},
-				orderHint: "0.1",
-			});
-		expect(response1.status).toBe(201);
-		category1 = response1.body as Category;
-
-		const response2 = await supertest(ctMock.app)
-			.post("/dummy/categories")
-			.send({
-				name: {
-					en: "Top hat",
-				},
-				slug: {
-					en: "top-hat",
-				},
-				orderHint: "0.1",
-			});
-		expect(response2.status).toBe(201);
-		category2 = response2.body as Category;
+		category1 = await categoryDraft.create({
+			name: {
+				en: "Top hat",
+			},
+			slug: {
+				en: "top-hat",
+			},
+			orderHint: "0.1",
+		});
+
+		category2 = await categoryDraft.create({
+			name: {
+				en: "Top hat",
+			},
+			slug: {
+				en: "top-hat",
+			},
+			orderHint: "0.1",
+		});
 	});
 
 	test("changeParent", async () => {
-		const changeNameResponse = await supertest(ctMock.app)
-			.post(`/dummy/categories/${category2?.id}`)
-			.send({
+		const changeNameResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/categories/${category2?.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -137,50 +212,50 @@ describe("categories changeParent", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(changeNameResponse.status).toBe(200);
-		expect(changeNameResponse.body.parent).toEqual({
+		expect(changeNameResponse.statusCode).toBe(200);
+		expect(changeNameResponse.json().parent).toEqual({
 			typeId: "category",
 			id: category1?.id,
 		});
-		expect(changeNameResponse.body.ancestors).toHaveLength(1);
-		expect(changeNameResponse.body.ancestors[0].id).toEqual(category1?.id);
+		expect(changeNameResponse.json().ancestors).toHaveLength(1);
+		expect(changeNameResponse.json().ancestors[0].id).toEqual(category1?.id);
 	});
 });
 
 describe("Categories add asset", () => {
 	const ctMock = new CommercetoolsMock();
+	const categoryDraft = categoryDraftFactory(ctMock);
 	let category: Category | undefined;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/categories")
-			.send({
-				name: {
-					en: "Top hat",
-				},
-				slug: {
-					en: "top-hat",
+		category = await categoryDraft.create({
+			name: {
+				en: "Top hat",
+			},
+			slug: {
+				en: "top-hat",
+			},
+			orderHint: "0.1",
+			assets: [
+				{
+					key: "some-key",
+					sources: [],
+					name: { en: "Some Asset" },
 				},
-				orderHint: "0.1",
-				assets: [
-					{
-						key: "some-key",
-					},
-				],
-			});
-		expect(response.status).toBe(201);
-
-		category = response.body as Category;
+			],
+		});
 	});
 
 	test("add second asset", async () => {
 		assert(category, "category not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/categories/${category.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/categories/${category.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -190,50 +265,52 @@ describe("Categories add asset", () => {
 						},
 					} as CategoryAddAssetAction,
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.assets).toHaveLength(2);
-		expect(response.body.assets[0].key).toEqual("some-key");
-		expect(response.body.assets[1].key).toEqual("some-other-key");
+		expect(response.statusCode).toBe(200);
+		expect(response.json().assets).toHaveLength(2);
+		expect(response.json().assets[0].key).toEqual("some-key");
+		expect(response.json().assets[1].key).toEqual("some-other-key");
 	});
 });
 
 describe("Categories remove asset", () => {
 	const ctMock = new CommercetoolsMock();
+	const categoryDraft = categoryDraftFactory(ctMock);
 	let category: Category | undefined;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/categories")
-			.send({
-				name: {
-					en: "Top hat",
+		category = await categoryDraft.create({
+			name: {
+				en: "Top hat",
+			},
+			slug: {
+				en: "top-hat",
+			},
+			orderHint: "0.1",
+			assets: [
+				{
+					key: "some-key",
+					sources: [],
+					name: { en: "Some Asset" },
 				},
-				slug: {
-					en: "top-hat",
+				{
+					key: "some-other-key",
+					sources: [],
+					name: { en: "Some Other Asset" },
 				},
-				orderHint: "0.1",
-				assets: [
-					{
-						key: "some-key",
-					},
-					{
-						key: "some-other-key",
-					},
-				],
-			});
-		expect(response.status).toBe(201);
-
-		category = response.body as Category;
+			],
+		});
 	});
 
 	test("remove assets by id and key", async () => {
 		assert(category, "category not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/categories/${category.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/categories/${category.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -245,9 +322,10 @@ describe("Categories remove asset", () => {
 						assetId: category.assets?.[0].id,
 					} as CategoryRemoveAssetAction,
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.assets).toHaveLength(0);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().assets).toHaveLength(0);
 	});
 });

package/src/services/category.ts

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

package/src/services/channel.test.ts

@@ -1,31 +1,36 @@
-import type { ChannelDraft } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import { channelDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("Channel", () => {
+	const channelDraft = channelDraftFactory(ctMock);
+
 	test("Create channel", async () => {
-		const draft: ChannelDraft = {
+		const draft = channelDraft.build({
 			key: "my-channel",
 			roles: ["InventorySupply"],
-		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/channels")
-			.send(draft);
+		});
 
-		expect(response.status).toBe(201);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/channels",
+			payload: draft,
+		});
 
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual({
 			address: undefined,
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			custom: undefined,
 			description: undefined,
 			geoLocation: undefined,
 			id: expect.anything(),
 			key: "my-channel",
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			name: undefined,
 			roles: ["InventorySupply"],
 			version: 1,
@@ -33,58 +38,48 @@ describe("Channel", () => {
 	});
 
 	test("Get channel", async () => {
-		const draft: ChannelDraft = {
+		const channel = await channelDraft.create({
 			key: "my-channel",
 			roles: ["InventorySupply"],
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/channels")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/channels/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/channels/${channel.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(channel);
 	});
 
 	test("Get channel by key", async () => {
-		const draft: ChannelDraft = {
+		const channel = await channelDraft.create({
 			key: "my-channel-key",
 			roles: ["InventorySupply"],
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/channels")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			"/dummy/channels/key=my-channel-key",
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/channels/key=my-channel-key",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(channel);
 	});
 
 	test("Query channels", async () => {
-		const draft: ChannelDraft = {
+		const channel = await channelDraft.create({
 			key: "test-channel",
 			roles: ["InventorySupply"],
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/channels")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get("/dummy/channels");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/channels",
+		});
 
-		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(channel);
 	});
 });

package/src/services/channel.ts

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