@labdigital/commercetools-mock 0.9.0 → 0.10.0

package/src/services/abstract.ts

@@ -14,7 +14,9 @@ export default abstract class AbstractService {
     this.registerRoutes(parent)
   }
 
-  extraRoutes(router: Router) {}
+  extraRoutes(router: Router) {
+
+  }
 
   registerRoutes(parent: Router) {
     const basePath = this.getBasePath()
@@ -27,8 +29,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 +70,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 +84,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 +126,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 +138,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'
 
 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

@@ -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,7 +1,6 @@
 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 { getRepositoryContext } from '../repositories/helpers'
@@ -10,10 +9,10 @@ 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() {
@@ -38,13 +37,11 @@ export class CartService extends AbstractService {
         ...cartOrOrder,
         currency: cartOrOrder.totalPrice.currencyCode,
         discountCodes: [],
-        lineItems: cartOrOrder.lineItems.map(lineItem => {
-          return {
-            ...lineItem,
-            variantId: lineItem.variant.id,
-            sku: lineItem.variant.sku,
-          }
-        }),
+        lineItems: cartOrOrder.lineItems.map((lineItem) => ({
+          ...lineItem,
+          variantId: lineItem.variant.id,
+          sku: lineItem.variant.sku,
+        })),
       }
 
       const newCart = this.repository.create(context, cartDraft)

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'
 
 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'
 
 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

@@ -7,7 +7,7 @@ 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 { 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'
 
 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'
 
 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 assert from 'assert'
+import { Customer } from '@commercetools/platform-sdk'
+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,7 +1,6 @@
 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 { getRepositoryContext } from '../repositories/helpers'
@@ -9,9 +8,9 @@ import { getRepositoryContext } from '../repositories/helpers'
 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'
 
 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'
 
 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() {

package/src/services/index.ts

@@ -0,0 +1,74 @@
+import { CartService } from './cart'
+import { CartDiscountService } from './cart-discount'
+import { CategoryServices } from './category'
+import { ChannelService } from './channel'
+import { CustomObjectService } from './custom-object'
+import { CustomerService } from './customer'
+import { CustomerGroupService } from './customer-group'
+import { DiscountCodeService } from './discount-code'
+import { ExtensionServices } from './extension'
+import { InventoryEntryService } from './inventory-entry'
+import { MyCartService } from './my-cart'
+import { MyCustomerService } from './my-customer'
+import { MyOrderService } from './my-order'
+import { MyPaymentService } from './my-payment'
+import { OrderService } from './order'
+import { PaymentService } from './payment'
+import { ProductService } from './product'
+import { ProductDiscountService } from './product-discount'
+import { ProductProjectionService } from './product-projection'
+import { ProductTypeService } from './product-type'
+import { ShippingMethodService } from './shipping-method'
+import { ShoppingListService } from './shopping-list'
+import { StateService } from './state'
+import { StoreService } from './store'
+import { SubscriptionService } from './subscription'
+import { TaxCategoryService } from './tax-category'
+import { TypeService } from './type'
+import { ZoneService } from './zone'
+
+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']),
+  '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']),
+})

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

@@ -8,12 +8,10 @@ describe('Inventory Entry Query', () => {
   let inventoryEntry: InventoryEntry | undefined
 
   beforeEach(async () => {
-    let response = await supertest(ctMock.app)
-      .post('/dummy/inventory')
-      .send({
-        sku: '1337',
-        quantityOnStock: 100,
-      })
+    const response = await supertest(ctMock.app).post('/dummy/inventory').send({
+      sku: '1337',
+      quantityOnStock: 100,
+    })
     expect(response.status).toBe(201)
     inventoryEntry = response.body
   })
@@ -59,12 +57,10 @@ describe('Inventory Entry Update Actions', () => {
   let customType: Type | undefined
 
   beforeEach(async () => {
-    let response = await supertest(ctMock.app)
-      .post('/dummy/inventory')
-      .send({
-        sku: '1337',
-        quantityOnStock: 100,
-      })
+    let response = await supertest(ctMock.app).post('/dummy/inventory').send({
+      sku: '1337',
+      quantityOnStock: 100,
+    })
     expect(response.status).toBe(201)
     inventoryEntry = response.body
 

package/src/services/inventory-entry.ts

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