@labdigital/commercetools-mock 2.17.1 → 2.18.0

package/src/services/standalone-price.test.ts

@@ -1,5 +1,5 @@
-import type { StandalonePriceDraft } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
+import type { StandalonePriceDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
 import {
 	afterAll,
 	afterEach,
@@ -8,279 +8,279 @@ import {
 	describe,
 	expect,
 	test,
-} from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+} from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('Standalone price Query', () => {
+describe("Standalone price Query", () => {
 	beforeAll(async () => {
 		const draft: StandalonePriceDraft = {
 			value: {
 				centAmount: 100,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 			},
-			country: 'DE',
-			sku: 'foo',
+			country: "DE",
+			sku: "foo",
 			active: true,
 			channel: {
-				typeId: 'channel',
-				id: 'bar',
+				typeId: "channel",
+				id: "bar",
 			},
 			discounted: {
 				value: {
 					centAmount: 80,
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 				},
 				discount: {
-					typeId: 'product-discount',
-					id: 'baz',
+					typeId: "product-discount",
+					id: "baz",
 				},
 			},
-		}
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/standalone-prices')
-			.send(draft)
-		expect(createResponse.status).toEqual(201)
-	})
+			.post("/dummy/standalone-prices")
+			.send(draft);
+		expect(createResponse.status).toEqual(201);
+	});
 
 	afterAll(async () => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
-	test('Get standalone price', async () => {
+	test("Get standalone price", async () => {
 		const response = await supertest(ctMock.app).get(
-			'/dummy/standalone-prices?sku=foo'
-		)
+			"/dummy/standalone-prices?sku=foo",
+		);
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 
 		expect(response.body.results).toEqual([
 			{
 				active: true,
 				channel: {
-					id: 'bar',
-					typeId: 'channel',
+					id: "bar",
+					typeId: "channel",
 				},
-				country: 'DE',
+				country: "DE",
 				createdAt: expect.anything(),
 				discounted: {
 					discount: {
-						id: 'baz',
-						typeId: 'product-discount',
+						id: "baz",
+						typeId: "product-discount",
 					},
 					value: {
 						centAmount: 80,
-						currencyCode: 'EUR',
+						currencyCode: "EUR",
 						fractionDigits: 2,
-						type: 'centPrecision',
+						type: "centPrecision",
 					},
 				},
 				id: expect.anything(),
 				lastModifiedAt: expect.anything(),
-				sku: 'foo',
+				sku: "foo",
 				value: {
 					centAmount: 100,
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 					fractionDigits: 2,
-					type: 'centPrecision',
+					type: "centPrecision",
 				},
 				version: 1,
 			},
-		])
-	})
-})
+		]);
+	});
+});
 
-describe('Standalone price Actions', () => {
-	let id: string | undefined
+describe("Standalone price Actions", () => {
+	let id: string | undefined;
 	beforeEach(async () => {
 		const draft: StandalonePriceDraft = {
 			value: {
 				centAmount: 100,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 			},
-			country: 'DE',
-			sku: 'foo',
+			country: "DE",
+			sku: "foo",
 			active: true,
 			channel: {
-				typeId: 'channel',
-				id: 'bar',
+				typeId: "channel",
+				id: "bar",
 			},
-		}
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/standalone-prices')
-			.send(draft)
-		expect(createResponse.status).toEqual(201)
-		id = createResponse.body.id
-	})
+			.post("/dummy/standalone-prices")
+			.send(draft);
+		expect(createResponse.status).toEqual(201);
+		id = createResponse.body.id;
+	});
 
 	afterEach(async () => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
-	test('changeValue', async () => {
+	test("changeValue", async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/standalone-prices/' + id)
+			.post("/dummy/standalone-prices/" + id)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'changeValue',
+						action: "changeValue",
 						value: {
 							centAmount: 200,
-							currencyCode: 'EUR',
+							currencyCode: "EUR",
 						},
 					},
 				],
-			})
+			});
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 
 		expect(response.body).toEqual({
 			active: true,
 			channel: {
-				id: 'bar',
-				typeId: 'channel',
+				id: "bar",
+				typeId: "channel",
 			},
-			country: 'DE',
+			country: "DE",
 			createdAt: expect.anything(),
 			id: id,
 			lastModifiedAt: expect.anything(),
-			sku: 'foo',
+			sku: "foo",
 			value: {
 				centAmount: 200,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				fractionDigits: 2,
-				type: 'centPrecision',
+				type: "centPrecision",
 			},
 			version: 2,
-		})
-	})
+		});
+	});
 
