@labdigital/commercetools-mock 1.6.0 → 1.6.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@labdigital/commercetools-mock",
   "author": "Michael van Tellingen",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "license": "MIT",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/repositories/cart-discount.ts

@@ -2,7 +2,9 @@ import type {
 	CartDiscount,
 	CartDiscountChangeIsActiveAction,
 	CartDiscountChangeSortOrderAction,
+	CartDiscountChangeTargetAction,
 	CartDiscountDraft,
+	CartDiscountSetCustomFieldAction,
 	CartDiscountSetDescriptionAction,
 	CartDiscountSetKeyAction,
 	CartDiscountSetValidFromAction,
@@ -14,6 +16,7 @@ import type {
 	CartDiscountValueFixed,
 	CartDiscountValueGiftLineItem,
 	CartDiscountValueRelative,
+	InvalidOperationError,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers.js'
 import type { Writable } from '../types.js'
@@ -21,7 +24,12 @@ import {
 	AbstractResourceRepository,
 	type RepositoryContext,
 } from './abstract.js'
-import { createTypedMoney, getStoreKeyReference } from './helpers.js'
+import {
+	createCustomFields,
+	createTypedMoney,
+	getStoreKeyReference,
+} from './helpers.js'
+import { CommercetoolsError } from '../exceptions.js'
 
 export class CartDiscountRepository extends AbstractResourceRepository<'cart-discount'> {
 	getTypeId() {
@@ -48,6 +56,11 @@ export class CartDiscountRepository extends AbstractResourceRepository<'cart-dis
 			validFrom: draft.validFrom,
 			validUntil: draft.validUntil,
 			value: this.transformValueDraft(draft.value),
+			custom: createCustomFields(
+				draft.custom,
+				context.projectKey,
+				this._storage
+			),
 		}
 		this.saveNew(context, resource)
 		return resource
@@ -142,5 +155,40 @@ export class CartDiscountRepository extends AbstractResourceRepository<'cart-dis
 		) => {
 			resource.isActive = isActive
 		},
+		changeTarget: (
+			context: RepositoryContext,
+			resource: Writable<CartDiscount>,
+			{ target }: CartDiscountChangeTargetAction
+		) => {
+			resource.target = target
+		},
+
+		setCustomField: (
+			context: RepositoryContext,
+			resource: Writable<CartDiscount>,
+			{ name, value }: CartDiscountSetCustomFieldAction
+		) => {
+			if (!resource.custom) {
+				return
+			}
+			if (value === null) {
+				if (name in resource.custom.fields) {
+					delete resource.custom.fields[name]
+				} else {
+					throw new CommercetoolsError<InvalidOperationError>(
+						{
+							code: 'InvalidOperation',
+							message:
+								'Cannot remove custom field ' +
+								name +
+								' because it does not exist.',
+						},
+						400
+					)
+				}
+			} else {
+				resource.custom.fields[name] = value
+			}
+		},
 	}
 }

package/src/repositories/category.ts

@@ -1,8 +1,12 @@
 import type {
+	Asset,
+	AssetDraft,
 	Category,
+	CategoryAddAssetAction,
 	CategoryChangeAssetNameAction,
 	CategoryChangeSlugAction,
 	CategoryDraft,
+	CategoryRemoveAssetAction,
 	CategorySetAssetDescriptionAction,
 	CategorySetAssetSourcesAction,
 	CategorySetCustomFieldAction,
@@ -27,6 +31,15 @@ export class CategoryRepository extends AbstractResourceRepository<'category'> {
 		return 'category' as const
 	}
 
+	assetFromAssetDraft = (
+		draft: AssetDraft,
+		context: RepositoryContext
+	): Asset => ({
+		...draft,
+		id: uuidv4(),
+		custom: createCustomFields(draft.custom, context.projectKey, this._storage),
+	})
+
 	create(context: RepositoryContext, draft: CategoryDraft): Category {
 		const resource: Category = {
 			...getBaseResourceProperties(),
@@ -177,5 +190,41 @@ export class CategoryRepository extends AbstractResourceRepository<'category'> {
 				resource.custom.fields[name] = value
 			}
 		},
+		removeAsset: (
+			context: RepositoryContext,
+			resource: Writable<Category>,
+			{ assetId, assetKey }: CategoryRemoveAssetAction
+		) => {
+			if (!resource.assets) {
+				return
+			}
+
+			if (assetId) {
+				resource.assets = resource.assets.filter(function (obj) {
+					return obj.id !== assetId
+				})
+
+				return
+			}
+
+			if (assetKey) {
+				resource.assets = resource.assets.filter(function (obj) {
+					return obj.key !== assetKey
+				})
+
+				return
+			}
+		},
+		addAsset: (
+			context: RepositoryContext,
+			resource: Writable<Category>,
+			{ asset }: CategoryAddAssetAction
+		) => {
+			if (!resource.assets) {
+				resource.assets = [this.assetFromAssetDraft(asset, context)]
+			} else {
+				resource.assets.push(this.assetFromAssetDraft(asset, context))
+			}
+		},
 	}
 }

