forked from jupyterlab/jupyterlab
-
Notifications
You must be signed in to change notification settings - Fork 0
/
editor.spec.ts
123 lines (107 loc) · 3.57 KB
/
editor.spec.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
// Copyright (c) Jupyter Development Team.
// Distributed under the terms of the Modified BSD License.
import { expect } from 'chai';
import { CodeEditor } from '@jupyterlab/codeeditor';
describe('CodeEditor.Model', () => {
let model: CodeEditor.Model;
beforeEach(() => {
model = new CodeEditor.Model();
});
afterEach(() => {
model.dispose();
});
describe('#constructor()', () => {
it('should create a CodeEditor Model', () => {
expect(model).to.be.an.instanceof(CodeEditor.Model);
expect(model.value.text).to.equal('');
});
it('should create a CodeEditor Model with an initial value', () => {
let other = new CodeEditor.Model({ value: 'Initial text here' });
expect(other).to.be.an.instanceof(CodeEditor.Model);
expect(other.value.text).to.equal('Initial text here');
other.dispose();
});
it('should create a CodeEditor Model with an initial mimetype', () => {
let other = new CodeEditor.Model({
value: 'import this',
mimeType: 'text/x-python'
});
expect(other).to.be.an.instanceof(CodeEditor.Model);
expect(other.mimeType).to.equal('text/x-python');
expect(other.value.text).to.equal('import this');
other.dispose();
});
});
describe('#mimeTypeChanged', () => {
it('should be emitted when the mime type changes', () => {
let called = false;
model.mimeTypeChanged.connect((sender, args) => {
expect(sender).to.equal(model);
expect(args.oldValue).to.equal('text/plain');
expect(args.newValue).to.equal('text/foo');
called = true;
});
model.mimeType = 'text/foo';
expect(called).to.be.true;
});
});
describe('#value', () => {
it('should be the observable value of the model', () => {
let called = false;
model.value.changed.connect((sender, args) => {
console.log('hi', args.value);
expect(sender).to.equal(model.value);
expect(args.type).to.equal('set');
expect(args.value).to.equal('foo');
called = true;
});
model.value.text = 'foo';
expect(called).to.be.true;
});
it('should handle an insert', () => {
let called = false;
model.value.changed.connect((sender, args) => {
expect(args.type).to.equal('insert');
expect(args.value).to.equal('foo');
called = true;
});
model.value.insert(0, 'foo');
expect(called).to.be.true;
});
it('should handle a remove', () => {
let called = false;
model.value.text = 'foo';
model.value.changed.connect((sender, args) => {
expect(args.type).to.equal('remove');
expect(args.value).to.equal('f');
called = true;
});
model.value.remove(0, 1);
expect(called).to.be.true;
});
});
describe('#selections', () => {
it('should be the selections associated with the model', () => {
expect(model.selections.keys().length).to.equal(0);
});
});
describe('#mimeType', () => {
it('should be the mime type of the model', () => {
expect(model.mimeType).to.equal('text/plain');
model.mimeType = 'text/foo';
expect(model.mimeType).to.equal('text/foo');
});
});
describe('#modelDB', () => {
it('should get the modelDB object associated with the model', () => {
expect(model.modelDB.has('value')).to.be.true;
});
});
describe('#isDisposed', () => {
it('should test whether the model is disposed', () => {
expect(model.isDisposed).to.be.false;
model.dispose();
expect(model.isDisposed).to.be.true;
});
});
});