@labdigital/commercetools-mock 0.5.13 → 0.5.14

package/src/repositories/type.ts

@@ -1,8 +1,22 @@
-import { Type, TypeDraft, ReferenceTypeId } from '@commercetools/platform-sdk'
+import {
+  Type,
+  TypeDraft,
+  ReferenceTypeId,
+  TypeUpdateAction,
+  FieldDefinition,
+  TypeSetDescriptionAction,
+  TypeChangeNameAction,
+  TypeAddFieldDefinitionAction,
+  TypeChangeEnumValueLabelAction,
+  TypeAddEnumValueAction,
+  TypeChangeFieldDefinitionOrderAction,
+  TypeRemoveFieldDefinitionAction,
+} from '@commercetools/platform-sdk'
+import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
 
-export class TypeRepository extends AbstractRepository {
+export class TypeRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'type'
   }
@@ -19,4 +33,120 @@ export class TypeRepository extends AbstractRepository {
     this.save(projectKey, resource)
     return resource
   }
+  actions: Partial<
+    Record<
+      TypeUpdateAction['action'],
+      (projectKey: string, resource: Writable<Type>, action: any) => void
+    >
+  > = {
+    addFieldDefinition: (
+      projectKey: string,
+      resource: Writable<Type>,
+      { fieldDefinition }: TypeAddFieldDefinitionAction
+    ) => {
+      resource.fieldDefinitions.push(fieldDefinition)
+    },
+    removeFieldDefinition: (
+      projectKey: string,
+      resource: Writable<Type>,
+      { fieldName }: TypeRemoveFieldDefinitionAction
+    ) => {
+      resource.fieldDefinitions = resource.fieldDefinitions.filter(f => {
+        return f.name !== fieldName
+      })
+    },
+    setDescription: (
+      projectKey: string,
+      resource: Writable<Type>,
+      { description }: TypeSetDescriptionAction
+    ) => {
+      resource.description = description
+    },
+    changeName: (
+      projectKey: string,
+      resource: Writable<Type>,
+      { name }: TypeChangeNameAction
+    ) => {
+      resource.name = name
+    },
+    changeFieldDefinitionOrder: (
+      projectKey: string,
+      resource: Writable<Type>,
+      { fieldNames }: TypeChangeFieldDefinitionOrderAction
+    ) => {
+      const fields = new Map(
+        resource.fieldDefinitions.map(item => [item.name, item])
+      )
+      const result: FieldDefinition[] = []
+      let current = resource.fieldDefinitions
+
+      fieldNames.forEach(fieldName => {
+        const field = fields.get(fieldName)
+        if (field === undefined) {
+          throw new Error('New field')
+        }
+        result.push(field)
+
+        // Remove from current items
+        current = current.filter(f => {
+          return f.name !== fieldName
+        })
+      })
+
+      resource.fieldDefinitions = result
+      // Add fields which were not specified in the order as last items. Not
+      // sure if this follows commercetools
+      resource.fieldDefinitions.push(...current)
+    },
+    addEnumValue: (
+      projectKey: string,
+      resource: Writable<Type>,
+      { fieldName, value }: TypeAddEnumValueAction
+    ) => {
+      resource.fieldDefinitions.forEach(field => {
+        if (field.name == fieldName) {
+          // TODO, should be done better i suppose
+          if (field.type.name == 'Enum') {
+            field.type.values.push(value)
+          } else if (
+            field.type.name == 'Set' &&
+            field.type.elementType.name == 'Enum'
+          ) {
+            field.type.elementType.values.push(value)
+          } else {
+            throw new Error('Type is not a Enum (or Set of Enum)')
+          }
+        }
+      })
+    },
+    changeEnumValueLabel: (
+      projectKey: string,
+      resource: Writable<Type>,
+      { fieldName, value }: TypeChangeEnumValueLabelAction
+    ) => {
+      resource.fieldDefinitions.forEach(field => {
+        if (field.name == fieldName) {
+          // TODO, should be done better i suppose
+          if (field.type.name == 'Enum') {
+            field.type.values.forEach(v => {
+              if (v.key == value.key) {
+                v.label = value.label
+              }
+            })
+          } else if (
+            field.type.name == 'Set' &&
+            field.type.elementType.name == 'Enum'
+          ) {
+            field.type.elementType.values.forEach(v => {
+              if (v.key == value.key) {
+                v.label = value.label
+              }
+            })
+          } else {
+            throw new Error('Type is not a Enum (or Set of Enum)')
+          }
+        }
+      })
+    },
+  }
 }

package/src/repositories/zone.ts

