@labdigital/commercetools-mock 2.51.0 → 2.53.0

package/src/product-search-availability.test.ts

@@ -0,0 +1,242 @@
+import type {
+	InventoryEntryDraft,
+	ProductDraft,
+	ProductPagedSearchResponse,
+	ProductSearchRequest,
+} from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "./index";
+
+describe("Product Search - Availability Filtering", () => {
+	const ctMock = new CommercetoolsMock();
+	let productId: string;
+
+	beforeEach(async () => {
+		// Create a product type first
+		const productTypeDraft = {
+			name: "Test Product Type",
+			key: "test-type",
+			description: "Test Product Type",
+		};
+
+		await supertest(ctMock.app)
+			.post("/dummy/product-types")
+			.send(productTypeDraft);
+
+		// Create a test product
+		const productDraft: ProductDraft = {
+			name: { "en-US": "Test Product" },
+			productType: {
+				typeId: "product-type",
+				key: "test-type",
+			},
+			slug: { "en-US": "test-product" },
+			masterVariant: {
+				sku: "TEST-SKU-001",
+			},
+			variants: [
+				{
+					sku: "TEST-SKU-002",
+				},
+			],
+		};
+
+		const productResponse = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send(productDraft);
+
+		productId = productResponse.body.id;
+
+		// Publish the product
+		await supertest(ctMock.app)
+			.post(`/dummy/products/${productId}`)
+			.send({
+				version: productResponse.body.version,
+				actions: [{ action: "publish" }],
+			});
+	});
+
+	afterEach(() => {
+		ctMock.clear();
+	});
+
+	async function createInventoryEntry(
+		sku: string,
+		quantityOnStock: number,
+		channelId?: string,
+	) {
+		const inventoryEntry: InventoryEntryDraft = {
+			sku,
+			quantityOnStock,
+			...(channelId && {
+				supplyChannel: {
+					typeId: "channel",
+					id: channelId,
+				},
+			}),
+		};
+
+		await supertest(ctMock.app).post("/dummy/inventory").send(inventoryEntry);
+	}
+
+	async function searchProducts(
+		query?: any,
+	): Promise<ProductPagedSearchResponse> {
+		const searchRequest: ProductSearchRequest = {
+			...(query && { query }),
+			productProjectionParameters: {
+				staged: false,
+			},
+		};
+
+		const response = await supertest(ctMock.app)
+			.post("/dummy/products/search")
+			.send(searchRequest);
+
+		return response.body;
+	}
+
+	test("should filter products by variants.availability.isOnStock = true", async () => {
+		// Create inventory with stock for one variant
+		await createInventoryEntry("TEST-SKU-001", 10);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStock",
+				value: true,
+			},
+		});
+
+		expect(result.results).toHaveLength(1);
+		expect(
+			result.results[0].productProjection?.masterVariant?.availability
+				?.isOnStock,
+		).toBe(true);
+	});
+
+	test("should filter products by variants.availability.isOnStock = false", async () => {
+		// Create inventory with zero stock
+		await createInventoryEntry("TEST-SKU-001", 0);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStock",
+				value: false,
+			},
+		});
+
+		// Should find the product because it's not on stock
+		expect(result.results).toHaveLength(1);
+		expect(
+			result.results[0].productProjection?.masterVariant?.availability
+				?.isOnStock,
+		).toBe(false);
+	});
+
+	test("should filter products by variants.availability.isOnStockForChannel", async () => {
+		const channelId = "test-channel-1";
+
+		// Create inventory for specific channel
+		await createInventoryEntry("TEST-SKU-001", 5, channelId);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStockForChannel",
+				value: channelId,
+			},
+		});
+
+		expect(result.results).toHaveLength(1);
+		expect(
+			(result.results[0].productProjection?.masterVariant?.availability as any)
+				?.isOnStockForChannel,
+		).toBe(channelId);
+	});
+
+	test("should not find products when filtering by non-matching channel", async () => {
+		const channelId = "test-channel-1";
+		const otherChannelId = "test-channel-2";
+
+		// Create inventory for specific channel
+		await createInventoryEntry("TEST-SKU-001", 5, channelId);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStockForChannel",
+				value: otherChannelId,
+			},
+		});
+
+		expect(result.results).toHaveLength(0);
+	});
+
+	test("should handle products without inventory entries", async () => {
+		// Don't create any inventory entries
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStock",
+				value: false,
+			},
+		});
+
+		// Should find the product because it has no stock
+		expect(result.results).toHaveLength(1);
+		expect(
+			result.results[0].productProjection?.masterVariant?.availability
+				?.isOnStock,
+		).toBe(false);
+	});
+
+	test("should work with OR queries for availability", async () => {
+		// Create inventory with stock
+		await createInventoryEntry("TEST-SKU-001", 10);
+
+		const result = await searchProducts({
+			or: [
+				{
+					exact: {
+						field: "variants.availability.isOnStock",
+						value: true,
+					},
+				},
+				{
+					exact: {
+						field: "variants.availability.isOnStock",
+						value: false,
+					},
+				},
+			],
+		});
+
+		// Should find the product regardless of stock status
+		expect(result.results).toHaveLength(1);
+	});
+
+	test("should work with AND queries combining availability and other fields", async () => {
+		await createInventoryEntry("TEST-SKU-001", 10);
+
+		const result = await searchProducts({
+			and: [
+				{
+					exact: {
+						field: "variants.availability.isOnStock",
+						value: true,
+					},
+				},
+				{
+					exact: {
+						field: "variants.sku",
+						value: "TEST-SKU-001",
+					},
+				},
+			],
+		});
+
+		expect(result.results).toHaveLength(1);
+		expect(result.results[0].productProjection?.masterVariant?.sku).toBe(
+			"TEST-SKU-001",
+		);
+	});
+});

