@labdigital/commercetools-mock 2.17.1 → 2.18.0

package/src/services/product.test.ts

@@ -12,112 +12,112 @@ import type {
 	StateDraft,
 	TaxCategory,
 	TaxCategoryDraft,
-} from '@commercetools/platform-sdk'
-import assert from 'assert'
-import supertest from 'supertest'
-import { beforeAll, beforeEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+} from "@commercetools/platform-sdk";
+import assert from "assert";
+import supertest from "supertest";
+import { beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
 const productTypeDraft: ProductTypeDraft = {
-	key: 'test-product-type',
-	name: 'Test Product Type',
-	description: 'Test Product Type description',
-}
+	key: "test-product-type",
+	name: "Test Product Type",
+	description: "Test Product Type description",
+};
 
 const categoryDraft1: CategoryDraft = {
-	key: 'category-1',
+	key: "category-1",
 	name: {
-		'nl-NL': 'Category One',
+		"nl-NL": "Category One",
 	},
 	slug: {
-		'nl-NL': 'category_1',
+		"nl-NL": "category_1",
 	},
-}
+};
 
 const categoryDraft2: CategoryDraft = {
-	key: 'category-2',
+	key: "category-2",
 	name: {
-		'nl-NL': 'Category Two',
+		"nl-NL": "Category Two",
 	},
 	slug: {
-		'nl-NL': 'category_2',
+		"nl-NL": "category_2",
 	},
-}
+};
 
 const taxcategoryDraft1: TaxCategoryDraft = {
-	name: 'Tax category 1',
-	key: 'tax-category-1',
-}
+	name: "Tax category 1",
+	key: "tax-category-1",
+};
 
 const taxcategoryDraft2: TaxCategoryDraft = {
-	name: 'Tax category 2',
-	key: 'tax-category-2',
-}
+	name: "Tax category 2",
+	key: "tax-category-2",
+};
 
 const productState1Draft: StateDraft = {
-	key: 'initial-state',
-	type: 'ProductState',
+	key: "initial-state",
+	type: "ProductState",
 	initial: true,
 	name: {
-		'nl-NL': 'Initial state',
+		"nl-NL": "Initial state",
 	},
 	description: {
-		'nl-NL': 'Product initial state',
+		"nl-NL": "Product initial state",
 	},
-}
+};
 
 const productState2Draft: StateDraft = {
-	key: 'another-state',
-	type: 'ProductState',
+	key: "another-state",
+	type: "ProductState",
 	initial: true,
 	name: {
-		'nl-NL': 'Another state',
+		"nl-NL": "Another state",
 	},
 	description: {
-		'nl-NL': 'Product another state',
+		"nl-NL": "Product another state",
 	},
-}
+};
 
 const publishedProductDraft: ProductDraft = {
 	name: {
-		'nl-NL': 'test published product',
+		"nl-NL": "test published product",
 	},
 	description: {
-		'nl-NL': 'Test published product description',
+		"nl-NL": "Test published product description",
 	},
 	productType: {
-		typeId: 'product-type',
-		key: 'test-product-type',
+		typeId: "product-type",
+		key: "test-product-type",
 	},
 	categories: [
 		{
-			typeId: 'category',
-			key: 'category-1',
+			typeId: "category",
+			key: "category-1",
 		},
 	],
 	taxCategory: {
-		typeId: 'tax-category',
+		typeId: "tax-category",
 		key: taxcategoryDraft1.key,
 	},
 	state: {
-		typeId: 'state',
-		key: 'initial-state',
+		typeId: "state",
+		key: "initial-state",
 	},
 	masterVariant: {
-		key: 'master-variant-key',
-		sku: '1337',
+		key: "master-variant-key",
+		sku: "1337",
 		attributes: [
 			{
-				name: 'test',
-				value: 'test',
+				name: "test",
+				value: "test",
 			},
 		],
 		prices: [
 			{
-				key: 'base_price_eur',
-				country: 'NL',
+				key: "base_price_eur",
+				country: "NL",
 				value: {
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 					centAmount: 1000,
 				},
 			},
@@ -125,20 +125,20 @@ const publishedProductDraft: ProductDraft = {
 	},
 	variants: [
 		{
-			key: 'variant-1-key',
-			sku: '1338',
+			key: "variant-1-key",
+			sku: "1338",
 			attributes: [
 				{
-					name: 'test2',
-					value: 'test2',
+					name: "test2",
+					value: "test2",
 				},
 			],
 			prices: [
 				{
-					key: 'base_price_eur',
-					country: 'NL',
+					key: "base_price_eur",
+					country: "NL",
 					value: {
-						currencyCode: 'EUR',
+						currencyCode: "EUR",
 						centAmount: 2000,
 					},
 				},
@@ -146,61 +146,61 @@ const publishedProductDraft: ProductDraft = {
 		},
 	],
 	slug: {
-		'nl-NL': 'test-published-product',
+		"nl-NL": "test-published-product",
 	},
 	metaTitle: {
-		'nl-NL': 'Unpublished product (meta title)',
+		"nl-NL": "Unpublished product (meta title)",
 	},
 	metaDescription: {
-		'nl-NL': 'Unpublished product description (meta description)',
+		"nl-NL": "Unpublished product description (meta description)",
 	},
 	metaKeywords: {
-		'nl-NL': 'Test product (meta Keywords)',
+		"nl-NL": "Test product (meta Keywords)",
 	},
 	publish: true,
-}
+};
 
 const unpublishedProductDraft: ProductDraft = {
-	key: 'test-unpublished-product',
+	key: "test-unpublished-product",
 	name: {
-		'nl-NL': 'test unpublished product',
+		"nl-NL": "test unpublished product",
 	},
 	description: {
-		'nl-NL': 'Test published product description',
+		"nl-NL": "Test published product description",
 	},
 	productType: {
-		typeId: 'product-type',
-		key: 'test-product-type',
+		typeId: "product-type",
+		key: "test-product-type",
 	},
 	categories: [
 		{
-			typeId: 'category',
-			key: 'category-1',
+			typeId: "category",
+			key: "category-1",
 		},
 	],
 	taxCategory: {
-		typeId: 'tax-category',
+		typeId: "tax-category",
 		key: taxcategoryDraft1.key,
 	},
 	state: {
-		typeId: 'state',
-		key: 'initial-state',
+		typeId: "state",
+		key: "initial-state",
 	},
 	masterVariant: {
-		key: 'master-variant-key',
-		sku: '2337',
+		key: "master-variant-key",
+		sku: "2337",
 		attributes: [
 			{
-				name: 'test',
-				value: 'test',
+				name: "test",
+				value: "test",
 			},
 		],
 		prices: [
 			{
-				key: 'base_price_eur',
-				country: 'NL',
+				key: "base_price_eur",
+				country: "NL",
 				value: {
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 					centAmount: 1000,
 				},
 			},
@@ -208,20 +208,20 @@ const unpublishedProductDraft: ProductDraft = {
 	},
 	variants: [
 		{
-			key: 'variant-1-key',
-			sku: '2338',
+			key: "variant-1-key",
+			sku: "2338",
 			attributes: [
 				{
-					name: 'test2',
-					value: 'test2',
+					name: "test2",
+					value: "test2",
 				},
 			],
 			prices: [
 				{
-					key: 'base_price_eur',
-					country: 'NL',
+					key: "base_price_eur",
+					country: "NL",
 					value: {
-						currencyCode: 'EUR',
+						currencyCode: "EUR",
 						centAmount: 2000,
 					},
 				},
@@ -229,145 +229,145 @@ const unpublishedProductDraft: ProductDraft = {
 		},
 	],
 	slug: {
-		'nl-NL': 'test-unpublished-product',
+		"nl-NL": "test-unpublished-product",
 	},
 	metaTitle: {
-		'nl-NL': 'Unpublished product (meta title)',
+		"nl-NL": "Unpublished product (meta title)",
 	},
 	metaDescription: {
-		'nl-NL': 'Unpublished product description (meta description)',
+		"nl-NL": "Unpublished product description (meta description)",
 	},
 	metaKeywords: {
-		'nl-NL': 'Test product (meta Keywords)',
+		"nl-NL": "Test product (meta Keywords)",
 	},
 	publish: false,
-}
-
-let productType: ProductType
-let category1: Category
-let category2: Category
-let taxCategory1: TaxCategory
-let taxCategory2: TaxCategory
-let productState1: State
-let productState2: State
-
-async function beforeAllProductTests(mock) {
-	let response
+};
+
+let productType: ProductType;
+let category1: Category;
+let category2: Category;
+let taxCategory1: TaxCategory;
+let taxCategory2: TaxCategory;
+let productState1: State;
+let productState2: State;
+
+async function beforeAllProductTests(mock: CommercetoolsMock) {
+	let response;
 	// Create Product Type
 	response = await supertest(mock.app)
-		.post('/dummy/product-types')
-		.send(productTypeDraft)
+		.post("/dummy/product-types")
+		.send(productTypeDraft);
 
-	expect(response.status).toBe(201)
-	productType = response.body
+	expect(response.status).toBe(201);
+	productType = response.body;
 
 	// Create Category 1
 	response = await supertest(mock.app)
-		.post('/dummy/categories')
-		.send(categoryDraft1)
+		.post("/dummy/categories")
+		.send(categoryDraft1);
 
-	expect(response.status).toBe(201)
-	category1 = response.body
+	expect(response.status).toBe(201);
+	category1 = response.body;
 
 	// Create Category 2
 	response = await supertest(mock.app)
-		.post('/dummy/categories')
-		.send(categoryDraft2)
+		.post("/dummy/categories")
+		.send(categoryDraft2);
 
-	expect(response.status).toBe(201)
-	category2 = response.body
+	expect(response.status).toBe(201);
+	category2 = response.body;
 
 	// Create Tax Category 1
 	response = await supertest(mock.app)
-		.post('/dummy/tax-categories')
-		.send(taxcategoryDraft1)
+		.post("/dummy/tax-categories")
+		.send(taxcategoryDraft1);
 
-	expect(response.status).toBe(201)
-	taxCategory1 = response.body
+	expect(response.status).toBe(201);
+	taxCategory1 = response.body;
 
 	// Create Tax Category 2
 	response = await supertest(mock.app)
-		.post('/dummy/tax-categories')
-		.send(taxcategoryDraft2)
+		.post("/dummy/tax-categories")
+		.send(taxcategoryDraft2);
 
-	expect(response.status).toBe(201)
-	taxCategory2 = response.body
+	expect(response.status).toBe(201);
+	taxCategory2 = response.body;
 
 	// Create Product State 1
 	response = await supertest(mock.app)
-		.post('/dummy/states')
-		.send(productState1Draft)
+		.post("/dummy/states")
+		.send(productState1Draft);
 
-	expect(response.status).toBe(201)
-	productState1 = response.body
+	expect(response.status).toBe(201);
+	productState1 = response.body;
 
 	// Create Product State 2
 	response = await supertest(mock.app)
-		.post('/dummy/states')
-		.send(productState2Draft)
+		.post("/dummy/states")
+		.send(productState2Draft);
 
-	expect(response.status).toBe(201)
-	productState2 = response.body
+	expect(response.status).toBe(201);
+	productState2 = response.body;
 }
 
-describe('Product', () => {
-	const ctMock = new CommercetoolsMock()
+describe("Product", () => {
+	const ctMock = new CommercetoolsMock();
 	beforeAll(async () => {
-		await beforeAllProductTests(ctMock)
-	})
+		await beforeAllProductTests(ctMock);
+	});
 
-	test('Create product', async () => {
-		assert(productType, 'product type not created')
+	test("Create product", async () => {
+		assert(productType, "product type not created");
 
 		const response = await supertest(ctMock.app)
-			.post('/dummy/products')
-			.send(unpublishedProductDraft)
+			.post("/dummy/products")
+			.send(unpublishedProductDraft);
 
 		const productData: ProductData = {
 			name: {
-				'nl-NL': 'test unpublished product',
+				"nl-NL": "test unpublished product",
 			},
 			description: {
-				'nl-NL': 'Test published product description',
+				"nl-NL": "Test published product description",
 			},
 			slug: {
-				'nl-NL': 'test-unpublished-product',
+				"nl-NL": "test-unpublished-product",
 			},
 			categories: [
 				{
 					id: category1.id,
-					typeId: 'category',
+					typeId: "category",
 				},
 			],
 			metaTitle: {
-				'nl-NL': 'Unpublished product (meta title)',
+				"nl-NL": "Unpublished product (meta title)",
 			},
 			metaDescription: {
-				'nl-NL': 'Unpublished product description (meta description)',
+				"nl-NL": "Unpublished product description (meta description)",
 			},
 			metaKeywords: {
-				'nl-NL': 'Test product (meta Keywords)',
+				"nl-NL": "Test product (meta Keywords)",
 			},
 			masterVariant: {
 				id: 1,
-				key: 'master-variant-key',
-				sku: '2337',
+				key: "master-variant-key",
+				sku: "2337",
 				assets: [],
 				attributes: [
 					{
-						name: 'test',
-						value: 'test',
+						name: "test",
+						value: "test",
 					},
 				],
 				prices: [
 					{
 						id: expect.anything(),
-						key: 'base_price_eur',
-						country: 'NL',
+						key: "base_price_eur",
+						country: "NL",
 						value: {
-							type: 'centPrecision',
+							type: "centPrecision",
 							centAmount: 1000,
-							currencyCode: 'EUR',
+							currencyCode: "EUR",
 							fractionDigits: 2,
 						},
 					},
@@ -376,26 +376,26 @@ describe('Product', () => {
 			},
 			variants: [
 				{
-					key: 'variant-1-key',
-					sku: '2338',
+					key: "variant-1-key",
+					sku: "2338",
 					assets: [],
 					id: 2,
 					images: [],
 					attributes: [
 						{
-							name: 'test2',
-							value: 'test2',
+							name: "test2",
+							value: "test2",
 						},
 					],
 					prices: [
 						{
 							id: expect.anything(),
-							key: 'base_price_eur',
-							country: 'NL',
+							key: "base_price_eur",
+							country: "NL",
 							value: {
-								type: 'centPrecision',
+								type: "centPrecision",
 								centAmount: 2000,
-								currencyCode: 'EUR',
+								currencyCode: "EUR",
 								fractionDigits: 2,
 							},
 						},
@@ -403,15 +403,15 @@ describe('Product', () => {
 				},
 			],
 			searchKeywords: {},
-		}
+		};
 
 		expect(response.body).toEqual({
 			createdAt: expect.anything(),
 			id: expect.anything(),
 			lastModifiedAt: expect.anything(),
-			key: 'test-unpublished-product',
+			key: "test-unpublished-product",
 			taxCategory: {
-				typeId: 'tax-category',
+				typeId: "tax-category",
 				id: taxCategory1.id,
 			},
 			masterData: {
@@ -421,43 +421,43 @@ describe('Product', () => {
 				published: false,
 			},
 			productType: {
-				typeId: 'product-type',
+				typeId: "product-type",
 				id: productType.id,
 			},
 			state: {
-				typeId: 'state',
+				typeId: "state",
 				id: productState1.id,
 			},
 			version: 1,
-		} as Product)
-	})
-})
+		} as Product);
+	});
+});
 
-describe('Product update actions', () => {
-	const ctMock = new CommercetoolsMock()
-	let productPublished: Product | undefined
+describe("Product update actions", () => {
+	const ctMock = new CommercetoolsMock();
+	let productPublished: Product | undefined;
 	beforeAll(async () => {
-		await beforeAllProductTests(ctMock)
-	})
+		await beforeAllProductTests(ctMock);
+	});
 
 	beforeEach(async () => {
-		let response
+		let response;
 		response = await supertest(ctMock.app)
-			.post('/dummy/products')
-			.send(publishedProductDraft)
+			.post("/dummy/products")
+			.send(publishedProductDraft);
 
-		expect(response.status).toBe(201)
-		productPublished = response.body
+		expect(response.status).toBe(201);
+		productPublished = response.body;
 
 		response = await supertest(ctMock.app)
-			.post('/dummy/products')
-			.send(unpublishedProductDraft)
+			.post("/dummy/products")
+			.send(unpublishedProductDraft);
 
-		expect(response.status).toBe(201)
-	})
+		expect(response.status).toBe(201);
+	});
 
-	test('setAttribute masterVariant (staged)', async () => {
-		assert(productPublished, 'product not created')
+	test("setAttribute masterVariant (staged)", async () => {
+		assert(productPublished, "product not created");
 
 		{
 			const response = await supertest(ctMock.app)
@@ -465,21 +465,23 @@ describe('Product update actions', () => {
 				.send({
 					version: 1,
 					actions: [
-						{ action: 'setAttribute', sku: '1337', name: 'foo', value: 'bar' },
+						{ 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(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' })
+				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
@@ -488,21 +490,21 @@ describe('Product update actions', () => {
 				.post(`/dummy/products/${productPublished.id}`)
 				.send({
 					version: 2,
-					actions: [{ action: 'publish', scope: 'All' }],
-				})
+					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(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
-			)
+				2,
+			);
 		}
-	})
+	});
 
-	test('setAttribute masterVariant (published)', async () => {
-		assert(productPublished, 'product not created')
+	test("setAttribute masterVariant (published)", async () => {
+		assert(productPublished, "product not created");
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
@@ -510,227 +512,225 @@ describe('Product update actions', () => {
 				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)
-		const product: Product = response.body
+		expect(response.status).toBe(200);
+		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)
+		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' })
-	})
+		const attr = response.body.masterData.staged.masterVariant.attributes[1];
+		expect(attr).toEqual({ name: "foo", value: "bar" });
+	});
 
-	test('setAttribute variant', async () => {
-		assert(productPublished, 'product not created')
+	test("setAttribute variant", async () => {
+		assert(productPublished, "product not created");
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
-					{ action: 'setAttribute', sku: '1338', name: 'foo', value: 'bar' },
+					{ action: "setAttribute", sku: "1338", name: "foo", value: "bar" },
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		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' })
-	})
+			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(productPublished, 'product not created')
+	test("setAttribute variant and publish", async () => {
+		assert(productPublished, "product not created");
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
-					{ action: 'setAttribute', sku: '1338', name: 'foo', value: 'bar' },
-					{ action: 'publish' },
+					{ action: "setAttribute", sku: "1338", name: "foo", value: "bar" },
+					{ action: "publish" },
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(3)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(3);
 		expect(
-			response.body.masterData.current.variants[0].attributes
-		).toHaveLength(2)
-		const attr = response.body.masterData.current.variants[0].attributes[1]
-		expect(attr).toEqual({ name: 'foo', value: 'bar' })
-	})
+			response.body.masterData.current.variants[0].attributes,
+		).toHaveLength(2);
+		const attr = response.body.masterData.current.variants[0].attributes[1];
+		expect(attr).toEqual({ name: "foo", value: "bar" });
+	});
 
-	test('setAttribute overwrite', async () => {
-		assert(productPublished, 'product not created')
+	test("setAttribute overwrite", 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: 'test', value: 'foo' },
+					{ action: "setAttribute", sku: "1337", name: "test", value: "foo" },
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(
-			response.body.masterData.staged.masterVariant.attributes
-		).toHaveLength(1)
-		const attr = response.body.masterData.staged.masterVariant.attributes[0]
-		expect(attr).toEqual({ name: 'test', value: 'foo' })
-	})
-
-	test('setAttributeInAllVariants overwrite', async () => {
-		assert(productPublished, 'product not created')
+			response.body.masterData.staged.masterVariant.attributes,
+		).toHaveLength(1);
+		const attr = response.body.masterData.staged.masterVariant.attributes[0];
+		expect(attr).toEqual({ name: "test", value: "foo" });
+	});
+
+	test("setAttributeInAllVariants overwrite", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setAttributeInAllVariants',
-						name: 'test',
-						value: 'foo',
+						action: "setAttributeInAllVariants",
+						name: "test",
+						value: "foo",
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(
-			response.body.masterData.staged.masterVariant.attributes
-		).toHaveLength(1)
+			});
+		expect(response.status).toBe(200);
+		const product = response.body as Product;
+		expect(product.version).toBe(2);
+		expect(product.masterData.staged.masterVariant.attributes).toHaveLength(1);
 
 		const masterVariantAttr1 =
-			response.body.masterData.staged.masterVariant.attributes[0]
-		expect(masterVariantAttr1).toEqual({ name: 'test', value: 'foo' })
-
-		response.body.masterData.staged.variants.forEach((variant) => {
-			expect(variant.attributes).toHaveLength(2)
-			expect(variant.attributes[1]).toEqual({
-				name: 'test',
-				value: 'foo',
-			})
-		})
-	})
-
-	test('setAttributeInAllVariants product staged', async () => {
-		assert(productPublished, 'product not created')
+			product.masterData.staged.masterVariant.attributes?.[0];
+		expect(masterVariantAttr1).toEqual({ name: "test", value: "foo" });
+
+		product.masterData.staged.variants.forEach((variant) => {
+			expect(variant.attributes).toHaveLength(2);
+			expect(variant.attributes?.[1]).toEqual({
+				name: "test",
+				value: "foo",
+			});
+		});
+	});
+
+	test("setAttributeInAllVariants product staged", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setAttributeInAllVariants',
-						name: 'foo',
-						value: 'bar',
+						action: "setAttributeInAllVariants",
+						name: "foo",
+						value: "bar",
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(
-			response.body.masterData.staged.masterVariant.attributes
-		).toHaveLength(2)
+			});
+		expect(response.status).toBe(200);
+		const product = response.body as Product;
+		expect(product.version).toBe(2);
+		expect(product.masterData.staged.masterVariant.attributes).toHaveLength(2);
 		const masterVariantAttr1 =
-			response.body.masterData.staged.masterVariant.attributes[0]
-		expect(masterVariantAttr1).toEqual({ name: 'test', value: 'test' })
+			product.masterData.staged.masterVariant.attributes?.[0];
+		expect(masterVariantAttr1).toEqual({ name: "test", value: "test" });
 
 		const masterVariantAttr2 =
-			response.body.masterData.staged.masterVariant.attributes[1]
+			product.masterData.staged.masterVariant.attributes?.[1];
 		expect(masterVariantAttr2).toEqual({
-			name: 'foo',
-			value: 'bar',
-		})
-		response.body.masterData.staged.variants.forEach((variant) => {
-			expect(variant.attributes).toHaveLength(2)
-			expect(variant.attributes[1]).toEqual({
-				name: 'foo',
-				value: 'bar',
-			})
-		})
-	})
-
-	test('setAttributeInAllVariants and publish', async () => {
-		assert(productPublished, 'product not created')
+			name: "foo",
+			value: "bar",
+		});
+		product.masterData.staged.variants.forEach((variant) => {
+			expect(variant.attributes).toHaveLength(2);
+			expect(variant.attributes?.[1]).toEqual({
+				name: "foo",
+				value: "bar",
+			});
+		});
+	});
+
+	test("setAttributeInAllVariants and publish", async () => {
+		assert(productPublished, "product not created");
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
-					{ action: 'setAttributeInAllVariants', name: 'foo', value: 'bar' },
-					{ action: 'publish' },
+					{ action: "setAttributeInAllVariants", name: "foo", value: "bar" },
+					{ action: "publish" },
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(3)
-		expect(
-			response.body.masterData.current.masterVariant.attributes
-		).toHaveLength(2)
-		const attr = response.body.masterData.current.masterVariant.attributes[1]
-		expect(attr).toEqual({ name: 'foo', value: 'bar' })
-
-		response.body.masterData.current.variants.forEach((variant) => {
-			expect(variant.attributes).toHaveLength(2)
-			expect(variant.attributes[1]).toEqual({
-				name: 'foo',
-				value: 'bar',
-			})
-		})
-	})
-
-	test('addExternalImage variant', async () => {
-		assert(productPublished, 'product not created')
+			});
+
+		const product = response.body as Product;
+		expect(response.status).toBe(200);
+		expect(product.version).toBe(3);
+		expect(product.masterData.current.masterVariant.attributes).toHaveLength(2);
+		const attr = product.masterData.current.masterVariant.attributes?.[1];
+		expect(attr).toEqual({ name: "foo", value: "bar" });
+
+		product.masterData.current.variants.forEach((variant) => {
+			expect(variant.attributes).toHaveLength(2);
+			expect(variant.attributes?.[1]).toEqual({
+				name: "foo",
+				value: "bar",
+			});
+		});
+	});
+
+	test("addExternalImage variant", async () => {
+		assert(productPublished, "product not created");
 
 		const image: Image = {
-			url: 'http://example.com/image',
+			url: "http://example.com/image",
 			dimensions: { w: 100, h: 100 },
-		}
+		};
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
-				actions: [{ action: 'addExternalImage', sku: '1338', image }],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.masterData.staged.variants[0].images).toHaveLength(1)
-		const attr = response.body.masterData.staged.variants[0].images[0]
-		expect(attr).toEqual(image)
-	})
-
-	test('removeImage variant', async () => {
-		assert(productPublished, 'product not created')
+				actions: [{ action: "addExternalImage", sku: "1338", image }],
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.masterData.staged.variants[0].images).toHaveLength(1);
+		const attr = response.body.masterData.staged.variants[0].images[0];
+		expect(attr).toEqual(image);
+	});
+
+	test("removeImage variant", async () => {
+		assert(productPublished, "product not created");
 
 		const image: Image = {
-			url: 'http://example.com/image',
+			url: "http://example.com/image",
 			dimensions: { w: 100, h: 100 },
-		}
+		};
 
 		{
 			const response = await supertest(ctMock.app)
 				.post(`/dummy/products/${productPublished.id}`)
 				.send({
 					version: 1,
-					actions: [{ action: 'addExternalImage', sku: '1338', image }],
-				})
-			expect(response.status).toBe(200)
-			expect(response.body.version).toBe(2)
+					actions: [{ action: "addExternalImage", sku: "1338", image }],
+				});
+			expect(response.status).toBe(200);
+			expect(response.body.version).toBe(2);
 		}
 
 		const response = await supertest(ctMock.app)
@@ -739,28 +739,28 @@ describe('Product update actions', () => {
 				version: 2,
 				actions: [
 					{
-						action: 'removeImage',
-						sku: '1338',
+						action: "removeImage",
+						sku: "1338",
 						imageUrl: image.url,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(3)
-		expect(response.body.masterData.staged.variants[0].images).toHaveLength(0)
-	})
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(3);
+		expect(response.body.masterData.staged.variants[0].images).toHaveLength(0);
+	});
 
-	test('moveImageToPosition variant', async () => {
-		assert(productPublished, 'product not created')
+	test("moveImageToPosition variant", async () => {
+		assert(productPublished, "product not created");
 
 		const image1: Image = {
-			url: 'http://example.com/image1',
+			url: "http://example.com/image1",
 			dimensions: { w: 100, h: 100 },
-		}
+		};
 		const image2: Image = {
-			url: 'http://example.com/image2',
+			url: "http://example.com/image2",
 			dimensions: { w: 100, h: 100 },
-		}
+		};
 
 		{
 			const response = await supertest(ctMock.app)
@@ -768,12 +768,12 @@ describe('Product update actions', () => {
 				.send({
 					version: 1,
 					actions: [
-						{ action: 'addExternalImage', sku: '1338', image: image1 },
-						{ action: 'addExternalImage', sku: '1338', image: image2 },
+						{ action: "addExternalImage", sku: "1338", image: image1 },
+						{ action: "addExternalImage", sku: "1338", image: image2 },
 					],
-				})
-			expect(response.status).toBe(200)
-			expect(response.body.version).toBe(3)
+				});
+			expect(response.status).toBe(200);
+			expect(response.body.version).toBe(3);
 		}
 
 		const response = await supertest(ctMock.app)
@@ -782,31 +782,31 @@ describe('Product update actions', () => {
 				version: 3,
 				actions: [
 					{
-						action: 'moveImageToPosition',
-						sku: '1338',
+						action: "moveImageToPosition",
+						sku: "1338",
 						imageUrl: image2.url,
 						position: 0,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(4)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(4);
 		expect(response.body.masterData.staged.variants[0].images).toEqual([
-			{ url: 'http://example.com/image2', dimensions: { w: 100, h: 100 } },
-			{ url: 'http://example.com/image1', dimensions: { w: 100, h: 100 } },
-		])
-	})
+			{ url: "http://example.com/image2", dimensions: { w: 100, h: 100 } },
+			{ url: "http://example.com/image1", dimensions: { w: 100, h: 100 } },
+		]);
+	});
 
-	test('addPrice variant', async () => {
-		assert(productPublished, 'product not created')
+	test("addPrice variant", async () => {
+		assert(productPublished, "product not created");
 
 		const priceDraft: PriceDraft = {
-			country: 'BE',
+			country: "BE",
 			value: {
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				centAmount: 3000,
 			},
-		}
+		};
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
@@ -814,49 +814,49 @@ describe('Product update actions', () => {
 				version: 1,
 				actions: [
 					{
-						action: 'addPrice',
+						action: "addPrice",
 						price: priceDraft,
 						variantId: 1,
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(response.body.masterData.staged.masterVariant.prices).toMatchObject([
 			{
-				country: 'NL',
+				country: "NL",
 				value: {
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 					centAmount: 1000,
 				},
 			},
 			{
-				country: 'BE',
+				country: "BE",
 				value: {
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 					centAmount: 3000,
 				},
 			},
-		])
+		]);
 		expect(response.body.masterData.staged.masterVariant.prices[1].id).toBe(
-			response.body.masterData.current.masterVariant.prices[1].id
-		)
-	})
+			response.body.masterData.current.masterVariant.prices[1].id,
+		);
+	});
 
-	test('changePrice variant', async () => {
-		assert(productPublished, 'product not created')
+	test("changePrice variant", async () => {
+		assert(productPublished, "product not created");
 		const priceId =
-			productPublished?.masterData.current.masterVariant.prices?.[0].id
-		assert(priceId)
+			productPublished?.masterData.current.masterVariant.prices?.[0].id;
+		assert(priceId);
 
 		const priceDraft: PriceDraft = {
-			country: 'BE',
+			country: "BE",
 			value: {
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				centAmount: 3000,
 			},
-		}
+		};
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
@@ -864,31 +864,31 @@ describe('Product update actions', () => {
 				version: 1,
 				actions: [
 					{
-						action: 'changePrice',
+						action: "changePrice",
 						priceId,
 						price: priceDraft,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(response.body.masterData.staged.masterVariant.prices).toMatchObject([
 			{
 				id: priceId,
-				country: 'BE',
+				country: "BE",
 				value: {
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 					centAmount: 3000,
 				},
 			},
-		])
-	})
+		]);
+	});
 
-	test('removePrice variant', async () => {
-		assert(productPublished, 'product not created')
+	test("removePrice variant", async () => {
+		assert(productPublished, "product not created");
 		const priceId =
-			productPublished?.masterData.current.masterVariant.prices?.[0].id
-		assert(priceId)
+			productPublished?.masterData.current.masterVariant.prices?.[0].id;
+		assert(priceId);
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
@@ -896,161 +896,163 @@ describe('Product update actions', () => {
 				version: 1,
 				actions: [
 					{
-						action: 'removePrice',
+						action: "removePrice",
 						priceId,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.masterData.staged.masterVariant.prices).toHaveLength(0)
-	})
-
-	test('changeName product', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.masterData.staged.masterVariant.prices).toHaveLength(
+			0,
+		);
+	});
+
+	test("changeName product", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'changeName',
-						name: 'new test published product',
+						action: "changeName",
+						name: "new test published product",
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(response.body.masterData.staged.name).toBe(
-			'new test published product'
-		)
+			"new test published product",
+		);
 		expect(response.body.masterData.current.name).toBe(
-			'new test published product'
-		)
-	})
+			"new test published product",
+		);
+	});
 
-	test('changeSlug product', async () => {
-		assert(productPublished, 'product not created')
+	test("changeSlug product", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'changeSlug',
+						action: "changeSlug",
 						slug: {
-							'nl-NL': 'test-published-product-new',
+							"nl-NL": "test-published-product-new",
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(response.body.masterData.staged.slug).toMatchObject({
-			'nl-NL': 'test-published-product-new',
-		})
+			"nl-NL": "test-published-product-new",
+		});
 		expect(response.body.masterData.current.slug).toMatchObject({
-			'nl-NL': 'test-published-product-new',
-		})
-	})
+			"nl-NL": "test-published-product-new",
+		});
+	});
 