@@ -0,0 +1,77 @@
+import {
+  ReferenceTypeId,
+  Zone,
+  ZoneAddLocationAction,
+  ZoneChangeNameAction,
+  ZoneDraft,
+  ZoneRemoveLocationAction,
+  ZoneSetDescriptionAction,
+  ZoneSetKeyAction,
+  ZoneUpdateAction,
+} from '@commercetools/platform-sdk'
+import { Writable } from 'types'
+import { getBaseResourceProperties } from '../helpers'
+import { AbstractResourceRepository } from './abstract'
+
+export class ZoneRepository extends AbstractResourceRepository {
+  getTypeId(): ReferenceTypeId {
+    return 'zone'
+  }
+
+  create(projectKey: string, draft: ZoneDraft): Zone {
+    const resource: Zone = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      locations: draft.locations || [],
+      name: draft.name,
+      description: draft.description,
+    }
+    this.save(projectKey, resource)
+    return resource
+  }
+
+  actions: Partial<
+    Record<
+      ZoneUpdateAction['action'],
+      (projectKey: string, resource: Writable<Zone>, action: any) => void
+    >
+  > = {
+    addLocation: (
+      projectKey: string,
+      resource: Writable<Zone>,
+      { location }: ZoneAddLocationAction
+    ) => {
+      resource.locations.push(location)
+    },
+    removeLocation: (
+      projectKey: string,
+      resource: Writable<Zone>,
+      { location }: ZoneRemoveLocationAction
+    ) => {
+      resource.locations = resource.locations.filter(loc => {
+        return !(loc.country == location.country && loc.state == location.state)
+      })
+    },
+    changeName: (
+      projectKey: string,
+      resource: Writable<Zone>,
+      { name }: ZoneChangeNameAction
+    ) => {
+      resource.name = name
+    },
+    setDescription: (
+      projectKey: string,
+      resource: Writable<Zone>,
+      { description }: ZoneSetDescriptionAction
+    ) => {
+      resource.description = description
+    },
+    setKey: (
+      projectKey: string,
+      resource: Writable<Zone>,
+      { key }: ZoneSetKeyAction
+    ) => {
+      resource.key = key
+    },
+  }
+}

package/src/server.ts

@@ -1,4 +1,9 @@
 import { CommercetoolsMock } from './index'
 
 const instance = new CommercetoolsMock()
-instance.runServer(3000)
+
+let port = 3000
+
+if (process.env.HTTP_SERVER_PORT) port = parseInt(process.env.HTTP_SERVER_PORT)
+
+instance.runServer(port)

package/src/services/abstract.ts

@@ -1,12 +1,13 @@
-import { QueryParams } from './../repositories/abstract'
 import { Update } from '@commercetools/platform-sdk'
 import { ParsedQs } from 'qs'
 import { Request, Response, Router } from 'express'
