@canonical/pragma-cli 0.32.0 → 0.33.0

package/src/testing/fixtures/graph/defaultPack.ts

@@ -0,0 +1,178 @@
+/**
+ * The hermetic, vendored "default-pack" fixture — a SMALL but REAL multi-typed
+ * design-system pack, shaped the way a shipped default pack actually is, not the
+ * way the 6-entity single-typed canonical graph was.
+ *
+ * WHY A SECOND GRAPH (the R1 "one graph" discipline notwithstanding): the
+ * canonical fixture (`canonical.ts`) is deliberately clean — every individual is
+ * single-typed (`a ds:Component`), every block carries a tier, every label is a
+ * bare string. That cleanliness is exactly what masked the real-data counter and
+ * classifier bugs the journey harness (AV-231, Backlog E) exists to catch. This
+ * fixture is the ADVERSARIAL default pack: it reproduces the four shapes a real
+ * vendored pack has that the clean graph does not —
+ *
+ *  1. `owl:NamedIndividual` co-typing — every block is
+ *     `a owl:NamedIndividual, ds:<Class>`, the way exported OWL individuals are.
+ *     This is what doubles the per-type instance tally (A1 `entityTotal` 2×): a
+ *     block counts once under `owl:NamedIndividual` AND once under its domain
+ *     class.
+ *  2. Two+ domain classes (`ds:Component` and `ds:Pattern`) so a read that keys
+ *     off the primary domain type is exercised across more than one class.
+ *  3. An UNTIERED block (`ds:orphanWidget` — a `ds:Component` with a `ds:name`
+ *     but NO `ds:tier`). `block list`'s SELECT inner-joins `?c ds:tier ?t`, so an
+ *     untiered block is silently dropped from every listing (A2), even though
+ *     `graph query` finds it — the fixture pins both halves of that divergence.
+ *  4. A multilingual `rdfs:label "Button"@en, "Bouton"@fr` — two same-predicate
+ *     labels whose winner in the single-valued index is store-order-arbitrary
+ *     (A7), a shape a bare-string fixture can never produce.
+ *
+ * The vocabulary is the live `ds:` design-system namespace (same as
+ * `blockGraph.ts`/`canonical.ts`), so `block list`, `ontology list/show`, and
+ * `graph query` all run against real terms — the hand-written `block list` verb
+ * hard-codes `ds:Component`/`ds:name`/`ds:tier`/`ds:release`.
+ *
+ * Stable anchors this fixture guarantees (pinned by the journey suite):
+ *  - Exactly 4 blocks in the graph: Button (`ds:Component`, global), Card
+ *    (`ds:Pattern`, global), Beta Badge (`ds:Component`, apps tier, beta
+ *    channel), Orphan Widget (`ds:Component`, UNTIERED).
+ *  - 5 TBox classes, 4 TBox properties, 2 tiers (`global`, `apps`), 2 release
+ *    channels (`stable`, `beta`).
+ *  - `ds:button` carries the multilingual label; every other subject is a bare
+ *    string, so the multilingual path is isolated to one entity.
+ */
+
+/** The prefixes the default-pack fixture store is built and queried with. */
+export const DEFAULT_PACK_PREFIXES: Readonly<Record<string, string>> = {
+  ds: "https://ds.canonical.com/",
+  owl: "http://www.w3.org/2002/07/owl#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+};
+
+/**
+ * The vendored default pack as one Turtle document: TBox (5 classes, 4
+ * properties) + ABox (2 tiers, 2 channels, 4 blocks). Every block is co-typed
+ * `owl:NamedIndividual` — the real-export shape the clean canonical graph omits.
+ */
+export const DEFAULT_PACK_TTL = `
+@prefix ds: <https://ds.canonical.com/> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+# ---- Ontology (TBox): 5 classes, 4 properties ----
+ds:UIBlock a owl:Class ; rdfs:label "UI Block" .
+ds:Component a owl:Class ; rdfs:subClassOf ds:UIBlock ; rdfs:label "Component" .
+ds:Pattern a owl:Class ; rdfs:subClassOf ds:UIBlock ; rdfs:label "Pattern" .
+ds:Tier a owl:Class ; rdfs:label "Tier" .
+ds:ReleaseChannel a owl:Class ; rdfs:label "Release Channel" .
+
+ds:name a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+# Functional (one tier per block), matching the live ontology — a non-functional
+# ds:tier compiles to a multi-valued GraphQL field the bundled block lookup rejects.
+ds:tier a owl:ObjectProperty, owl:FunctionalProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:Tier .
+ds:release a owl:ObjectProperty, owl:FunctionalProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:ReleaseChannel .
+ds:summary a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+
+# ---- Tiers (a real parent chain: apps -> global) ----
+ds:global a ds:Tier ; ds:name "global" .
+ds:apps a ds:Tier ; ds:name "apps" .
+
+# ---- Release channels ----
+ds:stable a ds:ReleaseChannel ; ds:name "stable" .
+ds:beta a ds:ReleaseChannel ; ds:name "beta" .
+
+# ---- Blocks (ABox) — every one co-typed owl:NamedIndividual (the export shape) ----
+
+# A component on the global tier, carrying a MULTILINGUAL label (A7 shape).
+ds:button a owl:NamedIndividual, ds:Component ;
+  ds:name "Button" ;
+  rdfs:label "Button"@en, "Bouton"@fr ;
+  ds:tier ds:global ;
+  ds:summary "A clickable button control." .
+
+# A second DOMAIN CLASS (ds:Pattern), on the global tier.
+ds:card a owl:NamedIndividual, ds:Pattern ;
+  ds:name "Card" ;
+  rdfs:label "Card" ;
+  ds:tier ds:global ;
+  ds:summary "A content card layout pattern." .
+
+# A component gated to the BETA channel and the non-global apps tier — exercises
+# both channel visibility and tier-chain inheritance.
+ds:betaBadge a owl:NamedIndividual, ds:Component ;
+  ds:name "Beta Badge" ;
+  rdfs:label "Beta Badge" ;
+  ds:tier ds:apps ;
+  ds:release ds:beta ;
+  ds:summary "An experimental badge, gated to the prerelease channel." .
+
+# An UNTIERED component — a real ds:Component with a ds:name but NO ds:tier.
+# It IS in the graph (graph query finds it) but block list's mandatory
+# tier join (?c ds:tier ?t) drops it (A2).
+ds:orphanWidget a owl:NamedIndividual, ds:Component ;
+  ds:name "Orphan Widget" ;
+  rdfs:label "Orphan Widget" ;
+  ds:summary "A component shipped without a tier assignment." .
+`;
+
+/** No-tier viewing config, `normal` channel — hides the beta-only Beta Badge. */
+export const DEFAULT_PACK_CONFIG = { channel: "normal" as const };
+
+/** `prerelease` channel, no tier — the config where every channel-gated block shows. */
+export const DEFAULT_PACK_ALL_VISIBLE_CONFIG = {
+  channel: "prerelease" as const,
+};
+
+/** The names of the 4 blocks the fixture declares, sorted (SPARQL `ORDER BY ?name`). */
+export const DEFAULT_PACK_BLOCK_NAMES = [
+  "Beta Badge",
+  "Button",
+  "Card",
+  "Orphan Widget",
+] as const;
+
+/** The block excluded from `block list` for want of a `ds:tier` (A2 anchor). */
+export const UNTIERED_BLOCK_NAME = "Orphan Widget";
+
+/**
+ * A second, ontology-only pack with NO tiered blocks — drives the EMPTY
+ * `block list` (a calm exit-0 empty result, not an error). It still declares the
+ * `ds:` TBox, so `ontology list` is POPULATED here (the populated/empty pair for
+ * the two list verbs is split across this and {@link INSTANCE_ONLY_TTL}).
+ */
+export const NO_BLOCKS_TTL = `
+@prefix ds: <https://ds.canonical.com/> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+ds:UIBlock a owl:Class .
+ds:Component a owl:Class ; rdfs:subClassOf ds:UIBlock .
+ds:Tier a owl:Class .
+ds:name a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+ds:tier a owl:ObjectProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:Tier .
+
+ds:global a ds:Tier ; ds:name "global" .
+`;
+
+/**
+ * A pack of pure instance data with NO `owl:Class`/`owl:*Property` declarations —
+ * drives the EMPTY `ontology list` (no namespace has any classes or properties
+ * to group), while `graph query` still resolves its triples.
+ */
+export const INSTANCE_ONLY_TTL = `
+@prefix ex: <https://ex.test/#> .
+ex:alpha ex:relatesTo ex:beta .
+ex:beta ex:name "Beta" .
+`;
+
+/**
+ * A malformed Turtle source — a subject/predicate with no object — drives the
+ * `sources update` data-error classification path (a NAMED `CONFIG_ERROR`, not
+ * an INTERNAL "please report this issue").
+ */
+export const MALFORMED_TTL = `@prefix ex: <https://ex.test/#> .
+ex:One a ex:Widget .
+ex:Two ex:danglingPredicate .
+`;

package/src/testing/fixtures/graph/owlExport.ts

@@ -0,0 +1,95 @@
+/**
+ * A realistic multi-typed OWL / Protégé-export fixture graph.
+ *
+ * The embedded `sample.ttl` (Button/Card/Dialog, each typed by exactly ONE
+ * domain class, every block tiered, every label untagged) is a TOY: it never
+ * exercises the counters/classifiers the way a real vocabulary does. This graph
+ * deliberately carries the shapes that only bite real packs (audit backlog A):
+ *
+ * - Protégé DUAL-typing: an individual asserted as its domain class AND
+ *   `owl:NamedIndividual` — the multiset that made `entityTotal` run ~2× (A1).
+ * - A MULTI-DOMAIN individual (`ex:toggle`: two domain classes) — so the
+ *   primary-type tie-break must be deterministic, not store-order (A3).
+ * - An UNTIERED block (`ds:datePicker`: a `ds:Component` with no `ds:tier`) —
+ *   which `block list --all-tiers` must surface, not hide (A2).
+ * - A blank-node `rdf:type` (`ex:field`'s anonymous SHACL-style class) — which
+ *   must NOT become a `type:"_:b0"` primary key (A6).
+ * - An OWL-PUNNED subject (`ex:Slider`: a class that is ALSO a metaclass
+ *   individual) — whose abox facet must survive alongside its tbox one (A8).
+ * - MULTILINGUAL labels (`"Button"@en` / `"Bouton"@fr`) — resolved to a stable
+ *   language, never whichever row the store returned first (A7).
+ *
+ * The `ds:` half is a compact but faithful design-system slice (so `block list`
+ * runs against it); the `ex:` half is generic OWL, proving the index is
+ * ontology-agnostic. One document, so a single store answers every read.
+ */
+
+/** The prefixes the OWL-export fixture store is built and queried with. */
+export const OWL_EXPORT_PREFIXES: Readonly<Record<string, string>> = {
+  ds: "https://ds.canonical.com/",
+  ex: "https://ex.test/vocab#",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  owl: "http://www.w3.org/2002/07/owl#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+};
+
+/** The multi-typed OWL-export fixture ontology + individuals as Turtle. */
+export const OWL_EXPORT_TTL = `
+@prefix ds:   <https://ds.canonical.com/> .
+@prefix ex:   <https://ex.test/vocab#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix owl:  <http://www.w3.org/2002/07/owl#> .
+@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+
+# ---- Design-system TBox (so \`block list\` has real block types) ----
+ds:UIBlock a owl:Class .
+ds:Component a owl:Class ; rdfs:subClassOf ds:UIBlock ; rdfs:label "Component" .
+ds:Tier a owl:Class .
+ds:name a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+ds:tier a owl:ObjectProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:Tier .
+ds:global a owl:NamedIndividual, ds:Tier ; ds:name "global" .
+
+# ---- Generic OWL domain classes (multi-typing lives here) ----
+ex:Interactive a owl:Class ; rdfs:label "Interactive" .
+ex:FormControl a owl:Class ; rdfs:label "Form Control" .
+ex:Category a owl:Class ; rdfs:label "Category" .
+
+# ---- A tiered block, Protégé-style DUAL-typed (domain class + owl:NamedIndividual),
+#      with a multilingual label (A1 + A7). ----
+ds:button a owl:NamedIndividual, ds:Component ;
+  ds:name "Button" ;
+  ds:tier ds:global ;
+  rdfs:label "Button"@en , "Bouton"@fr .
+
+# ---- An UNTIERED block: a ds:Component with NO ds:tier (A2). ----
+ds:datePicker a owl:NamedIndividual, ds:Component ;
+  ds:name "Date Picker" ;
+  rdfs:label "Date Picker"@en , "Sélecteur de date"@fr .
+
+# ---- A MULTI-DOMAIN individual: two domain classes + owl:NamedIndividual (A1 + A3).
+#      The abox primary must be the lexically-smallest: ex:FormControl < ex:Interactive. ----
+ex:toggle a owl:NamedIndividual, ex:Interactive, ex:FormControl ;
+  rdfs:label "Toggle"@en , "Bascule"@fr .
+
+# ---- An OWL-PUNNED subject: a class that is ALSO a metaclass individual (A8).
+#      Must emit BOTH a tbox facet (owl:Class) and an abox facet (ex:Category). ----
+ex:Slider a owl:Class, owl:NamedIndividual, ex:Category ;
+  rdfs:label "Slider" .
+
+# ---- A subject with a BLANK-NODE rdf:type: an anonymous class (A6).
+#      The blank node must NOT become ex:field's primary type. ----
+ex:field a owl:NamedIndividual, ex:FormControl, [ a owl:Class ] ;
+  rdfs:label "Field" .
+`;
+
+/** The distinct abox individuals this fixture declares (the `entityTotal` oracle). */
+export const OWL_EXPORT_ABOX_SUBJECTS: readonly string[] = [
+  "ds:button",
+  "ds:datePicker",
+  "ds:global",
+  "ex:Slider",
+  "ex:field",
+  "ex:toggle",
+];

package/src/testing/helpers/extractSnippets.ts

@@ -0,0 +1,29 @@
+/**
+ * Pull the runnable `pragma` command lines out of a Markdown document.
+ *
+ * Scans fenced `bash` / `sh` / `console` blocks, strips a leading shell prompt
+ * (`$ `), and keeps the lines that invoke `pragma`. Used by the doc-example
+ * tests to prove every command shown in the docs is real grammar and — for the
+ * curated read set — actually runs.
+ */
+
+/** Fenced `bash`/`sh`/`console` blocks, capturing the body between the fences. */
+const FENCE_RE = /```(?:bash|sh|console)\r?\n(?<body>[\s\S]*?)```/g;
+
+/**
+ * Extract every `pragma …` command line from a Markdown string.
+ *
+ * @param markdown - The Markdown source to scan.
+ * @returns The `pragma` command lines, in document order, prompt-stripped.
+ */
+export function extractPragmaCommands(markdown: string): string[] {
+  const commands: string[] = [];
+  for (const match of markdown.matchAll(FENCE_RE)) {
+    const body = match.groups?.body ?? "";
+    for (const rawLine of body.split("\n")) {
+      const line = rawLine.replace(/^\s*\$\s+/, "").trim();
+      if (line.startsWith("pragma ")) commands.push(line);
+    }
+  }
+  return commands;
+}

package/src/testing/helpers/golden.ts

@@ -14,7 +14,7 @@ import { fileURLToPath } from "node:url";
 // biome-ignore lint/suspicious/noControlCharactersInRegex: matching the literal ESC byte is the point
 const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
 
-/** The package repo root (`packages/cli/next`), for tokenizing absolute paths. */
+/** The package repo root (`packages/cli/pragma`), for tokenizing absolute paths. */
 const REPO_ROOT = fileURLToPath(new URL("../../../", import.meta.url)).replace(
   /\/$/,
   "",

package/src/capabilities/config/field.test.ts

@@ -1,188 +0,0 @@
-/**
- * `config tier` / `channel` / `detail` — storeless, covenant-exact setters.
- *
- * Pins the emitted shape against the golden slice, exercises set / reset-sentinel
- * / enum-reject / `--dry-run` plan / MCP plan-first-vs-confirm, and holds the
- * storeless invariant (a config write never boots the store).
- */
-
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { globalConfigPath } from "../../kernel/config/paths.js";
-import { CHANNELS } from "../../kernel/config/types.js";
-import { PragmaError } from "../../kernel/error/PragmaError.js";
-import {
-  executeVerb,
-  extractParams,
-} from "../../kernel/project/cli/dispatch.js";
-import { bootRuntime } from "../../kernel/runtime/boot.js";
-import type { GlobalFlags, PragmaRuntime } from "../../kernel/runtime/types.js";
-import { emitVerb } from "../../kernel/spec/emitSurface.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import { projectMcp } from "../../testing/helpers/projectMcp.js";
-import { CONFIG_FIELDS } from "./fields.js";
-import { configModule } from "./index.js";
-import { runField } from "./runField.js";
-
-const FLAGS: GlobalFlags = {
-  llm: false,
-  autoLlm: false,
-  format: "plain",
-  verbose: false,
-};
-const REAL = { dryRun: false, undo: false, yes: false };
-const DRY = { dryRun: true, undo: false, yes: false };
-
-const verbOf = (field: string): VerbSpec =>
-  configModule.verbs.find((v) => v.path[1] === field) as VerbSpec;
-const tierVerb = verbOf("tier");
-const channelVerb = verbOf("channel");
-const detailVerb = verbOf("detail");
-
-let prevXdg: string | undefined;
-const roots: string[] = [];
-const tmp = (prefix: string): string => {
-  const dir = mkdtempSync(join(tmpdir(), prefix));
-  roots.push(dir);
-  return dir;
-};
-
-beforeEach(() => {
-  prevXdg = process.env.XDG_CONFIG_HOME;
-  process.env.XDG_CONFIG_HOME = tmp("pragma-cfgfield-xdg-");
-});
-afterEach(() => {
-  process.env.XDG_CONFIG_HOME = prevXdg;
-  for (const dir of roots) rmSync(dir, { recursive: true, force: true });
-  roots.length = 0;
-});
-
-function readGlobal(): Record<string, unknown> {
-  return JSON.parse(readFileSync(globalConfigPath(), "utf-8"));
-}
-
-describe("config setters — covenant-exact emission (PROTECTED)", () => {
-  it("emits the golden slice for each field", () => {
-    expect(emitVerb(tierVerb)).toEqual({
-      v: "tier",
-      args: ["<path>"],
-      mutates: true,
-      mcp: "config_tier",
-    });
-    expect(emitVerb(channelVerb)).toEqual({
-      v: "channel",
-      args: ["<name>"],
-      mutates: true,
-      mcp: "config_channel",
-    });
-    expect(emitVerb(detailVerb)).toEqual({
-      v: "detail",
-      args: ["<level>"],
-      mutates: true,
-      mcp: "config_detail",
-    });
-  });
-});
-
-describe("config setters — write & reset", () => {
-  it("set writes the field to the GLOBAL config and never boots the store", async () => {
-    const rt: PragmaRuntime = bootRuntime(FLAGS, tmp("pragma-proj-"));
-    const outcome = await executeVerb(tierVerb, { path: "apps/lxd" }, REAL, rt);
-
-    expect(outcome.exitCode).toBe(0);
-    expect(outcome.stdout).toContain("Set tier = apps/lxd");
-    expect(readGlobal().tier).toBe("apps/lxd");
-    // Storeless invariant: a config write never touches the store factory.
-    expect(rt.store.booted).toBe(false);
-  });
-
-  it("channel/detail write their enum value", async () => {
-    const rt = bootRuntime(FLAGS, tmp("pragma-proj-"));
-    await executeVerb(channelVerb, { name: "experimental" }, REAL, rt);
-    await executeVerb(detailVerb, { level: "detailed" }, REAL, rt);
-    const written = readGlobal();
-    expect(written.channel).toBe("experimental");
-    expect(written.detail).toBe("detailed");
-  });
-
-  it("a reset sentinel removes the tier field", async () => {
-    const cwd = tmp("pragma-proj-");
-    await executeVerb(
-      tierVerb,
-      { path: "apps/lxd" },
-      REAL,
-      bootRuntime(FLAGS, cwd),
-    );
-    expect(readGlobal().tier).toBe("apps/lxd");
-
-    const outcome = await executeVerb(
-      tierVerb,
-      { path: "none" },
-      REAL,
-      bootRuntime(FLAGS, cwd),
-    );
-    expect(outcome.stdout).toContain("Reset tier");
-    expect("tier" in readGlobal()).toBe(false);
-  });
-});
-
-describe("config setters — enum rejection", () => {
-  it("the CLI coerce layer rejects a non-member with INVALID_INPUT + validOptions", () => {
-    let caught: unknown;
-    try {
-      extractParams(channelVerb.params, ["bogus"], {});
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(PragmaError);
-    expect((caught as PragmaError).code).toBe("INVALID_INPUT");
-    expect((caught as PragmaError).validOptions).toEqual([...CHANNELS]);
-  });
-
-  it("runField backstops a bad enum value before it reaches disk", () => {
-    const channelSpec = CONFIG_FIELDS.find((s) => s.field === "channel");
-    expect(() =>
-      runField(channelSpec as (typeof CONFIG_FIELDS)[number], {
-        name: "bogus",
-      }),
-    ).toThrow(/Invalid channel/);
-  });
-});
-
-describe("config setters — dry-run plan", () => {
-  it("--dry-run shows the WriteFile plan and writes nothing", async () => {
-    const rt = bootRuntime(FLAGS, tmp("pragma-proj-"));
-    const outcome = await executeVerb(tierVerb, { path: "apps/lxd" }, DRY, rt);
-
-    expect(outcome.exitCode).toBe(0);
-    expect(outcome.stdout).toContain("Write file");
-    expect(outcome.stdout).toContain(globalConfigPath());
-    expect(existsSync(globalConfigPath())).toBe(false);
-  });
-});
-
-describe("config setters — MCP plan-first / confirm parity", () => {
-  it("config_tier returns a plan without confirm, writes with confirm:true", async () => {
-    const cwd = tmp("pragma-proj-");
-    const mcp = await projectMcp([configModule], cwd);
-
-    const plan = await mcp.callTool("config_tier", { path: "apps/lxd" });
-    expect(plan.ok).toBe(true);
-    expect(plan.meta).toMatchObject({ planOnly: true, confirmRequired: true });
-    const planLines = (plan.data as { plan: string[] }).plan;
-    expect(planLines.some((line) => line.includes("Write file"))).toBe(true);
-    expect(existsSync(globalConfigPath())).toBe(false);
-
-    const done = await mcp.callTool("config_tier", {
-      path: "apps/lxd",
-      confirm: true,
-    });
-    await mcp.cleanup();
-
-    expect(done.ok).toBe(true);
-    expect(done.data).toMatchObject({ field: "tier", value: "apps/lxd" });
-    expect(readGlobal().tier).toBe("apps/lxd");
-  });
-});