@labdigital/commercetools-mock 1.2.0 → 1.3.1

package/src/services/standalone-price.test.ts

@@ -1,275 +1,286 @@
-import { StandalonePriceDraft } from '@commercetools/platform-sdk'
+import type { StandalonePriceDraft } from '@commercetools/platform-sdk'
 import supertest from 'supertest'
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from 'vitest'
 import { CommercetoolsMock } from '../index'
 
 const ctMock = new CommercetoolsMock()
 
 describe('Standalone price Query', () => {
-    beforeAll(async () => {
-        const draft: StandalonePriceDraft = {
-            value: {
-                centAmount: 100,
-                currencyCode: 'EUR',
-            },
-            country: 'DE',
-            sku: 'foo',
-            active: true,
-            channel: {
-                typeId: 'channel',
-                id: 'bar',
-            },
-            discounted: {
-                value: {
-                    centAmount: 80,
-                    currencyCode: 'EUR',
-                },
-                discount: {
-                    typeId: 'product-discount',
-                    id: 'baz',
-                },
-            },
-        }
-        const createResponse = await supertest(ctMock.app)
-            .post('/dummy/standalone-prices')
-            .send(draft)
-        expect(createResponse.status).toEqual(201)
-    })
+  beforeAll(async () => {
+    const draft: StandalonePriceDraft = {
+      value: {
+        centAmount: 100,
+        currencyCode: 'EUR',
+      },
+      country: 'DE',
+      sku: 'foo',
+      active: true,
+      channel: {
+        typeId: 'channel',
+        id: 'bar',
+      },
+      discounted: {
+        value: {
+          centAmount: 80,
+          currencyCode: 'EUR',
+        },
+        discount: {
+          typeId: 'product-discount',
+          id: 'baz',
+        },
+      },
+    }
+    const createResponse = await supertest(ctMock.app)
+      .post('/dummy/standalone-prices')
+      .send(draft)
+    expect(createResponse.status).toEqual(201)
+  })
 
-    afterAll(async () => {
-        ctMock.clear()
-    })
+  afterAll(async () => {
+    ctMock.clear()
+  })
 
-    test('Get standalone price', async () => {
-        const response = await supertest(ctMock.app).get('/dummy/standalone-prices?sku=foo')
+  test('Get standalone price', async () => {
+    const response = await supertest(ctMock.app).get(
+      '/dummy/standalone-prices?sku=foo'
+    )
 
-        expect(response.status).toBe(200)
+    expect(response.status).toBe(200)
 
-        expect(response.body.results).toEqual([
-            {
-                active: true,
-                channel: {
-                    id: 'bar',
-                    typeId: 'channel',
-                },
-                country: 'DE',
-                createdAt: expect.anything(),
-                discounted: {
-                    discount: {
-                        id: 'baz',
-                        typeId: 'product-discount',
-                    },
-                    value: {
-                        centAmount: 80,
-                        currencyCode: 'EUR',
-                        fractionDigits: 2,
-                        type: 'centPrecision',
-                    },
-                },
-                id: expect.anything(),
-                lastModifiedAt: expect.anything(),
-                sku: 'foo',
-                value: {
-                    centAmount: 100,
-                    currencyCode: 'EUR',
-                    fractionDigits: 2,
-                    type: 'centPrecision',
-                },
-                version: 1,
-            },
-        ])
-    })
+    expect(response.body.results).toEqual([
+      {
+        active: true,
+        channel: {
+          id: 'bar',
+          typeId: 'channel',
+        },
+        country: 'DE',
+        createdAt: expect.anything(),
+        discounted: {
+          discount: {
+            id: 'baz',
+            typeId: 'product-discount',
+          },
+          value: {
+            centAmount: 80,
+            currencyCode: 'EUR',
+            fractionDigits: 2,
+            type: 'centPrecision',
+          },
+        },
+        id: expect.anything(),
+        lastModifiedAt: expect.anything(),
+        sku: 'foo',
+        value: {
+          centAmount: 100,
+          currencyCode: 'EUR',
+          fractionDigits: 2,
+          type: 'centPrecision',
+        },
+        version: 1,
+      },
+    ])
+  })
 })
 
 describe('Standalone price Actions', () => {
-    let id: string | undefined
-    beforeEach(async () => {
-        const draft: StandalonePriceDraft = {
-            value: {
-                centAmount: 100,
-                currencyCode: 'EUR',
-            },
-            country: 'DE',
-            sku: 'foo',
-            active: true,
-            channel: {
-                typeId: 'channel',
-                id: 'bar',
-            },
-        }
-        const createResponse = await supertest(ctMock.app)
-            .post('/dummy/standalone-prices')
-            .send(draft)
-        expect(createResponse.status).toEqual(201)
-        id = createResponse.body.id
-    })
+  let id: string | undefined
+  beforeEach(async () => {
+    const draft: StandalonePriceDraft = {
+      value: {
+        centAmount: 100,
+        currencyCode: 'EUR',
+      },
+      country: 'DE',
+      sku: 'foo',
+      active: true,
+      channel: {
+        typeId: 'channel',
+        id: 'bar',
+      },
+    }
+    const createResponse = await supertest(ctMock.app)
+      .post('/dummy/standalone-prices')
+      .send(draft)
+    expect(createResponse.status).toEqual(201)
+    id = createResponse.body.id
+  })
 
-    afterEach(async () => {
-        ctMock.clear()
-    })
-
-    test('changeValue', async () => {
-        const response = await supertest(ctMock.app)
-            .post('/dummy/standalone-prices/' + id)
-            .send({
-                version: 1,
-                actions: [
-                    {
-                        action: 'changeValue',
-                        value: {
-                            centAmount: 200,
-                            currencyCode: 'EUR',
-                        },
-                    },
-                ],
-            })
-
-        expect(response.status).toBe(200)
+  afterEach(async () => {
+    ctMock.clear()
+  })
 
-        expect(response.body).toEqual({
-            active: true,
-            channel: {
-                id: 'bar',
-                typeId: 'channel',
-            },
-            country: 'DE',
-            createdAt: expect.anything(),
-            id: id,
-            lastModifiedAt: expect.anything(),
-            sku: 'foo',
+  test('changeValue', async () => {
+    const response = await supertest(ctMock.app)
+      .post('/dummy/standalone-prices/' + id)
+      .send({
+        version: 1,
+        actions: [
+          {
+            action: 'changeValue',
             value: {
-                centAmount: 200,
-                currencyCode: 'EUR',
-                fractionDigits: 2,
-                type: 'centPrecision',
+              centAmount: 200,
+              currencyCode: 'EUR',
             },
-            version: 2,
-        })
-    })
+          },
+        ],
+      })
 
-    test('setActive', async () => {
-        const response = await supertest(ctMock.app)
-            .post('/dummy/standalone-prices/' + id)
-            .send({
-                version: 1,
-                actions: [
-                    {
-                        action: 'setActive',
-                        active: false,
-                    },
-                ],
-            })
+    expect(response.status).toBe(200)
 
-        expect(response.status).toBe(200)
+    expect(response.body).toEqual({
+      active: true,
+      channel: {
+        id: 'bar',
+        typeId: 'channel',
+      },
+      country: 'DE',
+      createdAt: expect.anything(),
+      id: id,
+      lastModifiedAt: expect.anything(),
+      sku: 'foo',
+      value: {
+        centAmount: 200,
+        currencyCode: 'EUR',
+        fractionDigits: 2,
+        type: 'centPrecision',
+      },
+      version: 2,
+    })
+  })
 
-        expect(response.body).toEqual({
+  test('setActive', async () => {
+    const response = await supertest(ctMock.app)
+      .post('/dummy/standalone-prices/' + id)
+      .send({
+        version: 1,
+        actions: [
+          {
+            action: 'setActive',
             active: false,
-            channel: {
-                id: 'bar',
-                typeId: 'channel',
-            },
-            country: 'DE',
-            createdAt: expect.anything(),
-            id: id,
-            lastModifiedAt: expect.anything(),
-            sku: 'foo',
-            value: {
-                centAmount: 100,
-                currencyCode: 'EUR',
-                fractionDigits: 2,
-                type: 'centPrecision',
-            },
-            version: 2,
-        })
-    })
+          },
+        ],
+      })
 
-    test('setDiscounted', async () => {
-        const response = await supertest(ctMock.app)
-            .post('/dummy/standalone-prices/' + id)
-            .send({
-                version: 1,
-                actions: [
-                    {
-                        action: 'setDiscountedPrice',
-                        discounted: {
-                            value: {
-                                centAmount: 80,
-                                currencyCode: 'EUR',
-                            },
-                            discount: {
-                                typeId: 'product-discount',
-                                id: 'baz',
-                            },
-                        },
-                    },
-                ],
-            })
+    expect(response.status).toBe(200)
 
-        expect(response.status).toBe(200)
+    expect(response.body).toEqual({
+      active: false,
+      channel: {
+        id: 'bar',
+        typeId: 'channel',
+      },
+      country: 'DE',
+      createdAt: expect.anything(),
+      id: id,
+      lastModifiedAt: expect.anything(),
+      sku: 'foo',
+      value: {
+        centAmount: 100,
+        currencyCode: 'EUR',
+        fractionDigits: 2,
+        type: 'centPrecision',
+      },
+      version: 2,
+    })
+  })
 
-        expect(response.body).toEqual({
-            active: true,
-            channel: {
-                id: 'bar',
-                typeId: 'channel',
-            },
-            country: 'DE',
-            createdAt: expect.anything(),
+  test('setDiscounted', async () => {
+    const response = await supertest(ctMock.app)
+      .post('/dummy/standalone-prices/' + id)
+      .send({
+        version: 1,
+        actions: [
+          {
+            action: 'setDiscountedPrice',
             discounted: {
-                discount: {
-                    id: 'baz',
-                    typeId: 'product-discount',
-                },
-                value: {
-                    centAmount: 80,
-                    currencyCode: 'EUR',
-                    fractionDigits: 2,
-                    type: 'centPrecision',
-                },
-            },
-            id: id,
-            lastModifiedAt: expect.anything(),
-            sku: 'foo',
-            value: {
-                centAmount: 100,
+              value: {
+                centAmount: 80,
                 currencyCode: 'EUR',
-                fractionDigits: 2,
-                type: 'centPrecision',
+              },
+              discount: {
+                typeId: 'product-discount',
+                id: 'baz',
+              },
             },
-            version: 2,
-        })
+          },
+        ],
+      })
 
-        const response2 = await supertest(ctMock.app)
-            .post('/dummy/standalone-prices/' + id)
-            .send({
-                version: 2,
-                actions: [
-                    {
-                        action: 'setDiscountedPrice',
-                        discounted: null,
-                    },
-                ],
-            })
+    expect(response.status).toBe(200)
 
-        expect(response2.status).toBe(200)
+    expect(response.body).toEqual({
+      active: true,
+      channel: {
+        id: 'bar',
+        typeId: 'channel',
+      },
+      country: 'DE',
+      createdAt: expect.anything(),
+      discounted: {
+        discount: {
+          id: 'baz',
+          typeId: 'product-discount',
+        },
+        value: {
+          centAmount: 80,
+          currencyCode: 'EUR',
+          fractionDigits: 2,
+          type: 'centPrecision',
+        },
+      },
+      id: id,
+      lastModifiedAt: expect.anything(),
+      sku: 'foo',
+      value: {
+        centAmount: 100,
+        currencyCode: 'EUR',
+        fractionDigits: 2,
+        type: 'centPrecision',
+      },
+      version: 2,
+    })
 
-        expect(response2.body).toEqual({
-            active: true,
-            channel: {
-                id: 'bar',
-                typeId: 'channel',
-            },
-            country: 'DE',
-            createdAt: expect.anything(),
-            id: id,
-            lastModifiedAt: expect.anything(),
-            sku: 'foo',
-            value: {
-                centAmount: 100,
-                currencyCode: 'EUR',
-                fractionDigits: 2,
-                type: 'centPrecision',
-            },
-            version: 3,
-        })
+    const response2 = await supertest(ctMock.app)
+      .post('/dummy/standalone-prices/' + id)
+      .send({
+        version: 2,
+        actions: [
+          {
+            action: 'setDiscountedPrice',
+            discounted: null,
+          },
+        ],
+      })
+
+    expect(response2.status).toBe(200)
+
+    expect(response2.body).toEqual({
+      active: true,
+      channel: {
+        id: 'bar',
+        typeId: 'channel',
+      },
+      country: 'DE',
+      createdAt: expect.anything(),
+      id: id,
+      lastModifiedAt: expect.anything(),
+      sku: 'foo',
+      value: {
+        centAmount: 100,
+        currencyCode: 'EUR',
+        fractionDigits: 2,
+        type: 'centPrecision',
+      },
+      version: 3,
     })
-})
+  })
+})

