@labdigital/commercetools-mock 2.50.1 → 2.52.0

package/src/repositories/attribute-group.test.ts

@@ -0,0 +1,221 @@
+import type {
+	AttributeGroupChangeNameAction,
+	AttributeGroupDraft,
+	AttributeGroupSetAttributesAction,
+	AttributeGroupSetDescriptionAction,
+	AttributeGroupSetKeyAction,
+} from "@commercetools/platform-sdk";
+import { describe, expect, test } from "vitest";
+import type { Config } from "~src/config";
+import { InMemoryStorage } from "~src/storage";
+import { AttributeGroupRepository } from "./attribute-group";
+
+describe("AttributeGroup Repository", () => {
+	const storage = new InMemoryStorage();
+	const config: Config = { storage, strict: false };
+	const repository = new AttributeGroupRepository(config);
+
+	test("create attribute group", () => {
+		const draft: AttributeGroupDraft = {
+			name: { "en-US": "Size Attributes", "de-DE": "Größenattribute" },
+			description: { "en-US": "Attributes related to product size" },
+			key: "size-attributes",
+			attributes: [
+				{
+					key: "size",
+				},
+				{
+					key: "weight",
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.create(ctx, draft);
+
+		expect(result.id).toBeDefined();
+		expect(result.version).toBe(1);
+		expect(result.name).toEqual(draft.name);
+		expect(result.description).toEqual(draft.description);
+		expect(result.key).toBe(draft.key);
+		expect(result.attributes).toEqual(draft.attributes);
+
+		// Test that the attribute group is stored
+		const items = repository.query(ctx);
+		expect(items.count).toBe(1);
+		expect(items.results[0].id).toBe(result.id);
+	});
+
+	test("create attribute group with minimal data", () => {
+		const draft: AttributeGroupDraft = {
+			name: { "en-US": "Minimal Attributes" },
+			attributes: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.create(ctx, draft);
+
+		expect(result.id).toBeDefined();
+		expect(result.name).toEqual(draft.name);
+		expect(result.description).toBeUndefined();
+		expect(result.key).toBeUndefined();
+		expect(result.attributes).toEqual([]);
+	});
+
+	test("update attribute group - changeName", () => {
+		const draft: AttributeGroupDraft = {
+			name: { "en-US": "Original Name" },
+			key: "test-attributes",
+			attributes: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const attributeGroup = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			attributeGroup,
+			attributeGroup.version,
+			[
+				{
+					action: "changeName",
+					name: { "en-US": "Updated Name", "de-DE": "Aktualisierter Name" },
+				} as AttributeGroupChangeNameAction,
+			],
+		);
+
+		expect(result.name).toEqual({
+			"en-US": "Updated Name",
+			"de-DE": "Aktualisierter Name",
+		});
+		expect(result.version).toBe(attributeGroup.version + 1);
+	});
+
+	test("update attribute group - setDescription", () => {
+		const draft: AttributeGroupDraft = {
+			name: { "en-US": "Test Attributes" },
+			key: "test-attributes-2",
+			attributes: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const attributeGroup = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			attributeGroup,
+			attributeGroup.version,
+			[
+				{
+					action: "setDescription",
+					description: {
+						"en-US": "New description",
+						"de-DE": "Neue Beschreibung",
+					},
+				} as AttributeGroupSetDescriptionAction,
+			],
+		);
+
+		expect(result.description).toEqual({
+			"en-US": "New description",
+			"de-DE": "Neue Beschreibung",
+		});
+		expect(result.version).toBe(attributeGroup.version + 1);
+	});
+
+	test("update attribute group - setKey", () => {
+		const draft: AttributeGroupDraft = {
+			name: { "en-US": "Key Test Attributes" },
+			key: "original-key",
+			attributes: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const attributeGroup = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			attributeGroup,
+			attributeGroup.version,
+			[
+				{
+					action: "setKey",
+					key: "updated-key",
+				} as AttributeGroupSetKeyAction,
+			],
+		);
+
+		expect(result.key).toBe("updated-key");
+		expect(result.version).toBe(attributeGroup.version + 1);
+	});
+
+	test("update attribute group - setAttributes", () => {
+		const draft: AttributeGroupDraft = {
+			name: { "en-US": "Attributes Test" },
+			key: "attributes-test",
+			attributes: [
+				{
+					key: "original-attribute",
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const attributeGroup = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			attributeGroup,
+			attributeGroup.version,
+			[
+				{
+					action: "setAttributes",
+					attributes: [
+						{
+							key: "new-attribute-1",
+						},
+						{
+							key: "new-attribute-2",
+						},
+					],
+				} as AttributeGroupSetAttributesAction,
+			],
+		);
+
+		expect(result.attributes).toEqual([
+			{ key: "new-attribute-1" },
+			{ key: "new-attribute-2" },
+		]);
+		expect(result.version).toBe(attributeGroup.version + 1);
+	});
+
+	test("get and delete attribute group", () => {
+		const draft: AttributeGroupDraft = {
+			name: { "en-US": "Delete Test Attributes" },
+			key: "delete-test",
+			attributes: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const attributeGroup = repository.create(ctx, draft);
+
+		// Test get
+		const retrieved = repository.get(ctx, attributeGroup.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(attributeGroup.id);
+
+		// Test getByKey
+		const retrievedByKey = repository.getByKey(ctx, attributeGroup.key!);
+		expect(retrievedByKey).toBeDefined();
+		expect(retrievedByKey?.key).toBe(attributeGroup.key);
+
+		// Test delete
+		const deleted = repository.delete(ctx, attributeGroup.id);
+		expect(deleted).toBeDefined();
+		expect(deleted?.id).toBe(attributeGroup.id);
+
+		// Verify it's deleted
+		const notFound = repository.get(ctx, attributeGroup.id);
+		expect(notFound).toBeNull();
+	});
+});

package/src/repositories/business-unit.test.ts

@@ -0,0 +1,282 @@
+import type {
+	BusinessUnitChangeNameAction,
+	BusinessUnitChangeStatusAction,
+	BusinessUnitSetContactEmailAction,
+	CompanyDraft,
+	DivisionDraft,
+} from "@commercetools/platform-sdk";
+import { describe, expect, test } from "vitest";
+import type { Config } from "~src/config";
+import { getBaseResourceProperties } from "~src/helpers";
+import { InMemoryStorage } from "~src/storage";
+import { BusinessUnitRepository } from "./business-unit";
+import { CustomerRepository } from "./customer";
+
+describe("BusinessUnit Repository", () => {
+	const storage = new InMemoryStorage();
+	const config: Config = { storage, strict: false };
+	const repository = new BusinessUnitRepository(config);
+
+	// Add required dependencies for testing
+	storage.add("dummy", "store", {
+		...getBaseResourceProperties(),
+		id: "store-123",
+		key: "test-store",
+		name: { "en-US": "Test Store" },
+		languages: ["en-US"],
+		countries: [{ code: "US" }],
+		distributionChannels: [],
+		supplyChannels: [],
+		productSelections: [],
+	});
+
+	// Create a proper customer using the customer repository
+	const customerRepository = new CustomerRepository(config);
+	const customer = customerRepository.create(
+		{ projectKey: "dummy" },
+		{
+			email: "associate@example.com",
+			password: "password123",
+			firstName: "John",
+			lastName: "Associate",
+		},
+	);
+
+	test("create company business unit", () => {
+		const draft: CompanyDraft = {
+			key: "test-company",
+			unitType: "Company",
+			status: "Active",
+			name: "Test Company Inc.",
+			contactEmail: "contact@testcompany.com",
+			storeMode: "Explicit",
+			associateMode: "Explicit",
+			approvalRuleMode: "ExplicitApproval",
+			stores: [
+				{
+					typeId: "store",
+					key: "test-store",
+				},
+			],
+			addresses: [
+				{
+					country: "US",
+					city: "New York",
+					streetName: "5th Avenue",
+					streetNumber: "123",
+					postalCode: "10001",
+				},
+			],
+			defaultBillingAddress: 0,
+			defaultShippingAddress: 0,
+			billingAddresses: [0],
+			shippingAddresses: [0],
+			associates: [
+				{
+					customer: {
+						typeId: "customer",
+						id: customer.id,
+					},
+					associateRoleAssignments: [
+						{
+							associateRole: {
+								typeId: "associate-role",
+								key: "admin",
+							},
+							inheritance: "Enabled",
+						},
+					],
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.create(ctx, draft);
+
+		expect(result.id).toBeDefined();
+		expect(result.version).toBe(1);
+		expect(result.key).toBe(draft.key);
+		expect(result.unitType).toBe("Company");
+		expect(result.name).toBe(draft.name);
+		expect(result.contactEmail).toBe(draft.contactEmail);
+		expect(result.status).toBe(draft.status);
+		expect(result.storeMode).toBe(draft.storeMode);
+		expect(result.associateMode).toBe(draft.associateMode);
+		expect(result.approvalRuleMode).toBe(draft.approvalRuleMode);
+		expect(result.addresses).toHaveLength(1);
+		expect(result.addresses[0].country).toBe("US");
+		expect(result.stores).toHaveLength(1);
+		expect(result.associates).toHaveLength(1);
+
+		// Test that the business unit is stored
+		const items = repository.query(ctx);
+		expect(items.count).toBe(1);
+		expect(items.results[0].id).toBe(result.id);
+	});
+
+	test("create division business unit", () => {
+		// First create a company to be the parent
+		const companyDraft: CompanyDraft = {
+			key: "parent-company",
+			unitType: "Company",
+			status: "Active",
+			name: "Parent Company",
+		};
+
+		const company = repository.create({ projectKey: "dummy" }, companyDraft);
+
+		const draft: DivisionDraft = {
+			key: "test-division",
+			unitType: "Division",
+			status: "Active",
+			name: "Test Division",
+			contactEmail: "division@testcompany.com",
+			parentUnit: {
+				typeId: "business-unit",
+				key: "parent-company",
+			},
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.create(ctx, draft);
+
+		expect(result.id).toBeDefined();
+		expect(result.key).toBe(draft.key);
+		expect(result.unitType).toBe("Division");
+		expect(result.name).toBe(draft.name);
+		expect(result.contactEmail).toBe(draft.contactEmail);
+
+		// Check division-specific properties
+		if (result.unitType === "Division") {
+			expect(result.parentUnit?.key).toBe("parent-company");
+		}
+	});
+
+	test("create business unit with minimal data", () => {
+		const draft: CompanyDraft = {
+			key: "minimal-company",
+			unitType: "Company",
+			name: "Minimal Company",
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.create(ctx, draft);
+
+		expect(result.id).toBeDefined();
+		expect(result.key).toBe(draft.key);
+		expect(result.name).toBe(draft.name);
+		expect(result.unitType).toBe("Company");
+		expect(result.addresses).toEqual([]);
+		expect(result.associates).toEqual([]);
+		expect(result.stores).toBeUndefined();
+	});
+
+	test("update business unit - changeName", () => {
+		const draft: CompanyDraft = {
+			key: "update-test-company",
+			unitType: "Company",
+			name: "Original Company Name",
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const businessUnit = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			businessUnit,
+			businessUnit.version,
+			[
+				{
+					action: "changeName",
+					name: "Updated Company Name",
+				} as BusinessUnitChangeNameAction,
+			],
+		);
+
+		expect(result.name).toBe("Updated Company Name");
+		expect(result.version).toBe(businessUnit.version + 1);
+	});
+
+	test("update business unit - setContactEmail", () => {
+		const draft: CompanyDraft = {
+			key: "email-test-company",
+			unitType: "Company",
+			name: "Email Test Company",
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const businessUnit = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			businessUnit,
+			businessUnit.version,
+			[
+				{
+					action: "setContactEmail",
+					contactEmail: "newemail@company.com",
+				} as BusinessUnitSetContactEmailAction,
+			],
+		);
+
+		expect(result.contactEmail).toBe("newemail@company.com");
+		expect(result.version).toBe(businessUnit.version + 1);
+	});
+
+	test("update business unit - changeStatus", () => {
+		const draft: CompanyDraft = {
+			key: "status-test-company",
+			unitType: "Company",
+			name: "Status Test Company",
+			status: "Active",
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const businessUnit = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			businessUnit,
+			businessUnit.version,
+			[
+				{
+					action: "changeStatus",
+					status: "Inactive",
+				} as BusinessUnitChangeStatusAction,
+			],
+		);
+
+		expect(result.status).toBe("Inactive");
+		expect(result.version).toBe(businessUnit.version + 1);
+	});
+
+	test("get and delete business unit", () => {
+		const draft: CompanyDraft = {
+			key: "delete-test",
+			unitType: "Company",
+			name: "Delete Test Company",
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const businessUnit = repository.create(ctx, draft);
+
+		// Test get
+		const retrieved = repository.get(ctx, businessUnit.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(businessUnit.id);
+
+		// Test getByKey
+		const retrievedByKey = repository.getByKey(ctx, businessUnit.key!);
+		expect(retrievedByKey).toBeDefined();
+		expect(retrievedByKey?.key).toBe(businessUnit.key);
+
+		// Test delete
+		const deleted = repository.delete(ctx, businessUnit.id);
+		expect(deleted).toBeDefined();
+		expect(deleted?.id).toBe(businessUnit.id);
+
+		// Verify it's deleted
+		const notFound = repository.get(ctx, businessUnit.id);
+		expect(notFound).toBeNull();
+	});
+});

package/src/repositories/business-unit.ts

@@ -101,6 +101,7 @@ export class BusinessUnitRepository extends AbstractResourceRepository<"business
 		if (this._isDivisionDraft(draft)) {
 			const division = {
 				...resource,
+				unitType: "Division" as const,
 				parentUnit: getBusinessUnitKeyReference(
 					draft.parentUnit,
 					context.projectKey,
@@ -112,7 +113,10 @@ export class BusinessUnitRepository extends AbstractResourceRepository<"business
 			return division;
 		}
 		if (this._isCompanyDraft(draft)) {
-			const company = resource as Company;
+			const company = {
+				...resource,
+				unitType: "Company" as const,
+			} as Company;
 
 			this.saveNew(context, company);
 			return company;

package/src/repositories/cart/index.test.ts

@@ -1,6 +1,7 @@
 import type { CartDraft, LineItem } from "@commercetools/platform-sdk";
 import { describe, expect, test } from "vitest";
 import type { Config } from "~src/config";
+import { getBaseResourceProperties } from "~src/helpers";
 import { InMemoryStorage } from "~src/storage";
 import { CartRepository } from "./index";
 
@@ -9,6 +10,15 @@ describe("Cart repository", () => {
 	const config: Config = { storage, strict: false };
 	const repository = new CartRepository(config);
 
+	storage.add("dummy", "type", {
+		...getBaseResourceProperties(),
+		id: "1234567890",
+		key: "custom-type-key",
+		name: { "nl-NL": "custom-type-name" },
+		resourceTypeIds: [],
+		fieldDefinitions: [],
+	});
+
 	test("create cart in store", async () => {
 		storage.add("dummy", "product", {
 			createdAt: "",
@@ -108,6 +118,15 @@ describe("Cart repository", () => {
 							},
 						],
 					},
+					custom: {
+						type: {
+							typeId: "type",
+							id: "1234567890",
+						},
+						fields: {
+							description: "example description",
+						},
+					},
 				} as unknown as LineItem,
 			],
 			origin: "Customer",
@@ -149,5 +168,46 @@ describe("Cart repository", () => {
 		expect(result.taxMode).toEqual(cart.taxMode);
 		expect(result.taxRoundingMode).toEqual(cart.taxRoundingMode);
 		expect(result.store?.key).toEqual(ctx.storeKey);
+		expect(result.lineItems[0].custom?.fields.description as string).toEqual(
+			cart.lineItems![0].custom?.fields?.description,
+		);
+	});
+
+	test("create cart with business unit", async () => {
+		storage.add("dummy", "business-unit", {
+			...getBaseResourceProperties(),
+			unitType: "Company",
+			key: "business-unit-key",
+			status: "Active",
+			storeMode: "Explicit",
+			name: "Test",
+			addresses: [],
+			associateMode: "Explicit",
+			associates: [],
+			topLevelUnit: {
+				typeId: "business-unit",
+				key: "business-unit-key",
+			},
+			approvalRuleMode: "Explicit",
+		});
+
+		const cart: CartDraft = {
+			country: "NL",
+			currency: "EUR",
+			businessUnit: {
+				typeId: "business-unit",
+				key: "business-unit-key",
+			},
+		};
+
+		const ctx = { projectKey: "dummy", storeKey: "dummyStore" };
+
+		const result = repository.create(ctx, cart);
+		expect(result.id).toBeDefined();
+
+		expect(result.businessUnit).toEqual({
+			key: "business-unit-key",
+			typeId: "business-unit",
+		});
 	});
 });

package/src/repositories/cart/index.ts

@@ -1,4 +1,7 @@
-import type { InvalidOperationError } from "@commercetools/platform-sdk";
+import type {
+	BusinessUnit,
+	InvalidOperationError,
+} from "@commercetools/platform-sdk";
 import type {
 	Cart,
 	CartDraft,
@@ -43,6 +46,19 @@ export class CartRepository extends AbstractResourceRepository<"cart"> {
 			});
 		}
 
+		let storedBusinessUnit: BusinessUnit | undefined = undefined;
+		if (draft.businessUnit?.id || draft.businessUnit?.key) {
+			storedBusinessUnit =
+				this._storage.getByResourceIdentifier<"business-unit">(
+					context.projectKey,
+					{
+						typeId: "business-unit",
+						id: draft.businessUnit.id,
+						key: draft.businessUnit.key,
+					},
+				);
+		}
+
 		const lineItems =
 			draft.lineItems?.map((draftLineItem) =>
 				this.draftLineItemtoLineItem(
@@ -56,6 +72,13 @@ export class CartRepository extends AbstractResourceRepository<"cart"> {
 		const resource: Writable<Cart> = {
 			...getBaseResourceProperties(),
 			anonymousId: draft.anonymousId,
+			businessUnit:
+				storedBusinessUnit && draft.businessUnit
+					? {
+							typeId: draft.businessUnit.typeId,
+							key: storedBusinessUnit.key,
+						}
+					: undefined,
 			billingAddress: draft.billingAddress
 				? createAddress(draft.billingAddress, context.projectKey, this._storage)
 				: undefined,
@@ -202,6 +225,11 @@ export class CartRepository extends AbstractResourceRepository<"cart"> {
 			lineItemMode: "Standard",
 			priceMode: "Platform",
 			state: [],
+			custom: createCustomFields(
+				draftLineItem.custom,
+				projectKey,
+				this._storage,
+			),
 		};
 	};
 }