-import AbstractRepository from '../repositories/abstract'
+import { AbstractResourceRepository } from '../repositories/abstract'
 
 export default abstract class AbstractService {
   protected abstract getBasePath(): string
-  public abstract repository: AbstractRepository
+  public abstract repository: AbstractResourceRepository
+
+  createStatusCode = 201
 
   constructor(parent: Router) {
     this.registerRoutes(parent)
@@ -44,7 +45,12 @@ export default abstract class AbstractService {
   }
 
   getWithId(request: Request, response: Response) {
-    return this._expandWithId(request, response, request.params['id'])
+    const result = this._expandWithId(request, request.params['id'])
+    if (!result) {
+      return response.status(404).send()
+    }
+    console.log(JSON.stringify(result, null, 4))
+    return response.status(200).send(result)
   }
 
   getWithKey(request: Request, response: Response) {
@@ -78,7 +84,8 @@ export default abstract class AbstractService {
   post(request: Request, response: Response) {
     const draft = request.body
     const resource = this.repository.create(request.params.projectKey, draft)
-    return this._expandWithId(request, response, resource.id)
+    const result = this._expandWithId(request, resource.id)
+    return response.status(this.createStatusCode).send(result)
   }
 
   postWithId(request: Request, response: Response) {
@@ -101,25 +108,19 @@ export default abstract class AbstractService {
       updateRequest.actions
     )
 
-    return this._expandWithId(request, response, updatedResource.id)
+    const result = this._expandWithId(request, updatedResource.id)
+    return response.status(200).send(result)
   }
 
   postWithKey(request: Request, response: Response) {
     return response.status(500).send('Not implemented')
   }
 
-  protected _expandWithId(
-    request: Request,
-    response: Response,
-    resourceId: string
-  ) {
+  protected _expandWithId(request: Request, resourceId: string) {
     const result = this.repository.get(request.params.projectKey, resourceId, {
       expand: this._parseParam(request.query.expand),
     })
-    if (!result) {
-      return response.status(404).send('Not found')
-    }
-    return response.status(200).send(result)
+    return result
   }
 
   // No idea what i'm doing

package/src/services/cart-discount.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express'
+import AbstractService from './abstract'
+import { AbstractStorage } from '../storage'
+import { CartDiscountRepository } from '../repositories/cart-discount'
+
+export class CartDiscountService extends AbstractService {
+  public repository: CartDiscountRepository
+
+  constructor(parent: Router, storage: AbstractStorage) {
+    super(parent)
+    this.repository = new CartDiscountRepository(storage)
+  }
+
+  getBasePath() {
+    return 'cart-discounts'
+  }
+}

package/src/services/cart.test.ts

@@ -1,6 +1,12 @@
-import { Cart } from '@commercetools/platform-sdk'
+import {
+  Address,
+  Cart,
+  CentPrecisionMoney,
+  ProductDraft,
+} from '@commercetools/platform-sdk'
 import supertest from 'supertest'
 import { CommercetoolsMock } from '../index'
+import assert from 'assert'
 
 describe('Carts Query', () => {
   const ctMock = new CommercetoolsMock()
@@ -32,7 +38,7 @@ describe('Carts Query', () => {
           },
         ],
       })
-    expect(response.status).toBe(200)
+    expect(response.status).toBe(201)
 
     response = await supertest(ctMock.app)
       .post('/dummy/carts')
@@ -48,7 +54,7 @@ describe('Carts Query', () => {
           },
         },
       })
-    expect(response.status).toBe(200)
+    expect(response.status).toBe(201)
   })
 
   test('no filter', async () => {
@@ -69,3 +75,308 @@ describe('Carts Query', () => {
     expect(myCart.custom?.type.obj?.description?.en).toBe('Test Type')
   })
 })
+
+describe('Order Update Actions', () => {
+  const ctMock = new CommercetoolsMock()
+  let cart: Cart | undefined
+  const productDraft: ProductDraft = {
+    name: {
+      'nl-NL': 'test product',
+    },
+    productType: {
+      typeId: 'product-type',
+      id: 'some-uuid',
+    },
+    masterVariant: {
+      sku: '1337',
+      prices: [
+        {
+          value: {
+            type: 'centPrecision',
+            currencyCode: 'EUR',
+            centAmount: 14900,
+            fractionDigits: 2,
+          } as CentPrecisionMoney,
+        },
+      ],
+
+      attributes: [
+        {
+          name: 'test',
+          value: 'test',
+        },
+      ],
+    },
+    variants: [
+      {
+        sku: '1338',
+        prices: [
+          {
+            value: {
+              type: 'centPrecision',
+              currencyCode: 'EUR',
+              centAmount: 14900,
+              fractionDigits: 2,
+            } as CentPrecisionMoney,
+          },
+        ],
+        attributes: [
+          {
+            name: 'test2',
+            value: 'test2',
+          },
+        ],
+      },
+    ],
+    slug: {
+      'nl-NL': 'test-product',
+    },
+    publish: true,
+  }
+
+  beforeEach(async () => {
+    let response = await supertest(ctMock.app)
+      .post('/dummy/carts')
+      .send({
+        currency: 'EUR',
+      })
+    expect(response.status).toBe(201)
+    cart = response.body
+  })
+
+  afterEach(() => {
+    ctMock.clear()
+  })
+
+  test('no update', async () => {
+    assert(cart, 'cart not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'setLocale', locale: 'nl-NL' }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.locale).toBe('nl-NL')
+
+    const responseAgain = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 2,
+        actions: [{ action: 'setLocale', locale: 'nl-NL' }],
+      })
+    expect(responseAgain.status).toBe(200)
+    expect(responseAgain.body.version).toBe(2)
+    expect(responseAgain.body.locale).toBe('nl-NL')
+  })
+
+  test('addLineItem', async () => {
+    const product = await supertest(ctMock.app)
+      .post(`/dummy/products`)
+      .send(productDraft)
+      .then(x => x.body)
+
+    assert(cart, 'cart not created')
+    assert(product, 'product not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [
+          {
+            action: 'addLineItem',
+            productId: product.id,
+            variantId: product.masterData.current.variants[0].id,
+          },
+        ],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.lineItems).toHaveLength(1)
+    expect(response.body.totalPrice.centAmount).toEqual(14900)
+  })
+
+  test('addLineItem by SKU', async () => {
+    const product = await supertest(ctMock.app)
+      .post(`/dummy/products`)
+      .send(productDraft)
+      .then(x => x.body)
+
+    assert(cart, 'cart not created')
+    assert(product, 'product not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'addLineItem', sku: '1337', quantity: 2 }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.lineItems).toHaveLength(1)
+    expect(response.body.totalPrice.centAmount).toEqual(29800)
+  })
+
+  test('addLineItem unknown product', async () => {
+    assert(cart, 'cart not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'addLineItem', productId: '123', variantId: 1 }],
+      })
+    expect(response.status).toBe(400)
+    expect(response.body.message).toBe("A product with ID '123' not found.")
+  })
+
+  test('removeLineItem', async () => {
+    const product = await supertest(ctMock.app)
+      .post(`/dummy/products`)
+      .send(productDraft)
+      .then(x => x.body)
+
+    assert(cart, 'cart not created')
+    assert(product, 'product not created')
+
+    const updatedCart = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [
+          {
+            action: 'addLineItem',
+            productId: product.id,
+            variantId: product.masterData.current.variants[0].id,
+          },
+        ],
+      })
+    const lineItem = updatedCart.body.lineItems[0]
+    assert(lineItem, 'lineItem not created')
+
+    expect(updatedCart.body.lineItems).toHaveLength(1)
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: updatedCart.body.version,
+        actions: [{ action: 'removeLineItem', lineItemId: lineItem.id }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(3)
+    expect(response.body.lineItems).toHaveLength(0)
+  })
+
+  test('removeLineItem decrease quantity', async () => {
+    const product = await supertest(ctMock.app)
+      .post(`/dummy/products`)
+      .send(productDraft)
+      .then(x => x.body)
+
+    assert(cart, 'cart not created')
+    assert(product, 'product not created')
+
+    const updatedCart = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [
+          {
+            action: 'addLineItem',
+            productId: product.id,
+            variantId: product.masterData.current.variants[0].id,
+            quantity: 2,
+          },
+        ],
+      })
+    const lineItem = updatedCart.body.lineItems[0]
+    assert(lineItem, 'lineItem not created')
+
+    expect(updatedCart.body.lineItems).toHaveLength(1)
+    expect(updatedCart.body.lineItems[0].quantity).toBe(2)
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: updatedCart.body.version,
+        actions: [
+          { action: 'removeLineItem', lineItemId: lineItem.id, quantity: 1 },
+        ],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(3)
+    expect(response.body.lineItems).toHaveLength(1)
+    expect(response.body.lineItems[0].quantity).toBe(1)
+  })
+
+  test('setBillingAddress', async () => {
+    assert(cart, 'cart not created')
+
+    const address: Address = {
+      streetName: 'Street name',
+      city: 'Utrecht',
+      country: 'NL',
+    }
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'setBillingAddress', address }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.billingAddress).toEqual(address)
+  })
+
+  test('setCountry', async () => {
+    assert(cart, 'cart not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'setCountry', country: 'NL' }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.country).toBe('NL')
+  })
+
+  test('setCustomerEmail', async () => {
+    assert(cart, 'cart not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'setCustomerEmail', email: 'john@doe.com' }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.customerEmail).toBe('john@doe.com')
+  })
+
+  test('setShippingAddress', async () => {
+    assert(cart, 'cart not created')
+
+    const address: Address = {
+      streetName: 'Street name',
+      city: 'Utrecht',
+      country: 'NL',
+    }
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/carts/${cart.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'setShippingAddress', address }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.shippingAddress).toEqual(address)
+  })
+})

package/src/services/category.test.ts

@@ -0,0 +1,37 @@
+import { Category } from '@commercetools/platform-sdk'
+import supertest from 'supertest'
+import { CommercetoolsMock } from '../index'
+
+describe('Categories Query', () => {
+  const ctMock = new CommercetoolsMock()
+
+  beforeEach(async () => {
+    let response
+    response = await supertest(ctMock.app)
+      .post('/dummy/categories')
+      .send({
+        name: {
+          en: 'Top hat',
+        },
+        slug: {
+          en: 'top-hat',
+        },
+        orderHint: '0.1',
+      })
+    expect(response.status).toBe(201)
+  })
+
+  test('no filter', async () => {
+    const response = await supertest(ctMock.app)
+      .get('/dummy/categories')
+      .query({})
+      .send()
+
+    expect(response.status).toBe(200)
+    expect(response.body.count).toBe(1)
+
+    const category = response.body.results[0] as Category
+
+    expect(category.name.en).toBe('Top hat')
+  })
+})