-	test('setActive', async () => {
+	test("setActive", async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/standalone-prices/' + id)
+			.post("/dummy/standalone-prices/" + id)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setActive',
+						action: "setActive",
 						active: false,
 					},
 				],
-			})
+			});
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 
 		expect(response.body).toEqual({
 			active: false,
 			channel: {
-				id: 'bar',
-				typeId: 'channel',
+				id: "bar",
+				typeId: "channel",
 			},
-			country: 'DE',
+			country: "DE",
 			createdAt: expect.anything(),
 			id: id,
 			lastModifiedAt: expect.anything(),
-			sku: 'foo',
+			sku: "foo",
 			value: {
 				centAmount: 100,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				fractionDigits: 2,
-				type: 'centPrecision',
+				type: "centPrecision",
 			},
 			version: 2,
-		})
-	})
+		});
+	});
 
-	test('setDiscounted', async () => {
+	test("setDiscounted", async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/standalone-prices/' + id)
+			.post("/dummy/standalone-prices/" + id)
 			.send({
 				version: 1,
 				actions: [
 					{
-						action: 'setDiscountedPrice',
+						action: "setDiscountedPrice",
 						discounted: {
 							value: {
 								centAmount: 80,
-								currencyCode: 'EUR',
+								currencyCode: "EUR",
 							},
 							discount: {
-								typeId: 'product-discount',
-								id: 'baz',
+								typeId: "product-discount",
+								id: "baz",
 							},
 						},
 					},
 				],
-			})
+			});
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 
 		expect(response.body).toEqual({
 			active: true,
 			channel: {
-				id: 'bar',
-				typeId: 'channel',
+				id: "bar",
+				typeId: "channel",
 			},
-			country: 'DE',
+			country: "DE",
 			createdAt: expect.anything(),
 			discounted: {
 				discount: {
-					id: 'baz',
-					typeId: 'product-discount',
+					id: "baz",
+					typeId: "product-discount",
 				},
 				value: {
 					centAmount: 80,
-					currencyCode: 'EUR',
+					currencyCode: "EUR",
 					fractionDigits: 2,
-					type: 'centPrecision',
+					type: "centPrecision",
 				},
 			},
 			id: id,
 			lastModifiedAt: expect.anything(),
-			sku: 'foo',
+			sku: "foo",
 			value: {
 				centAmount: 100,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				fractionDigits: 2,
-				type: 'centPrecision',
+				type: "centPrecision",
 			},
 			version: 2,
-		})
+		});
 
 		const response2 = await supertest(ctMock.app)
-			.post('/dummy/standalone-prices/' + id)
+			.post("/dummy/standalone-prices/" + id)
 			.send({
 				version: 2,
 				actions: [
 					{
-						action: 'setDiscountedPrice',
+						action: "setDiscountedPrice",
 						discounted: null,
 					},
 				],
-			})
+			});
 
-		expect(response2.status).toBe(200)
+		expect(response2.status).toBe(200);
 
 		expect(response2.body).toEqual({
 			active: true,
 			channel: {
-				id: 'bar',
-				typeId: 'channel',
+				id: "bar",
+				typeId: "channel",
 			},
-			country: 'DE',
+			country: "DE",
 			createdAt: expect.anything(),
 			id: id,
 			lastModifiedAt: expect.anything(),
-			sku: 'foo',
+			sku: "foo",
 			value: {
 				centAmount: 100,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				fractionDigits: 2,
-				type: 'centPrecision',
+				type: "centPrecision",
 			},
 			version: 3,
-		})
-	})
-})
+		});
+	});
+});

