@labdigital/commercetools-mock 2.54.0 → 2.56.0

package/src/repositories/recurrence-policy/index.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert";
+import type {
+	RecurrencePolicy,
+	RecurrencePolicyDraft,
+	RecurringOrder,
+	RecurringOrderDraft,
+} from "@commercetools/platform-sdk";
+import type { Config } from "~src/config";
+import { getBaseResourceProperties } from "~src/helpers";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import { OrderRepository } from "../order";
+import { RecurrencePolicyUpdateHandler } from "./actions";
+
+export class RecurrencePolicyRepository extends AbstractResourceRepository<"recurrence-policy"> {
+	constructor(config: Config) {
+		super("recurrence-policy", config);
+		this.actions = new RecurrencePolicyUpdateHandler(config.storage);
+	}
+
+	create(
+		context: RepositoryContext,
+		draft: RecurrencePolicyDraft,
+	): RecurrencePolicy {
+		const resource: RecurrencePolicy = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			name: draft.name,
+			description: draft.description,
+			schedule: draft.schedule,
+		};
+		return this.saveNew(context, resource);
+	}
+}

package/src/repositories/recurring-order/actions.ts

@@ -0,0 +1,157 @@
+import type {
+	RecurringOrder,
+	RecurringOrderSetCustomFieldAction,
+	RecurringOrderSetCustomTypeAction,
+	RecurringOrderSetExpiresAtAction,
+	RecurringOrderSetKeyAction,
+	RecurringOrderSetOrderSkipConfigurationAction,
+	RecurringOrderSetScheduleAction,
+	RecurringOrderSetStartsAtAction,
+	RecurringOrderSetStateAction,
+	RecurringOrderTransitionStateAction,
+	RecurringOrderUpdateAction,
+} from "@commercetools/platform-sdk";
+import type { Writable } from "~src/types";
+import type { UpdateHandlerInterface } from "../abstract";
+import { AbstractUpdateHandler, type RepositoryContext } from "../abstract";
+
+export class RecurringOrderUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<UpdateHandlerInterface<RecurringOrder, RecurringOrderUpdateAction>>
+{
+	setCustomField(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ name, value }: RecurringOrderSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			throw new Error("Resource has no custom field");
+		}
+		if (value === null) {
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ type, fields }: RecurringOrderSetCustomTypeAction,
+	) {
+		if (!type) {
+			resource.custom = undefined;
+		} else {
+			const resolvedType = this._storage.getByResourceIdentifier(
+				context.projectKey,
+				type,
+			);
+			if (!resolvedType) {
+				throw new Error(`Type ${type} not found`);
+			}
+
+			resource.custom = {
+				type: {
+					typeId: "type",
+					id: resolvedType.id,
+				},
+				fields: fields || {},
+			};
+		}
+	}
+
+	setExpiresAt(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ expiresAt }: RecurringOrderSetExpiresAtAction,
+	) {
+		resource.expiresAt = expiresAt;
+	}
+
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ key }: RecurringOrderSetKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	setOrderSkipConfiguration(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{
+			skipConfiguration,
+			updatedExpiresAt,
+		}: RecurringOrderSetOrderSkipConfigurationAction,
+	) {
+		if (skipConfiguration) {
+			resource.skipConfiguration = {
+				type: skipConfiguration.type,
+				totalToSkip: skipConfiguration.totalToSkip,
+				skipped: 0,
+				lastSkippedAt: undefined,
+			};
+		} else {
+			resource.skipConfiguration = undefined;
+		}
+		if (updatedExpiresAt !== undefined) {
+			resource.expiresAt = updatedExpiresAt;
+		}
+	}
+
+	setSchedule(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ recurrencePolicy }: RecurringOrderSetScheduleAction,
+	) {
+		resource.schedule = {
+			...resource.schedule,
+			...recurrencePolicy,
+		};
+	}
+
+	setStartsAt(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ startsAt }: RecurringOrderSetStartsAtAction,
+	) {
+		resource.startsAt = startsAt;
+	}
+
+	setRecurringOrderState(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ recurringOrderState }: RecurringOrderSetStateAction,
+	) {
+		// Map the state draft to the actual state
+		switch (recurringOrderState.type) {
+			case "active":
+				resource.recurringOrderState = "Active";
+				if (recurringOrderState.resumesAt) {
+					resource.resumesAt = recurringOrderState.resumesAt;
+				}
+				break;
+			case "canceled":
+				resource.recurringOrderState = "Canceled";
+				break;
+			case "expired":
+				resource.recurringOrderState = "Expired";
+				break;
+			case "paused":
+				resource.recurringOrderState = "Paused";
+				break;
+		}
+	}
+
+	transitionState(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ state, force }: RecurringOrderTransitionStateAction,
+	) {
+		resource.state = {
+			typeId: "state",
+			id: state.id!,
+		};
+	}
+}

package/src/repositories/recurring-order/index.ts

