@labdigital/commercetools-mock 2.17.1 → 2.18.1

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

@@ -1,99 +1,99 @@
-import type { Cart, MyCartDraft } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { Cart, MyCartDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('MyCart', () => {
+describe("MyCart", () => {
 	beforeEach(async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/types')
+			.post("/dummy/types")
 			.send({
-				key: 'custom-payment',
+				key: "custom-payment",
 				name: {
-					'nl-NL': 'custom-payment',
+					"nl-NL": "custom-payment",
 				},
-				resourceTypeIds: ['payment'],
-			})
-		expect(response.status).toBe(201)
-	})
+				resourceTypeIds: ["payment"],
+			});
+		expect(response.status).toBe(201);
+	});
 
 	afterEach(() => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
-	test('Create my cart', async () => {
+	test("Create my cart", async () => {
 		const draft: MyCartDraft = {
-			currency: 'EUR',
-		}
+			currency: "EUR",
+		};
 
 		const response = await supertest(ctMock.app)
-			.post('/dummy/me/carts')
-			.send(draft)
+			.post("/dummy/me/carts")
+			.send(draft);
 
-		expect(response.status).toBe(201)
+		expect(response.status).toBe(201);
 		expect(response.body).toEqual({
 			id: expect.anything(),
 			createdAt: expect.anything(),
 			lastModifiedAt: expect.anything(),
 			version: 1,
-			cartState: 'Active',
+			cartState: "Active",
 			discountCodes: [],
 			directDiscounts: [],
-			inventoryMode: 'None',
+			inventoryMode: "None",
 			itemShippingAddresses: [],
 			lineItems: [],
 			customLineItems: [],
 			shipping: [],
-			shippingMode: 'Single',
+			shippingMode: "Single",
 			totalPrice: {
-				type: 'centPrecision',
+				type: "centPrecision",
 				centAmount: 0,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				fractionDigits: 0,
 			},
-			taxMode: 'Platform',
-			taxRoundingMode: 'HalfEven',
-			taxCalculationMode: 'LineItemLevel',
+			taxMode: "Platform",
+			taxRoundingMode: "HalfEven",
+			taxCalculationMode: "LineItemLevel",
 			refusedGifts: [],
-			origin: 'Customer',
-		} as Cart)
-	})
+			origin: "Customer",
+		} as Cart);
+	});
 
-	test('Get my cart by ID', async () => {
+	test("Get my cart by ID", async () => {
 		const draft: MyCartDraft = {
-			currency: 'EUR',
-		}
+			currency: "EUR",
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/me/carts')
-			.send(draft)
+			.post("/dummy/me/carts")
+			.send(draft);
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/me/carts/${createResponse.body.id}`
-		)
+			`/dummy/me/carts/${createResponse.body.id}`,
+		);
 
-		expect(response.status).toBe(200)
-		expect(response.body).toEqual(createResponse.body)
-	})
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
 
-	test('Get my active cart', async () => {
+	test("Get my active cart", async () => {
 		const draft: MyCartDraft = {
-			currency: 'EUR',
-		}
+			currency: "EUR",
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/me/carts')
-			.send(draft)
+			.post("/dummy/me/carts")
+			.send(draft);
 
-		const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`)
+		const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`);
 
-		expect(response.status).toBe(200)
-		expect(response.body).toEqual(createResponse.body)
-	})
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
 
-	test('Get my active cart which doesnt exists', async () => {
-		const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`)
+	test("Get my active cart which doesnt exists", async () => {
+		const response = await supertest(ctMock.app).get(`/dummy/me/active-cart`);
 
-		expect(response.status).toBe(404)
-	})
-})
+		expect(response.status).toBe(404);
+	});
+});

package/src/services/my-cart.ts

@@ -1,43 +1,43 @@
-import { Request, Response, Router } from 'express'
-import { CartRepository } from '../repositories/cart.js'
-import AbstractService from './abstract.js'
+import { Request, Response, Router } from "express";
+import { CartRepository } from "../repositories/cart";
+import AbstractService from "./abstract";
 
 export class MyCartService extends AbstractService {
-	public repository: CartRepository
+	public repository: CartRepository;
 
 	constructor(parent: Router, repository: CartRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'me'
+		return "me";
 	}
 
 	registerRoutes(parent: Router) {
 		// Overwrite this function to be able to handle /me/active-cart path.
-		const basePath = this.getBasePath()
-		const router = Router({ mergeParams: true })
+		const basePath = this.getBasePath();
+		const router = Router({ mergeParams: true });
 
-		this.extraRoutes(router)
+		this.extraRoutes(router);
 
-		router.get('/active-cart', this.activeCart.bind(this))
-		router.get('/carts/', this.get.bind(this))
-		router.get('/carts/:id', this.getWithId.bind(this))
+		router.get("/active-cart", this.activeCart.bind(this));
+		router.get("/carts/", this.get.bind(this));
+		router.get("/carts/:id", this.getWithId.bind(this));
 
-		router.delete('/carts/:id', this.deleteWithId.bind(this))
+		router.delete("/carts/:id", this.deleteWithId.bind(this));
 
-		router.post('/carts/', this.post.bind(this))
-		router.post('/carts/:id', this.postWithId.bind(this))
+		router.post("/carts/", this.post.bind(this));
+		router.post("/carts/:id", this.postWithId.bind(this));
 
-		parent.use(`/${basePath}`, router)
+		parent.use(`/${basePath}`, router);
 	}
 
 	activeCart(request: Request, response: Response) {
-		const resource = this.repository.getActiveCart(request.params.projectKey)
+		const resource = this.repository.getActiveCart(request.params.projectKey);
 		if (!resource) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
-		return response.status(200).send(resource)
+		return response.status(200).send(resource);
 	}
 }

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