package/src/services/standalone-price.ts

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

package/src/services/state.test.ts

@@ -1,51 +1,51 @@
-import { type StateDraft } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import { type StateDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('State', () => {
-	test('Create state', async () => {
+describe("State", () => {
+	test("Create state", async () => {
 		const draft: StateDraft = {
-			key: 'foo',
-			type: 'PaymentState',
-		}
+			key: "foo",
+			type: "PaymentState",
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/states')
-			.send(draft)
+			.post("/dummy/states")
+			.send(draft);
 
-		expect(response.status).toBe(201)
+		expect(response.status).toBe(201);
 
 		expect(response.body).toEqual({
 			builtIn: false,
 			createdAt: expect.anything(),
 			id: expect.anything(),
 			initial: false,
-			key: 'foo',
+			key: "foo",
 			lastModifiedAt: expect.anything(),
 			transitions: [],
-			type: 'PaymentState',
+			type: "PaymentState",
 			version: 1,
-		})
-	})
+		});
+	});
 
-	test('Get state', async () => {
+	test("Get state", async () => {
 		const draft: StateDraft = {
-			key: 'foo',
-			type: 'PaymentState',
-		}
+			key: "foo",
+			type: "PaymentState",
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/states')
-			.send(draft)
+			.post("/dummy/states")
+			.send(draft);
 
-		expect(createResponse.status).toBe(201)
+		expect(createResponse.status).toBe(201);
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/states/${createResponse.body.id}`
-		)
+			`/dummy/states/${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);
+	});
+});

package/src/services/state.ts

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

package/src/services/store.test.ts

@@ -1,74 +1,74 @@
-import type { Store } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { Store } 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('Store', () => {
+describe("Store", () => {
 	beforeAll(() => {
-		ctMock.start()
-	})
+		ctMock.start();
+	});
 
 	afterEach(() => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
 	afterAll(() => {
-		ctMock.stop()
-	})
+		ctMock.stop();
+	});
 
-	test('Get store by key', async () => {
-		ctMock.project('dummy').add('store', {
-			id: 'fake-store',
+	test("Get store by key", async () => {
+		ctMock.project("dummy").add("store", {
+			id: "fake-store",
 			version: 1,
-			createdAt: '',
-			lastModifiedAt: '',
-			key: 'STOREKEY',
+			createdAt: "",
+			lastModifiedAt: "",
+			key: "STOREKEY",
 			countries: [],
 			languages: [],
 			distributionChannels: [],
 			supplyChannels: [],
 			productSelections: [],
-		})
+		});
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/stores/key=STOREKEY`
-		)
+			`/dummy/stores/key=STOREKEY`,
+		);
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 		expect(response.body).toEqual({
 			version: 1,
-			createdAt: '',
-			id: 'fake-store',
-			key: 'STOREKEY',
-			lastModifiedAt: '',
+			createdAt: "",
+			id: "fake-store",
+			key: "STOREKEY",
+			lastModifiedAt: "",
 			countries: [],
 			languages: [],
 			distributionChannels: [],
 			supplyChannels: [],
 			productSelections: [],
-		} as Store)
-	})
+		} as Store);
+	});
 
-	test('Get store by 404 when not found by key', async () => {
-		ctMock.project('dummy').add('store', {
-			id: 'fake-store',
+	test("Get store by 404 when not found by key", async () => {
+		ctMock.project("dummy").add("store", {
+			id: "fake-store",
 			version: 1,
-			createdAt: '',
-			lastModifiedAt: '',
-			key: 'STOREKEY',
+			createdAt: "",
+			lastModifiedAt: "",
+			key: "STOREKEY",
 			countries: [],
 			languages: [],
 			distributionChannels: [],
 			supplyChannels: [],
 			productSelections: [],
-		})
+		});
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/stores/key=DOESNOTEXIST`
-		)
+			`/dummy/stores/key=DOESNOTEXIST`,
+		);
 
-		expect(response.status).toBe(404)
-	})
-})
+		expect(response.status).toBe(404);
+	});
+});

package/src/services/store.ts

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