Add tests for json data and injector

package.json

@@ -41,6 +41,7 @@
     "fs-extra": "^0.26.4",
     "istanbul-instrumenter-loader": "^0.1.3",
     "json-loader": "^0.5.4",
+    "json-to-html": "^0.1.2",
     "karma": "^0.13.19",
     "karma-chrome-launcher": "^0.2.2",
     "karma-coverage": "^0.5.3",

test/src/notebook/cells/model.spec.ts

@@ -406,7 +406,10 @@ describe('notebook/cells/model', () => {
           outputs: [
             {
               output_type: 'display_data',
-              data: { 'text/plain': 'foo' },
+              data: {
+                'text/plain': 'foo',
+                'application/json': { 'bar': 1 }
+              },
               metadata: {}
             } as nbformat.IDisplayData
           ],
@@ -414,8 +417,11 @@ describe('notebook/cells/model', () => {
           metadata: { trusted: false }
         };
         let model = new CodeCellModel(cell);
-        expect(model.toJSON()).to.not.equal(cell);
-        expect(model.toJSON()).to.eql(cell);
+        let serialized = model.toJSON();
+        expect(serialized).to.not.equal(cell);
+        expect(serialized).to.eql(cell);
+        let output = serialized.outputs[0] as any;
+        expect(output.data['application/json']['bar']).to.be(1);
       });
 
     });

test/src/rendermime/rendermime.spec.ts

@@ -3,6 +3,8 @@
 
 import expect = require('expect.js');
 
+import json2html = require('json2html');
+
 import {
   Widget
 } from 'phosphor/lib/ui/widget';
@@ -100,6 +102,34 @@ describe('rendermime/index', () => {
         expect(widget.node.innerHTML.indexOf('script')).to.be(-1);
       });
 
+      it('should render json data', () => {
+        let bundle: RenderMime.MimeMap<JSONObject> = {
+          'application/json': { 'foo': 1 }
+        };
+        let r = defaultRenderMime();
+        let widget = r.render({ bundle });
+        expect(widget.node.textContent).to.be('foo');
+      });
+
+      it('should accept an injector', () => {
+        let called = 0;
+        let injector = (mimetype: string, value: string | JSONObject) => {
+          if (mimetype === 'text/plain') {
+            expect(value as string).to.be('foo');
+            called++;
+          } else if (mimetype === 'application/json') {
+            expect((value as JSONObject)['foo']).to.be(1);
+            called++;
+          }
+        };
+        let bundle: RenderMime.MimeMap<string> = {
+          'foo/bar': '1'
+        };
+        let r = defaultRenderMime();
+        r.render({ bundle, injector });
+        expect(called).to.be(2);
+      });
+
     });
 
     describe('#preferredMimetype()', () => {

test/src/utils.ts

@@ -134,14 +134,50 @@ namespace Private {
   export
   const notebookFactory = new NotebookModelFactory();
 
+  class JSONRenderer extends HTMLRenderer {
+    /**
+     * The mimetypes this renderer accepts.
+     */
+    mimetypes = ['application/json'];
+
+    /**
+     * Render the transformed mime bundle.
+     */
+    render(options: RenderMime.IRendererOptions<string>): Widget {
+      options.source = json2html(options.source);
+      return super.render(options);
+    }
+  }
+
+
+  class InjectionRenderer extends TextRenderer {
+    /**
+     * The mimetypes this renderer accepts.
+     */
+    mimetypes = ['foo/bar'];
+
+    /**
+     * Render the transformed mime bundle.
+     */
+    render(options: RenderMime.IRendererOptions<string>): Widget {
+      if (options.injector) {
+        options.injector('text/plain', 'foo');
+        options.injector('application/json', { 'foo': 1 } );
+      }
+      return super.render(options);
+    }
+  }
+
   const TRANSFORMERS = [
     new JavascriptRenderer(),
+    new JSONRenderer(),
     new MarkdownRenderer(),
     new HTMLRenderer(),
     new PDFRenderer(),
     new ImageRenderer(),
     new SVGRenderer(),
     new LatexRenderer(),
+    new InjectionRenderer(),
     new TextRenderer()
   ];