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

package/src/services/cart.test.ts

@@ -4,81 +4,79 @@ import type {
 	Cart,
 	CentPrecisionMoney,
 	HighPrecisionMoneyDraft,
-	ProductDraft,
 	ShippingMethod,
-	ShippingMethodDraft,
 	ShippingMethodResourceIdentifier,
 	TaxCategory,
-	TaxCategoryDraft,
-	Zone,
 } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { calculateMoneyTotalCentAmount } from "#src/repositories/helpers.ts";
-import { customerDraftFactory } from "#src/testing/customer.ts";
+import {
+	cartDraftFactory,
+	customerDraftFactory,
+	productDraftFactory,
+	productTypeDraftFactory,
+	shippingMethodDraftFactory,
+	taxCategoryDraftFactory,
+	typeDraftFactory,
+	zoneDraftFactory,
+} from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 describe("Carts Query", () => {
 	const ctMock = new CommercetoolsMock();
 
 	beforeEach(async () => {
-		let response;
-		response = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "my-cart",
-				name: {
-					en: "Test",
-				},
-				description: {
-					en: "Test Type",
-				},
-				resourceTypeIds: ["order"],
-				fieldDefinitions: [
-					{
-						name: "offer_name",
-						label: {
-							en: "offer_name",
-						},
-						required: false,
-						type: {
-							name: "String",
-						},
-						inputHint: "SingleLine",
-					},
-				],
-			});
-		expect(response.status).toBe(201);
+		const typeFactory = typeDraftFactory(ctMock);
+		const cartFactory = cartDraftFactory(ctMock);
 
-		response = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({
-				currency: "EUR",
-				custom: {
-					type: {
-						typeId: "type",
-						key: "my-cart",
+		await typeFactory.create({
+			key: "my-cart",
+			name: {
+				en: "Test",
+			},
+			description: {
+				en: "Test Type",
+			},
+			resourceTypeIds: ["order"],
+			fieldDefinitions: [
+				{
+					name: "offer_name",
+					label: {
+						en: "offer_name",
 					},
-					fields: {
-						description: "example description",
+					required: false,
+					type: {
+						name: "String",
 					},
+					inputHint: "SingleLine",
 				},
-			});
-		expect(response.status).toBe(201);
+			],
+		});
+
+		await cartFactory.create({
+			currency: "EUR",
+			custom: {
+				type: {
+					typeId: "type",
+					key: "my-cart",
+				},
+				fields: {
+					description: "example description",
+				},
+			},
+		});
 	});
 
 	test("no filter", async () => {
-		const response = await supertest(ctMock.app)
-			.get("/dummy/carts")
-			.query({
-				expand: "custom.type",
-			})
-			.send();
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/carts?expand=custom.type",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.count).toBe(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().count).toBe(1);
 
-		const myCart = response.body.results[0] as Cart;
+		const myCart = response.json().results[0] as Cart;
 
 		expect(myCart.custom?.type.id).not.toBeUndefined();
 		expect(myCart.custom?.type.id).toBe(myCart.custom?.type.obj?.id);
@@ -88,25 +86,33 @@ describe("Carts Query", () => {
 	test("throw error when anonymousId and customerId are given", async () => {
 		const customerId = "400be09e-bfe8-4925-a307-4ef6280b063e";
 		const anonymousId = "a99f27d1-7e7e-4592-8d5a-aa5da1adfe24";
-		const response = await supertest(ctMock.app).post("/dummy/carts").send({
-			currency: "EUR",
-			anonymousId,
-			customerId,
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/carts",
+			payload: {
+				currency: "EUR",
+				anonymousId,
+				customerId,
+			},
 		});
-		expect(response.status).toBe(400);
-		expect(response.body.message).toBe(
+		expect(response.statusCode).toBe(400);
+		expect(response.json().message).toBe(
 			"Can set only one of customer OR anonymousId",
 		);
 	});
 
 	test("create cart with existing customer", async () => {
 		const customer = await customerDraftFactory(ctMock).create();
-		const response = await supertest(ctMock.app).post("/dummy/carts").send({
-			currency: "EUR",
-			customerId: customer.id,
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/carts",
+			payload: {
+				currency: "EUR",
+				customerId: customer.id,
+			},
 		});
-		expect(response.status).toBe(201);
-		expect(response.body.customerId).toBe(customer.id);
+		expect(response.statusCode).toBe(201);
+		expect(response.json().customerId).toBe(customer.id);
 	});
 });
 
@@ -114,90 +120,33 @@ describe("Cart Update Actions", () => {
 	const ctMock = new CommercetoolsMock();
 	let cart: Cart | undefined;
 	let taxCategory: TaxCategory;
+	let productDraft: Parameters<
+		ReturnType<typeof productDraftFactory>["create"]
+	>[0];
 
-	const createCart = async (currency: string) => {
-		const response = await supertest(ctMock.app).post("/dummy/carts").send({
-			currency,
-			country: "NL",
-		});
-		expect(response.status).toBe(201);
-		cart = response.body;
-	};
+	const cartFactory = cartDraftFactory(ctMock);
+	const taxCategoryFactory = taxCategoryDraftFactory(ctMock);
+	const productFactory = productDraftFactory(ctMock);
+	const typeFactory = typeDraftFactory(ctMock);
+	const zoneFactory = zoneDraftFactory(ctMock);
+	const shippingMethodFactory = shippingMethodDraftFactory(ctMock);
 
-	const createZone = async (country: string): Promise<Zone> => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/zones")
-			.send({
-				name: country,
-				locations: [
-					{
-						country,
-					},
-				],
-			});
-		expect(response.status).toBe(201);
-		return response.body;
-	};
-
-	const createTaxCategory = async (
-		draft: TaxCategoryDraft,
-	): Promise<TaxCategory> => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/tax-categories")
-			.send(draft);
-		expect(response.status).toBe(201);
-		return response.body;
-	};
-
-	const createShippingMethod = async (
-		draft: ShippingMethodDraft,
-	): Promise<ShippingMethod> => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/shipping-methods")
-			.send(draft);
-		expect(response.status).toBe(201);
-		return response.body;
-	};
-
-	const productDraft: ProductDraft = {
-		name: {
-			"nl-NL": "test product",
-		},
-		productType: {
-			typeId: "product-type",
-			id: "some-uuid",
-		},
-		masterVariant: {
-			sku: "1337",
-			prices: [
-				{
-					value: {
-						type: "centPrecision",
-						currencyCode: "EUR",
-						centAmount: 14900,
-						fractionDigits: 2,
-					} as CentPrecisionMoney,
-				},
-				{
-					value: {
-						type: "centPrecision",
-						currencyCode: "GBP",
-						centAmount: 18900,
-						fractionDigits: 2,
-					} as CentPrecisionMoney,
-				},
-			],
+	beforeEach(async () => {
+		const productType = await productTypeDraftFactory(ctMock).create({
+			name: "Test Product Type",
+			description: "Product type for cart tests",
+		});
 
-			attributes: [
-				{
-					name: "test",
-					value: "test",
-				},
-			],
-		},
-		variants: [
-			{
-				sku: "1338",
+		productDraft = {
+			name: {
+				"nl-NL": "test product",
+			},
+			productType: {
+				typeId: "product-type" as const,
+				id: productType.id,
+			},
+			masterVariant: {
+				sku: "1337",
 				prices: [
 					{
 						value: {
@@ -207,24 +156,55 @@ describe("Cart Update Actions", () => {
 							fractionDigits: 2,
 						} as CentPrecisionMoney,
 					},
+					{
+						value: {
+							type: "centPrecision",
+							currencyCode: "GBP",
+							centAmount: 18900,
+							fractionDigits: 2,
+						} as CentPrecisionMoney,
+					},
 				],
+
 				attributes: [
 					{
-						name: "test2",
-						value: "test2",
+						name: "test",
+						value: "test",
 					},
 				],
 			},
-		],
-		slug: {
-			"nl-NL": "test-product",
-		},
-		publish: true,
-	};
+			variants: [
+				{
+					sku: "1338",
+					prices: [
+						{
+							value: {
+								type: "centPrecision",
+								currencyCode: "EUR",
+								centAmount: 14900,
+								fractionDigits: 2,
+							} as CentPrecisionMoney,
+						},
+					],
+					attributes: [
+						{
+							name: "test2",
+							value: "test2",
+						},
+					],
+				},
+			],
+			slug: {
+				"nl-NL": "test-product",
+			},
+			publish: true,
+		};
 
-	beforeEach(async () => {
-		await createCart("EUR");
-		taxCategory = await createTaxCategory({
+		cart = await cartFactory.create({
+			currency: "EUR",
+			country: "NL",
+		});
+		taxCategory = await taxCategoryFactory.create({
 			name: "Standard VAT",
 			key: "standard-vat",
 			rates: [
@@ -245,39 +225,41 @@ describe("Cart Update Actions", () => {
 	test("no update", async () => {
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "setLocale", locale: "nl-NL" }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.locale).toBe("nl-NL");
-
-		const responseAgain = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().locale).toBe("nl-NL");
+
+		const responseAgain = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 2,
 				actions: [{ action: "setLocale", locale: "nl-NL" }],
-			});
-		expect(responseAgain.status).toBe(200);
-		expect(responseAgain.body.version).toBe(2);
-		expect(responseAgain.body.locale).toBe("nl-NL");
+			},
+		});
+		expect(responseAgain.statusCode).toBe(200);
+		expect(responseAgain.json().version).toBe(2);
+		expect(responseAgain.json().locale).toBe("nl-NL");
 	});
 
 	test("addLineItem", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -286,100 +268,99 @@ describe("Cart Update Actions", () => {
 						variantId: product.masterData.current.variants[0].id,
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toHaveLength(1);
-		expect(response.body.totalPrice.centAmount).toEqual(14900);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toHaveLength(1);
+		expect(response.json().totalPrice.centAmount).toEqual(14900);
 	});
 
 	test("addLineItem by SKU", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "addLineItem", sku: "1337", quantity: 2 }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toHaveLength(1);
-		expect(response.body.totalPrice.centAmount).toEqual(29800);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toHaveLength(1);
+		expect(response.json().totalPrice.centAmount).toEqual(29800);
 	});
 
 	test.each([
 		["EUR", 29800],
 		["GBP", 37800],
 	])("addLineItem with price selection", async (currency, total) => {
-		await createCart(currency);
+		cart = await cartFactory.create({
+			currency,
+			country: "NL",
+		});
 
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "addLineItem", sku: "1337", quantity: 2 }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toHaveLength(1);
-		expect(response.body.lineItems[0].price.value.currencyCode).toBe(currency);
-		expect(response.body.totalPrice.centAmount).toEqual(total);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toHaveLength(1);
+		expect(response.json().lineItems[0].price.value.currencyCode).toBe(
+			currency,
+		);
+		expect(response.json().totalPrice.centAmount).toEqual(total);
 	});
 
 	test("addLineItem with custom field", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
-
-		const type = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "my-type",
-				name: {
-					en: "My Type",
-				},
-				description: {
-					en: "My Type Description",
-				},
-				fieldDefinitions: [
-					{
-						name: "foo",
-						label: {
-							en: "foo",
-						},
-						required: false,
-						type: {
-							name: "String",
-						},
-						inputHint: "SingleLine",
+		const product = await productFactory.create(productDraft);
+
+		const type = await typeFactory.create({
+			key: "my-type",
+			name: {
+				en: "My Type",
+			},
+			description: {
+				en: "My Type Description",
+			},
+			fieldDefinitions: [
+				{
+					name: "foo",
+					label: {
+						en: "foo",
 					},
-				],
-			})
-			.then((x) => x.body);
+					required: false,
+					type: {
+						name: "String",
+					},
+					inputHint: "SingleLine",
+				},
+			],
+		});
 
 		assert(type, "type not created");
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -392,55 +373,51 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toHaveLength(1);
-		expect(response.body.lineItems[0].custom).toEqual({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toHaveLength(1);
+		expect(response.json().lineItems[0].custom).toEqual({
 			type: { typeId: "type", id: expect.any(String) },
 			fields: { foo: "bar" },
 		});
 	});
 
 	test("addLineItem with key", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
-
-		const type = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "my-type",
-				name: {
-					en: "My Type",
-				},
-				description: {
-					en: "My Type Description",
-				},
-				fieldDefinitions: [
-					{
-						name: "foo",
-						label: {
-							en: "foo",
-						},
-						required: false,
-						type: {
-							name: "String",
-						},
-						inputHint: "SingleLine",
+		const product = await productFactory.create(productDraft);
+
+		const type = await typeFactory.create({
+			key: "my-type",
+			name: {
+				en: "My Type",
+			},
+			description: {
+				en: "My Type Description",
+			},
+			fieldDefinitions: [
+				{
+					name: "foo",
+					label: {
+						en: "foo",
 					},
-				],
-			})
-			.then((x) => x.body);
+					required: false,
+					type: {
+						name: "String",
+					},
+					inputHint: "SingleLine",
+				},
+			],
+		});
 
 		assert(type, "type not created");
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -454,38 +431,39 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toHaveLength(1);
-		expect(response.body.lineItems[0].key).toBeDefined();
-		expect(response.body.lineItems[0].key).toBe("my-key");
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toHaveLength(1);
+		expect(response.json().lineItems[0].key).toBeDefined();
+		expect(response.json().lineItems[0].key).toBe("my-key");
 	});
 
 	test("addLineItem unknown product", async () => {
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "addLineItem", productId: "123", variantId: 1 }],
-			});
-		expect(response.status).toBe(400);
-		expect(response.body.message).toBe("A product with ID '123' not found.");
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json().message).toBe("A product with ID '123' not found.");
 	});
 
 	test("addItemShippingAddress", async () => {
-		await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -498,20 +476,22 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.body.itemShippingAddresses).toHaveLength(1);
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toHaveLength(0);
+		expect(response.json().itemShippingAddresses).toHaveLength(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toHaveLength(0);
 	});
 
 	test("changeTaxRoundingMode", async () => {
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -519,24 +499,23 @@ describe("Cart Update Actions", () => {
 						taxRoundingMode: "HalfUp",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.taxRoundingMode).toBe("HalfUp");
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().taxRoundingMode).toBe("HalfUp");
 	});
 
 	test("recalculate", async () => {
-		await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -544,24 +523,23 @@ describe("Cart Update Actions", () => {
 						updateProductData: true,
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(1);
 	});
 
 	test("removeLineItem", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const updatedCart = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const updatedCart = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -570,35 +548,36 @@ describe("Cart Update Actions", () => {
 						variantId: product.masterData.current.variants[0].id,
 					},
 				],
-			});
-		const lineItem = updatedCart.body.lineItems[0];
+			},
+		});
+		const lineItem = updatedCart.json().lineItems[0];
 		assert(lineItem, "lineItem not created");
 