-	test('setMetaTitle product', async () => {
-		assert(productPublished, 'product not created')
+	test("setMetaTitle product", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setMetaTitle',
+						action: "setMetaTitle",
 						metaTitle: {
-							'nl-NL': 'Unpublished product (new meta title)',
+							"nl-NL": "Unpublished product (new meta title)",
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(response.body.masterData.staged.metaTitle).toMatchObject({
-			'nl-NL': 'Unpublished product (new meta title)',
-		})
+			"nl-NL": "Unpublished product (new meta title)",
+		});
 		expect(response.body.masterData.current.metaTitle).toMatchObject({
-			'nl-NL': 'Unpublished product (new meta title)',
-		})
-	})
+			"nl-NL": "Unpublished product (new meta title)",
+		});
+	});
 
-	test('setMetaDescription product', async () => {
-		assert(productPublished, 'product not created')
+	test("setMetaDescription product", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setMetaDescription',
+						action: "setMetaDescription",
 						metaDescription: {
-							'nl-NL': 'Unpublished product description (new meta description)',
+							"nl-NL": "Unpublished product description (new meta description)",
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(response.body.masterData.staged.metaDescription).toMatchObject({
-			'nl-NL': 'Unpublished product description (new meta description)',
-		})
+			"nl-NL": "Unpublished product description (new meta description)",
+		});
 		expect(response.body.masterData.current.metaDescription).toMatchObject({
-			'nl-NL': 'Unpublished product description (new meta description)',
-		})
-	})
+			"nl-NL": "Unpublished product description (new meta description)",
+		});
+	});
 
