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

package/src/services/customer.ts

@@ -1,5 +1,13 @@
-import type { CustomerSignInResult } from "@commercetools/platform-sdk";
-import type { Request, Response, Router } from "express";
+import type {
+	CustomerCreateEmailToken,
+	CustomerCreatePasswordResetToken,
+	CustomerDraft,
+	CustomerEmailVerify,
+	CustomerResetPassword,
+	CustomerSignInResult,
+} from "@commercetools/platform-sdk";
+import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+import { validateDraft } from "#src/validate.ts";
 import type { CustomerRepository } from "../repositories/customer/index.ts";
 import { getRepositoryContext } from "../repositories/helpers.ts";
 import AbstractService from "./abstract.ts";
@@ -7,7 +15,7 @@ import AbstractService from "./abstract.ts";
 export class CustomerService extends AbstractService {
 	public repository: CustomerRepository;
 
-	constructor(parent: Router, repository: CustomerRepository) {
+	constructor(parent: FastifyInstance, repository: CustomerRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -16,57 +24,96 @@ export class CustomerService extends AbstractService {
 		return "customers";
 	}
 
-	extraRoutes(parent: Router) {
+	extraRoutes(parent: FastifyInstance) {
 		parent.post("/password-token", this.passwordResetToken.bind(this));
 		parent.post("/password/reset", this.passwordReset.bind(this));
 		parent.post("/email-token", this.emailToken.bind(this));
 		parent.post("/email/confirm", this.emailTokenConfirm.bind(this));
 	}
 
-	post(request: Request, response: Response) {
-		const draft = request.body;
-		const resource = this.repository.create(
+	async post(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Querystring: Record<string, any>;
+			Body: CustomerDraft;
+		}>,
+		reply: FastifyReply,
+	) {
+		// Validate the draft against the schema when strict mode is enabled
+		if (this.repository.strict && this.repository.draftSchema) {
+			validateDraft(request.body, this.repository.draftSchema);
+		}
+
+		const resource = await this.repository.create(
 			getRepositoryContext(request),
-			draft,
+			request.body,
 		);
-		const expanded = this._expandWithId(request, resource.id);
+		const expanded = await this._expandWithId(request, resource.id);
 
 		const result: CustomerSignInResult = {
 			customer: expanded,
 		};
-		response.status(this.createStatusCode).send(result);
+		return reply.status(this.createStatusCode).send(result);
 	}
 
-	passwordResetToken(request: Request, response: Response) {
-		const customer = this.repository.passwordResetToken(
+	async passwordResetToken(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: CustomerCreatePasswordResetToken;
+		}>,
+		reply: FastifyReply,
+	) {
+		const customer = await this.repository.passwordResetToken(
 			getRepositoryContext(request),
 			request.body,
 		);
 
-		response.status(200).send(customer);
+		return reply.status(200).send(customer);
 	}
 
-	passwordReset(request: Request, response: Response) {
-		const customer = this.repository.passwordReset(
+	async passwordReset(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: CustomerResetPassword;
+		}>,
+		reply: FastifyReply,
+	) {
+		const customer = await this.repository.passwordReset(
 			getRepositoryContext(request),
 			request.body,
 		);
 
-		response.status(200).send(customer);
+		return reply.status(200).send(customer);
 	}
 
-	emailToken(request: Request, response: Response) {
-		const id = request.body.id;
-		const token = this.repository.emailToken(getRepositoryContext(request), id);
-		response.status(200).send(token);
+	async emailToken(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: CustomerCreateEmailToken;
+		}>,
+		reply: FastifyReply,
+	) {
+		const body = request.body;
+		const id = body.id;
+		const token = await this.repository.emailToken(
+			getRepositoryContext(request),
+			id,
+		);
+		return reply.status(200).send(token);
 	}
 
-	emailTokenConfirm(request: Request, response: Response) {
-		const customer = this.repository.emailTokenConfirm(
+	async emailTokenConfirm(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: CustomerEmailVerify;
+		}>,
+		reply: FastifyReply,
+	) {
+		const customer = await this.repository.emailTokenConfirm(
 			getRepositoryContext(request),
 			request.body,
 		);
 
-		response.status(200).send(customer);
+		return reply.status(200).send(customer);
 	}
 }

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

@@ -1,67 +1,67 @@
-import type { DiscountCodeDraft } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { describe, expect, test } from "vitest";
+import {
+	cartDiscountDraftFactory,
+	discountCodeDraftFactory,
+} from "#src/testing/index.ts";
 import { CommercetoolsMock } from "../index.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("DiscountCode", () => {
-	test("Create discount code", async () => {
-		// First create a cart discount to reference
-		const cartDiscountResponse = await supertest(ctMock.app)
-			.post("/dummy/cart-discounts")
-			.send({
-				key: "test-cart-discount",
-				name: {
-					en: "Test Cart Discount",
-				},
-				value: {
-					type: "relative",
-					permyriad: 1000,
-				},
-				cartPredicate: "1 = 1",
-				target: {
-					type: "totalPrice",
-				},
-				sortOrder: "0.1",
-			});
+	const cartDiscountFactory = cartDiscountDraftFactory(ctMock);
+	const discountCodeFactory = discountCodeDraftFactory(ctMock);
 
-		expect(cartDiscountResponse.status).toBe(201);
+	test("Create discount code", async () => {
+		const cartDiscount = await cartDiscountFactory.create({
+			key: "test-cart-discount",
+			name: { en: "Test Cart Discount" },
+			value: {
+				type: "relative",
+				permyriad: 1000,
+			},
+			cartPredicate: "1 = 1",
+			target: {
+				type: "totalPrice",
+			},
+			sortOrder: "0.1",
+		});
 
-		const draft: DiscountCodeDraft = {
+		const draft = discountCodeFactory.build({
 			key: "SAVE10",
 			code: "SAVE10",
-			name: {
-				en: "Save 10% Discount",
-			},
+			name: { en: "Save 10% Discount" },
 			cartDiscounts: [
 				{
 					typeId: "cart-discount",
-					id: cartDiscountResponse.body.id,
+					id: cartDiscount.id,
 				},
 			],
 			isActive: true,
-		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/discount-codes")
-			.send(draft);
+		});
 
-		expect(response.status).toBe(201);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/discount-codes",
+			payload: draft,
+		});
 
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual({
 			applicationVersion: 1,
 			cartDiscounts: [
 				{
-					id: cartDiscountResponse.body.id,
+					id: cartDiscount.id,
 					typeId: "cart-discount",
 				},
 			],
 			code: "SAVE10",
 			createdAt: expect.anything(),
+			createdBy: expect.anything(),
 			groups: [],
 			id: expect.anything(),
 			isActive: true,
 			lastModifiedAt: expect.anything(),
+			lastModifiedBy: expect.anything(),
 			name: {
 				en: "Save 10% Discount",
 			},
@@ -71,50 +71,39 @@ describe("DiscountCode", () => {
 	});
 
 	test("Get discount code", async () => {
-		// First create a cart discount to reference
-		const cartDiscountResponse = await supertest(ctMock.app)
-			.post("/dummy/cart-discounts")
-			.send({
-				key: "test-cart-discount-2",
-				name: {
-					en: "Test Cart Discount 2",
-				},
-				value: {
-					type: "relative",
-					permyriad: 500,
-				},
-				cartPredicate: "1 = 1",
-				target: {
-					type: "totalPrice",
-				},
-				sortOrder: "0.1",
-			});
+		const cartDiscount = await cartDiscountFactory.create({
+			key: "test-cart-discount-2",
+			name: { en: "Test Cart Discount 2" },
+			value: {
+				type: "relative",
+				permyriad: 500,
+			},
+			cartPredicate: "1 = 1",
+			target: {
+				type: "totalPrice",
+			},
+			sortOrder: "0.1",
+		});
 
-		const draft: DiscountCodeDraft = {
+		const discountCode = await discountCodeFactory.create({
 			key: "TEST10",
 			code: "TEST10",
-			name: {
-				en: "Test Discount",
-			},
+			name: { en: "Test Discount" },
 			cartDiscounts: [
 				{
 					typeId: "cart-discount",
-					id: cartDiscountResponse.body.id,
+					id: cartDiscount.id,
 				},
 			],
 			isActive: true,
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/discount-codes")
-			.send(draft);
-
-		expect(createResponse.status).toBe(201);
+		});
 
-		const response = await supertest(ctMock.app).get(
-			`/dummy/discount-codes/${createResponse.body.id}`,
-		);
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: `/dummy/discount-codes/${discountCode.id}`,
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(discountCode);
 	});
 });

package/src/services/discount-code.ts

@@ -1,11 +1,11 @@
-import type { Router } from "express";
+import type { FastifyInstance } from "fastify";
 import type { DiscountCodeRepository } from "../repositories/discount-code/index.ts";
 import AbstractService from "./abstract.ts";
 
 export class DiscountCodeService extends AbstractService {
 	public repository: DiscountCodeRepository;
 
-	constructor(parent: Router, repository: DiscountCodeRepository) {
+	constructor(parent: FastifyInstance, repository: DiscountCodeRepository) {
 		super(parent);
 		this.repository = repository;
 	}