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, it } from "vitest";
import { getBinnedFields, getDirectionOfBar, ParamNames } from "../params";
import type { VegaLiteUnitSpec } from "../types";
describe("getDirectionOfBar", () => {
it("should return undefined if spec is not provided", () => {
expect(getDirectionOfBar(undefined!)).toBeUndefined();
});
it("should return undefined if mark is not in spec", () => {
const spec = { encoding: {} } as VegaLiteUnitSpec;
expect(getDirectionOfBar(spec)).toBeUndefined();
});
it('should return "vertical" if xEncoding type is "nominal"', () => {
const spec = {
mark: {},
encoding: { x: { type: "nominal" } },
} as VegaLiteUnitSpec;
expect(getDirectionOfBar(spec)).toBe("vertical");
});
it('should return "horizontal" if yEncoding type is "nominal"', () => {
const spec = {
mark: {},
encoding: { y: { type: "nominal" } },
} as VegaLiteUnitSpec;
expect(getDirectionOfBar(spec)).toBe("horizontal");
});
it('should return "horizontal" if xEncoding has "aggregate"', () => {
const spec = {
mark: {},
encoding: { x: { aggregate: "sum" } },
} as VegaLiteUnitSpec;
expect(getDirectionOfBar(spec)).toBe("horizontal");
});
it('should return "vertical" if yEncoding has "aggregate"', () => {
const spec = {
mark: {},
encoding: { y: { aggregate: "sum" } },
} as VegaLiteUnitSpec;
expect(getDirectionOfBar(spec)).toBe("vertical");
});
it("should return undefined if no conditions are met", () => {
const spec = { mark: {}, encoding: { x: {}, y: {} } } as VegaLiteUnitSpec;
expect(getDirectionOfBar(spec)).toBeUndefined();
});
});
describe("getBinnedFields", () => {
it("should return empty array if spec has no encoding", () => {
const spec = { mark: "point" } as VegaLiteUnitSpec;
expect(getBinnedFields(spec)).toEqual([]);
});
it("should return empty array if no fields are binned", () => {
const spec = {
mark: "point",
encoding: {
x: { field: "x", type: "quantitative" },
y: { field: "y", type: "quantitative" },
},
} as VegaLiteUnitSpec;
expect(getBinnedFields(spec)).toEqual([]);
});
it("should return binned field name for x encoding", () => {
const spec = {
mark: "bar",
encoding: {
x: { field: "x", bin: true, type: "quantitative" },
y: { aggregate: "count", type: "quantitative" },
},
} as VegaLiteUnitSpec;
expect(getBinnedFields(spec)).toEqual(["x"]);
});
it("should return binned field name for y encoding", () => {
const spec = {
mark: "bar",
encoding: {
x: { aggregate: "count", type: "quantitative" },
y: { field: "y", bin: true, type: "quantitative" },
},
} as VegaLiteUnitSpec;
expect(getBinnedFields(spec)).toEqual(["y"]);
});
it("should return multiple binned fields", () => {
const spec = {
mark: "rect",
encoding: {
x: { field: "x", bin: true, type: "quantitative" },
y: { field: "y", bin: true, type: "quantitative" },
color: { aggregate: "count", type: "quantitative" },
},
} as VegaLiteUnitSpec;
expect(getBinnedFields(spec)).toEqual(["x", "y"]);
});
it("should handle bin with custom configuration", () => {
const spec = {
mark: "bar",
encoding: {
x: {
field: "temperature",
bin: { maxbins: 20 },
type: "quantitative",
},
y: { aggregate: "count", type: "quantitative" },
},
} as VegaLiteUnitSpec;
expect(getBinnedFields(spec)).toEqual(["temperature"]);
});
it("should ignore encodings without field property", () => {
const spec = {
mark: "bar",
encoding: {
x: { bin: true, type: "quantitative" },
y: { field: "y", type: "quantitative" },
},
} as VegaLiteUnitSpec;
expect(getBinnedFields(spec)).toEqual([]);
});
});
describe("ParamNames", () => {
describe("binColoring", () => {
it("should generate bin_coloring for undefined layer", () => {
expect(ParamNames.binColoring(undefined)).toBe("bin_coloring");
});
it("should generate bin_coloring_0 for layer 0", () => {
expect(ParamNames.binColoring(0)).toBe("bin_coloring_0");
});
it("should generate bin_coloring_1 for layer 1", () => {
expect(ParamNames.binColoring(1)).toBe("bin_coloring_1");
});
});
describe("isBinColoring", () => {
it("should return true for bin_coloring", () => {
expect(ParamNames.isBinColoring("bin_coloring")).toBe(true);
});
it("should return true for bin_coloring_0", () => {
expect(ParamNames.isBinColoring("bin_coloring_0")).toBe(true);
});
it("should return true for bin_coloring_123", () => {
expect(ParamNames.isBinColoring("bin_coloring_123")).toBe(true);
});
it("should return false for select_point", () => {
expect(ParamNames.isBinColoring("select_point")).toBe(false);
});
it("should return false for select_interval", () => {
expect(ParamNames.isBinColoring("select_interval")).toBe(false);
});
it("should return false for legend_selection_field", () => {
expect(ParamNames.isBinColoring("legend_selection_field")).toBe(false);
});
});
});