@intentius/chant-lexicon-grafana 0.98.0 → 0.100.0

package/src/init-templates.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { build } from "@intentius/chant/build";
+import type { Serializer } from "@intentius/chant/serializer";
+import { lintCommand } from "@intentius/chant/cli/commands/lint";
+import { runPostSynthChecks } from "@intentius/chant/lint/post-synth";
+import { k8sPlugin } from "@intentius/chant-lexicon-k8s";
+import { prometheusPlugin } from "@intentius/chant-lexicon-prometheus";
+import { grafanaPlugin } from "./plugin";
+import { postSynthChecks } from "./lint/post-synth";
+
+// Every template builds with the lexicons its chant.config.ts names, and its
+// output passes every GRAF check, and the other lexicon's checks, with
+// nothing to report.
+const cases: Array<[string | undefined, Serializer[], string[]]> = [
+  [undefined, [grafanaPlugin.serializer], ["grafana"]],
+  ["red", [grafanaPlugin.serializer], ["grafana"]],
+  ["k8s-pods", [k8sPlugin.serializer, grafanaPlugin.serializer], ["k8s", "grafana"]],
+  ["slo", [prometheusPlugin.serializer, grafanaPlugin.serializer], ["prometheus", "grafana"]],
+];
+
+describe("init templates", () => {
+  test.each(cases)("%s builds, lints clean and passes every check", async (name, serializers, outputs) => {
+    const set = grafanaPlugin.initTemplates!(name);
+    const dir = mkdtempSync(join(import.meta.dirname, "..", ".init-template-"));
+    try {
+      mkdirSync(join(dir, "src"));
+      for (const [file, text] of Object.entries(set.src)) writeFileSync(join(dir, "src", file), text);
+      for (const [file, text] of Object.entries(set.root ?? {})) writeFileSync(join(dir, file), text);
+      const result = await build(join(dir, "src"), serializers);
+      expect(result.errors).toEqual([]);
+      for (const lexicon of outputs) expect(result.outputs.get(lexicon), lexicon).toBeTruthy();
+
+      expect(runPostSynthChecks(postSynthChecks, result)).toEqual([]);
+      const other = name === "k8s-pods" ? k8sPlugin : name === "slo" ? prometheusPlugin : undefined;
+      if (other) {
+        expect(runPostSynthChecks(other.postSynthChecks!(), result)).toEqual([]);
+      }
+
+      const lint = await lintCommand({ path: join(dir, "src"), format: "stylish", fix: false });
+      expect(lint.errorCount + lint.warningCount, lint.output).toBe(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("the RED template puts its dashboard in the pinned folder and counts served spans only", async () => {
+    const dir = mkdtempSync(join(import.meta.dirname, "..", ".init-template-"));
+    try {
+      mkdirSync(join(dir, "src"));
+      for (const [file, text] of Object.entries(grafanaPlugin.initTemplates!("red").src)) writeFileSync(join(dir, "src", file), text);
+      const result = await build(join(dir, "src"), [grafanaPlugin.serializer]);
+      const out = result.outputs.get("grafana") as { primary: string; files: Record<string, string> };
+      const index = JSON.parse(out.primary) as { dashboards: Array<{ uid: string; folderUid?: string }>; datasources: unknown[] };
+      expect(index.dashboards).toEqual([expect.objectContaining({ uid: "services-red", folderUid: "observability" })]);
+      // An ExternalDatasource is checked against, never provisioned.
+      expect(index.datasources).toEqual([]);
+      const dashboard = Object.entries(out.files).find(([path]) => path.endsWith("services-red.json"))![1];
+      expect(dashboard).toContain("SPAN_KIND_SERVER|SPAN_KIND_CONSUMER");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("the k8s-pods and slo templates build every lexicon their config names", () => {
+    for (const name of ["k8s-pods", "slo"]) {
+      const set = grafanaPlugin.initTemplates!(name);
+      expect(set.root?.["chant.config.ts"]).toContain('"grafana"');
+      expect(set.scripts?.build).toBe("chant build src");
+    }
+    expect(grafanaPlugin.initTemplates!("no-such-template")).toBe(grafanaPlugin.initTemplates!());
+  });
+});

package/src/init-templates.ts

@@ -0,0 +1,349 @@
+/**
+ * `chant init --lexicon grafana` scaffolds.
+ *
+ * - default: a Prometheus datasource and a job overview dashboard with a
+ *   typed variable, in a folder.
+ * - `red`: rate, errors and duration per service from the OpenTelemetry
+ *   collector's span metrics, over a Prometheus Grafana already has
+ *   (`ExternalDatasource`), in a pinned `Folder`.
+ * - `k8s-pods`: CPU, memory, restarts and pod phase per namespace, delivered
+ *   as ConfigMaps the Grafana Helm chart's sidecar loads, from the `/k8s`
+ *   subpath. Builds with the k8s lexicon.
+ * - `slo`: an SLO's recording rules, its dashboard and its burn-rate alerts
+ *   as Grafana-managed rules. Builds with the prometheus lexicon.
+ *
+ * The otel, prometheus and k8s lexicons these import are dependencies of
+ * the grafana lexicon, so they are installed with it. The templates that
+ * build with a second lexicon ship their own `chant.config.ts` and a build
+ * script without `--lexicon`, so every lexicon's output and checks run.
+ */
+import type { InitTemplateSet } from "@intentius/chant/lexicon";
+
+// ── default ────────────────────────────────────────────────────────────
+
+const DEFAULT_DATASOURCES = `/**
+ * The datasource the dashboards query, declared in the same build root so
+ * GRAF101 and GRAF102 check every panel's reference against it.
+ */
+import { Datasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new Datasource({ name: "Prometheus", type: "prometheus", url: "http://prometheus:9090", isDefault: true });
+
+export { prometheus };
+`;
+
+const DEFAULT_DASHBOARD = `/**
+ * One dashboard: which of a job's targets are up, and how long their
+ * scrapes take. Panels without a gridPos are laid out left to right.
+ */
+import { Dashboard, PromQuery, QueryVariable, StatPanel, TimeSeriesPanel } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+
+const jobQuery = { query: "label_values(up, job)", qryType: 1 as const, label: "job", metric: "up" };
+const job = new QueryVariable({ name: "job", label: "Job", datasource: prometheus, query: jobQuery, refresh: "onTimeRangeChange", sort: 1 });
+
+const up = new PromQuery({ expr: 'sum(up{job="$job"})', instant: true });
+const targetsUp = new StatPanel({ title: "Targets up", datasource: prometheus, targets: [up] });
+
+const scrape = new PromQuery({ expr: 'avg by (instance) (scrape_duration_seconds{job="$job"})', legendFormat: "{{instance}}" });
+const seconds = { defaults: { unit: "s" } };
+const scrapeDuration = new TimeSeriesPanel({ title: "Scrape duration", datasource: prometheus, targets: [scrape], fieldConfig: seconds });
+
+const lastHour = { from: "now-1h", to: "now" };
+
+const overview = new Dashboard({
+  title: "Overview",
+  uid: "overview",
+  tags: ["chant"],
+  time: lastHour,
+  refresh: "30s",
+  variables: [job],
+  panels: [targetsUp, scrapeDuration],
+  folder: "Services",
+});
+
+export { overview };
+`;
+
+// ── red ────────────────────────────────────────────────────────────────
+
+const RED_DATASOURCES = `/**
+ * The Prometheus the dashboard reads, one Grafana already has. It is checked
+ * against (GRAF101, GRAF102) and never provisioned: set \`uid\` to its uid,
+ * from Connections > Data sources in Grafana.
+ */
+import { ExternalDatasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new ExternalDatasource({ type: "prometheus", uid: "prometheus", name: "Prometheus" });
+
+export { prometheus };
+`;
+
+const RED_DASHBOARD = `/**
+ * Rate, errors and duration per service, from the span metrics the
+ * OpenTelemetry collector's \`spanmetrics\` connector writes. The metric and
+ * label names come from the connector's settings, so change them here to
+ * match your collector (or pass the connector itself, if the collector is
+ * declared with the otel lexicon) and every query follows.
+ */
+import { Folder, RedDashboard, type SpanKind } from "@intentius/chant-lexicon-grafana";
+import { spanMetricsNames } from "@intentius/chant-lexicon-otel";
+import { prometheus } from "./datasources";
+
+const milliseconds = { unit: "ms" };
+const connector = { namespace: "traces.span.metrics", histogram: milliseconds };
+const names = spanMetricsNames(connector);
+
+// The spans that serve a request or consume a message, so a service's own
+// outgoing calls don't count toward its rate. [] counts every kind.
+const served: SpanKind[] = ["SPAN_KIND_SERVER", "SPAN_KIND_CONSUMER"];
+
+// A Folder pins the uid, for links and alert rules that name it.
+const observability = new Folder({ title: "Observability", uid: "observability" });
+
+const services = RedDashboard({ spanMetrics: names, datasource: prometheus, spanKinds: served, folder: observability, uid: "services-red" });
+
+export { observability, services };
+`;
+
+// ── k8s-pods ───────────────────────────────────────────────────────────
+
+const K8S_CONFIG = `import type { ChantConfig } from "@intentius/chant";
+
+// The dashboard and the ConfigMaps that deliver it share one build root: the
+// grafana output is checked by the GRAF checks, the ConfigMaps are applied
+// with kubectl.
+export default { lexicons: ["k8s", "grafana"] } satisfies ChantConfig;
+`;
+
+const K8S_DATASOURCES = `/**
+ * The Prometheus that scrapes cAdvisor and kube-state-metrics, as Grafana
+ * reaches it inside the cluster.
+ */
+import { Datasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new Datasource({
+  name: "Prometheus",
+  type: "prometheus",
+  uid: "prometheus",
+  url: "http://prometheus-server.monitoring.svc:80",
+  isDefault: true,
+});
+
+export { prometheus };
+`;
+
+const K8S_VARIABLES = `/**
+ * Which namespace, and which of its pods. Queries use them as $namespace
+ * and $pod; \`pod\` takes several values, or all of them.
+ */
+import { QueryVariable } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+
+const namespace = new QueryVariable({
+  name: "namespace",
+  label: "Namespace",
+  datasource: prometheus,
+  query: "label_values(kube_pod_info, namespace)",
+  refresh: "onTimeRangeChange",
+  sort: 1,
+});
+
+const pod = new QueryVariable({
+  name: "pod",
+  label: "Pod",
+  datasource: prometheus,
+  query: 'label_values(kube_pod_info{namespace="$namespace"}, pod)',
+  refresh: "onTimeRangeChange",
+  sort: 1,
+  multi: true,
+  includeAll: true,
+});
+
+export { namespace, pod };
+`;
+
+const K8S_QUERIES = `/**
+ * PromQL over cAdvisor (container_*) and kube-state-metrics (kube_*).
+ */
+import { PromQuery } from "@intentius/chant-lexicon-grafana";
+
+const scope = 'namespace="$namespace", pod=~"$pod"';
+
+const cpu = new PromQuery({
+  expr: \`sum by (pod) (rate(container_cpu_usage_seconds_total{\${scope}, container!=""}[$__rate_interval]))\`,
+  legendFormat: "{{pod}}",
+});
+
+const memory = new PromQuery({
+  expr: \`sum by (pod) (container_memory_working_set_bytes{\${scope}, container!=""})\`,
+  legendFormat: "{{pod}}",
+});
+
+const restarts = new PromQuery({
+  expr: \`sum by (pod) (increase(kube_pod_container_status_restarts_total{\${scope}}[1h]))\`,
+  legendFormat: "{{pod}}",
+});
+
+const phase = new PromQuery({
+  expr: \`sum by (pod, phase) (kube_pod_status_phase{\${scope}}) > 0\`,
+  instant: true,
+  format: "table",
+});
+
+export { cpu, memory, restarts, phase };
+`;
+
+const K8S_DASHBOARD = `/**
+ * Pods in a namespace: what they use, how often they restart, and which
+ * phase each is in.
+ */
+import { Dashboard, TablePanel, TimeSeriesPanel, transformation } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+import { namespace, pod } from "./variables";
+import { cpu, memory, restarts, phase } from "./queries";
+
+const cores = { defaults: { unit: "suffix: cores" } };
+const cpuPanel = new TimeSeriesPanel({ title: "CPU", datasource: prometheus, targets: [cpu], fieldConfig: cores });
+
+const bytes = { defaults: { unit: "bytes" } };
+const memoryPanel = new TimeSeriesPanel({ title: "Memory working set", datasource: prometheus, targets: [memory], fieldConfig: bytes });
+
+const count = { defaults: { unit: "short", decimals: 0 } };
+const restartPanel = new TimeSeriesPanel({ title: "Restarts in the last hour", datasource: prometheus, targets: [restarts], fieldConfig: count });
+
+// The query returns one row per pod with its phase; drop the time and value columns.
+const hidden = { Time: true, Value: true };
+const renamed = { pod: "Pod", phase: "Phase" };
+const phaseColumns = [transformation("organize", { excludeByName: hidden, renameByName: renamed })];
+const phasePanel = new TablePanel({ title: "Pod phase", datasource: prometheus, targets: [phase], transformations: phaseColumns });
+
+const pods = new Dashboard({
+  title: "Kubernetes pods",
+  uid: "k8s-pods",
+  tags: ["chant", "kubernetes"],
+  refresh: "30s",
+  variables: [namespace, pod],
+  panels: [cpuPanel, memoryPanel, restartPanel, phasePanel],
+  folder: "Kubernetes",
+});
+
+export { pods };
+`;
+
+const K8S_DELIVERY = `/**
+ * The dashboard and the datasource as ConfigMaps, labelled the way the
+ * Grafana Helm chart's sidecar (also in kube-prometheus-stack) finds them:
+ * \`grafana_dashboard: "1"\` and \`grafana_datasource: "1"\`, the folder in the
+ * \`k8s-sidecar-target-directory\` annotation. \`kubectl apply -f\` the k8s
+ * output into the namespace Grafana watches.
+ */
+import { GrafanaConfigMaps } from "@intentius/chant-lexicon-grafana/k8s";
+import { prometheus } from "./datasources";
+import { pods } from "./dashboard";
+
+/** The namespace Grafana's sidecar watches for ConfigMaps. */
+export const GRAFANA_NAMESPACE = "monitoring";
+
+const delivered = [prometheus, pods];
+const labels = { "app.kubernetes.io/part-of": "grafana" };
+
+const grafanaConfigMaps = GrafanaConfigMaps({ entities: delivered, namespace: GRAFANA_NAMESPACE, labels });
+
+export { grafanaConfigMaps };
+`;
+
+// ── slo ────────────────────────────────────────────────────────────────
+
+const SLO_CONFIG = `import type { ChantConfig } from "@intentius/chant";
+
+// The SLO's Prometheus rules, and the Grafana dashboard and alert rules that
+// read what they record, share one build root: GRAF108 and GRAF112 check the
+// queries against the datasource declared here.
+export default { lexicons: ["prometheus", "grafana"] } satisfies ChantConfig;
+`;
+
+const SLO_DATASOURCES = `/**
+ * The Prometheus that evaluates the SLO's recording rules.
+ */
+import { Datasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new Datasource({ name: "Prometheus", type: "prometheus", uid: "prometheus", url: "http://prometheus:9090", isDefault: true });
+
+export { prometheus };
+`;
+
+const SLO_DECLARATION = `/**
+ * The SLO: 99.9% of checkout requests answer without a 5xx over 30 days.
+ * The prometheus lexicon builds its recording rules; the dashboard and the
+ * alert rules read the series they record, by the same names.
+ */
+import { Slo } from "@intentius/chant-lexicon-prometheus";
+
+const sli = {
+  errors: 'sum(rate(http_requests_total{job="checkout",code=~"5.."}[{{window}}]))',
+  total: 'sum(rate(http_requests_total{job="checkout"}[{{window}}]))',
+};
+const team = { team: "payments" };
+
+const checkout = Slo({
+  name: "checkout",
+  objective: 0.999,
+  window: "30d",
+  description: "Checkout requests answer without a 5xx.",
+  sli,
+  labels: team,
+});
+
+export { checkout };
+`;
+
+const SLO_DASHBOARD = `/**
+ * The SLO's dashboard (SLI against the objective, error budget left, each
+ * burn-rate pair against the rate it fires at), and the same burn rates as
+ * Grafana-managed alert rules in the same folder.
+ */
+import { SloAlertRules, SloDashboard } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+import { checkout } from "./slo";
+
+const checkoutSlo = SloDashboard({ slo: checkout, datasource: prometheus, folder: "SLOs" });
+
+const team = { team: "payments" };
+const runbook = { runbook_url: "https://runbooks.example.com/checkout-slo" };
+const checkoutBurn = SloAlertRules({ slo: checkout, datasource: prometheus, folder: "SLOs", labels: team, annotations: runbook });
+
+export { checkoutSlo, checkoutBurn };
+`;
+
+// Build every lexicon the config names, not just grafana.
+const ALL_LEXICONS = { build: "chant build src", dev: "chant build src --watch" };
+
+export const DEFAULT_TEMPLATE: InitTemplateSet = {
+  src: { "datasources.ts": DEFAULT_DATASOURCES, "dashboard.ts": DEFAULT_DASHBOARD },
+};
+
+export const RED_TEMPLATE: InitTemplateSet = {
+  src: { "datasources.ts": RED_DATASOURCES, "red.ts": RED_DASHBOARD },
+};
+
+export const K8S_PODS_TEMPLATE: InitTemplateSet = {
+  src: {
+    "datasources.ts": K8S_DATASOURCES,
+    "variables.ts": K8S_VARIABLES,
+    "queries.ts": K8S_QUERIES,
+    "dashboard.ts": K8S_DASHBOARD,
+    "k8s.ts": K8S_DELIVERY,
+  },
+  root: { "chant.config.ts": K8S_CONFIG },
+  scripts: ALL_LEXICONS,
+};
+
+export const SLO_TEMPLATE: InitTemplateSet = {
+  src: { "datasources.ts": SLO_DATASOURCES, "slo.ts": SLO_DECLARATION, "dashboards.ts": SLO_DASHBOARD },
+  root: { "chant.config.ts": SLO_CONFIG },
+  scripts: ALL_LEXICONS,
+};
+
+/** The template names `chant init --lexicon grafana --template <name>` takes, besides the default. */
+export const TEMPLATE_NAMES = ["red", "k8s-pods", "slo"] as const;

package/src/k8s.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "vitest";
+import { expandComposite } from "@intentius/chant/composite";
+import { k8sSerializer } from "@intentius/chant-lexicon-k8s";
+import { loadAll } from "js-yaml";
+import { Dashboard } from "./dashboard";
+import { Datasource } from "./datasource";
+import { StatPanel } from "./panels";
+import { PromQuery } from "./query";
+import { dashboardJson } from "./build";
+import { GrafanaConfigMaps, grafanaConfigMapLayout, grafanaVolumes } from "./k8s";
+
+const prometheus = new Datasource({ name: "Prometheus", type: "prometheus", url: "http://prometheus:9090" });
+const stat = () => new StatPanel({ title: "Up", datasource: prometheus, targets: [new PromQuery({ expr: "sum(up)" })] });
+const top = new Dashboard({ title: "Top", uid: "Top_Level", panels: [stat()] });
+const red = new Dashboard({ title: "RED", uid: "red", folder: "Services", panels: [stat()] });
+const slo = new Dashboard({ title: "SLO", uid: "slo", folder: "Services", panels: [stat()] });
+const entities = [prometheus, top, red, slo];
+
+type Manifest = { kind: string; metadata: { name: string; namespace?: string; labels?: Record<string, string>; annotations?: Record<string, string> }; data: Record<string, string> };
+
+function manifests(instance: ReturnType<typeof GrafanaConfigMaps>): Manifest[] {
+  const out = k8sSerializer.serialize(expandComposite("grafana", instance));
+  return (loadAll(typeof out === "string" ? out : out.primary) as Manifest[]).filter(Boolean);
+}
+
+describe("GrafanaConfigMaps", () => {
+  test("one ConfigMap per dashboard, labelled for the sidecar, holding dashboardJson(dashboard)", () => {
+    const docs = manifests(GrafanaConfigMaps({ entities, namespace: "obs", labels: { team: "sre" } }));
+    expect(docs.map((d) => d.metadata.name)).toEqual([
+      "grafana-dashboard-top-level",
+      "grafana-dashboard-red",
+      "grafana-dashboard-slo",
+      "grafana-datasources",
+      "grafana-dashboard-providers",
+    ]);
+    const [topCm, redCm] = docs;
+    expect(topCm.metadata).toEqual({ name: "grafana-dashboard-top-level", namespace: "obs", labels: { team: "sre", grafana_dashboard: "1" } });
+    expect(topCm.data).toEqual({ "Top_Level.json": dashboardJson(top) });
+    expect(redCm.metadata.annotations).toEqual({ "k8s-sidecar-target-directory": "Services" });
+    expect(docs[3].metadata.labels).toEqual({ team: "sre", grafana_datasource: "1" });
+    expect(Object.keys(docs[3].data)).toEqual(["chant.yaml"]);
+    expect(docs[3].data["chant.yaml"]).toContain("url: http://prometheus:9090");
+    expect(docs[4].metadata.labels).toEqual({ team: "sre" });
+  });
+
+  test("labels and the folder annotation can be changed or left off", () => {
+    const docs = manifests(GrafanaConfigMaps({ entities: [red], name: "Obs", dashboardLabel: ["dashboards", "obs"], folderAnnotation: false }));
+    expect(docs[0].metadata).toEqual({ name: "obs-dashboard-red", labels: { dashboards: "obs" } });
+    const bare = manifests(GrafanaConfigMaps({ entities: [prometheus], datasourceLabel: false }));
+    expect(bare.map((d) => [d.metadata.name, d.metadata.labels])).toEqual([["grafana-datasources", {}]]);
+  });
+
+  test("names stay unique and DNS-1123 when uids collide after lower-casing", () => {
+    const a = new Dashboard({ title: "A", uid: "Same" });
+    const b = new Dashboard({ title: "B", uid: "same" });
+    expect(grafanaConfigMapLayout({ entities: [a, b] }).dashboards.map((d) => d.configMap)).toEqual(["grafana-dashboard-same", "grafana-dashboard-same-2"]);
+  });
+});
+
+describe("grafanaVolumes", () => {
+  test("provisioning under /etc/grafana/provisioning, each dashboard folder a projected volume of its own", () => {
+    const { volumes, volumeMounts } = grafanaVolumes({ entities });
+    expect(volumeMounts).toEqual([
+      { name: "grafana-provisioning", mountPath: "/etc/grafana/provisioning", readOnly: true },
+      { name: "grafana-dashboards-0", mountPath: "/var/lib/grafana/dashboards", readOnly: true },
+      { name: "grafana-dashboards-1", mountPath: "/var/lib/grafana/dashboards/Services", readOnly: true },
+    ]);
+    expect(volumes).toEqual([
+      {
+        name: "grafana-provisioning",
+        projected: {
+          sources: [
+            { configMap: { name: "grafana-datasources", items: [{ key: "chant.yaml", path: "datasources/chant.yaml" }] } },
+            { configMap: { name: "grafana-dashboard-providers", items: [{ key: "chant.yaml", path: "dashboards/chant.yaml" }] } },
+          ],
+        },
+      },
+      { name: "grafana-dashboards-0", projected: { sources: [{ configMap: { name: "grafana-dashboard-top-level", items: [{ key: "Top_Level.json", path: "Top_Level.json" }] } }] } },
+      {
+        name: "grafana-dashboards-1",
+        projected: {
+          sources: [
+            { configMap: { name: "grafana-dashboard-red", items: [{ key: "red.json", path: "red.json" }] } },
+            { configMap: { name: "grafana-dashboard-slo", items: [{ key: "slo.json", path: "slo.json" }] } },
+          ],
+        },
+      },
+    ]);
+  });
+
+  test("a different dashboards path or volume name", () => {
+    const { volumeMounts } = grafanaVolumes({ entities: [red] }, { dashboardsPath: "/dash/", volumeName: "g" });
+    expect(volumeMounts.map((m) => [m.name, m.mountPath])).toEqual([
+      ["g-provisioning", "/etc/grafana/provisioning"],
+      ["g-dashboards-0", "/dash/Services"],
+    ]);
+  });
+});