package/src/repositories/product-projection.ts

@@ -5,12 +5,16 @@ import type {
 	QueryParam,
 } from '@commercetools/platform-sdk'
 import { ParsedQs } from 'qs'
+import { CommercetoolsError } from '../exceptions.js'
 import { QueryParamsAsArray } from '../helpers.js'
+import { parseQueryExpression } from '../lib/predicateParser.js'
 import { ProductProjectionSearch } from '../product-projection-search.js'
 import { type AbstractStorage } from '../storage/index.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
-import { parseQueryExpression } from '../lib/predicateParser.js'
-import { CommercetoolsError } from '../exceptions.js'
+import {
+	AbstractResourceRepository,
+	GetParams,
+	RepositoryContext,
+} from './abstract.js'
 
 type ProductProjectionQueryParams = {
 	staged?: boolean
@@ -45,6 +49,23 @@ export class ProductProjectionRepository extends AbstractResourceRepository<'pro
 		throw new Error('No valid action')
 	}
 
+	get(
+		context: RepositoryContext,
+		id: string,
+		params: GetParams = {}
+	): ProductProjection | null {
+		const resource = this._storage.get(
+			context.projectKey,
+			'product',
+			id,
+			params
+		)
+		if (resource) {
+			return this._searchService.transform(resource, false)
+		}
+		return null
+	}
+
 	query(context: RepositoryContext, params: ProductProjectionQueryParams = {}) {
 		let resources = this._storage
 			.all(context.projectKey, 'product')

package/src/repositories/store.ts

@@ -3,6 +3,7 @@ import type {
 	ChannelResourceIdentifier,
 	Store,
 	StoreDraft,
+	StoreSetCountriesAction,
 	StoreSetCustomFieldAction,
 	StoreSetCustomTypeAction,
 	StoreSetDistributionChannelsAction,
@@ -124,5 +125,12 @@ export class StoreRepository extends AbstractResourceRepository<'store'> {
 				resource.custom.fields[name] = value
 			}
 		},
+		setCountries: (
+			context: RepositoryContext,
+			resource: Writable<Store>,
+			{ countries }: StoreSetCountriesAction
+		) => {
+			resource.countries = countries ?? []
+		},
 	}
 }

package/src/services/cart-discount.test.ts