-		expect(updatedCart.body.lineItems).toHaveLength(1);
+		expect(updatedCart.json().lineItems).toHaveLength(1);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
-				version: updatedCart.body.version,
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: updatedCart.json().version,
 				actions: [{ action: "removeLineItem", lineItemId: lineItem.id }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(3);
-		expect(response.body.lineItems).toHaveLength(0);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(3);
+		expect(response.json().lineItems).toHaveLength(0);
 	});
 
 	test("removeLineItem decrease quantity", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const updatedCart = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const updatedCart = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -608,25 +587,28 @@ describe("Cart Update Actions", () => {
 						quantity: 2,
 					},
 				],
-			});
-		const lineItem = updatedCart.body.lineItems[0];
+			},
+		});
+		const lineItem = updatedCart.json().lineItems[0];
 		assert(lineItem, "lineItem not created");
 
-		expect(updatedCart.body.lineItems).toHaveLength(1);
-		expect(updatedCart.body.lineItems[0].quantity).toBe(2);
+		expect(updatedCart.json().lineItems).toHaveLength(1);
+		expect(updatedCart.json().lineItems[0].quantity).toBe(2);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
-				version: updatedCart.body.version,
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: updatedCart.json().version,
 				actions: [
 					{ action: "removeLineItem", lineItemId: lineItem.id, quantity: 1 },
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(3);
-		expect(response.body.lineItems).toHaveLength(1);
-		expect(response.body.lineItems[0].quantity).toBe(1);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(3);
+		expect(response.json().lineItems).toHaveLength(1);
+		expect(response.json().lineItems[0].quantity).toBe(1);
 	});
 
 	test("setBillingAddress", async () => {
@@ -638,15 +620,17 @@ describe("Cart Update Actions", () => {
 			country: "NL",
 		};
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "setBillingAddress", address }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.billingAddress).toEqual({
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().billingAddress).toEqual({
 			...address,
 			id: expect.any(String),
 		});
@@ -655,23 +639,26 @@ describe("Cart Update Actions", () => {
 	test("setCountry", async () => {
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "setCountry", country: "BE" }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.country).toBe("BE");
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().country).toBe("BE");
 	});
 
 	test("setDirectDiscounts", async () => {
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -694,10 +681,11 @@ describe("Cart Update Actions", () => {
 						],
 					},
 				],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.directDiscounts).toMatchObject([
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().directDiscounts).toMatchObject([
 			{
 				id: expect.any(String),
 				target: { type: "totalPrice" },
@@ -717,22 +705,16 @@ describe("Cart Update Actions", () => {
 	});
 
 	test("setLineItemPrice sets an external price for a line item", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(product, "product not created");
 
-		const baseCartResponse = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({ currency: "EUR" });
-		expect(baseCartResponse.status).toBe(201);
-		const baseCart = baseCartResponse.body as Cart;
+		const baseCart = await cartFactory.create({ currency: "EUR" });
 
-		const addLineItemResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${baseCart.id}`)
-			.send({
+		const addLineItemResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${baseCart.id}`,
+			payload: {
 				version: baseCart.version,
 				actions: [
 					{
@@ -742,9 +724,10 @@ describe("Cart Update Actions", () => {
 						key: "line-item-key",
 					},
 				],
-			});
-		expect(addLineItemResponse.status).toBe(200);
-		const cartWithLineItem = addLineItemResponse.body as Cart;
+			},
+		});
+		expect(addLineItemResponse.statusCode).toBe(200);
+		const cartWithLineItem = addLineItemResponse.json() as Cart;
 		const lineItem = cartWithLineItem.lineItems[0];
 		assert(lineItem, "lineItem not created");
 
@@ -755,9 +738,10 @@ describe("Cart Update Actions", () => {
 			fractionDigits: 2,
 		};
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cartWithLineItem.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cartWithLineItem.id}`,
+			payload: {
 				version: cartWithLineItem.version,
 				actions: [
 					{
@@ -766,13 +750,14 @@ describe("Cart Update Actions", () => {
 						externalPrice,
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(cartWithLineItem.version + 1);
-		expect(response.body.lineItems).toHaveLength(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(cartWithLineItem.version + 1);
+		expect(response.json().lineItems).toHaveLength(1);
 
-		const updatedLineItem = response.body.lineItems[0];
+		const updatedLineItem = response.json().lineItems[0];
 		expect(updatedLineItem.priceMode).toBe("ExternalPrice");
 		expect(updatedLineItem.price.value.centAmount).toBe(
 			externalPrice.centAmount,
@@ -783,28 +768,22 @@ describe("Cart Update Actions", () => {
 		expect(updatedLineItem.totalPrice.centAmount).toBe(
 			externalPrice.centAmount * updatedLineItem.quantity,
 		);
-		expect(response.body.totalPrice.centAmount).toBe(
+		expect(response.json().totalPrice.centAmount).toBe(
 			externalPrice.centAmount * updatedLineItem.quantity,
 		);
 	});
 
 	test("setLineItemPrice supports high precision external price", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(product, "product not created");
 
-		const baseCartResponse = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({ currency: "EUR" });
-		expect(baseCartResponse.status).toBe(201);
-		const baseCart = baseCartResponse.body as Cart;
+		const baseCart = await cartFactory.create({ currency: "EUR" });
 
-		const addLineItemResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${baseCart.id}`)
-			.send({
+		const addLineItemResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${baseCart.id}`,
+			payload: {
 				version: baseCart.version,
 				actions: [
 					{
@@ -813,9 +792,10 @@ describe("Cart Update Actions", () => {
 						quantity: 2,
 					},
 				],
-			});
-		expect(addLineItemResponse.status).toBe(200);
-		const cartWithLineItem = addLineItemResponse.body as Cart;
+			},
+		});
+		expect(addLineItemResponse.statusCode).toBe(200);
+		const cartWithLineItem = addLineItemResponse.json() as Cart;
 		const lineItem = cartWithLineItem.lineItems[0];
 		assert(lineItem, "lineItem not created");
 
@@ -834,9 +814,10 @@ describe("Cart Update Actions", () => {
 			2,
 		);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cartWithLineItem.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cartWithLineItem.id}`,
+			payload: {
 				version: cartWithLineItem.version,
 				actions: [
 					{
@@ -845,13 +826,14 @@ describe("Cart Update Actions", () => {
 						externalPrice,
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(cartWithLineItem.version + 1);
-		expect(response.body.lineItems).toHaveLength(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(cartWithLineItem.version + 1);
+		expect(response.json().lineItems).toHaveLength(1);
 
-		const updatedLineItem = response.body.lineItems[0];
+		const updatedLineItem = response.json().lineItems[0];
 		expect(updatedLineItem.priceMode).toBe("ExternalPrice");
 		expect(updatedLineItem.price.value.type).toBe("highPrecision");
 		expect(updatedLineItem.price.value.currencyCode).toBe(
@@ -865,26 +847,20 @@ describe("Cart Update Actions", () => {
 		);
 		expect(updatedLineItem.price.value.centAmount).toBe(expectedUnitCentAmount);
 		expect(updatedLineItem.totalPrice.centAmount).toBe(expectedTotalCentAmount);
-		expect(response.body.totalPrice.centAmount).toBe(expectedTotalCentAmount);
+		expect(response.json().totalPrice.centAmount).toBe(expectedTotalCentAmount);
 	});
 
 	test("setLineItemPrice supports high precision external price with fractionDigits 5", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(product, "product not created");
 
-		const baseCartResponse = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({ currency: "EUR" });
-		expect(baseCartResponse.status).toBe(201);
-		const baseCart = baseCartResponse.body as Cart;
+		const baseCart = await cartFactory.create({ currency: "EUR" });
 
-		const addLineItemResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${baseCart.id}`)
-			.send({
+		const addLineItemResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${baseCart.id}`,
+			payload: {
 				version: baseCart.version,
 				actions: [
 					{
@@ -893,9 +869,10 @@ describe("Cart Update Actions", () => {
 						quantity: 2,
 					},
 				],
-			});
-		expect(addLineItemResponse.status).toBe(200);
-		const cartWithLineItem = addLineItemResponse.body as Cart;
+			},
+		});
+		expect(addLineItemResponse.statusCode).toBe(200);
+		const cartWithLineItem = addLineItemResponse.json() as Cart;
 		const lineItem = cartWithLineItem.lineItems[0];
 		assert(lineItem, "lineItem not created");
 
@@ -914,9 +891,10 @@ describe("Cart Update Actions", () => {
 			2,
 		);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cartWithLineItem.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cartWithLineItem.id}`,
+			payload: {
 				version: cartWithLineItem.version,
 				actions: [
 					{
@@ -925,13 +903,14 @@ describe("Cart Update Actions", () => {
 						externalPrice,
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(cartWithLineItem.version + 1);
-		expect(response.body.lineItems).toHaveLength(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(cartWithLineItem.version + 1);
+		expect(response.json().lineItems).toHaveLength(1);
 
-		const updatedLineItem = response.body.lineItems[0];
+		const updatedLineItem = response.json().lineItems[0];
 		expect(updatedLineItem.priceMode).toBe("ExternalPrice");
 		expect(updatedLineItem.price.value.type).toBe("highPrecision");
 		expect(updatedLineItem.price.value.currencyCode).toBe(
@@ -945,26 +924,20 @@ describe("Cart Update Actions", () => {
 		);
 		expect(updatedLineItem.price.value.centAmount).toBe(expectedUnitCentAmount);
 		expect(updatedLineItem.totalPrice.centAmount).toBe(expectedTotalCentAmount);
-		expect(response.body.totalPrice.centAmount).toBe(expectedTotalCentAmount);
+		expect(response.json().totalPrice.centAmount).toBe(expectedTotalCentAmount);
 	});
 
 	test("setLineItemPrice fails when the money uses another currency", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(product, "product not created");
 
-		const baseCartResponse = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({ currency: "EUR" });
-		expect(baseCartResponse.status).toBe(201);
-		const baseCart = baseCartResponse.body as Cart;
+		const baseCart = await cartFactory.create({ currency: "EUR" });
 
-		const addLineItemResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${baseCart.id}`)
-			.send({
+		const addLineItemResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${baseCart.id}`,
+			payload: {
 				version: baseCart.version,
 				actions: [
 					{
@@ -973,15 +946,17 @@ describe("Cart Update Actions", () => {
 						quantity: 1,
 					},
 				],
-			});
-		expect(addLineItemResponse.status).toBe(200);
-		const cartWithLineItem = addLineItemResponse.body as Cart;
+			},
+		});
+		expect(addLineItemResponse.statusCode).toBe(200);
+		const cartWithLineItem = addLineItemResponse.json() as Cart;
 		const lineItem = cartWithLineItem.lineItems[0];
 		assert(lineItem, "lineItem not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cartWithLineItem.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cartWithLineItem.id}`,
+			payload: {
 				version: cartWithLineItem.version,
 				actions: [
 					{
@@ -995,29 +970,24 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(400);
-		expect(response.body.message).toContain("Currency mismatch");
+		expect(response.statusCode).toBe(400);
+		expect(response.json().message).toContain("Currency mismatch");
 	});
 
 	test("setLineItemPrice removes external price when no value is provided", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(product, "product not created");
 
-		const baseCartResponse = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({ currency: "EUR" });
-		expect(baseCartResponse.status).toBe(201);
-		const baseCart = baseCartResponse.body as Cart;
+		const baseCart = await cartFactory.create({ currency: "EUR" });
 
-		const addLineItemResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${baseCart.id}`)
-			.send({
+		const addLineItemResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${baseCart.id}`,
+			payload: {
 				version: baseCart.version,
 				actions: [
 					{
@@ -1026,9 +996,10 @@ describe("Cart Update Actions", () => {
 						quantity: 1,
 					},
 				],
-			});
-		expect(addLineItemResponse.status).toBe(200);
-		const cartWithLineItem = addLineItemResponse.body as Cart;
+			},
+		});
+		expect(addLineItemResponse.statusCode).toBe(200);
+		const cartWithLineItem = addLineItemResponse.json() as Cart;
 		const lineItem = cartWithLineItem.lineItems[0];
 		assert(lineItem, "lineItem not created");
 
@@ -1039,9 +1010,10 @@ describe("Cart Update Actions", () => {
 			fractionDigits: 2,
 		};
 
-		const setExternalPriceResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cartWithLineItem.id}`)
-			.send({
+		const setExternalPriceResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cartWithLineItem.id}`,
+			payload: {
 				version: cartWithLineItem.version,
 				actions: [
 					{
@@ -1050,14 +1022,16 @@ describe("Cart Update Actions", () => {
 						externalPrice,
 					},
 				],
-			});
-		expect(setExternalPriceResponse.status).toBe(200);
-		const cartWithExternalPrice = setExternalPriceResponse.body as Cart;
+			},
+		});
+		expect(setExternalPriceResponse.statusCode).toBe(200);
+		const cartWithExternalPrice = setExternalPriceResponse.json() as Cart;
 		expect(cartWithExternalPrice.lineItems[0].priceMode).toBe("ExternalPrice");
 
-		const resetResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cartWithExternalPrice.id}`)
-			.send({
+		const resetResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cartWithExternalPrice.id}`,
+			payload: {
 				version: cartWithExternalPrice.version,
 				actions: [
 					{
@@ -1065,13 +1039,16 @@ describe("Cart Update Actions", () => {
 						lineItemId: lineItem.id,
 					},
 				],
-			});
+			},
+		});
 
-		expect(resetResponse.status).toBe(200);
-		expect(resetResponse.body.version).toBe(cartWithExternalPrice.version + 1);
-		expect(resetResponse.body.lineItems).toHaveLength(1);
+		expect(resetResponse.statusCode).toBe(200);
+		expect(resetResponse.json().version).toBe(
+			cartWithExternalPrice.version + 1,
+		);
+		expect(resetResponse.json().lineItems).toHaveLength(1);
 
-		const revertedLineItem = resetResponse.body.lineItems[0];
+		const revertedLineItem = resetResponse.json().lineItems[0];
 		const expectedCentAmount =
 			product.masterData.current.masterVariant.prices?.[0].value.centAmount;
 		if (typeof expectedCentAmount !== "number") {
@@ -1082,73 +1059,65 @@ describe("Cart Update Actions", () => {
 		expect(revertedLineItem.totalPrice.centAmount).toBe(
 			expectedCentAmount * revertedLineItem.quantity,
 		);
-		expect(resetResponse.body.totalPrice.centAmount).toBe(
+		expect(resetResponse.json().totalPrice.centAmount).toBe(
 			expectedCentAmount * revertedLineItem.quantity,
 		);
 	});
 
 	test("setLineItemCustomField", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(product, "product not created");
 
-		const type = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "my-type",
-				name: {
-					en: "My Type",
-				},
-				description: {
-					en: "My Type Description",
-				},
-				fieldDefinitions: [
-					{
-						name: "foo",
-						label: {
-							en: "foo",
-						},
-						required: false,
-						type: {
-							name: "String",
-						},
-						inputHint: "SingleLine",
+		const type = await typeFactory.create({
+			key: "my-type",
+			name: {
+				en: "My Type",
+			},
+			description: {
+				en: "My Type Description",
+			},
+			fieldDefinitions: [
+				{
+					name: "foo",
+					label: {
+						en: "foo",
 					},
-				],
-			})
-			.then((x) => x.body);
+					required: false,
+					type: {
+						name: "String",
+					},
+					inputHint: "SingleLine",
+				},
+			],
+		});
 
 		assert(type, "type not created");
 
-		const myCart = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({
-				currency: "EUR",
-				lineItems: [
-					{
-						sku: product.masterData.current.masterVariant.sku,
-						quantity: 1,
-						custom: {
-							type: {
-								typeId: "type",
-								key: "my-type",
-							},
-							fields: {},
+		const myCart = await cartFactory.create({
+			currency: "EUR",
+			lineItems: [
+				{
+					sku: product.masterData.current.masterVariant.sku,
+					quantity: 1,
+					custom: {
+						type: {
+							typeId: "type",
+							key: "my-type",
 						},
+						fields: {},
 					},
-				],
-			})
-			.then((x) => x.body);
+				},
+			],
+		});
 
 		const lineItem = myCart.lineItems[0];
 		assert(lineItem, "lineItem not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${myCart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${myCart.id}`,
+			payload: {
 				version: myCart.version,
 				actions: [
 					{
@@ -1158,11 +1127,12 @@ describe("Cart Update Actions", () => {
 						value: "bar",
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toMatchObject([
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toMatchObject([
 			{
 				id: lineItem.id,
 				custom: {
@@ -1175,60 +1145,52 @@ describe("Cart Update Actions", () => {
 	});
 
 	test("setLineItemCustomType", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(product, "product not created");
 
-		const type = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "my-type",
-				name: {
-					en: "My Type",
-				},
-				description: {
-					en: "My Type Description",
-				},
-				fieldDefinitions: [
-					{
-						name: "foo",
-						label: {
-							en: "foo",
-						},
-						required: false,
-						type: {
-							name: "String",
-						},
-						inputHint: "SingleLine",
+		const type = await typeFactory.create({
+			key: "my-type",
+			name: {
+				en: "My Type",
+			},
+			description: {
+				en: "My Type Description",
+			},
+			fieldDefinitions: [
+				{
+					name: "foo",
+					label: {
+						en: "foo",
 					},
-				],
-			})
-			.then((x) => x.body);
+					required: false,
+					type: {
+						name: "String",
+					},
+					inputHint: "SingleLine",
+				},
+			],
+		});
 
 		assert(type, "type not created");
 
-		const myCart = await supertest(ctMock.app)
-			.post("/dummy/carts")
-			.send({
-				currency: "EUR",
-				lineItems: [
-					{
-						sku: product.masterData.current.masterVariant.sku,
-						quantity: 1,
-					},
-				],
-			})
-			.then((x) => x.body);
+		const myCart = await cartFactory.create({
+			currency: "EUR",
+			lineItems: [
+				{
+					sku: product.masterData.current.masterVariant.sku,
+					quantity: 1,
+				},
+			],
+		});
 
 		const lineItem = myCart.lineItems[0];
 		assert(lineItem, "lineItem not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${myCart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${myCart.id}`,
+			payload: {
 				version: myCart.version,
 				actions: [
 					{
@@ -1240,11 +1202,12 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.lineItems).toMatchObject([
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().lineItems).toMatchObject([
 			{
 				id: lineItem.id,
 				custom: {
@@ -1260,15 +1223,17 @@ describe("Cart Update Actions", () => {
 	test("setCustomerEmail", async () => {
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "setCustomerEmail", email: "john@doe.com" }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.customerEmail).toBe("john@doe.com");
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().customerEmail).toBe("john@doe.com");
 	});
 
 	test("setShippingAddress", async () => {
@@ -1280,15 +1245,17 @@ describe("Cart Update Actions", () => {
 			country: "NL",
 		};
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [{ action: "setShippingAddress", address }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.shippingAddress).toEqual(address);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().shippingAddress).toEqual(address);
 	});
 
 	test("setBillingAddressCustomType", async () => {
@@ -1300,37 +1267,35 @@ describe("Cart Update Actions", () => {
 			country: "NL",
 		};
 
-		const type = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "my-type",
-				name: {
-					en: "My Type",
-				},
-				description: {
-					en: "My Type Description",
-				},
-				fieldDefinitions: [
-					{
-						name: "foo",
-						label: {
-							en: "foo",
-						},
-						required: false,
-						type: {
-							name: "String",
-						},
-						inputHint: "SingleLine",
+		const type = await typeFactory.create({
+			key: "my-type",
+			name: {
+				en: "My Type",
+			},
+			description: {
+				en: "My Type Description",
+			},
+			fieldDefinitions: [
+				{
+					name: "foo",
+					label: {
+						en: "foo",
 					},
-				],
-			})
-			.then((x) => x.body);
+					required: false,
+					type: {
+						name: "String",
+					},
+					inputHint: "SingleLine",
+				},
+			],
+		});
 
 		assert(type, "type not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{ action: "setBillingAddress", address },
@@ -1346,11 +1311,12 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(3);
-		expect(response.body.billingAddress).toEqual({
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(3);
+		expect(response.json().billingAddress).toEqual({
 			...address,
 			id: expect.any(String),
 			custom: {
@@ -1369,37 +1335,35 @@ describe("Cart Update Actions", () => {
 			country: "NL",
 		};
 
-		const type = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "my-type",
-				name: {
-					en: "My Type",
-				},
-				description: {
-					en: "My Type Description",
-				},
-				fieldDefinitions: [
-					{
-						name: "foo",
-						label: {
-							en: "foo",
-						},
-						required: false,
-						type: {
-							name: "String",
-						},
-						inputHint: "SingleLine",
+		const type = await typeFactory.create({
+			key: "my-type",
+			name: {
+				en: "My Type",
+			},
+			description: {
+				en: "My Type Description",
+			},
+			fieldDefinitions: [
+				{
+					name: "foo",
+					label: {
+						en: "foo",
 					},
-				],
-			})
-			.then((x) => x.body);
+					required: false,
+					type: {
+						name: "String",
+					},
+					inputHint: "SingleLine",
+				},
+			],
+		});
 
 		assert(type, "type not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{ action: "setShippingAddress", address },
@@ -1415,11 +1379,12 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(3);
-		expect(response.body.shippingAddress).toEqual({
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(3);
+		expect(response.json().shippingAddress).toEqual({
 			...address,
 			custom: {
 				type: { typeId: "type", id: type.id },
@@ -1433,9 +1398,15 @@ describe("Cart Update Actions", () => {
 		let standardExcludedShippingMethod: ShippingMethod;
 		beforeEach(async () => {
 			assert(cart, "cart not created");
-			const nlZone = await createZone("NL");
-			const frZone = await createZone("FR");
-			const standardTax = await createTaxCategory({
+			const nlZone = await zoneFactory.create({
+				name: "NL",
+				locations: [{ country: "NL" }],
+			});
+			const frZone = await zoneFactory.create({
+				name: "FR",
+				locations: [{ country: "FR" }],
+			});
+			const standardTax = await taxCategoryFactory.create({
 				name: "Standard tax category",
 				key: "standard",
 				rates: [
@@ -1453,7 +1424,7 @@ describe("Cart Update Actions", () => {
 					},
 				],
 			});
-			await createTaxCategory({
+			await taxCategoryFactory.create({
 				name: "Reduced tax category",
 				key: "reduced",
 				rates: [
@@ -1471,7 +1442,7 @@ describe("Cart Update Actions", () => {
 					},
 				],
 			});
-			const standardExcludedTax = await createTaxCategory({
+			const standardExcludedTax = await taxCategoryFactory.create({
 				name: "Tax category that is excluded from price",
 				key: "standard-excluded",
 				rates: [
@@ -1489,7 +1460,7 @@ describe("Cart Update Actions", () => {
 					},
 				],
 			});
-			standardShippingMethod = await createShippingMethod({
+			standardShippingMethod = await shippingMethodFactory.create({
 				isDefault: false,
 				key: "standard",
 				name: "Standard shipping",
@@ -1533,7 +1504,7 @@ describe("Cart Update Actions", () => {
 				],
 			});
 
-			standardExcludedShippingMethod = await createShippingMethod({
+			standardExcludedShippingMethod = await shippingMethodFactory.create({
 				isDefault: false,
 				key: "standard-excluded",
 				name: "Standard shipping with tax excluded from price",
@@ -1576,7 +1547,7 @@ describe("Cart Update Actions", () => {
 					},
 				],
 			});
-			await createShippingMethod({
+			await shippingMethodFactory.create({
 				isDefault: false,
 				key: "express",
 				name: "Express shipping",
@@ -1622,9 +1593,10 @@ describe("Cart Update Actions", () => {
 
 			expect(
 				(
-					await supertest(ctMock.app)
-						.post(`/dummy/carts/${cart.id}`)
-						.send({
+					await ctMock.app.inject({
+						method: "POST",
+						url: `/dummy/carts/${cart.id}`,
+						payload: {
 							version: 1,
 							actions: [
 								{
@@ -1636,8 +1608,9 @@ describe("Cart Update Actions", () => {
 									},
 								},
 							],
-						})
-				).status,
+						},
+					})
+				).statusCode,
 			).toBe(200);
 		});
 
@@ -1649,15 +1622,17 @@ describe("Cart Update Actions", () => {
 				id: standardShippingMethod.id,
 			};
 
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/carts/${cart.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/carts/${cart.id}`,
+				payload: {
 					version: 2,
 					actions: [{ action: "setShippingMethod", shippingMethod }],
-				});
-			expect(response.status).toBe(200);
-			expect(response.body.version).toBe(3);
-			expect(response.body.shippingInfo.shippingMethod.id).toEqual(
+				},
+			});
+			expect(response.statusCode).toBe(200);
+			expect(response.json().version).toBe(3);
+			expect(response.json().shippingInfo.shippingMethod.id).toEqual(
 				standardShippingMethod.id,
 			);
 		});
@@ -1670,17 +1645,20 @@ describe("Cart Update Actions", () => {
 				id: standardShippingMethod.id,
 			};
 
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/carts/${cart.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/carts/${cart.id}`,
+				payload: {
 					version: 2,
 					actions: [{ action: "setShippingMethod", shippingMethod }],
-				});
-			expect(response.status).toBe(200);
+				},
+			});
+			expect(response.statusCode).toBe(200);
 
-			const removeResponse = await supertest(ctMock.app)
-				.post(`/dummy/carts/${cart.id}`)
-				.send({
+			const removeResponse = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/carts/${cart.id}`,
+				payload: {
 					version: 3,
 					actions: [
 						{
@@ -1688,9 +1666,10 @@ describe("Cart Update Actions", () => {
 							shippingKey: standardShippingMethod.key,
 						},
 					],
-				});
-			expect(removeResponse.status).toBe(200);
-			expect(removeResponse.body.shippingInfo).toBeUndefined();
+				},
+			});
+			expect(removeResponse.statusCode).toBe(200);
+			expect(removeResponse.json().shippingInfo).toBeUndefined();
 		});
 
 		test("correctly sets shippingInfo rates + tax when includedInPrice: true", async () => {
@@ -1702,33 +1681,35 @@ describe("Cart Update Actions", () => {
 				id: standardShippingMethod.id,
 			};
 
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/carts/${cart.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/carts/${cart.id}`,
+				payload: {
 					version: 2,
 					actions: [{ action: "setShippingMethod", shippingMethod }],
-				});
-			expect(response.status).toBe(200);
-			expect(response.body.version).toBe(3);
-			expect(response.body.shippingInfo.shippingRate.price).toMatchObject({
+				},
+			});
+			expect(response.statusCode).toBe(200);
+			expect(response.json().version).toBe(3);
+			expect(response.json().shippingInfo.shippingRate.price).toMatchObject({
 				centAmount: 499,
 				currencyCode: "EUR",
 				fractionDigits: 2,
 				type: "centPrecision",
 			});
-			expect(response.body.shippingInfo.price).toMatchObject({
+			expect(response.json().shippingInfo.price).toMatchObject({
 				centAmount: 499,
 				currencyCode: "EUR",
 				fractionDigits: 2,
 				type: "centPrecision",
 			});
-			expect(response.body.shippingInfo.taxRate).toMatchObject({
+			expect(response.json().shippingInfo.taxRate).toMatchObject({
 				name: "NL standard tax rate",
 				amount: 0.21,
 				includedInPrice: true,
 				country: "NL",
 			});
-			expect(response.body.shippingInfo.taxedPrice).toMatchObject({
+			expect(response.json().shippingInfo.taxedPrice).toMatchObject({
 				totalNet: {
 					type: "centPrecision",
 					centAmount: 412,
@@ -1771,34 +1752,36 @@ describe("Cart Update Actions", () => {
 				id: standardExcludedShippingMethod.id,
 			};
 
-			const response = await supertest(ctMock.app)
-				.post(`/dummy/carts/${cart.id}`)
-				.send({
+			const response = await ctMock.app.inject({
+				method: "POST",
+				url: `/dummy/carts/${cart.id}`,
+				payload: {
 					version: 2,
 					actions: [{ action: "setShippingMethod", shippingMethod }],
-				});
-			expect(response.status).toBe(200);
-			expect(response.body.version).toBe(3);
-			expect(response.body.shippingInfo.shippingRate.price).toMatchObject({
+				},
+			});
+			expect(response.statusCode).toBe(200);
+			expect(response.json().version).toBe(3);
+			expect(response.json().shippingInfo.shippingRate.price).toMatchObject({
 				centAmount: 499,
 				currencyCode: "EUR",
 				fractionDigits: 2,
 				type: "centPrecision",
 			});
 			// TODO: should this be gross or net? docs unclear (currently always just returns the shipping rate (tier) price)
-			expect(response.body.shippingInfo.price).toMatchObject({
+			expect(response.json().shippingInfo.price).toMatchObject({
 				centAmount: 499,
 				currencyCode: "EUR",
 				fractionDigits: 2,
 				type: "centPrecision",
 			});
-			expect(response.body.shippingInfo.taxRate).toMatchObject({
+			expect(response.json().shippingInfo.taxRate).toMatchObject({
 				name: "NL standard-excluded tax rate",
 				amount: 0.21,
 				includedInPrice: false,
 				country: "NL",
 			});
-			expect(response.body.shippingInfo.taxedPrice).toMatchObject({
+			expect(response.json().shippingInfo.taxedPrice).toMatchObject({
 				totalNet: {
 					type: "centPrecision",
 					centAmount: 499,
@@ -1834,17 +1817,15 @@ describe("Cart Update Actions", () => {
 	});
 
 	test("setLineItemShippingDetails", async () => {
-		const product = await supertest(ctMock.app)
-			.post("/dummy/products")
-			.send(productDraft)
-			.then((x) => x.body);
+		const product = await productFactory.create(productDraft);
 
 		assert(cart, "cart not created");
 		assert(product, "product not created");
 
-		const updatedCart = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const updatedCart = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1853,17 +1834,19 @@ describe("Cart Update Actions", () => {
 						variantId: product.masterData.current.variants[0].id,
 					},
 				],
-			});
-		const lineItem = updatedCart.body.lineItems[0];
+			},
+		});
+		const lineItem = updatedCart.json().lineItems[0];
 		assert(lineItem, "lineItem not created");
 
-		expect(updatedCart.body.version).toBe(2);
-		expect(updatedCart.body.lineItems).toHaveLength(1);
+		expect(updatedCart.json().version).toBe(2);
+		expect(updatedCart.json().lineItems).toHaveLength(1);
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
-				version: updatedCart.body.version,
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: updatedCart.json().version,
 				actions: [
 					{
 						action: "setLineItemShippingDetails",
@@ -1878,40 +1861,39 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(3);
-		expect(response.body.lineItems).toHaveLength(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(3);
+		expect(response.json().lineItems).toHaveLength(1);
 
-		const updatedLineItem = response.body.lineItems[0];
+		const updatedLineItem = response.json().lineItems[0];
 		expect(updatedLineItem.shippingDetails).toBeDefined();
 		expect(updatedLineItem.shippingDetails.targets).toHaveLength(1);
 	});
 
 	test("addCustomLineItem", async () => {
 		assert(cart, "cart not created");
-		const type = await supertest(ctMock.app)
-			.post("/dummy/types")
-			.send({
-				key: "custom-line-item-type",
-				name: { en: "Custom Line Item Type" },
-				resourceTypeIds: ["custom-line-item"],
-				fieldDefinitions: [
-					{
-						name: "description",
-						label: { en: "Description" },
-						required: false,
-						type: { name: "String" },
-						inputHint: "SingleLine",
-					},
-				],
-			})
-			.then((res) => res.body);
+		const type = await typeFactory.create({
+			key: "custom-line-item-type",
+			name: { en: "Custom Line Item Type" },
+			resourceTypeIds: ["custom-line-item"],
+			fieldDefinitions: [
+				{
+					name: "description",
+					label: { en: "Description" },
+					required: false,
+					type: { name: "String" },
+					inputHint: "SingleLine",
+				},
+			],
+		});
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1933,13 +1915,14 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(2);
-		expect(response.body.customLineItems).toHaveLength(1);
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(2);
+		expect(response.json().customLineItems).toHaveLength(1);
 
-		const customLineItem = response.body.customLineItems[0];
+		const customLineItem = response.json().customLineItems[0];
 		expect(customLineItem.name).toEqual({ en: "Custom Service Fee" });
 		expect(customLineItem.slug).toBe("service-fee");
 		expect(customLineItem.money.centAmount).toBe(1000);
@@ -1959,9 +1942,10 @@ describe("Cart Update Actions", () => {
 	test("removeCustomLineItem by ID", async () => {
 		assert(cart, "cart not created");
 
-		const addResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const addResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -1975,34 +1959,38 @@ describe("Cart Update Actions", () => {
 						quantity: 1,
 					},
 				],
-			});
+			},
+		});
 
-		expect(addResponse.status).toBe(200);
-		expect(addResponse.body.customLineItems).toHaveLength(1);
+		expect(addResponse.statusCode).toBe(200);
+		expect(addResponse.json().customLineItems).toHaveLength(1);
 
-		const customLineItemId = addResponse.body.customLineItems[0].id;
-		const removeResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
-				version: addResponse.body.version,
+		const customLineItemId = addResponse.json().customLineItems[0].id;
+		const removeResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: addResponse.json().version,
 				actions: [
 					{
 						action: "removeCustomLineItem",
 						customLineItemId,
 					},
 				],
-			});
+			},
+		});
 
-		expect(removeResponse.status).toBe(200);
-		expect(removeResponse.body.customLineItems).toHaveLength(0);
+		expect(removeResponse.statusCode).toBe(200);
+		expect(removeResponse.json().customLineItems).toHaveLength(0);
 	});
 
 	test("removeCustomLineItem by key", async () => {
 		assert(cart, "cart not created");
 
-		const addResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const addResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -2017,32 +2005,36 @@ describe("Cart Update Actions", () => {
 						quantity: 1,
 					},
 				],
-			});
+			},
+		});
 
-		expect(addResponse.status).toBe(200);
-		expect(addResponse.body.customLineItems).toHaveLength(1);
+		expect(addResponse.statusCode).toBe(200);
+		expect(addResponse.json().customLineItems).toHaveLength(1);
 
-		const removeResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
-				version: addResponse.body.version,
+		const removeResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: addResponse.json().version,
 				actions: [
 					{
 						action: "removeCustomLineItem",
 						customLineItemKey: "custom-service-fee",
 					},
 				],
-			});
+			},
+		});
 
-		expect(removeResponse.status).toBe(200);
-		expect(removeResponse.body.customLineItems).toHaveLength(0);
+		expect(removeResponse.statusCode).toBe(200);
+		expect(removeResponse.json().customLineItems).toHaveLength(0);
 	});
 
 	test("changeCustomLineItemQuantity", async () => {
 		assert(cart, "cart not created");
-		const addResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const addResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -2056,13 +2048,15 @@ describe("Cart Update Actions", () => {
 						quantity: 1,
 					},
 				],
-			});
+			},
+		});
 
-		const customLineItemId = addResponse.body.customLineItems[0].id;
-		const changeResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
-				version: addResponse.body.version,
+		const customLineItemId = addResponse.json().customLineItems[0].id;
+		const changeResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: addResponse.json().version,
 				actions: [
 					{
 						action: "changeCustomLineItemQuantity",
@@ -2070,21 +2064,23 @@ describe("Cart Update Actions", () => {
 						quantity: 3,
 					},
 				],
-			});
+			},
+		});
 
-		expect(changeResponse.status).toBe(200);
-		expect(changeResponse.body.customLineItems).toHaveLength(1);
+		expect(changeResponse.statusCode).toBe(200);
+		expect(changeResponse.json().customLineItems).toHaveLength(1);
 
-		const customLineItem = changeResponse.body.customLineItems[0];
+		const customLineItem = changeResponse.json().customLineItems[0];
 		expect(customLineItem.quantity).toBe(3);
 		expect(customLineItem.totalPrice.centAmount).toBe(3000);
 	});
 
 	test("changeCustomLineItemMoney", async () => {
 		assert(cart, "cart not created");
-		const addResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const addResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -2098,13 +2094,15 @@ describe("Cart Update Actions", () => {
 						quantity: 2,
 					},
 				],
-			});
+			},
+		});
 
-		const customLineItemId = addResponse.body.customLineItems[0].id;
-		const changeResponse = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
-				version: addResponse.body.version,
+		const customLineItemId = addResponse.json().customLineItems[0].id;
+		const changeResponse = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
+				version: addResponse.json().version,
 				actions: [
 					{
 						action: "changeCustomLineItemMoney",
@@ -2115,12 +2113,13 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(changeResponse.status).toBe(200);
-		expect(changeResponse.body.customLineItems).toHaveLength(1);
+		expect(changeResponse.statusCode).toBe(200);
+		expect(changeResponse.json().customLineItems).toHaveLength(1);
 
-		const customLineItem = changeResponse.body.customLineItems[0];
+		const customLineItem = changeResponse.json().customLineItems[0];
 		expect(customLineItem.money.centAmount).toBe(1500);
 		expect(customLineItem.totalPrice.centAmount).toBe(3000);
 	});
@@ -2128,9 +2127,10 @@ describe("Cart Update Actions", () => {
 	test("addCustomLineItem with tax calculation", async () => {
 		assert(cart, "cart not created");
 
-		const response = await supertest(ctMock.app)
-			.post(`/dummy/carts/${cart.id}`)
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: `/dummy/carts/${cart.id}`,
+			payload: {
 				version: 1,
 				actions: [
 					{
@@ -2148,10 +2148,11 @@ describe("Cart Update Actions", () => {
 						},
 					},
 				],
-			});
+			},
+		});
 
-		expect(response.status).toBe(200);
-		const customLineItem = response.body.customLineItems[0];
+		expect(response.statusCode).toBe(200);
+		const customLineItem = response.json().customLineItems[0];
 
 		expect(customLineItem.taxedPrice).toBeDefined();
 		expect(customLineItem.taxedPrice.totalNet.centAmount).toBe(1000);