@labdigital/commercetools-mock 1.5.0 → 1.6.0

package/src/services/index.ts

@@ -27,50 +27,58 @@ import { SubscriptionService } from './subscription.js'
 import { TaxCategoryService } from './tax-category.js'
 import { TypeService } from './type.js'
 import { ZoneService } from './zone.js'
+import { AttributeGroupService } from './attribute-group.js'
 
 export const createServices = (router: any, repos: any) => ({
-  category: new CategoryServices(router, repos['category']),
-  cart: new CartService(router, repos['cart'], repos['order']),
-  'cart-discount': new CartDiscountService(router, repos['cart-discount']),
-  customer: new CustomerService(router, repos['customer']),
-  channel: new ChannelService(router, repos['channel']),
-  'customer-group': new CustomerGroupService(router, repos['customer-group']),
-  'discount-code': new DiscountCodeService(router, repos['discount-code']),
-  extension: new ExtensionServices(router, repos['extension']),
-  'inventory-entry': new InventoryEntryService(
-    router,
-    repos['inventory-entry']
-  ),
-  'key-value-document': new CustomObjectService(
-    router,
-    repos['key-value-document']
-  ),
-  order: new OrderService(router, repos['order']),
-  payment: new PaymentService(router, repos['payment']),
-  'standalone-price': new StandAlonePriceService(router, repos['standalone-price']),
-  'my-cart': new MyCartService(router, repos['my-cart']),
-  'my-order': new MyOrderService(router, repos['my-order']),
-  'my-customer': new MyCustomerService(router, repos['my-customer']),
-  'my-payment': new MyPaymentService(router, repos['my-payment']),
-  'shipping-method': new ShippingMethodService(
-    router,
-    repos['shipping-method']
-  ),
-  'product-type': new ProductTypeService(router, repos['product-type']),
-  product: new ProductService(router, repos['product']),
-  'product-discount': new ProductDiscountService(
-    router,
-    repos['product-discount']
-  ),
-  'product-projection': new ProductProjectionService(
-    router,
-    repos['product-projection']
-  ),
-  'shopping-list': new ShoppingListService(router, repos['shopping-list']),
-  state: new StateService(router, repos['state']),
-  store: new StoreService(router, repos['store']),
-  subscription: new SubscriptionService(router, repos['subscription']),
-  'tax-category': new TaxCategoryService(router, repos['tax-category']),
-  type: new TypeService(router, repos['type']),
-  zone: new ZoneService(router, repos['zone']),
+	category: new CategoryServices(router, repos['category']),
+	cart: new CartService(router, repos['cart'], repos['order']),
+	'cart-discount': new CartDiscountService(router, repos['cart-discount']),
+	customer: new CustomerService(router, repos['customer']),
+	channel: new ChannelService(router, repos['channel']),
+	'customer-group': new CustomerGroupService(router, repos['customer-group']),
+	'discount-code': new DiscountCodeService(router, repos['discount-code']),
+	extension: new ExtensionServices(router, repos['extension']),
+	'inventory-entry': new InventoryEntryService(
+		router,
+		repos['inventory-entry']
+	),
+	'key-value-document': new CustomObjectService(
+		router,
+		repos['key-value-document']
+	),
+	order: new OrderService(router, repos['order']),
+	payment: new PaymentService(router, repos['payment']),
+	'standalone-price': new StandAlonePriceService(
+		router,
+		repos['standalone-price']
+	),
+	'my-cart': new MyCartService(router, repos['my-cart']),
+	'my-order': new MyOrderService(router, repos['my-order']),
+	'my-customer': new MyCustomerService(router, repos['my-customer']),
+	'my-payment': new MyPaymentService(router, repos['my-payment']),
+	'shipping-method': new ShippingMethodService(
+		router,
+		repos['shipping-method']
+	),
+	'product-type': new ProductTypeService(router, repos['product-type']),
+	product: new ProductService(router, repos['product']),
+	'product-discount': new ProductDiscountService(
+		router,
+		repos['product-discount']
+	),
+	'product-projection': new ProductProjectionService(
+		router,
+		repos['product-projection']
+	),
+	'shopping-list': new ShoppingListService(router, repos['shopping-list']),
+	state: new StateService(router, repos['state']),
+	store: new StoreService(router, repos['store']),
+	subscription: new SubscriptionService(router, repos['subscription']),
+	'tax-category': new TaxCategoryService(router, repos['tax-category']),
+	'attribute-group': new AttributeGroupService(
+		router,
+		repos['attribute-group']
+	),
+	type: new TypeService(router, repos['type']),
+	zone: new ZoneService(router, repos['zone']),
 })

