@labdigital/commercetools-mock 0.9.0 → 0.10.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'
 
 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'
 
 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'
 
 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'
 
 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

@@ -274,11 +274,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 +357,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'
 
 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'
 
 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,15 +1,14 @@
 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() {

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

@@ -1,4 +1,5 @@
 import {
+  Product,
   ProductDraft,
   ProductProjection,
   ProductProjectionPagedSearchResponse,
@@ -8,12 +9,14 @@ import {
 import supertest from 'supertest'
 import * as timekeeper from 'timekeeper'
 import { CommercetoolsMock } from '../index'
-import { Writable } from 'types'
+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'
 
 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,15 +1,14 @@
 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() {