1506 lines
43 KiB
JavaScript
1506 lines
43 KiB
JavaScript
import { getClientWithToken } from '../apollo/client';
|
||
import * as GQL from '../types';
|
||
import { ERRORS as BASE_ERRORS } from './base';
|
||
import { ServicesService } from './services';
|
||
import { ERRORS, SlotsService } from './slots';
|
||
import dayjs from 'dayjs';
|
||
import duration from 'dayjs/plugin/duration';
|
||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
||
|
||
if (!dayjs.prototype.duration) {
|
||
dayjs.extend(duration);
|
||
}
|
||
|
||
vi.mock('../apollo/client');
|
||
vi.mock('./services');
|
||
vi.mock('../config/env', () => {
|
||
return {
|
||
env: {
|
||
BOT_TOKEN: 'test',
|
||
LOGIN_GRAPHQL: 'test',
|
||
PASSWORD_GRAPHQL: 'test',
|
||
URL_GRAPHQL: 'test',
|
||
},
|
||
};
|
||
});
|
||
|
||
const mockGetClientWithToken = vi.mocked(getClientWithToken);
|
||
const mockServicesService = vi.mocked(ServicesService);
|
||
|
||
describe('SlotsService', () => {
|
||
/**
|
||
* @type {SlotsService}
|
||
*/
|
||
let slotsService;
|
||
const mockUser = { telegramId: 123_456_789 };
|
||
|
||
const mockCustomer = {
|
||
documentId: 'customer-123',
|
||
firstName: 'John',
|
||
lastName: 'Doe',
|
||
telegramId: 123_456_789,
|
||
};
|
||
|
||
const now = dayjs().minute(0).second(0).millisecond(0);
|
||
vi.setSystemTime(now.toDate());
|
||
|
||
const mockSlot = {
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'slot-123',
|
||
master: mockCustomer,
|
||
orders: [],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockGetCustomerResult = {
|
||
data: {
|
||
customers: [mockCustomer],
|
||
},
|
||
};
|
||
|
||
const mockGetSlotResult = {
|
||
data: {
|
||
slot: mockSlot,
|
||
},
|
||
};
|
||
|
||
beforeEach(() => {
|
||
slotsService = new SlotsService(mockUser);
|
||
vi.clearAllMocks();
|
||
});
|
||
|
||
afterEach(() => {
|
||
vi.restoreAllMocks();
|
||
});
|
||
|
||
describe('getAvailableTimeSlots', () => {
|
||
const mockVariables = {
|
||
filters: {
|
||
datetime_start: now.toISOString(),
|
||
},
|
||
};
|
||
|
||
const mockContext = {
|
||
service: {
|
||
documentId: { eq: 'service-123' },
|
||
},
|
||
};
|
||
|
||
const mockService = {
|
||
active: true,
|
||
documentId: 'service-123',
|
||
duration: '01:00:00', // 1 час
|
||
master: mockCustomer,
|
||
name: 'Test Service',
|
||
};
|
||
|
||
const mockGetServiceResult = {
|
||
service: mockService,
|
||
};
|
||
|
||
const mockSlotWithOrders = {
|
||
datetime_end: now.add(2, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'slot-123',
|
||
master: mockCustomer,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(1, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Scheduled,
|
||
},
|
||
],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockSlotWithoutOrders = {
|
||
datetime_end: now.add(5, 'hour').toISOString(),
|
||
datetime_start: now.add(3, 'hour').toISOString(),
|
||
documentId: 'slot-124',
|
||
master: mockCustomer,
|
||
orders: [],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockGetSlotsOrdersResult = {
|
||
data: {
|
||
slots: [mockSlotWithOrders, mockSlotWithoutOrders],
|
||
},
|
||
};
|
||
|
||
it('should successfully get available time slots', async () => {
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve(mockGetSlotsOrdersResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
// Мокаем ServicesService.getService
|
||
const mockGetService = vi.fn().mockResolvedValue(mockGetServiceResult);
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
expect(result).resolves.toEqual({
|
||
slots: [mockSlotWithOrders, mockSlotWithoutOrders],
|
||
times: [
|
||
{
|
||
slotId: 'slot-123',
|
||
time: now.add(1, 'hour').toISOString(), // 11:00
|
||
},
|
||
{
|
||
slotId: 'slot-124',
|
||
time: now.add(3, 'hour').toISOString(), // 13:00
|
||
},
|
||
{
|
||
slotId: 'slot-124',
|
||
time: now.add(3, 'hour').add(15, 'minute').toISOString(), // 13:15
|
||
},
|
||
{
|
||
slotId: 'slot-124',
|
||
time: now.add(3, 'hour').add(30, 'minute').toISOString(), // 13:30
|
||
},
|
||
{
|
||
slotId: 'slot-124',
|
||
time: now.add(3, 'hour').add(45, 'minute').toISOString(), // 13:45
|
||
},
|
||
{
|
||
slotId: 'slot-124',
|
||
time: now.add(4, 'hour').toISOString(), // 14:00
|
||
},
|
||
],
|
||
});
|
||
});
|
||
|
||
it('should throw error when datetime_start is missing', async () => {
|
||
const variablesWithoutStart = {
|
||
filters: {},
|
||
};
|
||
|
||
const result = slotsService.getAvailableTimeSlots(variablesWithoutStart, mockContext);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.MISSING_DATETIME_START);
|
||
});
|
||
|
||
it('should throw error when service documentId is missing', async () => {
|
||
const contextWithoutService = {
|
||
service: {},
|
||
};
|
||
|
||
const result = slotsService.getAvailableTimeSlots(mockVariables, contextWithoutService);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.MISSING_SERVICE_ID);
|
||
});
|
||
|
||
it('should throw error when service is not found', async () => {
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve(mockGetSlotsOrdersResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
// Мокаем ServicesService.getService возвращающий null
|
||
const mockGetService = vi.fn().mockResolvedValue({
|
||
data: { service: null },
|
||
});
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.SERVICE_NOT_FOUND);
|
||
});
|
||
|
||
it('should filter out times that conflict with orders', async () => {
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve(mockGetSlotsOrdersResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
// Мокаем ServicesService.getService
|
||
const mockGetService = vi.fn().mockResolvedValue(mockGetServiceResult);
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = await slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
// Проверяем, что время конфликтующее с заказом не включено
|
||
const conflictingTime = now.toISOString();
|
||
const hasConflictingTime = result.times.some((time) => time.time === conflictingTime);
|
||
expect(hasConflictingTime).toBe(false);
|
||
});
|
||
|
||
it('should include times from cancelled orders', async () => {
|
||
vi.setSystemTime(now.toDate()); // синхронизируем "текущее" время
|
||
|
||
const slotWithCancelledOrder = {
|
||
...mockSlotWithOrders,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(1, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Cancelled,
|
||
},
|
||
],
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [slotWithCancelledOrder] },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
const mockGetService = vi.fn().mockResolvedValue(mockGetServiceResult);
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = await slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
// Слот: 10:00–12:00, сервис = 1 час, шаг = 15 мин
|
||
// Все возможные начала интервалов: от 10:00 до 11:00 включительно (всего 5)
|
||
const expectedTimes = [
|
||
// now.toISOString(), // 10:00
|
||
now.add(15, 'minute').toISOString(), // 10:15
|
||
now.add(30, 'minute').toISOString(), // 10:30
|
||
now.add(45, 'minute').toISOString(), // 10:45
|
||
now.add(1, 'hour').toISOString(), // 11:00
|
||
];
|
||
|
||
const actualTimes = result.times
|
||
.filter((time) => time.slotId === slotWithCancelledOrder.documentId)
|
||
.map((time) => time.time);
|
||
|
||
expect(actualTimes).toEqual(expectedTimes);
|
||
});
|
||
|
||
it('should filter out times in the past', async () => {
|
||
const pastSlot = {
|
||
datetime_end: now.subtract(1, 'hour').toISOString(),
|
||
datetime_start: now.subtract(2, 'hour').toISOString(),
|
||
documentId: 'slot-past',
|
||
master: mockCustomer,
|
||
orders: [],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [pastSlot] },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
// Мокаем ServicesService.getService
|
||
const mockGetService = vi.fn().mockResolvedValue(mockGetServiceResult);
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = await slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
// Проверяем, что время в прошлом не включено
|
||
expect(result.times).toHaveLength(0);
|
||
});
|
||
|
||
it('should generate times with 15-minute intervals', async () => {
|
||
const longSlot = {
|
||
datetime_end: now.add(3, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'slot-long',
|
||
master: mockCustomer,
|
||
orders: [],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [longSlot] },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
// Мокаем ServicesService.getService
|
||
const mockGetService = vi.fn().mockResolvedValue(mockGetServiceResult);
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = await slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
// Проверяем, что времена генерируются с интервалом 15 минут
|
||
expect(result.times.length).toBeGreaterThan(1);
|
||
|
||
for (let index = 1; index < result.times.length; index++) {
|
||
const currentTime = dayjs(result.times[index].time);
|
||
const previousTime = dayjs(result.times[index - 1].time);
|
||
const diff = currentTime.diff(previousTime, 'minute');
|
||
expect(diff).toBe(15);
|
||
}
|
||
});
|
||
|
||
it('should skip slots without datetime_start or datetime_end', async () => {
|
||
const incompleteSlot = {
|
||
datetime_end: now.add(1, 'hour').toISOString(),
|
||
datetime_start: null, // отсутствует datetime_start
|
||
documentId: 'slot-incomplete',
|
||
master: mockCustomer,
|
||
orders: [],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [incompleteSlot] },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
// Мокаем ServicesService.getService
|
||
const mockGetService = vi.fn().mockResolvedValue(mockGetServiceResult);
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = await slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
// Проверяем, что слот без datetime_start пропущен
|
||
expect(result.times).toHaveLength(0);
|
||
});
|
||
|
||
it('should handle GraphQL errors', async () => {
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve({
|
||
error: { message: 'GraphQL error' },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
await expect(result).rejects.toThrow('GraphQL error');
|
||
});
|
||
|
||
it('should calculate service duration correctly', async () => {
|
||
const serviceWithDuration = {
|
||
...mockService,
|
||
duration: '00:30:00', // 30 минут
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetSlotsOrdersDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [mockSlotWithoutOrders] },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
query: mockQuery,
|
||
});
|
||
|
||
// Мокаем ServicesService.getService с другой длительностью
|
||
const mockGetService = vi.fn().mockResolvedValue({
|
||
service: serviceWithDuration,
|
||
});
|
||
mockServicesService.mockImplementation(() => ({
|
||
getService: mockGetService,
|
||
}));
|
||
|
||
const result = await slotsService.getAvailableTimeSlots(mockVariables, mockContext);
|
||
|
||
// Проверяем, что времена генерируются с учетом длительности услуги
|
||
expect(result.times.length).toBeGreaterThan(0);
|
||
|
||
// Последнее время должно быть не позже чем datetime_end минус длительность услуги
|
||
const lastTime = dayjs(result.times[result.times.length - 1].time);
|
||
const slotEnd = dayjs(mockSlotWithoutOrders.datetime_end);
|
||
const serviceDuration = dayjs.duration('00:30:00');
|
||
const maxTime = slotEnd.subtract(serviceDuration);
|
||
|
||
expect(lastTime.valueOf()).toBeLessThanOrEqual(maxTime.valueOf());
|
||
});
|
||
});
|
||
|
||
describe('createSlot', () => {
|
||
const mockVariables = {
|
||
input: {
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
state: GQL.Enum_Slot_State.Open,
|
||
},
|
||
};
|
||
|
||
const mockMutationResult = {
|
||
data: {
|
||
createSlot: mockSlot,
|
||
},
|
||
errors: undefined,
|
||
};
|
||
|
||
const mockMasterCustomer = {
|
||
...mockCustomer,
|
||
active: true,
|
||
role: 'master',
|
||
};
|
||
|
||
const mockGetMasterCustomerResult = {
|
||
data: {
|
||
customers: [mockMasterCustomer],
|
||
},
|
||
};
|
||
|
||
it('should successfully create slot when master is active', async () => {
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({ data: { slots: [] } }); // нет пересекающихся слотов
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot({
|
||
input: {
|
||
...mockVariables.input,
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
},
|
||
});
|
||
|
||
await expect(result).resolves.toBe(mockMutationResult.data);
|
||
});
|
||
|
||
it('should throw error when master is not found', async () => {
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve({
|
||
data: { customers: [] }, // мастер не найден
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(BASE_ERRORS.CUSTOMER_NOT_FOUND);
|
||
});
|
||
|
||
it('should throw error when master is not active', async () => {
|
||
const inactiveMaster = {
|
||
...mockMasterCustomer,
|
||
active: false,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve({
|
||
data: { customers: [inactiveMaster] },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.INACTIVE_MASTER);
|
||
});
|
||
|
||
it('should throw error when master role is not master', async () => {
|
||
const nonMasterCustomer = {
|
||
...mockMasterCustomer,
|
||
role: 'customer',
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve({
|
||
data: { customers: [nonMasterCustomer] },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.INACTIVE_MASTER);
|
||
});
|
||
|
||
it('should throw error when datetime_start is missing', async () => {
|
||
const variablesWithoutStart = {
|
||
input: {
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
state: GQL.Enum_Slot_State.Open,
|
||
},
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(variablesWithoutStart);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.MISSING_DATETIME_START);
|
||
});
|
||
|
||
it('should throw error when datetime_end is missing', async () => {
|
||
const variablesWithoutEnd = {
|
||
input: {
|
||
datetime_start: now.toISOString(),
|
||
state: GQL.Enum_Slot_State.Open,
|
||
},
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(variablesWithoutEnd);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.MISSING_DATETIME_END);
|
||
});
|
||
|
||
it('should throw error when datetime_end is before datetime_start', async () => {
|
||
const variablesWithInvalidTime = {
|
||
input: {
|
||
datetime_end: now.toISOString(),
|
||
datetime_start: now.add(6, 'hour').toISOString(),
|
||
state: GQL.Enum_Slot_State.Open,
|
||
},
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(variablesWithInvalidTime);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.INVALID_TIME);
|
||
});
|
||
|
||
it('should throw error when datetime_end equals datetime_start', async () => {
|
||
const variablesWithEqualTime = {
|
||
input: {
|
||
datetime_end: now.toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
state: GQL.Enum_Slot_State.Open,
|
||
},
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(variablesWithEqualTime);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.INVALID_TIME);
|
||
});
|
||
|
||
it('should throw error when slot is created in the past', async () => {
|
||
const yesterday = dayjs().subtract(1, 'day');
|
||
|
||
const variablesWithPastTime = {
|
||
input: {
|
||
datetime_end: yesterday.add(1, 'hour').toISOString(),
|
||
datetime_start: yesterday.toISOString(),
|
||
state: GQL.Enum_Slot_State.Open,
|
||
},
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(variablesWithPastTime);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.PAST_SLOT);
|
||
});
|
||
|
||
it('should throw error when time overlaps with other slots', async () => {
|
||
const overlappingSlot = {
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'slot-456',
|
||
master: mockMasterCustomer,
|
||
orders: [],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [overlappingSlot] },
|
||
}); // есть пересекающиеся слоты
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.OVERLAPPING_TIME);
|
||
});
|
||
|
||
it('should allow creation when time does not overlap with other slots', async () => {
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [] },
|
||
}); // нет пересекающихся слотов
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.createSlot(mockVariables);
|
||
|
||
await expect(result).resolves.toBe(mockMutationResult.data);
|
||
});
|
||
|
||
it('should include master documentId in mutation variables', async () => {
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetMasterCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({ data: { slots: [] } });
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
await slotsService.createSlot(mockVariables);
|
||
|
||
expect(mockMutate).toHaveBeenCalledWith({
|
||
mutation: GQL.CreateSlotDocument,
|
||
variables: {
|
||
...mockVariables,
|
||
input: {
|
||
...mockVariables.input,
|
||
master: mockMasterCustomer.documentId,
|
||
},
|
||
},
|
||
});
|
||
});
|
||
});
|
||
|
||
describe('updateSlot', () => {
|
||
const mockVariables = {
|
||
data: {
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
state: GQL.Enum_Slot_State.Open,
|
||
},
|
||
documentId: 'slot-123',
|
||
};
|
||
|
||
const mockMutationResult = {
|
||
data: {
|
||
updateSlot: mockSlot,
|
||
},
|
||
errors: undefined,
|
||
};
|
||
|
||
it('should successfully update slot when user has permission', async () => {
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve(mockGetSlotResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({ data: { slots: [] } });
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).resolves.toBe(mockMutationResult.data);
|
||
});
|
||
|
||
it('should successfully update slot when time is not changing', async () => {
|
||
const variablesWithoutTime = {
|
||
data: {
|
||
state: GQL.Enum_Slot_State.Closed,
|
||
},
|
||
documentId: 'slot-123',
|
||
};
|
||
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve(mockGetSlotResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(variablesWithoutTime);
|
||
|
||
await expect(result).resolves.toBe(mockMutationResult.data);
|
||
});
|
||
|
||
it('should throw error when user does not have permission', async () => {
|
||
const unrelatedCustomer = {
|
||
...mockCustomer,
|
||
documentId: 'different-customer-123',
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve({
|
||
data: { customers: [unrelatedCustomer] },
|
||
});
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: mockSlot }, // slot принадлежит другому пользователю
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.NO_PERMISSION);
|
||
});
|
||
|
||
it('should throw error when slot does not exist', async () => {
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: null }, // slot не найден
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.SLOT_NOT_FOUND);
|
||
});
|
||
|
||
it('should throw error when customer is not found', async () => {
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve({
|
||
data: { customers: [] }, // пользователь не найден
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(BASE_ERRORS.CUSTOMER_NOT_FOUND);
|
||
});
|
||
|
||
it('should throw error when datetime_start is missing', async () => {
|
||
const variablesWithMissingStart = {
|
||
data: {
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
},
|
||
documentId: 'slot-123',
|
||
};
|
||
|
||
const slotWithoutStart = {
|
||
...mockSlot,
|
||
datetime_start: null,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithoutStart },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(variablesWithMissingStart);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.MISSING_DATETIME_START);
|
||
});
|
||
|
||
it('should throw error when datetime_end is missing', async () => {
|
||
const variablesWithMissingEnd = {
|
||
data: {
|
||
datetime_start: now.toISOString(),
|
||
},
|
||
documentId: 'slot-123',
|
||
};
|
||
|
||
const slotWithoutEnd = {
|
||
...mockSlot,
|
||
datetime_end: null,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithoutEnd },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(variablesWithMissingEnd);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.MISSING_DATETIME_END);
|
||
});
|
||
|
||
it('should throw error when datetime_end is before datetime_start', async () => {
|
||
const variablesWithInvalidTime = {
|
||
data: {
|
||
datetime_end: now.toISOString(),
|
||
datetime_start: now.add(6, 'hour').toISOString(),
|
||
},
|
||
documentId: 'slot-123',
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve(mockGetSlotResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(variablesWithInvalidTime);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.INVALID_TIME);
|
||
});
|
||
|
||
it('should throw error when datetime_end equals datetime_start', async () => {
|
||
const variablesWithEqualTime = {
|
||
data: {
|
||
datetime_end: now.toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
},
|
||
documentId: 'slot-123',
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve(mockGetSlotResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(variablesWithEqualTime);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.INVALID_TIME);
|
||
});
|
||
|
||
it('should throw error when slot has scheduled orders', async () => {
|
||
const slotWithScheduledOrders = {
|
||
...mockSlot,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Scheduled,
|
||
},
|
||
],
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithScheduledOrders },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.HAS_ORDERS);
|
||
});
|
||
|
||
it('should throw error when slot has approved orders', async () => {
|
||
const slotWithApprovedOrders = {
|
||
...mockSlot,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Approved,
|
||
},
|
||
],
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithApprovedOrders },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.HAS_ORDERS);
|
||
});
|
||
|
||
it('should throw error when slot has completed orders', async () => {
|
||
const slotWithCompletedOrders = {
|
||
...mockSlot,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Completed,
|
||
},
|
||
],
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithCompletedOrders },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.HAS_ORDERS);
|
||
});
|
||
|
||
it('should throw error when slot has cancelled orders', async () => {
|
||
const slotWithCancelledOrders = {
|
||
...mockSlot,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Cancelled,
|
||
},
|
||
],
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithCancelledOrders },
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.HAS_ORDERS);
|
||
});
|
||
|
||
it('should allow update when slot has non-forbidden order states', async () => {
|
||
const slotWithNonForbiddenOrders = {
|
||
...mockSlot,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Draft, // не запрещенное состояние
|
||
},
|
||
],
|
||
};
|
||
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithNonForbiddenOrders },
|
||
});
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({ data: { slots: [] } }); // нет пересекающихся слотов
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).resolves.toBe(mockMutationResult.data);
|
||
});
|
||
|
||
it('should throw error when time overlaps with other slots', async () => {
|
||
const overlappingSlot = {
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'slot-456',
|
||
master: mockCustomer,
|
||
orders: [],
|
||
state: GQL.Enum_Slot_State.Open,
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve(mockGetSlotResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [overlappingSlot] },
|
||
}); // есть пересекающиеся слоты
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.OVERLAPPING_TIME);
|
||
});
|
||
|
||
it('should allow update when time does not overlap with other slots', async () => {
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve(mockGetSlotResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotsDocument) {
|
||
return Promise.resolve({
|
||
data: { slots: [] },
|
||
}); // нет пересекающихся слотов
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.updateSlot(mockVariables);
|
||
|
||
await expect(result).resolves.toBe(mockMutationResult.data);
|
||
});
|
||
});
|
||
|
||
describe('deleteSlot', () => {
|
||
const mockVariables = {
|
||
documentId: 'slot-123',
|
||
};
|
||
|
||
const mockMutationResult = {
|
||
data: {
|
||
deleteSlot: {
|
||
documentId: 'slot-123',
|
||
},
|
||
},
|
||
errors: undefined,
|
||
};
|
||
|
||
it('should successfully delete slot when no orders', async () => {
|
||
const mockMutate = vi.fn().mockResolvedValue(mockMutationResult);
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve(mockGetSlotResult);
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: mockMutate,
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.deleteSlot(mockVariables);
|
||
|
||
await expect(result).resolves.toBe(mockMutationResult.data);
|
||
});
|
||
|
||
it('should throw error when slot has orders', async () => {
|
||
const slotWithOrders = {
|
||
...mockSlot,
|
||
orders: [
|
||
{
|
||
datetime_end: now.add(6, 'hour').toISOString(),
|
||
datetime_start: now.toISOString(),
|
||
documentId: 'order-123',
|
||
state: GQL.Enum_Order_State.Scheduled,
|
||
},
|
||
],
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve(mockGetCustomerResult);
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: slotWithOrders }, // slot с заказами
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.deleteSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.HAS_ORDERS);
|
||
});
|
||
|
||
it('should throw error when user does not have permission', async () => {
|
||
const unrelatedCustomer = {
|
||
...mockCustomer,
|
||
documentId: 'different-customer-123',
|
||
};
|
||
|
||
const mockQuery = vi.fn().mockImplementation(({ query }) => {
|
||
if (query === GQL.GetCustomerDocument) {
|
||
return Promise.resolve({
|
||
data: { customers: [unrelatedCustomer] },
|
||
});
|
||
}
|
||
|
||
if (query === GQL.GetSlotDocument) {
|
||
return Promise.resolve({
|
||
data: { slot: mockSlot }, // slot принадлежит другому пользователю
|
||
});
|
||
}
|
||
|
||
return Promise.resolve({ data: {} });
|
||
});
|
||
|
||
mockGetClientWithToken.mockResolvedValue({
|
||
mutate: vi.fn(),
|
||
query: mockQuery,
|
||
});
|
||
|
||
const result = slotsService.deleteSlot(mockVariables);
|
||
|
||
await expect(result).rejects.toThrow(ERRORS.NO_PERMISSION);
|
||
});
|
||
});
|
||
});
|