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

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

@@ -2,63 +2,71 @@ import type {
 	Customer,
 	CustomerChangePassword,
 	CustomerToken,
-	MyCustomerDraft,
 } from "@commercetools/platform-sdk";
-import supertest from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { customerDraftFactory } from "#src/testing/index.ts";
 import { CommercetoolsMock, getBaseResourceProperties } from "../index.ts";
 import { hashPassword } from "../lib/password.ts";
 
 const ctMock = new CommercetoolsMock();
 
 describe("Me", () => {
+	const customerFactory = customerDraftFactory(ctMock);
+
 	afterEach(() => {
 		ctMock.clear();
 	});
 
 	test("Create me", async () => {
-		const draft: MyCustomerDraft = {
+		const draft = customerFactory.build({
 			email: "test@example.org",
 			password: "p4ssw0rd",
-		};
+		});
 
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/signup")
-			.send(draft);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/signup",
+			payload: draft,
+		});
 
-		expect(response.status).toBe(201);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(201);
+		expect(response.json()).toEqual({
 			customer: {
-				...draft,
+				email: "test@example.org",
 				password: "cDRzc3cwcmQ=",
-				lowercaseEmail: draft.email.toLowerCase(),
+				lowercaseEmail: "test@example.org",
 				authenticationMode: "Password",
 				version: 1,
 				isEmailVerified: false,
-				addresses: [],
+				addresses: expect.anything(),
 				billingAddressIds: [],
 				shippingAddressIds: [],
 				id: expect.anything(),
 				createdAt: expect.anything(),
+				createdBy: expect.anything(),
 				lastModifiedAt: expect.anything(),
+				lastModifiedBy: expect.anything(),
 				stores: [],
+				customerGroupAssignments: [],
+				firstName: "John",
+				lastName: "Doe",
 			},
 		});
 	});
 
 	test("Get me", async () => {
-		const draft: MyCustomerDraft = {
+		const customer = await customerFactory.create({
 			email: "test@example.org",
 			password: "p4ssw0rd",
-		};
-		const createResponse = await supertest(ctMock.app)
-			.post("/dummy/me/signup")
-			.send(draft);
+		});
 
-		const response = await supertest(ctMock.app).get("/dummy/me");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/me",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual(createResponse.body.customer);
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual(customer);
 	});
 });
 
