@intentius/chant-lexicon-grafana 0.98.0 → 0.100.0

package/src/build.test.ts

@@ -1,23 +1,29 @@
 import { describe, expect, test } from "vitest";
-import { Datasource } from "./datasource";
-import { Dashboard } from "./dashboard";
+import { Datasource, DatasourceProvisioning, ExternalDatasource } from "./datasource";
+import { Dashboard, DashboardProvider } from "./dashboard";
+import { Folder } from "./folder";
+import { load } from "js-yaml";
 import { Row, StatPanel, TextPanel, TimeSeriesPanel, TablePanel, definePanel } from "./panels";
 import { PromQuery, TempoQuery, LokiQuery, defineQuery } from "./query";
 import {
+  AdhocVariable,
   CustomVariable,
   ConstantVariable,
   DatasourceVariable,
+  GroupByVariable,
   IntervalVariable,
   QueryVariable,
+  SwitchVariable,
   TextboxVariable,
 } from "./variables";
-import { panelsJson, renderDashboard, variableModel, dashboardJson, grafanaFiles, type PanelJson } from "./build";
+import { panelsJson, renderDashboard, variableModel, dashboardJson, grafanaFiles, buildGrafana, customVariableOptions, type PanelJson } from "./build";
 
 /** The panels array, read as plain panels (the tests below build no rows unless they say so). */
 function panelsOnly(items: Parameters<typeof panelsJson>[0]): PanelJson[] {
   return panelsJson(items) as PanelJson[];
 }
 import { validateDashboardSchema } from "./schema-validate";
+import { checkGrid } from "./validate-output";
 
 const prometheus = new Datasource({ name: "Prometheus", type: "prometheus" });
 const tempo = new Datasource({ name: "Tempo", type: "tempo" });
@@ -77,6 +83,138 @@ describe("layout", () => {
     expect((panels[1] as unknown as { panels: unknown[] }).panels).toEqual([]);
   });
 
