@labdigital/commercetools-mock 1.4.0 → 1.6.0

package/src/services/custom-object.ts

@@ -5,63 +5,63 @@ import { getRepositoryContext } from '../repositories/helpers.js'
 import AbstractService from './abstract.js'
 
 export class CustomObjectService extends AbstractService {
-  public repository: CustomObjectRepository
+	public repository: CustomObjectRepository
 
-  constructor(parent: Router, repository: CustomObjectRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: CustomObjectRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'custom-objects'
-  }
+	getBasePath() {
+		return 'custom-objects'
+	}
 
-  extraRoutes(router: Router) {
-    router.get('/:container/:key', this.getWithContainerAndKey.bind(this))
-    router.post('/:container/:key', this.createWithContainerAndKey.bind(this))
-    router.delete('/:container/:key', this.deleteWithContainerAndKey.bind(this))
-  }
+	extraRoutes(router: Router) {
+		router.get('/:container/:key', this.getWithContainerAndKey.bind(this))
+		router.post('/:container/:key', this.createWithContainerAndKey.bind(this))
+		router.delete('/:container/:key', this.deleteWithContainerAndKey.bind(this))
+	}
 
-  getWithContainerAndKey(request: Request, response: Response) {
-    const result = this.repository.getWithContainerAndKey(
-      getRepositoryContext(request),
-      request.params.container,
-      request.params.key
-    )
+	getWithContainerAndKey(request: Request, response: Response) {
+		const result = this.repository.getWithContainerAndKey(
+			getRepositoryContext(request),
+			request.params.container,
+			request.params.key
+		)
 
-    if (!result) {
-      return response.status(404).send('Not Found')
-    }
-    return response.status(200).send(result)
-  }
+		if (!result) {
+			return response.status(404).send('Not Found')
+		}
+		return response.status(200).send(result)
+	}
 
-  createWithContainerAndKey(request: Request, response: Response) {
-    const draft: CustomObjectDraft = {
-      ...request.body,
-      key: request.params.key,
-      container: request.params.container,
-    }
+	createWithContainerAndKey(request: Request, response: Response) {
+		const draft: CustomObjectDraft = {
+			...request.body,
+			key: request.params.key,
+			container: request.params.container,
+		}
 
-    const result = this.repository.create(getRepositoryContext(request), draft)
-    return response.status(200).send(result)
-  }
+		const result = this.repository.create(getRepositoryContext(request), draft)
+		return response.status(200).send(result)
+	}
 
-  deleteWithContainerAndKey(request: Request, response: Response) {
-    const current = this.repository.getWithContainerAndKey(
-      getRepositoryContext(request),
-      request.params.container,
-      request.params.key
-    )
+	deleteWithContainerAndKey(request: Request, response: Response) {
+		const current = this.repository.getWithContainerAndKey(
+			getRepositoryContext(request),
+			request.params.container,
+			request.params.key
+		)
 
-    if (!current) {
-      return response.status(404).send('Not Found')
-    }
+		if (!current) {
+			return response.status(404).send('Not Found')
+		}
 
-    const result = this.repository.delete(
-      getRepositoryContext(request),
-      current.id
-    )
+		const result = this.repository.delete(
+			getRepositoryContext(request),
+			current.id
+		)
 
-    return response.status(200).send(result)
-  }
+		return response.status(200).send(result)
+	}
 }

package/src/services/customer-group.ts

@@ -3,14 +3,14 @@ import { CustomerGroupRepository } from '../repositories/customer-group.js'
 import AbstractService from './abstract.js'
 
 export class CustomerGroupService extends AbstractService {
-  public repository: CustomerGroupRepository
+	public repository: CustomerGroupRepository
 
-  constructor(parent: Router, repository: CustomerGroupRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: CustomerGroupRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'customer-groups'
-  }
+	getBasePath() {
+		return 'customer-groups'
+	}
 }

package/src/services/customer.test.ts

@@ -5,133 +5,155 @@ import { afterEach, beforeEach, describe, expect, test } from 'vitest'
 import { CommercetoolsMock, getBaseResourceProperties } from '../index.js'
 
 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')