package/src/services/inventory-entry.test.ts

@@ -5,169 +5,169 @@ import { afterEach, beforeEach, describe, expect, test } from 'vitest'
 import { CommercetoolsMock } from '../index.js'
 
 describe('Inventory Entry Query', () => {
-  const ctMock = new CommercetoolsMock()
-  let inventoryEntry: InventoryEntry | undefined
-
-  beforeEach(async () => {
-    const response = await supertest(ctMock.app).post('/dummy/inventory').send({
-      sku: '1337',
-      quantityOnStock: 100,
-    })
-    expect(response.status).toBe(201)
-    inventoryEntry = response.body
-  })
-
-  afterEach(() => {
-    ctMock.clear()
-  })
-
-  test('no filter', async () => {
-    assert(inventoryEntry, 'inventory entry not created')
-
-    const response = await supertest(ctMock.app).get(`/dummy/inventory`)
-    expect(response.status).toBe(200)
-    expect(response.body.count).toBe(1)
-    expect(response.body.total).toBe(1)
-    expect(response.body.offset).toBe(0)
-    expect(response.body.limit).toBe(20)
-  })
-
-  test('filter sku', async () => {
-    assert(inventoryEntry, 'inventory entry not created')
-
-    {
-      const response = await supertest(ctMock.app)
-        .get(`/dummy/inventory`)
-        .query({ where: 'sku="unknown"' })
-      expect(response.status).toBe(200)
-      expect(response.body.count).toBe(0)
-    }
-    {
-      const response = await supertest(ctMock.app)
-        .get(`/dummy/inventory`)
-        .query({ where: 'sku="1337"' })
-      expect(response.status).toBe(200)
-      expect(response.body.count).toBe(1)
-    }
-  })
+	const ctMock = new CommercetoolsMock()
+	let inventoryEntry: InventoryEntry | undefined
+
+	beforeEach(async () => {
+		const response = await supertest(ctMock.app).post('/dummy/inventory').send({
+			sku: '1337',
+			quantityOnStock: 100,
+		})
+		expect(response.status).toBe(201)
+		inventoryEntry = response.body
+	})
+
+	afterEach(() => {
+		ctMock.clear()
+	})
+
+	test('no filter', async () => {
+		assert(inventoryEntry, 'inventory entry not created')
+
+		const response = await supertest(ctMock.app).get(`/dummy/inventory`)
+		expect(response.status).toBe(200)
+		expect(response.body.count).toBe(1)
+		expect(response.body.total).toBe(1)
+		expect(response.body.offset).toBe(0)
+		expect(response.body.limit).toBe(20)
+	})
+
+	test('filter sku', async () => {
+		assert(inventoryEntry, 'inventory entry not created')
+
+		{
+			const response = await supertest(ctMock.app)
+				.get(`/dummy/inventory`)
+				.query({ where: 'sku="unknown"' })
+			expect(response.status).toBe(200)
+			expect(response.body.count).toBe(0)
+		}
+		{
+			const response = await supertest(ctMock.app)
+				.get(`/dummy/inventory`)
+				.query({ where: 'sku="1337"' })
+			expect(response.status).toBe(200)
+			expect(response.body.count).toBe(1)
+		}
+	})
 })
 
 describe('Inventory Entry Update Actions', () => {
-  const ctMock = new CommercetoolsMock()
-  let inventoryEntry: InventoryEntry | undefined
-  let customType: Type | undefined
-
-  beforeEach(async () => {
-    let response = await supertest(ctMock.app).post('/dummy/inventory').send({
-      sku: '1337',
-      quantityOnStock: 100,
-    })
-    expect(response.status).toBe(201)
-    inventoryEntry = response.body
-
-    response = await supertest(ctMock.app)
-      .post('/dummy/types')
-      .send({
-        key: 'custom-inventory',
-        name: {
-          'nl-NL': 'custom-inventory',
-        },
-        resourceTypeIds: ['inventory-entry'],
-      })
-    expect(response.status).toBe(201)
-    customType = response.body
-  })
-
-  test('changeQuantity', async () => {
-    assert(inventoryEntry, 'inventory entry not created')
-
-    const response = await supertest(ctMock.app)
-      .post(`/dummy/inventory/${inventoryEntry.id}`)
-      .send({
-        version: 1,
-        actions: [{ action: 'changeQuantity', quantity: 300 }],
-      })
-    expect(response.status).toBe(200)
-    expect(response.body.version).toBe(2)
-    expect(response.body.availableQuantity).toBe(300)
-    expect(response.body.quantityOnStock).toBe(300)
-  })
-
-  test('set custom type', async () => {
-    assert(inventoryEntry, 'inventory entry not created')
-    assert(customType, 'custom type not created')
-
-    const response = await supertest(ctMock.app)
-      .post(`/dummy/inventory/${inventoryEntry.id}`)
-      .send({
-        version: 1,
-        actions: [
-          {
-            action: 'setCustomType',
-            type: { typeId: 'type', id: customType.id },
-          },
-        ],
-      })
-    expect(response.status).toBe(200)
-    expect(response.body.version).toBe(2)
-    expect(response.body.custom.type.id).toBe(customType.id)
-  })
-
-  test('set expected delivery', async () => {
-    assert(inventoryEntry, 'inventory entry not created')
-    const expectedDelivery = '2021-04-02T15:06:19.700Z'
-    const response = await supertest(ctMock.app)
-      .post(`/dummy/inventory/${inventoryEntry.id}`)
-      .send({
-        version: 1,
-        actions: [{ action: 'setExpectedDelivery', expectedDelivery }],
-      })
-    expect(response.status).toBe(200)
-    expect(response.body.version).toBe(2)
-    expect(response.body.expectedDelivery).toBe(expectedDelivery)
-  })
-
-  test('set custom field', async () => {
-    assert(inventoryEntry, 'inventory entry not created')
-    assert(customType, 'custom type not created')
-
-    const setCustomTypeResponse = await supertest(ctMock.app)
-      .post(`/dummy/inventory/${inventoryEntry.id}`)
-      .send({
-        version: 1,
-        actions: [
-          {
-            action: 'setCustomType',
-            type: { typeId: 'type', id: customType.id },
-            fields: { lol: 'bar' },
-          },
-        ],
-      })
-    expect(setCustomTypeResponse.status).toBe(200)
-    expect(setCustomTypeResponse.body.custom.type.id).toBe(customType.id)
-
-    const response = await supertest(ctMock.app)
-      .post(`/dummy/inventory/${inventoryEntry.id}`)
-      .send({
-        version: 2,
-        actions: [{ action: 'setCustomField', name: 'foo', value: 'bar' }],
-      })
-
-    expect(response.status).toBe(200)
-    expect(response.body.version).toBe(3)
-    expect(response.body.custom.fields['foo']).toBe('bar')
-  })
-
-  test('set restockable in days', async () => {
-    assert(inventoryEntry, 'inventory entry not created')
-    const response = await supertest(ctMock.app)
-      .post(`/dummy/inventory/${inventoryEntry.id}`)
-      .send({
-        version: 1,
-        actions: [{ action: 'setRestockableInDays', restockableInDays: 0 }],
-      })
-    expect(response.status).toEqual(200)
-    expect(response.body.version).toEqual(2)
-    expect(response.body.restockableInDays).toEqual(0)
-  })
+	const ctMock = new CommercetoolsMock()
+	let inventoryEntry: InventoryEntry | undefined
+	let customType: Type | undefined
+
+	beforeEach(async () => {
+		let response = await supertest(ctMock.app).post('/dummy/inventory').send({
+			sku: '1337',
+			quantityOnStock: 100,
+		})
+		expect(response.status).toBe(201)
+		inventoryEntry = response.body
+
+		response = await supertest(ctMock.app)
+			.post('/dummy/types')
+			.send({
+				key: 'custom-inventory',
+				name: {
+					'nl-NL': 'custom-inventory',
+				},
+				resourceTypeIds: ['inventory-entry'],
+			})
+		expect(response.status).toBe(201)
+		customType = response.body
+	})
+
+	test('changeQuantity', async () => {
+		assert(inventoryEntry, 'inventory entry not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/inventory/${inventoryEntry.id}`)
+			.send({
+				version: 1,
+				actions: [{ action: 'changeQuantity', quantity: 300 }],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.availableQuantity).toBe(300)
+		expect(response.body.quantityOnStock).toBe(300)
+	})
+
+	test('set custom type', async () => {
+		assert(inventoryEntry, 'inventory entry not created')
+		assert(customType, 'custom type not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/inventory/${inventoryEntry.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'setCustomType',
+						type: { typeId: 'type', id: customType.id },
+					},
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.custom.type.id).toBe(customType.id)
+	})
+
+	test('set expected delivery', async () => {
+		assert(inventoryEntry, 'inventory entry not created')
+		const expectedDelivery = '2021-04-02T15:06:19.700Z'
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/inventory/${inventoryEntry.id}`)
+			.send({
+				version: 1,
+				actions: [{ action: 'setExpectedDelivery', expectedDelivery }],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.expectedDelivery).toBe(expectedDelivery)
+	})
+
+	test('set custom field', async () => {
+		assert(inventoryEntry, 'inventory entry not created')
+		assert(customType, 'custom type not created')
+
+		const setCustomTypeResponse = await supertest(ctMock.app)
+			.post(`/dummy/inventory/${inventoryEntry.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'setCustomType',
+						type: { typeId: 'type', id: customType.id },
+						fields: { lol: 'bar' },
+					},
+				],
+			})
+		expect(setCustomTypeResponse.status).toBe(200)
+		expect(setCustomTypeResponse.body.custom.type.id).toBe(customType.id)
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/inventory/${inventoryEntry.id}`)
+			.send({
+				version: 2,
+				actions: [{ action: 'setCustomField', name: 'foo', value: 'bar' }],
+			})
+
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(3)
+		expect(response.body.custom.fields['foo']).toBe('bar')
+	})
+
+	test('set restockable in days', async () => {
+		assert(inventoryEntry, 'inventory entry not created')
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/inventory/${inventoryEntry.id}`)
+			.send({
+				version: 1,
+				actions: [{ action: 'setRestockableInDays', restockableInDays: 0 }],
+			})
+		expect(response.status).toEqual(200)
+		expect(response.body.version).toEqual(2)
+		expect(response.body.restockableInDays).toEqual(0)
+	})
 })