+  test("a row with a y keeps that line, even over an empty band or on a line a panel takes (#2992)", () => {
+    const panels = panelsJson([
+      new StatPanel({ title: "a", gridPos: { x: 0, y: 0, w: 24, h: 4 } }),
+      new Row({ title: "late", gridPos: { y: 6 }, panels: [new StatPanel({ title: "b", gridPos: { x: 0, y: 7, w: 24, h: 4 } })] }),
+      new Row({ title: "auto", panels: [new StatPanel({ title: "c" })] }),
+      new Row({ title: "early", gridPos: { y: 8 } }),
+    ]);
+    expect(panels.map((p) => [p.title, p.gridPos])).toEqual([
+      ["a", { h: 4, w: 24, x: 0, y: 0 }],
+      ["late", { h: 1, w: 24, x: 0, y: 6 }],
+      ["b", { h: 4, w: 24, x: 0, y: 7 }],
+      // An auto-placed row skips the line the "early" row reserved.
+      ["auto", { h: 1, w: 24, x: 0, y: 11 }],
+      ["c", { h: 4, w: 6, x: 0, y: 12 }],
+      ["early", { h: 1, w: 24, x: 0, y: 8 }],
+    ]);
+  });
+
+  test("an auto-placed panel flows around an explicit one declared before it (#2941)", () => {
+    const panels = panelsJson([
+      new TimeSeriesPanel({ title: "a", gridPos: { x: 0, y: 0, w: 12 } }),
+      new TimeSeriesPanel({ title: "b", gridPos: { w: 12 } }),
+    ]);
+    expect(panels.map((p) => p.gridPos)).toEqual([
+      { h: 8, w: 12, x: 0, y: 0 },
+      { h: 8, w: 12, x: 12, y: 0 },
+    ]);
+  });
+
+  test("an explicit panel reserves its cells even when declared after auto-placed ones", () => {
+    const panels = panelsJson([
+      new StatPanel({ title: "s1" }),
+      new StatPanel({ title: "s2" }),
+      new StatPanel({ title: "s3" }),
+      new StatPanel({ title: "s4" }),
+      new StatPanel({ title: "pinned", gridPos: { x: 6, y: 0, w: 6, h: 4 } }),
+      new TextPanel({ title: "wide" }),
+    ]);
+    expect(panels.map((p) => [p.title, p.gridPos])).toEqual([
+      ["s1", { h: 4, w: 6, x: 0, y: 0 }],
+      ["s2", { h: 4, w: 6, x: 12, y: 0 }],
+      ["s3", { h: 4, w: 6, x: 18, y: 0 }],
+      ["s4", { h: 4, w: 6, x: 0, y: 4 }],
+      ["pinned", { h: 4, w: 6, x: 6, y: 0 }],
+      ["wide", { h: 3, w: 24, x: 0, y: 8 }],
+    ]);
+  });
+
+  test("a line blocked by an explicit panel is skipped", () => {
+    const panels = panelsJson([
+      new StatPanel({ title: "band", gridPos: { x: 0, y: 0, w: 24, h: 2 } }),
+      new StatPanel({ title: "hole", gridPos: { x: 0, y: 6, w: 6, h: 2 } }),
+      new StatPanel({ title: "s1" }),
+      new TextPanel({ title: "wide" }),
+    ]);
+    expect(panels.map((p) => [p.title, p.gridPos])).toEqual([
+      ["band", { h: 2, w: 24, x: 0, y: 0 }],
+      ["hole", { h: 2, w: 6, x: 0, y: 6 }],
+      ["s1", { h: 4, w: 6, x: 0, y: 2 }],
+      ["wide", { h: 3, w: 24, x: 0, y: 8 }],
+    ]);
+  });
+
+  test("a partial gridPos is honoured: x only keeps its column, y only its line", () => {
+    const panels = panelsJson([
+      new StatPanel({ title: "right", gridPos: { x: 18 } }),
+      new StatPanel({ title: "left", gridPos: { x: 0 } }),
+      new StatPanel({ title: "next" }),
+      new StatPanel({ title: "low", gridPos: { y: 20, w: 12 } }),
+      new StatPanel({ title: "low2", gridPos: { y: 20, w: 12 } }),
+      new StatPanel({ title: "low3", gridPos: { y: 20, w: 12 } }),
+    ]);
+    expect(panels.map((p) => [p.title, p.gridPos])).toEqual([
+      ["right", { h: 4, w: 6, x: 18, y: 0 }],
+      ["left", { h: 4, w: 6, x: 0, y: 4 }],
+      ["next", { h: 4, w: 6, x: 6, y: 4 }],
+      ["low", { h: 4, w: 12, x: 0, y: 20 }],
+      ["low2", { h: 4, w: 12, x: 12, y: 20 }],
+      ["low3", { h: 4, w: 12, x: 0, y: 24 }],
+    ]);
+  });
+
+  test("a full-width row header skips lines taken by explicit panels", () => {
+    const panels = panelsJson([
+      new TimeSeriesPanel({ title: "top" }),
+      new Row({
+        title: "open",
+        panels: [new StatPanel({ title: "pinned", gridPos: { x: 0, y: 8, w: 24, h: 2 } }), new StatPanel({ title: "a" })],
+      }),
+      new Row({ title: "next" }),
+    ]);
+    expect(panels.map((p) => [p.type, p.title, p.gridPos])).toEqual([
+      ["timeseries", "top", { h: 8, w: 12, x: 0, y: 0 }],
+      ["row", "open", { h: 1, w: 24, x: 0, y: 10 }],
+      ["stat", "pinned", { h: 2, w: 24, x: 0, y: 8 }],
+      ["stat", "a", { h: 4, w: 6, x: 0, y: 11 }],
+      ["row", "next", { h: 1, w: 24, x: 0, y: 15 }],
+    ]);
+  });
+
+  test("a collapsed row's panels flow around its own explicit panels and don't block the dashboard", () => {
+    const panels = panelsJson([
+      new Row({
+        title: "shut",
+        collapsed: true,
+        panels: [new StatPanel({ title: "pinned", gridPos: { x: 0, y: 1, w: 6, h: 4 } }), new StatPanel({ title: "a" })],
+      }),
+      new StatPanel({ title: "after" }),
+    ]);
+    const shut = panels[0] as unknown as { panels: PanelJson[] };
+    expect(shut.panels.map((p) => [p.title, p.gridPos])).toEqual([
+      ["pinned", { h: 4, w: 6, x: 0, y: 1 }],
+      ["a", { h: 4, w: 6, x: 6, y: 1 }],
+    ]);
+    expect(panels[1].gridPos).toEqual({ h: 4, w: 6, x: 0, y: 1 });
+  });
+
+  test("a mixed layout built by the dashboard passes GRAF105", () => {
+    const dash = new Dashboard({
+      title: "Mixed",
+      panels: [
+        new TimeSeriesPanel({ title: "a", gridPos: { x: 0, y: 0, w: 12 } }),
+        new TimeSeriesPanel({ title: "b", gridPos: { w: 12 } }),
+        new StatPanel({ title: "c", gridPos: { x: 6 } }),
+        new StatPanel({ title: "d", gridPos: { x: 12, y: 8, w: 12, h: 4 } }),
+        new StatPanel({ title: "e" }),
+        new Row({ title: "r", panels: [new StatPanel({ title: "f", gridPos: { x: 18, y: 12 } }), new StatPanel({ title: "g" })] }),
+      ],
+    });
+    expect(checkGrid({ dashboards: [{ json: JSON.parse(dashboardJson(dash)) }], datasources: [] })).toEqual([]);
+  });
+
   test("auto ids skip ids set explicitly", () => {
     const panels = panelsJson([new StatPanel(), new StatPanel({ id: 1 }), new StatPanel()]);
     expect(panels.map((p) => p.id)).toEqual([2, 1, 3]);
@@ -102,6 +240,17 @@ describe("datasources and targets", () => {
     ]);
   });
 