package/src/product-search.ts

@@ -148,6 +148,23 @@ export class ProductSearch {
 			? product.masterData.current
 			: product.masterData.staged;
 
+		const getVariantAvailability = (sku?: string) => {
+			if (!sku) {
+				return {
+					isOnStock: false,
+					availableQuantity: 0,
+					isOnStockForChannel: undefined,
+				};
+			}
+			return (
+				availabilityBySku.get(sku) || {
+					isOnStock: false,
+					availableQuantity: 0,
+					isOnStockForChannel: undefined,
+				}
+			);
+		};
+
 		return {
 			id: product.id,
 			createdAt: product.createdAt,
@@ -159,12 +176,13 @@ export class ProductSearch {
 			metaDescription: obj.metaDescription,
 			slug: obj.slug,
 			categories: obj.categories,
-			masterVariant: obj.masterVariant,
+			masterVariant: {
+				...obj.masterVariant,
+				availability: getVariantAvailability(obj.masterVariant.sku),
+			},
 			variants: obj.variants.map((variant) => ({
 				...variant,
-				availability: variant.sku
-					? availabilityBySku.get(variant.sku)
-					: { isOnStock: false, availableQuantity: 0, isOnStockForChannel: [] },
+				availability: getVariantAvailability(variant.sku),
 			})),
 			productType: product.productType,
 			hasStagedChanges: product.masterData.hasStagedChanges,

package/src/repositories/as-associate.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "vitest";
+import type { Config } from "~src/config";
+import { InMemoryStorage } from "~src/storage";
+import {
+	AsAssociateCartRepository,
+	AsAssociateOrderRepository,
+	AsAssociateQuoteRequestRepository,
+} from "./as-associate";
+import { CustomerRepository } from "./customer";
+
+describe("As Associate Repositories", () => {
+	const storage = new InMemoryStorage();
+	const config: Config = { storage, strict: false };
+
+	test("AsAssociateCartRepository can create and retrieve carts", () => {
+		const repository = new AsAssociateCartRepository(config);
+		const ctx = { projectKey: "test-project" };
+
+		const cartDraft = {
+			currency: "EUR",
+			inventoryMode: "None" as const,
+			taxMode: "Platform" as const,
+			taxRoundingMode: "HalfEven" as const,
+			taxCalculationMode: "UnitPriceLevel" as const,
+		};
+
+		const cart = repository.create(ctx, cartDraft);
+		expect(cart.id).toBeDefined();
+		expect(cart.version).toBe(1);
+		expect(cart.totalPrice.currencyCode).toBe("EUR");
+
+		// Test query
+		const result = repository.query(ctx);
+		expect(result.count).toBe(1);
+		expect(result.results[0].id).toBe(cart.id);
+
+		// Test get
+		const retrieved = repository.get(ctx, cart.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(cart.id);
+	});
+
+	test("AsAssociateOrderRepository can create and retrieve orders", () => {
+		const repository = new AsAssociateOrderRepository(config);
+		const ctx = { projectKey: "test-project" };
+
+		// First create a cart to create an order from
+		const cartRepository = new AsAssociateCartRepository(config);
+		const cartDraft = {
+			currency: "EUR",
+			inventoryMode: "None" as const,
+			taxMode: "Platform" as const,
+			taxRoundingMode: "HalfEven" as const,
+			taxCalculationMode: "UnitPriceLevel" as const,
+		};
+		const cart = cartRepository.create(ctx, cartDraft);
+
+		const orderDraft = {
+			cart: {
+				id: cart.id,
+				typeId: "cart" as const,
+			},
+			version: cart.version,
+		};
+
+		const order = repository.create(ctx, orderDraft);
+		expect(order.id).toBeDefined();
+		expect(order.version).toBe(1);
+		expect(order.cart?.id).toBe(cart.id);
+
+		// Test query
+		const result = repository.query(ctx);
+		expect(result.count).toBe(1);
+		expect(result.results[0].id).toBe(order.id);
+
+		// Test get
+		const retrieved = repository.get(ctx, order.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(order.id);
+	});
+
+	test("AsAssociateQuoteRequestRepository can create and retrieve quote requests", () => {
+		const repository = new AsAssociateQuoteRequestRepository(config);
+		const ctx = { projectKey: "test-project" };
+
+		// Create a customer using the customer repository
+		const customerRepository = new CustomerRepository(config);
+		const customer = customerRepository.create(ctx, {
+			email: "test@example.com",
+			password: "password123",
+			firstName: "John",
+			lastName: "Doe",
+		});
+
+		// First create a cart to create a quote request from
+		const cartRepository = new AsAssociateCartRepository(config);
+		const cartDraft = {
+			currency: "EUR",
+			customerId: customer.id,
+		};
+		const cart = cartRepository.create(ctx, cartDraft);
+
+		const quoteRequestDraft = {
+			cart: {
+				id: cart.id,
+				typeId: "cart" as const,
+			},
+			cartVersion: cart.version,
+		};
+
+		const quoteRequest = repository.create(ctx, quoteRequestDraft);
+		expect(quoteRequest.id).toBeDefined();
+		expect(quoteRequest.version).toBe(1);
+		expect(quoteRequest.cart?.id).toBe(cart.id);
+
+		// Test query
+		const result = repository.query(ctx);
+		expect(result.count).toBe(1);
+		expect(result.results[0].id).toBe(quoteRequest.id);
+
+		// Test get
+		const retrieved = repository.get(ctx, quoteRequest.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(quoteRequest.id);
+	});
+});

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();
+	});
+});