@labdigital/commercetools-mock 2.50.1 → 2.52.0

package/src/services/my-business-unit.test.ts

@@ -0,0 +1,113 @@
+import type { BusinessUnitDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
+
+const ctMock = new CommercetoolsMock();
+
+describe("MyBusinessUnit", () => {
+	test("Get my business units", async () => {
+		// First create a business unit
+		const draft: BusinessUnitDraft = {
+			key: "my-business-unit",
+			unitType: "Company",
+			name: "My Business Unit",
+			contactEmail: "contact@example.com",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/business-units")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get(
+			"/dummy/me/business-units/",
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body.count).toBeGreaterThanOrEqual(0);
+		expect(response.body.results).toBeDefined();
+	});
+
+	test("Get my business unit by ID", async () => {
+		// First create a business unit
+		const draft: BusinessUnitDraft = {
+			key: "my-business-unit",
+			unitType: "Company",
+			name: "My Business Unit",
+			contactEmail: "contact@example.com",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/business-units")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get(
+			`/dummy/me/business-units/${createResponse.body.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
+
+	test("Delete my business unit", async () => {
+		// First create a business unit
+		const draft: BusinessUnitDraft = {
+			key: "my-business-unit",
+			unitType: "Company",
+			name: "My Business Unit",
+			contactEmail: "contact@example.com",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/business-units")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		// Now delete the business unit
+		const deleteResponse = await supertest(ctMock.app).delete(
+			`/dummy/me/business-units/${createResponse.body.id}`,
+		);
+
+		expect(deleteResponse.status).toBe(200);
+		expect(deleteResponse.body).toEqual(createResponse.body);
+
+		// Verify that the business unit is deleted
+		const newResponse = await supertest(ctMock.app).get(
+			`/dummy/me/business-units/${createResponse.body.id}`,
+		);
+		expect(newResponse.status).toBe(404);
+	});
+
+	test("Update my business unit", async () => {
+		// First create a business unit
+		const draft: BusinessUnitDraft = {
+			key: "my-business-unit",
+			unitType: "Company",
+			name: "My Business Unit",
+			contactEmail: "contact@example.com",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/business-units")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const updateResponse = await supertest(ctMock.app)
+			.post(`/dummy/me/business-units/${createResponse.body.id}`)
+			.send({
+				id: createResponse.body.id,
+				version: createResponse.body.version,
+				actions: [
+					{
+						action: "changeName",
+						name: "Updated Business Unit Name",
+					},
+				],
+			});
+
+		expect(updateResponse.status).toBe(200);
+		expect(updateResponse.body.name).toBe("Updated Business Unit Name");
+	});
+});

package/src/services/my-business-unit.ts

@@ -22,6 +22,12 @@ export class MyBusinessUnitService extends AbstractService {
 		this.extraRoutes(router);
 
 		router.get("/business-units/", this.get.bind(this));
+		router.get("/business-units/:id", this.getWithId.bind(this));
+
+		router.delete("/business-units/:id", this.deleteWithId.bind(this));
+
+		router.post("/business-units/", this.post.bind(this));
+		router.post("/business-units/:id", this.postWithId.bind(this));
 
 		parent.use(`/${basePath}`, router);
 	}

package/src/services/my-customer.test.ts

@@ -293,4 +293,28 @@ describe("/me", () => {
 		expect(response.body.version).toBe(3);
 		expect(response.body.custom.fields.foobar).toBe(true);
 	});
+
+	test("deleteMe", async () => {
+		const response = await supertest(ctMock.app).delete("/dummy/me");
+		expect(response.status).toBe(200);
+		expect(response.body.id).toBeDefined();
+	});
+
+	test("signIn with invalid credentials", async () => {
+		const response = await supertest(ctMock.app).post("/dummy/me/login").send({
+			email: "nonexistent@example.com",
+			password: "wrongpassword",
+		});
+
+		expect(response.status).toBe(400);
+		expect(response.body).toEqual({
+			message: "Account with the given credentials not found.",
+			errors: [
+				{
+					code: "InvalidCredentials",
+					message: "Account with the given credentials not found.",
+				},
+			],
+		});
+	});
 });

package/src/services/order.test.ts

@@ -273,6 +273,24 @@ describe("Order payment tests", () => {
 		expect(maybePayment).toBeDefined();
 		expect(maybePayment.paymentStatus.state.obj).toBeDefined();
 	});
+
+	test("get by orderNumber - not found", async () => {
+		const response = await supertest(ctMock.app).get(
+			"/dummy/orders/order-number=nonexistent",
+		);
+
+		expect(response.status).toBe(404);
+		expect(response.body).toEqual({
+			statusCode: 404,
+			message: "The Resource with key 'nonexistent' was not found.",
+			errors: [
+				{
+					code: "ResourceNotFound",
+					message: "The Resource with key 'nonexistent' was not found.",
+				},
+			],
+		});
+	});
 });
 
 describe("Order Update Actions", () => {

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

@@ -0,0 +1,146 @@
+import type { ProductDiscountDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
+
+const ctMock = new CommercetoolsMock();
+
+describe("ProductDiscount", () => {
+	test("Create product discount", async () => {
+		const draft: ProductDiscountDraft = {
+			key: "summer-sale",
+			name: {
+				en: "Summer Sale",
+			},
+			description: {
+				en: "20% off all products",
+			},
+			value: {
+				type: "relative",
+				permyriad: 2000,
+			},
+			predicate: "1=1",
+			sortOrder: "0.1",
+			isActive: true,
+		};
+		const response = await supertest(ctMock.app)
+			.post("/dummy/product-discounts")
+			.send(draft);
+
+		expect(response.status).toBe(201);
+
+		expect(response.body).toEqual({
+			createdAt: expect.anything(),
+			description: {
+				en: "20% off all products",
+			},
+			id: expect.anything(),
+			isActive: true,
+			key: "summer-sale",
+			lastModifiedAt: expect.anything(),
+			name: {
+				en: "Summer Sale",
+			},
+			predicate: "1=1",
+			references: [],
+			sortOrder: "0.1",
+			validFrom: undefined,
+			validUntil: undefined,
+			value: {
+				permyriad: 2000,
+				type: "relative",
+			},
+			version: 1,
+		});
+	});
+
+	test("Get product discount", async () => {
+		const draft: ProductDiscountDraft = {
+			key: "test-discount",
+			name: {
+				en: "Test Discount",
+			},
+			value: {
+				type: "absolute",
+				money: [
+					{
+						currencyCode: "EUR",
+						centAmount: 1000,
+					},
+				],
+			},
+			predicate: "1=1",
+			sortOrder: "0.2",
+			isActive: true,
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/product-discounts")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get(
+			`/dummy/product-discounts/${createResponse.body.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
+
+	test("Get product discount by key", async () => {
+		const draft: ProductDiscountDraft = {
+			key: "key-discount",
+			name: {
+				en: "Key Discount",
+			},
+			value: {
+				type: "relative",
+				permyriad: 1500,
+			},
+			predicate: "1=1",
+			sortOrder: "0.3",
+			isActive: false,
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/product-discounts")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get(
+			"/dummy/product-discounts/key=key-discount",
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
+
+	test("Query product discounts", async () => {
+		const draft: ProductDiscountDraft = {
+			key: "query-discount",
+			name: {
+				en: "Query Discount",
+			},
+			value: {
+				type: "relative",
+				permyriad: 500,
+			},
+			predicate: "1=1",
+			sortOrder: "0.4",
+			isActive: true,
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/product-discounts")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get(
+			"/dummy/product-discounts",
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body.count).toBeGreaterThan(0);
+		expect(response.body.results).toContainEqual(createResponse.body);
+	});
+});

package/src/services/project.test.ts

@@ -48,4 +48,21 @@ describe("Project", () => {
 		const response = await supertest(ctMock.app).post("/dummy/");
 		expect(response.statusCode).toBe(400);
 	});
+
+	test("Post successful update", async () => {
+		const response = await supertest(ctMock.app)
+			.post("/dummy/")
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "changeName",
+						name: "Updated Project Name",
+					},
+				],
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.name).toBe("Updated Project Name");
+		expect(response.body.version).toBe(2);
+	});
 });

package/src/services/reviews.test.ts

@@ -0,0 +1,230 @@
+import type { Product, Review, State } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "~src/index";
+
+describe("Review Update Actions", () => {
+	let ctMock: CommercetoolsMock;
+	let review: Review;
+	let product: Product;
+	let state: State;
+
+	beforeEach(async () => {
+		ctMock = new CommercetoolsMock();
+
+		// Create a product to target
+		const productResponse = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send({
+				name: { en: "Test Product" },
+				slug: { en: "test-product" },
+				productType: {
+					typeId: "product-type",
+					key: "dummy-product-type",
+				},
+				masterVariant: {
+					sku: "test-sku-1",
+					prices: [
+						{
+							value: {
+								currencyCode: "EUR",
+								centAmount: 1000,
+							},
+						},
+					],
+				},
+			});
+		expect(productResponse.status).toBe(201);
+		product = productResponse.body;
+
+		// Create a state
+		const stateResponse = await supertest(ctMock.app)
+			.post("/dummy/states")
+			.send({
+				key: "review-state",
+				type: "ReviewState",
+				name: { en: "Review State" },
+				initial: true,
+			});
+		expect(stateResponse.status).toBe(201);
+		state = stateResponse.body;
+
+		// Create a review
+		const reviewResponse = await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				key: "test-review",
+				authorName: "John Doe",
+				title: "Great product!",
+				text: "I really love this product.",
+				rating: 5,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+		expect(reviewResponse.status).toBe(201);
+		review = reviewResponse.body;
+	});
+
+	test("setAuthorName", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "setAuthorName",
+						authorName: "Jane Smith",
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.authorName).toBe("Jane Smith");
+		expect(response.body.version).toBe(2);
+	});
+
+	test("setTitle", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "setTitle",
+						title: "Amazing product!",
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.title).toBe("Amazing product!");
+		expect(response.body.version).toBe(2);
+	});
+
+	test("setText", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "setText",
+						text: "This product exceeded my expectations!",
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.text).toBe("This product exceeded my expectations!");
+		expect(response.body.version).toBe(2);
+	});
+
+	test("setRating", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "setRating",
+						rating: 4,
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.rating).toBe(4);
+		expect(response.body.version).toBe(2);
+	});
+
+	test("setLocale", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "setLocale",
+						locale: "de-DE",
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.locale).toBe("de-DE");
+		expect(response.body.version).toBe(2);
+	});
+
+	test("setKey", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "setKey",
+						key: "updated-review-key",
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.key).toBe("updated-review-key");
+		expect(response.body.version).toBe(2);
+	});
+
+	test("transitionState", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "transitionState",
+						state: {
+							typeId: "state",
+							id: state.id,
+						},
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.state).toMatchObject({
+			typeId: "state",
+			id: state.id,
+		});
+		expect(response.body.version).toBe(2);
+	});
+
+	test("multiple actions in one update", async () => {
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/reviews/${review.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: "setAuthorName",
+						authorName: "Updated Author",
+					},
+					{
+						action: "setRating",
+						rating: 3,
+					},
+					{
+						action: "setText",
+						text: "Updated review text",
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.authorName).toBe("Updated Author");
+		expect(response.body.rating).toBe(3);
+		expect(response.body.text).toBe("Updated review text");
+		// Version should be incremented by 3 since each action modifies the resource
+		expect(response.body.version).toBe(4);
+	});
+});