Added tests for mimeType and executionSummary of notebook code

Author: subhash-arabhi

vscode/src/test/unit/mocks/vscode/mockVscode.ts

@@ -19,13 +19,15 @@ import { URI } from './uri';
 import { mockWindowNamespace } from './namespaces/window';
 import { mockEnvNamespace } from './namespaces/env';
 import { mockedEnums } from './vscodeHostedTypes';
+import { NotebookCellOutputItem } from './notebookCellOutputItem';
 
 type VSCode = typeof vscode;
 const mockedVSCode: Partial<VSCode> = {};
 
 const mockedVscodeClassesAndTypes = () => {
     mockedVSCode.Uri = URI as any;
     mockedVSCode.ViewColumn = mockedEnums.viewColumn;
+    mockedVSCode.NotebookCellOutputItem = NotebookCellOutputItem as any;
 }
 
 const mockNamespaces = () => {

vscode/src/test/unit/mocks/vscode/notebookCellOutputItem.ts

@@ -0,0 +1,31 @@
+/*
+  Copyright (c) 2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+export class NotebookCellOutputItem {
+  public data: Uint8Array;
+  public mime: string;
+  private constructor(data: Uint8Array, mime: string) {
+    this.data = data;
+    this.mime = mime;
+  }
+  public static create(data: Uint8Array, mime: string) {
+    return new NotebookCellOutputItem(data, mime);
+  }
+  public static text(text: string, mime: string) {
+    const enc = new TextEncoder().encode(text);
+    return new NotebookCellOutputItem(enc, mime);
+  }
+}

vscode/src/test/unit/notebooks/executionSummary.unit.test.ts

@@ -0,0 +1,108 @@
+/*
+  Copyright (c) 2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { expect } from 'chai';
+import { ExecutionSummary, ExecutionSummaryData } from '../../../notebooks/executionSummary';
+import { describe, it } from 'mocha';
+
+describe('ExecutionSummary', () => {
+  describe('constructor defaults', () => {
+    it('defaults to null executionOrder and false success', () => {
+      const es = new ExecutionSummary();
+      expect(es.executionOrder).to.be.null;
+      expect(es.success).to.equal(false);
+    });
+
+    it('accepts explicit values', () => {
+      const es = new ExecutionSummary(3, true);
+      expect(es.executionOrder).to.equal(3);
+      expect(es.success).to.equal(true);
+
+      const es2 = new ExecutionSummary(0, false);
+      expect(es2.executionOrder).to.equal(0);
+      expect(es2.success).to.equal(false);
+    });
+  });
+
+  describe('static fromMetadata()', () => {
+    it('returns defaults when meta and fallback are undefined', () => {
+      const es = ExecutionSummary.fromMetadata();
+      expect(es.executionOrder).to.be.null;
+      expect(es.success).to.equal(false);
+    });
+
+    it('uses fallbackExecCount when meta.executionOrder is undefined', () => {
+      const es = ExecutionSummary.fromMetadata({}, 7);
+      expect(es.executionOrder).to.equal(7);
+      expect(es.success).to.equal(false);
+    });
+
+    it('uses fallbackExecCount when meta.executionOrder is null', () => {
+      const meta: ExecutionSummaryData = { executionOrder: null };
+      const es = ExecutionSummary.fromMetadata(meta, 12);
+      expect(es.executionOrder).to.equal(12);
+      expect(es.success).to.equal(false);
+    });
+
+    it('ignores fallback when meta.executionOrder is provided', () => {
+      const meta: ExecutionSummaryData = { executionOrder: 5, success: true };
+      const es = ExecutionSummary.fromMetadata(meta, 10);
+      expect(es.executionOrder).to.equal(5);
+      expect(es.success).to.equal(true);
+    });
+
+    it('defaults success to false if meta.success is undefined', () => {
+      const meta: ExecutionSummaryData = { executionOrder: 2 };
+      const es = ExecutionSummary.fromMetadata(meta, null);
+      expect(es.executionOrder).to.equal(2);
+      expect(es.success).to.equal(false);
+    });
+
+    it('respects meta.success when false explicitly', () => {
+      const meta: ExecutionSummaryData = { executionOrder: 8, success: false };
+      const es = ExecutionSummary.fromMetadata(meta, 1);
+      expect(es.executionOrder).to.equal(8);
+      expect(es.success).to.equal(false);
+    });
+  });
+
+  describe('toJSON()', () => {
+    it('serializes current state to ExecutionSummaryData', () => {
+      const es = new ExecutionSummary(9, true);
+      const json = es.toJSON();
+      expect(json).to.deep.equal({ executionOrder: 9, success: true });
+    });
+
+    it('handles null executionOrder serialization', () => {
+      const es = new ExecutionSummary(null, false);
+      const json = es.toJSON();
+      expect(json).to.deep.equal({ executionOrder: null, success: false });
+    });
+
+    it('round-trips fromMetadata → toJSON', () => {
+      const meta: ExecutionSummaryData = { executionOrder: 15, success: true };
+      const es = ExecutionSummary.fromMetadata(meta, 20);
+      const json = es.toJSON();
+      expect(json).to.deep.equal(meta);
+    });
+
+    it('round-trips fallbackExecCount when meta missing', () => {
+      const es = ExecutionSummary.fromMetadata(undefined, 33);
+      const json = es.toJSON();
+      expect(json).to.deep.equal({ executionOrder: 33, success: false });
+    });
+  });
+});

vscode/src/test/unit/notebooks/mimeTypeHandler.unit.test.ts

@@ -0,0 +1,186 @@
+/*
+  Copyright (c) 2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { expect } from 'chai';
+import { Buffer } from 'buffer';
+import { NotebookCellOutputItem } from 'vscode';
+import { MimeTypeHandler } from '../../../notebooks/mimeTypeHandler';
+import { mimeTypes } from '../../../notebooks/constants';
+import { IMimeBundle } from '../../../notebooks/types';
+import { describe, it } from 'mocha';
+
+describe('MimeTypeHandler', () => {
+
+  function decodeData(item: NotebookCellOutputItem): string {
+    const bytes: Uint8Array = (item as any).data;
+    return new TextDecoder().decode(bytes);
+  }
+
+  describe('getters isText / isImage', () => {
+    it('isText ⇢ true only for mimeTypes.TEXT', () => {
+      expect(new MimeTypeHandler(mimeTypes.TEXT).isText).to.be.true;
+      expect(new MimeTypeHandler('image/jpeg').isText).to.be.false;
+    });
+
+    it('isImage ⇢ true only for image/*', () => {
+      expect(new MimeTypeHandler('image/png').isImage).to.be.true;
+      expect(new MimeTypeHandler(mimeTypes.TEXT).isImage).to.be.false;
+    });
+      
+  });
+
+  describe('static toBytes()', () => {
+    it('decodes a base64 string into the original Uint8Array', () => {
+      const text = 'Hello, 世界!';
+      const b64  = Buffer.from(text).toString('base64');
+      const out  = MimeTypeHandler.toBytes(b64);
+      expect(out).to.be.instanceOf(Uint8Array);
+      expect(Buffer.from(out).toString()).to.equal(text);
+    });
+
+    it('returns the same Uint8Array when passed through', () => {
+      const arr = new Uint8Array([1, 2, 3]);
+      expect(MimeTypeHandler.toBytes(arr)).to.equal(arr);
+    });
+
+    it('decodes empty string to empty Uint8Array', () => {
+      const out = MimeTypeHandler.toBytes('');
+      expect(out).to.be.instanceOf(Uint8Array);
+      expect(out.length).to.equal(0);
+    });
+  });
+
+  describe('static toString()', () => {
+    it('returns the same string if input is already string', () => {
+      const s = 'just a test';
+      expect(MimeTypeHandler.toString(s)).to.equal(s);
+    });
+
+    it('decodes a Uint8Array into a string via TextDecoder', () => {
+      const text    = '¡Hola!';
+      const encoder = new TextEncoder();
+      const arr     = encoder.encode(text);
+      expect(MimeTypeHandler.toString(arr)).to.equal(text);
+    });
+
+    it('decodes empty Uint8Array to empty string', () => {
+      const arr = new Uint8Array([]);
+      expect(MimeTypeHandler.toString(arr)).to.equal('');
+    });
+  });
+
+  describe('makeOutputItem()', () => {
+    it('for TEXT builds a NotebookCellOutputItem containing the UTF-8 bytes of the string', () => {
+      const handler = new MimeTypeHandler(mimeTypes.TEXT);
+      const item    = handler.makeOutputItem('plain text');
+      expect(item).to.be.instanceOf(NotebookCellOutputItem);
+      expect((item as any).mime).to.equal(mimeTypes.TEXT);
+      expect(decodeData(item)).to.equal('plain text');
+    });
+
+    it('handles empty text payload correctly', () => {
+      const handler = new MimeTypeHandler(mimeTypes.TEXT);
+      const item    = handler.makeOutputItem('');
+      expect(decodeData(item)).to.equal('');
+      expect((item as any).data.length).to.equal(0);
+    });
+
+    it('for image/* with a base64 string decodes back to the original bytes', () => {
+      const raw  = new Uint8Array([10, 20, 30]);
+      const b64  = Buffer.from(raw).toString('base64');
+      const handler = new MimeTypeHandler('image/png');
+      const item    = handler.makeOutputItem(b64);
+      expect((item as any).mime).to.equal('image/png');
+      const got = (item as any).data as Uint8Array;
+      expect(Array.from(got)).to.deep.equal(Array.from(raw));
+    });
+
+    it('for image/* with a Uint8Array leaves the bytes untouched', () => {
+      const raw = new Uint8Array([5, 6, 7]);
+      const handler = new MimeTypeHandler('image/gif');
+      const item    = handler.makeOutputItem(raw);
+      expect((item as any).mime).to.equal('image/gif');
+      expect((item as any).data).to.equal(raw);
+    });
+
+    it('unknown mime routes through text branch', () => {
+      const handler = new MimeTypeHandler('application/xml');
+      const payload = '<note/>';
+      const item    = handler.makeOutputItem(payload);
+      expect((item as any).mime).to.equal('application/xml');
+      expect(decodeData(item)).to.equal(payload);
+    });
+  });
+
+  describe('static itemsFromBundle()', () => {
+    it('filters to only text & image entries and decodes each correctly', () => {
+      const rawImg = new Uint8Array([1, 2, 3]);
+      const b64img = Buffer.from(rawImg).toString('base64');
+      const bundle: IMimeBundle = {
+        [mimeTypes.TEXT]: 'foo',
+        'image/png': b64img,
+        'application/json': '{"x":1}',
+      };
+
+      const items = MimeTypeHandler.itemsFromBundle(bundle);
+      expect(items).to.have.length(2);
+
+      const textItem = items.find(i => (i as any).mime === mimeTypes.TEXT)!;
+      expect(decodeData(textItem)).to.equal('foo');
+
+      const imgItem = items.find(i => (i as any).mime === 'image/png')!;
+      const gotBytes = (imgItem as any).data as Uint8Array;
+      expect(Array.from(gotBytes)).to.deep.equal(Array.from(rawImg));
+    });
+
+    it('joins string-array values before creating the output item', () => {
+      const bundle: IMimeBundle = {
+        [mimeTypes.TEXT]: ['a', 'b', 'c'],
+      };
+      const items = MimeTypeHandler.itemsFromBundle(bundle);
+      expect(items).to.have.length(1);
+      const only = items[0];
+      expect(decodeData(only)).to.equal('abc');
+      expect((only as any).mime).to.equal(mimeTypes.TEXT);
+    });
+
+    it('joins base64-string-array for image payload', () => {
+      // "SGVs" + "bG8=" => "SGVsbG8=" which decodes to "Hello"
+      const segs = ['SGVs', 'bG8='];
+      const bundle: IMimeBundle = {
+        'image/png': segs,
+      };
+      const items = MimeTypeHandler.itemsFromBundle(bundle);
+      expect(items).to.have.length(1);
+      const only = items[0];
+      expect((only as any).mime).to.equal('image/png');
+      expect(decodeData(only)).to.equal('Hello');
+    });
+
+    it('empty bundle yields no items', () => {
+      const items = MimeTypeHandler.itemsFromBundle({});
+      expect(items).to.be.empty;
+    });
+
+    it('unsupported mime types are dropped', () => {
+      const bundle: IMimeBundle = {
+        'application/json': '[1,2,3]',
+        'video/mp4': 'abcd',
+      };
+      expect(MimeTypeHandler.itemsFromBundle(bundle)).to.be.empty;
+    });
+  });
+});