package/src/services/state.test.ts

@@ -1,5 +1,6 @@
-import { StateDraft } from '@commercetools/platform-sdk'
+import { type StateDraft } from '@commercetools/platform-sdk'
 import supertest from 'supertest'
+import { describe, expect, test } from 'vitest'
 import { CommercetoolsMock } from '../index'
 
 const ctMock = new CommercetoolsMock()

package/src/services/store.test.ts

@@ -1,4 +1,6 @@
+import type { Store } from '@commercetools/platform-sdk'
 import supertest from 'supertest'
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest'
 import { CommercetoolsMock } from '../index'
 
 const ctMock = new CommercetoolsMock()
@@ -23,6 +25,7 @@ describe('Store', () => {
       createdAt: '',
       lastModifiedAt: '',
       key: 'STOREKEY',
+      countries: [],
       languages: [],
       distributionChannels: [],
       supplyChannels: [],
@@ -40,11 +43,12 @@ describe('Store', () => {
       id: 'fake-store',
       key: 'STOREKEY',
       lastModifiedAt: '',
+      countries: [],
       languages: [],
       distributionChannels: [],
       supplyChannels: [],
       productSelections: [],
-    })
+    } as Store)
   })
 
   test('Get store by 404 when not found by key', async () => {
@@ -54,6 +58,7 @@ describe('Store', () => {
       createdAt: '',
       lastModifiedAt: '',
       key: 'STOREKEY',
+      countries: [],
       languages: [],
       distributionChannels: [],
       supplyChannels: [],

package/src/services/tax-category.test.ts

@@ -1,5 +1,6 @@
-import { TaxCategoryDraft } from '@commercetools/platform-sdk'
+import type { TaxCategoryDraft } from '@commercetools/platform-sdk'
 import supertest from 'supertest'
+import { afterEach, describe, expect, test } from 'vitest'
 import { CommercetoolsMock } from '../index'
 
 const ctMock = new CommercetoolsMock()

package/src/storage/abstract.ts

@@ -1,4 +1,4 @@
-import {
+import type {
     BaseResource,
     Project,
     QueryParam,

package/src/storage/in-memory.ts

@@ -1,4 +1,7 @@
-import {
+import type {
+  AssociateRole,
+  AttributeGroup,
+  BusinessUnit,
   Cart,
   CartDiscount,
   Category,
@@ -65,6 +68,9 @@ export class InMemoryStorage extends AbstractStorage {
     let projectStorage = this.resources[projectKey]
     if (!projectStorage) {
       projectStorage = this.resources[projectKey] = {
+        'associate-role': new Map<string, AssociateRole>(),
+        'attribute-group': new Map<string, AttributeGroup>(),
+        'business-unit': new Map<string, BusinessUnit>(),
         cart: new Map<string, Cart>(),
         'cart-discount': new Map<string, CartDiscount>(),
         category: new Map<string, Category>(),

package/src/types.ts

@@ -1,4 +1,4 @@
-import * as ctp from '@commercetools/platform-sdk'
+import type * as ctp from '@commercetools/platform-sdk'
 import { RepositoryMap } from './repositories'
 import AbstractService from './services/abstract'
 
@@ -21,6 +21,9 @@ export type Services = Partial<{
 export type ResourceType = keyof ResourceMap & keyof RepositoryMap
 
 export type ResourceMap = {
+  'attribute-group': ctp.AttributeGroup
+  'associate-role': ctp.AssociateRole
+  'business-unit': ctp.BusinessUnit
   'cart-discount': ctp.CartDiscount
   cart: ctp.Cart
   category: ctp.Category
@@ -58,6 +61,9 @@ export type ResourceMap = {
 }
 
 export type PagedQueryResponseMap = {
+  'attribute-group': ctp.AttributeGroupPagedQueryResponse
+  'associate-role': ctp.AssociateRolePagedQueryResponse
+  'business-unit': ctp.BusinessUnitPagedQueryResponse
   'cart-discount': ctp.CartDiscountPagedQueryResponse
   cart: ctp.CartPagedQueryResponse
   category: ctp.CategoryPagedQueryResponse