Update tests

test/src/docregistry/registry.spec.ts

@@ -30,12 +30,65 @@ class WidgetFactory extends ABCWidgetFactory<Widget, DocumentRegistry.IModel> {
     return 'test';
   }
 
+  get fileExtensions(): string[] {
+    return ['.txt'];
+  }
+
   createNew(context: DocumentRegistry.IContext<DocumentRegistry.IModel>, kernel?: Kernel.IModel): Widget {
     return new Widget();
   }
 }
 
 
+class MarkdownWidgetFactory extends WidgetFactory {
+
+  get name(): string {
+    return 'markdown';
+  }
+
+  get fileExtensions(): string[] {
+    return ['.md'];
+  }
+}
+
+
+
+class PythonWidgetFactory extends WidgetFactory {
+
+  get name(): string {
+    return 'python';
+  }
+
+  get fileExtensions(): string[] {
+    return ['.py'];
+  }
+
+  get preferKernel(): boolean {
+    return true;
+  }
+
+  get canStartKernel(): boolean {
+    return true;
+  }
+}
+
+
+class GlobalWidgetFactory extends WidgetFactory {
+
+  get name(): string {
+    return 'global';
+  }
+
+  get fileExtensions(): string[] {
+    return ['*'];
+  }
+
+  get defaultFor(): string[] {
+    return ['*'];
+  }
+}
+
+
 class WidgetExtension implements DocumentRegistry.IWidgetExtension<Widget, DocumentRegistry.IModel> {
 
    createNew(widget: Widget, context: DocumentRegistry.IContext<DocumentRegistry.IModel>): IDisposable {
@@ -95,59 +148,33 @@ describe('docregistry/registry', () => {
 
       it('should become the global default if `*` is given as a defaultFor', () => {
         registry.addModelFactory(new TextModelFactory());
-        let factory = new WidgetFactory();
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['*'],
-          displayName: 'foo',
-          modelName: 'text'
-        });
+        let factory = new GlobalWidgetFactory();
+        registry.addWidgetFactory(factory);
         expect(registry.defaultWidgetFactory('*')).to.be('foo');
       });
 
       it('should override an existing global default', () => {
         registry.addModelFactory(new TextModelFactory());
-        registry.addWidgetFactory(new WidgetFactory(), {
-          fileExtensions: ['*'],
-          defaultFor: ['.*'],
-          displayName: 'foo',
-          modelName: 'text'
-        });
-        let factory = new WidgetFactory();
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['*'],
-          defaultFor: ['*'],
-          displayName: 'bar',
-          modelName: 'text'
-        });
+        registry.addWidgetFactory(new GlobalWidgetFactory());
+        let factory = new GlobalWidgetFactory();
+        registry.addWidgetFactory(factory);
         expect(registry.defaultWidgetFactory('*')).to.be('bar');
       });
 
       it('should override an existing extension default', () => {
         registry.addModelFactory(new TextModelFactory());
-        registry.addWidgetFactory(new WidgetFactory(), {
-          fileExtensions: ['.txt'],
-          displayName: 'foo',
-          modelName: 'text'
-        });
+        registry.addWidgetFactory(new WidgetFactory());
         let factory = new WidgetFactory();
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.txt'],
-          displayName: 'bar',
-          modelName: 'text'
-        });
-        expect(registry.defaultWidgetFactory('.txt')).to.be('foo');
+        registry.addWidgetFactory(factory);
+        expect(registry.defaultWidgetFactory('.txt')).to.be(factory);
       });
 
       it('should be removed from the registry when disposed', () => {
         registry.addModelFactory(new TextModelFactory());
         let factory = new WidgetFactory();
-        let disposable = registry.addWidgetFactory(factory, {
-          fileExtensions: ['.txt'],
-          displayName: 'bar',
-          modelName: 'text'
-        });
+        let disposable = registry.addWidgetFactory(factory);
         disposable.dispose();
-        expect(registry.getWidgetFactory('bar')).to.be(void 0);
+        expect(registry.getWidgetFactory('test')).to.be(void 0);
       });
 
     });
