@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/services/product.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import { ProductRepository } from '../repositories/product.js'
-import AbstractService from './abstract.js'
+import { Router } from "express";
+import { ProductRepository } from "../repositories/product";
+import AbstractService from "./abstract";
 
 export class ProductService extends AbstractService {
-	public repository: ProductRepository
+	public repository: ProductRepository;
 
 	constructor(parent: Router, repository: ProductRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'products'
+		return "products";
 	}
 }

package/src/services/project.test.ts

@@ -1,27 +1,27 @@
-import type { Project } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { Project } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('Project', () => {
+describe("Project", () => {
 	beforeAll(() => {
-		ctMock.start()
-	})
+		ctMock.start();
+	});
 
 	afterEach(() => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
 	afterAll(() => {
-		ctMock.stop()
-	})
+		ctMock.stop();
+	});
 
-	test('Get project by key', async () => {
-		const response = await supertest(ctMock.app).get('/dummy/')
+	test("Get project by key", async () => {
+		const response = await supertest(ctMock.app).get("/dummy/");
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 		expect(response.body).toEqual({
 			version: 1,
 			carts: {
@@ -29,24 +29,29 @@ describe('Project', () => {
 				deleteDaysAfterLastModification: 90,
 			},
 			countries: [],
-			createdAt: '2018-10-04T11:32:12.603Z',
+			createdAt: "2018-10-04T11:32:12.603Z",
 			currencies: [],
-			key: 'dummy',
+			key: "dummy",
 			languages: [],
 			messages: {
 				deleteDaysAfterCreation: 15,
 				enabled: false,
 			},
-			name: '',
+			name: "",
 			searchIndexing: {
 				orders: {
-					status: 'Deactivated',
+					status: "Deactivated",
 				},
 				products: {
-					status: 'Deactivated',
+					status: "Deactivated",
 				},
 			},
-			trialUntil: '2018-12',
-		} as Project)
-	})
-})
+			trialUntil: "2018-12",
+		} as Project);
+	});
+
+	test("Post empty update ", async () => {
+		const response = await supertest(ctMock.app).post("/dummy/");
+		expect(response.statusCode).toBe(400);
+	});
+});

package/src/services/project.ts

@@ -1,41 +1,46 @@
-import type { Update } from '@commercetools/platform-sdk'
-import { Request, Response, Router } from 'express'
-import { getRepositoryContext } from '../repositories/helpers.js'
-import { ProjectRepository } from '../repositories/project.js'
+import { Update } from "@commercetools/platform-sdk";
+import { Request, Response, Router } from "express";
+import { updateRequestSchema } from "~src/schemas/update-request";
+import { validateData } from "~src/validate";
+import { getRepositoryContext } from "../repositories/helpers";
+import { ProjectRepository } from "../repositories/project";
 
 export class ProjectService {
-	public repository: ProjectRepository
+	public repository: ProjectRepository;
 
 	constructor(parent: Router, repository: ProjectRepository) {
-		this.repository = repository
-		this.registerRoutes(parent)
+		this.repository = repository;
+		this.registerRoutes(parent);
 	}
 
 	registerRoutes(parent: Router) {
-		parent.get('', this.get.bind(this))
-		parent.post('', this.post.bind(this))
+		parent.get("", this.get.bind(this));
+		parent.post("", this.post.bind(this));
 	}
 
 	get(request: Request, response: Response) {
-		const project = this.repository.get(getRepositoryContext(request))
-		return response.status(200).send(project)
+		const project = this.repository.get(getRepositoryContext(request));
+		return response.status(200).send(project);
 	}
 
 	post(request: Request, response: Response) {
-		const updateRequest: Update = request.body
-		const project = this.repository.get(getRepositoryContext(request))
+		const updateRequest = validateData<Update>(
+			request.body,
+			updateRequestSchema,
+		);
+		const project = this.repository.get(getRepositoryContext(request));
 
 		if (!project) {
-			return response.status(404).send({})
+			return response.status(404).send({});
 		}
 
 		const updatedResource = this.repository.processUpdateActions(
 			getRepositoryContext(request),
 			project,
 			updateRequest.version,
-			updateRequest.actions
-		)
+			updateRequest.actions,
+		);
 
-		return response.status(200).send(updatedResource)
+		return response.status(200).send(updatedResource);
 	}
 }