@@ -1,35 +1,36 @@
 import type {
 	CustomerChangePassword,
+	CustomerToken,
 	MyCustomerDraft,
-} from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock, getBaseResourceProperties } from '../index.js'
-import { hashPassword } from '../lib/password.js'
+} from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock, getBaseResourceProperties } from "../index";
+import { hashPassword } from "../lib/password";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('Me', () => {
+describe("Me", () => {
 	afterEach(() => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
-	test('Create me', async () => {
+	test("Create me", async () => {
 		const draft: MyCustomerDraft = {
-			email: 'test@example.org',
-			password: 'p4ssw0rd',
-		}
+			email: "test@example.org",
+			password: "p4ssw0rd",
+		};
 
 		const response = await supertest(ctMock.app)
-			.post('/dummy/me/signup')
-			.send(draft)
+			.post("/dummy/me/signup")
+			.send(draft);
 
-		expect(response.status).toBe(201)
+		expect(response.status).toBe(201);
 		expect(response.body).toEqual({
 			customer: {
 				...draft,
-				password: 'cDRzc3cwcmQ=',
-				authenticationMode: 'Password',
+				password: "cDRzc3cwcmQ=",
+				authenticationMode: "Password",
 				version: 1,
 				isEmailVerified: false,
 				addresses: [],
@@ -37,151 +38,201 @@ describe('Me', () => {
 				createdAt: expect.anything(),
 				lastModifiedAt: expect.anything(),
 			},
-		})
-	})
+		});
+	});
 
-	test('Get me', async () => {
+	test("Get me", async () => {
 		const draft: MyCustomerDraft = {
-			email: 'test@example.org',
-			password: 'p4ssw0rd',
-		}
+			email: "test@example.org",
+			password: "p4ssw0rd",
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/me/signup')
-			.send(draft)
+			.post("/dummy/me/signup")
+			.send(draft);
 
-		const response = await supertest(ctMock.app).get(`/dummy/me`)
+		const response = await supertest(ctMock.app).get(`/dummy/me`);
 
-		expect(response.status).toBe(200)
-		expect(response.body).toEqual(createResponse.body.customer)
-	})
-})
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body.customer);
+	});
+});
 
-describe('/me', () => {
+describe("/me", () => {
 	afterEach(() => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
 	beforeEach(() => {
-		ctMock.project('dummy').add('customer', {
-			id: '123',
-			createdAt: '2021-03-18T14:00:00.000Z',
+		ctMock.project("dummy").add("customer", {
+			id: "123",
+			createdAt: "2021-03-18T14:00:00.000Z",
 			version: 2,
-			lastModifiedAt: '2021-03-18T14:00:00.000Z',
-			email: 'foo@example.org',
+			lastModifiedAt: "2021-03-18T14:00:00.000Z",
+			email: "foo@example.org",
 			addresses: [],
 			isEmailVerified: true,
-			authenticationMode: 'password',
-			custom: { type: { typeId: 'type', id: '' }, fields: {} },
-		})
-	})
+			authenticationMode: "password",
+			custom: { type: { typeId: "type", id: "" }, fields: {} },
+		});
+	});
 
-	test('Get me', async () => {
-		const response = await supertest(ctMock.app).get('/dummy/me')
+	test("Get me", async () => {
+		const response = await supertest(ctMock.app).get("/dummy/me");
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 		expect(response.body).toEqual({
-			id: '123',
-			createdAt: '2021-03-18T14:00:00.000Z',
+			id: "123",
+			createdAt: "2021-03-18T14:00:00.000Z",
 			version: 2,
-			lastModifiedAt: '2021-03-18T14:00:00.000Z',
-			email: 'foo@example.org',
+			lastModifiedAt: "2021-03-18T14:00:00.000Z",
+			email: "foo@example.org",
 			addresses: [],
 			isEmailVerified: true,
-			authenticationMode: 'password',
+			authenticationMode: "password",
 			custom: {
 				fields: {},
 				type: {
-					id: '',
-					typeId: 'type',
+					id: "",
+					typeId: "type",
 				},
 			},
-		})
-	})
+		});
+	});
 
-	test('Delete me', async () => {
-		const response = await supertest(ctMock.app).delete('/dummy/me')
+	test("Delete me", async () => {
+		const response = await supertest(ctMock.app).delete("/dummy/me");
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 		expect(response.body).toEqual({
-			id: '123',
-			createdAt: '2021-03-18T14:00:00.000Z',
+			id: "123",
+			createdAt: "2021-03-18T14:00:00.000Z",
 			version: 2,
-			lastModifiedAt: '2021-03-18T14:00:00.000Z',
-			email: 'foo@example.org',
+			lastModifiedAt: "2021-03-18T14:00:00.000Z",
+			email: "foo@example.org",
 			addresses: [],
 			isEmailVerified: true,
-			authenticationMode: 'password',
+			authenticationMode: "password",
 			custom: {
 				fields: {},
 				type: {
-					id: '',
-					typeId: 'type',
+					id: "",
+					typeId: "type",
 				},
 			},
-		})
+		});
 
-		const newResponse = await supertest(ctMock.app).get('/dummy/me')
-		expect(newResponse.status).toBe(404)
-	})
+		const newResponse = await supertest(ctMock.app).get("/dummy/me");
+		expect(newResponse.status).toBe(404);
+	});
 