-    )
-  })
+	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')
+		)
+	})
+
+	test('setCustomField', async () => {
+		assert(customer, 'customer not created')
+
+		customer = {
+			...customer,
+			custom: { type: { typeId: 'type', id: '' }, fields: {} },
+		}
+		ctMock.project('dummy').add('customer', customer)
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/customers/${customer.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{ action: 'setCustomField', name: 'isValidCouponCode', value: false },
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.custom.fields.isValidCouponCode).toBe(false)
+	})
 })

package/src/services/customer.ts

@@ -6,35 +6,35 @@ import { getRepositoryContext } from '../repositories/helpers.js'
 import AbstractService from './abstract.js'
 
 export class CustomerService extends AbstractService {
-  public repository: CustomerRepository
+	public repository: CustomerRepository
 
-  constructor(parent: Router, repository: CustomerRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: CustomerRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'customers'
-  }
+	getBasePath() {
+		return 'customers'
+	}
 
-  extraRoutes(parent: Router) {
-    parent.post('/password-token', (request, response) => {
-      const customer = this.repository.query(getRepositoryContext(request), {
-        where: [`email="${request.body.email}"`],
-      })
-      // @ts-ignore
-      const ttlMinutes: number = request.params.ttlMinutes
-        ? // @ts-ignore
-          +request.params.ttlMinutes
-        : 34560
-      const { version, ...rest } = getBaseResourceProperties()
+	extraRoutes(parent: Router) {
+		parent.post('/password-token', (request, response) => {
+			const customer = this.repository.query(getRepositoryContext(request), {
+				where: [`email="${request.body.email}"`],
+			})
+			// @ts-ignore
+			const ttlMinutes: number = request.params.ttlMinutes
+				? // @ts-ignore
+				  +request.params.ttlMinutes
+				: 34560
+			const { version, ...rest } = getBaseResourceProperties()
 
-      return response.status(200).send({
-        ...rest,
-        customerId: customer.results[0].id,
-        expiresAt: new Date(Date.now() + ttlMinutes * 60).toISOString(),
-        value: uuidv4(),
-      })
-    })
-  }
+			return response.status(200).send({
+				...rest,
+				customerId: customer.results[0].id,
+				expiresAt: new Date(Date.now() + ttlMinutes * 60).toISOString(),
+				value: uuidv4(),
+			})
+		})
+	}
 }

package/src/services/discount-code.ts

@@ -3,14 +3,14 @@ import { DiscountCodeRepository } from '../repositories/discount-code.js'
 import AbstractService from './abstract.js'
 
 export class DiscountCodeService extends AbstractService {
-  public repository: DiscountCodeRepository
+	public repository: DiscountCodeRepository
 
-  constructor(parent: Router, repository: DiscountCodeRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: DiscountCodeRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'discount-codes'
-  }
+	getBasePath() {
+		return 'discount-codes'
+	}
 }

package/src/services/extension.ts

@@ -3,14 +3,14 @@ import { ExtensionRepository } from '../repositories/extension.js'
 import AbstractService from './abstract.js'
 
 export class ExtensionServices extends AbstractService {
-  public repository: ExtensionRepository
+	public repository: ExtensionRepository
 
-  constructor(parent: Router, repository: ExtensionRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: ExtensionRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'extensions'
-  }
+	getBasePath() {
+		return 'extensions'
+	}
 }

package/src/services/index.ts

@@ -27,50 +27,58 @@ import { SubscriptionService } from './subscription.js'
 import { TaxCategoryService } from './tax-category.js'
 import { TypeService } from './type.js'
 import { ZoneService } from './zone.js'
+import { AttributeGroupService } from './attribute-group.js'
 
 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']),
-  'standalone-price': new StandAlonePriceService(router, repos['standalone-price']),
-  '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']),
+	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']),
+	'standalone-price': new StandAlonePriceService(
+		router,
+		repos['standalone-price']
+	),
+	'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']),
+	'attribute-group': new AttributeGroupService(
+		router,
+		repos['attribute-group']
+	),
+	type: new TypeService(router, repos['type']),
+	zone: new ZoneService(router, repos['zone']),
 })