@@ -0,0 +1,52 @@
+import assert from "node:assert";
+import type {
+	RecurringOrder,
+	RecurringOrderDraft,
+} from "@commercetools/platform-sdk";
+import type { Config } from "~src/config";
+import { getBaseResourceProperties } from "~src/helpers";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import { OrderRepository } from "../order";
+import { RecurringOrderUpdateHandler } from "./actions";
+
+export class RecurringOrderRepository extends AbstractResourceRepository<"recurring-order"> {
+	constructor(config: Config) {
+		super("recurring-order", config);
+		this.actions = new RecurringOrderUpdateHandler(config.storage);
+	}
+
+	create(
+		context: RepositoryContext,
+		draft: RecurringOrderDraft,
+	): RecurringOrder {
+		assert(draft.cart, "draft.cart is missing");
+
+		const orderRepo = new OrderRepository(this.config);
+
+		const initialOrder = orderRepo.createFromCart(context, {
+			id: draft.cart.id!,
+			typeId: "cart",
+		});
+
+		const resource: RecurringOrder = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			cart: {
+				typeId: "cart",
+				id: draft.cart.id!,
+			},
+			originOrder: {
+				typeId: "order",
+				id: initialOrder.id,
+			},
+			startsAt: draft.startsAt,
+			expiresAt: draft.expiresAt,
+			recurringOrderState: "Active",
+			schedule: { type: "standard", intervalUnit: "month", value: 1 },
+		};
+		return this.saveNew(context, resource);
+	}
+}

package/src/repositories/review.test.ts

