@intentius/chant-lexicon-grafana 0.97.0 → 0.99.0

package/src/export-resources.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Live export (#2946) against an in-memory Grafana: the IR goes through the
+ * importer's generator unchanged, and a dashboard exported from Grafana
+ * generates the same source as the same JSON given to `chant import`.
+ */
+
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { exportResources } from "./export-resources";
+import { fakeGrafana, liveDatasource, type FakeGrafanaState } from "./api/fake-grafana";
+import { GrafanaGenerator } from "./import/generator";
+import { parseGrafana } from "./import/parser";
+import { grafanaPlugin } from "./plugin";
+import { datasourceProps } from "./import/live-export";
+
+const CONFIG = { grafana: { profiles: { prod: { url: "http://grafana.test" } } } };
+
+const board = {
+  title: "Checkout",
+  tags: ["shop"],
+  graphTooltip: 1,
+  schemaVersion: 41,
+  panels: [
+    {
+      type: "timeseries",
+      id: 1,
+      title: "Requests",
+      gridPos: { h: 8, w: 12, x: 0, y: 0 },
+      datasource: { type: "prometheus", uid: "prom" },
+      targets: [{ refId: "A", expr: "sum(rate(http_requests_total[5m]))", datasource: { type: "prometheus", uid: "prom" } }],
+    },
+  ],
+};
+
+function state(overrides: Partial<FakeGrafanaState> = {}): FakeGrafanaState {
+  return {
+    api: "v1",
+    dashboards: {
+      checkout: { spec: board, annotations: { "grafana.app/managedBy": "classic-file-provisioning", "grafana.app/managerId": "chant" } },
+      "hand-made": { spec: { title: "Hand made", panels: [] } },
+    },
+    datasources: {
+      prom: liveDatasource({ name: "Prom", type: "prometheus", uid: "prom", url: "http://prometheus:9090", isDefault: true, secure: ["basicAuthPassword"] }),
+    },
+    ...overrides,
+  };
+}
+
+const exportFrom = (s: FakeGrafanaState, opts: Partial<Parameters<typeof exportResources>[0]> = {}) =>
+  exportResources({ environment: "prod", config: CONFIG, env: {}, http: fakeGrafana(s), ...opts });
+
+describe("exportResources", () => {
+  it("is wired on the plugin", () => {
+    expect(typeof grafanaPlugin.exportResources).toBe("function");
+  });
+
+  it("feeds the importer's generator unchanged, and generates what chant import writes for the same JSON", async () => {
+    const ir = await exportFrom(state(), { selector: { type: "Grafana::Dashboard", name: "checkout" } });
+    const exported = new GrafanaGenerator().generate(ir);
+    const imported = new GrafanaGenerator().generate(parseGrafana(JSON.stringify({ ...board, uid: "checkout" })));
+    expect(exported).toEqual(imported);
+    expect(exported.map((f) => f.path)).toEqual(expect.arrayContaining([expect.stringMatching(/^checkout\/dashboard\.ts$/)]));
+  });
+
+  it("exports every dashboard and datasource, secrets as key names only", async () => {
+    const ir = await exportFrom(state());
+    expect(ir.resources.map((r) => `${r.type}:${r.logicalId}`).sort()).toEqual(["Grafana::Dashboard:checkout", "Grafana::Dashboard:handMade", "Grafana::Provisioning:datasources"]);
+    const files = new GrafanaGenerator().generate(ir);
+    const ds = files.find((f) => f.path === "datasources.ts")!.content;
+    expect(ds).toContain('basicAuthPassword: "[REDACTED]"');
+    expect(ir.warnings?.join("\n")).toMatch(/\[REDACTED\]/);
+  });
+
+  it("a dashboard refers to a datasource exported beside it by uid, rather than declaring it again", async () => {
+    const files = new GrafanaGenerator().generate(await exportFrom(state()));
+    const dashboardDatasources = files.find((f) => f.path === "checkout/datasources.ts")!.content;
+    expect(dashboardDatasources).not.toContain("ExternalDatasource");
+    expect(dashboardDatasources).toMatch(/const prom: DatasourceRef<"prometheus"> = \{ type: "prometheus", uid: "prom" \}/);
+    expect(files.find((f) => f.path === "datasources.ts")!.content).toContain("new Datasource(");
+  });
+
+  it("owned keeps only chant's dashboards and no datasources", async () => {
+    const ir = await exportFrom(state(), { owned: true });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["checkout"]);
+    expect(ir.warnings?.join("\n")).toMatch(/datasources are not exported with --owned/);
+  });
+
+  it("reads the legacy API on a server without dashboard.grafana.app", async () => {
+    const ir = await exportFrom(state({ api: "legacy" }), { selector: { name: "checkout" } });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["checkout"]);
+  });
+
+  it("leaves out a v2-stored dashboard the server does not serve at v2, and says so", async () => {
+    const s = state();
+    s.dashboards.checkout.storedVersion = "v2beta1";
+    const ir = await exportFrom(s, { selector: { type: "Grafana::Dashboard" } });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["handMade"]);
+    expect(ir.warnings?.join("\n")).toMatch(/checkout is not exported: it is stored as a v2beta1 dashboard .* lossy down-conversion/);
+  });
+
+  it("exports a v2-stored dashboard through its v2 read, as chant import of the same v2 JSON does (#2947)", async () => {
+    const fixture = JSON.parse(readFileSync(join(import.meta.dirname, "..", "test", "fixtures", "exports", "grafana-13.2.2", "tabs.v2-resource.json"), "utf-8")) as { spec: Record<string, unknown> };
+    const s = state();
+    s.dashboards.checkout = { ...s.dashboards.checkout, storedVersion: "v2", v2: fixture.spec };
+    const ir = await exportFrom(s, { selector: { type: "Grafana::Dashboard", name: "checkout" } });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["checkoutTabs"]);
+    expect(ir.warnings).toContainEqual(expect.stringMatching(/^dashboard checkout is stored as v2 and exported in the classic model: layout: the dashboard's tabs "Overview" and "Details" become expanded rows/));
+    const exported = new GrafanaGenerator().generate(ir);
+    const imported = new GrafanaGenerator().generate(parseGrafana(JSON.stringify({ ...fixture, metadata: { name: "checkout" } })));
+    expect(exported).toEqual(imported);
+  });
+
+  it("fails loudly when there is no Grafana to read", async () => {
+    await expect(exportResources({ environment: "staging", config: CONFIG, env: {} })).rejects.toThrow(/GRAFANA_URL/);
+  });
+});
+
+describe("datasourceProps", () => {
+  const live = liveDatasource({ name: "Prom", type: "prometheus", uid: "prom", url: "http://p:9090", secure: ["password"] });
+
+  it("keeps what somebody set, and names secrets without their values", () => {
+    expect(datasourceProps(live)).toEqual({ name: "Prom", type: "prometheus", uid: "prom", url: "http://p:9090", secureJsonData: { password: "[REDACTED]" } });
+  });
+
+  it("keeps the API's defaults under verbatim, and editable from readOnly", () => {
+    expect(datasourceProps({ ...live, readOnly: false }, { keepDefaults: true })).toMatchObject({ access: "proxy", isDefault: false, editable: true });
+  });
+});

