kopia lustrzana https://github.com/c9/core
566 wiersze
24 KiB
JavaScript
566 wiersze
24 KiB
JavaScript
/*global describe it before after bar*/
|
|
|
|
"use client";
|
|
|
|
var expect = require("lib/chai/chai").expect;
|
|
|
|
expect.setupArchitectTest([
|
|
{
|
|
packagePath: "plugins/c9.core/c9",
|
|
workspaceId: "ubuntu/ip-10-35-77-180",
|
|
startdate: new Date(),
|
|
debug: true,
|
|
hosted: true,
|
|
},
|
|
|
|
"plugins/c9.core/ext",
|
|
"plugins/c9.core/http-xhr",
|
|
"plugins/c9.core/util",
|
|
"plugins/c9.ide.ui/lib_apf",
|
|
"plugins/c9.ide.ui/menus",
|
|
{
|
|
packagePath: "plugins/c9.core/settings",
|
|
settings: "default",
|
|
testing: true
|
|
},
|
|
{
|
|
packagePath: "plugins/c9.ide.ui/ui",
|
|
staticPrefix: "plugins/c9.ide.ui"
|
|
},
|
|
"plugins/c9.ide.editors/document",
|
|
"plugins/c9.ide.editors/undomanager",
|
|
{
|
|
packagePath: "plugins/c9.ide.editors/editors",
|
|
defaultEditor: "ace"
|
|
},
|
|
"plugins/c9.ide.editors/editor",
|
|
"plugins/c9.ide.editors/tabmanager",
|
|
"plugins/c9.ide.ui/focus",
|
|
"plugins/c9.ide.editors/pane",
|
|
"plugins/c9.ide.editors/tab",
|
|
{
|
|
packagePath: "plugins/c9.ide.ace/ace",
|
|
staticPrefix: "plugins/c9.ide.layout.classic"
|
|
},
|
|
"plugins/c9.ide.keys/commands",
|
|
"plugins/c9.fs/proc",
|
|
"plugins/c9.vfs.client/vfs_client",
|
|
"plugins/c9.vfs.client/endpoint",
|
|
"plugins/c9.ide.auth/auth",
|
|
"plugins/c9.core/api",
|
|
"plugins/c9.fs/fs",
|
|
|
|
"plugins/c9.ide.dialog/dialog",
|
|
"plugins/c9.ide.dialog.common/alert",
|
|
"plugins/c9.ide.dialog.common/alert_internal",
|
|
|
|
{
|
|
consumes: ["tabManager", "ace", "commands", "settings"],
|
|
provides: [],
|
|
setup: main
|
|
}
|
|
]);
|
|
|
|
function main(options, imports, register) {
|
|
var settings = imports.settings;
|
|
var commands = imports.commands;
|
|
var tabs = imports.tabManager;
|
|
var ace = imports.ace;
|
|
|
|
function getTabHtml(tab) {
|
|
return tab.pane.aml.getPage("editor::" + tab.editorType).$ext;
|
|
}
|
|
|
|
expect.html.setConstructor(function(tab) {
|
|
if (tab && typeof tab == "object")
|
|
return getTabHtml(tab);
|
|
});
|
|
|
|
describe('ace', function() {
|
|
before(function(done) {
|
|
bar.$ext.style.background = "rgba(220, 220, 220, 0.93)";
|
|
bar.$ext.style.position = "fixed";
|
|
bar.$ext.style.left = "20px";
|
|
bar.$ext.style.width = "1000px";
|
|
bar.$ext.style.bottom = "20px";
|
|
bar.$ext.style.height = "33%";
|
|
|
|
document.body.style.marginBottom = "33%";
|
|
|
|
tabs.once("ready", function() {
|
|
tabs.getPanes()[0].focus();
|
|
done();
|
|
});
|
|
});
|
|
|
|
describe("open", function() {
|
|
this.timeout(10000);
|
|
|
|
it('should open a pane with just an editor', function(done) {
|
|
tabs.openFile("/file.txt", function(err, tab) {
|
|
expect(tabs.getTabs()).length(1);
|
|
|
|
expect(tab.document.title).equals("file.txt");
|
|
done();
|
|
});
|
|
});
|
|
it('should handle multiple documents in the same pane', function(done) {
|
|
tabs.openFile("/listing.json", function(err, tab) {
|
|
expect(tabs.getTabs()).length(2);
|
|
|
|
tab.activate();
|
|
|
|
var doc = tab.document;
|
|
expect(doc.title).match(new RegExp("listing.json"));
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
describe("clear(), getState() and setState()", function() {
|
|
var state, info = {};
|
|
|
|
it('should retrieve the state', function(done) {
|
|
// @todo make sure ace has a selection and scrolltop / left
|
|
|
|
state = tabs.getState();
|
|
info.pages = tabs.getTabs().map(function(tab) {
|
|
return tab.path || tab.id;
|
|
});
|
|
done();
|
|
});
|
|
it('should clear all tabs and pages', function(done) {
|
|
tabs.getPanes()[0];
|
|
var pages = tabs.getTabs();
|
|
tabs.clear(true, true); //Soft clear, not unloading the pages
|
|
expect(tabs.getTabs(), "pages").length(0);
|
|
expect(tabs.getPanes(), "tabManager").length(0);
|
|
//expect(pane.getTabs(), "aml").length(0);
|
|
done();
|
|
});
|
|
it('should restore the state', function(done) {
|
|
// @todo make sure the selection and scrolltop / left is preserved
|
|
|
|
tabs.setState(state, false, function(err) {
|
|
if (err) throw err.message;
|
|
});
|
|
var l = info.pages.length;
|
|
expect(tabs.getTabs()).length(l);
|
|
expect(tabs.getPanes()[0].getTabs()).length(l);
|
|
expect(tabs.focussedTab.pane.getTabs()).length(l);
|
|
|
|
expect(tabs.getTabs().map(function(tab) {
|
|
return tab.path || tab.id;
|
|
})).to.deep.equal(info.pages);
|
|
done();
|
|
});
|
|
it('should jump to on an already loaded file', function(done) {
|
|
var tab = tabs.focussedTab;
|
|
tab.document.setState({
|
|
ace: {
|
|
jump: {
|
|
row: 3,
|
|
column: 10
|
|
}
|
|
}
|
|
});
|
|
var cursor = tab.editor.ace.getCursorPosition();
|
|
expect(cursor.row).equals(3);
|
|
expect(cursor.column).equals(10);
|
|
done();
|
|
});
|
|
});
|
|
describe("split(), pane.unload()", function() {
|
|
it('should split a pane horizontally, making the existing pane the left one', function(done) {
|
|
var pane = tabs.focussedTab.pane;
|
|
var righttab = pane.hsplit(true);
|
|
tabs.focussedTab.attachTo(righttab);
|
|
done();
|
|
});
|
|
it('should remove the left pane from a horizontal split', function(done) {
|
|
var pane = tabs.getPanes()[0];
|
|
var tab = tabs.getPanes()[1].getTab();
|
|
pane.unload();
|
|
expect(tabs.getPanes()).length(1);
|
|
expect(tabs.getTabs()).length(2);
|
|
tabs.focusTab(tab);
|
|
done();
|
|
});
|
|
});
|
|
describe("focus(), blur()", function() {
|
|
it.skip('should get the right className and take keyboard input when focussed', function(done) {
|
|
done();
|
|
});
|
|
it.skip(`should get the right className and not take any keyboard input when blurred`, function(done) {
|
|
done();
|
|
});
|
|
});
|
|
describe("customType", function() {
|
|
it('should remember custom types set on known extensions', function(done) {
|
|
|
|
//@todo check if it is recorded in settings
|
|
done();
|
|
});
|
|
it('should remember custom types set on unknown extensions', function(done) {
|
|
|
|
//@todo check if it is recorded in settings
|
|
done();
|
|
});
|
|
});
|
|
|
|
function render() {
|
|
var editor = tabs.focussedTab.editor;
|
|
var changes = editor.ace.renderer.$loop.changes;
|
|
editor.ace.renderer.$loop.changes = 0;
|
|
editor.ace.renderer.$renderChanges(changes, true);
|
|
}
|
|
|
|
describe("setOption()", function() {
|
|
this.timeout(10000);
|
|
var lineHeight, session, editor, charWidth, doc;
|
|
|
|
before(function(done) {
|
|
doc = tabs.focussedTab.document;
|
|
editor = doc.editor;
|
|
session = doc.getSession().session;
|
|
lineHeight = doc.editor.ace.renderer.lineHeight;
|
|
charWidth = doc.editor.ace.renderer.characterWidth;
|
|
|
|
done();
|
|
});
|
|
|
|
it('should change a theme', function(done) {
|
|
function checkTheme(id, className, callback) {
|
|
editor.ace.renderer.on("themeLoaded", function me(e) {
|
|
if (e.theme.cssClass != className) return;
|
|
editor.ace.renderer.removeListener("themeLoaded", me);
|
|
expect.html(getTabHtml(tabs.focussedTab).childNodes[1]).className(className);
|
|
callback();
|
|
});
|
|
ace.setTheme(id);
|
|
}
|
|
checkTheme("ace/theme/textmate", "ace-tm", function() {
|
|
checkTheme("ace/theme/tomorrow_night_bright", "ace-tomorrow-night-bright", function() {
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
it('should allow setting useWrapMode', function(done) {
|
|
var charW = editor.ace.renderer.layerConfig.characterWidth;
|
|
expect(charW).to.ok;
|
|
bar.$ext.style.width = 150 * charW + "px";
|
|
|
|
doc.value = Array(17).join("a very long string to be wrapped ");
|
|
|
|
render();
|
|
bar.$ext.style.width = "1000px";
|
|
|
|
expect(document.querySelector(".ace_gutter-cell").offsetHeight).to.equal(lineHeight);
|
|
editor.setOption("useWrapMode", true);
|
|
|
|
render();
|
|
expect(Math.ceil(document.querySelector(".ace_gutter-cell").offsetHeight)).to.equal(lineHeight * 7);
|
|
|
|
// check that wrap to view setting is not lost when user settings are changes
|
|
settings.set("user/ace/@selectionStyle", "line");
|
|
expect(editor.ace.getOption("selectionStyle")).to.equal("line");
|
|
settings.set("user/ace/@selectionStyle", "text");
|
|
render();
|
|
expect(editor.ace.getOption("selectionStyle")).to.equal("text");
|
|
expect(editor.ace.session.getOption("wrap")).to.equal("printMargin");
|
|
|
|
done();
|
|
});
|
|
it('should allow setting wrapToView', function(done) {
|
|
expect(document.querySelector(".ace_gutter-cell").offsetHeight).to.equal(lineHeight * 7);
|
|
editor.setOption("wrapToView", true);
|
|
|
|
render();
|
|
var ace = editor.ace;
|
|
var cols = Math.floor((ace.container.offsetWidth - ace.renderer.gutterWidth - 2 * ace.renderer.$padding) / charWidth);
|
|
|
|
expect(cols).to.equal(ace.session.getWrapLimit());
|
|
expect(document.querySelector(".ace_gutter-cell").offsetHeight).to.equal(lineHeight * ace.session.getRowLength(0));
|
|
|
|
done();
|
|
});
|
|
it('should allow setting wrapBehavioursEnabled', function(done) {
|
|
done();
|
|
});
|
|
it('should allow setting newLineMode', function(done) {
|
|
editor.setOption("newLineMode", "windows");
|
|
doc.value = "line1\nline2\nline3\nline4\nline5";
|
|
|
|
render();
|
|
|
|
expect(session.getValue(session.doc.$fsNewLine)).to.match(/\r/);
|
|
|
|
editor.setOption("newLineMode", "unix");
|
|
|
|
expect(session.getValue()).to.not.match(/\r/);
|
|
|
|
editor.setOption("newLineMode", "auto");
|
|
|
|
expect(session.getValue()).to.not.match(/\r/);
|
|
|
|
done();
|
|
});
|
|
it('should allow setting tabSize', function(done) {
|
|
doc.value = "\tline1\n\t\tline2\n\t\tline3\n\tline4\nline5";
|
|
render();
|
|
|
|
editor.setOption("tabSize", 4);
|
|
|
|
render();
|
|
expect.html(doc.tab, "tabSize: 4").text(/\s{8}/);
|
|
|
|
editor.setOption("tabSize", 8);
|
|
render();
|
|
|
|
expect.html(doc.tab, "tabSize: 8").text(/\s{16}/);
|
|
|
|
done();
|
|
});
|
|
it('should allow setting useSoftTabs', function(done) {
|
|
doc.value = " line1\n line2\n line3\n line4\nline5";
|
|
render();
|
|
|
|
editor.setOption("tabSize", 4);
|
|
editor.setOption("useSoftTabs", true);
|
|
|
|
editor.ace.moveCursorTo(1, 0);
|
|
// command isAvailable works only if editor is focussed
|
|
// which might break the test when debugger is focussed
|
|
editor.ace.isFocused = function() {return true;};
|
|
commands.exec("gotoright", editor, null,
|
|
document.createEvent("KeyboardEvent"));
|
|
delete editor.ace.isFocused;
|
|
|
|
expect(editor.ace.getCursorPosition()).deep.equal({ row: 1, column: 4 });
|
|
|
|
done();
|
|
});
|
|
it('should allow setting fontSize', function(done) {
|
|
expect(document.querySelector(".ace_gutter-cell").offsetHeight).equal(lineHeight);
|
|
|
|
editor.setOption("fontSize", 30);
|
|
|
|
expect(document.querySelector(".ace_gutter-cell").offsetHeight).gt(lineHeight);
|
|
|
|
editor.setOption("fontSize", 12);
|
|
|
|
done();
|
|
});
|
|
it('should allow setting fontFamily', function(done) {
|
|
editor.setOption("fontFamily", "Courier New");
|
|
render();
|
|
|
|
expect(editor.ace.container.style.fontFamily).to.match(/Courier New/);
|
|
|
|
var font = "Monaco, Menlo, 'Ubuntu Mono', Consolas, source-code-pro, monospace";
|
|
editor.setOption("fontFamily", font);
|
|
render();
|
|
|
|
expect(editor.ace.container.style.fontFamily).to.match(/Monaco/)
|
|
.and.to.not.match(/Courier/);
|
|
|
|
done();
|
|
});
|
|
it('should allow setting selectionStyle', function(done) {
|
|
session.getSelection().setSelectionRange({
|
|
start: {
|
|
row: 0,
|
|
column: 0
|
|
},
|
|
end: {
|
|
row: 4,
|
|
column: 0
|
|
}
|
|
}, false);
|
|
|
|
editor.setOption("selectionStyle", "text");
|
|
render();
|
|
|
|
function selectionElementWidth() {
|
|
var el = document.querySelectorAll(".ace_selection")[0];
|
|
return el.getBoundingClientRect().width;
|
|
}
|
|
|
|
var chars = selectionElementWidth() / charWidth;
|
|
expect(chars - 10).to.lt(1 / 100);
|
|
|
|
editor.setOption("selectionStyle", "line");
|
|
render();
|
|
|
|
chars = selectionElementWidth() / charWidth;
|
|
expect(chars).to.gt(10);
|
|
|
|
done();
|
|
});
|
|
it('should allow setting highlightActiveLine', function(done) {
|
|
session.getSelection().clearSelection();
|
|
|
|
editor.setOption("highlightActiveLine", false);
|
|
render();
|
|
expect(document.querySelector(".ace_active-line")).to.not.ok;
|
|
|
|
editor.setOption("highlightActiveLine", true);
|
|
render();
|
|
expect(document.querySelector(".ace_active-line")).to.ok;
|
|
|
|
done();
|
|
});
|
|
it('should allow setting highlightGutterLine', function(done) {
|
|
editor.setOption("highlightGutterLine", false);
|
|
render();
|
|
expect(document.querySelector(".ace_gutter-active-line")).to.not.ok;
|
|
|
|
editor.setOption("highlightGutterLine", true);
|
|
render();
|
|
expect(document.querySelector(".ace_gutter-active-line").offsetHeight).to.ok;
|
|
|
|
done();
|
|
});
|
|
it('should allow setting showInvisibles', function(done) {
|
|
editor.setOption("showInvisibles", true);
|
|
render();
|
|
expect(document.querySelectorAll(".ace_invisible").length).ok;
|
|
editor.setOption("showInvisibles", false);
|
|
render();
|
|
expect(document.querySelectorAll(".ace_invisible").length).not.ok;
|
|
|
|
done();
|
|
});
|
|
it('should allow setting showPrintMargin', function(done) {
|
|
editor.setOption("showPrintMargin", false);
|
|
expect(document.querySelector(".ace_print-margin").style.visibility).equal("hidden");
|
|
editor.setOption("showPrintMargin", true);
|
|
expect(document.querySelector(".ace_print-margin").style.visibility).equal("visible");
|
|
done();
|
|
});
|
|
it('should allow setting printMarginColumn', function(done) {
|
|
editor.setOption("printMarginColumn", 100);
|
|
var value = Math.floor(parseInt(document.querySelector(".ace_print-margin").style.left) / charWidth);
|
|
expect(value).equal(100);
|
|
editor.setOption("printMarginColumn", 80);
|
|
var value = Math.floor(parseInt(document.querySelector(".ace_print-margin").style.left) / charWidth);
|
|
expect(value).equal(80);
|
|
done();
|
|
});
|
|
it('should allow setting displayIndentGuides', function(done) {
|
|
editor.setOption("displayIndentGuides", false);
|
|
render();
|
|
expect(document.querySelector(".ace_indent-guide")).to.not.ok;
|
|
editor.setOption("displayIndentGuides", true);
|
|
render();
|
|
expect(document.querySelector(".ace_indent-guide")).to.ok;
|
|
done();
|
|
});
|
|
it('should allow setting behavioursEnabled', function(done) {
|
|
editor.setOption("syntax", "javascript");
|
|
expect(editor.ace.session.$mode.$id).to.equal("ace/mode/javascript");
|
|
|
|
editor.setOption("behavioursEnabled", false);
|
|
doc.value = "test";
|
|
render();
|
|
editor.ace.moveCursorTo(0, 4);
|
|
render();
|
|
editor.ace.insert("(");
|
|
render();
|
|
expect(doc.value).to.equal("test(");
|
|
|
|
editor.setOption("behavioursEnabled", true);
|
|
doc.value = "test";
|
|
render();
|
|
editor.ace.moveCursorTo(0, 4);
|
|
render();
|
|
editor.ace.insert("(");
|
|
render();
|
|
expect(doc.value).to.equal("test()");
|
|
|
|
done();
|
|
});
|
|
it('should allow setting showGutter', function(done) {
|
|
editor.setOption("showGutter", false);
|
|
expect.html(document.querySelector(".ace_gutter")).not.visible;
|
|
editor.setOption("showGutter", true);
|
|
expect.html(document.querySelector(".ace_gutter")).visible;
|
|
done();
|
|
});
|
|
it('should allow setting showFoldWidgets', function(done) {
|
|
doc.value = "function(){\n\t\n}";
|
|
editor.setOption("showFoldWidgets", false);
|
|
render();
|
|
expect.html(document.querySelector(".ace_fold-widget").offsetHeight).not.ok;
|
|
editor.setOption("showFoldWidgets", true);
|
|
render();
|
|
expect.html(document.querySelector(".ace_fold-widget")).ok;
|
|
done();
|
|
});
|
|
it('should allow setting highlightSelectedWord', function(done) {
|
|
doc.value = "test\ntest\ntest";
|
|
session.getSelection().setSelectionRange({
|
|
start: {
|
|
row: 0,
|
|
column: 0
|
|
},
|
|
end: {
|
|
row: 0,
|
|
column: 4
|
|
}
|
|
}, false);
|
|
editor.setOption("highlightSelectedWord", false);
|
|
render();
|
|
expect.html(document.querySelector(".ace_selected-word")).not.ok;
|
|
editor.setOption("highlightSelectedWord", true);
|
|
render();
|
|
expect.html(document.querySelector(".ace_selected-word")).ok;
|
|
done();
|
|
});
|
|
it('should allow setting animatedScroll', function(done) {
|
|
var i = 0;
|
|
doc.value = Array(100).join("x").split("x").map(function() {return "Line " + i++;}).join("\n");
|
|
render();
|
|
|
|
editor.setOption("animatedScroll", false);
|
|
editor.scrollTo(50, 0);
|
|
render();
|
|
expect.html(doc.tab).text("50");
|
|
|
|
editor.setOption("animatedScroll", true);
|
|
editor.scrollTo(0, 0);
|
|
render();
|
|
expect.html(doc.tab).text("50");
|
|
done();
|
|
});
|
|
it('should not lose undomanager state', function(done) {
|
|
var u = editor.activeDocument.undoManager;
|
|
u.setState({ mark: -1, position: -1, stack: []});
|
|
var state = u.getState();
|
|
expect(state.mark).to.equal(-1);
|
|
expect(state.position).to.equal(-1);
|
|
expect(state.stack.length).to.equal(0);
|
|
|
|
u.setState({ mark: -2, position: -1, stack: []});
|
|
state = u.getState();
|
|
expect(state.mark).to.equal(-2);
|
|
expect(state.position).to.equal(-1);
|
|
expect(state.stack.length).to.equal(0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
// @todo test split api and menu
|
|
|
|
if (!onload.remain) {
|
|
after(function(done) {
|
|
tabs.unload();
|
|
|
|
document.body.style.marginBottom = "";
|
|
done();
|
|
});
|
|
}
|
|
});
|
|
|
|
register();
|
|
}
|