test(sourcemap): consolidate indexed section admission checks (#13066)

This commit is contained in:
morluto authored and GitHub committed 2026-11-21 10:20:13 +00:00
1 parent 5bbd238f2f
commit 47d86582c8
4 files changed
+153 -271

No files matched your search

+33 -180
View File
@@ -1,4 +1,4 @@
import { describe, expect, it } from "vitest";
import { expect, it } from "vitest";
import {
inspectLocalSourceMapDeclarations,
@@ -45,191 +45,44 @@ it("applies observed-content policy to complete and partially invalid maps", ()
).toMatchObject({ embedded: true, complete: false });
});
describe("source-map envelope walk", () => {
it("retains ordered declarations under nested section offsets", () => {
const root = {
it("rejects non-version-3 roots and nested maps", () => {
expect(inspect({ version: 3 })).toMatchObject({
declarations: [],
limitations: ["Source map has no sources array."],
});
expect(inspect(null)).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(inspect([{ version: 3 }])).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(inspect({ version: 2, mappings: "AAAA" })).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(inspect({ mappings: "AAAA" })).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(
inspect({
version: 3,
sections: [
{
offset: { line: 0, column: 0 },
map: {
version: 3,
sections: [
{
offset: { line: 0, column: 0 },
map: { ...leaf, sources: ["b.ts"] },
},
{
offset: { line: 1, column: 0 },
map: { ...leaf, sources: ["c.ts"] },
},
],
},
},
{
offset: { line: 10, column: 0 },
map: { ...leaf, sources: ["d.ts"] },
map: { version: "3", sections: [] },
},
],
};
const result = inspect(root);
expect(result.limitations).toEqual([]);
expect(result.invalid_sections).toEqual([]);
expect(result.declarations.map(({ source }) => source)).toEqual([
"b.ts",
"c.ts",
"d.ts",
]);
});
it("retains external sections in canonical path order and embedded leaves", () => {
const url = "https://app.test/maps/part.map";
const result = inspect({
version: 3,
sections: [
{
offset: { line: 0, column: 0 },
map: {
version: 3,
sections: [
{ offset: { line: 0, column: 0 }, url: `${url}/nested` },
{ offset: { line: 1, column: 0 }, map: leaf },
],
},
},
{ offset: { line: 1, column: 0 }, url },
{
offset: { line: 2, column: 0 },
map: { ...leaf, sources: ["after.ts"] },
},
],
});
expect(result).toMatchObject({
limitations: [],
declarations: [
{ sectionPath: [0, 1], source: "app.ts" },
{ sectionPath: [2], source: "after.ts" },
],
external_sections: [
{ section_path: [0, 0], url: `${url}/nested` },
{ section_path: [1], url },
],
invalid_sections: [],
});
});
it("retains valid leaves and URLs when a sibling section is malformed", () => {
const url = "https://app.test/maps/part.map";
const result = inspect({
version: 3,
sections: [
{
offset: { line: 0, column: 0 },
map: { ...leaf, sources: ["before.ts"] },
},
{ offset: { line: 1, column: 0 }, url },
{ offset: { line: 2, column: 0 }, url: 12, map: leaf },
{
offset: { line: 3, column: 0 },
map: { ...leaf, sources: ["after.ts"] },
},
],
});
expect(result).toMatchObject({
limitations: [],
declarations: [
{ sectionPath: [0], source: "before.ts" },
{ sectionPath: [3], source: "after.ts" },
],
external_sections: [{ section_path: [1], url }],
invalid_sections: [
{
section_path: [2],
reason: expect.stringMatching(/section URL.*must be a string/iu),
},
],
});
});
it("rejects sections without embedded maps or an external URL", () => {
const missing = {
version: 3,
sections: [{ offset: { line: 0, column: 0 } }],
};
expect(inspect(missing)).toMatchObject({
invalid_sections: [
{
section_path: [0],
reason: expect.stringMatching(
/source-map section requires.*embedded map or external URL/i,
),
},
],
});
});
});
describe("malformed source-map envelope facts", () => {
it("marks a present non-array sections member malformed at the map path", () => {
expect(
inspect({
version: 3,
sections: null,
sources: ["must-not-be-read.ts"],
mappings: "AAAA",
}),
).toEqual({
declarations: [],
limitations: [],
external_sections: [],
invalid_sections: [
{
section_path: [],
reason: expect.stringMatching(/sections.*must be an array/iu),
},
],
});
});
it("rejects non-version-3 roots and nested maps", () => {
expect(inspect({ version: 3 })).toMatchObject({
declarations: [],
limitations: ["Source map has no sources array."],
});
expect(inspect(null)).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(inspect([{ version: 3 }])).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(inspect({ version: 2, mappings: "AAAA" })).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(inspect({ mappings: "AAAA" })).toMatchObject({
declarations: [],
limitations: ["Source map is not a version 3 map."],
});
expect(
inspect({
version: 3,
sections: [
{
offset: { line: 0, column: 0 },
map: { version: "3", sections: [] },
},
],
}),
).toMatchObject({
invalid_sections: [
{
section_path: [0],
reason: "Indexed source-map section map is not a version 3 map.",
},
],
});
}),
).toMatchObject({
invalid_sections: [
{
section_path: [0],
reason: "Indexed source-map section map is not a version 3 map.",
},
],
});
});
@@ -1,6 +1,5 @@
import { describe, expect, it } from "vitest";
import { traceSourceMap } from "./TraceSourceMap.js";
import { inspectSourceMap } from "../../domain/sourceMapFormat.js";
const url = "https://app.test/maps/app.js.map?v=2#map";
const point = { line: 1, column: 0 };
@@ -14,39 +13,6 @@ const leaf = {
const trace = (map: unknown, position = point) =>
traceSourceMap(JSON.stringify(map), url, position);
it("uses the same conservative section classification for URL-plus-map and malformed URLs", () => {
const externalUrl = "https://app.test/maps/part.map";
const external = () =>
inspectSourceMap(
JSON.stringify({
version: 3,
sections: [
{ offset: { line: 0, column: 0 }, url: externalUrl, map: leaf },
],
}),
);
expect(external).toThrow(
expect.objectContaining({
failure: expect.objectContaining({ kind: "unsupported" }),
message: `External source-map section URL is not fetched: ${externalUrl}`,
}),
);
const malformed = () =>
inspectSourceMap(
JSON.stringify({
version: 3,
sections: [{ offset: { line: 0, column: 0 }, url: 12, map: leaf }],
}),
);
expect(malformed).toThrow(
expect.objectContaining({
failure: expect.objectContaining({ kind: "malformed" }),
message: expect.stringMatching(/section URL.*must be a string.*\[0\]/iu),
}),
);
});
it("keeps ignore-list precedence and section-local indexes for duplicate sources", () => {
const map = {
version: 3,