-	test('setMetaKeywords product', async () => {
-		assert(productPublished, 'product not created')
+	test("setMetaKeywords product", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setMetaKeywords',
+						action: "setMetaKeywords",
 						metaKeywords: {
-							'nl-NL': 'Test product (newmeta Keywords)',
+							"nl-NL": "Test product (newmeta Keywords)",
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
 		expect(response.body.masterData.staged.metaKeywords).toMatchObject({
-			'nl-NL': 'Test product (newmeta Keywords)',
-		})
+			"nl-NL": "Test product (newmeta Keywords)",
+		});
 		expect(response.body.masterData.current.metaKeywords).toMatchObject({
-			'nl-NL': 'Test product (newmeta Keywords)',
-		})
-	})
+			"nl-NL": "Test product (newmeta Keywords)",
+		});
+	});
 
-	test('addVariant product', async () => {
-		assert(productPublished, 'product not created')
+	test("addVariant product", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'addVariant',
-						sku: '4567',
-						key: 'variant-2-key',
+						action: "addVariant",
+						sku: "4567",
+						key: "variant-2-key",
 						price: [
 							{
-								key: 'base_price_eur',
-								country: 'NL',
+								key: "base_price_eur",
+								country: "NL",
 								value: {
-									currencyCode: 'EUR',
+									currencyCode: "EUR",
 									centAmount: 3000,
 								},
 							},
@@ -1058,362 +1060,362 @@ describe('Product update actions', () => {
 						images: [],
 						attributes: [
 							{
-								name: 'test3',
-								value: 'test3',
+								name: "test3",
+								value: "test3",
 							},
 						],
 						assets: [],
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.masterData.staged.variants).toHaveLength(2)
-		expect(response.body.masterData.current.variants).toHaveLength(2)
-		expect(response.body.masterData.staged.variants[1].id).toBe(3)
-		expect(response.body.masterData.current.variants[1].id).toBe(3)
-	})
-
-	test('removeVariant by id', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.masterData.staged.variants).toHaveLength(2);
+		expect(response.body.masterData.current.variants).toHaveLength(2);
+		expect(response.body.masterData.staged.variants[1].id).toBe(3);
+		expect(response.body.masterData.current.variants[1].id).toBe(3);
+	});
+
+	test("removeVariant by id", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'removeVariant',
+						action: "removeVariant",
 						id: 2,
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.masterData.staged.variants).toHaveLength(0)
-		expect(response.body.masterData.current.variants).toHaveLength(0)
-	})
-
-	test('removeVariant by sku', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.masterData.staged.variants).toHaveLength(0);
+		expect(response.body.masterData.current.variants).toHaveLength(0);
+	});
+
+	test("removeVariant by sku", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'removeVariant',
-						sku: '1338',
+						action: "removeVariant",
+						sku: "1338",
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.masterData.staged.variants).toHaveLength(0)
-		expect(response.body.masterData.current.variants).toHaveLength(0)
-	})
-
-	test('removeVariant master', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.masterData.staged.variants).toHaveLength(0);
+		expect(response.body.masterData.current.variants).toHaveLength(0);
+	});
+
+	test("removeVariant master", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'removeVariant',
+						action: "removeVariant",
 						id: 1,
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(500)
+			});
+		expect(response.status).toBe(500);
 		expect(response.body.error).toBe(
-			`Can not remove the variant [ID:1] for [Product:${productPublished.id}] since it's the master variant`
-		)
-	})
+			`Can not remove the variant [ID:1] for [Product:${productPublished.id}] since it's the master variant`,
+		);
+	});
 