package/src/services/reviews.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import AbstractService from './abstract.js'
-import { ReviewRepository } from '../repositories/review.js'
+import { Router } from "express";
+import { ReviewRepository } from "../repositories/review";
+import AbstractService from "./abstract";
 
 export class ReviewService extends AbstractService {
-	public repository: ReviewRepository
+	public repository: ReviewRepository;
 
 	constructor(parent: Router, repository: ReviewRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'reviews'
+		return "reviews";
 	}
 }

package/src/services/shipping-method.test.ts

@@ -4,190 +4,190 @@ import type {
 	ShippingMethodDraft,
 	TaxCategoryDraft,
 	ZoneDraft,
-} from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
-import { isType } from '../types.js'
+} from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
+import { isType } from "../types";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('Shipping method', () => {
+describe("Shipping method", () => {
 	beforeEach(async () => {
 		await supertest(ctMock.app)
-			.post('/dummy/tax-categories')
+			.post("/dummy/tax-categories")
 			.send(
 				isType<TaxCategoryDraft>({
-					name: 'foo',
-					key: 'standard',
+					name: "foo",
+					key: "standard",
 					rates: [],
-				})
+				}),
 			)
 			.then((res) => {
-				expect(res.status).toEqual(201)
-			})
+				expect(res.status).toEqual(201);
+			});
 
 		await supertest(ctMock.app)
-			.post('/dummy/zones')
+			.post("/dummy/zones")
 			.send(
 				isType<ZoneDraft>({
-					name: 'The Netherlands',
-					key: 'NL',
+					name: "The Netherlands",
+					key: "NL",
 					locations: [
 						{
-							country: 'NL',
+							country: "NL",
 						},
 					],
-				})
+				}),
 			)
 			.then((res) => {
-				expect(res.status).toEqual(201)
-			})
-	})
+				expect(res.status).toEqual(201);
+			});
+	});
 
 	afterEach(async () => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
-	test('Create shipping method', async () => {
+	test("Create shipping method", async () => {
 		const draft: ShippingMethodDraft = {
-			name: 'foo',
-			taxCategory: { typeId: 'tax-category', key: 'standard' },
+			name: "foo",
+			taxCategory: { typeId: "tax-category", key: "standard" },
 			isDefault: true,
 			zoneRates: [],
-		}
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/shipping-methods')
-			.send(draft)
+			.post("/dummy/shipping-methods")
+			.send(draft);
 
-		expect(response.status).toBe(201)
+		expect(response.status).toBe(201);
 
 		expect(response.body).toEqual({
 			createdAt: expect.anything(),
 			id: expect.anything(),
 			isDefault: true,
 			lastModifiedAt: expect.anything(),
-			name: 'foo',
+			name: "foo",
 			taxCategory: {
 				id: expect.anything(),
-				typeId: 'tax-category',
+				typeId: "tax-category",
 			},
 			version: 1,
 			zoneRates: [],
-		})
-	})
+		});
+	});
 
