@labdigital/commercetools-mock 2.65.1 → 3.0.0-beta.0

package/src/services/product.test.ts

@@ -1,26 +1,18 @@
 import assert from "node:assert";
 import type {
 	Category,
-	CategoryDraft,
 	Image,
-	InventoryEntryDraft,
 	PriceDraft,
 	Product,
 	ProductData,
-	ProductDraft,
 	ProductPagedSearchResponse,
 	ProductSearchRequest,
 	ProductSearchResult,
 	ProductType,
-	ProductTypeDraft,
 	State,
-	StateDraft,
 	TaxCategory,
-	TaxCategoryDraft,
 	Type,
-	TypeDraft,
 } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import {
 	afterAll,
 	beforeAll,
@@ -29,93 +21,120 @@ import {
 	expect,
 	test,
 } from "vitest";
+import {
+	categoryDraftFactory,
+	channelDraftFactory,
+	inventoryEntryDraftFactory,
+	productDraftFactory,
+	productTypeDraftFactory,
+	stateDraftFactory,
+	taxCategoryDraftFactory,
+	typeDraftFactory,
+} from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
-const productTypeDraft: ProductTypeDraft = {
-	key: "test-product-type",
-	name: "Test Product Type",
-	description: "Test Product Type description",
-};
+let productType: ProductType;
+let category1: Category;
+let category2: Category;
+let taxCategory1: TaxCategory;
+let taxCategory2: TaxCategory;
+let productState1: State;
+let productState2: State;
+let productPriceType: Type;
 
-const categoryDraft1: CategoryDraft = {
-	key: "category-1",
-	name: {
-		"nl-NL": "Category One",
-	},
-	slug: {
-		"nl-NL": "category_1",
-	},
-};
+async function beforeAllProductTests(mock: CommercetoolsMock) {
+	const productTypeFactory = productTypeDraftFactory(mock);
+	const categoryFactory = categoryDraftFactory(mock);
+	const taxCategoryFactory = taxCategoryDraftFactory(mock);
+	const stateFactory = stateDraftFactory(mock);
+	const typeFactory = typeDraftFactory(mock);
 
-const categoryDraft2: CategoryDraft = {
-	key: "category-2",
-	name: {
-		"nl-NL": "Category Two",
-	},
-	slug: {
-		"nl-NL": "category_2",
-	},
-};
+	productType = await productTypeFactory.create({
+		key: "test-product-type",
+		name: "Test Product Type",
+		description: "Test Product Type description",
+	});
 
-const taxcategoryDraft1: TaxCategoryDraft = {
-	name: "Tax category 1",
-	key: "tax-category-1",
-};
+	category1 = await categoryFactory.create({
+		key: "category-1",
+		name: {
+			"nl-NL": "Category One",
+		},
+		slug: {
+			"nl-NL": "category_1",
+		},
+	});
 
-const taxcategoryDraft2: TaxCategoryDraft = {
-	name: "Tax category 2",
-	key: "tax-category-2",
-};
+	category2 = await categoryFactory.create({
+		key: "category-2",
+		name: {
+			"nl-NL": "Category Two",
+		},
+		slug: {
+			"nl-NL": "category_2",
+		},
+	});
 
-const productState1Draft: StateDraft = {
-	key: "initial-state",
-	type: "ProductState",
-	initial: true,
-	name: {
-		"nl-NL": "Initial state",
-	},
-	description: {
-		"nl-NL": "Product initial state",
-	},
-};
+	taxCategory1 = await taxCategoryFactory.create({
+		name: "Tax category 1",
+		key: "tax-category-1",
+	});
 
-const productState2Draft: StateDraft = {
-	key: "another-state",
-	type: "ProductState",
-	initial: true,
-	name: {
-		"nl-NL": "Another state",
-	},
-	description: {
-		"nl-NL": "Product another state",
-	},
-};
+	taxCategory2 = await taxCategoryFactory.create({
+		name: "Tax category 2",
+		key: "tax-category-2",
+	});
 
-const productPriceTypeDraft: TypeDraft = {
-	key: "product-price",
-	name: {
-		en: "ProductPriceType",
-	},
-	description: {
-		en: "Product Price Type",
-	},
-	resourceTypeIds: ["product-price"],
-	fieldDefinitions: [
-		{
-			name: "lastModifiedAt",
-			label: {
-				en: "Last modified at",
-			},
-			required: false,
-			type: {
-				name: "DateTime",
-			},
-			inputHint: "SingleLine",
+	productState1 = await stateFactory.create({
+		key: "initial-state",
+		type: "ProductState",
+		initial: true,
+		name: {
+			"nl-NL": "Initial state",
 		},
-	],
-};
+		description: {
+			"nl-NL": "Product initial state",
+		},
+	});
 
-const publishedProductDraft: ProductDraft = {
+	productState2 = await stateFactory.create({
+		key: "another-state",
+		type: "ProductState",
+		initial: true,
+		name: {
+			"nl-NL": "Another state",
+		},
+		description: {
+			"nl-NL": "Product another state",
+		},
+	});
+
+	productPriceType = await typeFactory.create({
+		key: "product-price",
+		name: {
+			en: "ProductPriceType",
+		},
+		description: {
+			en: "Product Price Type",
+		},
+		resourceTypeIds: ["product-price"],
+		fieldDefinitions: [
+			{
+				name: "lastModifiedAt",
+				label: {
+					en: "Last modified at",
+				},
+				required: false,
+				type: {
+					name: "DateTime",
+				},
+				inputHint: "SingleLine",
+			},
+		],
+	});
+}
+
+const publishedProductDraftOverrides = {
 	name: {
 		"nl-NL": "test published product",
 	},
@@ -123,21 +142,21 @@ const publishedProductDraft: ProductDraft = {
 		"nl-NL": "Test published product description",
 	},
 	productType: {
-		typeId: "product-type",
+		typeId: "product-type" as const,
 		key: "test-product-type",
 	},
 	categories: [
 		{
-			typeId: "category",
+			typeId: "category" as const,
 			key: "category-1",
 		},
 	],
 	taxCategory: {
-		typeId: "tax-category",
-		key: taxcategoryDraft1.key,
+		typeId: "tax-category" as const,
+		key: "tax-category-1",
 	},
 	state: {
-		typeId: "state",
+		typeId: "state" as const,
 		key: "initial-state",
 	},
 	masterVariant: {
@@ -197,7 +216,7 @@ const publishedProductDraft: ProductDraft = {
 	publish: true,
 };
 
-const unpublishedProductDraft: ProductDraft = {
+const unpublishedProductDraftOverrides = {
 	key: "test-unpublished-product",
 	name: {
 		"nl-NL": "test unpublished product",
@@ -206,21 +225,21 @@ const unpublishedProductDraft: ProductDraft = {
 		"nl-NL": "Test published product description",
 	},
 	productType: {
-		typeId: "product-type",
+		typeId: "product-type" as const,
 		key: "test-product-type",
 	},
 	categories: [
 		{
-			typeId: "category",
+			typeId: "category" as const,
 			key: "category-1",
 		},
 	],
 	taxCategory: {
-		typeId: "tax-category",
-		key: taxcategoryDraft1.key,
+		typeId: "tax-category" as const,
+		key: "tax-category-1",
 	},
 	state: {
-		typeId: "state",
+		typeId: "state" as const,
 		key: "initial-state",
 	},
 	masterVariant: {
@@ -280,82 +299,10 @@ const unpublishedProductDraft: ProductDraft = {
 	publish: false,
 };
 
-let productType: ProductType;
-let category1: Category;
-let category2: Category;
-let taxCategory1: TaxCategory;
-let taxCategory2: TaxCategory;
-let productState1: State;
-let productState2: State;
-let productPriceType: Type;
-
-async function beforeAllProductTests(mock: CommercetoolsMock) {
-	let response;
-	// Create Product Type
-	response = await supertest(mock.app)
-		.post("/dummy/product-types")
-		.send(productTypeDraft);
-
-	expect(response.status).toBe(201);
-	productType = response.body;
-
-	// Create Category 1
-	response = await supertest(mock.app)
-		.post("/dummy/categories")
-		.send(categoryDraft1);
-
-	expect(response.status).toBe(201);
-	category1 = response.body;
-
-	// Create Category 2
-	response = await supertest(mock.app)
-		.post("/dummy/categories")
-		.send(categoryDraft2);
-
-	expect(response.status).toBe(201);
-	category2 = response.body;
-
-	// Create Tax Category 1
-	response = await supertest(mock.app)
-		.post("/dummy/tax-categories")
-		.send(taxcategoryDraft1);
-
-	expect(response.status).toBe(201);
-	taxCategory1 = response.body;
-
-	// Create Tax Category 2
-	response = await supertest(mock.app)
-		.post("/dummy/tax-categories")
-		.send(taxcategoryDraft2);
-
-	expect(response.status).toBe(201);
-	taxCategory2 = response.body;
-
-	// Create Product State 1
-	response = await supertest(mock.app)
-		.post("/dummy/states")
-		.send(productState1Draft);
-
-	expect(response.status).toBe(201);
-	productState1 = response.body;
-
-	// Create Product State 2
-	response = await supertest(mock.app)
-		.post("/dummy/states")
-		.send(productState2Draft);
-
-	expect(response.status).toBe(201);
-	productState2 = response.body;
-
-	response = await supertest(mock.app)
-		.post("/dummy/types")
-		.send(productPriceTypeDraft);
-	expect(response.status).toBe(201);
-	productPriceType = response.body;
-}
-
 describe("Product", () => {
 	const ctMock = new CommercetoolsMock();
+	const productFactory = productDraftFactory(ctMock);
+
 	beforeAll(async () => {
 		await beforeAllProductTests(ctMock);
 	});
@@ -363,18 +310,20 @@ describe("Product", () => {
 	test("Create product", async () => {
 		assert(productType, "product type not created");
 
-		const response = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(unpublishedProductDraft);
+		const product = await productFactory.create(
+			unpublishedProductDraftOverrides,
+		);
 
 		const productData: ProductData = {
 			name: {
+				en: expect.any(String),
 				"nl-NL": "test unpublished product",
 			},
 			description: {
 				"nl-NL": "Test published product description",
 			},
 			slug: {
+				en: expect.any(String),
 				"nl-NL": "test-unpublished-product",
 			},
 			categories: [
@@ -450,10 +399,12 @@ describe("Product", () => {
 			searchKeywords: {},
 		};
 
-		expect(response.body).toEqual({
+		expect(product).toEqual({
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			id: expect.anything(),
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			key: "test-unpublished-product",
 			taxCategory: {
 				typeId: "tax-category",
@@ -480,46 +431,42 @@ describe("Product", () => {
 
 describe("Product update actions", () => {
 	const ctMock = new CommercetoolsMock();
+	const productFactory = productDraftFactory(ctMock);
 	let productPublished: Product | undefined;
+
 	beforeAll(async () => {
 		await beforeAllProductTests(ctMock);
 	});
 
 	beforeEach(async () => {
-		let response;
-		response = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(publishedProductDraft);
-
-		expect(response.status).toBe(201);
-		productPublished = response.body;
-
-		response = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(unpublishedProductDraft);
+		productPublished = await productFactory.create(
+			publishedProductDraftOverrides,
+		);
 
-		expect(response.status).toBe(201);
+		await productFactory.create(unpublishedProductDraftOverrides);
 	});
 
 	afterAll(async () => {
-		ctMock.clear();
+		await ctMock.clear();
 	});
 
 	test("setAttribute masterVariant (staged)", async () => {
 		assert(productPublished, "product not created");
 
 		{
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/products/${productPublished.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/products/${productPublished.id}`,
+				payload: {
 					version: 1,
 					actions: [
 						{ action: "setAttribute", sku: "1337", name: "foo", value: "bar" },
 					],
-				});
+				},
+			});
 
-			expect(response.status).toBe(200);
-			const product: Product = response.body;
+			expect(response.statusCode).toBe(200);
+			const product: Product = response.json();
 			expect(product.version).toBe(2);
 			expect(product.masterData.hasStagedChanges).toBeTruthy();
 			expect(product.masterData.current.masterVariant.attributes).toHaveLength(
@@ -529,21 +476,23 @@ describe("Product update actions", () => {
 				2,
 			);
 
-			const attr = response.body.masterData.staged.masterVariant.attributes[1];
+			const attr = product.masterData.staged.masterVariant.attributes?.[1];
 			expect(attr).toEqual({ name: "foo", value: "bar" });
 		}
 
 		// Publish
 		{
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/products/${productPublished.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/products/${productPublished.id}`,
+				payload: {
 					version: 2,
 					actions: [{ action: "publish", scope: "All" }],
-				});
+				},
+			});
 
-			expect(response.status).toBe(200);
-			const product: Product = response.body;
+			expect(response.statusCode).toBe(200);
+			const product: Product = response.json();
 			expect(product.version).toBe(3);
 			expect(product.masterData.hasStagedChanges).toBeFalsy();
 			expect(product.masterData.current.masterVariant.attributes).toHaveLength(
@@ -555,9 +504,10 @@ describe("Product update actions", () => {
 	test("setAttribute masterVariant (published)", async () => {
 		assert(productPublished, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -568,10 +518,11 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		const product: Product = response.body;
+		expect(response.statusCode).toBe(200);
+		const product: Product = response.json();
 
 		// TODO: Since we auto publish it actually does two version updates. So the
 		// version should be 3
@@ -580,76 +531,80 @@ describe("Product update actions", () => {
 		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];
+		const attr = product.masterData.staged.masterVariant.attributes?.[1];
 		expect(attr).toEqual({ name: "foo", value: "bar" });
 	});
 
 	test("setAttribute variant", async () => {
 		assert(productPublished, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{ action: "setAttribute", sku: "1338", name: "foo", value: "bar" },
 				],
-			});
-		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(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.variants[0].attributes).toHaveLength(2);
+		const attr = 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");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{ action: "setAttribute", sku: "1338", name: "foo", value: "bar" },
 					{ action: "publish" },
 				],
-			});
-		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(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(3);
+		expect(body.masterData.current.variants[0].attributes).toHaveLength(2);
+		const attr = body.masterData.current.variants[0].attributes[1];
 		expect(attr).toEqual({ name: "foo", value: "bar" });
 	});
 
 	test("setAttribute overwrite", async () => {
 		assert(productPublished, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{ action: "setAttribute", sku: "1337", name: "test", value: "foo" },
 				],
-			});
-		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(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.masterVariant.attributes).toHaveLength(1);
+		const attr = 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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -658,9 +613,10 @@ describe("Product update actions", () => {
 						value: "foo",
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		const product = response.body as Product;
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const product = response.json() as Product;
 		expect(product.version).toBe(2);
 		expect(product.masterData.staged.masterVariant.attributes).toHaveLength(1);
 
@@ -679,9 +635,10 @@ describe("Product update actions", () => {
 
 	test("setAttributeInAllVariants product staged", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -690,9 +647,10 @@ describe("Product update actions", () => {
 						value: "bar",
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		const product = response.body as Product;
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const product = response.json() as Product;
 		expect(product.version).toBe(2);
 		expect(product.masterData.staged.masterVariant.attributes).toHaveLength(2);
 		const masterVariantAttr1 =
@@ -717,18 +675,20 @@ describe("Product update actions", () => {
 	test("setAttributeInAllVariants and publish", async () => {
 		assert(productPublished, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{ action: "setAttributeInAllVariants", name: "foo", value: "bar" },
 					{ action: "publish" },
 				],
-			});
+			},
+		});
 
-		const product = response.body as Product;
-		expect(response.status).toBe(200);
+		const product = response.json() as Product;
+		expect(response.statusCode).toBe(200);
 		expect(product.version).toBe(3);
 		expect(product.masterData.current.masterVariant.attributes).toHaveLength(2);
 		const attr = product.masterData.current.masterVariant.attributes?.[1];
@@ -750,16 +710,19 @@ describe("Product update actions", () => {
 			url: "http://example.com/image",
 			dimensions: { w: 100, h: 100 },
 		};
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				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(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.variants[0].images).toHaveLength(1);
+		const attr = body.masterData.staged.variants[0].images[0];
 		expect(attr).toEqual(image);
 	});
 
@@ -772,19 +735,22 @@ describe("Product update actions", () => {
 		};
 
 		{
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/products/${productPublished.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/products/${productPublished.id}`,
+				payload: {
 					version: 1,
 					actions: [{ action: "addExternalImage", sku: "1338", image }],
-				});
-			expect(response.status).toBe(200);
-			expect(response.body.version).toBe(2);
+				},
+			});
+			expect(response.statusCode).toBe(200);
+			expect(response.json().version).toBe(2);
 		}
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 2,
 				actions: [
 					{
@@ -793,10 +759,12 @@ describe("Product update actions", () => {
 						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.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(3);
+		expect(body.masterData.staged.variants[0].images).toHaveLength(0);
 	});
 
 	test("moveImageToPosition variant", async () => {
@@ -812,22 +780,25 @@ describe("Product update actions", () => {
 		};
 
 		{
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/products/${productPublished.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/products/${productPublished.id}`,
+				payload: {
 					version: 1,
 					actions: [
 						{ 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.statusCode).toBe(200);
+			expect(response.json().version).toBe(3);
 		}
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 3,
 				actions: [
 					{
@@ -837,10 +808,12 @@ describe("Product update actions", () => {
 						position: 0,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(4);
-		expect(response.body.masterData.staged.variants[0].images).toEqual([
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(4);
+		expect(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 } },
 		]);
@@ -857,9 +830,10 @@ describe("Product update actions", () => {
 			},
 		};
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -869,10 +843,12 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.masterVariant.prices).toMatchObject([
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.masterVariant.prices).toMatchObject([
 			{
 				country: "NL",
 				value: {
@@ -888,8 +864,8 @@ describe("Product update actions", () => {
 				},
 			},
 		]);
-		expect(response.body.masterData.staged.masterVariant.prices[1].id).toBe(
-			response.body.masterData.current.masterVariant.prices[1].id,
+		expect(body.masterData.staged.masterVariant.prices[1].id).toBe(
+			body.masterData.current.masterVariant.prices[1].id,
 		);
 	});
 
@@ -907,9 +883,10 @@ describe("Product update actions", () => {
 			},
 		};
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -918,10 +895,12 @@ describe("Product update actions", () => {
 						price: priceDraft,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.masterVariant.prices).toMatchObject([
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.masterVariant.prices).toMatchObject([
 			{
 				id: priceId,
 				country: "BE",
@@ -939,9 +918,10 @@ describe("Product update actions", () => {
 			productPublished?.masterData.current.masterVariant.prices?.[0].id;
 		assert(priceId);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -949,19 +929,20 @@ describe("Product update actions", () => {
 						priceId,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.masterVariant.prices).toHaveLength(
-			0,
-		);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -970,22 +951,21 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.name).toBe(
-			"new test published product",
-		);
-		expect(response.body.masterData.current.name).toBe(
-			"new test published product",
-		);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.name).toBe("new test published product");
+		expect(body.masterData.current.name).toBe("new test published product");
 	});
 
 	test("changeSlug product", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -996,22 +976,25 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.slug).toMatchObject({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.slug).toMatchObject({
 			"nl-NL": "test-published-product-new",
 		});
-		expect(response.body.masterData.current.slug).toMatchObject({
+		expect(body.masterData.current.slug).toMatchObject({
 			"nl-NL": "test-published-product-new",
 		});
 	});
 
 	test("setMetaTitle product", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1022,22 +1005,25 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.metaTitle).toMatchObject({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.metaTitle).toMatchObject({
 			"nl-NL": "Unpublished product (new meta title)",
 		});
-		expect(response.body.masterData.current.metaTitle).toMatchObject({
+		expect(body.masterData.current.metaTitle).toMatchObject({
 			"nl-NL": "Unpublished product (new meta title)",
 		});
 	});
 
 	test("setMetaDescription product", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1048,22 +1034,25 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.metaDescription).toMatchObject({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.metaDescription).toMatchObject({
 			"nl-NL": "Unpublished product description (new meta description)",
 		});
-		expect(response.body.masterData.current.metaDescription).toMatchObject({
+		expect(body.masterData.current.metaDescription).toMatchObject({
 			"nl-NL": "Unpublished product description (new meta description)",
 		});
 	});
 
 	test("setMetaKeywords product", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1074,22 +1063,25 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.masterData.staged.metaKeywords).toMatchObject({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.metaKeywords).toMatchObject({
 			"nl-NL": "Test product (newmeta Keywords)",
 		});
-		expect(response.body.masterData.current.metaKeywords).toMatchObject({
+		expect(body.masterData.current.metaKeywords).toMatchObject({
 			"nl-NL": "Test product (newmeta Keywords)",
 		});
 	});
 
 	test("addVariant product", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1117,20 +1109,23 @@ describe("Product update actions", () => {
 						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);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.variants).toHaveLength(2);
+		expect(body.masterData.current.variants).toHaveLength(2);
+		expect(body.masterData.staged.variants[1].id).toBe(3);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1139,18 +1134,21 @@ describe("Product update actions", () => {
 						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);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.variants).toHaveLength(0);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1159,18 +1157,21 @@ describe("Product update actions", () => {
 						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);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.variants).toHaveLength(0);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1179,18 +1180,21 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(500);
-		expect(response.body.error).toBe(
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().errors[0].code).toBe("InvalidOperation");
+		expect(response.json().message).toBe(
 			`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");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1199,23 +1203,26 @@ describe("Product update actions", () => {
 						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);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(2);
+		expect(body.masterData.staged.variants).toHaveLength(1);
+		expect(body.masterData.staged.masterVariant.id).toBe(2);
+		expect(body.masterData.staged.variants[0].id).toBe(1);
+
+		expect(body.masterData.current.variants).toHaveLength(1);
+		expect(body.masterData.current.masterVariant.id).toBe(2);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1224,23 +1231,26 @@ describe("Product update actions", () => {
 						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);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.version).toBe(1);
+		expect(body.masterData.staged.variants).toHaveLength(1);
+		expect(body.masterData.staged.masterVariant.id).toBe(1);
+		expect(body.masterData.staged.variants[0].id).toBe(2);
+
+		expect(body.masterData.current.variants).toHaveLength(1);
+		expect(body.masterData.current.masterVariant.id).toBe(1);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1251,17 +1261,19 @@ describe("Product update actions", () => {
 						},
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.taxCategory.id).toBe(taxCategory2.id);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1272,16 +1284,18 @@ describe("Product update actions", () => {
 						},
 					},
 				],
-			});
-		expect(response.status).toBe(400);
-		expect(response.body.errors[0].code).toBe("ReferencedResourceNotFound");
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().errors[0].code).toBe("ReferencedResourceNotFound");
 	});
 
 	test("setTaxCategory fail 2", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1291,16 +1305,18 @@ describe("Product update actions", () => {
 						},
 					},
 				],
-			});
-		expect(response.status).toBe(400);
-		expect(response.body.errors[0].code).toBe("InvalidJsonInput");
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().errors[0].code).toBe("InvalidJsonInput");
 	});
 
 	test("addToCategory by id", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1312,17 +1328,20 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.masterData.staged.categories).toHaveLength(2);
-		expect(response.body.masterData.current.categories).toHaveLength(2);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.masterData.staged.categories).toHaveLength(2);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1334,18 +1353,21 @@ describe("Product update actions", () => {
 						staged: true,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.masterData.staged.categories).toHaveLength(2);
-		expect(response.body.masterData.current.categories).toHaveLength(1);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.masterData.staged.categories).toHaveLength(2);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1357,16 +1379,18 @@ describe("Product update actions", () => {
 						staged: true,
 					},
 				],
-			});
-		expect(response.status).toBe(400);
-		expect(response.body.errors[0].code).toBe("ReferencedResourceNotFound");
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().errors[0].code).toBe("ReferencedResourceNotFound");
 	});
 
 	test("addToCategory fail 2", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1375,16 +1399,18 @@ describe("Product update actions", () => {
 						staged: true,
 					},
 				],
-			});
-		expect(response.status).toBe(400);
-		expect(response.body.errors[0].code).toBe("InvalidJsonInput");
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().errors[0].code).toBe("InvalidJsonInput");
 	});
 
 	test("removeFromCategory", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1396,17 +1422,20 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.masterData.staged.categories).toHaveLength(0);
-		expect(response.body.masterData.current.categories).toHaveLength(0);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		const body = response.json();
+		expect(body.masterData.staged.categories).toHaveLength(0);
+		expect(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({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1418,16 +1447,18 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(400);
-		expect(response.body.errors[0].code).toBe("ReferencedResourceNotFound");
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().errors[0].code).toBe("ReferencedResourceNotFound");
 	});
 
 	test("removeFromCategory fail 2", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1439,16 +1470,18 @@ describe("Product update actions", () => {
 						staged: false,
 					},
 				],
-			});
-		expect(response.status).toBe(400);
-		expect(response.body.errors[0].code).toBe("InvalidOperation");
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().errors[0].code).toBe("InvalidOperation");
 	});
 
 	test("transitionState", async () => {
 		assert(productPublished, "product not created");
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1460,9 +1493,10 @@ describe("Product update actions", () => {
 						force: false,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.state).toMatchObject({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().state).toMatchObject({
 			typeId: "state",
 			id: productState2.id,
 		});
@@ -1474,9 +1508,10 @@ describe("Product update actions", () => {
 			productPublished?.masterData.current.masterVariant.prices?.[0].id;
 		assert(priceId);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/products/${productPublished.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/products/${productPublished.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1494,10 +1529,11 @@ describe("Product update actions", () => {
 						priceId,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
+			},
+		});
+		expect(response.statusCode).toBe(200);
 		expect(
-			response.body.masterData.staged.masterVariant.prices?.[0].custom.fields
+			response.json().masterData.staged.masterVariant.prices?.[0].custom.fields
 				?.myCustomField,
 		).toBe("MyRandomValue");
 	});
@@ -1506,33 +1542,15 @@ describe("Product update actions", () => {
 // Test the general product search implementation
 describe("Product Search - Generic", () => {
 	const ctMock = new CommercetoolsMock();
-
-	async function addInventoryEntry(sku: string, quantity: number) {
-		const inventoryEntryDraft: InventoryEntryDraft = {
-			key: `${sku}_stock`,
-			sku,
-			quantityOnStock: quantity,
-			supplyChannel: {
-				typeId: "channel",
-				id: "dummy-inventory-channel",
-			},
-		};
-
-		await supertest(ctMock.app)
-			.post("/dummy/inventory")
-			.send(inventoryEntryDraft);
-	}
+	const productFactory = productDraftFactory(ctMock);
+	const inventoryFactory = inventoryEntryDraftFactory(ctMock);
 
 	beforeAll(async () => {
 		await beforeAllProductTests(ctMock);
 
-		new Array(24).fill(null).forEach(async () => {
-			const response = await supertest(ctMock.app)
-				.post("/dummy/products")
-				.send(publishedProductDraft);
-
-			expect(response.status).toBe(201);
-		});
+		for (let i = 0; i < 24; i++) {
+			await productFactory.create(publishedProductDraftOverrides);
+		}
 	});
 
 	test("Pagination", async () => {
@@ -1547,11 +1565,13 @@ describe("Product Search - Generic", () => {
 				},
 				limit: 24,
 			};
-			const response = await supertest(ctMock.app)
-				.post("/dummy/products/search")
-				.send(body);
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/products/search",
+				payload: body,
+			});
 
-			const pagedSearchResponse: ProductPagedSearchResponse = response.body;
+			const pagedSearchResponse: ProductPagedSearchResponse = response.json();
 			expect(pagedSearchResponse.limit).toBe(24);
 			expect(pagedSearchResponse.offset).toBe(0);
 			expect(pagedSearchResponse.total).toBeGreaterThan(0);
@@ -1582,11 +1602,13 @@ describe("Product Search - Generic", () => {
 				offset: 88,
 			};
 
-			const response = await supertest(ctMock.app)
-				.post("/dummy/products/search")
-				.send(body);
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: "/dummy/products/search",
+				payload: body,
+			});
 
-			const pagedSearchResponse: ProductPagedSearchResponse = response.body;
+			const pagedSearchResponse: ProductPagedSearchResponse = response.json();
 			expect(pagedSearchResponse.limit).toBe(88);
 			expect(pagedSearchResponse.offset).toBe(88);
 			expect(pagedSearchResponse.total).toBeGreaterThan(0);
@@ -1605,11 +1627,15 @@ describe("Product Search - Generic", () => {
 	});
 
 	test("Filter on inventory", async () => {
+		const channel = await channelDraftFactory(ctMock).create({
+			roles: ["InventorySupply"],
+		});
+
 		const body: ProductSearchRequest = {
 			query: {
 				exact: {
 					field: "variants.availability.isOnStockForChannel",
-					value: "dummy-inventory-channel",
+					value: channel.id,
 				},
 			},
 			productProjectionParameters: {
@@ -1621,24 +1647,33 @@ describe("Product Search - Generic", () => {
 			limit: 1,
 		};
 
-		const response1 = await supertest(ctMock.app)
-			.post("/dummy/products/search")
-			.send(body);
+		const response1 = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/products/search",
+			payload: body,
+		});
 
-		const pagedSearchResponse1: ProductPagedSearchResponse = response1.body;
+		const pagedSearchResponse1: ProductPagedSearchResponse = response1.json();
 
 		expect(pagedSearchResponse1.results.length).toBe(0);
 
-		await addInventoryEntry(
-			publishedProductDraft.variants?.[0]?.sku as string,
-			10,
-		);
+		await inventoryFactory.create({
+			key: "1338_stock",
+			sku: "1338",
+			quantityOnStock: 10,
+			supplyChannel: {
+				typeId: "channel",
+				id: channel.id,
+			},
+		});
 
-		const response2 = await supertest(ctMock.app)
-			.post("/dummy/products/search")
-			.send(body);
+		const response2 = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/products/search",
+			payload: body,
+		});
 
-		const pagedSearchResponse2: ProductPagedSearchResponse = response2.body;
+		const pagedSearchResponse2: ProductPagedSearchResponse = response2.json();
 
 		const productFound = pagedSearchResponse2.results.find(
 			(result) => result?.productProjection?.masterVariant?.sku === "1337",