-	test('changeMasterVariant', async () => {
-		assert(productPublished, 'product not created')
+	test("changeMasterVariant", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'changeMasterVariant',
-						sku: '1338',
+						action: "changeMasterVariant",
+						sku: "1338",
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.masterData.staged.variants).toHaveLength(1)
-		expect(response.body.masterData.staged.masterVariant.id).toBe(2)
-		expect(response.body.masterData.staged.variants[0].id).toBe(1)
-
-		expect(response.body.masterData.current.variants).toHaveLength(1)
-		expect(response.body.masterData.current.masterVariant.id).toBe(2)
-		expect(response.body.masterData.current.variants[0].id).toBe(1)
-	})
-
-	test('changeMasterVariant same master', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.masterData.staged.variants).toHaveLength(1);
+		expect(response.body.masterData.staged.masterVariant.id).toBe(2);
+		expect(response.body.masterData.staged.variants[0].id).toBe(1);
+
+		expect(response.body.masterData.current.variants).toHaveLength(1);
+		expect(response.body.masterData.current.masterVariant.id).toBe(2);
+		expect(response.body.masterData.current.variants[0].id).toBe(1);
+	});
+
+	test("changeMasterVariant same master", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'changeMasterVariant',
+						action: "changeMasterVariant",
 						variantId: 1,
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(1)
-		expect(response.body.masterData.staged.variants).toHaveLength(1)
-		expect(response.body.masterData.staged.masterVariant.id).toBe(1)
-		expect(response.body.masterData.staged.variants[0].id).toBe(2)
-
-		expect(response.body.masterData.current.variants).toHaveLength(1)
-		expect(response.body.masterData.current.masterVariant.id).toBe(1)
-		expect(response.body.masterData.current.variants[0].id).toBe(2)
-	})
-
-	test('setTaxCategory', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(1);
+		expect(response.body.masterData.staged.variants).toHaveLength(1);
+		expect(response.body.masterData.staged.masterVariant.id).toBe(1);
+		expect(response.body.masterData.staged.variants[0].id).toBe(2);
+
+		expect(response.body.masterData.current.variants).toHaveLength(1);
+		expect(response.body.masterData.current.masterVariant.id).toBe(1);
+		expect(response.body.masterData.current.variants[0].id).toBe(2);
+	});
+
+	test("setTaxCategory", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setTaxCategory',
+						action: "setTaxCategory",
 						taxCategory: {
-							typeId: 'tax-category',
+							typeId: "tax-category",
 							id: taxCategory2.id,
 						},
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.taxCategory.id).toBe(taxCategory2.id)
-	})
-
-	test('setTaxCategory fail 1', async () => {
-		assert(productPublished, 'product not created')
-		const fakeTaxCategoryId = '00000000-0000-0000-0000-000000000000'
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.taxCategory.id).toBe(taxCategory2.id);
+	});
+
+	test("setTaxCategory fail 1", async () => {
+		assert(productPublished, "product not created");
+		const fakeTaxCategoryId = "00000000-0000-0000-0000-000000000000";
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setTaxCategory',
+						action: "setTaxCategory",
 						taxCategory: {
-							typeId: 'tax-category',
+							typeId: "tax-category",
 							id: fakeTaxCategoryId,
 						},
 					},
 				],
