@labdigital/commercetools-mock 0.9.1 → 0.10.1

package/src/services/abstract.ts

@@ -1,12 +1,12 @@
 import { Update } from '@commercetools/platform-sdk'
-import { ParsedQs } from 'qs'
 import { Request, Response, Router } from 'express'
+import { ParsedQs } from 'qs'
 import { AbstractResourceRepository } from '../repositories/abstract'
 import { getRepositoryContext } from '../repositories/helpers'
 
 export default abstract class AbstractService {
   protected abstract getBasePath(): string
-  public abstract repository: AbstractResourceRepository
+  public abstract repository: AbstractResourceRepository<any>
 
   createStatusCode = 201
 
@@ -27,8 +27,8 @@ export default abstract class AbstractService {
     router.get('/key=:key', this.getWithKey.bind(this)) // same thing goes for the key routes
     router.get('/:id', this.getWithId.bind(this))
 
-    router.delete('/key=:key', this.deletewithKey.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('/key=:key', this.postWithKey.bind(this))
@@ -68,7 +68,7 @@ export default abstract class AbstractService {
     return response.status(200).send(result)
   }
 
-  deletewithId(request: Request, response: Response) {
+  deleteWithId(request: Request, response: Response) {
     const result = this.repository.delete(
       getRepositoryContext(request),
       request.params['id'],
@@ -82,8 +82,26 @@ export default abstract class AbstractService {
     return response.status(200).send(result)
   }
 
-  deletewithKey(request: Request, response: Response) {
-    return response.status(500).send('Not implemented')
+  deleteWithKey(request: Request, response: Response) {
+    const resource = this.repository.getByKey(
+      getRepositoryContext(request),
+      request.params['key']
+    )
+    if (!resource) {
+      return response.status(404).send('Not found')
+    }
+
+    const result = this.repository.delete(
+      getRepositoryContext(request),
+      resource.id,
+      {
+        expand: this._parseParam(request.query.expand),
+      }
+    )
+    if (!result) {
+      return response.status(404).send('Not found')
+    }
+    return response.status(200).send(result)
   }
 
   post(request: Request, response: Response) {
@@ -106,13 +124,10 @@ export default abstract class AbstractService {
       return response.status(404).send('Not found')
     }
 
-    if (resource.version !== updateRequest.version) {
-      return response.status(409).send('Concurrent modification')
-    }
-
     const updatedResource = this.repository.processUpdateActions(
       getRepositoryContext(request),
       resource,
+      updateRequest.version,
       updateRequest.actions
     )
 
@@ -121,7 +136,23 @@ export default abstract class AbstractService {
   }
 
   postWithKey(request: Request, response: Response) {
-    return response.status(500).send('Not implemented')
+    const updateRequest: Update = request.body
+    const resource = this.repository.getByKey(
+      getRepositoryContext(request),
+      request.params['key']
+    )
+    if (!resource) {
+      return response.status(404).send('Not found')
+    }
+    const updatedResource = this.repository.processUpdateActions(
+      getRepositoryContext(request),
+      resource,
+      updateRequest.version,
+      updateRequest.actions
+    )
+
+    const result = this._expandWithId(request, updatedResource.id)
+    return response.status(200).send(result)
   }
 
   protected _expandWithId(request: Request, resourceId: string) {

package/src/services/cart-discount.ts

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

package/src/services/cart.test.ts

@@ -4,9 +4,9 @@ import {
   CentPrecisionMoney,
   ProductDraft,
 } from '@commercetools/platform-sdk'
+import assert from 'assert'
 import supertest from 'supertest'
 import { CommercetoolsMock } from '../index'
-import assert from 'assert'
 
 describe('Carts Query', () => {
   const ctMock = new CommercetoolsMock()
@@ -81,11 +81,9 @@ describe('Cart Update Actions', () => {
   let cart: Cart | undefined
 
   const createCart = async (currency: string) => {
-    let response = await supertest(ctMock.app)
-      .post('/dummy/carts')
-      .send({
-        currency,
-      })
+    const response = await supertest(ctMock.app).post('/dummy/carts').send({
+      currency,
+    })
     expect(response.status).toBe(201)
     cart = response.body
   }
@@ -189,7 +187,7 @@ describe('Cart Update Actions', () => {
     const product = await supertest(ctMock.app)
       .post(`/dummy/products`)
       .send(productDraft)
-      .then(x => x.body)
+      .then((x) => x.body)
 
     assert(cart, 'cart not created')
     assert(product, 'product not created')
@@ -216,7 +214,7 @@ describe('Cart Update Actions', () => {
     const product = await supertest(ctMock.app)
       .post(`/dummy/products`)
       .send(productDraft)
-      .then(x => x.body)
+      .then((x) => x.body)
 
     assert(cart, 'cart not created')
     assert(product, 'product not created')
@@ -242,7 +240,7 @@ describe('Cart Update Actions', () => {
     const product = await supertest(ctMock.app)
       .post(`/dummy/products`)
       .send(productDraft)
-      .then(x => x.body)
+      .then((x) => x.body)
 
     assert(cart, 'cart not created')
     assert(product, 'product not created')
@@ -277,7 +275,7 @@ describe('Cart Update Actions', () => {
     const product = await supertest(ctMock.app)
       .post(`/dummy/products`)
       .send(productDraft)
-      .then(x => x.body)
+      .then((x) => x.body)
 
     assert(cart, 'cart not created')
     assert(product, 'product not created')
@@ -314,7 +312,7 @@ describe('Cart Update Actions', () => {
     const product = await supertest(ctMock.app)
       .post(`/dummy/products`)
       .send(productDraft)
-      .then(x => x.body)
+      .then((x) => x.body)
 
     assert(cart, 'cart not created')
     assert(product, 'product not created')

package/src/services/cart.ts

@@ -1,19 +1,22 @@
-import AbstractService from './abstract'
-import { Router } from 'express'
-import { CartRepository } from '../repositories/cart'
-import { AbstractStorage } from '../storage'
 import { Cart, CartDraft, Order } from '@commercetools/platform-sdk'
-import { OrderRepository } from '../repositories/order'
+import { Request, Response, Router } from 'express'
+import { CartRepository } from '../repositories/cart'
 import { getRepositoryContext } from '../repositories/helpers'
+import { OrderRepository } from '../repositories/order'
+import AbstractService from './abstract'
 
 export class CartService extends AbstractService {
   public repository: CartRepository
   public orderRepository: OrderRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(
+    parent: Router,
+    cartRepository: CartRepository,
+    orderRepository: OrderRepository
+  ) {
     super(parent)
-    this.repository = new CartRepository(storage)
-    this.orderRepository = new OrderRepository(storage)
+    this.repository = cartRepository
+    this.orderRepository = orderRepository
   }
 
   getBasePath() {
@@ -21,35 +24,36 @@ export class CartService extends AbstractService {
   }
 
   extraRoutes(parent: Router) {
-    parent.post('/replicate', (request, response) => {
-      const context = getRepositoryContext(request)
-
-      // @ts-ignore
-      const cartOrOrder: Cart | Order | null =
-        request.body.reference.typeId === 'order'
-          ? this.orderRepository.get(context, request.body.reference.id)
-          : this.repository.get(context, request.body.reference.id)
-
-      if (!cartOrOrder) {
-        return response.status(400).send()
-      }
-
-      const cartDraft: CartDraft = {
-        ...cartOrOrder,
-        currency: cartOrOrder.totalPrice.currencyCode,
-        discountCodes: [],
-        lineItems: cartOrOrder.lineItems.map(lineItem => {
-          return {
-            ...lineItem,
-            variantId: lineItem.variant.id,
-            sku: lineItem.variant.sku,
-          }
-        }),
-      }
-
-      const newCart = this.repository.create(context, cartDraft)
-
-      return response.status(200).send(newCart)
-    })
+    parent.post('/replicate', this.replicate.bind(this))
+  }
+
+  replicate(request: Request, response: Response) {
+    const context = getRepositoryContext(request)
+
+    // @ts-ignore
+    const cartOrOrder: Cart | Order | null =
+      request.body.reference.typeId === 'order'
+        ? this.orderRepository.get(context, request.body.reference.id)
+        : this.repository.get(context, request.body.reference.id)
+
+    if (!cartOrOrder) {
+      return response.status(400).send()
+    }
+
+    const cartDraft: CartDraft = {
+      ...cartOrOrder,
+      currency: cartOrOrder.totalPrice.currencyCode,
+      discountCodes: [],
+      shipping: [], // TODO: cartOrOrder.shipping,
+      lineItems: cartOrOrder.lineItems.map((lineItem) => ({
+        ...lineItem,
+        variantId: lineItem.variant.id,
+        sku: lineItem.variant.sku,
+      })),
+    }
+
+    const newCart = this.repository.create(context, cartDraft)
+
+    return response.status(200).send(newCart)
   }
 }

package/src/services/category.test.ts

@@ -6,8 +6,7 @@ describe('Categories Query', () => {
   const ctMock = new CommercetoolsMock()
 
   beforeEach(async () => {
-    let response
-    response = await supertest(ctMock.app)
+    const response = await supertest(ctMock.app)
       .post('/dummy/categories')
       .send({
         name: {

package/src/services/category.ts

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

package/src/services/channel.ts

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

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

@@ -1,13 +1,13 @@
 import { CustomObject } from '@commercetools/platform-sdk'
-import { getBaseResourceProperties } from '../helpers'
 import supertest from 'supertest'
+import { getBaseResourceProperties } from '../helpers'
 import { CommercetoolsMock } from '../index'
 
 describe('CustomObject create', () => {
   const ctMock = new CommercetoolsMock()
 
   test('Create new object', async () => {
-    let response = await supertest(ctMock.app)
+    const response = await supertest(ctMock.app)
       .post('/dummy/custom-objects')
       .send({
         container: 'my-container',
@@ -145,27 +145,27 @@ describe('CustomObject retrieve', () => {
   test('update with container and key', async () => {
     ctMock.project('dummy').add('key-value-document', {
       ...getBaseResourceProperties(),
-      container: 'my-container',
+      container: 'my-other-container',
       key: 'my-key',
       value: 'my-value',
       version: 2,
     })
 
     const response = await supertest(ctMock.app)
-      .post('/dummy/custom-objects/my-container/my-key')
+      .post('/dummy/custom-objects/my-other-container/my-key')
       .send({
         value: 'new-value',
       })
 
     expect(response.status).toEqual(200)
     expect(response.body).toEqual({
-      container: 'my-container',
+      container: 'my-other-container',
       createdAt: expect.anything(),
       id: expect.anything(),
       key: 'my-key',
       lastModifiedAt: expect.anything(),
       value: 'new-value',
-      version: 2,
+      version: 3,
     })
   })
 

package/src/services/custom-object.ts

@@ -1,16 +1,15 @@
-import AbstractService from './abstract'
+import { CustomObjectDraft } from '@commercetools/platform-sdk'
 import { Request, Response, Router } from 'express'
 import { CustomObjectRepository } from '../repositories/custom-object'
-import { AbstractStorage } from '../storage'
-import { CustomObjectDraft } from '@commercetools/platform-sdk'
 import { getRepositoryContext } from '../repositories/helpers'
+import AbstractService from './abstract'
 
 export class CustomObjectService extends AbstractService {
   public repository: CustomObjectRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: CustomObjectRepository) {
     super(parent)
-    this.repository = new CustomObjectRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {

package/src/services/customer-group.ts

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

package/src/services/customer.test.ts

@@ -0,0 +1,136 @@
+import { Customer } from '@commercetools/platform-sdk'
+import assert from 'assert'
+import supertest from 'supertest'
+import { CommercetoolsMock, getBaseResourceProperties } from '../index'
+
+describe('Customer Update Actions', () => {
+  const ctMock = new CommercetoolsMock()
+  let customer: Customer | undefined
+
+  beforeEach(async () => {
+    customer = {
+      ...getBaseResourceProperties(),
+      id: 'customer-uuid',
+      email: 'user@example.com',
+      password: 'supersecret',
+      addresses: [],
+      isEmailVerified: true,
+      authenticationMode: 'Password', //default in Commercetools
+      version: 1,
+    }
+    ctMock.project('dummy').add('customer', customer)
+  })
+
+  afterEach(() => {
+    ctMock.clear()
+  })
+
+  test('changeEmail', async () => {
+    assert(customer, 'customer not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/customers/${customer.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'changeEmail', email: 'new@example.com' }],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.email).toBe('new@example.com')
+  })
+
+  test('setAuthenticationMode to an invalid mode', async () => {
+    assert(customer, 'customer not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/customers/${customer.id}`)
+      .send({
+        version: 1,
+        actions: [{ action: 'setAuthenticationMode', authMode: 'invalid' }],
+      })
+    expect(response.status).toBe(400)
+    expect(response.body.message).toBe(
+      'Request body does not contain valid JSON.'
+    )
+    expect(response.body.errors[0].code).toBe('InvalidJsonInput')
+    expect(response.body.errors[0].detailedErrorMessage).toBe(
+      "actions -> authMode: Invalid enum value: 'invalid'. Expected one of: 'Password','ExternalAuth'"
+    )
+  })
+
+  test('setAuthenticationMode to ExternalAuth', async () => {
+    assert(customer, 'customer not created')
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/customers/${customer.id}`)
+      .send({
+        version: 1,
+        actions: [
+          { action: 'setAuthenticationMode', authMode: 'ExternalAuth' },
+        ],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(2)
+    expect(response.body.authenticationMode).toBe('ExternalAuth')
+    expect(response.body.password).toBe(undefined)
+  })
+
+  test('setAuthenticationMode error when setting current authMode', async () => {
+    assert(customer, 'customer not created')
+    assert(
+      customer.authenticationMode == 'Password',
+      'customer not in default state'
+    )
+
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/customers/${customer.id}`)
+      .send({
+        version: 1,
+        actions: [
+          {
+            action: 'setAuthenticationMode',
+            authMode: 'Password',
+            password: 'newpass',
+          },
+        ],
+      })
+    expect(response.status).toBe(400)
+    expect(response.body.message).toBe(
+      "The customer is already using the 'Password' authentication mode."
+    )
+  })
+
+  test('setAuthenticationMode to Password', async () => {
+    assert(customer, 'customer not created')
+
+    //change *away from* Password authMode (to be able to test changing *to* Password authMode)
+    await supertest(ctMock.app)
+      .post(`/dummy/customers/${customer.id}`)
+      .send({
+        version: 1,
+        actions: [
+          { action: 'setAuthenticationMode', authMode: 'ExternalAuth' },
+        ],
+      })
+
+    //change to Password authMode
+    const response = await supertest(ctMock.app)
+      .post(`/dummy/customers/${customer.id}`)
+      .send({
+        version: 2,
+        actions: [
+          {
+            action: 'setAuthenticationMode',
+            authMode: 'Password',
+            password: 'newpass',
+          },
+        ],
+      })
+    expect(response.status).toBe(200)
+    expect(response.body.version).toBe(3)
+    expect(response.body.authenticationMode).toBe('Password')
+    expect(response.body.password).toBe(
+      Buffer.from('newpass').toString('base64')
+    )
+  })
+})

package/src/services/customer.ts

@@ -1,17 +1,16 @@
-import AbstractService from './abstract'
 import { Router } from 'express'
-import { CustomerRepository } from '../repositories/customer'
-import { AbstractStorage } from '../storage'
-import { getBaseResourceProperties } from '../helpers'
 import { v4 as uuidv4 } from 'uuid'
+import { getBaseResourceProperties } from '../helpers'
+import { CustomerRepository } from '../repositories/customer'
 import { getRepositoryContext } from '../repositories/helpers'
+import AbstractService from './abstract'
 
 export class CustomerService extends AbstractService {
   public repository: CustomerRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: CustomerRepository) {
     super(parent)
-    this.repository = new CustomerRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {

package/src/services/discount-code.ts

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

package/src/services/extension.ts

@@ -1,14 +1,13 @@
-import AbstractService from './abstract'
 import { Router } from 'express'
-import { AbstractStorage } from '../storage'
 import { ExtensionRepository } from '../repositories/extension'
+import AbstractService from './abstract'
 
 export class ExtensionServices extends AbstractService {
   public repository: ExtensionRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: ExtensionRepository) {
     super(parent)
-    this.repository = new ExtensionRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {