debian-mirror-gitlab/spec/frontend/editor/editor_lite_spec.js

248 lines
7.1 KiB
JavaScript
Raw Normal View History

2020-05-24 23:13:21 +05:30
import { editor as monacoEditor, languages as monacoLanguages, Uri } from 'monaco-editor';
2020-03-09 13:42:32 +05:30
import Editor from '~/editor/editor_lite';
2020-04-08 14:13:33 +05:30
import { DEFAULT_THEME, themes } from '~/ide/lib/themes';
2020-03-09 13:42:32 +05:30
describe('Base editor', () => {
let editorEl;
let editor;
const blobContent = 'Foo Bar';
const blobPath = 'test.md';
const uri = new Uri('gitlab', false, blobPath);
const fakeModel = { foo: 'bar' };
beforeEach(() => {
setFixtures('<div id="editor" data-editor-loading></div>');
editorEl = document.getElementById('editor');
editor = new Editor();
});
afterEach(() => {
editor.dispose();
editorEl.remove();
});
it('initializes Editor with basic properties', () => {
expect(editor).toBeDefined();
expect(editor.editorEl).toBe(null);
expect(editor.blobContent).toEqual('');
expect(editor.blobPath).toEqual('');
});
it('removes `editor-loading` data attribute from the target DOM element', () => {
editor.createInstance({ el: editorEl });
expect(editorEl.dataset.editorLoading).toBeUndefined();
});
describe('instance of the Editor', () => {
let modelSpy;
let instanceSpy;
let setModel;
let dispose;
beforeEach(() => {
2020-05-24 23:13:21 +05:30
setModel = jest.fn();
dispose = jest.fn();
modelSpy = jest.spyOn(monacoEditor, 'createModel').mockImplementation(() => fakeModel);
instanceSpy = jest.spyOn(monacoEditor, 'create').mockImplementation(() => ({
2020-03-09 13:42:32 +05:30
setModel,
dispose,
2020-05-24 23:13:21 +05:30
}));
2020-03-09 13:42:32 +05:30
});
it('does nothing if no dom element is supplied', () => {
editor.createInstance();
expect(editor.editorEl).toBe(null);
expect(editor.blobContent).toEqual('');
expect(editor.blobPath).toEqual('');
expect(modelSpy).not.toHaveBeenCalled();
expect(instanceSpy).not.toHaveBeenCalled();
expect(setModel).not.toHaveBeenCalled();
});
it('creates model to be supplied to Monaco editor', () => {
editor.createInstance({ el: editorEl, blobPath, blobContent });
expect(modelSpy).toHaveBeenCalledWith(blobContent, undefined, uri);
expect(setModel).toHaveBeenCalledWith(fakeModel);
});
it('initializes the instance on a supplied DOM node', () => {
editor.createInstance({ el: editorEl });
expect(editor.editorEl).not.toBe(null);
2020-05-24 23:13:21 +05:30
expect(instanceSpy).toHaveBeenCalledWith(editorEl, expect.anything());
2020-03-09 13:42:32 +05:30
});
});
describe('implementation', () => {
beforeEach(() => {
editor.createInstance({ el: editorEl, blobPath, blobContent });
});
afterEach(() => {
editor.model.dispose();
});
it('correctly proxies value from the model', () => {
expect(editor.getValue()).toEqual(blobContent);
});
it('is capable of changing the language of the model', () => {
2020-05-24 23:13:21 +05:30
// ignore warnings and errors Monaco posts during setup
// (due to being called from Jest/Node.js environment)
jest.spyOn(console, 'warn').mockImplementation(() => {});
jest.spyOn(console, 'error').mockImplementation(() => {});
2020-03-09 13:42:32 +05:30
const blobRenamedPath = 'test.js';
expect(editor.model.getLanguageIdentifier().language).toEqual('markdown');
editor.updateModelLanguage(blobRenamedPath);
expect(editor.model.getLanguageIdentifier().language).toEqual('javascript');
});
it('falls back to plaintext if there is no language associated with an extension', () => {
const blobRenamedPath = 'test.myext';
2020-05-24 23:13:21 +05:30
const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
2020-03-09 13:42:32 +05:30
editor.updateModelLanguage(blobRenamedPath);
expect(spy).not.toHaveBeenCalled();
expect(editor.model.getLanguageIdentifier().language).toEqual('plaintext');
});
});
2020-04-08 14:13:33 +05:30
2020-07-28 23:09:34 +05:30
describe('extensions', () => {
const foo1 = jest.fn();
const foo2 = jest.fn();
const bar = jest.fn();
const MyExt1 = {
foo: foo1,
};
const MyExt2 = {
bar,
};
const MyExt3 = {
foo: foo2,
};
beforeEach(() => {
editor.createInstance({ el: editorEl, blobPath, blobContent });
});
afterEach(() => {
editor.model.dispose();
});
it('is extensible with the extensions', () => {
expect(editor.foo).toBeUndefined();
editor.use(MyExt1);
expect(editor.foo).toEqual(foo1);
});
it('does not fail if no extensions supplied', () => {
const spy = jest.spyOn(global.console, 'error');
editor.use();
expect(spy).not.toHaveBeenCalled();
});
it('is extensible with multiple extensions', () => {
expect(editor.foo).toBeUndefined();
expect(editor.bar).toBeUndefined();
editor.use([MyExt1, MyExt2]);
expect(editor.foo).toEqual(foo1);
expect(editor.bar).toEqual(bar);
});
it('uses the last definition of a method in case of an overlap', () => {
editor.use([MyExt1, MyExt2, MyExt3]);
expect(editor).toEqual(
expect.objectContaining({
foo: foo2,
bar,
}),
);
});
it('correctly resolves references withing extensions', () => {
const FunctionExt = {
inst() {
return this.instance;
},
mod() {
return this.model;
},
};
editor.use(FunctionExt);
expect(editor.inst()).toEqual(editor.instance);
expect(editor.mod()).toEqual(editor.model);
});
});
2020-05-24 23:13:21 +05:30
describe('languages', () => {
it('registers custom languages defined with Monaco', () => {
expect(monacoLanguages.getLanguages()).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: 'vue',
}),
]),
);
});
});
2020-04-08 14:13:33 +05:30
describe('syntax highlighting theme', () => {
let themeDefineSpy;
let themeSetSpy;
let defaultScheme;
beforeEach(() => {
2020-05-24 23:13:21 +05:30
themeDefineSpy = jest.spyOn(monacoEditor, 'defineTheme').mockImplementation(() => {});
themeSetSpy = jest.spyOn(monacoEditor, 'setTheme').mockImplementation(() => {});
2020-04-08 14:13:33 +05:30
defaultScheme = window.gon.user_color_scheme;
});
afterEach(() => {
window.gon.user_color_scheme = defaultScheme;
});
it('sets default syntax highlighting theme', () => {
const expectedTheme = themes.find(t => t.name === DEFAULT_THEME);
editor = new Editor();
expect(themeDefineSpy).toHaveBeenCalledWith(DEFAULT_THEME, expectedTheme.data);
expect(themeSetSpy).toHaveBeenCalledWith(DEFAULT_THEME);
});
it('sets correct theme if it is set in users preferences', () => {
const expectedTheme = themes.find(t => t.name !== DEFAULT_THEME);
expect(expectedTheme.name).not.toBe(DEFAULT_THEME);
window.gon.user_color_scheme = expectedTheme.name;
editor = new Editor();
expect(themeDefineSpy).toHaveBeenCalledWith(expectedTheme.name, expectedTheme.data);
expect(themeSetSpy).toHaveBeenCalledWith(expectedTheme.name);
});
it('falls back to default theme if a selected one is not supported yet', () => {
const name = 'non-existent-theme';
const nonExistentTheme = { name };
window.gon.user_color_scheme = nonExistentTheme.name;
editor = new Editor();
expect(themeDefineSpy).not.toHaveBeenCalled();
expect(themeSetSpy).toHaveBeenCalledWith(DEFAULT_THEME);
});
});
2020-03-09 13:42:32 +05:30
});