-			})
-		expect(response.status).toBe(400)
-		expect(response.body.errors[0].code).toBe('ReferencedResourceNotFound')
-	})
+			});
+		expect(response.status).toBe(400);
+		expect(response.body.errors[0].code).toBe("ReferencedResourceNotFound");
+	});
 
-	test('setTaxCategory fail 2', async () => {
-		assert(productPublished, 'product not created')
+	test("setTaxCategory fail 2", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setTaxCategory',
+						action: "setTaxCategory",
 						taxCategory: {
-							typeId: 'tax-category',
+							typeId: "tax-category",
 						},
 					},
 				],
-			})
-		expect(response.status).toBe(400)
-		expect(response.body.errors[0].code).toBe('InvalidJsonInput')
-	})
+			});
+		expect(response.status).toBe(400);
+		expect(response.body.errors[0].code).toBe("InvalidJsonInput");
+	});
 
-	test('addToCategory by id', async () => {
-		assert(productPublished, 'product not created')
+	test("addToCategory by id", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'addToCategory',
+						action: "addToCategory",
 						category: {
-							typeId: 'category',
+							typeId: "category",
 							id: category2.id,
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.masterData.staged.categories).toHaveLength(2)
-		expect(response.body.masterData.current.categories).toHaveLength(2)
-	})
-
-	test('addToCategory by key', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.masterData.staged.categories).toHaveLength(2);
+		expect(response.body.masterData.current.categories).toHaveLength(2);
+	});
+
+	test("addToCategory by key", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'addToCategory',
+						action: "addToCategory",
 						category: {
-							typeId: 'category',
+							typeId: "category",
 							key: category2.key,
 						},
 						staged: true,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.masterData.staged.categories).toHaveLength(2)
