327 lines
11 KiB
JavaScript
327 lines
11 KiB
JavaScript
import axios from 'axios';
|
|
import { actions } from '../../assignmentPolicies';
|
|
import types from '../../../mutation-types';
|
|
import assignmentPoliciesList, { camelCaseFixtures } from './fixtures';
|
|
import camelcaseKeys from 'camelcase-keys';
|
|
import snakecaseKeys from 'snakecase-keys';
|
|
|
|
const commit = vi.fn();
|
|
|
|
global.axios = axios;
|
|
vi.mock('axios');
|
|
vi.mock('camelcase-keys');
|
|
vi.mock('snakecase-keys');
|
|
vi.mock('../../../utils/api');
|
|
|
|
describe('#actions', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
describe('#get', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
axios.get.mockResolvedValue({ data: assignmentPoliciesList });
|
|
camelcaseKeys.mockReturnValue(camelCaseFixtures);
|
|
|
|
await actions.get({ commit });
|
|
|
|
expect(camelcaseKeys).toHaveBeenCalledWith(assignmentPoliciesList);
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetching: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES, camelCaseFixtures],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetching: false }],
|
|
]);
|
|
});
|
|
|
|
it('sends correct actions if API is error', async () => {
|
|
axios.get.mockRejectedValue({ message: 'Incorrect header' });
|
|
|
|
await actions.get({ commit });
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetching: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetching: false }],
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('#show', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
const policyData = assignmentPoliciesList[0];
|
|
const camelCasedPolicy = camelCaseFixtures[0];
|
|
|
|
axios.get.mockResolvedValue({ data: policyData });
|
|
camelcaseKeys.mockReturnValue(camelCasedPolicy);
|
|
|
|
await actions.show({ commit }, 1);
|
|
|
|
expect(camelcaseKeys).toHaveBeenCalledWith(policyData);
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetchingItem: true }],
|
|
[types.SET_ASSIGNMENT_POLICY, camelCasedPolicy],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetchingItem: false }],
|
|
]);
|
|
});
|
|
|
|
it('sends correct actions if API is error', async () => {
|
|
axios.get.mockRejectedValue({ message: 'Not found' });
|
|
|
|
await actions.show({ commit }, 1);
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetchingItem: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isFetchingItem: false }],
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('#create', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
const newPolicy = assignmentPoliciesList[0];
|
|
const camelCasedData = camelCaseFixtures[0];
|
|
const snakeCasedPolicy = { assignment_order: 'round_robin' };
|
|
|
|
axios.post.mockResolvedValue({ data: newPolicy });
|
|
camelcaseKeys.mockReturnValue(camelCasedData);
|
|
snakecaseKeys.mockReturnValue(snakeCasedPolicy);
|
|
|
|
const result = await actions.create({ commit }, newPolicy);
|
|
|
|
expect(snakecaseKeys).toHaveBeenCalledWith(newPolicy);
|
|
expect(camelcaseKeys).toHaveBeenCalledWith(newPolicy);
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isCreating: true }],
|
|
[types.ADD_ASSIGNMENT_POLICY, camelCasedData],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isCreating: false }],
|
|
]);
|
|
expect(result).toEqual(newPolicy);
|
|
});
|
|
|
|
it('sends correct actions if API is error', async () => {
|
|
axios.post.mockRejectedValue(new Error('Validation error'));
|
|
|
|
await expect(actions.create({ commit }, {})).rejects.toThrow(Error);
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isCreating: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isCreating: false }],
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('#update', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
const updateParams = { id: 1, name: 'Updated Policy' };
|
|
const responseData = {
|
|
...assignmentPoliciesList[0],
|
|
name: 'Updated Policy',
|
|
};
|
|
const camelCasedData = {
|
|
...camelCaseFixtures[0],
|
|
name: 'Updated Policy',
|
|
};
|
|
const snakeCasedParams = { name: 'Updated Policy' };
|
|
|
|
axios.patch.mockResolvedValue({ data: responseData });
|
|
camelcaseKeys.mockReturnValue(camelCasedData);
|
|
snakecaseKeys.mockReturnValue(snakeCasedParams);
|
|
|
|
const result = await actions.update({ commit }, updateParams);
|
|
|
|
expect(snakecaseKeys).toHaveBeenCalledWith({ name: 'Updated Policy' });
|
|
expect(camelcaseKeys).toHaveBeenCalledWith(responseData);
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isUpdating: true }],
|
|
[types.EDIT_ASSIGNMENT_POLICY, camelCasedData],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isUpdating: false }],
|
|
]);
|
|
expect(result).toEqual(responseData);
|
|
});
|
|
|
|
it('sends correct actions if API is error', async () => {
|
|
axios.patch.mockRejectedValue(new Error('Validation error'));
|
|
|
|
await expect(
|
|
actions.update({ commit }, { id: 1, name: 'Test' })
|
|
).rejects.toThrow(Error);
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isUpdating: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isUpdating: false }],
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('#delete', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
const policyId = 1;
|
|
axios.delete.mockResolvedValue({});
|
|
|
|
await actions.delete({ commit }, policyId);
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isDeleting: true }],
|
|
[types.DELETE_ASSIGNMENT_POLICY, policyId],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isDeleting: false }],
|
|
]);
|
|
});
|
|
|
|
it('sends correct actions if API is error', async () => {
|
|
axios.delete.mockRejectedValue(new Error('Not found'));
|
|
|
|
await expect(actions.delete({ commit }, 1)).rejects.toThrow(Error);
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isDeleting: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES_UI_FLAG, { isDeleting: false }],
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('#getInboxes', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
const policyId = 1;
|
|
const inboxData = {
|
|
inboxes: [
|
|
{ id: 1, name: 'Support' },
|
|
{ id: 2, name: 'Sales' },
|
|
],
|
|
};
|
|
const camelCasedInboxes = [
|
|
{ id: 1, name: 'Support' },
|
|
{ id: 2, name: 'Sales' },
|
|
];
|
|
|
|
axios.get.mockResolvedValue({ data: inboxData });
|
|
camelcaseKeys.mockReturnValue(camelCasedInboxes);
|
|
|
|
await actions.getInboxes({ commit }, policyId);
|
|
|
|
expect(camelcaseKeys).toHaveBeenCalledWith(inboxData.inboxes);
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isFetching: true }],
|
|
[
|
|
types.SET_ASSIGNMENT_POLICIES_INBOXES,
|
|
{ policyId, inboxes: camelCasedInboxes },
|
|
],
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isFetching: false }],
|
|
]);
|
|
});
|
|
|
|
it('sends correct actions if API fails', async () => {
|
|
axios.get.mockRejectedValue(new Error('API Error'));
|
|
|
|
await expect(actions.getInboxes({ commit }, 1)).rejects.toThrow(Error);
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isFetching: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isFetching: false }],
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('#setInboxPolicy', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
const responseData = { success: true, policy_id: 2 };
|
|
const camelCasedData = { success: true, policyId: 2 };
|
|
|
|
axios.post.mockResolvedValue({ data: responseData });
|
|
camelcaseKeys.mockReturnValue(camelCasedData);
|
|
|
|
const result = await actions.setInboxPolicy(
|
|
{ commit },
|
|
{ inboxId: 1, policyId: 2 }
|
|
);
|
|
|
|
expect(camelcaseKeys).toHaveBeenCalledWith(responseData);
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.ADD_ASSIGNMENT_POLICIES_INBOXES, camelCasedData],
|
|
]);
|
|
expect(result).toEqual(responseData);
|
|
});
|
|
|
|
it('throws error if API fails', async () => {
|
|
axios.post.mockRejectedValue(new Error('API Error'));
|
|
|
|
await expect(
|
|
actions.setInboxPolicy({ commit }, { inboxId: 1, policyId: 2 })
|
|
).rejects.toThrow(Error);
|
|
});
|
|
});
|
|
|
|
describe('#getInboxPolicy', () => {
|
|
it('returns camelCased response data if API is success', async () => {
|
|
const responseData = { policy_id: 1, name: 'Round Robin' };
|
|
const camelCasedData = { policyId: 1, name: 'Round Robin' };
|
|
|
|
axios.get.mockResolvedValue({ data: responseData });
|
|
camelcaseKeys.mockReturnValue(camelCasedData);
|
|
|
|
const result = await actions.getInboxPolicy({}, { inboxId: 1 });
|
|
|
|
expect(camelcaseKeys).toHaveBeenCalledWith(responseData);
|
|
expect(result).toEqual(camelCasedData);
|
|
});
|
|
|
|
it('throws error if API fails', async () => {
|
|
axios.get.mockRejectedValue(new Error('Not found'));
|
|
|
|
await expect(
|
|
actions.getInboxPolicy({}, { inboxId: 999 })
|
|
).rejects.toThrow(Error);
|
|
});
|
|
});
|
|
|
|
describe('#updateInboxPolicy', () => {
|
|
it('commits EDIT_ASSIGNMENT_POLICY mutation', async () => {
|
|
const policy = { id: 1, name: 'Updated Policy' };
|
|
|
|
await actions.updateInboxPolicy({ commit }, { policy });
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.EDIT_ASSIGNMENT_POLICY, policy],
|
|
]);
|
|
});
|
|
|
|
it('throws error if commit fails', async () => {
|
|
commit.mockImplementation(() => {
|
|
throw new Error('Commit failed');
|
|
});
|
|
|
|
await expect(
|
|
actions.updateInboxPolicy({ commit }, { policy: {} })
|
|
).rejects.toThrow(Error);
|
|
});
|
|
});
|
|
|
|
describe('#removeInboxPolicy', () => {
|
|
it('sends correct actions if API is success', async () => {
|
|
const policyId = 1;
|
|
const inboxId = 2;
|
|
|
|
axios.delete.mockResolvedValue({});
|
|
|
|
await actions.removeInboxPolicy({ commit }, { policyId, inboxId });
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isDeleting: true }],
|
|
[types.DELETE_ASSIGNMENT_POLICIES_INBOXES, { policyId, inboxId }],
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isDeleting: false }],
|
|
]);
|
|
});
|
|
|
|
it('sends correct actions if API fails', async () => {
|
|
axios.delete.mockRejectedValue(new Error('Not found'));
|
|
|
|
await expect(
|
|
actions.removeInboxPolicy({ commit }, { policyId: 1, inboxId: 999 })
|
|
).rejects.toThrow(Error);
|
|
|
|
expect(commit.mock.calls).toEqual([
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isDeleting: true }],
|
|
[types.SET_ASSIGNMENT_POLICIES_INBOXES_UI_FLAG, { isDeleting: false }],
|
|
]);
|
|
});
|
|
});
|
|
});
|