debian-mirror-gitlab/spec/frontend/notes/stores/getters_spec.js

458 lines
14 KiB
JavaScript
Raw Normal View History

2021-11-18 22:05:49 +05:30
import discussionWithTwoUnresolvedNotes from 'test_fixtures/merge_requests/resolved_diff_discussion.json';
2021-04-29 21:17:54 +05:30
import { DESC, ASC } from '~/notes/constants';
2021-03-11 19:13:27 +05:30
import * as getters from '~/notes/stores/getters';
2018-11-08 19:23:39 +05:30
import {
notesDataMock,
userDataMock,
noteableDataMock,
individualNote,
collapseNotesMock,
2021-01-03 14:25:43 +05:30
discussionMock,
2018-11-18 11:00:15 +05:30
discussion1,
discussion2,
discussion3,
resolvedDiscussion1,
unresolvableDiscussion,
2021-04-29 21:17:54 +05:30
draftComments,
draftReply,
draftDiffDiscussion,
2018-11-08 19:23:39 +05:30
} from '../mock_data';
2019-12-04 20:38:33 +05:30
// Helper function to ensure that we're using the same schema across tests.
const createDiscussionNeighborParams = (discussionId, diffOrder, step) => ({
discussionId,
diffOrder,
step,
});
2021-04-29 21:17:54 +05:30
const asDraftDiscussion = (x) => ({ ...x, individual_note: true });
2018-03-17 18:26:18 +05:30
describe('Getters Notes Store', () => {
let state;
2018-11-08 19:23:39 +05:30
2018-03-17 18:26:18 +05:30
beforeEach(() => {
state = {
2018-11-08 19:23:39 +05:30
discussions: [individualNote],
2018-03-17 18:26:18 +05:30
targetNoteHash: 'hash',
lastFetchedAt: 'timestamp',
2018-11-08 19:23:39 +05:30
isNotesFetched: false,
2018-03-17 18:26:18 +05:30
notesData: notesDataMock,
userData: userDataMock,
noteableData: noteableDataMock,
2020-04-08 14:13:33 +05:30
descriptionVersions: 'descriptionVersions',
2020-04-22 19:07:51 +05:30
discussionSortOrder: DESC,
2018-03-17 18:26:18 +05:30
};
});
2018-11-08 19:23:39 +05:30
2019-09-30 21:07:59 +05:30
describe('showJumpToNextDiscussion', () => {
it('should return true if there are 2 or more unresolved discussions', () => {
const localGetters = {
unresolvedDiscussionsIdsByDate: ['123', '456'],
allResolvableDiscussions: [],
};
expect(getters.showJumpToNextDiscussion(state, localGetters)()).toBe(true);
});
it('should return false if there are 1 or less unresolved discussions', () => {
const localGetters = {
unresolvedDiscussionsIdsByDate: ['123'],
allResolvableDiscussions: [],
};
expect(getters.showJumpToNextDiscussion(state, localGetters)()).toBe(false);
});
});
2018-11-08 19:23:39 +05:30
describe('discussions', () => {
2021-04-29 21:17:54 +05:30
let batchComments = null;
2021-01-03 14:25:43 +05:30
2021-04-29 21:17:54 +05:30
const getDiscussions = () => getters.discussions(state, {}, { batchComments });
2021-01-03 14:25:43 +05:30
2021-04-29 21:17:54 +05:30
describe('without batchComments module', () => {
it('should return all discussions in the store', () => {
expect(getDiscussions()).toEqual([individualNote]);
2021-01-03 14:25:43 +05:30
});
2021-04-29 21:17:54 +05:30
it('should transform discussion to individual notes in timeline view', () => {
state.discussions = [discussionMock];
state.isTimelineEnabled = true;
const discussions = getDiscussions();
expect(discussions.length).toEqual(discussionMock.notes.length);
discussions.forEach((discussion) => {
expect(discussion.individual_note).toBe(true);
expect(discussion.id).toBe(discussion.notes[0].id);
expect(discussion.created_at).toBe(discussion.notes[0].created_at);
});
});
});
describe('with batchComments', () => {
beforeEach(() => {
batchComments = { drafts: [...draftComments, draftReply, draftDiffDiscussion] };
});
it.each`
discussionSortOrder | expectation
${ASC} | ${[individualNote, ...draftComments.map(asDraftDiscussion)]}
${DESC} | ${[...draftComments.reverse().map(asDraftDiscussion), individualNote]}
`(
'only appends draft comments (discussionSortOrder=$discussionSortOrder)',
({ discussionSortOrder, expectation }) => {
state.discussionSortOrder = discussionSortOrder;
expect(getDiscussions()).toEqual(expectation);
},
);
});
});
describe('hasDrafts', () => {
it.each`
rootGetters | expected
${{}} | ${false}
${{ 'batchComments/hasDrafts': true }} | ${true}
${{ 'batchComments/hasDrafts': false }} | ${false}
`('with rootGetters=$rootGetters, returns $expected', ({ rootGetters, expected }) => {
expect(getters.hasDrafts({}, {}, {}, rootGetters)).toBe(expected);
2021-01-03 14:25:43 +05:30
});
2018-11-08 19:23:39 +05:30
});
describe('resolvedDiscussionsById', () => {
it('ignores unresolved system notes', () => {
2021-11-18 22:05:49 +05:30
const [discussion] = discussionWithTwoUnresolvedNotes;
2018-11-08 19:23:39 +05:30
discussion.notes[0].resolved = true;
discussion.notes[1].resolved = false;
state.discussions.push(discussion);
expect(getters.resolvedDiscussionsById(state)).toEqual({
[discussion.id]: discussion,
});
});
});
describe('Collapsed notes', () => {
const stateCollapsedNotes = {
discussions: collapseNotesMock,
targetNoteHash: 'hash',
lastFetchedAt: 'timestamp',
notesData: notesDataMock,
userData: userDataMock,
noteableData: noteableDataMock,
};
it('should return a single system note when a description was updated multiple times', () => {
2021-04-29 21:17:54 +05:30
expect(getters.discussions(stateCollapsedNotes, {}, {}).length).toEqual(1);
2018-03-17 18:26:18 +05:30
});
});
describe('targetNoteHash', () => {
it('should return `targetNoteHash`', () => {
expect(getters.targetNoteHash(state)).toEqual('hash');
});
});
describe('getNotesData', () => {
it('should return all data in `notesData`', () => {
expect(getters.getNotesData(state)).toEqual(notesDataMock);
});
});
describe('getNoteableData', () => {
it('should return all data in `noteableData`', () => {
expect(getters.getNoteableData(state)).toEqual(noteableDataMock);
});
});
describe('getUserData', () => {
it('should return all data in `userData`', () => {
expect(getters.getUserData(state)).toEqual(userDataMock);
});
});
describe('notesById', () => {
it('should return the note for the given id', () => {
expect(getters.notesById(state)).toEqual({ 1390: individualNote.notes[0] });
});
});
describe('getCurrentUserLastNote', () => {
it('should return the last note of the current user', () => {
expect(getters.getCurrentUserLastNote(state)).toEqual(individualNote.notes[0]);
});
});
2018-03-27 19:54:05 +05:30
describe('openState', () => {
it('should return the issue state', () => {
expect(getters.openState(state)).toEqual(noteableDataMock.state);
});
});
2018-11-08 19:23:39 +05:30
describe('isNotesFetched', () => {
it('should return the state for the fetching notes', () => {
expect(getters.isNotesFetched(state)).toBeFalsy();
});
});
2018-11-18 11:00:15 +05:30
describe('allResolvableDiscussions', () => {
it('should return only resolvable discussions in same order', () => {
2019-02-15 15:39:39 +05:30
state.discussions = [
discussion3,
unresolvableDiscussion,
discussion1,
unresolvableDiscussion,
discussion2,
];
2018-11-18 11:00:15 +05:30
2019-02-15 15:39:39 +05:30
expect(getters.allResolvableDiscussions(state)).toEqual([
2018-11-18 11:00:15 +05:30
discussion3,
discussion1,
discussion2,
]);
});
it('should return empty array if there are no resolvable discussions', () => {
2019-02-15 15:39:39 +05:30
state.discussions = [unresolvableDiscussion, unresolvableDiscussion];
2018-11-18 11:00:15 +05:30
2019-02-15 15:39:39 +05:30
expect(getters.allResolvableDiscussions(state)).toEqual([]);
2018-11-18 11:00:15 +05:30
});
});
describe('unresolvedDiscussionsIdsByDiff', () => {
it('should return all discussions IDs in diff order', () => {
const localGetters = {
allResolvableDiscussions: [discussion3, discussion1, discussion2],
};
expect(getters.unresolvedDiscussionsIdsByDiff(state, localGetters)).toEqual([
'abc1',
'abc2',
'abc3',
]);
});
it('should return empty array if all discussions have been resolved', () => {
const localGetters = {
allResolvableDiscussions: [resolvedDiscussion1],
};
expect(getters.unresolvedDiscussionsIdsByDiff(state, localGetters)).toEqual([]);
});
});
describe('unresolvedDiscussionsIdsByDate', () => {
it('should return all discussions in date ascending order', () => {
const localGetters = {
allResolvableDiscussions: [discussion3, discussion1, discussion2],
};
expect(getters.unresolvedDiscussionsIdsByDate(state, localGetters)).toEqual([
'abc2',
'abc1',
'abc3',
]);
});
it('should return empty array if all discussions have been resolved', () => {
const localGetters = {
allResolvableDiscussions: [resolvedDiscussion1],
};
expect(getters.unresolvedDiscussionsIdsByDate(state, localGetters)).toEqual([]);
});
});
describe('unresolvedDiscussionsIdsOrdered', () => {
const localGetters = {
unresolvedDiscussionsIdsByDate: ['123', '456'],
unresolvedDiscussionsIdsByDiff: ['abc', 'def'],
};
it('should return IDs ordered by diff when diffOrder param is true', () => {
expect(getters.unresolvedDiscussionsIdsOrdered(state, localGetters)(true)).toEqual([
'abc',
'def',
]);
});
it('should return IDs ordered by date when diffOrder param is not true', () => {
expect(getters.unresolvedDiscussionsIdsOrdered(state, localGetters)(false)).toEqual([
'123',
'456',
]);
2018-12-13 13:39:08 +05:30
2018-11-18 11:00:15 +05:30
expect(getters.unresolvedDiscussionsIdsOrdered(state, localGetters)(undefined)).toEqual([
'123',
'456',
]);
});
});
describe('isLastUnresolvedDiscussion', () => {
const localGetters = {
unresolvedDiscussionsIdsOrdered: () => ['123', '456', '789'],
};
it('should return true if the discussion id provided is the last', () => {
expect(getters.isLastUnresolvedDiscussion(state, localGetters)('789')).toBe(true);
});
it('should return false if the discussion id provided is not the last', () => {
expect(getters.isLastUnresolvedDiscussion(state, localGetters)('123')).toBe(false);
expect(getters.isLastUnresolvedDiscussion(state, localGetters)('456')).toBe(false);
});
});
2019-12-04 20:38:33 +05:30
describe('findUnresolvedDiscussionIdNeighbor', () => {
let localGetters;
beforeEach(() => {
localGetters = {
unresolvedDiscussionsIdsOrdered: () => ['123', '456', '789'],
};
});
2018-11-18 11:00:15 +05:30
2019-12-04 20:38:33 +05:30
[
{ step: 1, id: '123', expected: '456' },
{ step: 1, id: '456', expected: '789' },
{ step: 1, id: '789', expected: '123' },
{ step: -1, id: '123', expected: '789' },
{ step: -1, id: '456', expected: '123' },
{ step: -1, id: '789', expected: '456' },
].forEach(({ step, id, expected }) => {
it(`with step ${step} and id ${id}, returns next value`, () => {
const params = createDiscussionNeighborParams(id, true, step);
expect(getters.findUnresolvedDiscussionIdNeighbor(state, localGetters)(params)).toBe(
expected,
);
});
2018-11-18 11:00:15 +05:30
});
2019-12-04 20:38:33 +05:30
describe('with 1 unresolved discussion', () => {
beforeEach(() => {
localGetters = {
unresolvedDiscussionsIdsOrdered: () => ['123'],
};
});
2021-03-08 18:12:59 +05:30
[
{ step: 1, id: '123', expected: '123' },
{ step: -1, id: '123', expected: '123' },
].forEach(({ step, id, expected }) => {
it(`with step ${step} and match, returns only value`, () => {
const params = createDiscussionNeighborParams(id, true, step);
expect(getters.findUnresolvedDiscussionIdNeighbor(state, localGetters)(params)).toBe(
expected,
);
});
});
2019-10-12 21:52:04 +05:30
2019-12-04 20:38:33 +05:30
it('with no match, returns only value', () => {
const params = createDiscussionNeighborParams('bogus', true, 1);
expect(getters.findUnresolvedDiscussionIdNeighbor(state, localGetters)(params)).toBe('123');
});
});
describe('with 0 unresolved discussions', () => {
beforeEach(() => {
localGetters = {
unresolvedDiscussionsIdsOrdered: () => [],
};
2019-10-12 21:52:04 +05:30
});
2019-12-04 20:38:33 +05:30
[{ step: 1 }, { step: -1 }].forEach(({ step }) => {
it(`with step ${step}, returns undefined`, () => {
const params = createDiscussionNeighborParams('bogus', true, step);
expect(
getters.findUnresolvedDiscussionIdNeighbor(state, localGetters)(params),
).toBeUndefined();
2019-10-12 21:52:04 +05:30
});
});
});
2019-12-04 20:38:33 +05:30
});
2019-10-12 21:52:04 +05:30
2019-12-04 20:38:33 +05:30
describe('findUnresolvedDiscussionIdNeighbor aliases', () => {
let neighbor;
let findUnresolvedDiscussionIdNeighbor;
let localGetters;
2019-10-12 21:52:04 +05:30
2019-12-04 20:38:33 +05:30
beforeEach(() => {
neighbor = {};
2020-03-13 15:44:24 +05:30
findUnresolvedDiscussionIdNeighbor = jest.fn(() => neighbor);
2019-12-04 20:38:33 +05:30
localGetters = { findUnresolvedDiscussionIdNeighbor };
});
2019-10-12 21:52:04 +05:30
2019-12-04 20:38:33 +05:30
describe('nextUnresolvedDiscussionId', () => {
it('should return result of find neighbor', () => {
const expectedParams = createDiscussionNeighborParams('123', true, 1);
const result = getters.nextUnresolvedDiscussionId(state, localGetters)('123', true);
expect(findUnresolvedDiscussionIdNeighbor).toHaveBeenCalledWith(expectedParams);
expect(result).toBe(neighbor);
2019-10-12 21:52:04 +05:30
});
});
2019-12-04 20:38:33 +05:30
describe('previosuUnresolvedDiscussionId', () => {
it('should return result of find neighbor', () => {
const expectedParams = createDiscussionNeighborParams('123', true, -1);
const result = getters.previousUnresolvedDiscussionId(state, localGetters)('123', true);
2019-10-12 21:52:04 +05:30
2019-12-04 20:38:33 +05:30
expect(findUnresolvedDiscussionIdNeighbor).toHaveBeenCalledWith(expectedParams);
expect(result).toBe(neighbor);
2019-10-12 21:52:04 +05:30
});
});
});
2018-11-18 11:00:15 +05:30
describe('firstUnresolvedDiscussionId', () => {
const localGetters = {
unresolvedDiscussionsIdsByDate: ['123', '456'],
unresolvedDiscussionsIdsByDiff: ['abc', 'def'],
};
it('should return the first discussion id by diff when diffOrder param is true', () => {
expect(getters.firstUnresolvedDiscussionId(state, localGetters)(true)).toBe('abc');
});
it('should return the first discussion id by date when diffOrder param is not true', () => {
expect(getters.firstUnresolvedDiscussionId(state, localGetters)(false)).toBe('123');
expect(getters.firstUnresolvedDiscussionId(state, localGetters)(undefined)).toBe('123');
});
it('should be falsy if all discussions are resolved', () => {
const localGettersFalsy = {
unresolvedDiscussionsIdsByDiff: [],
unresolvedDiscussionsIdsByDate: [],
};
expect(getters.firstUnresolvedDiscussionId(state, localGettersFalsy)(true)).toBeFalsy();
expect(getters.firstUnresolvedDiscussionId(state, localGettersFalsy)(false)).toBeFalsy();
});
});
2019-07-07 11:18:12 +05:30
describe('getDiscussion', () => {
it('returns discussion by ID', () => {
state.discussions.push({ id: '1' });
expect(getters.getDiscussion(state)('1')).toEqual({ id: '1' });
});
});
2020-04-08 14:13:33 +05:30
describe('descriptionVersions', () => {
it('should return `descriptionVersions`', () => {
expect(getters.descriptionVersions(state)).toEqual('descriptionVersions');
});
});
2020-04-22 19:07:51 +05:30
describe('sortDirection', () => {
it('should return `discussionSortOrder`', () => {
expect(getters.sortDirection(state)).toBe(DESC);
});
});
2018-03-17 18:26:18 +05:30
});