Merge pull request #106 from blink1073/widgetfactory-test

NotebookWidgetFactory tests

src/notebook/notebook/widgetfactory.ts

@@ -41,14 +41,21 @@ export
 class NotebookWidgetFactory implements IWidgetFactory<NotebookPanel> {
   /**
    * Construct a new notebook widget factory.
+   *
+   * @param rendermime - The rendermime instance.
+   *
+   * @param clipboard - The application clipboard.
    */
   constructor(rendermime: RenderMime<Widget>, clipboard: IClipboard) {
-    this._rendermime = rendermime.clone();
+    this._rendermime = rendermime;
     this._clipboard = clipboard;
   }
 
   /**
    * Get whether the factory has been disposed.
+   *
+   * #### Notes
+   * This is a read-only property.
    */
   get isDisposed(): boolean {
     return this._rendermime === null;
@@ -64,6 +71,10 @@ class NotebookWidgetFactory implements IWidgetFactory<NotebookPanel> {
 
   /**
    * Create a new widget.
+   *
+   * #### Notes
+   * The factory will start the appropriate kernel and populate
+   * the default toolbar items using `ToolbarItems.populateDefaults`.
    */
   createNew(model: INotebookModel, context: IDocumentContext, kernel?: IKernelId): NotebookPanel {
     let rendermime = this._rendermime.clone();
@@ -83,6 +94,8 @@ class NotebookWidgetFactory implements IWidgetFactory<NotebookPanel> {
    *
    * @returns A promise that resolves to true if the document should close
    *   and false otherwise.
+   *
+   * ### The default implementation is a no-op.
    */
   beforeClose(model: INotebookModel, context: IDocumentContext, widget: NotebookPanel): Promise<boolean> {
     // No special action required.

test/src/docmanager/mockcontext.ts

@@ -7,6 +7,10 @@ import {
   IKernelId, IKernel, IKernelSpecIds, ISessionId, IContentsModel
 } from 'jupyter-js-services';
 
+import {
+  MockKernel
+} from 'jupyter-js-services/lib/mockkernel';
+
 import {
   IDisposable
 } from 'phosphor-disposable';
@@ -53,7 +57,7 @@ class MockContext implements IDocumentContext {
   }
 
   get kernel(): IKernel {
-    return null;
+    return this._kernel;
   }
 
   get path(): string {
@@ -65,7 +69,31 @@ class MockContext implements IDocumentContext {
   }
 
   get kernelspecs(): IKernelSpecIds {
-    return void 0;
+    return {
+      default: 'python',
+      kernelspecs: {
+        python: {
+          name: 'python',
+          spec: {
+            language: 'python',
+            argv: [],
+            display_name: 'Python',
+            env: {}
+          },
+          resources: {}
+        },
+        shell: {
+          name: 'shell',
+          spec: {
+            language: 'shell',
+            argv: [],
+            display_name: 'Shell',
+            env: {}
+          },
+          resources: {}
+        }
+      }
+    };
   }
 
   get isDisposed(): boolean {
@@ -78,7 +106,9 @@ class MockContext implements IDocumentContext {
   }
 
   changeKernel(options: IKernelId): Promise<IKernel> {
-    return Promise.resolve(void 0);
+    this._kernel = new MockKernel(options);
+    this.kernelChanged.emit(this._kernel);
+    return Promise.resolve(this._kernel);
   }
 
   save(): Promise<void> {
@@ -102,6 +132,7 @@ class MockContext implements IDocumentContext {
   }
 
   private _model: IDocumentModel = null;
+  private _kernel: IKernel = null;
 }
 
 

test/src/index.ts

@@ -11,6 +11,7 @@ import './notebook/notebook/nbformat.spec';
 import './notebook/notebook/model.spec';
 import './notebook/notebook/modelfactory.spec';
 import './notebook/notebook/widget.spec';
+import './notebook/notebook/widgetfactory.spec';
 
 import './notebook/output-area/model.spec';
 import './notebook/output-area/widget.spec';

test/src/notebook/notebook/widgetfactory.spec.ts

@@ -0,0 +1,154 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import expect = require('expect.js');
+
+import {
+  MimeData
+} from 'phosphor-dragdrop';
+
+import {
+  NotebookModel
+} from '../../../../lib/notebook/notebook/model';
+
+import {
+  NotebookPanel
+} from '../../../../lib/notebook/notebook/panel';
+
+import {
+  NotebookWidgetFactory
+} from '../../../../lib/notebook/notebook/widgetfactory';
+
+import {
+  MockContext
+} from '../../docmanager/mockcontext';
+
+import {
+  defaultRenderMime
+} from '../../rendermime/rendermime.spec';
+
+
+const rendermime = defaultRenderMime();
+const clipboard = new MimeData();
+
+
+describe('notebook/notebook/widgetfactory', () => {
+
+  describe('NotebookWidgetFactory', () => {
+
+    describe('#constructor()', () => {
+
+      it('should create a notebook widget factory', () => {
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        expect(factory).to.be.a(NotebookWidgetFactory);
+      });
+
+    });
+
+    describe('#isDisposed', () => {
+
+      it('should get whether the factory has been disposed', () => {
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        expect(factory.isDisposed).to.be(false);
+        factory.dispose();
+        expect(factory.isDisposed).to.be(true);
+      });
+
+      it('should be read-only', () => {
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        expect(() => { factory.isDisposed = false; }).to.throwError();
+      });
+
+    });
+
+    describe('#dispose()', () => {
+
+      it('should dispose of the resources held by the factory', () => {
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        factory.dispose();
+        expect(factory.isDisposed).to.be(true);
+      });
+
+      it('should be safe to call multiple times', () => {
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        factory.dispose();
+        factory.dispose();
+        expect(factory.isDisposed).to.be(true);
+      });
+
+    });
+
+    describe('#createNew()', () => {
+
+      it('should create a new `NotebookPanel` widget', () => {
+        let model = new NotebookModel();
+        let context = new MockContext(model);
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        let panel = factory.createNew(model, context);
+        expect(panel).to.be.a(NotebookPanel);
+      });
+
+      it('should create a clone of the rendermime', () => {
+        let model = new NotebookModel();
+        let context = new MockContext(model);
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        let panel = factory.createNew(model, context);
+        expect(panel.rendermime).to.not.be(rendermime);
+      });
+
+      it('should start a kernel if one is given', () => {
+        let model = new NotebookModel();
+        let context = new MockContext(model);
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        let panel = factory.createNew(model, context, { name: 'shell' });
+        expect(panel.context.kernel.name).to.be('shell');
+      });
+
+      it('should start a kernel given the default kernel language', () => {
+        let model = new NotebookModel();
+        let context = new MockContext(model);
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        let panel = factory.createNew(model, context);
+        expect(panel.context.kernel.name).to.be('python');
+      });
+
+      it('should start a kernel based on default language of the model', () => {
+        let model = new NotebookModel();
+        let cursor = model.getMetadata('language_info');
+        cursor.setValue({ name: 'shell' });
+        let context = new MockContext(model);
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        let panel = factory.createNew(model, context);
+        expect(panel.context.kernel.name).to.be('shell');
+      });
+
+      it('should populate the default toolbar items', () => {
+        let model = new NotebookModel();
+        let context = new MockContext(model);
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        let panel = factory.createNew(model, context);
+        let items = panel.toolbar.list();
+        expect(items).to.contain('save');
+        expect(items).to.contain('restart');
+        expect(items).to.contain('kernelStatus');
+      });
+
+    });
+
+    describe('#beforeClose()', () => {
+
+      it('should be a no-op', (done) => {
+        let model = new NotebookModel();
+        let context = new MockContext(model);
+        let factory = new NotebookWidgetFactory(rendermime, clipboard);
+        let panel = factory.createNew(model, context);
+        factory.beforeClose(model, context, panel).then(() => {
+          done();
+        });
+      });
+
+    });
+
+  });
+
+});