@labdigital/commercetools-mock 1.10.0 → 2.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@labdigital/commercetools-mock",
   "author": "Michael van Tellingen",
-  "version": "1.10.0",
+  "version": "2.0.0",
   "license": "MIT",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -19,7 +19,7 @@
     }
   },
   "engines": {
-    "node": ">=16",
+    "node": ">=18",
     "pnpm": ">=8.6.5"
   },
   "packageManager": "pnpm@8.6.5",
@@ -39,7 +39,7 @@
     "express": "^4.18.2",
     "lodash.isequal": "^4.5.0",
     "morgan": "^1.10.0",
-    "nock": "^13.3.2",
+    "msw": "^2.0.0",
     "supertest": "^6.3.3",
     "uuid": "^9.0.0"
   },

package/src/constants.ts

@@ -1,4 +1,2 @@
-export const DEFAULT_API_HOSTNAME =
-	/^https:\/\/api\..*?\.commercetools.com:443$/
-export const DEFAULT_AUTH_HOSTNAME =
-	/^https:\/\/auth\..*?\.commercetools.com:443$/
+export const DEFAULT_API_HOSTNAME = 'https://api.*.commercetools.com'
+export const DEFAULT_AUTH_HOSTNAME = 'https://auth.*.commercetools.com'

package/src/ctMock.ts

@@ -1,7 +1,8 @@
-import nock from 'nock'
 import express, { NextFunction, Request, Response } from 'express'
 import supertest from 'supertest'
 import morgan from 'morgan'
+import { setupServer, SetupServer } from 'msw/node'
+import { http, HttpResponse } from 'msw'
 import { AbstractStorage, InMemoryStorage } from './storage/index.js'
 import { Services } from './types.js'
 import { CommercetoolsError } from './exceptions.js'
@@ -36,16 +37,15 @@ const DEFAULT_OPTIONS: CommercetoolsMockOptions = {
 	silent: false,
 }
 
