@labdigital/commercetools-mock 0.9.1 → 0.10.1

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

@@ -1,5 +1,5 @@
-import assert from 'assert'
 import { InventoryEntry, Type } from '@commercetools/platform-sdk'
+import assert from 'assert'
 import supertest from 'supertest'
 import { CommercetoolsMock } from '../index'
 
@@ -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'
+import AbstractService from './abstract'
 
 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() {

package/src/services/my-cart.test.ts

@@ -40,6 +40,8 @@ describe('MyCart', () => {
       cartState: 'Active',
       lineItems: [],
       customLineItems: [],
+      shipping: [],
+      shippingMode: 'Single',
       totalPrice: {
         type: 'centPrecision',
         centAmount: 0,

package/src/services/my-cart.ts

@@ -1,14 +1,13 @@
-import AbstractService from './abstract'
 import { Request, Response, Router } from 'express'
-import { AbstractStorage } from '../storage'
 import { CartRepository } from '../repositories/cart'
+import AbstractService from './abstract'
 
 export class MyCartService extends AbstractService {
   public repository: CartRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: CartRepository) {
     super(parent)
-    this.repository = new CartRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {
@@ -26,7 +25,7 @@ export class MyCartService extends AbstractService {
     router.get('/carts/', this.get.bind(this))
     router.get('/carts/:id', this.getWithId.bind(this))
 
-    router.delete('/carts/:id', this.deletewithId.bind(this))
+    router.delete('/carts/:id', this.deleteWithId.bind(this))
 
     router.post('/carts/', this.post.bind(this))
     router.post('/carts/:id', this.postWithId.bind(this))

package/src/services/my-customer.ts

@@ -1,15 +1,14 @@
-import AbstractService from './abstract'
 import { Request, Response, Router } from 'express'
-import { AbstractStorage } from '../storage'
 import { CustomerRepository } from '../repositories/customer'
 import { getRepositoryContext } from '../repositories/helpers'
+import AbstractService from './abstract'
 
 export class MyCustomerService 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/my-order.ts

@@ -1,14 +1,13 @@
-import AbstractService from './abstract'
 import { Router } from 'express'
-import { AbstractStorage } from '../storage'
 import { MyOrderRepository } from '../repositories/my-order'
+import AbstractService from './abstract'
 
 export class MyOrderService extends AbstractService {
   public repository: MyOrderRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: MyOrderRepository) {
     super(parent)
-    this.repository = new MyOrderRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {
@@ -25,7 +24,7 @@ export class MyOrderService extends AbstractService {
     router.get('/orders/', this.get.bind(this))
     router.get('/orders/:id', this.getWithId.bind(this))
 
-    router.delete('/orders/:id', this.deletewithId.bind(this))
+    router.delete('/orders/:id', this.deleteWithId.bind(this))
 
     router.post('/orders/', this.post.bind(this))
     router.post('/orders/:id', this.postWithId.bind(this))

package/src/services/my-payment.ts

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

package/src/services/order.test.ts

@@ -137,21 +137,13 @@ describe('Order payment tests', () => {
     }
 
     const order: Order = {
+      ...getBaseResourceProperties(),
       customLineItems: [],
       lastMessageSequenceNumber: 0,
       lineItems: [],
+      orderNumber: '1337',
       orderState: 'Open',
       origin: 'Customer',
-      refusedGifts: [],
-      syncInfo: [],
-      totalPrice: {
-        type: 'centPrecision',
-        fractionDigits: 2,
-        centAmount: 2000,
-        currencyCode: 'EUR',
-      },
-      ...getBaseResourceProperties(),
-      orderNumber: '1337',
       paymentInfo: {
         payments: [
           {
@@ -160,6 +152,16 @@ describe('Order payment tests', () => {
           },
         ],
       },
+      refusedGifts: [],
+      shipping: [],
+      shippingMode: 'Single',
+      syncInfo: [],
+      totalPrice: {
+        type: 'centPrecision',
+        fractionDigits: 2,
+        centAmount: 2000,
+        currencyCode: 'EUR',
+      },
     }
 
     ctMock.project().add('state', state)
@@ -228,21 +230,13 @@ describe('Order payment tests', () => {
     }
 
     const order: Order = {
+      ...getBaseResourceProperties(),
       customLineItems: [],
       lastMessageSequenceNumber: 0,
       lineItems: [],
+      orderNumber: '1337',
       orderState: 'Open',
       origin: 'Customer',
-      refusedGifts: [],
-      syncInfo: [],
-      totalPrice: {
-        type: 'centPrecision',
-        fractionDigits: 2,
-        centAmount: 2000,
-        currencyCode: 'EUR',
-      },
-      ...getBaseResourceProperties(),
-      orderNumber: '1337',
       paymentInfo: {
         payments: [
           {
@@ -251,6 +245,16 @@ describe('Order payment tests', () => {
           },
         ],
       },
+      refusedGifts: [],
+      shipping: [],
+      shippingMode: 'Single',
+      syncInfo: [],
+      totalPrice: {
+        type: 'centPrecision',
+        fractionDigits: 2,
+        centAmount: 2000,
+        currencyCode: 'EUR',
+      },
     }
 
     ctMock.project().add('state', state)
@@ -274,11 +278,9 @@ describe('Order Update Actions', () => {
   let order: Order | undefined
 
   beforeEach(async () => {
-    let response = await supertest(ctMock.app)
-      .post('/dummy/carts')
-      .send({
-        currency: 'EUR',
-      })
+    let response = await supertest(ctMock.app).post('/dummy/carts').send({
+      currency: 'EUR',
+    })
     expect(response.status).toBe(201)
     const cart = response.body
 
@@ -359,7 +361,7 @@ describe('Order Update Actions', () => {
         ],
       })
     expect(response.status).toBe(200)
-    expect(response.body.version).toBe(2)
+    expect(response.body.version).toBe(3)
     expect(response.body.orderState).toBe('Cancelled')
     expect(response.body.paymentState).toBe('Failed')
   })

package/src/services/order.ts

@@ -1,15 +1,14 @@
-import AbstractService from './abstract'
 import { Request, Response, Router } from 'express'
-import { OrderRepository } from '../repositories/order'
-import { AbstractStorage } from '../storage'
 import { getRepositoryContext } from '../repositories/helpers'
+import { OrderRepository } from '../repositories/order'
+import AbstractService from './abstract'
 
 export class OrderService extends AbstractService {
   public repository: OrderRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: OrderRepository) {
     super(parent)
-    this.repository = new OrderRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {

package/src/services/payment.ts

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

package/src/services/product-discount.ts

@@ -1,33 +1,16 @@
+import { Router } from 'express'
 import { ProductDiscountRepository } from '../repositories/product-discount'
 import AbstractService from './abstract'
-import { Request, Response, Router } from 'express'
-import { AbstractStorage } from '../storage'
-import { getRepositoryContext } from '../repositories/helpers'
 
 export class ProductDiscountService extends AbstractService {
   public repository: ProductDiscountRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: ProductDiscountRepository) {
     super(parent)
-    this.repository = new ProductDiscountRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {
     return 'product-discounts'
   }
-
-  extraRoutes(router: Router) {
-    router.get('/key=:key', this.getWithKey.bind(this))
-  }
-
-  getWithKey(request: Request, response: Response) {
-    const resource = this.repository.getWithKey(
-      getRepositoryContext(request),
-      request.params.key
-    )
-    if (resource) {
-      return response.status(200).send(resource)
-    }
-    return response.status(404).send('Not found')
-  }
 }

package/src/services/product-projection.test.ts

@@ -1,4 +1,5 @@
 import {
+  Product,
   ProductDraft,
   ProductProjection,
   ProductProjectionPagedSearchResponse,
@@ -7,13 +8,15 @@ import {
 } from '@commercetools/platform-sdk'
 import supertest from 'supertest'
 import * as timekeeper from 'timekeeper'
+import { Writable } from '../types'
 import { CommercetoolsMock } from '../index'
-import { Writable } from 'types'
 
 const ctMock = new CommercetoolsMock()
 
 let productType: ProductType
 let productProjection: ProductProjection
+let publishedProduct: Product
+let unpublishedProduct: Product
 
 beforeEach(async () => {
   timekeeper.freeze(new Date('2022-07-22T13:31:49.840Z'))
@@ -32,7 +35,48 @@ beforeEach(async () => {
     productType = response.body
   }
 
-  // Create the product
+  // Create an unpublished product
+  {
+    const productDraft: Writable<ProductDraft> = {
+      publish: false,
+      key: 'my-unpublished-product',
+      masterVariant: {
+        sku: 'my-unpub-sku',
+        prices: [
+          {
+            value: {
+              currencyCode: 'EUR',
+              centAmount: 189,
+            },
+          },
+        ],
+        attributes: [
+          {
+            name: 'number',
+            value: 1 as any,
+          },
+        ],
+      },
+      name: {
+        'nl-NL': 'test unpublished product',
+      },
+      productType: {
+        typeId: 'product-type',
+        id: productType.id,
+      },
+      slug: {
+        'nl-NL': 'test-unpublished-product',
+      },
+    }
+
+    const response = await supertest(ctMock.app)
+      .post('/dummy/products')
+      .send(productDraft)
+    expect(response.ok).toBe(true)
+    unpublishedProduct = response.body
+  }
+
+  // Create a published product
   {
     const productDraft: Writable<ProductDraft> = {
       publish: true,
@@ -90,6 +134,7 @@ beforeEach(async () => {
       .send(productDraft)
     expect(response.ok).toBe(true)
     const product = response.body
+    publishedProduct = response.body
 
     // Create the expected ProductProjection object
     productProjection = {
@@ -97,6 +142,9 @@ beforeEach(async () => {
       createdAt: '2022-07-22T13:31:49.840Z',
       lastModifiedAt: '2022-07-22T13:31:49.840Z',
       version: 1,
+      key: 'my-product-key',
+      published: true,
+      hasStagedChanges: false,
       masterVariant: {
         id: 1,
         sku: 'my-sku',
@@ -148,12 +196,7 @@ beforeEach(async () => {
 
 afterEach(async () => {
   timekeeper.reset()
-
-  const response = await supertest(ctMock.app)
-    .delete(`/dummy/products/${productProjection.id}`)
-    .send()
-  expect(response.ok).toBe(true)
-  const product = response.body
+  ctMock.clear()
 })
 
 // Test the general product projection implementation
@@ -196,6 +239,31 @@ describe('Product Projection Search - Generic', () => {
     }
   })
 
+  test('Search - unpublished', async () => {
+    {
+      const response = await supertest(ctMock.app)
+        .get('/dummy/product-projections/search')
+        .query({
+          limit: 50,
+          staged: true,
+        })
+
+      const result: ProductProjectionPagedSearchResponse = response.body
+
+      expect(result).toMatchObject({
+        count: 2,
+        limit: 50,
+        offset: 0,
+        total: 2,
+        facets: {},
+        results: [
+          { id: unpublishedProduct.id, published: false },
+          { id: publishedProduct.id, published: true },
+        ],
+      })
+    }
+  })
+
   test('Get 404 when not found by key with expand', async () => {
     const response = await supertest(ctMock.app)
       .get('/dummy/product-projections/key=DOESNOTEXIST')

package/src/services/product-projection.ts

@@ -1,15 +1,14 @@
-import { ProductProjectionRepository } from './../repositories/product-projection'
-import AbstractService from './abstract'
-import { AbstractStorage } from '../storage'
 import { Request, Response, Router } from 'express'
 import { getRepositoryContext } from '../repositories/helpers'
+import { ProductProjectionRepository } from './../repositories/product-projection'
+import AbstractService from './abstract'
 
 export class ProductProjectionService extends AbstractService {
   public repository: ProductProjectionRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: ProductProjectionRepository) {
     super(parent)
-    this.repository = new ProductProjectionRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {

package/src/services/product-type.ts

@@ -1,33 +1,16 @@
+import { Router } from 'express'
 import { ProductTypeRepository } from '../repositories/product-type'
 import AbstractService from './abstract'
-import { Request, Response, Router } from 'express'
-import { AbstractStorage } from '../storage'
-import { getRepositoryContext } from '../repositories/helpers'
 
 export class ProductTypeService extends AbstractService {
   public repository: ProductTypeRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: ProductTypeRepository) {
     super(parent)
-    this.repository = new ProductTypeRepository(storage)
+    this.repository = repository
   }
 
   getBasePath() {
     return 'product-types'
   }
-
-  extraRoutes(router: Router) {
-    router.get('/key=:key', this.getWithKey.bind(this))
-  }
-
-  getWithKey(request: Request, response: Response) {
-    const resource = this.repository.getWithKey(
-      getRepositoryContext(request),
-      request.params.key
-    )
-    if (resource) {
-      return response.status(200).send(resource)
-    }
-    return response.status(404).send('Not found')
-  }
 }