it('should get a list of user metadata keys', () => {
let model = new CellModel({});
let cursor = model.getMetadata('foo');
expect(toArray(model.listMetadata())).to.be.empty();
cursor.setValue(1);
expect(toArray(model.listMetadata())).to.eql(['foo']);
});
it('should return model options', () => {
let model = new CompleterModel();
let options = ['foo'];
model.setOptions(options);
expect(toArray(model.options())).to.not.equal(options);
expect(toArray(model.options())).to.eql(options);
});
it('should clone the rendermime instance with shallow copies of data', () => {
let r = defaultRenderMime();
let c = r.clone();
expect(toArray(c.mimetypes())).to.eql(toArray(r.mimetypes()));
let t = new TextRenderer();
c.addRenderer('text/foo', t);
expect(r).to.not.be(c);
});
it('should take an optional order index', () => {
let r = defaultRenderMime();
let t = new TextRenderer();
let len = toArray(r.mimetypes()).length;
r.addRenderer('text/foo', t, 0);
let index = toArray(r.mimetypes()).indexOf('text/foo');
expect(index).to.be(0);
expect(toArray(r.mimetypes()).length).to.be(len + 1);
});
it('should list the metadata namespace keys for the notebook', () => {
let model = new NotebookModel();
let keys = ['kernelspec', 'language_info', 'orig_nbformat'];
expect(toArray(model.listMetadata())).to.eql(keys);
let cursor = model.getMetadata('foo');
expect(toArray(model.listMetadata())).to.eql(keys);
cursor.setValue(1);
keys.push('foo');
expect(toArray(model.listMetadata())).to.eql(keys);
});
it('should handle just a multi-part extension', () => {
registry.addModelFactory(new TextModelFactory());
let factory = new WidgetFactory({
name: 'table',
fileExtensions: ['.table.json'],
});
registry.addWidgetFactory(factory);
let factories = registry.preferredWidgetFactories('.table.json');
expect(toArray(factories)).to.eql([factory]);
factories = registry.preferredWidgetFactories('.json');
expect(toArray(factories)).to.eql([]);
});
it('should get the registered file creators', () => {
expect(toArray(registry.creators()).length).to.be(0);
let creators = [
{ name: 'Python Notebook', fileType: 'notebook' },
{ name: 'R Notebook', fileType: 'notebook' },
{ name: 'CSharp Notebook', fileType: 'notebook' }
];
registry.addCreator(creators[0]);
registry.addCreator(creators[1]);
registry.addCreator(creators[2]);
expect(toArray(registry.creators()).length).to.be(3);
expect(registry.creators().next().name).to.be('CSharp Notebook');
});
it('should give the valid registered widget factories', () => {
expect(toArray(registry.preferredWidgetFactories())).to.eql([]);
registry.addModelFactory(new TextModelFactory());
let factory = createFactory();
registry.addWidgetFactory(factory);
let gFactory = new WidgetFactory({
name: 'global',
fileExtensions: ['*'],
defaultFor: ['*']
});
registry.addWidgetFactory(gFactory);
let factories = registry.preferredWidgetFactories('.txt');
expect(toArray(factories)).to.eql([factory, gFactory]);
});
it('should get the registered extensions for a given widget', () => {
let foo = new WidgetExtension();
let bar = new WidgetExtension();
registry.addWidgetExtension('fizz', foo);
registry.addWidgetExtension('fizz', bar);
registry.addWidgetExtension('buzz', foo);
let fizz = toArray(registry.widgetExtensions('fizz'));
expect(fizz[0]).to.be(foo);
expect(fizz[1]).to.be(bar);
expect(fizz.length).to.be(2);
let buzz = toArray(registry.widgetExtensions('buzz'));
expect(buzz[0]).to.be(foo);
expect(toArray(buzz).length).to.be(1);
expect(registry.widgetExtensions('baz').next()).to.be(void 0);
});
it('should add a renderer by mimetype', () => {
let r = defaultRenderMime();
let t = new TextRenderer();
r.addRenderer('text/foo', t);
let index = toArray(r.mimetypes()).indexOf('text/foo');
expect(index).to.be(0);
});
