@labdigital/commercetools-mock 0.9.0 → 0.10.0

package/src/services/product.test.ts

@@ -1,88 +1,110 @@
-import { Product, ProductDraft } from '@commercetools/platform-sdk'
+import { Product, ProductData, ProductDraft } from '@commercetools/platform-sdk'
 import supertest from 'supertest'
 import { CommercetoolsMock } from '../index'
 import assert from 'assert'
 
 const ctMock = new CommercetoolsMock()
 
-describe('Product', () => {
-  test('Create product', async () => {
-    const draft: ProductDraft = {
-      name: {
-        'nl-NL': 'test product',
-      },
-      productType: {
-        typeId: 'product-type',
-        id: 'some-uuid',
+const publishedProductDraft: ProductDraft = {
+  name: {
+    'nl-NL': 'test published product',
+  },
+  productType: {
+    typeId: 'product-type',
+    id: 'some-uuid',
+  },
+  masterVariant: {
+    sku: '1337',
+    attributes: [
+      {
+        name: 'test',
+        value: 'test',
       },
-      slug: {
-        'nl-NL': 'test-product',
+    ],
+  },
+  variants: [
+    {
+      sku: '1338',
+      attributes: [
+        {
+          name: 'test2',
+          value: 'test2',
+        },
+      ],
+    },
+  ],
+  slug: {
+    'nl-NL': 'test-published-product',
+  },
+  publish: true,
+}
+
+const unpublishedProductDraft: ProductDraft = {
+  name: {
+    'nl-NL': 'test unpublished product',
+  },
+  productType: {
+    typeId: 'product-type',
+    id: 'some-uuid',
+  },
+  masterVariant: {
+    sku: '2337',
+    attributes: [
+      {
+        name: 'test',
+        value: 'test',
       },
-      masterVariant: {},
-    }
+    ],
+  },
+  variants: [
+    {
+      sku: '2338',
+      attributes: [
+        {
+          name: 'test2',
+          value: 'test2',
+        },
+      ],
+    },
+  ],
+  slug: {
+    'nl-NL': 'test-unpublished-product',
+  },
+  publish: false,
+}
 
+describe('Product', () => {
+  test('Create product', async () => {
     const response = await supertest(ctMock.app)
       .post('/dummy/products')
-      .send(draft)
+      .send(unpublishedProductDraft)
 
-    expect(response.body).toEqual({
-      createdAt: expect.anything(),
-      id: expect.anything(),
-      lastModifiedAt: expect.anything(),
-      masterData: {
-        staged: {
-          name: {
-            'nl-NL': 'test product',
-          },
-          slug: {
-            'nl-NL': 'test-product',
-          },
-          categories: [],
-          masterVariant: {
-            assets: [],
-            attributes: [],
-            id: 1,
-            images: [],
-          },
-          variants: [],
-        },
-        hasStagedChanges: true,
-        published: false,
-      },
-      productType: {
-        typeId: 'product-type',
-        id: 'some-uuid',
-      },
-      version: 1,
-    })
-  })
-})
-
-describe('Product update actions', () => {
-  const ctMock = new CommercetoolsMock()
-  let product: Product | undefined
-
-  beforeEach(async () => {
-    const draft: ProductDraft = {
+    const productData: ProductData = {
       name: {
-        'nl-NL': 'test product',
+        'nl-NL': 'test unpublished product',
       },
-      productType: {
-        typeId: 'product-type',
-        id: 'some-uuid',
+      slug: {
+        'nl-NL': 'test-unpublished-product',
       },
+      categories: [],
       masterVariant: {
-        sku: '1337',
+        sku: '2337',
+        assets: [],
         attributes: [
           {
             name: 'test',
             value: 'test',
           },
         ],
+        id: 1,
+        images: [],
       },
       variants: [
         {
-          sku: '1338',
+          sku: '2338',
+          assets: [],
+          id: 2,
+          images: [],
           attributes: [
             {
               name: 'test2',
@@ -91,44 +113,132 @@ describe('Product update actions', () => {
           ],
         },
       ],
-      slug: {
-        'nl-NL': 'test-product',
-      },
-      publish: true,
+      searchKeywords: {},
     }
-    let response = await supertest(ctMock.app)
+
+    expect(response.body).toEqual({
+      createdAt: expect.anything(),
+      id: expect.anything(),
+      lastModifiedAt: expect.anything(),
+      masterData: {
+        staged: productData,
+        current: productData,
+        hasStagedChanges: false,
+        published: false,
+      },
+      productType: {
+        typeId: 'product-type',
+        id: 'some-uuid',
+      },
+      version: 1,
+    } as Product)
+  })
+})
+
+describe('Product update actions', () => {
+  const ctMock = new CommercetoolsMock()
+  let productPublished: Product | undefined
+  let productUnpublished: Product | undefined
+
+  beforeEach(async () => {
+    let response
+    response = await supertest(ctMock.app)
+      .post('/dummy/products')
+      .send(publishedProductDraft)
+
+    expect(response.status).toBe(201)
+    productPublished = response.body
+
+    response = await supertest(ctMock.app)
       .post('/dummy/products')
-      .send(draft)
+      .send(unpublishedProductDraft)
 
     expect(response.status).toBe(201)
-    product = response.body
+    productUnpublished = response.body
   })
 
-  test('setAttribute masterVariant', async () => {
-    assert(product, 'product not created')
+  test('setAttribute masterVariant (staged)', async () => {
+    assert(productPublished, 'product not created')
+
+    {
+      const response = await supertest(ctMock.app)
+        .post(`/dummy/products/${productPublished.id}`)
+        .send({
+          version: 1,
+          actions: [
+            { action: 'setAttribute', sku: '1337', name: 'foo', value: 'bar' },
+          ],
+        })
+
+      expect(response.status).toBe(200)
+      const product: Product = response.body
+      expect(product.version).toBe(2)
+      expect(product.masterData.hasStagedChanges).toBeTruthy()
+      expect(product.masterData.current.masterVariant.attributes).toHaveLength(
+        1
+      )
+      expect(product.masterData.staged.masterVariant.attributes).toHaveLength(2)
+
+      const attr = response.body.masterData.staged.masterVariant.attributes[1]
+      expect(attr).toEqual({ name: 'foo', value: 'bar' })
+    }
+
+    // Publish
+    {
+      const response = await supertest(ctMock.app)
+        .post(`/dummy/products/${productPublished.id}`)
+        .send({
+          version: 2,
+          actions: [{ action: 'publish', scope: 'All' }],
+        })
+
+      expect(response.status).toBe(200)
+      const product: Product = response.body
+      expect(product.version).toBe(3)
+      expect(product.masterData.hasStagedChanges).toBeFalsy()
+      expect(product.masterData.current.masterVariant.attributes).toHaveLength(
+        2
+      )
+    }
+  })
+
+  test('setAttribute masterVariant (published)', async () => {
+    assert(productPublished, 'product not created')
 
     const response = await supertest(ctMock.app)
-      .post(`/dummy/products/${product.id}`)
+      .post(`/dummy/products/${productPublished.id}`)
       .send({
         version: 1,
         actions: [
-          { action: 'setAttribute', sku: '1337', name: 'foo', value: 'bar' },
+          {
+            action: 'setAttribute',
+            sku: '1337',
+            name: 'foo',
+            value: 'bar',
+            staged: false,
+          },
         ],
       })
+
     expect(response.status).toBe(200)
-    expect(response.body.version).toBe(2)
-    expect(
-      response.body.masterData.current.masterVariant.attributes
-    ).toHaveLength(2)
-    const attr = response.body.masterData.current.masterVariant.attributes[1]
+    const product: Product = response.body
+
+    // TODO: Since we auto publish it actually does two version updates. So the
+    // version should be 3
+    expect(product.version).toBe(2)
+    expect(product.masterData.hasStagedChanges).toBeFalsy()
+    expect(product.masterData.current.masterVariant.attributes).toHaveLength(2)
+    expect(product.masterData.staged.masterVariant.attributes).toHaveLength(2)
+
+    const attr = response.body.masterData.staged.masterVariant.attributes[1]
     expect(attr).toEqual({ name: 'foo', value: 'bar' })
   })
 
   test('setAttribute variant', async () => {
-    assert(product, 'product not created')
+    assert(productPublished, 'product not created')
 
     const response = await supertest(ctMock.app)
-      .post(`/dummy/products/${product.id}`)
+      .post(`/dummy/products/${productPublished.id}`)
       .send({
         version: 1,
         actions: [
@@ -137,18 +247,18 @@ describe('Product update actions', () => {
       })
     expect(response.status).toBe(200)
     expect(response.body.version).toBe(2)
-    expect(
-      response.body.masterData.current.variants[0].attributes
-    ).toHaveLength(2)
-    const attr = response.body.masterData.current.variants[0].attributes[1]
+    expect(response.body.masterData.staged.variants[0].attributes).toHaveLength(
+      2
+    )
+    const attr = response.body.masterData.staged.variants[0].attributes[1]
     expect(attr).toEqual({ name: 'foo', value: 'bar' })
   })
 
   test('setAttribute variant and publish', async () => {
-    assert(product, 'product not created')
+    assert(productPublished, 'product not created')
 
     const response = await supertest(ctMock.app)
-      .post(`/dummy/products/${product.id}`)
+      .post(`/dummy/products/${productPublished.id}`)
       .send({
         version: 1,
         actions: [
@@ -157,7 +267,7 @@ describe('Product update actions', () => {
         ],
       })
     expect(response.status).toBe(200)
-    expect(response.body.version).toBe(2)
+    expect(response.body.version).toBe(3)
     expect(
       response.body.masterData.current.variants[0].attributes
     ).toHaveLength(2)
@@ -166,10 +276,10 @@ describe('Product update actions', () => {
   })
 
   test('setAttribute overwrite', async () => {
-    assert(product, 'product not created')
+    assert(productPublished, 'product not created')
 
     const response = await supertest(ctMock.app)
-      .post(`/dummy/products/${product.id}`)
+      .post(`/dummy/products/${productPublished.id}`)
       .send({
         version: 1,
         actions: [
@@ -179,9 +289,9 @@ describe('Product update actions', () => {
     expect(response.status).toBe(200)
     expect(response.body.version).toBe(2)
     expect(
-      response.body.masterData.current.masterVariant.attributes
+      response.body.masterData.staged.masterVariant.attributes
     ).toHaveLength(1)
-    const attr = response.body.masterData.current.masterVariant.attributes[0]
+    const attr = response.body.masterData.staged.masterVariant.attributes[0]
     expect(attr).toEqual({ name: 'test', value: 'foo' })
   })
 })

package/src/services/product.ts

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

package/src/services/project.ts

@@ -1,6 +1,5 @@
 import { Router } from 'express'
 import { Request, Response } from 'express'
-import { AbstractStorage } from '../storage'
 import { ProjectRepository } from '../repositories/project'
 import { Update } from '@commercetools/platform-sdk'
 import { getRepositoryContext } from '../repositories/helpers'
@@ -8,8 +7,8 @@ import { getRepositoryContext } from '../repositories/helpers'
 export class ProjectService {
   public repository: ProjectRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
-    this.repository = new ProjectRepository(storage)
+  constructor(parent: Router, repository: ProjectRepository) {
+    this.repository = repository
     this.registerRoutes(parent)
   }
 
@@ -34,6 +33,7 @@ export class ProjectService {
     this.repository.processUpdateActions(
       getRepositoryContext(request),
       project,
+      updateRequest.version,
       updateRequest.actions
     )
 

package/src/services/shipping-method.ts

@@ -1,14 +1,13 @@
 import { ShippingMethodRepository } from '../repositories/shipping-method'
 import AbstractService from './abstract'
-import { AbstractStorage } from '../storage'
 import { Router } from 'express'
 
 export class ShippingMethodService extends AbstractService {
   public repository: ShippingMethodRepository
 
-  constructor(parent: Router, storage: AbstractStorage) {
+  constructor(parent: Router, repository: ShippingMethodRepository) {
     super(parent)
-    this.repository = new ShippingMethodRepository(storage)
+    this.repository = repository
     this.registerRoutes(parent)
   }
 

package/src/services/shopping-list.ts

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

package/src/services/state.ts

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

package/src/services/store.test.ts

@@ -23,7 +23,10 @@ describe('Store', () => {
       createdAt: '',
       lastModifiedAt: '',
       key: 'STOREKEY',
+      languages: [],
       distributionChannels: [],
+      supplyChannels: [],
+      productSelections: [],
     })
 
     const response = await supertest(ctMock.app).get(
@@ -32,12 +35,15 @@ describe('Store', () => {
 
     expect(response.status).toBe(200)
     expect(response.body).toEqual({
+      version: 1,
       createdAt: '',
-      distributionChannels: [],
       id: 'fake-store',
       key: 'STOREKEY',
       lastModifiedAt: '',
-      version: 1,
+      languages: [],
+      distributionChannels: [],
+      supplyChannels: [],
+      productSelections: [],
     })
   })
 
@@ -48,7 +54,10 @@ describe('Store', () => {
       createdAt: '',
       lastModifiedAt: '',
       key: 'STOREKEY',
+      languages: [],
       distributionChannels: [],
+      supplyChannels: [],
+      productSelections: [],
     })
 
     const response = await supertest(ctMock.app).get(

package/src/services/store.ts

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

package/src/services/subscription.ts

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

package/src/services/tax-category.ts

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

package/src/services/type.ts

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

package/src/services/zone.ts

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