package/src/services/inventory-entry.ts

@@ -3,14 +3,14 @@ import { InventoryEntryRepository } from '../repositories/inventory-entry.js'
 import AbstractService from './abstract.js'
 
 export class InventoryEntryService extends AbstractService {
-  public repository: InventoryEntryRepository
+	public repository: InventoryEntryRepository
 
-  constructor(parent: Router, repository: InventoryEntryRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: InventoryEntryRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'inventory'
-  }
+	getBasePath() {
+		return 'inventory'
+	}
 }

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

@@ -6,94 +6,94 @@ import { CommercetoolsMock } from '../index.js'
 const ctMock = new CommercetoolsMock()
 
 describe('MyCart', () => {
-  beforeEach(async () => {
-    const response = await supertest(ctMock.app)
-      .post('/dummy/types')
-      .send({
-        key: 'custom-payment',
-        name: {
-          'nl-NL': 'custom-payment',
-        },
-        resourceTypeIds: ['payment'],
-      })
-    expect(response.status).toBe(201)
-  })
+	beforeEach(async () => {
+		const response = await supertest(ctMock.app)
+			.post('/dummy/types')
+			.send({
+				key: 'custom-payment',
+				name: {
+					'nl-NL': 'custom-payment',
+				},
+				resourceTypeIds: ['payment'],
+			})
+		expect(response.status).toBe(201)
+	})
 
-  afterEach(() => {
-    ctMock.clear()
-  })
+	afterEach(() => {
+		ctMock.clear()
+	})
 
-  test('Create my cart', async () => {
-    const draft: MyCartDraft = {
-      currency: 'EUR',
-    }
+	test('Create my cart', async () => {
+		const draft: MyCartDraft = {
+			currency: 'EUR',
+		}
 
-    const response = await supertest(ctMock.app)
-      .post('/dummy/me/carts')
-      .send(draft)
+		const response = await supertest(ctMock.app)
+			.post('/dummy/me/carts')
+			.send(draft)
 
-    expect(response.status).toBe(201)
-    expect(response.body).toEqual({
-      id: expect.anything(),
-      createdAt: expect.anything(),
-      lastModifiedAt: expect.anything(),
-      version: 1,
-      cartState: 'Active',
-      discountCodes: [],
-      directDiscounts: [],
-      inventoryMode: 'None',
-      itemShippingAddresses: [],
-      lineItems: [],
-      customLineItems: [],
-      shipping: [],
-      shippingMode: 'Single',
-      totalPrice: {
-        type: 'centPrecision',
-        centAmount: 0,
-        currencyCode: 'EUR',
-        fractionDigits: 0,
-      },
-      taxMode: 'Platform',
-      taxRoundingMode: 'HalfEven',
-      taxCalculationMode: 'LineItemLevel',
-      refusedGifts: [],
-      origin: 'Customer',
-    } as Cart)
-  })
+		expect(response.status).toBe(201)
+		expect(response.body).toEqual({
+			id: expect.anything(),
+			createdAt: expect.anything(),
+			lastModifiedAt: expect.anything(),
+			version: 1,
+			cartState: 'Active',
+			discountCodes: [],
+			directDiscounts: [],
+			inventoryMode: 'None',
+			itemShippingAddresses: [],
+			lineItems: [],
+			customLineItems: [],
+			shipping: [],
+			shippingMode: 'Single',
+			totalPrice: {
+				type: 'centPrecision',
+				centAmount: 0,
+				currencyCode: 'EUR',
+				fractionDigits: 0,
+			},
+			taxMode: 'Platform',
+			taxRoundingMode: 'HalfEven',
+			taxCalculationMode: 'LineItemLevel',
+			refusedGifts: [],
+			origin: 'Customer',
+		} as Cart)
+	})
 
-  test('Get my cart by ID', async () => {
-    const draft: MyCartDraft = {
-      currency: 'EUR',
-    }
-    const createResponse = await supertest(ctMock.app)
-      .post('/dummy/me/carts')
-      .send(draft)
+	test('Get my cart by ID', async () => {
+		const draft: MyCartDraft = {
+			currency: 'EUR',
+		}
+		const createResponse = await supertest(ctMock.app)
+			.post('/dummy/me/carts')
+			.send(draft)
 
-    const response = await supertest(ctMock.app).get(
-      `/dummy/me/carts/${createResponse.body.id}`
-    )
+		const response = await supertest(ctMock.app).get(
+			`/dummy/me/carts/${createResponse.body.id}`
+		)
 
-    expect(response.status).toBe(200)
-    expect(response.body).toEqual(createResponse.body)
-  })
+		expect(response.status).toBe(200)
+		expect(response.body).toEqual(createResponse.body)
+	})
 
-  test('Get my active cart', async () => {
-    const draft: MyCartDraft = {
-      currency: 'EUR',
-    }
-    const createResponse = await supertest(ctMock.app)
-      .post('/dummy/me/carts')
-      .send(draft)
+	test('Get my active cart', async () => {
+		const draft: MyCartDraft = {
+			currency: 'EUR',
+		}
+		const createResponse = await supertest(ctMock.app)
+			.post('/dummy/me/carts')
+			.send(draft)
 
-    const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`)
+		const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`)
 
-    expect(response.status).toBe(200)
-    expect(response.body).toEqual(createResponse.body)
-  })
+		expect(response.status).toBe(200)
+		expect(response.body).toEqual(createResponse.body)
+	})
 
-  test('Get my active cart which doesnt exists', async () => {
-    const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`)
+	test('Get my active cart which doesnt exists', async () => {
+		const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`)
 
-    expect(response.status).toBe(404)
-  })
+		expect(response.status).toBe(404)
+	})
 })