The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
import fetch from "node-fetch";
import type { VersionInfoFile } from "./types";
import {
generateVersionInfoJson,
getOssVersionInfo,
getSupportedMajorVersions,
getSupportedMajors,
getVersionInfoUrl,
hasRecentMinorReleaseIn,
isLtsVersion,
updateVersionInfoLatest,
updateVersionInfoLatestJson,
} from "./version-info";
jest.mock("node-fetch", () => ({
__esModule: true,
default: jest.fn(),
}));
const mockFetch = jest.mocked(fetch);
describe("version-info", () => {
describe("generateVersionInfoJson", () => {
const oldJson = {
latest: {
version: "v0.2.3",
released: "2021-01-01",
patch: true,
highlights: ["see https://www.metabase.com/changelog/2#metabase-23"],
},
older: [],
} as VersionInfoFile;
it("should add new version to version info json", () => {
const generatedJson = generateVersionInfoJson({
version: "v0.3.0",
existingVersionInfo: oldJson,
});
expect(generatedJson.older).toEqual([
{
version: "v0.3.0",
released: expect.any(String),
patch: false,
highlights: ["see https://www.metabase.com/changelog/3#metabase-30"],
},
]);
});
it("should leave old latest version intact", () => {
const generatedJson = generateVersionInfoJson({
version: "v0.3.0",
existingVersionInfo: oldJson,
});
expect(generatedJson.latest).toEqual(oldJson.latest);
});
it("properly records patch releases", () => {
const generatedJson = generateVersionInfoJson({
version: "v0.45.1",
existingVersionInfo: oldJson,
});
expect(generatedJson.older[0].patch).toEqual(true);
});
it("properly recognizes major releases", () => {
const generatedJson = generateVersionInfoJson({
version: "v0.45.0",
existingVersionInfo: oldJson,
});
expect(generatedJson.older[0].patch).toEqual(false);
});
it("should always record releases in older array", () => {
const generatedJson = generateVersionInfoJson({
version: "v0.1.9",
existingVersionInfo: oldJson,
});
expect(generatedJson.older[0]).toEqual({
version: "v0.1.9",
released: expect.any(String),
patch: true,
highlights: ["see https://www.metabase.com/changelog/1#metabase-19"],
});
});
it("should ignore an already released version", () => {
const generatedJson = generateVersionInfoJson({
version: "v0.2.3",
existingVersionInfo: oldJson,
});
expect(generatedJson).toEqual(oldJson);
});
});
describe("updateVersionInfoLatestJson", () => {
const oldJson = {
latest: {
version: "v0.2.4",
released: "2022-01-01",
patch: true,
highlights: ["Old Issue 1", "Old Issue 2"],
},
older: [
{
version: "v0.2.5",
released: "2023-01-01",
patch: true,
highlights: ["New Issue 31", "New Issue 41"],
},
{
version: "v0.2.3",
released: "2021-01-01",
patch: true,
highlights: ["Old Issue 3", "Old Issue 4"],
},
{
version: "v0.2.2",
released: "2020-01-01",
patch: true,
highlights: ["Old Issue 5", "Old Issue 6"],
},
],
} as VersionInfoFile;
it("should update latest version", () => {
const updatedJson = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.5",
existingVersionInfo: oldJson,
});
expect(updatedJson.latest.version).toEqual("v0.2.5");
expect(updatedJson.beta).toEqual(oldJson.beta);
expect(updatedJson.nightly).toEqual(oldJson.nightly);
});
it("should ignore if version is already latest", () => {
const updatedJson = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.4",
existingVersionInfo: oldJson,
});
expect(updatedJson).toEqual(oldJson);
});
it("should throw if new version is not in older versions", () => {
expect(() =>
updateVersionInfoLatestJson({
newLatestVersion: "v0.2.1",
existingVersionInfo: oldJson,
}),
).toThrow();
});
it("should remove the new latest version from the older versions", () => {
const updatedJson = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.5",
existingVersionInfo: oldJson,
});
expect(updatedJson.older).not.toContainEqual({
version: "v0.2.5",
released: "2023-01-01",
patch: true,
highlights: ["New Issue 31", "New Issue 41"],
});
});
it("should keep the old latest version in the older versions", () => {
const updatedJson = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.5",
existingVersionInfo: oldJson,
});
expect(updatedJson.older).toContainEqual({
version: "v0.2.4",
released: "2022-01-01",
patch: true,
highlights: ["Old Issue 1", "Old Issue 2"],
});
});
it("should update rollout % on new latest version", () => {
const updatedJson = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.5",
existingVersionInfo: oldJson,
rollout: 51,
});
expect(updatedJson.latest.rollout).toEqual(51);
});
it("should update rollout % on old latest version", () => {
const updatedJson = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.4",
existingVersionInfo: oldJson,
rollout: 51,
});
expect(updatedJson.latest).toEqual({
version: "v0.2.4",
released: "2022-01-01",
patch: true,
highlights: ["Old Issue 1", "Old Issue 2"],
rollout: 51,
});
const updatedJson2 = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.4",
existingVersionInfo: updatedJson,
rollout: 59,
});
expect(updatedJson2.latest).toEqual({
version: "v0.2.4",
released: "2022-01-01",
patch: true,
highlights: ["Old Issue 1", "Old Issue 2"],
rollout: 59,
});
});
it("should remove rollout % on old latest version", () => {
const updatedJson = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.4",
existingVersionInfo: oldJson,
rollout: 51,
});
const updatedJson2 = updateVersionInfoLatestJson({
newLatestVersion: "v0.2.5",
existingVersionInfo: updatedJson,
rollout: 100,
});
expect(updatedJson2.latest).toEqual({
version: "v0.2.5",
released: "2023-01-01",
patch: true,
highlights: ["New Issue 31", "New Issue 41"],
rollout: 100,
});
expect(updatedJson2.older[0]).toEqual({
version: "v0.2.4",
released: "2022-01-01",
patch: true,
highlights: ["Old Issue 1", "Old Issue 2"],
// no rollout
});
});
});
describe("updateVersionInfoLatest", () => {
const existingFile = {
latest: {
version: "v0.2.4",
released: "2022-01-01",
patch: true,
highlights: ["Old Issue 1"],
},
older: [
{
version: "v0.2.5",
released: "2023-01-01",
patch: true,
highlights: ["New Issue"],
},
],
} as VersionInfoFile;
beforeEach(() => {
process.env.AWS_S3_STATIC_BUCKET = "my.metabase.com";
process.env.AWS_REGION = "us-north-9";
mockFetch.mockReset();
mockFetch.mockResolvedValue({
json: async () => existingFile,
} as Awaited<ReturnType<typeof fetch>>);
});
it("fetches the OSS version-info.json for a v0.* version", async () => {
await updateVersionInfoLatest({ newVersion: "v0.2.5" });
expect(mockFetch).toHaveBeenCalledTimes(1);
expect(mockFetch).toHaveBeenCalledWith(
"http://my.metabase.com.s3.us-north-9.amazonaws.com/version-info.json",
);
});
it("fetches the EE version-info-ee.json for a v1.* version", async () => {
const eeFile = {
latest: { ...existingFile.latest, version: "v1.2.4" },
older: [{ ...existingFile.older[0], version: "v1.2.5" }],
} as VersionInfoFile;
mockFetch.mockResolvedValue({
json: async () => eeFile,
} as Awaited<ReturnType<typeof fetch>>);
await updateVersionInfoLatest({ newVersion: "v1.2.5" });
expect(mockFetch).toHaveBeenCalledWith(
"http://my.metabase.com.s3.us-north-9.amazonaws.com/version-info-ee.json",
);
});
it("promotes the new version to latest via updateVersionInfoLatestJson", async () => {
const result = await updateVersionInfoLatest({
newVersion: "v0.2.5",
rollout: 42,
});
expect(result.latest).toEqual({
version: "v0.2.5",
released: "2023-01-01",
patch: true,
highlights: ["New Issue"],
rollout: 42,
});
expect(result.older).toContainEqual({
version: "v0.2.4",
released: "2022-01-01",
patch: true,
highlights: ["Old Issue 1"],
});
});
it("defaults rollout to 100 when omitted", async () => {
const result = await updateVersionInfoLatest({ newVersion: "v0.2.5" });
expect(result.latest.rollout).toEqual(100);
});
});
describe("getSupportedMajorVersions", () => {
const fileWith = (major_version_support: any) =>
({
latest: {},
older: [],
major_version_support,
}) as unknown as VersionInfoFile;
it("returns majors whose eol is today or later, newest first", () => {
const versionInfo = fileWith([
{ major: 54, released: "2025-04-15", lts: true, eol: "2025-06-01" },
{ major: 60, released: "2026-04-01", lts: true, eol: "2027-06-01" },
{ major: 61, released: "2026-05-01", lts: false, eol: "2026-07-01" },
]);
expect(getSupportedMajorVersions(versionInfo, "2026-06-04")).toEqual([
61, 60,
]);
});
it("treats eol === today as out of support", () => {
const versionInfo = fileWith([
{ major: 88, released: "2026-04-01", lts: true, eol: "2026-06-04" },
{ major: 89, released: "2026-04-01", lts: true, eol: "2026-06-05" },
]);
expect(getSupportedMajorVersions(versionInfo, "2026-06-04")).toEqual([
89,
]);
});
it("ignores the lts flag — support is computed from eol only", () => {
const versionInfo = fileWith([
{ major: 60, released: "2026-04-01", lts: false, eol: "2027-06-01" },
{ major: 54, released: "2025-04-15", lts: true, eol: "2025-06-01" },
]);
expect(getSupportedMajorVersions(versionInfo, "2026-06-04")).toEqual([
60,
]);
});
it("de-duplicates repeated majors", () => {
const versionInfo = fileWith([
{ major: 60, released: "2026-04-01", lts: true, eol: "2027-06-01" },
{ major: 60, released: "2026-04-01", lts: true, eol: "2027-12-01" },
]);
expect(getSupportedMajorVersions(versionInfo, "2026-06-04")).toEqual([
60,
]);
});
it("throws when major_version_support is missing or empty", () => {
expect(() => getSupportedMajorVersions(fileWith(undefined))).toThrow(
/no `major_version_support`/,
);
expect(() => getSupportedMajorVersions(fileWith([]))).toThrow(
/no `major_version_support`/,
);
});
it("throws when every line is past end-of-life", () => {
const versionInfo = fileWith([
{ major: 54, released: "2025-04-15", lts: true, eol: "2025-06-01" },
]);
expect(() =>
getSupportedMajorVersions(versionInfo, "2026-06-04"),
).toThrow(/No in-support major versions/);
});
});
describe("getSupportedMajors", () => {
beforeEach(() => {
process.env.AWS_S3_STATIC_BUCKET = "my.metabase.com";
process.env.AWS_REGION = "us-north-9";
mockFetch.mockReset();
});
it("fetches the OSS version-info.json and returns supported majors", async () => {
mockFetch.mockResolvedValue({
json: async () => ({
latest: {},
older: [],
major_version_support: [
{ major: 60, released: "2026-04-01", lts: true, eol: "2027-06-01" },
{ major: 54, released: "2025-04-15", lts: true, eol: "2025-06-01" },
],
}),
} as Awaited<ReturnType<typeof fetch>>);
const majors = await getSupportedMajors("2026-06-04");
expect(mockFetch).toHaveBeenCalledWith(
"http://my.metabase.com.s3.us-north-9.amazonaws.com/version-info.json",
);
expect(majors).toEqual([60]);
});
});
describe("hasRecentMinorReleaseIn", () => {
const release = (version: string, released: string) => ({
version,
released,
patch: true,
highlights: [],
});
const fileWith = (...releases: ReturnType<typeof release>[]) =>
({
latest: releases[0],
older: releases.slice(1),
}) as VersionInfoFile;
it("skips v0.66.2 on Tuesday when v0.66.1 shipped on Monday", () => {
const versionInfo = fileWith(
release("v0.66.1", "2026-11-02"),
release("v0.66.0", "2026-10-26"),
);
expect(hasRecentMinorReleaseIn(versionInfo, 66, 3, "2026-11-03")).toBe(
true,
);
});
it("includes the first and last day of the window", () => {
expect(
hasRecentMinorReleaseIn(
fileWith(release("v0.65.2", "2026-11-01")),
65,
3,
"2026-11-03",
),
).toBe(true);
expect(
hasRecentMinorReleaseIn(
fileWith(release("v0.65.2", "2026-11-03")),
65,
3,
"2026-11-03",
),
).toBe(true);
});
it("ignores releases before the window", () => {
const versionInfo = fileWith(release("v0.65.2", "2026-10-31"));
expect(hasRecentMinorReleaseIn(versionInfo, 65, 3, "2026-11-03")).toBe(
false,
);
});
it("uses the window size it is given", () => {
const versionInfo = fileWith(release("v0.65.2", "2026-10-28"));
expect(hasRecentMinorReleaseIn(versionInfo, 65, 3, "2026-11-03")).toBe(
false,
);
expect(hasRecentMinorReleaseIn(versionInfo, 65, 7, "2026-11-03")).toBe(
true,
);
});
it("finds releases in the older list", () => {
const versionInfo = fileWith(
release("v0.66.1", "2026-10-27"),
release("v0.58.38", "2026-10-26"),
);
expect(hasRecentMinorReleaseIn(versionInfo, 58, 3, "2026-10-27")).toBe(
true,
);
});
it("ignores other majors", () => {
const versionInfo = fileWith(release("v0.65.2", "2026-10-27"));
expect(hasRecentMinorReleaseIn(versionInfo, 64, 3, "2026-10-27")).toBe(
false,
);
});
it("counts a gold release", () => {
const versionInfo = fileWith(release("v0.66.0", "2026-10-26"));
expect(hasRecentMinorReleaseIn(versionInfo, 66, 3, "2026-10-27")).toBe(
true,
);
});
it("ignores patches and pre-releases", () => {
const versionInfo = fileWith(
release("v0.66.0-beta", "2026-10-26"),
release("v0.65.2.1", "2026-10-27"),
release("v0.65.3-rc1", "2026-10-27"),
);
expect(hasRecentMinorReleaseIn(versionInfo, 66, 3, "2026-10-27")).toBe(
false,
);
expect(hasRecentMinorReleaseIn(versionInfo, 65, 3, "2026-10-27")).toBe(
false,
);
});
it("throws on an invalid window", () => {
const versionInfo = fileWith(release("v0.65.2", "2026-10-27"));
expect(() =>
hasRecentMinorReleaseIn(versionInfo, 65, NaN, "2026-10-27"),
).toThrow(/Invalid window/);
expect(() =>
hasRecentMinorReleaseIn(versionInfo, 65, -1, "2026-10-27"),
).toThrow(/Invalid window/);
});
});
describe("getOssVersionInfo", () => {
beforeEach(() => {
process.env.AWS_S3_STATIC_BUCKET = "my.metabase.com";
process.env.AWS_REGION = "us-north-9";
mockFetch.mockReset();
});
it("fetches the OSS version-info.json", async () => {
const versionInfo = { latest: {}, older: [] };
mockFetch.mockResolvedValue({
ok: true,
json: async () => versionInfo,
} as Awaited<ReturnType<typeof fetch>>);
expect(await getOssVersionInfo()).toEqual(versionInfo);
expect(mockFetch).toHaveBeenCalledWith(
"http://my.metabase.com.s3.us-north-9.amazonaws.com/version-info.json",
);
});
it("throws a clear error when the fetch fails", async () => {
mockFetch.mockResolvedValue({
ok: false,
status: 403,
statusText: "Forbidden",
} as Awaited<ReturnType<typeof fetch>>);
await expect(getOssVersionInfo()).rejects.toThrow(
"Could not fetch http://my.metabase.com.s3.us-north-9.amazonaws.com/version-info.json: 403 Forbidden",
);
});
});
describe("isLtsVersion", () => {
const majorVersionSupport = [
{ major: 55, released: "2025-04-15", lts: true, eol: "2027-06-01" },
{ major: 56, released: "2025-08-01", lts: false, eol: "2026-08-01" },
];
const mockVersionInfo = (major_version_support: any) => {
mockFetch.mockResolvedValue({
json: async () => ({ latest: {}, older: [], major_version_support }),
} as Awaited<ReturnType<typeof fetch>>);
};
beforeEach(() => {
process.env.AWS_S3_STATIC_BUCKET = "my.metabase.com";
process.env.AWS_REGION = "us-north-9";
mockFetch.mockReset();
mockVersionInfo(majorVersionSupport);
});
it("returns true when the version's major is an lts release", async () => {
expect(await isLtsVersion({ version: "v0.55.2" })).toEqual(true);
});
it("returns false when the version's major is not an lts release", async () => {
expect(await isLtsVersion({ version: "v0.56.0" })).toEqual(false);
});
it("returns false when the version's major is absent from the support list", async () => {
expect(await isLtsVersion({ version: "v0.99.0" })).toEqual(false);
});
it("returns true for an EE (v1.*) version of an lts major", async () => {
expect(await isLtsVersion({ version: "v1.55.0" })).toEqual(true);
});
it("resolves the major from patch and pre-release version strings", async () => {
expect(await isLtsVersion({ version: "v0.55.1.2" })).toEqual(true);
expect(await isLtsVersion({ version: "v0.55.0-RC1" })).toEqual(true);
});
it("returns false when major_version_support is missing", async () => {
mockVersionInfo(undefined);
expect(await isLtsVersion({ version: "v0.55.0" })).toEqual(false);
});
it("returns false when major_version_support is empty", async () => {
mockVersionInfo([]);
expect(await isLtsVersion({ version: "v0.55.0" })).toEqual(false);
});
});
describe("getVersionInfoUrl", () => {
beforeEach(() => {
jest.resetModules();
process.env.AWS_S3_STATIC_BUCKET = "my.metabase.com";
process.env.AWS_REGION = "us-north-9";
});
it("should generate oss version info url", () => {
expect(getVersionInfoUrl("v0.99.3")).toEqual(
"http://my.metabase.com.s3.us-north-9.amazonaws.com/version-info.json",
);
});
it("should generate ee version info url", () => {
expect(getVersionInfoUrl("v1.99.3")).toEqual(
"http://my.metabase.com.s3.us-north-9.amazonaws.com/version-info-ee.json",
);
});
});
});