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

402 lines
10 KiB
JavaScript
Raw Normal View History

2018-05-09 12:01:36 +05:30
import * as getters from '~/ide/stores/getters';
2020-01-01 13:55:28 +05:30
import { createStore } from '~/ide/stores';
2018-05-09 12:01:36 +05:30
import { file } from '../helpers';
describe('IDE store getters', () => {
let localState;
2020-01-01 13:55:28 +05:30
let localStore;
2018-05-09 12:01:36 +05:30
beforeEach(() => {
2020-01-01 13:55:28 +05:30
localStore = createStore();
localState = localStore.state;
2018-05-09 12:01:36 +05:30
});
describe('activeFile', () => {
it('returns the current active file', () => {
localState.openFiles.push(file());
localState.openFiles.push(file('active'));
localState.openFiles[1].active = true;
expect(getters.activeFile(localState).name).toBe('active');
});
it('returns undefined if no active files are found', () => {
localState.openFiles.push(file());
localState.openFiles.push(file('active'));
expect(getters.activeFile(localState)).toBeNull();
});
});
describe('modifiedFiles', () => {
it('returns a list of modified files', () => {
localState.openFiles.push(file());
localState.changedFiles.push(file('changed'));
localState.changedFiles[0].changed = true;
const modifiedFiles = getters.modifiedFiles(localState);
expect(modifiedFiles.length).toBe(1);
expect(modifiedFiles[0].name).toBe('changed');
});
});
describe('currentMergeRequest', () => {
it('returns Current Merge Request', () => {
localState.currentProjectId = 'abcproject';
localState.currentMergeRequestId = 1;
localState.projects.abcproject = {
mergeRequests: {
2020-01-01 13:55:28 +05:30
1: {
mergeId: 1,
},
2018-05-09 12:01:36 +05:30
},
};
expect(getters.currentMergeRequest(localState).mergeId).toBe(1);
});
it('returns null if no active Merge Request was found', () => {
localState.currentProjectId = 'otherproject';
expect(getters.currentMergeRequest(localState)).toBeNull();
});
});
2018-10-15 14:42:47 +05:30
describe('allBlobs', () => {
beforeEach(() => {
Object.assign(localState.entries, {
2020-01-01 13:55:28 +05:30
index: {
type: 'blob',
name: 'index',
lastOpenedAt: 0,
},
app: {
type: 'blob',
name: 'blob',
lastOpenedAt: 0,
},
folder: {
type: 'folder',
name: 'folder',
lastOpenedAt: 0,
},
2018-10-15 14:42:47 +05:30
});
});
it('returns only blobs', () => {
expect(getters.allBlobs(localState).length).toBe(2);
});
it('returns list sorted by lastOpenedAt', () => {
localState.entries.app.lastOpenedAt = new Date().getTime();
expect(getters.allBlobs(localState)[0].name).toBe('blob');
});
});
describe('getChangesInFolder', () => {
it('returns length of changed files for a path', () => {
localState.changedFiles.push(
{
path: 'test/index',
name: 'index',
},
{
path: 'app/123',
name: '123',
},
);
expect(getters.getChangesInFolder(localState)('test')).toBe(1);
});
it('returns length of changed & staged files for a path', () => {
localState.changedFiles.push(
{
path: 'test/index',
name: 'index',
},
{
path: 'testing/123',
name: '123',
},
);
localState.stagedFiles.push(
{
path: 'test/123',
name: '123',
},
{
path: 'test/index',
name: 'index',
},
{
path: 'testing/12345',
name: '12345',
},
);
expect(getters.getChangesInFolder(localState)('test')).toBe(2);
});
it('returns length of changed & tempFiles files for a path', () => {
localState.changedFiles.push(
{
path: 'test/index',
name: 'index',
},
{
path: 'test/newfile',
name: 'newfile',
tempFile: true,
},
);
expect(getters.getChangesInFolder(localState)('test')).toBe(2);
});
});
describe('lastCommit', () => {
it('returns the last commit of the current branch on the current project', () => {
const commitTitle = 'Example commit title';
const localGetters = {
currentProject: {
2018-11-08 19:23:39 +05:30
name: 'test-project',
},
currentBranch: {
commit: {
title: commitTitle,
2018-10-15 14:42:47 +05:30
},
},
};
localState.currentBranchId = 'example-branch';
expect(getters.lastCommit(localState, localGetters).title).toBe(commitTitle);
});
});
2018-11-08 19:23:39 +05:30
describe('currentBranch', () => {
it('returns current projects branch', () => {
2019-12-26 22:10:19 +05:30
localState.currentProjectId = 'abcproject';
localState.currentBranchId = 'master';
localState.projects.abcproject = {
name: 'abcproject',
branches: {
master: {
name: 'master',
2018-11-08 19:23:39 +05:30
},
},
};
2019-12-26 22:10:19 +05:30
const localGetters = {
2020-01-01 13:55:28 +05:30
findBranch: jest.fn(),
2019-12-26 22:10:19 +05:30
};
getters.currentBranch(localState, localGetters);
expect(localGetters.findBranch).toHaveBeenCalledWith('abcproject', 'master');
});
});
describe('findProject', () => {
it('returns the project matching the id', () => {
localState.currentProjectId = 'abcproject';
localState.projects.abcproject = {
name: 'abcproject',
};
expect(getters.findProject(localState)('abcproject').name).toBe('abcproject');
});
});
describe('findBranch', () => {
let result;
it('returns the selected branch from a project', () => {
localState.currentProjectId = 'abcproject';
2018-11-08 19:23:39 +05:30
localState.currentBranchId = 'master';
2019-12-26 22:10:19 +05:30
localState.projects.abcproject = {
name: 'abcproject',
branches: {
master: {
name: 'master',
},
},
};
const localGetters = {
findProject: () => localState.projects.abcproject,
};
2018-11-08 19:23:39 +05:30
2019-12-26 22:10:19 +05:30
result = getters.findBranch(localState, localGetters)('abcproject', 'master');
expect(result.name).toBe('master');
2018-11-08 19:23:39 +05:30
});
});
2018-11-18 11:00:15 +05:30
2019-09-04 21:01:54 +05:30
describe('isOnDefaultBranch', () => {
it('returns false when no project exists', () => {
const localGetters = {
currentProject: undefined,
};
expect(getters.isOnDefaultBranch({}, localGetters)).toBeFalsy();
});
it("returns true when project's default branch matches current branch", () => {
const localGetters = {
currentProject: {
default_branch: 'master',
},
branchName: 'master',
};
expect(getters.isOnDefaultBranch({}, localGetters)).toBeTruthy();
});
it("returns false when project's default branch doesn't match current branch", () => {
const localGetters = {
currentProject: {
default_branch: 'master',
},
branchName: 'feature',
};
expect(getters.isOnDefaultBranch({}, localGetters)).toBeFalsy();
});
});
2018-11-18 11:00:15 +05:30
describe('packageJson', () => {
it('returns package.json entry', () => {
2020-01-01 13:55:28 +05:30
localState.entries['package.json'] = {
name: 'package.json',
};
2018-11-18 11:00:15 +05:30
expect(getters.packageJson(localState)).toEqual({
name: 'package.json',
});
});
});
2019-12-04 20:38:33 +05:30
describe('canPushToBranch', () => {
it('returns false when no currentBranch exists', () => {
const localGetters = {
currentProject: undefined,
};
expect(getters.canPushToBranch({}, localGetters)).toBeFalsy();
});
it('returns true when can_push to currentBranch', () => {
const localGetters = {
currentProject: {
default_branch: 'master',
},
2020-01-01 13:55:28 +05:30
currentBranch: {
can_push: true,
},
2019-12-04 20:38:33 +05:30
};
expect(getters.canPushToBranch({}, localGetters)).toBeTruthy();
});
it('returns false when !can_push to currentBranch', () => {
const localGetters = {
currentProject: {
default_branch: 'master',
},
2020-01-01 13:55:28 +05:30
currentBranch: {
can_push: false,
},
2019-12-04 20:38:33 +05:30
};
expect(getters.canPushToBranch({}, localGetters)).toBeFalsy();
});
});
2020-01-01 13:55:28 +05:30
describe('isFileDeletedAndReadded', () => {
const f = { ...file('sample'), content: 'sample', raw: 'sample' };
it.each([
{
entry: { ...f, tempFile: true },
staged: { ...f, deleted: true },
output: true,
},
{
entry: { ...f, content: 'changed' },
staged: { ...f, content: 'changed' },
output: false,
},
{
entry: { ...f, content: 'changed' },
output: false,
},
])(
'checks staged and unstaged files to see if a file was deleted and readded (case %#)',
({ entry, staged, output }) => {
Object.assign(localState, {
entries: {
[entry.path]: entry,
},
stagedFiles: [],
});
if (staged) localState.stagedFiles.push(staged);
expect(localStore.getters.isFileDeletedAndReadded(entry.path)).toBe(output);
},
);
});
describe('getDiffInfo', () => {
const f = { ...file('sample'), content: 'sample', raw: 'sample' };
it.each([
{
entry: { ...f, tempFile: true },
staged: { ...f, deleted: true },
output: { deleted: false, changed: false, tempFile: false },
},
{
entry: { ...f, tempFile: true, content: 'changed', raw: '' },
staged: { ...f, deleted: true },
output: { deleted: false, changed: true, tempFile: false },
},
{
entry: { ...f, content: 'changed' },
output: { changed: true },
},
{
entry: { ...f, content: 'sample' },
staged: { ...f, content: 'changed' },
output: { changed: false },
},
{
entry: { ...f, deleted: true },
output: { deleted: true, changed: false },
},
{
entry: { ...f, prevPath: 'old_path' },
output: { renamed: true, changed: false },
},
{
entry: { ...f, prevPath: 'old_path', content: 'changed' },
output: { renamed: true, changed: true },
},
])(
'compares changes in a file entry and returns a resulting diff info (case %#)',
({ entry, staged, output }) => {
Object.assign(localState, {
entries: {
[entry.path]: entry,
},
stagedFiles: [],
});
if (staged) localState.stagedFiles.push(staged);
expect(localStore.getters.getDiffInfo(entry.path)).toEqual(expect.objectContaining(output));
},
);
});
2018-05-09 12:01:36 +05:30
});