package/src/export-resources.ts

@@ -0,0 +1,84 @@
+/**
+ * Live export for grafana (#2946): `chant import --from <env>` writes the
+ * environment's dashboards and datasources as chant TypeScript.
+ *
+ * All I/O is here; the mapping is pure in ./import/live-export.ts, and the
+ * IR it builds is the importer's own (#2945), so a dashboard exported from
+ * Grafana and the same dashboard's JSON given to `chant import` generate the
+ * same source through the same `GrafanaGenerator`.
+ *
+ * - Every dashboard in the organisation is listed over the API the thin
+ *   read uses (`/apis/dashboard.grafana.app`, or `/api/search` plus
+ *   `/api/dashboards/uid` on Grafana 11). A dashboard stored as v2 is read at
+ *   v2 and exported through its classic form, with a warning for each thing
+ *   the classic form cannot hold (#2947).
+ * - Every datasource is read by uid, for `secureJsonFields`; secrets come
+ *   back as key names only (see `datasourceProps`).
+ * - `selector.type` is `Grafana::Dashboard` or `Grafana::Datasource`;
+ *   `selector.name` is a uid.
+ * - `owned` keeps only dashboards that are chant's (./ownership.ts), and
+ *   leaves datasources out, since their ownership cannot be read. There is no
+ *   project here to name its providers, so a file-provisioned dashboard is
+ *   chant's when its provider is the default one, `chant`.
+ * - `verbatim` keeps datasource keys at the API's "not set" values. A
+ *   dashboard is always planned by the importer, which leaves out keys at
+ *   Grafana's defaults either way.
+ */
+
+import type { ExportedTemplate, ResourceSelector } from "@intentius/chant/lexicon";
+import { bindGrafana, type BindOptions } from "./api/bind";
+import { classicDashboardOf, listDashboards } from "./api/dashboards";
+import { listDatasources, readDatasource } from "./api/datasources";
+import { DASHBOARD_TYPE } from "./dashboard";
+import { DATASOURCE_TYPE } from "./datasource";
+import { exportTemplate } from "./import/live-export";
+import { DEFAULT_PROVIDER_NAME, dashboardOwnership } from "./ownership";
+
+type Json = Record<string, unknown>;
+
+export interface GrafanaExportOptions extends Omit<BindOptions, "environment"> {
+  environment: string;
+  stack?: string;
+  region?: string;
+  selector?: ResourceSelector;
+  owned?: boolean;
+  verbatim?: boolean;
+}
+
+export async function exportResources(options: GrafanaExportOptions): Promise<ExportedTemplate> {
+  const client = await bindGrafana({ ...options });
+  const type = options.selector?.type;
+  const name = options.selector?.name;
+  const warnings: string[] = [];
+
+  const dashboards: Array<{ json: Json }> = [];
+  if (type === undefined || type === DASHBOARD_TYPE) {
+    const providers = new Set([DEFAULT_PROVIDER_NAME]);
+    for (const live of await listDashboards(client)) {
+      if (name !== undefined && live.uid !== name) continue;
+      if (options.owned && dashboardOwnership(live, providers).ownership !== "owned") continue;
+      const classic = classicDashboardOf(live);
+      if ("unsupported" in classic) {
+        warnings.push(`dashboard ${live.uid} is not exported: ${classic.unsupported}`);
+        continue;
+      }
+      for (const w of classic.warnings ?? []) warnings.push(`dashboard ${live.uid} is stored as v2 and exported in the classic model: ${w}`);
+      dashboards.push({ json: classic.json });
+    }
+  }
+
+  const datasources: Json[] = [];
+  if ((type === undefined || type === DATASOURCE_TYPE) && !options.owned) {
+    for (const summary of await listDatasources(client)) {
+      const uid = typeof summary.uid === "string" ? summary.uid : undefined;
+      if (!uid || (name !== undefined && uid !== name)) continue;
+      const read = await readDatasource(client, uid);
+      if ("present" in read) datasources.push(read.present);
+    }
+  } else if (options.owned && (type === undefined || type === DATASOURCE_TYPE)) {
+    warnings.push("datasources are not exported with --owned: Grafana's datasource API carries no ownership marker");
+  }
+
+  const ir = exportTemplate({ dashboards, datasources, keepDefaults: options.verbatim });
+  return { ...ir, warnings: [...warnings, ...(ir.warnings ?? [])] };
+}