+const _globalListeners: SetupServer[] = []
+
 export class CommercetoolsMock {
 	public app: express.Express
 	public options: CommercetoolsMockOptions
 
 	private _storage: AbstractStorage
 	private _oauth2: OAuth2Server
-	private _nockScopes: {
-		auth: nock.Scope | undefined
-		api: nock.Scope | undefined
-	} = { auth: undefined, api: undefined }
+	private _mswServer: SetupServer | undefined = undefined
 	private _services: Services | null
 	private _repositories: RepositoryMap | null
 	private _projectService?: ProjectService
@@ -67,19 +67,17 @@ export class CommercetoolsMock {
 
 	start() {
 		// Order is important here when the hostnames match
-		this.mockAuthHost()
-		this.mockApiHost()
+		this.clear()
+		this.startServer()
 	}
 
 	stop() {
-		this._nockScopes.auth?.persist(false)
-		this._nockScopes.auth = undefined
-
-		this._nockScopes.api?.persist(false)
-		this._nockScopes.api = undefined
+		this._mswServer?.close()
+		this._mswServer = undefined
 	}
 
 	clear() {
+		this._mswServer?.resetHandlers()
 		this._storage.clear()
 	}
 
@@ -157,48 +155,81 @@ export class CommercetoolsMock {
 		return app
 	}
 
-	private mockApiHost() {
-		const app = this.app
+	private startServer() {
+		// Check if there are any other servers running
+		if (_globalListeners.length > 0) {
+			if (this._mswServer !== undefined) {
+				throw new Error('Server already started')
+			} else {
+				console.warn("Server wasn't stopped properly, clearing")
+				_globalListeners.forEach((listener) => listener.close())
+			}
+		}
 
-		this._nockScopes.api = nock(this.options.apiHost)
-			.persist()
-			.get(/.*/)
-			.reply(async function (uri) {
-				const response = await supertest(app)
-					.get(uri)
-					.set(copyHeaders(this.req.headers))
-				return [response.status, response.body]
-			})
-			.post(/.*/)
-			.reply(async function (uri, body) {
-				const response = await supertest(app)
-					.post(uri)
-					.set(copyHeaders(this.req.headers))
+		const app = this.app
+		this._mswServer = setupServer(
+			http.post(`${this.options.authHost}/oauth/*`, async ({ request }) => {
+				const text = await request.text()
+				const url = new URL(request.url)
+				const res = await supertest(app)
+					.post(url.pathname + '?' + url.searchParams.toString())
+					.set(copyHeaders(request.headers))
+					.send(text)
+
+				return new HttpResponse(res.text, {
+					status: res.status,
+					headers: res.headers,
+				})
+			}),
+			http.get(`${this.options.apiHost}/*`, async ({ request }) => {
+				const body = await request.text()
+				const url = new URL(request.url)
+				const res = await supertest(app)
+					.get(url.pathname + '?' + url.searchParams.toString())
+					.set(copyHeaders(request.headers))
 					.send(body)
-				return [response.status, response.body]
-			})
-			.delete(/.*/)
-			.reply(async function (uri, body) {
-				const response = await supertest(app)
-					.delete(uri)
-					.set(copyHeaders(this.req.headers))
+				return new HttpResponse(res.text, {
+					status: res.status,
+					headers: res.headers,
+				})
+			}),
+			http.post(`${this.options.apiHost}/*`, async ({ request }) => {
+				const body = await request.text()
+				const url = new URL(request.url)
+				const res = await supertest(app)
+					.post(url.pathname + '?' + url.searchParams.toString())
+					.set(copyHeaders(request.headers))
+					.send(body)
+				return new HttpResponse(res.text, {
+					status: res.status,
+					headers: res.headers,
+				})
+			}),
+			http.delete(`${this.options.apiHost}/*`, async ({ request }) => {
+				const body = await request.text()
+				const url = new URL(request.url)
+				const res = await supertest(app)
+					.delete(url.pathname + '?' + url.searchParams.toString())
+					.set(copyHeaders(request.headers))
 					.send(body)
-				return [response.status, response.body]
-			})
-	}
-
-	private mockAuthHost() {
-		const app = this.app
 
-		this._nockScopes.auth = nock(this.options.authHost)
-			.persist()
-			.post(/^\/oauth\/.*/)
-			.reply(async function (uri, body) {
-				const response = await supertest(app)
-					.post(uri + '?' + body)
-					.set(copyHeaders(this.req.headers))
-					.send()
-				return [response.status, response.body]
+				return new HttpResponse(res.text, {
+					status: res.status,
+					headers: res.headers,
+				})
 			})
+		)
+		this._mswServer.listen({
+			// We need to allow requests done by supertest
+			onUnhandledRequest: (request, print) => {
+				const url = new URL(request.url)
+				if (url.hostname === '127.0.0.1') {
+					return
+				}
+				print.error()
+			},
+		})
+
+		_globalListeners.push(this._mswServer)
 	}
 }

package/src/index.test.ts

@@ -1,27 +1,63 @@
 import { type InvalidTokenError } from '@commercetools/platform-sdk'
 import { CommercetoolsMock } from './index.js'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import nock from 'nock'
+import { expect, test } from 'vitest'
 import got from 'got'
 
-beforeEach(() => {
-	nock.disableNetConnect()
-	nock.enableNetConnect('127.0.0.1') // supertest
-})
-afterEach(() => {
-	nock.enableNetConnect()
-	nock.cleanAll()
+test('node:fetch client', async () => {
+	const ctMock = new CommercetoolsMock({
+		enableAuthentication: true,
+		validateCredentials: true,
+		apiHost: 'https://localhost',
+		authHost: 'https://localhost:8080',
+	})
+	ctMock.start()
+
+	const authHeader = 'Basic ' + Buffer.from('foo:bar').toString('base64')
+	let response = await fetch('https://localhost:8080/oauth/token', {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/x-www-form-urlencoded',
+			Authorization: authHeader,
+		},
+		body: new URLSearchParams({
+			grant_type: 'client_credentials',
+			scope: 'manage_project:commercetools-node-mock',
+		}),
+	})
+
+	const authBody = await response.json()
+	expect(response.status).toBe(200)
+
+	const token = authBody.access_token
+	response = await fetch('https://localhost/my-project/orders', {
+		headers: {
+			Authorization: `Bearer ${token}`,
+		},
+	})
+
+	const body = await response.json()
+	expect(response.status).toBe(200)
+	expect(body).toStrictEqual({
+		count: 0,
+		total: 0,
+		offset: 0,
+		limit: 20,
+		results: [],
+	})
+	ctMock.stop()
 })
 
-test('Default mock endpoints', async () => {
+test('got client', async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: true,
 		validateCredentials: true,
+		apiHost: 'https://localhost',
+		authHost: 'https://localhost:8080',
 	})
 	ctMock.start()
 
 	let response = await got.post<{ access_token: string }>(
-		'https://auth.europe-west1.gcp.commercetools.com/oauth/token',
+		'https://localhost:8080/oauth/token',
 		{
 			searchParams: {
 				grant_type: 'client_credentials',
@@ -36,15 +72,12 @@ test('Default mock endpoints', async () => {
 
 	const token = response.body.access_token
 	expect(response.body.access_token).toBeDefined()
-	response = await got.get(
-		'https://api.europe-west1.gcp.commercetools.com/my-project/orders',
-		{
-			headers: {
-				Authorization: `Bearer ${token}`,
-			},
-			responseType: 'json',
-		}
-	)
+	response = await got.get('https://localhost/my-project/orders', {
+		headers: {
+			Authorization: `Bearer ${token}`,
+		},
+		responseType: 'json',
+	})
 	expect(response.statusCode).toBe(200)
 	expect(response.body).toStrictEqual({
 		count: 0,
@@ -192,6 +225,7 @@ test('apiHost mock proxy: querystring', async () => {
 			expand: 'custom.type',
 		},
 	})
+
 	expect(response.statusCode).toBe(200)
 	expect(response.body).toStrictEqual({
 		count: 0,

package/src/lib/proxy.ts

@@ -1,12 +1,12 @@
-export const copyHeaders = (headers: Record<string, string>) => {
-	const validHeaders = ['accept', 'host', 'authorization']
+export const copyHeaders = (headers: Headers) => {
+	const validHeaders = ['accept', 'host', 'authorization', 'content-type']
 	const result: Record<string, string> = {}
 
-	Object.entries(headers).forEach(([key, value]) => {
+	for (const [key, value] of headers.entries()) {
 		if (validHeaders.includes(key.toLowerCase())) {
 			result[key] = value
 		}
-	})
+	}
 
 	return result
 }

package/src/repositories/cart.ts

@@ -4,6 +4,8 @@ import type {
 	Cart,
 	CartAddLineItemAction,
 	CartChangeLineItemQuantityAction,
+	CartAddItemShippingAddressAction,
+	CartSetLineItemShippingDetailsAction,
 	CartDraft,
 	CartRemoveLineItemAction,
 	CartSetBillingAddressAction,
@@ -18,6 +20,7 @@ import type {
 	GeneralError,
 	LineItem,
 	LineItemDraft,
+	ItemShippingDetails,
 	Price,
 	Product,
 	ProductPagedQueryResponse,
@@ -216,6 +219,20 @@ export class CartRepository extends AbstractResourceRepository<'cart'> {
 			// Update cart total price
 			resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
 		},
+		addItemShippingAddress: (
+			context: RepositoryContext,
+			resource: Writable<Cart>,
+			{ action, address }: CartAddItemShippingAddressAction
+		) => {
+			const newAddress = createAddress(
+				address,
+				context.projectKey,
+				this._storage
+			)
+			if (newAddress) {
+				resource.itemShippingAddresses.push(newAddress)
+			}
+		},
 		changeLineItemQuantity: (
 			context: RepositoryContext,
 			resource: Writable<Cart>,
@@ -392,6 +409,37 @@ export class CartRepository extends AbstractResourceRepository<'cart'> {
 		) => {
 			resource.locale = locale
 		},
+		setLineItemShippingDetails: (
+			context: RepositoryContext,
+			resource: Writable<Cart>,
+			{
+				action,
+				shippingDetails,
+				lineItemId,
+				lineItemKey,
+			}: CartSetLineItemShippingDetailsAction
+		) => {
+			const lineItem = resource.lineItems.find(
+				(x) =>
+					(lineItemId && x.id === lineItemId) ||
+					(lineItemKey && x.key === lineItemKey)
+			)
+
+			if (!lineItem) {
+				// Check if line item is found
+				throw new CommercetoolsError<GeneralError>({
+					code: 'General',
+					message: lineItemKey
+						? `A line item with key '${lineItemKey}' not found.`
+						: `A line item with ID '${lineItemId}' not found.`,
+				})
+			}
+
+			lineItem.shippingDetails = {
+				...shippingDetails,
+				valid: true,
+			} as ItemShippingDetails
+		},
 		setShippingAddress: (
 			context: RepositoryContext,
 			resource: Writable<Cart>,

package/src/repositories/product-selection.ts

@@ -1,8 +1,8 @@
 import type {
 	ProductSelection,
+	ProductSelectionChangeNameAction,
 	ProductSelectionDraft,
-	Review,
-	ReviewUpdateAction,
+	ProductSelectionUpdateAction,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers.js'
 import type { Writable } from '../types.js'
@@ -20,6 +20,7 @@ export class ProductSelectionRepository extends AbstractResourceRepository<'prod
 		const resource: ProductSelection = {
 			...getBaseResourceProperties(),
 			productCount: 0,
+			key: draft.key,
 			name: draft.name,
 			type: 'individual',
 			mode: 'Individual',
@@ -30,12 +31,20 @@ export class ProductSelectionRepository extends AbstractResourceRepository<'prod
 
 	actions: Partial<
 		Record<
-			ReviewUpdateAction['action'],
+			ProductSelectionUpdateAction['action'],
 			(
 				context: RepositoryContext,
-				resource: Writable<Review>,
+				resource: Writable<ProductSelection>,
 				action: any
 			) => void
 		>
-	> = {}
+	> = {
+		changeName: (
+			context: RepositoryContext,
+			resource: Writable<ProductSelection>,
+			{ name }: ProductSelectionChangeNameAction
+		) => {
+			resource.name = name
+		},
+	}
 }

package/src/services/cart.test.ts

@@ -272,6 +272,37 @@ describe('Cart Update Actions', () => {
 		expect(response.body.message).toBe("A product with ID '123' not found.")
 	})
 
+	test('addItemShippingAddress', async () => {
+		const product = await supertest(ctMock.app)
+			.post(`/dummy/products`)
+			.send(productDraft)
+			.then((x) => x.body)
+
+		assert(cart, 'cart not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'addItemShippingAddress',
+						address: {
+							firstName: 'John',
+							lastName: 'Doe',
+							company: 'My Company',
+							country: 'NL',
+						},
+					},
+				],
+			})
+
+		expect(response.body.itemShippingAddresses).toHaveLength(1)
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.lineItems).toHaveLength(0)
+	})
+
 	test('removeLineItem', async () => {
 		const product = await supertest(ctMock.app)
 			.post(`/dummy/products`)
@@ -418,4 +449,60 @@ describe('Cart Update Actions', () => {
 		expect(response.body.version).toBe(2)
 		expect(response.body.shippingAddress).toEqual(address)
 	})
+
+	test('setLineItemShippingDetails', async () => {
+		const product = await supertest(ctMock.app)
+			.post(`/dummy/products`)
+			.send(productDraft)
+			.then((x) => x.body)
+
+		assert(cart, 'cart not created')
+		assert(product, 'product not created')
+
+		const updatedCart = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'addLineItem',
+						productId: product.id,
+						variantId: product.masterData.current.variants[0].id,
+					},
+				],
+			})
+		const lineItem = updatedCart.body.lineItems[0]
+		assert(lineItem, 'lineItem not created')
+
+		expect(updatedCart.body.version).toBe(2)
+		expect(updatedCart.body.lineItems).toHaveLength(1)
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cart.id}`)
+			.send({
+				version: updatedCart.body.version,
+				actions: [
+					{
+						action: 'setLineItemShippingDetails',
+						lineItemId: lineItem.id,
+						shippingDetails: {
+							targets: [
+								{
+									addressKey: 'address-key',
+									quantity: 1,
+								},
+							],
+						},
+					},
+				],
+			})
+
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(3)
+		expect(response.body.lineItems).toHaveLength(1)
+
+		const updatedLineItem = response.body.lineItems[0]
+		expect(updatedLineItem.shippingDetails).toBeDefined()
+		expect(updatedLineItem.shippingDetails.targets).toHaveLength(1)
+	})
 })

package/src/services/index.ts

@@ -1,12 +1,13 @@
 import { AssociateRoleServices } from './associate-roles.js'
+import { AttributeGroupService } from './attribute-group.js'
 import { BusinessUnitServices } from './business-units.js'
-import { CartService } from './cart.js'
 import { CartDiscountService } from './cart-discount.js'
+import { CartService } from './cart.js'
 import { CategoryServices } from './category.js'
 import { ChannelService } from './channel.js'
 import { CustomObjectService } from './custom-object.js'
-import { CustomerService } from './customer.js'
 import { CustomerGroupService } from './customer-group.js'
+import { CustomerService } from './customer.js'
 import { DiscountCodeService } from './discount-code.js'
 import { ExtensionServices } from './extension.js'
 import { InventoryEntryService } from './inventory-entry.js'
@@ -16,10 +17,11 @@ import { MyOrderService } from './my-order.js'
 import { MyPaymentService } from './my-payment.js'
 import { OrderService } from './order.js'
 import { PaymentService } from './payment.js'
-import { ProductService } from './product.js'
 import { ProductDiscountService } from './product-discount.js'
 import { ProductProjectionService } from './product-projection.js'
+import { ProductSelectionService } from './product-selection.js'
 import { ProductTypeService } from './product-type.js'
+import { ProductService } from './product.js'
 import { ShippingMethodService } from './shipping-method.js'
 import { ShoppingListService } from './shopping-list.js'
 import { StandAlonePriceService } from './standalone-price.js'
@@ -29,7 +31,6 @@ 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) => ({
 	'associate-role': new AssociateRoleServices(router, repos['associate-role']),
@@ -74,6 +75,10 @@ export const createServices = (router: any, repos: any) => ({
 		router,
 		repos['product-projection']
 	),
+	'product-selection': new ProductSelectionService(
+		router,
+		repos['product-selection']
+	),
 	'shopping-list': new ShoppingListService(router, repos['shopping-list']),
 	state: new StateService(router, repos['state']),
 	store: new StoreService(router, repos['store']),

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

@@ -0,0 +1,36 @@
+import type { ProductSelectionDraft } from '@commercetools/platform-sdk'
+import supertest from 'supertest'
+import { describe, expect, test } from 'vitest'
+import { CommercetoolsMock } from '../index.js'
+
+const ctMock = new CommercetoolsMock()
+
+describe('product-selection', () => {
+	test('Create product selection', async () => {
+		const draft: ProductSelectionDraft = {
+			name: {
+				en: 'foo',
+			},
+			key: 'foo',
+		}
+		const response = await supertest(ctMock.app)
+			.post('/dummy/product-selections')
+			.send(draft)
+
+		expect(response.status).toBe(201)
+
+		expect(response.body).toEqual({
+			createdAt: expect.anything(),
+			id: expect.anything(),
+			lastModifiedAt: expect.anything(),
+			name: {
+				en: 'foo',
+			},
+			key: 'foo',
+			version: 1,
+			productCount: 0,
+			type: 'individual',
+			mode: 'Individual',
+		})
+	})
+})

package/src/services/product-selection.ts

@@ -0,0 +1,16 @@
+import { Router } from 'express'
+import AbstractService from './abstract.js'
+import { ProductSelectionRepository } from '../repositories/product-selection.js'
+
+export class ProductSelectionService extends AbstractService {
+	public repository: ProductSelectionRepository
+
+	constructor(parent: Router, repository: ProductSelectionRepository) {
+		super(parent)
+		this.repository = repository
+	}
+
+	getBasePath() {
+		return 'product-selections'
+	}
+}