@@ -36,6 +36,7 @@ describe("Review Repository", () => {
 			current: {
 				name: { "en-US": "Test Product" },
 				slug: { "en-US": "test-product" },
+				attributes: [],
 				categories: [],
 				masterVariant: {
 					id: 1,
@@ -49,6 +50,7 @@ describe("Review Repository", () => {
 			staged: {
 				name: { "en-US": "Test Product" },
 				slug: { "en-US": "test-product" },
+				attributes: [],
 				categories: [],
 				masterVariant: {
 					id: 1,

package/src/repositories/shopping-list/actions.ts

@@ -103,6 +103,7 @@ export class ShoppingListUpdateHandler
 				name: product.masterData.current.name,
 				variantId: varId,
 				quantity,
+				published: Boolean(product.masterData.current),
 			});
 		}
 	}

package/src/repositories/shopping-list/index.ts

@@ -75,6 +75,7 @@ export class ShoppingListRepository extends AbstractResourceRepository<"shopping
 			productId: draftLineItem.productId ?? "",
 			name: {},
 			variantId,
+			published: true,
 			quantity: draftLineItem.quantity ?? 1,
 			productType: { typeId: "product-type", id: "" },
 			custom: createCustomFields(

package/src/services/cart.test.ts

@@ -111,6 +111,7 @@ describe("Carts Query", () => {
 describe("Cart Update Actions", () => {
 	const ctMock = new CommercetoolsMock();
 	let cart: Cart | undefined;
+	let taxCategory: TaxCategory;
 
 	const createCart = async (currency: string) => {
 		const response = await supertest(ctMock.app).post("/dummy/carts").send({
@@ -220,6 +221,18 @@ describe("Cart Update Actions", () => {
 
 	beforeEach(async () => {
 		await createCart("EUR");
+		taxCategory = await createTaxCategory({
+			name: "Standard VAT",
+			key: "standard-vat",
+			rates: [
+				{
+					name: "NL VAT",
+					amount: 0.21,
+					includedInPrice: false,
+					country: "NL",
+				},
+			],
+		});
 	});
 
 	afterEach(() => {
@@ -1327,4 +1340,273 @@ describe("Cart Update Actions", () => {
 		expect(updatedLineItem.shippingDetails).toBeDefined();
 		expect(updatedLineItem.shippingDetails.targets).toHaveLength(1);
 	});
+
+	test("addCustomLineItem", async () => {
+		assert(cart, "cart not created");
+		const type = await supertest(ctMock.app)
+			.post("/dummy/types")
+			.send({
+				key: "custom-line-item-type",
+				name: { en: "Custom Line Item Type" },
+				resourceTypeIds: ["custom-line-item"],
+				fieldDefinitions: [
+					{
+						name: "description",
+						label: { en: "Description" },
+						required: false,
+						type: { name: "String" },
+						inputHint: "SingleLine",
+					},
+				],
+			})
+			.then((res) => res.body);
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "addCustomLineItem",
+						name: { en: "Custom Service Fee" },
+						slug: "service-fee",
+						money: {
+							currencyCode: "EUR",
+							centAmount: 1000,
+						},
+						quantity: 1,
+						taxCategory: {
+							typeId: "tax-category",
+							id: taxCategory.id,
+						},
+						custom: {
+							type: { typeId: "type", key: type.key },
+							fields: { description: "Premium support service" },
+						},
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.customLineItems).toHaveLength(1);
+
+		const customLineItem = response.body.customLineItems[0];
+		expect(customLineItem.name).toEqual({ en: "Custom Service Fee" });
+		expect(customLineItem.slug).toBe("service-fee");
+		expect(customLineItem.money.centAmount).toBe(1000);
+		expect(customLineItem.quantity).toBe(1);
+		expect(customLineItem.totalPrice.centAmount).toBe(1000);
+		expect(customLineItem.taxCategory.id).toBe(taxCategory.id);
+		expect(customLineItem.taxedPrice).toBeDefined();
+		expect(customLineItem.id).toBeDefined();
+		expect(customLineItem.custom).toBeDefined();
+		expect(customLineItem.custom.fields.description).toBe(
+			"Premium support service",
+		);
+	});
+
+	test("removeCustomLineItem by ID", async () => {
+		assert(cart, "cart not created");
+
+		const addResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "addCustomLineItem",
+						name: { en: "Service Fee" },
+						slug: "service-fee",
+						money: {
+							currencyCode: "EUR",
+							centAmount: 1000,
+						},
+						quantity: 1,
+					},
+				],
+			});
+
+		expect(addResponse.status).toBe(200);
+		expect(addResponse.body.customLineItems).toHaveLength(1);
+
+		const customLineItemId = addResponse.body.customLineItems[0].id;
+		const removeResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: addResponse.body.version,
+				actions: [
+					{
+						action: "removeCustomLineItem",
+						customLineItemId,
+					},
+				],
+			});
+
+		expect(removeResponse.status).toBe(200);
+		expect(removeResponse.body.customLineItems).toHaveLength(0);
+	});
+
+	test("removeCustomLineItem by key", async () => {
+		assert(cart, "cart not created");
+
+		const addResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "addCustomLineItem",
+						name: { en: "Service Fee" },
+						slug: "service-fee",
+						key: "custom-service-fee",
+						money: {
+							currencyCode: "EUR",
+							centAmount: 1000,
+						},
+						quantity: 1,
+					},
+				],
+			});
+
+		expect(addResponse.status).toBe(200);
+		expect(addResponse.body.customLineItems).toHaveLength(1);
+
+		const removeResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: addResponse.body.version,
+				actions: [
+					{
+						action: "removeCustomLineItem",
+						customLineItemKey: "custom-service-fee",
+					},
+				],
+			});
+
+		expect(removeResponse.status).toBe(200);
+		expect(removeResponse.body.customLineItems).toHaveLength(0);
+	});
+
+	test("changeCustomLineItemQuantity", async () => {
+		assert(cart, "cart not created");
+		const addResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "addCustomLineItem",
+						name: { en: "Service Fee" },
+						slug: "service-fee",
+						money: {
+							currencyCode: "EUR",
+							centAmount: 1000,
+						},
+						quantity: 1,
+					},
+				],
+			});
+
+		const customLineItemId = addResponse.body.customLineItems[0].id;
+		const changeResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: addResponse.body.version,
+				actions: [
+					{
+						action: "changeCustomLineItemQuantity",
+						customLineItemId,
+						quantity: 3,
+					},
+				],
+			});
+
+		expect(changeResponse.status).toBe(200);
+		expect(changeResponse.body.customLineItems).toHaveLength(1);
+
+		const customLineItem = changeResponse.body.customLineItems[0];
+		expect(customLineItem.quantity).toBe(3);
+		expect(customLineItem.totalPrice.centAmount).toBe(3000);
+	});
+
+	test("changeCustomLineItemMoney", async () => {
+		assert(cart, "cart not created");
+		const addResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "addCustomLineItem",
+						name: { en: "Service Fee" },
+						slug: "service-fee",
+						money: {
+							currencyCode: "EUR",
+							centAmount: 1000,
+						},
+						quantity: 2,
+					},
+				],
+			});
+
+		const customLineItemId = addResponse.body.customLineItems[0].id;
+		const changeResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: addResponse.body.version,
+				actions: [
+					{
+						action: "changeCustomLineItemMoney",
+						customLineItemId,
+						money: {
+							currencyCode: "EUR",
+							centAmount: 1500,
+						},
+					},
+				],
+			});
+
+		expect(changeResponse.status).toBe(200);
+		expect(changeResponse.body.customLineItems).toHaveLength(1);
+
+		const customLineItem = changeResponse.body.customLineItems[0];
+		expect(customLineItem.money.centAmount).toBe(1500);
+		expect(customLineItem.totalPrice.centAmount).toBe(3000);
+	});
+
+	test("addCustomLineItem with tax calculation", async () => {
+		assert(cart, "cart not created");
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "addCustomLineItem",
+						name: { en: "Taxed Service" },
+						slug: "taxed-service",
+						money: {
+							currencyCode: "EUR",
+							centAmount: 1000,
+						},
+						quantity: 1,
+						taxCategory: {
+							typeId: "tax-category",
+							id: taxCategory.id,
+						},
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		const customLineItem = response.body.customLineItems[0];
+
+		expect(customLineItem.taxedPrice).toBeDefined();
+		expect(customLineItem.taxedPrice.totalNet.centAmount).toBe(1000);
+		expect(customLineItem.taxedPrice.totalGross.centAmount).toBe(1210);
+		expect(customLineItem.taxedPrice.taxPortions).toHaveLength(1);
+		expect(customLineItem.taxedPrice.taxPortions[0].rate).toBe(0.21);
+	});
 });