package/src/generated/lexicon-grafana.json

@@ -1,9 +1,54 @@
 {
+  "AlertListPanel": {
+    "resourceType": "Grafana::Panel::alertlist",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AlertQuery": {
+    "resourceType": "Grafana::AlertQuery",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AlertRule": {
+    "resourceType": "Grafana::AlertRule",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AlertRuleGroup": {
+    "resourceType": "Grafana::AlertRuleGroup",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "BarChartPanel": {
+    "resourceType": "Grafana::Panel::barchart",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "BarGaugePanel": {
+    "resourceType": "Grafana::Panel::bargauge",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "CanvasPanel": {
+    "resourceType": "Grafana::Panel::canvas",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "ClassicConditionsExpression": {
+    "resourceType": "Grafana::Expression::classic_conditions",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "ConstantVariable": {
     "resourceType": "Grafana::Variable::constant",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ContactPoint": {
+    "resourceType": "Grafana::ContactPoint",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "CustomVariable": {
     "resourceType": "Grafana::Variable::custom",
     "kind": "resource",
@@ -29,16 +74,36 @@
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ExternalDatasource": {
+    "resourceType": "Grafana::ExternalDatasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "FlameGraphPanel": {
+    "resourceType": "Grafana::Panel::flamegraph",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "GaugePanel": {
     "resourceType": "Grafana::Panel::gauge",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "GeomapPanel": {
+    "resourceType": "Grafana::Panel::geomap",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "HeatmapPanel": {
     "resourceType": "Grafana::Panel::heatmap",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "HistogramPanel": {
+    "resourceType": "Grafana::Panel::histogram",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "IntervalVariable": {
     "resourceType": "Grafana::Variable::interval",
     "kind": "resource",
@@ -54,6 +119,36 @@
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "MathExpression": {
+    "resourceType": "Grafana::Expression::math",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "MuteTiming": {
+    "resourceType": "Grafana::MuteTiming",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "NodeGraphPanel": {
+    "resourceType": "Grafana::Panel::nodeGraph",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "NotificationPolicy": {
+    "resourceType": "Grafana::NotificationPolicy",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "NotificationTemplate": {
+    "resourceType": "Grafana::NotificationTemplate",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "PieChartPanel": {
+    "resourceType": "Grafana::Panel::piechart",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "PromQuery": {
     "resourceType": "Grafana::Query::prometheus",
     "kind": "resource",
@@ -64,16 +159,41 @@
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ReduceExpression": {
+    "resourceType": "Grafana::Expression::reduce",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "ResampleExpression": {
+    "resourceType": "Grafana::Expression::resample",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "Row": {
     "resourceType": "Grafana::Row",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "SqlExpression": {
+    "resourceType": "Grafana::Expression::sql",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "StateTimelinePanel": {
+    "resourceType": "Grafana::Panel::state-timeline",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "StatPanel": {
     "resourceType": "Grafana::Panel::stat",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "StatusHistoryPanel": {
+    "resourceType": "Grafana::Panel::status-history",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "TablePanel": {
     "resourceType": "Grafana::Panel::table",
     "kind": "resource",
@@ -94,6 +214,11 @@
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ThresholdExpression": {
+    "resourceType": "Grafana::Expression::threshold",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "TimeSeriesPanel": {
     "resourceType": "Grafana::Panel::timeseries",
     "kind": "resource",
@@ -103,5 +228,15 @@
     "resourceType": "Grafana::Panel::traces",
     "kind": "resource",
     "lexicon": "grafana"
+  },
+  "TrendPanel": {
+    "resourceType": "Grafana::Panel::trend",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "XYChartPanel": {
+    "resourceType": "Grafana::Panel::xychart",
+    "kind": "resource",
+    "lexicon": "grafana"
   }
 }

package/src/import/alerting-roundtrip.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Round trips of alerting provisioning files through `chant import`.
+ *
+ * Provisioning YAML -> TypeScript -> `chant build` -> provisioning YAML must
+ * give back the same file for every fixture: Grafana 12.4.11 and 13.2.2
+ * exports, and files other projects provision Grafana from (provenance in
+ * test/fixtures/alerting/README.md), and what the alerting example builds.
+ * "The same" means equal after `normalizeAlerting` once the importer's
+ * edits are applied to the source. The generated source must lint clean,
+ * and the rebuilt file must pass GRAF108 and GRAF111-GRAF114 without
+ * errors. generated-types.e2e.test.ts type-checks the generated source;
+ * alerting.e2e.test.ts provisions the rebuilt exports into Grafana.
+ */
+
+import { describe, expect, test } from "vitest";
+import { join } from "path";
+import { load } from "js-yaml";
+import { build } from "@intentius/chant/build";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { lintCommand } from "@intentius/chant/cli/commands/lint";
+import { importCommand } from "@intentius/chant/cli/commands/import";
+import { grafanaSerializer } from "../serializer";
+import { ALERTING_FILE } from "../alerting-build";
+import { buildGrafana } from "../build";
+import { validateGrafanaOutput, type GrafanaIssue } from "../validate-output";
+import { GrafanaParser, type AlertingResourceMetadata } from "./parser";
+import { GrafanaGenerator } from "./generator";
+import { applyEdits } from "./edits";
+import { normalizeAlerting } from "./normalize-alerting";
+import { ALERTING, exampleOutputs, fixturesDir, projectDir, read, removeDir, repoRoot, writeFiles } from "./testdata/fixtures";
+
+type Json = Record<string, unknown>;
+
+interface Imported {
+  source: string;
+  warnings: string[];
+  expected: Json;
+  rebuilt: Json;
+  issues: GrafanaIssue[];
+  lint: { errorCount: number; warningCount: number; output: string };
+}
+
+/** Several files -> IR -> TypeScript in one project -> `chant build`, `chant lint`, and the checks. */
+async function importAndBuild(contents: string[]): Promise<Imported> {
+  const dir = projectDir();
+  try {
+    const srcDir = join(dir, "src");
+    const warnings: string[] = [];
+    const sources: string[] = [];
+    const expected: Json = { apiVersion: 1 };
+    contents.forEach((content, i) => {
+      const ir = new GrafanaParser().parse(content);
+      warnings.push(...(ir.warnings ?? []));
+      const generated = new GrafanaGenerator().generate(ir).map((f) => ({ ...f, path: contents.length > 1 ? `f${i}/${f.path}` : f.path }));
+      writeFiles(srcDir, generated);
+      sources.push(...generated.map((f) => `// ${f.path}\n${f.content}`));
+      const meta = ir.resources[0]!.metadata as unknown as AlertingResourceMetadata;
+      for (const [k, v] of Object.entries(applyEdits(meta.source, meta.edits))) {
+        if (Array.isArray(v)) expected[k] = [...((expected[k] as unknown[]) ?? []), ...v];
+      }
+    });
+    const result = await build(srcDir, [grafanaSerializer]);
+    expect(result.errors).toEqual([]);
+    const text = (result.outputs.get("grafana") as SerializerResult | undefined)?.files?.[ALERTING_FILE];
+    const built = buildGrafana(new Map([...result.entities].filter(([, e]) => e.lexicon === "grafana")));
+    const issues = validateGrafanaOutput({
+      dashboards: [],
+      datasources: built.datasources,
+      externalDatasources: built.externalDatasources,
+      alerting: built.alerting ? [{ json: built.alerting as unknown as Json }] : [],
+    });
+    const lint = await lintCommand({ path: srcDir, format: "stylish" });
+    return {
+      source: sources.join("\n"),
+      warnings,
+      expected,
+      rebuilt: text === undefined ? { apiVersion: 1 } : (load(text) as Json),
+      issues,
+      lint: { errorCount: lint.errorCount, warningCount: lint.warningCount, output: lint.output },
+    };
+  } finally {
+    removeDir(dir);
+  }
+}
+
+async function expectRoundTrip(...contents: string[]): Promise<Imported> {
+  const out = await importAndBuild(contents);
+  expect(normalizeAlerting(out.rebuilt)).toEqual(normalizeAlerting(out.expected));
+  expect(out.lint.errorCount + out.lint.warningCount, out.lint.output).toBe(0);
+  expect(out.issues.filter((i) => i.severity === "error")).toEqual([]);
+  return out;
+}
+
+describe("alerting provisioning YAML -> TypeScript -> alerting provisioning YAML", () => {
+  for (const file of ALERTING) {
+    test(file, async () => {
+      await expectRoundTrip(read(file));
+    });
+  }
+
+  test("each Grafana version's exports, imported into one project, reference each other and pass every check", async () => {
+    for (const v of ["grafana-12.4.11", "grafana-13.2.2"]) {
+      const files = ALERTING.filter((f) => f.startsWith(`alerting/${v}/`)).map((f) => read(f));
+      const out = await expectRoundTrip(...files);
+      // With the contact points and mute timings declared, GRAF113 checks every reference and finds them all.
+      expect(out.issues.filter((i) => i.code === "GRAF113")).toEqual([]);
+      expect(out.issues.filter((i) => i.code === "GRAF112")).toEqual([]);
+    }
+  });
+
+  test("a project's files, imported together, pass every check", async () => {
+    const marin = ALERTING.filter((f) => f.includes("/marin.")).map((f) => read(f));
+    const out = await expectRoundTrip(...marin);
+    expect(out.issues.filter((i) => i.code === "GRAF113")).toEqual([]);
+  });
+
+  test("the typed classes carry each server-side expression, and a datasource query keeps its model", async () => {
+    const out = await importAndBuild([read("alerting/grafana-13.2.2/alert-rules.yaml")]);
+    for (const cls of ["ReduceExpression", "ThresholdExpression", "ResampleExpression", "MathExpression", "ClassicConditionsExpression"]) {
+      expect(out.source).toContain(`new ${cls}(`);
+    }
+    expect(out.source).toContain('const prom = new ExternalDatasource({ type: "prometheus", uid: "prom" });');
+    expect(out.source).toContain("new AlertQuery({ datasource: prom, model:");
+    // The recovery threshold is carried; the editor's operator/query/reducer on a threshold are not needed.
+    expect(out.source).toContain('unloadEvaluator: { params: [0.03], type: "lt" }');
+    expect(out.warnings).toEqual([]);
+  });
+
+  test("what cannot be carried, or had to be guessed, is a warning", async () => {
+    const proto = await importAndBuild([read("alerting/community/proto-fleet.proto-fleet-rules.yaml")]);
+    expect(proto.warnings).toContainEqual(expect.stringContaining('the plugin type of "protofleet-timescaledb"'));
+    expect(proto.warnings).toContainEqual(expect.stringContaining("2 rule deletions (deleteRules)"));
+    expect(proto.source).toContain('datasource: "protofleet-timescaledb"');
+
+    const eth = await importAndBuild([read("alerting/community/eth-docker.disk_space.yml")]);
+    expect(eth.warnings).toContainEqual(expect.stringContaining('"PBFA97CFB590B2093"; the queries look like PromQL'));
+
+    const cps = await importAndBuild([read("alerting/grafana-13.2.2/contact-points.yaml")]);
+    expect(cps.warnings).toEqual([expect.stringContaining("url as $__env{ONCALL_SLACK_URL} is read from the environment")]);
+    expect(cps.rebuilt).toMatchObject({ contactPoints: expect.arrayContaining([expect.objectContaining({ name: "oncall" })]) });
+    expect(JSON.stringify(cps.rebuilt)).not.toContain("[REDACTED]");
+  });
+
+  test("the alerting example's file round-trips", async () => {
+    const [, text] = (await exampleOutputs()).find(([f]) => f === `alerting/${ALERTING_FILE}`)!;
+    await expectRoundTrip(text);
+  });
+
+  test("chant import detects the file as grafana's, and a Prometheus rule file as prometheus's", async () => {
+    const dir = projectDir();
+    try {
+      const alerting = await importCommand({ templatePath: join(fixturesDir, "alerting", "grafana-13.2.2", "policies.yaml"), output: join(dir, "src"), force: true });
+      expect(alerting.lexicon).toBe("grafana");
+      expect(alerting.generatedFiles).toEqual(["notifications.ts"]);
+      const rules = await importCommand({ templatePath: join(repoRoot, "lexicons/prometheus/src/import/testdata/rules-full.yml"), output: join(dir, "rules"), force: true });
+      expect(rules.lexicon).toBe("prometheus");
+    } finally {
+      removeDir(dir);
+    }
+  });
+});