@labdigital/commercetools-mock 0.5.11 → 0.5.14

package/src/services/abstract.ts

@@ -1,11 +1,13 @@
 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)
@@ -21,15 +23,15 @@ export default abstract class AbstractService {
     this.extraRoutes(router)
 
     router.get('/', this.get.bind(this))
+    router.get('/key=:key', this.getWithKey.bind(this)) // same thing goes for the key routes
     router.get('/:id', this.getWithId.bind(this))
-    router.get('/key=:key', this.getWithKey.bind(this))
 
-    router.delete('/:id', this.deletewithId.bind(this))
     router.delete('/key=:key', this.deletewithKey.bind(this))
+    router.delete('/:id', this.deletewithId.bind(this))
 
     router.post('/', this.post.bind(this))
-    router.post('/:id', this.postWithId.bind(this))
     router.post('/key=:key', this.postWithKey.bind(this))
+    router.post('/:id', this.postWithId.bind(this))
 
     parent.use(`/${basePath}`, router)
   }
@@ -43,11 +45,22 @@ 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) {
-    return response.status(500).send('Not implemented')
+    const result = this.repository.getByKey(
+      request.params.projectKey,
+      request.params['key'],
+      { expand: this._parseParam(request.query.expand) }
+    )
+    if (!result) return response.status(404).send()
+    return response.status(200).send(result)
   }
 
   deletewithId(request: Request, response: Response) {
@@ -71,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) {
@@ -94,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')
+  })
+})

package/src/services/category.ts

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

package/src/services/channel.ts

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

package/src/services/custom-object.test.ts

@@ -15,7 +15,7 @@ describe('CustomObject create', () => {
         value: 'my-value',
       })
 
-    expect(response.status).toBe(200)
+    expect(response.status).toBe(201)
     const customObject = response.body
     expect(customObject.container).toBe('my-container')
     expect(customObject.key).toBe('my-key')
@@ -36,7 +36,7 @@ describe('CustomObject retrieve', () => {
         value: 'my-value',
       })
 
-    expect(response.status).toBe(200)
+    expect(response.status).toBe(201)
     customObject = response.body
     expect(customObject.container).toBe('my-container')
     expect(customObject.key).toBe('my-key')
@@ -67,7 +67,7 @@ describe('CustomObject retrieve', () => {
         value: 'my-value',
       })
 
-    expect(response.status).toBe(200)
+    expect(response.status).toBe(201)
   })
 
   test('New with version (errors)', async () => {
@@ -141,4 +141,54 @@ describe('CustomObject retrieve', () => {
       version: 1,
     })
   })
+
+  test('update with container and key', async () => {
+    ctMock.project('dummy').add('custom-object', {
+      ...getBaseResourceProperties(),
+      container: 'my-container',
+      key: 'my-key',
+      value: 'my-value',
+      version: 2,
+    })
+
+    const response = await supertest(ctMock.app)
+      .post('/dummy/custom-objects/my-container/my-key')
+      .send({
+        value: 'new-value',
+      })
+
+    expect(response.status).toEqual(200)
+    expect(response.body).toEqual({
+      container: 'my-container',
+      createdAt: expect.anything(),
+      id: expect.anything(),
+      key: 'my-key',
+      lastModifiedAt: expect.anything(),
+      value: 'new-value',
+      version: 2,
+    })
+  })
+
+  test('delete with container and key', async () => {
+    const response = await supertest(ctMock.app)
+      .delete('/dummy/custom-objects/my-container/my-key')
+      .send()
+
+    expect(response.status).toEqual(200)
+    expect(response.body).toEqual({
+      container: 'my-container',
+      createdAt: expect.anything(),
+      id: expect.anything(),
+      key: 'my-key',
+      lastModifiedAt: expect.anything(),
+      value: 'my-value',
+      version: 1,
+    })
+
+    const fetchRes = await supertest(ctMock.app)
+      .get('/dummy/custom-objects/my-container/my-key')
+      .send()
+
+    expect(fetchRes.status).toEqual(404)
+  })
 })

package/src/services/custom-object.ts

@@ -2,6 +2,7 @@ import AbstractService from './abstract'
 import { Request, Response, Router } from 'express'
 import { CustomObjectRepository } from '../repositories/custom-object'
 import { AbstractStorage } from '../storage'
+import { CustomObjectDraft } from '@commercetools/platform-sdk'
 
 export class CustomObjectService extends AbstractService {
   public repository: CustomObjectRepository
@@ -17,6 +18,8 @@ export class CustomObjectService extends AbstractService {
 
   extraRoutes(router: Router) {
     router.get('/:container/:key', this.getWithContainerAndKey.bind(this))
+    router.post('/:container/:key', this.createWithContainerAndKey.bind(this))
+    router.delete('/:container/:key', this.deleteWithContainerAndKey.bind(this))
   }
 
   getWithContainerAndKey(request: Request, response: Response) {
@@ -31,4 +34,31 @@ export class CustomObjectService extends AbstractService {
     }
     return response.status(200).send(result)
   }
+
+  createWithContainerAndKey(request: Request, response: Response) {
+    const draft: CustomObjectDraft = {
+      ...request.body,
+      key: request.params.key,
+      container: request.params.container,
+    }
+
+    const result = this.repository.create(request.params.projectKey, draft)
+    return response.status(200).send(result)
+  }
+
+  deleteWithContainerAndKey(request: Request, response: Response) {
+    const current = this.repository.getWithContainerAndKey(
+      request.params.projectKey,
+      request.params.container,
+      request.params.key
+    )
+
+    if (!current) {
+      return response.status(404).send('Not Found')
+    }
+
+    const result = this.repository.delete(request.params.projectKey, current.id)
+
+    return response.status(200).send(result)
+  }
 }

package/src/services/customer-group.ts

@@ -0,0 +1,17 @@
+import AbstractService from './abstract'
+import { Router } from 'express'
+import { CustomerGroupRepository } from '../repositories/customer-group'
+import { AbstractStorage } from '../storage'
+
+export class CustomerGroupService extends AbstractService {
+  public repository: CustomerGroupRepository
+
+  constructor(parent: Router, storage: AbstractStorage) {
+    super(parent)
+    this.repository = new CustomerGroupRepository(storage)
+  }
+
+  getBasePath() {
+    return 'customer-groups'
+  }
+}

package/src/services/discount-code.ts

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