@labdigital/commercetools-mock 1.5.0 → 1.6.1

package/src/services/state.ts

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

package/src/services/store.test.ts

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

package/src/services/store.ts

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

package/src/services/subscription.ts

@@ -3,14 +3,14 @@ import { SubscriptionRepository } from '../repositories/subscription.js'
 import AbstractService from './abstract.js'
 
 export class SubscriptionService extends AbstractService {
-  public repository: SubscriptionRepository
+	public repository: SubscriptionRepository
 
-  constructor(parent: Router, repository: SubscriptionRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: SubscriptionRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'subscriptions'
-  }
+	getBasePath() {
+		return 'subscriptions'
+	}
 }

package/src/services/tax-category.test.ts

@@ -6,75 +6,75 @@ import { CommercetoolsMock } from '../index.js'
 const ctMock = new CommercetoolsMock()
 
 describe('Tax Category', () => {
-  afterEach(() => {
-    ctMock.clear()
-  })
-  test('Create tax category', async () => {
-    const draft: TaxCategoryDraft = {
-      name: 'foo',
-      key: 'standard',
-      rates: [],
-    }
-    const response = await supertest(ctMock.app)
-      .post('/dummy/tax-categories')
-      .send(draft)
+	afterEach(() => {
+		ctMock.clear()
+	})
+	test('Create tax category', async () => {
+		const draft: TaxCategoryDraft = {
+			name: 'foo',
+			key: 'standard',
+			rates: [],
+		}
+		const response = await supertest(ctMock.app)
+			.post('/dummy/tax-categories')
+			.send(draft)
 
-    expect(response.status).toBe(201)
+		expect(response.status).toBe(201)
 
-    expect(response.body).toEqual({
-      createdAt: expect.anything(),
-      id: expect.anything(),
-      lastModifiedAt: expect.anything(),
-      name: 'foo',
-      rates: [],
-      key: 'standard',
-      version: 1,
-    })
-  })
+		expect(response.body).toEqual({
+			createdAt: expect.anything(),
+			id: expect.anything(),
+			lastModifiedAt: expect.anything(),
+			name: 'foo',
+			rates: [],
+			key: 'standard',
+			version: 1,
+		})
+	})
 
-  test('Get tax category', async () => {
-    const draft: TaxCategoryDraft = {
-      name: 'foo',
-      key: 'standard',
-      rates: [],
-    }
-    const createResponse = await supertest(ctMock.app)
-      .post('/dummy/tax-categories')
-      .send(draft)
+	test('Get tax category', async () => {
+		const draft: TaxCategoryDraft = {
+			name: 'foo',
+			key: 'standard',
+			rates: [],
+		}
+		const createResponse = await supertest(ctMock.app)
+			.post('/dummy/tax-categories')
+			.send(draft)
 
-    expect(createResponse.status).toBe(201)
+		expect(createResponse.status).toBe(201)
 
-    const response = await supertest(ctMock.app).get(
-      `/dummy/tax-categories/${createResponse.body.id}`
-    )
+		const response = await supertest(ctMock.app).get(
+			`/dummy/tax-categories/${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 tax category with key', async () => {
-    const draft: TaxCategoryDraft = {
-      name: 'foo',
-      key: 'standard',
-      rates: [],
-    }
-    const createResponse = await supertest(ctMock.app)
-      .post('/dummy/tax-categories')
-      .send(draft)
+	test('Get tax category with key', async () => {
+		const draft: TaxCategoryDraft = {
+			name: 'foo',
+			key: 'standard',
+			rates: [],
+		}
+		const createResponse = await supertest(ctMock.app)
+			.post('/dummy/tax-categories')
+			.send(draft)
 
-    expect(createResponse.status).toBe(201)
+		expect(createResponse.status).toBe(201)
 
-    const response = await supertest(ctMock.app)
-      .get(`/dummy/tax-categories/`)
-      .query({ where: `key="${createResponse.body.key}"` })
+		const response = await supertest(ctMock.app)
+			.get(`/dummy/tax-categories/`)
+			.query({ where: `key="${createResponse.body.key}"` })
 
-    expect(response.status).toBe(200)
-    expect(response.body).toEqual({
-      count: 1,
-      limit: 20,
-      offset: 0,
-      total: 1,
-      results: [createResponse.body],
-    })
-  })
+		expect(response.status).toBe(200)
+		expect(response.body).toEqual({
+			count: 1,
+			limit: 20,
+			offset: 0,
+			total: 1,
+			results: [createResponse.body],
+		})
+	})
 })

package/src/services/tax-category.ts

@@ -3,14 +3,14 @@ import { TaxCategoryRepository } from '../repositories/tax-category.js'
 import AbstractService from './abstract.js'
 
 export class TaxCategoryService extends AbstractService {
-  public repository: TaxCategoryRepository
+	public repository: TaxCategoryRepository
 
-  constructor(parent: Router, repository: TaxCategoryRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: TaxCategoryRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'tax-categories'
-  }
+	getBasePath() {
+		return 'tax-categories'
+	}
 }

package/src/services/type.ts

@@ -3,14 +3,14 @@ import { TypeRepository } from '../repositories/type.js'
 import AbstractService from './abstract.js'
 
 export class TypeService extends AbstractService {
-  public repository: TypeRepository
+	public repository: TypeRepository
 
-  constructor(parent: Router, repository: TypeRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: TypeRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'types'
-  }
+	getBasePath() {
+		return 'types'
+	}
 }

package/src/services/zone.ts

@@ -3,14 +3,14 @@ import { ZoneRepository } from '../repositories/zone.js'
 import AbstractService from './abstract.js'
 
 export class ZoneService extends AbstractService {
-  public repository: ZoneRepository
+	public repository: ZoneRepository
 
-  constructor(parent: Router, repository: ZoneRepository) {
-    super(parent)
-    this.repository = repository
-  }
+	constructor(parent: Router, repository: ZoneRepository) {
+		super(parent)
+		this.repository = repository
+	}
 
-  getBasePath() {
-    return 'zones'
-  }
+	getBasePath() {
+		return 'zones'
+	}
 }

package/src/storage/abstract.ts

@@ -1,82 +1,82 @@
 import type {
-    BaseResource,
-    Project,
-    QueryParam,
-    ResourceIdentifier
+	BaseResource,
+	Project,
+	QueryParam,
+	ResourceIdentifier,
 } from '@commercetools/platform-sdk'
 import { PagedQueryResponseMap, ResourceMap, ResourceType } from '../types.js'
 
 export type GetParams = {
-  expand?: string[]
+	expand?: string[]
 }
 
 export type QueryParams = {
-  expand?: string | string[]
-  sort?: string | string[]
-  limit?: number
-  offset?: number
-  withTotal?: boolean
-  where?: string | string[]
-  [key: string]: QueryParam
+	expand?: string | string[]
+	sort?: string | string[]
+	limit?: number
+	offset?: number
+	withTotal?: boolean
+	where?: string | string[]
+	[key: string]: QueryParam
 }
 
 export abstract class AbstractStorage {
-  abstract clear(): void
+	abstract clear(): void
 
-  abstract all<RT extends ResourceType>(
-    projectKey: string,
-    typeId: RT
-  ): Array<ResourceMap[RT]>
+	abstract all<RT extends ResourceType>(
+		projectKey: string,
+		typeId: RT
+	): Array<ResourceMap[RT]>
 
-  abstract add<RT extends ResourceType>(
-    projectKey: string,
-    typeId: RT,
-    obj: ResourceMap[RT]
-  ): void
+	abstract add<RT extends ResourceType>(
+		projectKey: string,
+		typeId: RT,
+		obj: ResourceMap[RT]
+	): void
 
-  abstract get<RT extends ResourceType>(
-    projectKey: string,
-    typeId: RT,
-    id: string,
-    params?: GetParams
-  ): ResourceMap[RT] | null
+	abstract get<RT extends ResourceType>(
+		projectKey: string,
+		typeId: RT,
+		id: string,
+		params?: GetParams
+	): ResourceMap[RT] | null
 
-  abstract getByKey<RT extends ResourceType>(
-    projectKey: string,
-    typeId: RT,
-    key: string,
-    params: GetParams
-  ): ResourceMap[RT] | null
+	abstract getByKey<RT extends ResourceType>(
+		projectKey: string,
+		typeId: RT,
+		key: string,
+		params: GetParams
+	): ResourceMap[RT] | null
 
-  abstract addProject(projectKey: string): Project
-  abstract getProject(projectKey: string): Project
-  abstract saveProject(project: Project): Project
+	abstract addProject(projectKey: string): Project
+	abstract getProject(projectKey: string): Project
+	abstract saveProject(project: Project): Project
 
-  abstract delete<RT extends ResourceType>(
-    projectKey: string,
-    typeId: RT,
-    id: string,
-    params: GetParams
-  ): ResourceMap[RT] | null
+	abstract delete<RT extends ResourceType>(
+		projectKey: string,
+		typeId: RT,
+		id: string,
+		params: GetParams
+	): ResourceMap[RT] | null
 
-  abstract query<RT extends ResourceType>(
-    projectKey: string,
-    typeId: RT,
-    params: QueryParams
-  ): PagedQueryResponseMap[RT]
+	abstract query<RT extends ResourceType>(
+		projectKey: string,
+		typeId: RT,
+		params: QueryParams
+	): PagedQueryResponseMap[RT]
 
-  abstract getByResourceIdentifier<RT extends ResourceType>(
-    projectKey: string,
-    identifier: ResourceIdentifier
-  ): ResourceMap[RT] | null
+	abstract getByResourceIdentifier<RT extends ResourceType>(
+		projectKey: string,
+		identifier: ResourceIdentifier
+	): ResourceMap[RT] | null
 
-  abstract expand<T>(
-    projectKey: string,
-    obj: T,
-    clause: undefined | string | string[]
-  ): T
+	abstract expand<T>(
+		projectKey: string,
+		obj: T,
+		clause: undefined | string | string[]
+	): T
 }
 
 export type ProjectStorage = {
-  [index in ResourceType]: Map<string, BaseResource>
+	[index in ResourceType]: Map<string, BaseResource>
 }