+  test("a panel declared Mixed stays Mixed, and a query naming no datasource is not sent to Mixed (#2992)", () => {
+    const mixed = { type: "datasource", uid: "-- Mixed --" };
+    const [bare, panel] = panelsOnly([
+      new TextPanel({ datasource: mixed }),
+      new StatPanel({ datasource: mixed, targets: [new PromQuery({ expr: "up", datasource: prometheus }), new PromQuery({ expr: "down" })] }),
+    ]);
+    expect(bare.datasource).toEqual(mixed);
+    expect(panel.datasource).toEqual(mixed);
+    expect(panel.targets!.map((t) => (t as { datasource?: unknown }).datasource)).toEqual([{ type: "prometheus", uid: "prometheus" }, undefined]);
+  });
+
   test("a panel takes its queries' shared datasource, and a row passes its own down", () => {
     const [shared] = panelsOnly([new StatPanel({ targets: [new PromQuery({ expr: "up", datasource: prometheus })] })]);
     expect(shared.datasource).toEqual({ type: "prometheus", uid: "prometheus" });
@@ -158,6 +307,98 @@ describe("variables", () => {
     expect(variableModel(new TextboxVariable({ name: "q" }))).toMatchObject({ type: "textbox", query: "" });
   });
 
+  test("an object query is written as it is, its text as the definition", () => {
+    const query = { qryType: 1 as const, query: "label_values(up, job)", refId: "PrometheusVariableQueryEditor-VariableQuery" };
+    expect(variableModel(new QueryVariable({ name: "job", datasource: prometheus, query }))).toMatchObject({ query, definition: "label_values(up, job)" });
+    expect(variableModel(new QueryVariable({ name: "ns", datasource: prometheus, query: { namespace: "AWS/EC2" }, definition: "Namespaces" }))).toMatchObject({
+      query: { namespace: "AWS/EC2" },
+      definition: "Namespaces",
+    });
+  });
+
+  test("ad hoc, group by and switch variables as Grafana writes them", () => {
+    const ds = new DatasourceVariable({ name: "ds", pluginType: "prometheus" });
+    expect(variableModel(new AdhocVariable({ name: "f", datasource: ds, filters: [{ key: "ns", operator: "=", value: "shop" }] }))).toEqual({
+      type: "adhoc",
+      name: "f",
+      datasource: { type: "prometheus", uid: "${ds}" },
+      filters: [{ key: "ns", operator: "=", value: "shop" }],
+      baseFilters: [],
+    });
+    expect(variableModel(new GroupByVariable({ name: "by", datasource: prometheus, options: ["pod", { text: "Node", value: "node" }], defaultValue: ["pod"] }))).toEqual({
+      type: "groupby",
+      name: "by",
+      datasource: { type: "prometheus", uid: prometheus.uid },
+      options: [
+        { text: "pod", value: "pod" },
+        { text: "Node", value: "node" },
+      ],
+      current: { text: ["pod"], value: ["pod"] },
+      defaultValue: { text: ["pod"], value: ["pod"] },
+    });
+    expect(variableModel(new SwitchVariable({ name: "on" }))).toEqual({
+      type: "switch",
+      name: "on",
+      current: { text: "false", value: "false" },
+      options: [
+        { text: "true", value: "true" },
+        { text: "false", value: "false" },
+      ],
+    });
+    expect(variableModel(new SwitchVariable({ name: "q", enabled: true, enabledValue: "0.99", disabledValue: "0.5" }))).toMatchObject({
+      current: { text: "0.99", value: "0.99" },
+      options: [
+        { text: "0.99", value: "0.99" },
+        { text: "0.5", value: "0.5" },
+      ],
+    });
+  });
+
+  test("a custom value in Grafana's `text : value` syntax shows the text and sets the value (#2944)", () => {
+    const v = variableModel(new CustomVariable({ name: "env", values: ["Production : prod", "Staging : stg", "dev"] }));
+    expect(v).toMatchObject({
+      query: "Production : prod,Staging : stg,dev",
+      current: { text: "Production", value: "prod" },
+      options: [
+        { selected: true, text: "Production", value: "prod" },
+        { selected: false, text: "Staging", value: "stg" },
+        { selected: false, text: "dev", value: "dev" },
+      ],
+    });
+  });
+
+  test("a custom value's selected option follows current by value, and multi-value current selects several", () => {
+    const v = variableModel(
+      new CustomVariable({ name: "env", multi: true, values: ["Production : prod", "Staging : stg"], current: { text: ["Staging"], value: ["stg"] } }),
+    );
+    expect((v as { options: Array<{ selected: boolean }> }).options.map((o) => o.selected)).toEqual([false, true]);
+  });
+
+  test("a comma already escaped as \\, is not escaped again (#2944)", () => {
+    const v = variableModel(new CustomVariable({ name: "pair", values: ["a\\,b", "c,d", "Label, with comma : x\\,y"] }));
+    expect(v).toMatchObject({
+      query: "a\\,b,c\\,d,Label\\, with comma : x\\,y",
+      options: [
+        { text: "a,b", value: "a,b" },
+        { text: "c,d", value: "c,d" },
+        { text: "Label, with comma", value: "x,y" },
+      ],
+    });
+  });
+
+  test("customVariableOptions parses a query the way Grafana does", () => {
+    expect(customVariableOptions("a : 1, b,c\\,d , ,x:y, k : v : w")).toEqual([
+      { text: "a", value: "1" },
+      { text: "b", value: "b" },
+      { text: "c,d", value: "c,d" },
+      { text: "", value: "" },
+      // No spaces around the colon: one plain value.
+      { text: "x:y", value: "x:y" },
+      // Grafana's first group is greedy: the last ` : ` splits.
+      { text: "k : v", value: "w" },
+    ]);
+  });
+
   test("a dashboard with every variable kind matches the dashboard schema", () => {
     const dash = new Dashboard({
       title: "Vars",
@@ -168,6 +409,10 @@ describe("variables", () => {
         new DatasourceVariable({ name: "ds", pluginType: "prometheus" }),
         new ConstantVariable({ name: "cluster", value: "x" }),
         new TextboxVariable({ name: "q", value: "y" }),
+        new QueryVariable({ name: "pods", datasource: prometheus, query: { qryType: 1, query: "label_values(kube_pod_info, pod)" } }),
+        new AdhocVariable({ name: "f", datasource: prometheus, baseFilters: [{ key: "cluster", operator: "=", value: "prod" }], defaultKeys: [{ text: "pod" }] }),
+        new GroupByVariable({ name: "by", datasource: prometheus, options: ["pod"] }),
+        new SwitchVariable({ name: "on", enabled: true }),
       ],
     });
     expect(validateDashboardSchema(renderDashboard(dash) as unknown as Record<string, unknown>)).toEqual([]);
@@ -176,17 +421,17 @@ describe("variables", () => {
 
 describe("extension points", () => {
   test("definePanel and defineQuery produce classes that render and lay out like built-ins", () => {
-    const PieChartPanel = definePanel<{ pieType?: "pie" | "donut" }>()({ type: "piechart", className: "PieChartPanel", defaultSize: { w: 8, h: 8 } });
-    const ElasticQuery = defineQuery<{ query: string; refId?: string }>()({ datasourceType: "elasticsearch", className: "ElasticQuery" });
-    const es = new Datasource({ name: "Logs ES", type: "elasticsearch" });
+    const ClockPanel = definePanel<{ mode?: "time" | "countdown" }>()({ type: "grafana-clock-panel", className: "ClockPanel", defaultSize: { w: 8, h: 8 } });
+    const OpenSearchQuery = defineQuery<{ query: string; refId?: string }>()({ datasourceType: "grafana-opensearch-datasource", className: "OpenSearchQuery" });
+    const os = new Datasource({ name: "Logs OS", type: "grafana-opensearch-datasource" });
     const json = renderDashboard(
-      new Dashboard({ title: "Custom", panels: [new PieChartPanel({ options: { pieType: "donut" }, datasource: es, targets: [new ElasticQuery({ query: "*" })] })] }),
+      new Dashboard({ title: "Custom", panels: [new ClockPanel({ options: { mode: "countdown" }, datasource: os, targets: [new OpenSearchQuery({ query: "*" })] })] }),
     );
     expect(json.panels![0]).toMatchObject({
-      type: "piechart",
+      type: "grafana-clock-panel",
       gridPos: { w: 8, h: 8, x: 0, y: 0 },
-      options: { pieType: "donut" },
-      datasource: { type: "elasticsearch", uid: "logs-es" },
+      options: { mode: "countdown" },
+      datasource: { type: "grafana-opensearch-datasource", uid: "logs-os" },
       targets: [{ refId: "A", query: "*" }],
     });
     expect(validateDashboardSchema(json as unknown as Record<string, unknown>)).toEqual([]);
@@ -208,3 +453,99 @@ describe("extension points", () => {
     ]);
   });
 });
+
+describe("folders (#2944)", () => {
+  test("a nested folder is written as nested directories under dashboards/", () => {
+    const built = buildGrafana([new Dashboard({ title: "Pods", uid: "pods", folder: "Platform/Kubernetes" })]);
+    expect(built.dashboards[0].file).toBe("dashboards/Platform/Kubernetes/pods.json");
+    expect(built.index.dashboards[0].folder).toBe("Platform/Kubernetes");
+  });
+
+  test("blank levels, dot-led levels and backslashes can't leave dashboards/", () => {
+    const file = (folder: string) => buildGrafana([new Dashboard({ title: "D", uid: "d", folder })]).dashboards[0].file;
+    expect(file("/Platform//Kubernetes/")).toBe("dashboards/Platform/Kubernetes/d.json");
+    expect(file("../../etc")).toBe("dashboards/etc/d.json");
+    expect(file("a\\b")).toBe("dashboards/a-b/d.json");
+    expect(file(" / ")).toBe("dashboards/d.json");
+  });
+});
+
+describe("folder uids and nesting (#2953)", () => {
+  const platform = new Folder({ title: "Platform", uid: "plat" });
+  const k8s = new Folder({ title: "Kubernetes", parent: platform });
+
+  test("a Folder is written where its path is, and the index lists every level with its uid and parent", () => {
+    const built = buildGrafana(
+      new Map<string, never>([
+        ["pods", new Dashboard({ title: "Pods", uid: "pods", folder: k8s }) as never],
+        ["nodes", new Dashboard({ title: "Nodes", uid: "nodes", folder: "Platform/Kubernetes/Nodes" }) as never],
+        ["spare", new Folder({ title: "Spare" }) as never],
+      ]),
+    );
+    expect(built.dashboards.map((d) => [d.file, d.folder, d.folderUid])).toEqual([
+      ["dashboards/Platform/Kubernetes/pods.json", "Platform/Kubernetes", "platform-kubernetes"],
+      ["dashboards/Platform/Kubernetes/Nodes/nodes.json", "Platform/Kubernetes/Nodes", "platform-kubernetes-nodes"],
+    ]);
+    expect(built.index.folders).toEqual([
+      { uid: "plat", title: "Platform", path: "Platform" },
+      { uid: "platform-kubernetes", title: "Kubernetes", parentUid: "plat", path: "Platform/Kubernetes" },
+      { uid: "platform-kubernetes-nodes", title: "Nodes", parentUid: "platform-kubernetes", path: "Platform/Kubernetes/Nodes" },
+      { uid: "spare", title: "Spare", path: "Spare" },
+    ]);
+  });
+
+  test("a path and a Folder at the same path are one folder; the Folder's uid wins", () => {
+    const built = buildGrafana([new Dashboard({ title: "A", uid: "a", folder: "Platform" }), new Dashboard({ title: "B", uid: "b", folder: platform })]);
+    expect(built.dashboards.map((d) => d.folderUid)).toEqual(["plat", "plat"]);
+    expect(built.folders).toEqual([{ uid: "plat", title: "Platform", path: "Platform" }]);
+  });
+
+  test("a Folder title is one level, and two uids at one path are refused", () => {
+    expect(() => new Folder({ title: "Platform/Kubernetes" })).toThrow(/not one folder level/);
+    expect(() => buildGrafana([new Folder({ title: "X", uid: "one" }), new Folder({ title: "X", uid: "two" })])).toThrow(/declared with the uids "one" and "two"/);
+  });
+
+  test("a root-level Folder on a DashboardProvider is written as folder and folderUid; a nested one is refused", () => {
+    const built = buildGrafana([new DashboardProvider({ name: "ops", folder: platform, path: "/d" })]);
+    expect(built.providers[0]).toMatchObject({ folder: "Platform", folderUid: "plat", options: { foldersFromFilesStructure: false } });
+    expect(() => new DashboardProvider({ name: "ops", folder: k8s })).toThrow(/nested; Grafana creates a provider's folder at the root/);
+  });
+});
+
+describe("annotations (#2953)", () => {
+  test("an annotation is written with its datasource resolved and Grafana's defaults filled in", () => {
+    const json = renderDashboard(
+      new Dashboard({
+        title: "D",
+        annotations: [
+          { name: "Deploys", datasource: prometheus, target: new PromQuery({ expr: "changes(up[5m]) > 0" }), titleFormat: "deploy" },
+          { name: "Incidents", datasource: { type: "grafana", uid: "-- Grafana --" }, enable: false, iconColor: "blue", target: { type: "tags", tags: ["incident"], limit: 100, matchAny: false } },
+        ],
+      }),
+    );
+    expect(json.annotations).toEqual({
+      list: [
+        { datasource: { type: "prometheus", uid: "prometheus" }, enable: true, iconColor: "red", name: "Deploys", titleFormat: "deploy", target: expect.objectContaining({ refId: "Anno", expr: "changes(up[5m]) > 0" }) },
+        { datasource: { type: "grafana", uid: "-- Grafana --" }, enable: false, iconColor: "blue", name: "Incidents", target: { type: "tags", tags: ["incident"], limit: 100, matchAny: false } },
+      ],
+    });
+    expect(validateDashboardSchema(json as never).filter((p) => p.severity === "error")).toEqual([]);
+    expect(renderDashboard(new Dashboard({ title: "E" })).annotations).toEqual({ list: [] });
+  });
+});
+
+describe("datasource prune (#2953)", () => {
+  const files = (entities: unknown[]) => load(buildGrafana(entities as never).files["provisioning/datasources/chant.yaml"] ?? "null") as Record<string, unknown> | null;
+
+  test("the datasource file prunes by default, so a removed Datasource leaves Grafana", () => {
+    expect(files([prometheus])).toMatchObject({ apiVersion: 1, prune: true });
+  });
+
+  test("DatasourceProvisioning turns pruning off and lists datasources to delete", () => {
+    const out = files([prometheus, new DatasourceProvisioning({ prune: false, deleteDatasources: [{ name: "Old" }, { name: "Other", orgId: 2 }] })]);
+    expect(out).toEqual({ apiVersion: 1, deleteDatasources: [{ name: "Old" }, { name: "Other", orgId: 2 }], datasources: [expect.objectContaining({ name: "Prometheus" })] });
+    expect(files([new DatasourceProvisioning({ deleteDatasources: [{ name: "Old" }] })])).toEqual({ apiVersion: 1, prune: true, deleteDatasources: [{ name: "Old" }], datasources: [] });
+    expect(files([new ExternalDatasource({ type: "prometheus", uid: "p" })])).toBeNull();
+    expect(() => buildGrafana([new DatasourceProvisioning({}), new DatasourceProvisioning({})])).toThrow(/at most one DatasourceProvisioning/);
+  });
+});