Improve code coverage for src/repositories to exceed 80% minimum (#304)

This PR significantly improves code coverage for files in the
`src/repositories` path, bringing all targeted files above the 80%
minimum threshold as requested in the issue.

## Summary of Changes

Added comprehensive test suites for 10 repository files that had low
test coverage:

| Repository File | Before | After | Improvement |
|----------------|--------|-------|-------------|
| `index.ts` | 0% | **100%** | +100% |
| `extension.ts` | 24.66% | **100%** | +75.34% |
| `as-associate.ts` | 35.48% | **100%** | +64.52% |
| `business-unit.ts` | 40.65% | **88.34%** | +47.69% |
| `customer-group.ts` | 42.85% | **100%** | +57.15% |
| `attribute-group.ts` | 45.94% | **100%** | +54.06% |
| `channel.ts` | 45.83% | **100%** | +54.17% |
| `review.ts` | 50.25% | **96.05%** | +45.80% |
| `subscription.ts` | 50.74% | **100%** | +49.26% |
| `zone.ts` | 45.83% | **100%** | +54.17% |

## Test Coverage Added

- **82 comprehensive test cases** across 10 new test files
- Full CRUD operations testing for all repositories
- All update actions covered for each repository type
- Error handling and edge case validation
- Custom field management and multi-language support
- Complex data structure handling (addresses, geo-coordinates, business
hierarchies)

## Bug Fixes

1. **Fixed missing `key` field in review repository**: The `key` field
from `ReviewDraft` was not being preserved during creation
2. **Fixed missing `unitType` in business-unit repository**: Company and
Division types were not setting the required `unitType` field

## Key Features Tested

- Repository factory functions and dependency injection
- Resource reference resolution and validation  
- Secret masking for sensitive data (extensions, subscriptions)
- Geographic location management (zones, channels)
- Business unit hierarchy (companies and divisions)
- Multi-language support (attribute groups, channels)
- Event subscription handling with multiple destination types

All tests follow existing patterns in the codebase and focus on business
logic validation while making minimal changes to achieve maximum
coverage improvement.

Fixes #303.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: mvantellingen <245297+mvantellingen@users.noreply.github.com>

Author: Copilot

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

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