@fox-hound-tools/refine-library
Version:
Refine sdk library
690 lines • 34 kB
JavaScript
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { createDataProvider } from '../../../src/refine/provider/data-provider';
describe('DataProvider', () => {
const mockById = {
get: vi.fn(), // getOne
patch: vi.fn(), // updateOne
delete: vi.fn(), // deleteOne
};
const mockClient = {
v1: {
test: {
get: vi.fn(), // getList, getMany
post: vi.fn(), // createOne
put: vi.fn(), // createMany
patch: vi.fn(), // updateMany
delete: vi.fn(), // deleteMany
byId: vi.fn(() => mockById),
},
cameleCase: {
get: vi.fn(), // getList, getMany
post: vi.fn(), // createOne
put: vi.fn(), // createMany
patch: vi.fn(), // updateMany
delete: vi.fn(), // deleteMany
byId: vi.fn(() => mockById),
},
custom: {
get: vi.fn(), // custom
post: vi.fn(), // custom
},
},
};
const nestedMockClient = {
v1: {
byParentId: vi.fn(() => {
return mockClient.v1;
}),
},
};
beforeEach(() => {
vi.clearAllMocks();
});
const dataProvider = createDataProvider(mockClient);
const nestedDataProvider = createDataProvider(nestedMockClient);
describe('getList', () => {
it('should call client get method with correct parameters', async () => {
mockClient.v1.test.get.mockResolvedValueOnce({ value: [{ id: 1 }] });
const response = await dataProvider.getList({
resource: 'test',
pagination: { current: 1, pageSize: 10 },
sorters: [{ field: 'id', order: 'asc' }],
filters: [{ field: 'name', operator: 'eq', value: 'test' }],
meta: { version: 'v1' },
});
expect(mockClient.v1.test.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
page: 1,
pageSize: 10,
orders: ['id.asc'],
filters: ['name.eq.test'],
},
});
expect(response).toEqual({ data: [{ id: 1 }], total: 1 });
});
it('should call client get method with correct parameters when nested', async () => {
mockClient.v1.test.get.mockResolvedValueOnce({ value: [{ id: 1 }] });
const response = await nestedDataProvider.getList({
resource: '{parentId}/test',
pagination: { current: 1, pageSize: 10 },
sorters: [{ field: 'id', order: 'asc' }],
filters: [{ field: 'name', operator: 'eq', value: 'test' }],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
page: 1,
pageSize: 10,
orders: ['id.asc'],
filters: ['name.eq.test'],
},
});
expect(response).toEqual({ data: [{ id: 1 }], total: 1 });
});
it('should call client get method with correct parameters for camelCase resource', async () => {
mockClient.v1.cameleCase.get.mockResolvedValueOnce({ value: [{ id: 1 }] });
const response = await dataProvider.getList({
resource: 'camele-case',
pagination: { current: 1, pageSize: 10 },
sorters: [{ field: 'id', order: 'asc' }],
filters: [{ field: 'name', operator: 'eq', value: 'test' }],
meta: { version: 'v1' },
});
expect(mockClient.v1.cameleCase.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
page: 1,
pageSize: 10,
orders: ['id.asc'],
filters: ['name.eq.test'],
},
});
expect(response).toEqual({ data: [{ id: 1 }], total: 1 });
});
it('should call client get method with correct parameters for nested camelCase resource', async () => {
mockClient.v1.cameleCase.get.mockResolvedValueOnce({ value: [{ id: 1 }] });
const response = await nestedDataProvider.getList({
resource: '{parentId}/camele-case',
pagination: { current: 1, pageSize: 10 },
sorters: [{ field: 'id', order: 'asc' }],
filters: [{ field: 'name', operator: 'eq', value: 'test' }],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
page: 1,
pageSize: 10,
orders: ['id.asc'],
filters: ['name.eq.test'],
},
});
expect(response).toEqual({ data: [{ id: 1 }], total: 1 });
});
});
describe('getMany', () => {
it('should call client get method with correct parameters', async () => {
mockClient.v1.test.get.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.getMany({
resource: 'test',
ids: [1, 2],
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.test.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
filters: ['id.in.(1,2)'],
},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client get method with correct parameters when nested', async () => {
mockClient.v1.test.get.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.getMany({
resource: '{parentId}/test',
ids: [1, 2],
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 2 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(2);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
filters: ['id.in.(1,2)'],
},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client get method with correct parameters for camelCase resource', async () => {
mockClient.v1.cameleCase.get.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.getMany({
resource: 'camele-case',
ids: [1, 2],
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.cameleCase.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
filters: ['id.in.(1,2)'],
},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client get method with correct parameters for nested camelCase resource', async () => {
mockClient.v1.cameleCase.get.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.getMany({
resource: '{parentId}/camele-case',
ids: [1, 2],
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 2 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(2);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
filters: ['id.in.(1,2)'],
},
});
expect(response).toEqual({
data: [{ id: 1 }, { id: 2 }],
});
});
});
describe('getOne', () => {
it('should call client get method with correct parameters', async () => {
mockById.get.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.getOne({
resource: 'test',
id: 1,
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.test.byId).toHaveBeenCalledWith(1);
expect(mockById.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client get method with correct parameters when nested', async () => {
mockById.get.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.getOne({
resource: '{parentId}/test',
id: 1,
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.byId).toHaveBeenCalledWith(1);
expect(mockClient.v1.test.byId).toBeCalledTimes(1);
expect(mockById.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client get method with correct parameters for camelCase resource', async () => {
mockById.get.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.getOne({
resource: 'camele-case',
id: 1,
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.cameleCase.byId).toHaveBeenCalledWith(1);
expect(mockById.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client get method with correct parameters for nested camelCase resource', async () => {
mockById.get.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.getOne({
resource: '{parentId}/camele-case',
id: 1,
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.byId).toHaveBeenCalledWith(1);
expect(mockById.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
});
describe('create', () => {
it('should call client post method with correct parameters', async () => {
mockClient.v1.test.post.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.create({
resource: 'test',
variables: { name: 'test' },
meta: { version: 'v1' },
});
expect(mockClient.v1.test.post).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client post method with correct parameters when nested', async () => {
mockClient.v1.test.post.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.create({
resource: '{parentId}/test',
variables: { name: 'test' },
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.post).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client post method with correct parameters for camelCase resource', async () => {
mockClient.v1.cameleCase.post.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.create({
resource: 'camele-case',
variables: { name: 'test' },
meta: { version: 'v1' },
});
expect(mockClient.v1.cameleCase.post).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client post method with correct parameters for nested camelCase resource', async () => {
mockClient.v1.cameleCase.post.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.create({
resource: '{parentId}/camele-case',
variables: { name: 'test' },
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.post).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
});
describe('createMany', () => {
it('should call client post method with correct parameters', async () => {
mockClient.v1.test.put.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.createMany({
resource: 'test',
variables: [{ name: 'test' }, { name: 'test2' }],
meta: { version: 'v1' },
});
expect(mockClient.v1.test.put).toHaveBeenCalledWith({ value: [{ name: 'test' }, { name: 'test2' }] }, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client post method with correct parameters when nested', async () => {
mockClient.v1.test.put.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.createMany({
resource: '{parentId}/test',
variables: [{ name: 'test' }, { name: 'test2' }],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.put).toHaveBeenCalledWith({ value: [{ name: 'test' }, { name: 'test2' }] }, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client post method with correct parameters for camelCase resource', async () => {
mockClient.v1.cameleCase.put.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.createMany({
resource: 'camele-case',
variables: [{ name: 'test' }, { name: 'test2' }],
meta: { version: 'v1' },
});
expect(mockClient.v1.cameleCase.put).toHaveBeenCalledWith({ value: [{ name: 'test' }, { name: 'test2' }] }, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client post method with correct parameters for nested camelCase resource', async () => {
mockClient.v1.cameleCase.put.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.createMany({
resource: '{parentId}/camele-case',
variables: [{ name: 'test' }, { name: 'test2' }],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.put).toHaveBeenCalledWith({ value: [{ name: 'test' }, { name: 'test2' }] }, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
});
describe('update', () => {
it('should call client patch method with correct parameters', async () => {
mockById.patch.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.update({
resource: 'test',
id: 1,
variables: { name: 'test' },
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.test.byId).toHaveBeenCalledWith(1);
expect(mockClient.v1.test.byId).toBeCalledTimes(1);
expect(mockById.patch).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client patch method with correct parameters when nested', async () => {
mockById.patch.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.update({
resource: '{parentId}/test',
id: 1,
variables: { name: 'test' },
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.byId).toHaveBeenCalledWith(1);
expect(mockClient.v1.test.byId).toBeCalledTimes(1);
expect(mockById.patch).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client patch method with correct parameters for camelCase resource', async () => {
mockById.patch.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.update({
resource: 'camele-case',
id: 1,
variables: { name: 'test' },
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.cameleCase.byId).toHaveBeenCalledWith(1);
expect(mockById.patch).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client patch method with correct parameters for nested camelCase resource', async () => {
mockById.patch.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.update({
resource: '{parentId}/camele-case',
id: 1,
variables: { name: 'test' },
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.byId).toHaveBeenCalledWith(1);
expect(mockById.patch).toHaveBeenCalledWith({ name: 'test' }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { id: 1 } });
});
});
describe('updateMany', () => {
it('should call client patch method with correct parameters', async () => {
mockClient.v1.test.patch.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.updateMany({
resource: 'test',
ids: [],
variables: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
meta: { version: 'v1' },
});
expect(mockClient.v1.test.patch).toHaveBeenCalledWith({
value: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
}, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client patch method with correct parameters when nested', async () => {
mockClient.v1.test.patch.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.updateMany({
resource: '{parentId}/test',
ids: [],
variables: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.patch).toHaveBeenCalledWith({
value: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
}, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should throw an error when ids are provided', async () => {
await expect(dataProvider.updateMany({
resource: 'test',
ids: [1, 2],
variables: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
meta: { version: 'v1' },
})).rejects.toThrow('Update many does not support filtering by ids');
});
it('should throw an error when variables does not array', async () => {
await expect(dataProvider.updateMany({
resource: 'test',
ids: [],
variables: { id: 1, name: 'test' },
meta: { version: 'v1' },
})).rejects.toThrow('Update many does not support updating single record');
});
it('should call client patch method with correct parameters for camelCase resource', async () => {
mockClient.v1.cameleCase.patch.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.updateMany({
resource: 'camele-case',
ids: [],
variables: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
meta: { version: 'v1' },
});
expect(mockClient.v1.cameleCase.patch).toHaveBeenCalledWith({
value: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
}, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client patch method with correct parameters for nested camelCase resource', async () => {
mockClient.v1.cameleCase.patch.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.updateMany({
resource: '{parentId}/camele-case',
ids: [],
variables: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.patch).toHaveBeenCalledWith({
value: [
{ id: 1, name: 'test' },
{ id: 2, name: 'test2' },
],
}, {
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
});
describe('deleteOne', () => {
it('should call client delete method with correct parameters', async () => {
mockById.delete.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.deleteOne({
resource: 'test',
id: 1,
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.test.byId).toHaveBeenCalledWith(1);
expect(mockClient.v1.test.byId).toBeCalledTimes(1);
expect(mockById.delete).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client delete method with correct parameters when nested', async () => {
mockById.delete.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.deleteOne({
resource: '{parentId}/test',
id: 1,
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.byId).toHaveBeenCalledWith(1);
expect(mockClient.v1.test.byId).toBeCalledTimes(1);
expect(mockById.delete).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client delete method with correct parameters for camelCase resource', async () => {
mockById.delete.mockResolvedValueOnce({ id: 1 });
const response = await dataProvider.deleteOne({
resource: 'camele-case',
id: 1,
meta: { version: 'v1', idColumnName: 'id' },
});
expect(mockClient.v1.cameleCase.byId).toHaveBeenCalledWith(1);
expect(mockById.delete).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
it('should call client delete method with correct parameters for nested camelCase resource', async () => {
mockById.delete.mockResolvedValueOnce({ id: 1 });
const response = await nestedDataProvider.deleteOne({
resource: '{parentId}/camele-case',
id: 1,
meta: { version: 'v1', idColumnName: 'id', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.byId).toHaveBeenCalledWith(1);
expect(mockById.delete).toHaveBeenCalledWith({
headers: {},
queryParameters: {},
});
expect(response).toEqual({ data: { id: 1 } });
});
});
describe('deleteMany', () => {
it('should call client delete method with correct parameters', async () => {
mockClient.v1.test.delete.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.deleteMany({
resource: 'test',
ids: [1, 2],
meta: { version: 'v1' },
});
expect(mockClient.v1.test.delete).toHaveBeenCalledWith({ ids: [1, 2] }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client delete method with correct parameters when nested', async () => {
mockClient.v1.test.delete.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.deleteMany({
resource: '{parentId}/test',
ids: [1, 2],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
variables: { flag: true },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.test.delete).toHaveBeenCalledWith({ ids: [1, 2], flag: true }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client delete method with correct parameters for camelCase resource', async () => {
mockClient.v1.cameleCase.delete.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.deleteMany({
resource: 'camele-case',
ids: [1, 2],
meta: { version: 'v1' },
});
expect(mockClient.v1.cameleCase.delete).toHaveBeenCalledWith({ ids: [1, 2] }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: [{ id: 1 }, { id: 2 }] });
});
it('should call client delete method with correct parameters for nested camelCase resource', async () => {
mockClient.v1.cameleCase.delete.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.deleteMany({
resource: '{parentId}/camele-case',
ids: [1, 2],
meta: { version: 'v1', parentKeys: { parentId: 1 } },
variables: { flag: true },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.cameleCase.delete).toHaveBeenCalledWith({ ids: [1, 2], flag: true }, { headers: {}, queryParameters: {} });
expect(response).toEqual({
data: [{ id: 1 }, { id: 2 }],
});
});
});
describe('custom', () => {
it('should call client custom method with correct parameters', async () => {
mockClient.v1.custom.get.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await dataProvider.custom({
url: 'custom',
method: 'get',
meta: { version: 'v1' },
sorters: [{ field: 'id', order: 'asc' }],
filters: [{ field: 'name', operator: 'eq', value: 'test' }],
});
expect(mockClient.v1.custom.get).toHaveBeenCalledWith({
headers: {},
queryParameters: {
orders: ['id.asc'],
filters: ['name.eq.test'],
},
});
expect(response).toEqual({ data: { value: [{ id: 1 }, { id: 2 }] } });
});
it('should call client custom method with correct parameters when nested', async () => {
mockClient.v1.custom.post.mockResolvedValueOnce({ value: [{ id: 1 }, { id: 2 }] });
const response = await nestedDataProvider.custom({
url: '{parentId}/custom',
method: 'post',
payload: { flag: true },
meta: { version: 'v1', parentKeys: { parentId: 1 } },
});
expect(nestedMockClient.v1.byParentId).toHaveBeenCalledWith(1);
expect(nestedMockClient.v1.byParentId).toBeCalledTimes(1);
expect(mockClient.v1.custom.post).toHaveBeenCalledWith({ flag: true }, { headers: {}, queryParameters: {} });
expect(response).toEqual({ data: { value: [{ id: 1 }, { id: 2 }] } });
});
it.each(['head', 'options'])('should throw an error when method is %s', async (method) => {
await expect(dataProvider.custom({
url: 'custom',
method,
meta: { version: 'v1' },
})).rejects.toThrow('Method not allowed');
});
});
});
//# sourceMappingURL=data-provider.spec.js.map