-		expect(response.body.masterData.current.categories).toHaveLength(1)
-	})
-
-	test('addToCategory fail 1', async () => {
-		assert(productPublished, 'product not created')
-		const fakeCategoryId = '00000000-0000-0000-0000-000000000000'
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.masterData.staged.categories).toHaveLength(2);
+		expect(response.body.masterData.current.categories).toHaveLength(1);
+	});
+
+	test("addToCategory fail 1", async () => {
+		assert(productPublished, "product not created");
+		const fakeCategoryId = "00000000-0000-0000-0000-000000000000";
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'addToCategory',
+						action: "addToCategory",
 						category: {
-							typeId: 'category',
+							typeId: "category",
 							id: fakeCategoryId,
 						},
 						staged: true,
 					},
 				],
-			})
-		expect(response.status).toBe(400)
-		expect(response.body.errors[0].code).toBe('ReferencedResourceNotFound')
-	})
+			});
+		expect(response.status).toBe(400);
+		expect(response.body.errors[0].code).toBe("ReferencedResourceNotFound");
+	});
 
-	test('addToCategory fail 2', async () => {
-		assert(productPublished, 'product not created')
+	test("addToCategory fail 2", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'addToCategory',
+						action: "addToCategory",
 						category: null,
 						staged: true,
 					},
 				],
-			})
-		expect(response.status).toBe(400)
-		expect(response.body.errors[0].code).toBe('InvalidJsonInput')
-	})
+			});
+		expect(response.status).toBe(400);
+		expect(response.body.errors[0].code).toBe("InvalidJsonInput");
+	});
 
