A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
/* Copyright 2026 Marimo. All rights reserved. */
import { describe, expect, test } from "vitest";
import {
type Base64String,
base64ToDataURL,
base64ToDataView,
base64ToUint8Array,
type DataURLString,
dataViewToBase64,
deserializeJson,
extractBase64FromDataURL,
isDataURLString,
type JsonString,
uint8ArrayToBase64,
} from "../base64";
describe("base64", () => {
describe("deserializeJson", () => {
test("deserializes JSON string to object", () => {
const json = '{"name":"marimo","type":"notebook"}' as JsonString<{
name: string;
type: string;
}>;
const result = deserializeJson(json);
expect(result).toEqual({ name: "marimo", type: "notebook" });
});
test("deserializes JSON array", () => {
const json = "[1,2,3]" as JsonString<number[]>;
const result = deserializeJson(json);
expect(result).toEqual([1, 2, 3]);
});
});
describe("base64ToDataURL", () => {
test("creates proper data URL with mime type", () => {
const base64 = "SGVsbG8=" as Base64String;
const result = base64ToDataURL(base64, "text/plain");
expect(result).toBe("data:text/plain;base64,SGVsbG8=");
});
test("handles image mime types", () => {
const base64 = "iVBORw0KGgo=" as Base64String;
const result = base64ToDataURL(base64, "image/png");
expect(result).toBe("data:image/png;base64,iVBORw0KGgo=");
});
});
describe("isDataURLString", () => {
test.each([
["data:text/plain;base64,SGVsbG8=", true],
["data:image/png;base64,iVBORw0KGgoAAAANSUhEUgA", true],
["not-a-data-url", false],
["base64,SGVsbG8=", false],
["data:text/plain,hello", false],
["data:text/plain;charset=utf-8,hello", false],
])("isDataURLString(%s) returns %s", (input, expected) => {
expect(isDataURLString(input)).toBe(expected);
});
});
describe("extractBase64FromDataURL", () => {
test.each([
["data:text/plain;base64,SGVsbG8=", "SGVsbG8="],
[
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgA",
"iVBORw0KGgoAAAANSUhEUgA",
],
["data:application/json;base64,", ""],
["data:text/html;charset=utf-8;base64,PGh0bWw+", "PGh0bWw+"],
])("extracts base64 from %s", (dataUrl, expected) => {
expect(extractBase64FromDataURL(dataUrl as DataURLString)).toBe(expected);
});
});
describe("base64ToUint8Array", () => {
test("converts base64 to Uint8Array", () => {
const base64 = "QUJD" as Base64String; // "ABC"
const result = base64ToUint8Array(base64);
expect(result).toEqual(new Uint8Array([65, 66, 67]));
});
test("handles empty base64 string", () => {
const base64 = "" as Base64String;
const result = base64ToUint8Array(base64);
expect(result).toEqual(new Uint8Array([]));
});
});
describe("base64ToDataView", () => {
test("converts base64 to DataView", () => {
const base64 = "QUJD" as Base64String; // "ABC"
const result = base64ToDataView(base64);
expect(result.byteLength).toBe(3);
expect(result.getUint8(0)).toBe(65);
expect(result.getUint8(1)).toBe(66);
expect(result.getUint8(2)).toBe(67);
});
});
describe("uint8ArrayToBase64", () => {
test("converts Uint8Array to base64", () => {
const array = new Uint8Array([65, 66, 67]);
const result = uint8ArrayToBase64(array);
expect(result).toBe("QUJD");
});
test("handles empty Uint8Array", () => {
const array = new Uint8Array([]);
const result = uint8ArrayToBase64(array);
expect(result).toBe("");
});
});
describe("dataViewToBase64", () => {
test("should convert a DataView to a base64 string", () => {
const encoder = new TextEncoder();
const bytes = encoder.encode("Hello, World!");
const dataView = new DataView(bytes.buffer);
const base64 = dataViewToBase64(dataView);
// Decode and verify
const decoded = atob(base64);
expect(decoded).toBe("Hello, World!");
});
test("should handle empty DataView", () => {
const dataView = new DataView(new ArrayBuffer(0));
const base64 = dataViewToBase64(dataView);
expect(base64).toBe("");
});
test("should handle DataView with offset and length", () => {
const encoder = new TextEncoder();
const bytes = encoder.encode("Hello, World!");
// Create a DataView that only looks at "World!"
const dataView = new DataView(bytes.buffer, 7, 6);
const base64 = dataViewToBase64(dataView);
const decoded = atob(base64);
expect(decoded).toBe("World!");
});
test("should handle binary data", () => {
const bytes = new Uint8Array([0, 1, 2, 255, 254, 253]);
const dataView = new DataView(bytes.buffer);
const base64 = dataViewToBase64(dataView);
// Verify round-trip
const decoded = atob(base64);
const decodedBytes = new Uint8Array(decoded.length);
for (let i = 0; i < decoded.length; i++) {
decodedBytes[i] = decoded.charCodeAt(i);
}
expect([...decodedBytes]).toEqual([0, 1, 2, 255, 254, 253]);
});
});
describe("round-trip conversions", () => {
test("Uint8Array to base64 and back", () => {
const original = new Uint8Array([1, 2, 3, 255, 128, 0]);
const base64 = uint8ArrayToBase64(original);
const result = base64ToUint8Array(base64);
expect(result).toEqual(original);
});
test("DataView to base64 and back", () => {
const buffer = new ArrayBuffer(4);
const original = new DataView(buffer);
original.setUint32(0, 0x12_34_56_78);
const base64 = dataViewToBase64(original);
const result = base64ToDataView(base64);
expect(result.getUint32(0)).toBe(0x12_34_56_78);
});
});
});