@@ -68,7 +76,7 @@ describe("/me", () => {
 	});
 
 	beforeEach(() => {
-		ctMock.project("dummy").add("customer", {
+		ctMock.project("dummy").unsafeAdd("customer", {
 			id: "123",
 			createdAt: "2021-03-18T14:00:00.000Z",
 			version: 2,
@@ -79,18 +87,26 @@ describe("/me", () => {
 			authenticationMode: "password",
 			custom: { type: { typeId: "type", id: "" }, fields: {} },
 			stores: [],
+			shippingAddressIds: [],
+			billingAddressIds: [],
+			customerGroupAssignments: [],
 		});
 	});
 
 	test("Get me", async () => {
-		const response = await supertest(ctMock.app).get("/dummy/me");
+		const response = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/me",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual({
 			id: "123",
 			createdAt: "2021-03-18T14:00:00.000Z",
+			createdBy: expect.anything(),
 			version: 2,
 			lastModifiedAt: "2021-03-18T14:00:00.000Z",
+			lastModifiedBy: expect.anything(),
 			email: "foo@example.org",
 			addresses: [],
 			isEmailVerified: true,
@@ -103,18 +119,26 @@ describe("/me", () => {
 				},
 			},
 			stores: [],
+			shippingAddressIds: [],
+			billingAddressIds: [],
+			customerGroupAssignments: [],
 		});
 	});
 
 	test("Delete me", async () => {
-		const response = await supertest(ctMock.app).delete("/dummy/me");
+		const response = await ctMock.app.inject({
+			method: "DELETE",
+			url: "/dummy/me",
+		});
 
-		expect(response.status).toBe(200);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(200);
+		expect(response.json()).toEqual({
 			id: "123",
 			createdAt: "2021-03-18T14:00:00.000Z",
+			createdBy: expect.anything(),
 			version: 2,
 			lastModifiedAt: "2021-03-18T14:00:00.000Z",
+			lastModifiedBy: expect.anything(),
 			email: "foo@example.org",
 			addresses: [],
 			isEmailVerified: true,
@@ -127,10 +151,16 @@ describe("/me", () => {
 				},
 			},
 			stores: [],
+			shippingAddressIds: [],
+			billingAddressIds: [],
+			customerGroupAssignments: [],
 		});
 
-		const newResponse = await supertest(ctMock.app).get("/dummy/me");
-		expect(newResponse.status).toBe(404);
+		const newResponse = await ctMock.app.inject({
+			method: "GET",
+			url: "/dummy/me",
+		});
+		expect(newResponse.statusCode).toBe(404);
 	});
 
 	test("Change my password", async () => {
@@ -144,8 +174,11 @@ describe("/me", () => {
 			authenticationMode: "Password", //default in Commercetools
 			version: 1,
 			stores: [],
+			shippingAddressIds: [],
+			billingAddressIds: [],
+			customerGroupAssignments: [],
 		};
-		ctMock.project("dummy").add("customer", customer);
+		ctMock.project("dummy").unsafeAdd("customer", customer);
 
 		const draft: CustomerChangePassword = {
 			id: customer.id,
@@ -153,11 +186,13 @@ describe("/me", () => {
 			newPassword: "newP4ssw0rd",
 			currentPassword: "p4ssw0rd",
 		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/password")
-			.send(draft);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/password",
+			payload: draft,
+		});
 
-		expect(response.status).toBe(200);
+		expect(response.statusCode).toBe(200);
 	});
 
 	test("Fail to change password", async () => {
@@ -167,12 +202,14 @@ describe("/me", () => {
 			newPassword: "newP4ssw0rd",
 			currentPassword: "p4ssw0rd",
 		};
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/password")
-			.send(draft);
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/password",
+			payload: draft,
+		});
 
-		expect(response.status).toBe(400);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(400);
+		expect(response.json()).toEqual({
 			message: "Account with the given credentials not found.",
 			statusCode: 400,
 			errors: [
@@ -195,34 +232,43 @@ describe("/me", () => {
 			authenticationMode: "Password", //default in Commercetools
 			version: 1,
 			stores: [],
+			shippingAddressIds: [],
+			billingAddressIds: [],
+			customerGroupAssignments: [],
 		};
-		ctMock.project("dummy").add("customer", customer);
+		ctMock.project("dummy").unsafeAdd("customer", customer);
 
-		const token = await supertest(ctMock.app)
-			.post("/dummy/customers/password-token")
-			.send({
+		const tokenResponse = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/customers/password-token",
+			payload: {
 				email: "user@example.com",
-			})
-			.then((response) => response.body as CustomerToken);
+			},
+		});
+		const token = tokenResponse.json() as CustomerToken;
 
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/password/reset")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/password/reset",
+			payload: {
 				tokenValue: token.value,
 				newPassword: "somethingNew",
-			});
-		expect(response.status).toBe(200);
+			},
+		});
+		expect(response.statusCode).toBe(200);
 	});
 
 	test("fail reset password flow", async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/password/reset")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/password/reset",
+			payload: {
 				tokenValue: "invalid-token",
 				newPassword: "somethingNew",
-			});
-		expect(response.status).toBe(400);
-		expect(response.body).toEqual({
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json()).toEqual({
 			message: `The Customer with ID 'Token(invalid-token)' was not found.`,
 			statusCode: 400,
 			errors: [
@@ -245,32 +291,41 @@ describe("/me", () => {
 			authenticationMode: "Password", //default in Commercetools
 			version: 1,
 			stores: [],
+			shippingAddressIds: [],
+			billingAddressIds: [],
+			customerGroupAssignments: [],
 		};
-		ctMock.project("dummy").add("customer", customer);
+		ctMock.project("dummy").unsafeAdd("customer", customer);
 
-		const token = await supertest(ctMock.app)
-			.post("/dummy/customers/email-token")
-			.send({
+		const tokenResponse = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/customers/email-token",
+			payload: {
 				id: "customer-uuid",
-			})
-			.then((response) => response.body as CustomerToken);
+			},
+		});
+		const token = tokenResponse.json() as CustomerToken;
 
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/email/confirm")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/email/confirm",
+			payload: {
 				tokenValue: token.value,
-			});
-		expect(response.status).toBe(200);
+			},
+		});
+		expect(response.statusCode).toBe(200);
 	});
 
 	test("fail verify email flow", async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me/email/confirm")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/email/confirm",
+			payload: {
 				tokenValue: "invalid-token",
-			});
-		expect(response.status).toBe(400);
-		expect(response.body).toEqual({
+			},
+		});
+		expect(response.statusCode).toBe(400);
+		expect(response.json()).toEqual({
 			message: `The Customer with ID 'Token(invalid-token)' was not found.`,
 			statusCode: 400,
 			errors: [
@@ -283,31 +338,41 @@ describe("/me", () => {
 	});
 
 	test("setCustomField", async () => {
-		const response = await supertest(ctMock.app)
-			.post("/dummy/me")
-			.send({
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me",
+			payload: {
 				version: 2,
 				actions: [{ action: "setCustomField", name: "foobar", value: true }],
-			});
-		expect(response.status).toBe(200);
-		expect(response.body.version).toBe(3);
-		expect(response.body.custom.fields.foobar).toBe(true);
+			},
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().version).toBe(3);
+		expect(response.json().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();
+		const response = await ctMock.app.inject({
+			method: "DELETE",
+			url: "/dummy/me",
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().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",
+		const response = await ctMock.app.inject({
+			method: "POST",
+			url: "/dummy/me/login",
+			payload: {
+				email: "nonexistent@example.com",
+				password: "wrongpassword",
+			},
 		});
 
-		expect(response.status).toBe(400);
-		expect(response.body).toEqual({
+		expect(response.statusCode).toBe(400);
+		expect(response.json()).toEqual({
+			statusCode: 400,
 			message: "Account with the given credentials not found.",
 			errors: [
 				{

package/src/services/my-customer.ts

@@ -1,6 +1,14 @@
-import type { Update } from "@commercetools/platform-sdk";
-import type { Request, Response } from "express";
-import { Router } from "express";
+import type {
+	MyCustomerChangePassword,
+	MyCustomerDraft,
+	MyCustomerEmailVerify,
+	MyCustomerResetPassword,
+	MyCustomerSignin,
+	ResourceNotFoundError,
+	Update,
+} from "@commercetools/platform-sdk";
+import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import { updateRequestSchema } from "#src/schemas/update-request.ts";
 import { validateData } from "#src/validate.ts";
 import { hashPassword } from "../lib/password.ts";
@@ -11,7 +19,7 @@ import AbstractService from "./abstract.ts";
 export class MyCustomerService extends AbstractService {
 	public repository: MyCustomerRepository;
 
-	constructor(parent: Router, repository: MyCustomerRepository) {
+	constructor(parent: FastifyInstance, repository: MyCustomerRepository) {
 		super(parent);
 		this.repository = repository;
 	}
@@ -20,126 +28,187 @@ export class MyCustomerService extends AbstractService {
 		return "me";
 	}
 
-	registerRoutes(parent: Router) {
+	registerRoutes(parent: FastifyInstance) {
 		// Overwrite this function to be able to handle /me path.
 		const basePath = this.getBasePath();
-		const router = Router({ mergeParams: true });
+		parent.register(
+			(instance, opts, done) => {
+				this.extraRoutes(instance);
 
-		this.extraRoutes(router);
+				instance.get("", this.getMe.bind(this));
+				instance.post("", this.updateMe.bind(this));
+				instance.delete("", this.deleteMe.bind(this));
 
-		router.get("", this.getMe.bind(this));
-		router.post("", this.updateMe.bind(this));
-		router.delete("", this.deleteMe.bind(this));
+				instance.post("/signup", this.signUp.bind(this));
 
-		router.post("/signup", this.signUp.bind(this));
+				instance.post("/login", this.signIn.bind(this));
+				instance.post("/password", this.changePassword.bind(this));
+				instance.post("/password/reset", this.resetPassword.bind(this));
+				instance.post("/email/confirm", this.emailConfirm.bind(this));
 
-		router.post("/login", this.signIn.bind(this));
-		router.post("/password", this.changePassword.bind(this));
-		router.post("/password/reset", this.resetPassword.bind(this));
-		router.post("/email/confirm", this.emailConfirm.bind(this));
-
-		parent.use(`/${basePath}`, router);
+				done();
+			},
+			{ prefix: `/${basePath}` },
+		);
 	}
 
-	getMe(request: Request, response: Response) {
-		const resource = this.repository.getMe(getRepositoryContext(request));
+	async getMe(
+		request: FastifyRequest<{ Params: Record<string, string> }>,
+		reply: FastifyReply,
+	) {
+		const resource = await this.repository.getMe(getRepositoryContext(request));
 		if (!resource) {
-			response.status(404).send({ statusCode: 404 });
-			return;
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: "The Resource was not found.",
+				},
+				404,
+			);
 		}
-		response.status(200).send(resource);
+		return reply.status(200).send(resource);
 	}
 
-	updateMe(request: Request, response: Response) {
-		const resource = this.repository.getMe(getRepositoryContext(request));
+	async updateMe(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Querystring: Record<string, any>;
+		}>,
+		reply: FastifyReply,
+	) {
+		const resource = await this.repository.getMe(getRepositoryContext(request));
 
 		if (!resource) {
-			response.status(404).send({ statusCode: 404 });
-			return;
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: "The Resource was not found.",
+				},
+				404,
+			);
 		}
 		const updateRequest = validateData<Update>(
 			request.body,
 			updateRequestSchema,
 		);
-		const updatedResource = this.repository.processUpdateActions(
+		const updatedResource = await this.repository.processUpdateActions(
 			getRepositoryContext(request),
 			resource,
 			updateRequest.version,
 			updateRequest.actions,
 		);
 
-		const result = this._expandWithId(request, updatedResource.id);
-		response.status(200).send(result);
+		const result = await this._expandWithId(request, updatedResource.id);
+		return reply.status(200).send(result);
 	}
 
-	deleteMe(request: Request, response: Response) {
-		const resource = this.repository.deleteMe(getRepositoryContext(request));
+	async deleteMe(
+		request: FastifyRequest<{ Params: Record<string, string> }>,
+		reply: FastifyReply,
+	) {
+		const resource = await this.repository.deleteMe(
+			getRepositoryContext(request),
+		);
 		if (!resource) {
-			response.status(404).send({ statusCode: 404 });
-			return;
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: "The Resource was not found.",
+				},
+				404,
+			);
 		}
 
-		response.status(200).send(resource);
+		return reply.status(200).send(resource);
 	}
 
-	signUp(request: Request, response: Response) {
+	async signUp(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Querystring: Record<string, any>;
+			Body: MyCustomerDraft;
+		}>,
+		reply: FastifyReply,
+	) {
 		const draft = request.body;
-		const resource = this.repository.create(
+		const resource = await this.repository.create(
 			getRepositoryContext(request),
 			draft,
 		);
-		const result = this._expandWithId(request, resource.id);
-		response.status(this.createStatusCode).send({ customer: result });
+		const result = await this._expandWithId(request, resource.id);
+		return reply.status(this.createStatusCode).send({ customer: result });
 	}
 
-	changePassword(request: Request, response: Response) {
-		const customer = this.repository.changePassword(
+	async changePassword(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: MyCustomerChangePassword;
+		}>,
+		reply: FastifyReply,
+	) {
+		const customer = await this.repository.changePassword(
 			getRepositoryContext(request),
 			request.body,
 		);
 
-		response.status(200).send(customer);
+		return reply.status(200).send(customer);
 	}
 
-	resetPassword(request: Request, response: Response) {
-		const customer = this.repository.passwordReset(
+	async resetPassword(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: MyCustomerResetPassword;
+		}>,
+		reply: FastifyReply,
+	) {
+		const customer = await this.repository.passwordReset(
 			getRepositoryContext(request),
 			request.body,
 		);
 
-		response.status(200).send(customer);
+		return reply.status(200).send(customer);
 	}
 
-	emailConfirm(request: Request, response: Response) {
-		const customer = this.repository.confirmEmail(
+	async emailConfirm(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: MyCustomerEmailVerify;
+		}>,
+		reply: FastifyReply,
+	) {
+		const customer = await this.repository.confirmEmail(
 			getRepositoryContext(request),
 			request.body,
 		);
 
-		response.status(200).send(customer);
+		return reply.status(200).send(customer);
 	}
 
-	signIn(request: Request, response: Response) {
-		const { email, password } = request.body;
+	async signIn(
+		request: FastifyRequest<{
+			Params: Record<string, string>;
+			Body: MyCustomerSignin;
+		}>,
+		reply: FastifyReply,
+	) {
+		const body = request.body;
+		const { email, password } = body;
 		const encodedPassword = hashPassword(password);
 
-		const result = this.repository.query(getRepositoryContext(request), {
+		const result = await this.repository.query(getRepositoryContext(request), {
 			where: [`email = "${email}"`, `password = "${encodedPassword}"`],
 		});
 
 		if (result.count === 0) {
-			response.status(400).send({
-				message: "Account with the given credentials not found.",
-				errors: [
-					{
-						code: "InvalidCredentials",
-						message: "Account with the given credentials not found.",
-					},
-				],
-			});
-			return;
+			throw new CommercetoolsError<any>(
+				{
+					code: "InvalidCredentials",
+					message: "Account with the given credentials not found.",
+				},
+				400,
+			);
 		}
 
-		response.status(200).send({ customer: result.results[0] });
+		return reply.status(200).send({ customer: result.results[0] });
 	}
 }