debian-mirror-gitlab/spec/frontend/diffs/store/utils_spec.js

1116 lines
35 KiB
JavaScript
Raw Normal View History

2020-04-08 14:13:33 +05:30
import { clone } from 'lodash';
2018-11-08 19:23:39 +05:30
import * as utils from '~/diffs/store/utils';
import {
LINE_POSITION_LEFT,
LINE_POSITION_RIGHT,
TEXT_DIFF_POSITION_TYPE,
2018-12-05 23:21:45 +05:30
LEGACY_DIFF_NOTE_TYPE,
2018-11-08 19:23:39 +05:30
DIFF_NOTE_TYPE,
NEW_LINE_TYPE,
OLD_LINE_TYPE,
MATCH_LINE_TYPE,
2020-04-08 14:13:33 +05:30
INLINE_DIFF_VIEW_TYPE,
2018-11-08 19:23:39 +05:30
PARALLEL_DIFF_VIEW_TYPE,
} from '~/diffs/constants';
import { MERGE_REQUEST_NOTEABLE_TYPE } from '~/notes/constants';
import diffFileMockData from '../mock_data/diff_file';
2020-06-23 00:09:42 +05:30
import { diffMetadata } from '../mock_data/diff_metadata';
2018-11-08 19:23:39 +05:30
import { noteableDataMock } from '../../notes/mock_data';
2019-07-07 11:18:12 +05:30
const getDiffFileMock = () => JSON.parse(JSON.stringify(diffFileMockData));
2020-06-23 00:09:42 +05:30
const getDiffMetadataMock = () => JSON.parse(JSON.stringify(diffMetadata));
2018-11-08 19:23:39 +05:30
describe('DiffsStoreUtils', () => {
describe('findDiffFile', () => {
2019-02-15 15:39:39 +05:30
const files = [{ file_hash: 1, name: 'one' }];
2018-11-08 19:23:39 +05:30
it('should return correct file', () => {
expect(utils.findDiffFile(files, 1).name).toEqual('one');
expect(utils.findDiffFile(files, 2)).toBeUndefined();
});
});
describe('getReversePosition', () => {
it('should return correct line position name', () => {
expect(utils.getReversePosition(LINE_POSITION_RIGHT)).toEqual(LINE_POSITION_LEFT);
expect(utils.getReversePosition(LINE_POSITION_LEFT)).toEqual(LINE_POSITION_RIGHT);
});
});
describe('findIndexInInlineLines and findIndexInParallelLines', () => {
const expectSet = (method, lines, invalidLines) => {
expect(method(lines, { oldLineNumber: 3, newLineNumber: 5 })).toEqual(4);
expect(method(invalidLines || lines, { oldLineNumber: 32, newLineNumber: 53 })).toEqual(-1);
};
describe('findIndexInInlineLines', () => {
it('should return correct index for given line numbers', () => {
2019-02-15 15:39:39 +05:30
expectSet(utils.findIndexInInlineLines, getDiffFileMock().highlighted_diff_lines);
2018-11-08 19:23:39 +05:30
});
});
describe('findIndexInParallelLines', () => {
it('should return correct index for given line numbers', () => {
2020-04-08 14:13:33 +05:30
expectSet(utils.findIndexInParallelLines, getDiffFileMock().parallel_diff_lines, []);
});
});
});
describe('getPreviousLineIndex', () => {
[
{ diffViewType: INLINE_DIFF_VIEW_TYPE, file: { parallel_diff_lines: [] } },
{ diffViewType: PARALLEL_DIFF_VIEW_TYPE, file: { highlighted_diff_lines: [] } },
].forEach(({ diffViewType, file }) => {
describe(`with diffViewType (${diffViewType}) in split diffs`, () => {
let diffFile;
beforeEach(() => {
diffFile = { ...clone(diffFileMockData), ...file };
});
it('should return the correct previous line number', () => {
const emptyLines =
diffViewType === INLINE_DIFF_VIEW_TYPE
? diffFile.parallel_diff_lines
: diffFile.highlighted_diff_lines;
// This expectation asserts that we cannot possibly be using the opposite view type lines in the next expectation
expect(emptyLines.length).toBe(0);
expect(
utils.getPreviousLineIndex(diffViewType, diffFile, {
oldLineNumber: 3,
newLineNumber: 5,
}),
).toBe(4);
});
2018-11-08 19:23:39 +05:30
});
});
});
describe('removeMatchLine', () => {
it('should remove match line properly by regarding the bottom parameter', () => {
const diffFile = getDiffFileMock();
const lineNumbers = { oldLineNumber: 3, newLineNumber: 5 };
2019-02-15 15:39:39 +05:30
const inlineIndex = utils.findIndexInInlineLines(
diffFile.highlighted_diff_lines,
lineNumbers,
);
const parallelIndex = utils.findIndexInParallelLines(
diffFile.parallel_diff_lines,
lineNumbers,
);
const atInlineIndex = diffFile.highlighted_diff_lines[inlineIndex];
const atParallelIndex = diffFile.parallel_diff_lines[parallelIndex];
2018-11-08 19:23:39 +05:30
utils.removeMatchLine(diffFile, lineNumbers, false);
2018-12-13 13:39:08 +05:30
2019-02-15 15:39:39 +05:30
expect(diffFile.highlighted_diff_lines[inlineIndex]).not.toEqual(atInlineIndex);
expect(diffFile.parallel_diff_lines[parallelIndex]).not.toEqual(atParallelIndex);
2018-11-08 19:23:39 +05:30
utils.removeMatchLine(diffFile, lineNumbers, true);
2018-12-13 13:39:08 +05:30
2019-02-15 15:39:39 +05:30
expect(diffFile.highlighted_diff_lines[inlineIndex + 1]).not.toEqual(atInlineIndex);
expect(diffFile.parallel_diff_lines[parallelIndex + 1]).not.toEqual(atParallelIndex);
2018-11-08 19:23:39 +05:30
});
});
describe('addContextLines', () => {
2020-04-08 14:13:33 +05:30
[INLINE_DIFF_VIEW_TYPE, PARALLEL_DIFF_VIEW_TYPE].forEach(diffViewType => {
it(`should add context lines for ${diffViewType}`, () => {
const diffFile = getDiffFileMock();
const inlineLines = diffFile.highlighted_diff_lines;
const parallelLines = diffFile.parallel_diff_lines;
const lineNumbers = { oldLineNumber: 3, newLineNumber: 5 };
const contextLines = [{ lineNumber: 42, line_code: '123' }];
const options = { inlineLines, parallelLines, contextLines, lineNumbers, diffViewType };
const inlineIndex = utils.findIndexInInlineLines(inlineLines, lineNumbers);
const parallelIndex = utils.findIndexInParallelLines(parallelLines, lineNumbers);
const normalizedParallelLine = {
left: options.contextLines[0],
right: options.contextLines[0],
line_code: '123',
};
utils.addContextLines(options);
if (diffViewType === INLINE_DIFF_VIEW_TYPE) {
expect(inlineLines[inlineIndex]).toEqual(contextLines[0]);
} else {
expect(parallelLines[parallelIndex]).toEqual(normalizedParallelLine);
}
});
2019-07-07 11:18:12 +05:30
2020-04-08 14:13:33 +05:30
it(`should add context lines properly with bottom parameter for ${diffViewType}`, () => {
const diffFile = getDiffFileMock();
const inlineLines = diffFile.highlighted_diff_lines;
const parallelLines = diffFile.parallel_diff_lines;
const lineNumbers = { oldLineNumber: 3, newLineNumber: 5 };
const contextLines = [{ lineNumber: 42, line_code: '123' }];
const options = {
inlineLines,
parallelLines,
contextLines,
lineNumbers,
bottom: true,
diffViewType,
};
const normalizedParallelLine = {
left: options.contextLines[0],
right: options.contextLines[0],
line_code: '123',
};
utils.addContextLines(options);
if (diffViewType === INLINE_DIFF_VIEW_TYPE) {
expect(inlineLines[inlineLines.length - 1]).toEqual(contextLines[0]);
} else {
expect(parallelLines[parallelLines.length - 1]).toEqual(normalizedParallelLine);
}
});
2018-11-08 19:23:39 +05:30
});
});
describe('getNoteFormData', () => {
it('should properly create note form data', () => {
const diffFile = getDiffFileMock();
noteableDataMock.targetType = MERGE_REQUEST_NOTEABLE_TYPE;
const options = {
note: 'Hello world!',
noteableData: noteableDataMock,
noteableType: MERGE_REQUEST_NOTEABLE_TYPE,
diffFile,
noteTargetLine: {
2019-02-15 15:39:39 +05:30
line_code: '1c497fbb3a46b78edf04cc2a2fa33f67e3ffbe2a_1_3',
meta_data: null,
new_line: 3,
old_line: 1,
2018-11-08 19:23:39 +05:30
},
diffViewType: PARALLEL_DIFF_VIEW_TYPE,
linePosition: LINE_POSITION_LEFT,
2020-06-23 00:09:42 +05:30
lineRange: { start_line_code: 'abc_1_1', end_line_code: 'abc_2_2' },
2018-11-08 19:23:39 +05:30
};
const position = JSON.stringify({
2019-02-15 15:39:39 +05:30
base_sha: diffFile.diff_refs.base_sha,
start_sha: diffFile.diff_refs.start_sha,
head_sha: diffFile.diff_refs.head_sha,
old_path: diffFile.old_path,
new_path: diffFile.new_path,
2018-11-08 19:23:39 +05:30
position_type: TEXT_DIFF_POSITION_TYPE,
2019-02-15 15:39:39 +05:30
old_line: options.noteTargetLine.old_line,
new_line: options.noteTargetLine.new_line,
2020-06-23 00:09:42 +05:30
line_range: options.lineRange,
2018-11-08 19:23:39 +05:30
});
const postData = {
view: options.diffViewType,
line_type: options.linePosition === LINE_POSITION_RIGHT ? NEW_LINE_TYPE : OLD_LINE_TYPE,
2019-02-15 15:39:39 +05:30
merge_request_diff_head_sha: diffFile.diff_refs.head_sha,
2018-11-08 19:23:39 +05:30
in_reply_to_discussion_id: '',
note_project_id: '',
target_type: options.noteableType,
target_id: options.noteableData.id,
2018-12-05 23:21:45 +05:30
return_discussion: true,
2018-11-08 19:23:39 +05:30
note: {
noteable_type: options.noteableType,
noteable_id: options.noteableData.id,
2019-02-15 15:39:39 +05:30
commit_id: undefined,
2018-11-08 19:23:39 +05:30
type: DIFF_NOTE_TYPE,
2019-02-15 15:39:39 +05:30
line_code: options.noteTargetLine.line_code,
2018-11-08 19:23:39 +05:30
note: options.note,
position,
},
};
expect(utils.getNoteFormData(options)).toEqual({
endpoint: options.noteableData.create_note_path,
data: postData,
});
});
2018-12-05 23:21:45 +05:30
it('should create legacy note form data', () => {
const diffFile = getDiffFileMock();
2019-02-15 15:39:39 +05:30
delete diffFile.diff_refs.start_sha;
delete diffFile.diff_refs.head_sha;
2018-12-05 23:21:45 +05:30
noteableDataMock.targetType = MERGE_REQUEST_NOTEABLE_TYPE;
const options = {
note: 'Hello world!',
noteableData: noteableDataMock,
noteableType: MERGE_REQUEST_NOTEABLE_TYPE,
diffFile,
noteTargetLine: {
2019-02-15 15:39:39 +05:30
line_code: '1c497fbb3a46b78edf04cc2a2fa33f67e3ffbe2a_1_3',
meta_data: null,
new_line: 3,
old_line: 1,
2018-12-05 23:21:45 +05:30
},
diffViewType: PARALLEL_DIFF_VIEW_TYPE,
linePosition: LINE_POSITION_LEFT,
};
const position = JSON.stringify({
2019-02-15 15:39:39 +05:30
base_sha: diffFile.diff_refs.base_sha,
2018-12-05 23:21:45 +05:30
start_sha: undefined,
head_sha: undefined,
2019-02-15 15:39:39 +05:30
old_path: diffFile.old_path,
new_path: diffFile.new_path,
2018-12-05 23:21:45 +05:30
position_type: TEXT_DIFF_POSITION_TYPE,
2019-02-15 15:39:39 +05:30
old_line: options.noteTargetLine.old_line,
new_line: options.noteTargetLine.new_line,
2018-12-05 23:21:45 +05:30
});
const postData = {
view: options.diffViewType,
line_type: options.linePosition === LINE_POSITION_RIGHT ? NEW_LINE_TYPE : OLD_LINE_TYPE,
merge_request_diff_head_sha: undefined,
in_reply_to_discussion_id: '',
note_project_id: '',
target_type: options.noteableType,
target_id: options.noteableData.id,
return_discussion: true,
note: {
noteable_type: options.noteableType,
noteable_id: options.noteableData.id,
2019-02-15 15:39:39 +05:30
commit_id: undefined,
2018-12-05 23:21:45 +05:30
type: LEGACY_DIFF_NOTE_TYPE,
2019-02-15 15:39:39 +05:30
line_code: options.noteTargetLine.line_code,
2018-12-05 23:21:45 +05:30
note: options.note,
position,
},
};
expect(utils.getNoteFormData(options)).toEqual({
endpoint: options.noteableData.create_note_path,
data: postData,
});
});
2018-11-08 19:23:39 +05:30
});
describe('addLineReferences', () => {
const lineNumbers = { oldLineNumber: 3, newLineNumber: 4 };
it('should add correct line references when bottom set to true', () => {
const lines = [{ type: null }, { type: MATCH_LINE_TYPE }];
const linesWithReferences = utils.addLineReferences(lines, lineNumbers, true);
2019-02-15 15:39:39 +05:30
expect(linesWithReferences[0].old_line).toEqual(lineNumbers.oldLineNumber + 1);
expect(linesWithReferences[0].new_line).toEqual(lineNumbers.newLineNumber + 1);
expect(linesWithReferences[1].meta_data.old_pos).toEqual(4);
expect(linesWithReferences[1].meta_data.new_pos).toEqual(5);
2018-11-08 19:23:39 +05:30
});
it('should add correct line references when bottom falsy', () => {
const lines = [{ type: null }, { type: MATCH_LINE_TYPE }, { type: null }];
const linesWithReferences = utils.addLineReferences(lines, lineNumbers);
2019-02-15 15:39:39 +05:30
expect(linesWithReferences[0].old_line).toEqual(0);
expect(linesWithReferences[0].new_line).toEqual(1);
expect(linesWithReferences[1].meta_data.old_pos).toEqual(2);
expect(linesWithReferences[1].meta_data.new_pos).toEqual(3);
2018-11-08 19:23:39 +05:30
});
2019-10-12 21:52:04 +05:30
it('should add correct line references when isExpandDown is true', () => {
const lines = [{ type: null }, { type: MATCH_LINE_TYPE }];
const linesWithReferences = utils.addLineReferences(lines, lineNumbers, false, true, {
old_line: 10,
new_line: 11,
});
expect(linesWithReferences[1].meta_data.old_pos).toEqual(10);
expect(linesWithReferences[1].meta_data.new_pos).toEqual(11);
});
2018-11-08 19:23:39 +05:30
});
describe('trimFirstCharOfLineContent', () => {
it('trims the line when it starts with a space', () => {
2019-02-15 15:39:39 +05:30
expect(utils.trimFirstCharOfLineContent({ rich_text: ' diff' })).toEqual({
rich_text: 'diff',
2018-11-20 20:47:30 +05:30
});
2018-11-08 19:23:39 +05:30
});
it('trims the line when it starts with a +', () => {
2019-02-15 15:39:39 +05:30
expect(utils.trimFirstCharOfLineContent({ rich_text: '+diff' })).toEqual({
rich_text: 'diff',
2018-11-20 20:47:30 +05:30
});
2018-11-08 19:23:39 +05:30
});
it('trims the line when it starts with a -', () => {
2019-02-15 15:39:39 +05:30
expect(utils.trimFirstCharOfLineContent({ rich_text: '-diff' })).toEqual({
rich_text: 'diff',
2018-11-20 20:47:30 +05:30
});
2018-11-08 19:23:39 +05:30
});
it('does not trims the line when it starts with a letter', () => {
2019-02-15 15:39:39 +05:30
expect(utils.trimFirstCharOfLineContent({ rich_text: 'diff' })).toEqual({
rich_text: 'diff',
2018-11-20 20:47:30 +05:30
});
2018-11-08 19:23:39 +05:30
});
it('does not modify the provided object', () => {
const lineObj = {
2019-02-15 15:39:39 +05:30
rich_text: ' diff',
2018-11-08 19:23:39 +05:30
};
utils.trimFirstCharOfLineContent(lineObj);
2018-12-13 13:39:08 +05:30
2019-03-02 22:35:43 +05:30
expect(lineObj).toEqual({ rich_text: ' diff' });
2018-11-08 19:23:39 +05:30
});
it('handles a undefined or null parameter', () => {
2019-03-02 22:35:43 +05:30
expect(utils.trimFirstCharOfLineContent()).toEqual({});
2018-11-20 20:47:30 +05:30
});
});
2020-05-24 23:13:21 +05:30
describe('prepareLineForRenamedFile', () => {
const diffFile = {
file_hash: 'file-hash',
};
const lineIndex = 4;
const sourceLine = {
foo: 'test',
rich_text: ' <p>rich</p>', // Note the leading space
};
const correctLine = {
foo: 'test',
line_code: 'file-hash_5_5',
old_line: 5,
new_line: 5,
rich_text: '<p>rich</p>', // Note no leading space
discussionsExpanded: true,
discussions: [],
hasForm: false,
text: undefined,
alreadyPrepared: true,
};
let preppedLine;
beforeEach(() => {
preppedLine = utils.prepareLineForRenamedFile({
diffViewType: INLINE_DIFF_VIEW_TYPE,
line: sourceLine,
index: lineIndex,
diffFile,
});
});
it('copies over the original line object to the new prepared line', () => {
expect(preppedLine).toEqual(
expect.objectContaining({
foo: correctLine.foo,
rich_text: correctLine.rich_text,
}),
);
});
it('correctly sets the old and new lines, plus a line code', () => {
expect(preppedLine.old_line).toEqual(correctLine.old_line);
expect(preppedLine.new_line).toEqual(correctLine.new_line);
expect(preppedLine.line_code).toEqual(correctLine.line_code);
});
it('returns a single object with the correct structure for `inline` lines', () => {
expect(preppedLine).toEqual(correctLine);
});
it('returns a nested object with "left" and "right" lines + the line code for `parallel` lines', () => {
preppedLine = utils.prepareLineForRenamedFile({
diffViewType: PARALLEL_DIFF_VIEW_TYPE,
line: sourceLine,
index: lineIndex,
diffFile,
});
expect(Object.keys(preppedLine)).toEqual(['left', 'right', 'line_code']);
expect(preppedLine.left).toEqual(correctLine);
expect(preppedLine.right).toEqual(correctLine);
expect(preppedLine.line_code).toEqual(correctLine.line_code);
});
});
2018-11-20 20:47:30 +05:30
describe('prepareDiffData', () => {
2020-06-23 00:09:42 +05:30
describe('for regular diff files', () => {
let mock;
let preparedDiff;
let splitInlineDiff;
let splitParallelDiff;
let completedDiff;
beforeEach(() => {
mock = getDiffFileMock();
preparedDiff = { diff_files: [mock] };
splitInlineDiff = {
diff_files: [{ ...mock, parallel_diff_lines: undefined }],
};
splitParallelDiff = {
diff_files: [{ ...mock, highlighted_diff_lines: undefined }],
};
completedDiff = {
diff_files: [{ ...mock, highlighted_diff_lines: undefined }],
};
2019-02-15 15:39:39 +05:30
2020-06-23 00:09:42 +05:30
preparedDiff.diff_files = utils.prepareDiffData(preparedDiff);
splitInlineDiff.diff_files = utils.prepareDiffData(splitInlineDiff);
splitParallelDiff.diff_files = utils.prepareDiffData(splitParallelDiff);
completedDiff.diff_files = utils.prepareDiffData(completedDiff, [mock]);
});
2020-03-13 15:44:24 +05:30
2020-06-23 00:09:42 +05:30
it('sets the renderIt and collapsed attribute on files', () => {
const firstParallelDiffLine = preparedDiff.diff_files[0].parallel_diff_lines[2];
2018-11-20 20:47:30 +05:30
2020-06-23 00:09:42 +05:30
expect(firstParallelDiffLine.left.discussions.length).toBe(0);
expect(firstParallelDiffLine.left).not.toHaveAttr('text');
expect(firstParallelDiffLine.right.discussions.length).toBe(0);
expect(firstParallelDiffLine.right).not.toHaveAttr('text');
const firstParallelChar = firstParallelDiffLine.right.rich_text.charAt(0);
2018-12-13 13:39:08 +05:30
2020-06-23 00:09:42 +05:30
expect(firstParallelChar).not.toBe(' ');
expect(firstParallelChar).not.toBe('+');
expect(firstParallelChar).not.toBe('-');
2018-12-13 13:39:08 +05:30
2020-06-23 00:09:42 +05:30
const checkLine = preparedDiff.diff_files[0].highlighted_diff_lines[0];
2018-11-20 20:47:30 +05:30
2020-06-23 00:09:42 +05:30
expect(checkLine.discussions.length).toBe(0);
expect(checkLine).not.toHaveAttr('text');
const firstChar = checkLine.rich_text.charAt(0);
2018-12-13 13:39:08 +05:30
2020-06-23 00:09:42 +05:30
expect(firstChar).not.toBe(' ');
expect(firstChar).not.toBe('+');
expect(firstChar).not.toBe('-');
2018-12-13 13:39:08 +05:30
2020-06-23 00:09:42 +05:30
expect(preparedDiff.diff_files[0].renderIt).toBeTruthy();
expect(preparedDiff.diff_files[0].collapsed).toBeFalsy();
});
2018-11-20 20:47:30 +05:30
2020-06-23 00:09:42 +05:30
it('adds line_code to all lines', () => {
expect(
preparedDiff.diff_files[0].parallel_diff_lines.filter(line => !line.line_code),
).toHaveLength(0);
});
2019-02-15 15:39:39 +05:30
2020-06-23 00:09:42 +05:30
it('uses right line code if left has none', () => {
const firstLine = preparedDiff.diff_files[0].parallel_diff_lines[0];
2019-02-15 15:39:39 +05:30
2020-06-23 00:09:42 +05:30
expect(firstLine.line_code).toEqual(firstLine.right.line_code);
});
2019-02-15 15:39:39 +05:30
2020-06-23 00:09:42 +05:30
it('guarantees an empty array for both diff styles', () => {
expect(splitInlineDiff.diff_files[0].parallel_diff_lines.length).toEqual(0);
expect(splitInlineDiff.diff_files[0].highlighted_diff_lines.length).toBeGreaterThan(0);
expect(splitParallelDiff.diff_files[0].parallel_diff_lines.length).toBeGreaterThan(0);
expect(splitParallelDiff.diff_files[0].highlighted_diff_lines.length).toEqual(0);
});
2020-03-13 15:44:24 +05:30
2020-06-23 00:09:42 +05:30
it('merges existing diff files with newly loaded diff files to ensure split diffs are eventually completed', () => {
expect(completedDiff.diff_files.length).toEqual(1);
expect(completedDiff.diff_files[0].parallel_diff_lines.length).toBeGreaterThan(0);
expect(completedDiff.diff_files[0].highlighted_diff_lines.length).toBeGreaterThan(0);
});
2020-03-13 15:44:24 +05:30
2020-06-23 00:09:42 +05:30
it('leaves files in the existing state', () => {
const priorFiles = [mock];
const fakeNewFile = {
...mock,
content_sha: 'ABC',
file_hash: 'DEF',
};
const updatedFilesList = utils.prepareDiffData({ diff_files: [fakeNewFile] }, priorFiles);
2020-03-13 15:44:24 +05:30
2020-06-23 00:09:42 +05:30
expect(updatedFilesList).toEqual([mock, fakeNewFile]);
});
2020-03-13 15:44:24 +05:30
2020-06-23 00:09:42 +05:30
it('completes an existing split diff without overwriting existing diffs', () => {
// The current state has a file that has only loaded inline lines
const priorFiles = [{ ...mock, parallel_diff_lines: [] }];
// The next (batch) load loads two files: the other half of that file, and a new file
const fakeBatch = [
{ ...mock, highlighted_diff_lines: undefined },
{ ...mock, highlighted_diff_lines: undefined, content_sha: 'ABC', file_hash: 'DEF' },
];
const updatedFilesList = utils.prepareDiffData({ diff_files: fakeBatch }, priorFiles);
expect(updatedFilesList).toEqual([
mock,
expect.objectContaining({
content_sha: 'ABC',
file_hash: 'DEF',
}),
]);
});
2020-03-13 15:44:24 +05:30
});
2020-06-23 00:09:42 +05:30
describe('for diff metadata', () => {
let mock;
let preparedDiffFiles;
beforeEach(() => {
mock = getDiffMetadataMock();
preparedDiffFiles = utils.prepareDiffData(mock);
});
it('sets the renderIt and collapsed attribute on files', () => {
expect(preparedDiffFiles[0].renderIt).toBeTruthy();
expect(preparedDiffFiles[0].collapsed).toBeFalsy();
});
it('guarantees an empty array of lines for both diff styles', () => {
expect(preparedDiffFiles[0].parallel_diff_lines.length).toEqual(0);
expect(preparedDiffFiles[0].highlighted_diff_lines.length).toEqual(0);
});
it('leaves files in the existing state', () => {
const fileMock = getDiffFileMock();
const metaData = getDiffMetadataMock();
const priorFiles = [fileMock];
const updatedFilesList = utils.prepareDiffData(metaData, priorFiles);
expect(updatedFilesList.length).toEqual(2);
expect(updatedFilesList[0]).toEqual(fileMock);
});
it('adds a new file to the file that already exists in state', () => {
// This is actually buggy behavior:
// Because the metadata doesn't include a content_sha,
// the de-duplicator in prepareDiffData doesn't realize it
// should combine these two.
// This buggy behavior hasn't caused a defect YET, because
// `diffs_metadata.json` is only called the first time the
// diffs app starts up, which is:
// - after a fresh page load
// - after you switch to the changes tab *the first time*
// This test should begin FAILING and can be reversed to check
// for just a single file when this is implemented:
// https://gitlab.com/groups/gitlab-org/-/epics/2852#note_304803233
const fileMock = getDiffFileMock();
const metaMock = getDiffMetadataMock();
const priorFiles = [{ ...fileMock }];
const updatedFilesList = utils.prepareDiffData(metaMock, priorFiles);
expect(updatedFilesList).toEqual([
fileMock,
{
...metaMock.diff_files[0],
highlighted_diff_lines: [],
parallel_diff_lines: [],
},
]);
});
2020-03-13 15:44:24 +05:30
});
2018-11-20 20:47:30 +05:30
});
describe('isDiscussionApplicableToLine', () => {
const diffPosition = {
baseSha: 'ed13df29948c41ba367caa757ab3ec4892509910',
headSha: 'b921914f9a834ac47e6fd9420f78db0f83559130',
newLine: null,
newPath: '500-lines-4.txt',
oldLine: 5,
oldPath: '500-lines-4.txt',
startSha: 'ed13df29948c41ba367caa757ab3ec4892509910',
};
const wrongDiffPosition = {
baseSha: 'wrong',
headSha: 'wrong',
newLine: null,
newPath: '500-lines-4.txt',
oldLine: 5,
oldPath: '500-lines-4.txt',
startSha: 'wrong',
};
const discussions = {
upToDateDiscussion1: {
original_position: diffPosition,
position: wrongDiffPosition,
},
outDatedDiscussion1: {
original_position: wrongDiffPosition,
position: wrongDiffPosition,
},
};
2020-05-24 23:13:21 +05:30
// When multi line comments are fully implemented `line_code` will be
// included in all requests. Until then we need to ensure the logic does
// not change when it is included only in the "comparison" argument.
const lineRange = { start_line_code: 'abc_1_1', end_line_code: 'abc_1_2' };
2018-11-20 20:47:30 +05:30
it('returns true when the discussion is up to date', () => {
expect(
2018-12-05 23:21:45 +05:30
utils.isDiscussionApplicableToLine({
discussion: discussions.upToDateDiscussion1,
2020-05-24 23:13:21 +05:30
diffPosition: { ...diffPosition, line_range: lineRange },
2018-12-05 23:21:45 +05:30
latestDiff: true,
}),
2018-11-20 20:47:30 +05:30
).toBe(true);
});
it('returns false when the discussion is not up to date', () => {
expect(
2018-12-05 23:21:45 +05:30
utils.isDiscussionApplicableToLine({
discussion: discussions.outDatedDiscussion1,
2020-05-24 23:13:21 +05:30
diffPosition: { ...diffPosition, line_range: lineRange },
2018-12-05 23:21:45 +05:30
latestDiff: true,
}),
).toBe(false);
});
it('returns true when line codes match and discussion does not contain position and is not active', () => {
const discussion = { ...discussions.outDatedDiscussion1, line_code: 'ABC_1', active: false };
delete discussion.original_position;
delete discussion.position;
expect(
utils.isDiscussionApplicableToLine({
discussion,
diffPosition: {
...diffPosition,
lineCode: 'ABC_1',
2020-05-24 23:13:21 +05:30
line_range: lineRange,
2018-12-05 23:21:45 +05:30
},
latestDiff: true,
}),
2018-11-20 20:47:30 +05:30
).toBe(false);
2018-11-08 19:23:39 +05:30
});
2018-12-05 23:21:45 +05:30
it('returns true when line codes match and discussion does not contain position and is active', () => {
const discussion = { ...discussions.outDatedDiscussion1, line_code: 'ABC_1', active: true };
delete discussion.original_position;
delete discussion.position;
expect(
utils.isDiscussionApplicableToLine({
discussion,
diffPosition: {
...diffPosition,
2019-02-15 15:39:39 +05:30
line_code: 'ABC_1',
2020-05-24 23:13:21 +05:30
line_range: lineRange,
2018-12-05 23:21:45 +05:30
},
latestDiff: true,
}),
).toBe(true);
});
it('returns false when not latest diff', () => {
const discussion = { ...discussions.outDatedDiscussion1, line_code: 'ABC_1', active: true };
delete discussion.original_position;
delete discussion.position;
expect(
utils.isDiscussionApplicableToLine({
discussion,
diffPosition: {
...diffPosition,
lineCode: 'ABC_1',
2020-05-24 23:13:21 +05:30
line_range: lineRange,
2018-12-05 23:21:45 +05:30
},
latestDiff: false,
}),
).toBe(false);
});
});
describe('generateTreeList', () => {
let files;
beforeAll(() => {
files = [
{
2019-02-15 15:39:39 +05:30
new_path: 'app/index.js',
deleted_file: false,
new_file: false,
removed_lines: 10,
added_lines: 0,
file_hash: 'test',
2018-12-05 23:21:45 +05:30
},
{
2019-02-15 15:39:39 +05:30
new_path: 'app/test/index.js',
deleted_file: false,
new_file: true,
removed_lines: 0,
added_lines: 0,
file_hash: 'test',
2018-12-05 23:21:45 +05:30
},
2018-12-13 13:39:08 +05:30
{
2019-02-15 15:39:39 +05:30
new_path: 'app/test/filepathneedstruncating.js',
deleted_file: false,
new_file: true,
removed_lines: 0,
added_lines: 0,
file_hash: 'test',
2018-12-13 13:39:08 +05:30
},
2018-12-05 23:21:45 +05:30
{
2019-02-15 15:39:39 +05:30
new_path: 'package.json',
deleted_file: true,
new_file: false,
removed_lines: 0,
added_lines: 0,
file_hash: 'test',
2018-12-05 23:21:45 +05:30
},
];
});
it('creates a tree of files', () => {
const { tree } = utils.generateTreeList(files);
expect(tree).toEqual([
{
key: 'app',
path: 'app',
name: 'app',
type: 'tree',
tree: [
{
addedLines: 0,
changed: true,
deleted: false,
fileHash: 'test',
key: 'app/index.js',
name: 'index.js',
2019-03-02 22:35:43 +05:30
parentPath: 'app/',
2018-12-05 23:21:45 +05:30
path: 'app/index.js',
removedLines: 10,
tempFile: false,
type: 'blob',
tree: [],
},
{
key: 'app/test',
path: 'app/test',
name: 'test',
type: 'tree',
opened: true,
tree: [
{
addedLines: 0,
changed: true,
deleted: false,
fileHash: 'test',
key: 'app/test/index.js',
name: 'index.js',
2019-03-02 22:35:43 +05:30
parentPath: 'app/test/',
2018-12-05 23:21:45 +05:30
path: 'app/test/index.js',
removedLines: 0,
tempFile: true,
type: 'blob',
tree: [],
},
2018-12-13 13:39:08 +05:30
{
addedLines: 0,
changed: true,
deleted: false,
fileHash: 'test',
key: 'app/test/filepathneedstruncating.js',
name: 'filepathneedstruncating.js',
2019-03-02 22:35:43 +05:30
parentPath: 'app/test/',
2018-12-13 13:39:08 +05:30
path: 'app/test/filepathneedstruncating.js',
removedLines: 0,
tempFile: true,
type: 'blob',
tree: [],
},
2018-12-05 23:21:45 +05:30
],
},
],
opened: true,
},
{
key: 'package.json',
2019-03-02 22:35:43 +05:30
parentPath: '/',
2018-12-05 23:21:45 +05:30
path: 'package.json',
name: 'package.json',
type: 'blob',
changed: true,
tempFile: false,
deleted: true,
fileHash: 'test',
addedLines: 0,
removedLines: 0,
tree: [],
},
]);
});
it('creates flat list of blobs & folders', () => {
const { treeEntries } = utils.generateTreeList(files);
expect(Object.keys(treeEntries)).toEqual([
'app',
'app/index.js',
'app/test',
'app/test/index.js',
2018-12-13 13:39:08 +05:30
'app/test/filepathneedstruncating.js',
2018-12-05 23:21:45 +05:30
'package.json',
]);
});
2018-11-08 19:23:39 +05:30
});
2019-02-15 15:39:39 +05:30
describe('getDiffMode', () => {
it('returns mode when matched in file', () => {
expect(
utils.getDiffMode({
renamed_file: true,
}),
).toBe('renamed');
});
it('returns mode_changed if key has no match', () => {
expect(
utils.getDiffMode({
2019-07-07 11:18:12 +05:30
viewer: { name: 'mode_changed' },
2019-02-15 15:39:39 +05:30
}),
).toBe('mode_changed');
});
it('defaults to replaced', () => {
expect(utils.getDiffMode({})).toBe('replaced');
});
});
2019-03-02 22:35:43 +05:30
describe('getLowestSingleFolder', () => {
it('returns path and tree of lowest single folder tree', () => {
const folder = {
name: 'app',
type: 'tree',
tree: [
{
name: 'javascripts',
type: 'tree',
tree: [
{
type: 'blob',
name: 'index.js',
},
],
},
],
};
const { path, treeAcc } = utils.getLowestSingleFolder(folder);
expect(path).toEqual('app/javascripts');
expect(treeAcc).toEqual([
{
type: 'blob',
name: 'index.js',
},
]);
});
it('returns passed in folders path & tree when more than tree exists', () => {
const folder = {
name: 'app',
type: 'tree',
tree: [
{
name: 'spec',
type: 'blob',
tree: [],
},
],
};
const { path, treeAcc } = utils.getLowestSingleFolder(folder);
expect(path).toEqual('app');
expect(treeAcc).toBeNull();
});
});
describe('flattenTree', () => {
it('returns flattened directory structure', () => {
const tree = [
{
type: 'tree',
name: 'app',
tree: [
{
type: 'tree',
name: 'javascripts',
tree: [
{
type: 'blob',
name: 'index.js',
tree: [],
},
],
},
],
},
{
type: 'tree',
name: 'ee',
tree: [
{
type: 'tree',
name: 'lib',
tree: [
{
type: 'tree',
name: 'ee',
tree: [
{
type: 'tree',
name: 'gitlab',
tree: [
{
type: 'tree',
name: 'checks',
tree: [
{
type: 'tree',
name: 'longtreenametomakepath',
tree: [
{
type: 'blob',
name: 'diff_check.rb',
tree: [],
},
],
},
],
},
],
},
],
},
],
},
],
},
{
type: 'tree',
name: 'spec',
tree: [
{
type: 'tree',
name: 'javascripts',
tree: [],
},
{
type: 'blob',
name: 'index_spec.js',
tree: [],
},
],
},
];
const flattened = utils.flattenTree(tree);
expect(flattened).toEqual([
{
type: 'tree',
name: 'app/javascripts',
tree: [
{
type: 'blob',
name: 'index.js',
tree: [],
},
],
},
{
type: 'tree',
name: 'ee/lib/…/…/…/longtreenametomakepath',
tree: [
{
name: 'diff_check.rb',
tree: [],
type: 'blob',
},
],
},
{
type: 'tree',
name: 'spec',
tree: [
{
type: 'tree',
name: 'javascripts',
tree: [],
},
{
type: 'blob',
name: 'index_spec.js',
tree: [],
},
],
},
]);
});
});
2019-07-07 11:18:12 +05:30
describe('convertExpandLines', () => {
it('converts expanded lines to normal lines', () => {
const diffLines = [
{
type: 'match',
old_line: 1,
new_line: 1,
},
{
type: '',
old_line: 2,
new_line: 2,
},
];
const lines = utils.convertExpandLines({
diffLines,
data: [{ text: 'expanded' }],
typeKey: 'type',
oldLineKey: 'old_line',
newLineKey: 'new_line',
mapLine: ({ line, oldLine, newLine }) => ({
...line,
old_line: oldLine,
new_line: newLine,
}),
});
expect(lines).toEqual([
{
text: 'expanded',
new_line: 1,
old_line: 1,
discussions: [],
hasForm: false,
},
{
type: '',
old_line: 2,
new_line: 2,
},
]);
});
});
2020-07-28 23:09:34 +05:30
describe('getDefaultWhitespace', () => {
it('defaults to true if querystring and cookie are undefined', () => {
expect(utils.getDefaultWhitespace()).toBe(true);
});
it('returns false if querystring is `1`', () => {
expect(utils.getDefaultWhitespace('1', '0')).toBe(false);
});
it('returns true if querystring is `0`', () => {
expect(utils.getDefaultWhitespace('0', undefined)).toBe(true);
});
it('returns false if cookie is `1`', () => {
expect(utils.getDefaultWhitespace(undefined, '1')).toBe(false);
});
it('returns true if cookie is `0`', () => {
expect(utils.getDefaultWhitespace(undefined, '0')).toBe(true);
});
});
2018-11-08 19:23:39 +05:30
});