@@ -211,14 +238,14 @@ describe('docregistry/registry', () => {
       it('should add a file type to the document registry', () => {
         let fileType = { name: 'notebook', extension: '.ipynb' };
         registry.addFileType(fileType);
-        expect(registry.fileTypes.next()).to.be(fileType);
+        expect(registry.getFileTypes().next()).to.be(fileType);
       });
 
       it('should be removed from the registry when disposed', () => {
         let fileType = { name: 'notebook', extension: '.ipynb' };
         let disposable = registry.addFileType(fileType);
         disposable.dispose();
-        expect(toArray(registry.fileTypes).length).to.be(0);
+        expect(toArray(registry.getFileTypes()).length).to.be(0);
       });
 
       it('should be a no-op if a file type of the same name is registered', () => {
@@ -226,7 +253,7 @@ describe('docregistry/registry', () => {
         registry.addFileType(fileType);
         let disposable = registry.addFileType(fileType);
         disposable.dispose();
-        expect(registry.fileTypes.next()).to.be(fileType);
+        expect(registry.getFileTypes().next()).to.be(fileType);
       });
 
     });
@@ -236,14 +263,14 @@ describe('docregistry/registry', () => {
       it('should add a file type to the document registry', () => {
         let creator = { name: 'notebook', fileType: 'notebook' };
         registry.addCreator(creator);
-        expect(registry.creators.next()).to.be(creator);
+        expect(registry.getCreators().next()).to.be(creator);
       });
 
       it('should be removed from the registry when disposed', () => {
         let creator = { name: 'notebook', fileType: 'notebook' };
         let disposable = registry.addCreator(creator);
         disposable.dispose();
-        expect(toArray(registry.creators).length).to.be(0);
+        expect(toArray(registry.getCreators()).length).to.be(0);
       });
 
       it('should end up in locale order', () => {
@@ -255,7 +282,7 @@ describe('docregistry/registry', () => {
         registry.addCreator(creators[0]);
         registry.addCreator(creators[1]);
         registry.addCreator(creators[2]);
-        let it = registry.creators;
+        let it = registry.getCreators();
         expect(it.next()).to.be(creators[2]);
         expect(it.next()).to.be(creators[0]);
         expect(it.next()).to.be(creators[1]);
@@ -266,81 +293,49 @@ describe('docregistry/registry', () => {
         registry.addCreator(creator);
         let disposable = registry.addCreator(creator);
         disposable.dispose();
-        expect(registry.creators.next()).to.eql(creator);
+        expect(registry.getCreators().next()).to.eql(creator);
       });
 
     });
 
-    describe('#listWidgetFactories()', () => {
+    describe('#preferredWidgetFactories()', () => {
 
-      it('should list the names of the valid registered widget factories', () => {
-        expect(registry.listWidgetFactories()).to.eql([]);
+      it('should give the valid registered widget factories', () => {
+        expect(toArray(registry.preferredWidgetFactories())).to.eql([]);
         registry.addModelFactory(new TextModelFactory());
         let factory = new WidgetFactory();
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.foo'],
-          displayName: 'Foo',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.foo'],
-          displayName: 'Bar',
-          modelName: 'text'
-        });
-        expect(toArray(registry.listWidgetFactories('.foo'))).to.eql(['Foo', 'Bar']);
+        registry.addWidgetFactory(factory);
+        let gFactory = new GlobalWidgetFactory();
+        registry.addWidgetFactory(gFactory);
+        let factories = registry.preferredWidgetFactories('.txt');
+        expect(toArray(factories)).to.eql([factory, gFactory]);
       });
 
       it('should not list a factory whose model is not registered', () => {
-        registry.addWidgetFactory(new WidgetFactory(), {
-          fileExtensions: ['.bar'],
-          displayName: 'Bar',
-          modelName: 'text'
-        });
-        expect(registry.listWidgetFactories().next()).to.eql(void 0);
+        registry.addWidgetFactory(new WidgetFactory());
+        expect(registry.preferredWidgetFactories().next()).to.eql(void 0);
       });
 
       it('should select the factory for a given extension', () => {
         registry.addModelFactory(new TextModelFactory());
         let factory = new WidgetFactory();
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.foo'],
-          displayName: 'Foo',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.bar'],
-          displayName: 'Bar',
-          modelName: 'text'
-        });
-        expect(registry.listWidgetFactories('.foo').next()).to.be('Foo');
+        registry.addWidgetFactory(factory);
+        let mdFactory = new MarkdownWidgetFactory();
+        registry.addWidgetFactory(mdFactory);
+        expect(registry.preferredWidgetFactories('.txt').next()).to.be(factory);
+        expect(registry.preferredWidgetFactories('.md').next()).to.be(mdFactory);
       });
 
       it('should respect the priority order', () => {
         registry.addModelFactory(new TextModelFactory());
         let factory = new WidgetFactory();
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.txt'],
-          displayName: 'Foo',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.txt'],
-          defaultFor: ['.txt'],
-          displayName: 'Bar',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['*'],
-          displayName: 'Buzz',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['*'],
-          defaultFor: ['*'],
-          displayName: 'Fizz',
-          modelName: 'text'
-        });
-        expect(toArray(registry.listWidgetFactories('.txt'))).to.eql(['Bar', 'Fizz', 'Foo', 'Buzz']);
+        registry.addWidgetFactory(factory);
+        let gFactory = new GlobalWidgetFactory();
+        registry.addWidgetFactory(gFactory);
+        let mdFactory = new MarkdownWidgetFactory();
+        registry.addWidgetFactory(mdFactory);
+        let factories = registry.preferredWidgetFactories('.txt');
+        expect(toArray(factories)).to.eql([factory, gFactory]);
       });
 
     });
@@ -350,54 +345,39 @@ describe('docregistry/registry', () => {
       it('should get the default widget factory for a given extension', () => {
         registry.addModelFactory(new TextModelFactory());
         let factory = new WidgetFactory();
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.txt'],
-          displayName: 'Foo',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['.txt'],
-          defaultFor: ['.txt'],
-          displayName: 'Bar',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['*'],
-          displayName: 'Buzz',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(factory, {
-          fileExtensions: ['*'],
-          defaultFor: ['*'],
-          displayName: 'Fizz',
-          modelName: 'text'
-        });
-        expect(registry.defaultWidgetFactory('.txt')).to.be('Bar');
-        expect(registry.defaultWidgetFactory()).to.be('Fizz');
+        registry.addWidgetFactory(factory);
+        let gFactory = new GlobalWidgetFactory();
+        registry.addWidgetFactory(gFactory);
+        let mdFactory = new MarkdownWidgetFactory();
+        registry.addWidgetFactory(mdFactory);
+        expect(registry.defaultWidgetFactory('.txt')).to.be(factory);
+        expect(registry.defaultWidgetFactory('.md')).to.be(mdFactory);
+        expect(registry.defaultWidgetFactory()).to.be(gFactory);
       });
 
     });
 
-    describe('#fileTypes', () => {
+    describe('#getFileTypes()', () => {
 
       it('should get the registered file types', () => {
-        expect(toArray(registry.fileTypes).length).to.be(0);
+        expect(toArray(registry.getFileTypes()).length).to.be(0);
         let fileTypes = [
           { name: 'notebook', extension: '.ipynb' },
           { name: 'python', extension: '.py' }
         ];
         registry.addFileType(fileTypes[0]);
         registry.addFileType(fileTypes[1]);
-        expect(registry.fileTypes.next()).to.be(fileTypes[0]);
-        expect(registry.fileTypes.next()).to.be(fileTypes[1]);
+        let values = registry.getFileTypes();
+        expect(values.next()).to.be(fileTypes[0]);
+        expect(values.next()).to.be(fileTypes[1]);
       });
 
     });
 
-    describe('#creators', () => {
+    describe('#getCreators()', () => {
 
       it('should get the registered file creators', () => {
-        expect(toArray(registry.creators).length).to.be(0);
+        expect(toArray(registry.getCreators()).length).to.be(0);
         let creators = [
           { name: 'Python Notebook', fileType: 'notebook' },
           { name: 'R Notebook', fileType: 'notebook' },
@@ -406,8 +386,8 @@ describe('docregistry/registry', () => {
         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');
+        expect(toArray(registry.getCreators()).length).to.be(3);
+        expect(registry.getCreators().next().name).to.be('CSharp Notebook');
       });
 
     });
@@ -450,25 +430,15 @@ describe('docregistry/registry', () => {
 
       it('should get a kernel preference', () => {
         registry.addModelFactory(new TextModelFactory());
-        registry.addWidgetFactory(new WidgetFactory(), {
-          fileExtensions: ['.txt'],
-          displayName: 'foo',
-          modelName: 'text'
-        });
-        registry.addWidgetFactory(new WidgetFactory(), {
-          fileExtensions: ['.py'],
-          displayName: 'bar',
-          modelName: 'text',
-          canStartKernel: true,
-          preferKernel: true
-        });
-
-        let pref = registry.getKernelPreference('.c', 'foo');
+        registry.addWidgetFactory(new WidgetFactory());
+        registry.addWidgetFactory(new PythonWidgetFactory());
+
+        let pref = registry.getKernelPreference('.c', 'global');
         expect(pref.language).to.be('clike');
         expect(pref.preferKernel).to.be(false);
         expect(pref.canStartKernel).to.be(false);
 
-        pref = registry.getKernelPreference('.py', 'bar');
+        pref = registry.getKernelPreference('.py', 'python');
         expect(pref.language).to.be('python');
         expect(pref.preferKernel).to.be(true);
         expect(pref.canStartKernel).to.be(true);
@@ -479,19 +449,12 @@ describe('docregistry/registry', () => {
 
     });
 
-    describe('#getModelFactoryFor()', () => {
+    describe('#getModelFactory()', () => {
 
-      it('should get a registered model factory for a given widget name', () => {
+      it('should get a registered model factory by name', () => {
         let mFactory = new TextModelFactory();
         registry.addModelFactory(mFactory);
-        registry.addWidgetFactory(new WidgetFactory(), {
-          fileExtensions: ['.txt'],
-          displayName: 'foo',
-          modelName: 'text'
-        });
-        expect(registry.getModelFactoryFor('foo')).to.be(mFactory);
-        expect(registry.getModelFactoryFor('FOO')).to.be(mFactory);
-        expect(registry.getModelFactoryFor('text')).to.be(void 0);
+        expect(registry.getModelFactory('text')).to.be(mFactory);
       });
 
     });
@@ -500,23 +463,13 @@ describe('docregistry/registry', () => {
 
       it('should get a widget factory by name', () => {
         registry.addModelFactory(new TextModelFactory());
-        let foo = new WidgetFactory();
-        registry.addWidgetFactory(foo, {
-          fileExtensions: ['*'],
-          defaultFor: ['.*'],
-          displayName: 'foo',
-          modelName: 'text'
-        });
-        let bar = new WidgetFactory();
-        registry.addWidgetFactory(bar, {
-          fileExtensions: ['*'],
-          defaultFor: ['*'],
-          displayName: 'bar',
-          modelName: 'text'
-        });
-        expect(registry.getWidgetFactory('foo')).to.be(foo);
-        expect(registry.getWidgetFactory('Foo')).to.be(foo);
-        expect(registry.getWidgetFactory('bar')).to.be(bar);
+        let factory = new WidgetFactory();
+        registry.addWidgetFactory(factory);
+        let mdFactory = new MarkdownWidgetFactory();
+        registry.addWidgetFactory(mdFactory);
+        expect(registry.getWidgetFactory('test')).to.be(factory);
+        expect(registry.getWidgetFactory('Test')).to.be(factory);
+        expect(registry.getWidgetFactory('markdown')).to.be(mdFactory);
         expect(registry.getWidgetFactory('baz')).to.be(void 0);
       });