-	test('removeFromCategory', async () => {
-		assert(productPublished, 'product not created')
+	test("removeFromCategory", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'removeFromCategory',
+						action: "removeFromCategory",
 						category: {
-							typeId: 'category',
+							typeId: "category",
 							key: category1.key,
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.masterData.staged.categories).toHaveLength(0)
-		expect(response.body.masterData.current.categories).toHaveLength(0)
-	})
-
-	test('removeFromCategory fail 1', async () => {
-		assert(productPublished, 'product not created')
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.masterData.staged.categories).toHaveLength(0);
+		expect(response.body.masterData.current.categories).toHaveLength(0);
+	});
+
+	test("removeFromCategory fail 1", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'removeFromCategory',
+						action: "removeFromCategory",
 						category: {
-							typeId: 'category',
-							id: 'fake-category-id',
+							typeId: "category",
+							id: "fake-category-id",
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(400)
-		expect(response.body.errors[0].code).toBe('ReferencedResourceNotFound')
-	})
+			});
+		expect(response.status).toBe(400);
+		expect(response.body.errors[0].code).toBe("ReferencedResourceNotFound");
+	});
 
-	test('removeFromCategory fail 2', async () => {
-		assert(productPublished, 'product not created')
+	test("removeFromCategory fail 2", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'removeFromCategory',
+						action: "removeFromCategory",
 						category: {
-							typeId: 'category',
+							typeId: "category",
 							id: category2.id,
 						},
 						staged: false,
 					},
 				],
-			})
-		expect(response.status).toBe(400)
-		expect(response.body.errors[0].code).toBe('InvalidOperation')
-	})
+			});
+		expect(response.status).toBe(400);
+		expect(response.body.errors[0].code).toBe("InvalidOperation");
+	});
 
-	test('transitionState', async () => {
-		assert(productPublished, 'product not created')
+	test("transitionState", async () => {
+		assert(productPublished, "product not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/products/${productPublished.id}`)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'transitionState',
+						action: "transitionState",
 						state: {
-							typeId: 'state',
+							typeId: "state",
 							id: productState2.id,
 						},
 						force: false,
 					},
 				],
-			})
-		expect(response.status).toBe(200)
+			});
+		expect(response.status).toBe(200);
 		expect(response.body.state).toMatchObject({
-			typeId: 'state',
+			typeId: "state",
 			id: productState2.id,
-		})
-	})
-})
+		});
+	});
+});