-	test('Get shipping method', async () => {
+	test("Get shipping method", async () => {
 		const draft: ShippingMethodDraft = {
-			name: 'foo',
-			taxCategory: { typeId: 'tax-category', key: 'standard' },
+			name: "foo",
+			taxCategory: { typeId: "tax-category", key: "standard" },
 			isDefault: true,
 			zoneRates: [],
-		}
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/shipping-methods')
-			.send(draft)
+			.post("/dummy/shipping-methods")
+			.send(draft);
 
-		expect(createResponse.status).toBe(201)
+		expect(createResponse.status).toBe(201);
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/shipping-methods/${createResponse.body.id}`
-		)
+			`/dummy/shipping-methods/${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 shipping methods matching cart', async () => {
+	test("Get shipping methods matching cart", async () => {
 		const cart = await supertest(ctMock.app)
-			.post('/dummy/carts')
+			.post("/dummy/carts")
 			.send(
 				isType<CartDraft>({
-					currency: 'EUR',
+					currency: "EUR",
 					shippingAddress: {
-						country: 'NL',
+						country: "NL",
 					},
-				})
+				}),
 			)
-			.then((res) => res.body as Cart)
+			.then((res) => res.body as Cart);
 
 		await supertest(ctMock.app)
-			.post('/dummy/shipping-methods')
+			.post("/dummy/shipping-methods")
 			.send(
 				isType<ShippingMethodDraft>({
-					name: 'NL',
-					taxCategory: { typeId: 'tax-category', key: 'standard' },
+					name: "NL",
+					taxCategory: { typeId: "tax-category", key: "standard" },
 					isDefault: true,
 					zoneRates: [
 						{
 							zone: {
-								typeId: 'zone',
-								key: 'NL',
+								typeId: "zone",
+								key: "NL",
 							},
 							shippingRates: [
 								{
 									price: {
-										currencyCode: 'EUR',
+										currencyCode: "EUR",
 										centAmount: 495,
 									},
 								},
 							],
 						},
 					],
-				})
+				}),
 			)
 			.then((res) => {
-				expect(res.status).toEqual(201)
-			})
+				expect(res.status).toEqual(201);
+			});
 
 		await supertest(ctMock.app)
-			.post('/dummy/shipping-methods')
+			.post("/dummy/shipping-methods")
 			.send(
 				isType<ShippingMethodDraft>({
-					name: 'NL/GBP',
-					taxCategory: { typeId: 'tax-category', key: 'standard' },
+					name: "NL/GBP",
+					taxCategory: { typeId: "tax-category", key: "standard" },
 					isDefault: true,
 					zoneRates: [
 						{
 							zone: {
-								typeId: 'zone',
-								key: 'NL',
+								typeId: "zone",
+								key: "NL",
 							},
 							shippingRates: [
 								{
 									price: {
-										currencyCode: 'GBP',
+										currencyCode: "GBP",
 										centAmount: 495,
 									},
 								},
 							],
 						},
 					],
-				})
+				}),
 			)
 			.then((res) => {
-				expect(res.status).toEqual(201)
-			})
+				expect(res.status).toEqual(201);
+			});
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/shipping-methods/matching-cart?cartId=${cart.id}`
-		)
+			`/dummy/shipping-methods/matching-cart?cartId=${cart.id}`,
+		);
 
-		expect(response.status, JSON.stringify(response.body)).toBe(200)
+		expect(response.status, JSON.stringify(response.body)).toBe(200);
 		expect(response.body).toMatchObject({
 			count: 1,
 			limit: 20,
 			offset: 0,
 			results: [
 				{
-					name: 'NL',
+					name: "NL",
 					zoneRates: [
 						{
 							shippingRates: [
 								{
 									isMatching: true,
 									price: {
-										currencyCode: 'EUR',
+										currencyCode: "EUR",
 										centAmount: 495,
 									},
 								},
@@ -197,6 +197,6 @@ describe('Shipping method', () => {
 				},
 			],
 			total: 1,
-		})
-	})
-})
+		});
+	});
+});

package/src/services/shipping-method.ts

@@ -1,38 +1,38 @@
-import { Request, Response, Router } from 'express'
-import { ShippingMethodRepository } from '../repositories/shipping-method.js'
-import AbstractService from './abstract.js'
-import { getRepositoryContext } from '../repositories/helpers.js'
-import { queryParamsValue } from '../helpers.js'
+import { Request, Response, Router } from "express";
+import { queryParamsValue } from "../helpers";
+import { getRepositoryContext } from "../repositories/helpers";
+import { ShippingMethodRepository } from "../repositories/shipping-method";
+import AbstractService from "./abstract";
 
 export class ShippingMethodService extends AbstractService {
-	public repository: ShippingMethodRepository
+	public repository: ShippingMethodRepository;
 
 	constructor(parent: Router, repository: ShippingMethodRepository) {
-		super(parent)
-		this.repository = repository
-		this.registerRoutes(parent)
+		super(parent);
+		this.repository = repository;
+		this.registerRoutes(parent);
 	}
 
 	getBasePath() {
-		return 'shipping-methods'
+		return "shipping-methods";
 	}
 
 	extraRoutes(parent: Router) {
-		parent.get('/matching-cart', this.matchingCart.bind(this))
+		parent.get("/matching-cart", this.matchingCart.bind(this));
 	}
 
 	matchingCart(request: Request, response: Response) {
-		const cartId = queryParamsValue(request.query.cartId)
+		const cartId = queryParamsValue(request.query.cartId);
 		if (!cartId) {
-			return response.status(400).send()
+			return response.status(400).send();
 		}
 		const result = this.repository.matchingCart(
 			getRepositoryContext(request),
 			cartId,
 			{
 				expand: this._parseParam(request.query.expand),
-			}
-		)
-		return response.status(200).send(result)
+			},
+		);
+		return response.status(200).send(result);
 	}
 }