@@ -0,0 +1,362 @@
+import assert from 'assert'
+import supertest from 'supertest'
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import { CommercetoolsMock } from '../index.js'
+import { CartDiscount, TypeDraft } from '@commercetools/platform-sdk'
+
+const typeDraft: TypeDraft = {
+	key: 'my-type',
+	name: {
+		en: 'TestType',
+	},
+	description: {
+		en: 'Test Type',
+	},
+	resourceTypeIds: ['cart-discount'],
+	fieldDefinitions: [
+		{
+			name: 'discount_name',
+			label: {
+				en: 'Discount name',
+			},
+			required: false,
+			type: {
+				name: 'String',
+			},
+			inputHint: 'SingleLine',
+		},
+		{
+			name: 'fixedAmount',
+			label: {
+				en: 'Fixed Amount',
+			},
+			required: true,
+			type: {
+				name: 'Money',
+			},
+			inputHint: 'SingleLine',
+		},
+	],
+}
+
+const getCartDiscountDraft = (typeId: string) => ({
+	version: 1,
+	key: 'my-relative-cart-discount',
+	name: { en: 'myRelativeCartDiscount' },
+	value: {
+		type: 'relative',
+		permyriad: 1000,
+	},
+	description: { en: 'My relative cart discount' },
+	target: { type: 'lineItems', predicate: '1=1' },
+	isActive: false,
+	custom: {
+		type: {
+			typeId: 'type',
+			id: typeId,
+		},
+		fields: {
+			discount_name: 'MyDiscount',
+			fixedAmount: {
+				type: 'centPrecision',
+				currencyCode: 'USD',
+				centAmount: 15000,
+				fractionDigits: 2,
+			},
+		},
+	},
+	validFrom: '2000-01-01T00:00:01.000Z',
+	validUntil: '2000-12-31T23:59:59.999Z',
+	sortOrder: '0.1',
+})
+
+describe('Cart Discounts Query', () => {
+	const ctMock = new CommercetoolsMock()
+
+	beforeEach(async () => {
+		let response
+		response = await supertest(ctMock.app).post('/dummy/types').send(typeDraft)
+		expect(response.status).toBe(201)
+		const typeId = response._body.id
+
+		response = await supertest(ctMock.app)
+			.post('/dummy/cart-discounts')
+			.send(getCartDiscountDraft(typeId))
+		expect(response.status).toBe(201)
+	})
+
+	test('no filter', async () => {
+		const response = await supertest(ctMock.app)
+			.get('/dummy/cart-discounts')
+			.send()
+
+		expect(response.status).toBe(200)
+		expect(response.body.count).toBe(1)
+
+		const myRelativeCartDiscount = response.body.results[0] as CartDiscount
+		expect(myRelativeCartDiscount.key).toBe('my-relative-cart-discount')
+		expect(myRelativeCartDiscount.description).toStrictEqual({
+			en: 'My relative cart discount',
+		})
+		expect(myRelativeCartDiscount.isActive).toBe(false)
+		expect(myRelativeCartDiscount.name).toStrictEqual({
+			en: 'myRelativeCartDiscount',
+		})
+		expect(myRelativeCartDiscount.stores).toStrictEqual([])
+		expect(myRelativeCartDiscount.references).toStrictEqual([])
+		expect(myRelativeCartDiscount.target).toStrictEqual({
+			type: 'lineItems',
+			predicate: '1=1',
+		})
+		expect(myRelativeCartDiscount.requiresDiscountCode).toBe(false)
+		expect(myRelativeCartDiscount.stackingMode).toBe('Stacking')
+		expect(myRelativeCartDiscount.value).toStrictEqual({
+			type: 'relative',
+			permyriad: 1000,
+		})
+
+		expect(myRelativeCartDiscount.custom?.type.id).not.toBeUndefined()
+		expect(myRelativeCartDiscount.custom?.type.typeId).toBe('type')
+		expect(myRelativeCartDiscount.custom?.fields).toStrictEqual({
+			discount_name: 'MyDiscount',
+			fixedAmount: {
+				centAmount: 15000,
+				currencyCode: 'USD',
+				fractionDigits: 2,
+				type: 'centPrecision',
+			},
+		})
+	})
+})
+
+describe('Cart Discounts Update Actions', () => {
+	const ctMock = new CommercetoolsMock()
+	let cartDiscount: CartDiscount | undefined
+
+	const createType = async () => {
+		const response = await supertest(ctMock.app)
+			.post('/dummy/types')
+			.send(typeDraft)
+		expect(response.status).toBe(201)
+		return response.body.id
+	}
+
+	const createCartDiscount = async (typeId) => {
+		const cartDiscountDraft = getCartDiscountDraft(typeId)
+		const response = await supertest(ctMock.app)
+			.post('/dummy/cart-discounts')
+			.send(cartDiscountDraft)
+		expect(response.status).toBe(201)
+		cartDiscount = response.body
+	}
+
+	beforeEach(async () => {
+		const typeId = await createType()
+		await createCartDiscount(typeId)
+	})
+
+	afterEach(() => {
+		ctMock.clear()
+	})
+
+	test('set key', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [{ action: 'setKey', key: 'my-cart-discount' }],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.key).toBe('my-cart-discount')
+	})
+
+	test('set description', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{ action: 'setDescription', description: { en: 'Description' } },
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.description.en).toBe('Description')
+	})
+
+	test('set valid from', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{ action: 'setValidFrom', validFrom: '2020-01-01T00:00:01.000Z' },
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.validFrom).toBe('2020-01-01T00:00:01.000Z')
+	})
+
+	test('set valid until', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{ action: 'setValidUntil', validUntil: '2020-12-31T23:59:59.999Z' },
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.validUntil).toBe('2020-12-31T23:59:59.999Z')
+	})
+
+	test('set valid from and until', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'setValidFromAndUntil',
+						validFrom: '2020-01-01T00:00:01.000Z',
+						validUntil: '2020-12-31T23:59:59.999Z',
+					},
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.validFrom).toBe('2020-01-01T00:00:01.000Z')
+		expect(response.body.validUntil).toBe('2020-12-31T23:59:59.999Z')
+	})
+
+	test('change sort order', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [{ action: 'changeSortOrder', sortOrder: '0.2' }],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.sortOrder).toBe('0.2')
+	})
+
+	test('change isActive', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [{ action: 'changeIsActive', isActive: true }],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.isActive).toBe(true)
+	})
+
+	test('change target', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'changeTarget',
+						target: { type: 'shippingInfo', predicate: '2=2' },
+					},
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.target).toStrictEqual({
+			type: 'shippingInfo',
+			predicate: '2=2',
+		})
+	})
+
+	test('set custom field', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'setCustomField',
+						name: 'fixedAmount',
+						value: {
+							type: 'centPrecision',
+							currencyCode: 'EUR',
+							centAmount: 15,
+							fractionDigits: 2,
+						},
+					},
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.custom.fields.fixedAmount).toStrictEqual({
+			type: 'centPrecision',
+			currencyCode: 'EUR',
+			centAmount: 15,
+			fractionDigits: 2,
+		})
+	})
+
+	test('reset custom field', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'setCustomField',
+						name: 'fixedAmount',
+						value: null,
+					},
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.custom.fields.fixedAmount).toBeUndefined()
+	})
+
+	test('reset non-existing custom field', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'setCustomField',
+						name: 'nonExistingField',
+						value: null,
+					},
+				],
+			})
+		expect(response.status).toBe(400)
+	})
+})