1178 lines
34 KiB
JavaScript
1178 lines
34 KiB
JavaScript
import AxiosMockAdapter from 'axios-mock-adapter';
|
|
import { TEST_HOST } from 'helpers/test_constants';
|
|
import axios from '~/lib/utils/axios_utils';
|
|
import boardsStore, { gqlClient } from '~/boards/stores/boards_store';
|
|
import eventHub from '~/boards/eventhub';
|
|
import { listObj, listObjDuplicate } from './mock_data';
|
|
|
|
import ListIssue from '~/boards/models/issue';
|
|
import List from '~/boards/models/list';
|
|
|
|
jest.mock('js-cookie');
|
|
|
|
const createTestIssue = () => ({
|
|
title: 'Testing',
|
|
id: 1,
|
|
iid: 1,
|
|
confidential: false,
|
|
labels: [],
|
|
assignees: [],
|
|
});
|
|
|
|
describe('boardsStore', () => {
|
|
const dummyResponse = "without type checking this doesn't matter";
|
|
const boardId = 'dummy-board-id';
|
|
const endpoints = {
|
|
boardsEndpoint: `${TEST_HOST}/boards`,
|
|
listsEndpoint: `${TEST_HOST}/lists`,
|
|
bulkUpdatePath: `${TEST_HOST}/bulk/update`,
|
|
recentBoardsEndpoint: `${TEST_HOST}/recent/boards`,
|
|
};
|
|
|
|
let axiosMock;
|
|
|
|
beforeEach(() => {
|
|
axiosMock = new AxiosMockAdapter(axios);
|
|
boardsStore.setEndpoints({
|
|
...endpoints,
|
|
boardId,
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
axiosMock.restore();
|
|
});
|
|
|
|
const setupDefaultResponses = () => {
|
|
axiosMock
|
|
.onGet(`${endpoints.listsEndpoint}/${listObj.id}/issues?id=${listObj.id}&page=1`)
|
|
.reply(200, { issues: [createTestIssue()] });
|
|
axiosMock.onPost(endpoints.listsEndpoint).reply(200, listObj);
|
|
axiosMock.onPut();
|
|
};
|
|
|
|
describe('all', () => {
|
|
it('makes a request to fetch lists', () => {
|
|
axiosMock.onGet(endpoints.listsEndpoint).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.all()).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onGet(endpoints.listsEndpoint).replyOnce(500);
|
|
|
|
return expect(boardsStore.all()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('generateDefaultLists', () => {
|
|
const listsEndpointGenerate = `${endpoints.listsEndpoint}/generate.json`;
|
|
|
|
it('makes a request to generate default lists', () => {
|
|
axiosMock.onPost(listsEndpointGenerate).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.generateDefaultLists()).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onPost(listsEndpointGenerate).replyOnce(500);
|
|
|
|
return expect(boardsStore.generateDefaultLists()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('createList', () => {
|
|
const entityType = 'moorhen';
|
|
const entityId = 'quack';
|
|
const expectedRequest = expect.objectContaining({
|
|
data: JSON.stringify({ list: { [entityType]: entityId } }),
|
|
});
|
|
|
|
let requestSpy;
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock.onPost(endpoints.listsEndpoint).replyOnce(config => requestSpy(config));
|
|
});
|
|
|
|
it('makes a request to create a list', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.createList(entityId, entityType))
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(boardsStore.createList(entityId, entityType))
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('updateList', () => {
|
|
const id = 'David Webb';
|
|
const position = 'unknown';
|
|
const collapsed = false;
|
|
const expectedRequest = expect.objectContaining({
|
|
data: JSON.stringify({ list: { position, collapsed } }),
|
|
});
|
|
|
|
let requestSpy;
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock.onPut(`${endpoints.listsEndpoint}/${id}`).replyOnce(config => requestSpy(config));
|
|
});
|
|
|
|
it('makes a request to update a list position', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.updateList(id, position, collapsed))
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(boardsStore.updateList(id, position, collapsed))
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('destroyList', () => {
|
|
const id = '-42';
|
|
|
|
let requestSpy;
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock
|
|
.onDelete(`${endpoints.listsEndpoint}/${id}`)
|
|
.replyOnce(config => requestSpy(config));
|
|
});
|
|
|
|
it('makes a request to delete a list', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.destroyList(id))
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(boardsStore.destroyList(id))
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('saveList', () => {
|
|
let list;
|
|
|
|
beforeEach(() => {
|
|
list = new List(listObj);
|
|
setupDefaultResponses();
|
|
});
|
|
|
|
it('makes a request to save a list', () => {
|
|
const expectedResponse = expect.objectContaining({ issues: [createTestIssue()] });
|
|
const expectedListValue = {
|
|
id: listObj.id,
|
|
position: listObj.position,
|
|
type: listObj.list_type,
|
|
label: listObj.label,
|
|
};
|
|
expect(list.id).toBe(listObj.id);
|
|
expect(list.position).toBe(listObj.position);
|
|
expect(list).toMatchObject(expectedListValue);
|
|
|
|
return expect(boardsStore.saveList(list)).resolves.toEqual(expectedResponse);
|
|
});
|
|
});
|
|
|
|
describe('getListIssues', () => {
|
|
let list;
|
|
|
|
beforeEach(() => {
|
|
list = new List(listObj);
|
|
setupDefaultResponses();
|
|
});
|
|
|
|
it('makes a request to get issues', () => {
|
|
const expectedResponse = expect.objectContaining({ issues: [createTestIssue()] });
|
|
expect(list.issues).toEqual([]);
|
|
|
|
return expect(boardsStore.getListIssues(list, true)).resolves.toEqual(expectedResponse);
|
|
});
|
|
});
|
|
|
|
describe('getIssuesForList', () => {
|
|
const id = 'TOO-MUCH';
|
|
const url = `${endpoints.listsEndpoint}/${id}/issues?id=${id}`;
|
|
|
|
it('makes a request to fetch list issues', () => {
|
|
axiosMock.onGet(url).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.getIssuesForList(id)).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('makes a request to fetch list issues with filter', () => {
|
|
const filter = { algal: 'scrubber' };
|
|
axiosMock.onGet(`${url}&algal=scrubber`).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.getIssuesForList(id, filter)).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onGet(url).replyOnce(500);
|
|
|
|
return expect(boardsStore.getIssuesForList(id)).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('moveIssue', () => {
|
|
const urlRoot = 'potato';
|
|
const id = 'over 9000';
|
|
const fromListId = 'left';
|
|
const toListId = 'right';
|
|
const moveBeforeId = 'up';
|
|
const moveAfterId = 'down';
|
|
const expectedRequest = expect.objectContaining({
|
|
data: JSON.stringify({
|
|
from_list_id: fromListId,
|
|
to_list_id: toListId,
|
|
move_before_id: moveBeforeId,
|
|
move_after_id: moveAfterId,
|
|
}),
|
|
});
|
|
|
|
let requestSpy;
|
|
|
|
beforeAll(() => {
|
|
global.gon.relative_url_root = urlRoot;
|
|
});
|
|
|
|
afterAll(() => {
|
|
delete global.gon.relative_url_root;
|
|
});
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock
|
|
.onPut(`${urlRoot}/-/boards/${boardId}/issues/${id}`)
|
|
.replyOnce(config => requestSpy(config));
|
|
});
|
|
|
|
it('makes a request to move an issue between lists', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.moveIssue(id, fromListId, toListId, moveBeforeId, moveAfterId))
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(boardsStore.moveIssue(id, fromListId, toListId, moveBeforeId, moveAfterId))
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('newIssue', () => {
|
|
const id = 1;
|
|
const issue = { some: 'issue data' };
|
|
const url = `${endpoints.listsEndpoint}/${id}/issues`;
|
|
const expectedRequest = expect.objectContaining({
|
|
data: JSON.stringify({
|
|
issue,
|
|
}),
|
|
});
|
|
|
|
let requestSpy;
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock.onPost(url).replyOnce(config => requestSpy(config));
|
|
});
|
|
|
|
it('makes a request to create a new issue', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.newIssue(id, issue))
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(boardsStore.newIssue(id, issue))
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getBacklog', () => {
|
|
const urlRoot = 'deep';
|
|
const url = `${urlRoot}/-/boards/${boardId}/issues.json?not=relevant`;
|
|
const requestParams = {
|
|
not: 'relevant',
|
|
};
|
|
|
|
beforeAll(() => {
|
|
global.gon.relative_url_root = urlRoot;
|
|
});
|
|
|
|
afterAll(() => {
|
|
delete global.gon.relative_url_root;
|
|
});
|
|
|
|
it('makes a request to fetch backlog', () => {
|
|
axiosMock.onGet(url).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.getBacklog(requestParams)).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onGet(url).replyOnce(500);
|
|
|
|
return expect(boardsStore.getBacklog(requestParams)).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('bulkUpdate', () => {
|
|
const issueIds = [1, 2, 3];
|
|
const extraData = { moar: 'data' };
|
|
const expectedRequest = expect.objectContaining({
|
|
data: JSON.stringify({
|
|
update: {
|
|
...extraData,
|
|
issuable_ids: '1,2,3',
|
|
},
|
|
}),
|
|
});
|
|
|
|
let requestSpy;
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock.onPost(endpoints.bulkUpdatePath).replyOnce(config => requestSpy(config));
|
|
});
|
|
|
|
it('makes a request to create a list', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.bulkUpdate(issueIds, extraData))
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(boardsStore.bulkUpdate(issueIds, extraData))
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getIssueInfo', () => {
|
|
const dummyEndpoint = `${TEST_HOST}/some/where`;
|
|
|
|
it('makes a request to the given endpoint', () => {
|
|
axiosMock.onGet(dummyEndpoint).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.getIssueInfo(dummyEndpoint)).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onGet(dummyEndpoint).replyOnce(500);
|
|
|
|
return expect(boardsStore.getIssueInfo(dummyEndpoint)).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('toggleIssueSubscription', () => {
|
|
const dummyEndpoint = `${TEST_HOST}/some/where`;
|
|
|
|
it('makes a request to the given endpoint', () => {
|
|
axiosMock.onPost(dummyEndpoint).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.toggleIssueSubscription(dummyEndpoint)).resolves.toEqual(
|
|
expectedResponse,
|
|
);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onPost(dummyEndpoint).replyOnce(500);
|
|
|
|
return expect(boardsStore.toggleIssueSubscription(dummyEndpoint)).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('recentBoards', () => {
|
|
const url = `${endpoints.recentBoardsEndpoint}.json`;
|
|
|
|
it('makes a request to fetch all boards', () => {
|
|
axiosMock.onGet(url).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.recentBoards()).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onGet(url).replyOnce(500);
|
|
|
|
return expect(boardsStore.recentBoards()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('createBoard', () => {
|
|
const labelIds = ['first label', 'second label'];
|
|
const assigneeId = 'as sign ee';
|
|
const milestoneId = 'vegetable soup';
|
|
const board = {
|
|
labels: labelIds.map(id => ({ id })),
|
|
assignee: { id: assigneeId },
|
|
milestone: { id: milestoneId },
|
|
};
|
|
|
|
describe('for existing board', () => {
|
|
const id = 'skate-board';
|
|
const url = `${endpoints.boardsEndpoint}/${id}.json`;
|
|
const expectedRequest = expect.objectContaining({
|
|
data: JSON.stringify({
|
|
board: {
|
|
...board,
|
|
id,
|
|
label_ids: labelIds,
|
|
assignee_id: assigneeId,
|
|
milestone_id: milestoneId,
|
|
},
|
|
}),
|
|
});
|
|
|
|
let requestSpy;
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock.onPut(url).replyOnce(config => requestSpy(config));
|
|
jest.spyOn(gqlClient, 'mutate').mockReturnValue(Promise.resolve({}));
|
|
});
|
|
|
|
it('makes a request to update the board', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = [
|
|
expect.objectContaining({ data: dummyResponse }),
|
|
expect.objectContaining({}),
|
|
];
|
|
|
|
return expect(
|
|
boardsStore.createBoard({
|
|
...board,
|
|
id,
|
|
}),
|
|
)
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(
|
|
boardsStore.createBoard({
|
|
...board,
|
|
id,
|
|
}),
|
|
)
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('for new board', () => {
|
|
const url = `${endpoints.boardsEndpoint}.json`;
|
|
const expectedRequest = expect.objectContaining({
|
|
data: JSON.stringify({
|
|
board: {
|
|
...board,
|
|
label_ids: labelIds,
|
|
assignee_id: assigneeId,
|
|
milestone_id: milestoneId,
|
|
},
|
|
}),
|
|
});
|
|
|
|
let requestSpy;
|
|
|
|
beforeEach(() => {
|
|
requestSpy = jest.fn();
|
|
axiosMock.onPost(url).replyOnce(config => requestSpy(config));
|
|
jest.spyOn(gqlClient, 'mutate').mockReturnValue(Promise.resolve({}));
|
|
});
|
|
|
|
it('makes a request to create a new board', () => {
|
|
requestSpy.mockReturnValue([200, dummyResponse]);
|
|
const expectedResponse = dummyResponse;
|
|
|
|
return expect(boardsStore.createBoard(board))
|
|
.resolves.toEqual(expectedResponse)
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
requestSpy.mockReturnValue([500]);
|
|
|
|
return expect(boardsStore.createBoard(board))
|
|
.rejects.toThrow()
|
|
.then(() => {
|
|
expect(requestSpy).toHaveBeenCalledWith(expectedRequest);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('deleteBoard', () => {
|
|
const id = 'capsized';
|
|
const url = `${endpoints.boardsEndpoint}/${id}.json`;
|
|
|
|
it('makes a request to delete a boards', () => {
|
|
axiosMock.onDelete(url).replyOnce(200, dummyResponse);
|
|
const expectedResponse = expect.objectContaining({ data: dummyResponse });
|
|
|
|
return expect(boardsStore.deleteBoard({ id })).resolves.toEqual(expectedResponse);
|
|
});
|
|
|
|
it('fails for error response', () => {
|
|
axiosMock.onDelete(url).replyOnce(500);
|
|
|
|
return expect(boardsStore.deleteBoard({ id })).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('when created', () => {
|
|
beforeEach(() => {
|
|
setupDefaultResponses();
|
|
|
|
jest.spyOn(boardsStore, 'moveIssue').mockReturnValue(Promise.resolve());
|
|
jest.spyOn(boardsStore, 'moveMultipleIssues').mockReturnValue(Promise.resolve());
|
|
|
|
boardsStore.create();
|
|
});
|
|
|
|
it('starts with a blank state', () => {
|
|
expect(boardsStore.state.lists.length).toBe(0);
|
|
});
|
|
|
|
describe('addList', () => {
|
|
it('sorts by position', () => {
|
|
boardsStore.addList({ position: 2 });
|
|
boardsStore.addList({ position: 1 });
|
|
|
|
expect(boardsStore.state.lists.map(({ position }) => position)).toEqual([1, 2]);
|
|
});
|
|
});
|
|
|
|
describe('toggleFilter', () => {
|
|
const dummyFilter = 'x=42';
|
|
let updateTokensSpy;
|
|
|
|
beforeEach(() => {
|
|
updateTokensSpy = jest.fn();
|
|
eventHub.$once('updateTokens', updateTokensSpy);
|
|
|
|
// prevent using window.history
|
|
jest.spyOn(boardsStore, 'updateFiltersUrl').mockReturnValue();
|
|
});
|
|
|
|
it('adds the filter if it is not present', () => {
|
|
boardsStore.filter.path = 'something';
|
|
|
|
boardsStore.toggleFilter(dummyFilter);
|
|
|
|
expect(boardsStore.filter.path).toEqual(`something&${dummyFilter}`);
|
|
expect(updateTokensSpy).toHaveBeenCalled();
|
|
expect(boardsStore.updateFiltersUrl).toHaveBeenCalled();
|
|
});
|
|
|
|
it('removes the filter if it is present', () => {
|
|
boardsStore.filter.path = `something&${dummyFilter}`;
|
|
|
|
boardsStore.toggleFilter(dummyFilter);
|
|
|
|
expect(boardsStore.filter.path).toEqual('something');
|
|
expect(updateTokensSpy).toHaveBeenCalled();
|
|
expect(boardsStore.updateFiltersUrl).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('lists', () => {
|
|
it('creates new list without persisting to DB', () => {
|
|
expect(boardsStore.state.lists.length).toBe(0);
|
|
|
|
boardsStore.addList(listObj);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(1);
|
|
});
|
|
|
|
it('finds list by ID', () => {
|
|
boardsStore.addList(listObj);
|
|
const list = boardsStore.findList('id', listObj.id);
|
|
|
|
expect(list.id).toBe(listObj.id);
|
|
});
|
|
|
|
it('finds list by type', () => {
|
|
boardsStore.addList(listObj);
|
|
const list = boardsStore.findList('type', 'label');
|
|
|
|
expect(list).toBeDefined();
|
|
});
|
|
|
|
it('finds list by label ID', () => {
|
|
boardsStore.addList(listObj);
|
|
const list = boardsStore.findListByLabelId(listObj.label.id);
|
|
|
|
expect(list.id).toBe(listObj.id);
|
|
});
|
|
|
|
it('gets issue when new list added', () => {
|
|
boardsStore.addList(listObj);
|
|
const list = boardsStore.findList('id', listObj.id);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(1);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
expect(list.issues.length).toBe(1);
|
|
expect(list.issues[0].id).toBe(1);
|
|
});
|
|
});
|
|
|
|
it('persists new list', () => {
|
|
boardsStore.new({
|
|
title: 'Test',
|
|
list_type: 'label',
|
|
label: {
|
|
id: 1,
|
|
title: 'Testing',
|
|
color: 'red',
|
|
description: 'testing;',
|
|
},
|
|
});
|
|
|
|
expect(boardsStore.state.lists.length).toBe(1);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
const list = boardsStore.findList('id', listObj.id);
|
|
|
|
expect(list).toEqual(
|
|
expect.objectContaining({
|
|
id: listObj.id,
|
|
position: 0,
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
it('check for blank state adding', () => {
|
|
expect(boardsStore.shouldAddBlankState()).toBe(true);
|
|
});
|
|
|
|
it('check for blank state not adding', () => {
|
|
boardsStore.addList(listObj);
|
|
|
|
expect(boardsStore.shouldAddBlankState()).toBe(false);
|
|
});
|
|
|
|
it('check for blank state adding when closed list exist', () => {
|
|
boardsStore.addList({
|
|
list_type: 'closed',
|
|
});
|
|
|
|
expect(boardsStore.shouldAddBlankState()).toBe(true);
|
|
});
|
|
|
|
it('removes list from state', () => {
|
|
boardsStore.addList(listObj);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(1);
|
|
|
|
boardsStore.removeList(listObj.id, 'label');
|
|
|
|
expect(boardsStore.state.lists.length).toBe(0);
|
|
});
|
|
|
|
it('moves the position of lists', () => {
|
|
const listOne = boardsStore.addList(listObj);
|
|
boardsStore.addList(listObjDuplicate);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(2);
|
|
|
|
boardsStore.moveList(listOne, [listObjDuplicate.id, listObj.id]);
|
|
|
|
expect(listOne.position).toBe(1);
|
|
});
|
|
|
|
it('moves an issue from one list to another', () => {
|
|
const listOne = boardsStore.addList(listObj);
|
|
const listTwo = boardsStore.addList(listObjDuplicate);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(2);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
expect(listOne.issues.length).toBe(1);
|
|
expect(listTwo.issues.length).toBe(1);
|
|
|
|
boardsStore.moveIssueToList(listOne, listTwo, listOne.findIssue(1));
|
|
|
|
expect(listOne.issues.length).toBe(0);
|
|
expect(listTwo.issues.length).toBe(1);
|
|
});
|
|
});
|
|
|
|
it('moves an issue from backlog to a list', () => {
|
|
const backlog = boardsStore.addList({
|
|
...listObj,
|
|
list_type: 'backlog',
|
|
});
|
|
const listTwo = boardsStore.addList(listObjDuplicate);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(2);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
expect(backlog.issues.length).toBe(1);
|
|
expect(listTwo.issues.length).toBe(1);
|
|
|
|
boardsStore.moveIssueToList(backlog, listTwo, backlog.findIssue(1));
|
|
|
|
expect(backlog.issues.length).toBe(0);
|
|
expect(listTwo.issues.length).toBe(1);
|
|
});
|
|
});
|
|
|
|
it('moves issue to top of another list', () => {
|
|
const listOne = boardsStore.addList(listObj);
|
|
const listTwo = boardsStore.addList(listObjDuplicate);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(2);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
listOne.issues[0].id = 2;
|
|
|
|
expect(listOne.issues.length).toBe(1);
|
|
expect(listTwo.issues.length).toBe(1);
|
|
|
|
boardsStore.moveIssueToList(listOne, listTwo, listOne.findIssue(2), 0);
|
|
|
|
expect(listOne.issues.length).toBe(0);
|
|
expect(listTwo.issues.length).toBe(2);
|
|
expect(listTwo.issues[0].id).toBe(2);
|
|
expect(boardsStore.moveIssue).toHaveBeenCalledWith(2, listOne.id, listTwo.id, null, 1);
|
|
});
|
|
});
|
|
|
|
it('moves issue to bottom of another list', () => {
|
|
const listOne = boardsStore.addList(listObj);
|
|
const listTwo = boardsStore.addList(listObjDuplicate);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(2);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
listOne.issues[0].id = 2;
|
|
|
|
expect(listOne.issues.length).toBe(1);
|
|
expect(listTwo.issues.length).toBe(1);
|
|
|
|
boardsStore.moveIssueToList(listOne, listTwo, listOne.findIssue(2), 1);
|
|
|
|
expect(listOne.issues.length).toBe(0);
|
|
expect(listTwo.issues.length).toBe(2);
|
|
expect(listTwo.issues[1].id).toBe(2);
|
|
expect(boardsStore.moveIssue).toHaveBeenCalledWith(2, listOne.id, listTwo.id, 1, null);
|
|
});
|
|
});
|
|
|
|
it('moves issue in list', () => {
|
|
const issue = new ListIssue({
|
|
title: 'Testing',
|
|
id: 2,
|
|
iid: 2,
|
|
confidential: false,
|
|
labels: [],
|
|
assignees: [],
|
|
});
|
|
const list = boardsStore.addList(listObj);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
list.addIssue(issue);
|
|
|
|
expect(list.issues.length).toBe(2);
|
|
|
|
boardsStore.moveIssueInList(list, issue, 0, 1, [1, 2]);
|
|
|
|
expect(list.issues[0].id).toBe(2);
|
|
expect(boardsStore.moveIssue).toHaveBeenCalledWith(2, null, null, 1, null);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('setListDetail', () => {
|
|
it('sets the list detail', () => {
|
|
boardsStore.detail.list = 'not a list';
|
|
|
|
const dummyValue = 'new list';
|
|
boardsStore.setListDetail(dummyValue);
|
|
|
|
expect(boardsStore.detail.list).toEqual(dummyValue);
|
|
});
|
|
});
|
|
|
|
describe('clearDetailIssue', () => {
|
|
it('resets issue details', () => {
|
|
boardsStore.detail.issue = 'something';
|
|
|
|
boardsStore.clearDetailIssue();
|
|
|
|
expect(boardsStore.detail.issue).toEqual({});
|
|
});
|
|
});
|
|
|
|
describe('setIssueDetail', () => {
|
|
it('sets issue details', () => {
|
|
boardsStore.detail.issue = 'some details';
|
|
|
|
const dummyValue = 'new details';
|
|
boardsStore.setIssueDetail(dummyValue);
|
|
|
|
expect(boardsStore.detail.issue).toEqual(dummyValue);
|
|
});
|
|
});
|
|
|
|
describe('startMoving', () => {
|
|
it('stores list and issue', () => {
|
|
const dummyIssue = 'some issue';
|
|
const dummyList = 'some list';
|
|
|
|
boardsStore.startMoving(dummyList, dummyIssue);
|
|
|
|
expect(boardsStore.moving.issue).toEqual(dummyIssue);
|
|
expect(boardsStore.moving.list).toEqual(dummyList);
|
|
});
|
|
});
|
|
|
|
describe('setTimeTrackingLimitToHours', () => {
|
|
it('sets the timeTracking.LimitToHours option', () => {
|
|
boardsStore.timeTracking.limitToHours = false;
|
|
|
|
boardsStore.setTimeTrackingLimitToHours('true');
|
|
|
|
expect(boardsStore.timeTracking.limitToHours).toEqual(true);
|
|
});
|
|
});
|
|
|
|
describe('setCurrentBoard', () => {
|
|
const dummyBoard = 'hoverboard';
|
|
|
|
it('sets the current board', () => {
|
|
const { state } = boardsStore;
|
|
state.currentBoard = null;
|
|
|
|
boardsStore.setCurrentBoard(dummyBoard);
|
|
|
|
expect(state.currentBoard).toEqual(dummyBoard);
|
|
});
|
|
});
|
|
|
|
describe('toggleMultiSelect', () => {
|
|
let basicIssueObj;
|
|
|
|
beforeAll(() => {
|
|
basicIssueObj = { id: 987654 };
|
|
});
|
|
|
|
afterEach(() => {
|
|
boardsStore.clearMultiSelect();
|
|
});
|
|
|
|
it('adds issue when not present', () => {
|
|
boardsStore.toggleMultiSelect(basicIssueObj);
|
|
|
|
const selectedIds = boardsStore.multiSelect.list.map(({ id }) => id);
|
|
|
|
expect(selectedIds.includes(basicIssueObj.id)).toEqual(true);
|
|
});
|
|
|
|
it('removes issue when issue is present', () => {
|
|
boardsStore.toggleMultiSelect(basicIssueObj);
|
|
let selectedIds = boardsStore.multiSelect.list.map(({ id }) => id);
|
|
|
|
expect(selectedIds.includes(basicIssueObj.id)).toEqual(true);
|
|
|
|
boardsStore.toggleMultiSelect(basicIssueObj);
|
|
selectedIds = boardsStore.multiSelect.list.map(({ id }) => id);
|
|
|
|
expect(selectedIds.includes(basicIssueObj.id)).toEqual(false);
|
|
});
|
|
});
|
|
|
|
describe('clearMultiSelect', () => {
|
|
it('clears all the multi selected issues', () => {
|
|
const issue1 = { id: 12345 };
|
|
const issue2 = { id: 12346 };
|
|
|
|
boardsStore.toggleMultiSelect(issue1);
|
|
boardsStore.toggleMultiSelect(issue2);
|
|
|
|
expect(boardsStore.multiSelect.list.length).toEqual(2);
|
|
|
|
boardsStore.clearMultiSelect();
|
|
|
|
expect(boardsStore.multiSelect.list.length).toEqual(0);
|
|
});
|
|
});
|
|
|
|
describe('moveMultipleIssuesToList', () => {
|
|
it('move issues on the new index', () => {
|
|
const listOne = boardsStore.addList(listObj);
|
|
const listTwo = boardsStore.addList(listObjDuplicate);
|
|
|
|
expect(boardsStore.state.lists.length).toBe(2);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
expect(listOne.issues.length).toBe(1);
|
|
expect(listTwo.issues.length).toBe(1);
|
|
|
|
boardsStore.moveMultipleIssuesToList({
|
|
listFrom: listOne,
|
|
listTo: listTwo,
|
|
issues: listOne.issues,
|
|
newIndex: 0,
|
|
});
|
|
|
|
expect(listTwo.issues.length).toBe(1);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('moveMultipleIssuesInList', () => {
|
|
it('moves multiple issues in list', () => {
|
|
const issueObj = {
|
|
title: 'Issue #1',
|
|
id: 12345,
|
|
iid: 2,
|
|
confidential: false,
|
|
labels: [],
|
|
assignees: [],
|
|
};
|
|
const issue1 = new ListIssue(issueObj);
|
|
const issue2 = new ListIssue({
|
|
...issueObj,
|
|
title: 'Issue #2',
|
|
id: 12346,
|
|
});
|
|
|
|
const list = boardsStore.addList(listObj);
|
|
|
|
return axios.waitForAll().then(() => {
|
|
list.addIssue(issue1);
|
|
list.addIssue(issue2);
|
|
|
|
expect(list.issues.length).toBe(3);
|
|
expect(list.issues[0].id).not.toBe(issue2.id);
|
|
|
|
boardsStore.moveMultipleIssuesInList({
|
|
list,
|
|
issues: [issue1, issue2],
|
|
oldIndicies: [0],
|
|
newIndex: 1,
|
|
idArray: [1, 12345, 12346],
|
|
});
|
|
|
|
expect(list.issues[0].id).toBe(issue1.id);
|
|
|
|
expect(boardsStore.moveMultipleIssues).toHaveBeenCalledWith({
|
|
ids: [issue1.id, issue2.id],
|
|
fromListId: null,
|
|
toListId: null,
|
|
moveBeforeId: 1,
|
|
moveAfterId: null,
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('addListIssue', () => {
|
|
let list;
|
|
const issue1 = new ListIssue({
|
|
title: 'Testing',
|
|
id: 2,
|
|
iid: 2,
|
|
confidential: false,
|
|
labels: [
|
|
{
|
|
color: '#ff0000',
|
|
description: 'testing;',
|
|
id: 5000,
|
|
priority: undefined,
|
|
textColor: 'white',
|
|
title: 'Test',
|
|
},
|
|
],
|
|
assignees: [],
|
|
});
|
|
const issue2 = new ListIssue({
|
|
title: 'Testing',
|
|
id: 1,
|
|
iid: 1,
|
|
confidential: false,
|
|
labels: [
|
|
{
|
|
id: 1,
|
|
title: 'test',
|
|
color: 'red',
|
|
description: 'testing',
|
|
},
|
|
],
|
|
assignees: [
|
|
{
|
|
id: 1,
|
|
name: 'name',
|
|
username: 'username',
|
|
avatar_url: 'http://avatar_url',
|
|
},
|
|
],
|
|
real_path: 'path/to/issue',
|
|
});
|
|
|
|
beforeEach(() => {
|
|
list = new List(listObj);
|
|
list.addIssue(issue1);
|
|
setupDefaultResponses();
|
|
});
|
|
|
|
it('adds issues that are not already on the list', () => {
|
|
expect(list.findIssue(issue2.id)).toBe(undefined);
|
|
expect(list.issues).toEqual([issue1]);
|
|
|
|
boardsStore.addListIssue(list, issue2);
|
|
expect(list.findIssue(issue2.id)).toBe(issue2);
|
|
expect(list.issues.length).toBe(2);
|
|
expect(list.issues).toEqual([issue1, issue2]);
|
|
});
|
|
});
|
|
|
|
describe('updateIssue', () => {
|
|
let issue;
|
|
let patchSpy;
|
|
|
|
beforeEach(() => {
|
|
issue = new ListIssue({
|
|
title: 'Testing',
|
|
id: 1,
|
|
iid: 1,
|
|
confidential: false,
|
|
labels: [
|
|
{
|
|
id: 1,
|
|
title: 'test',
|
|
color: 'red',
|
|
description: 'testing',
|
|
},
|
|
],
|
|
assignees: [
|
|
{
|
|
id: 1,
|
|
name: 'name',
|
|
username: 'username',
|
|
avatar_url: 'http://avatar_url',
|
|
},
|
|
],
|
|
real_path: 'path/to/issue',
|
|
});
|
|
|
|
patchSpy = jest.fn().mockReturnValue([200, { labels: [] }]);
|
|
axiosMock.onPatch(`path/to/issue.json`).reply(({ data }) => patchSpy(JSON.parse(data)));
|
|
});
|
|
|
|
it('passes assignee ids when there are assignees', () => {
|
|
boardsStore.updateIssue(issue);
|
|
return boardsStore.updateIssue(issue).then(() => {
|
|
expect(patchSpy).toHaveBeenCalledWith({
|
|
issue: {
|
|
milestone_id: null,
|
|
assignee_ids: [1],
|
|
label_ids: [1],
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
it('passes assignee ids of [0] when there are no assignees', () => {
|
|
issue.removeAllAssignees();
|
|
|
|
return boardsStore.updateIssue(issue).then(() => {
|
|
expect(patchSpy).toHaveBeenCalledWith({
|
|
issue: {
|
|
milestone_id: null,
|
|
assignee_ids: [0],
|
|
label_ids: [1],
|
|
},
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|