-	test('Change my password', async () => {
+	test("Change my password", async () => {
 		const customer = {
 			...getBaseResourceProperties(),
-			id: 'customer-uuid',
-			email: 'user@example.com',
-			password: hashPassword('p4ssw0rd'),
+			id: "customer-uuid",
+			email: "user@example.com",
+			password: hashPassword("p4ssw0rd"),
 			addresses: [],
 			isEmailVerified: true,
-			authenticationMode: 'Password', //default in Commercetools
+			authenticationMode: "Password", //default in Commercetools
 			version: 1,
-		}
-		ctMock.project('dummy').add('customer', customer)
+		};
+		ctMock.project("dummy").add("customer", customer);
 
 		const draft: CustomerChangePassword = {
 			id: customer.id,
 			version: customer.version,
-			newPassword: 'newP4ssw0rd',
-			currentPassword: 'p4ssw0rd',
-		}
+			newPassword: "newP4ssw0rd",
+			currentPassword: "p4ssw0rd",
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/me/password')
-			.send(draft)
+			.post("/dummy/me/password")
+			.send(draft);
 
-		expect(response.status).toBe(200)
-	})
+		expect(response.status).toBe(200);
+	});
 
-	test('Fail to change password', async () => {
+	test("Fail to change password", async () => {
 		const draft: CustomerChangePassword = {
-			id: 'foo',
+			id: "foo",
 			version: 1,
-			newPassword: 'newP4ssw0rd',
-			currentPassword: 'p4ssw0rd',
-		}
+			newPassword: "newP4ssw0rd",
+			currentPassword: "p4ssw0rd",
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/me/password')
-			.send(draft)
+			.post("/dummy/me/password")
+			.send(draft);
 
-		expect(response.status).toBe(404)
+		expect(response.status).toBe(400);
 		expect(response.body).toEqual({
+			message: "Account with the given credentials not found.",
+			statusCode: 400,
 			errors: [
 				{
-					code: 'InvalidCurrentPassword',
-					message: 'Account with the given credentials not found.',
+					code: "InvalidCurrentPassword",
+					message: "Account with the given credentials not found.",
 				},
 			],
-			message: 'Account with the given credentials not found.',
-		})
-	})
+		});
+	});
+
+	test("reset password flow", async () => {
+		const customer = {
+			...getBaseResourceProperties(),
+			id: "customer-uuid",
+			email: "user@example.com",
+			password: hashPassword("p4ssw0rd"),
+			addresses: [],
+			isEmailVerified: true,
+			authenticationMode: "Password", //default in Commercetools
+			version: 1,
+		};
+		ctMock.project("dummy").add("customer", customer);
+
+		const token = await supertest(ctMock.app)
+			.post("/dummy/customers/password-token")
+			.send({
+				email: "user@example.com",
+			})
+			.then((response) => response.body as CustomerToken);
 
-	test('setCustomField', async () => {
+		const response = await supertest(ctMock.app)
+			.post("/dummy/me/password/reset")
+			.send({
+				tokenValue: token.value,
+				newPassword: "somethingNew",
+			});
+		expect(response.status).toBe(200);
+	});
+
+	test("fail reset password flow", async () => {
+		const response = await supertest(ctMock.app)
+			.post("/dummy/me/password/reset")
+			.send({
+				tokenValue: "invalid-token",
+				newPassword: "somethingNew",
+			});
+		expect(response.status).toBe(400);
+		expect(response.body).toEqual({
+			message: `The Customer with ID 'Token(invalid-token)' was not found.`,
+			statusCode: 400,
+			errors: [
+				{
+					code: "ResourceNotFound",
+					message: `The Customer with ID 'Token(invalid-token)' was not found.`,
+				},
+			],
+		});
+	});
+
+	test("setCustomField", async () => {
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/me`)
 			.send({
 				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)
-	})
-})
+				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);
+	});
+});