@elizaos/plugin-xr 2.0.3-beta.5

package/src/__tests__/routes-e2e.test.ts

@@ -0,0 +1,276 @@
+/**
+ * Route-level e2e for plugin-xr (issue #8802).
+ *
+ * Boots the plugin's declared `Route[]` through the REAL production dispatcher
+ * over a loopback `http.createServer`, exercising the real auth gate, query
+ * parsing, param extraction, and `routeHandler` return-shape marshaling — with a
+ * faked `XRSessionService` standing in for the only runtime dependency.
+ *
+ * The XR routes use the canonical return-shape `routeHandler(ctx) -> {status,
+ * headers, body}` contract. In production those routes are dispatched by
+ * `mountRoutesOnHono` -> `dispatchRoute` (packages/agent/src/api/hono-adapter.ts
+ * + dispatch-route.ts), NOT by the legacy `tryHandleRuntimePluginRoute` (which
+ * only invokes the Express-shaped `route.handler`). This test drives the actual
+ * production path: it builds the real Hono app for the runtime and serves its
+ * `fetch` handler over a real TCP socket, asserting on live HTTP responses.
+ *
+ * No mocked `json`/`error` helpers, no shape-only checks: every assertion is on
+ * a real HTTP response delivered over the loopback socket.
+ */
+
+import { Buffer } from "node:buffer";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import type { IAgentRuntime } from "@elizaos/core";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { buildHonoAppForRuntime } from "../../../../packages/agent/src/api/hono-adapter.ts";
+import { xrConnectRoute } from "../routes/xr-connect.ts";
+import { xrSimulatorRoute } from "../routes/xr-simulator-route.ts";
+import { xrStatusRoute } from "../routes/xr-status.ts";
+import { xrViewHostRoute } from "../routes/xr-view-host.ts";
+import { xrViewsRoute } from "../routes/xr-views.ts";
+import { XR_SERVICE_TYPE } from "../services/xr-session-service.ts";
+
+const XR_ROUTES = [
+  xrStatusRoute,
+  xrConnectRoute,
+  xrViewsRoute,
+  xrViewHostRoute,
+  xrSimulatorRoute,
+];
+
+const servers: http.Server[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    servers.map(
+      (server) =>
+        new Promise<void>((resolve) => {
+          server.closeAllConnections?.();
+          server.close(() => resolve());
+        }),
+    ),
+  );
+  servers.length = 0;
+});
+
+interface FakeConnection {
+  id: string;
+  deviceType: string;
+  connectedAt: Date;
+}
+
+function makeRuntime(
+  options: {
+    withService?: boolean;
+    connections?: FakeConnection[];
+    recentFrameIds?: string[];
+  } = {},
+): IAgentRuntime {
+  const { withService = true, connections = [], recentFrameIds = [] } = options;
+
+  const recent = new Set(recentFrameIds);
+  const service = {
+    getConnections: () => connections,
+    getVisionPipeline: () => ({
+      hasRecentFrame: (id: string) => recent.has(id),
+    }),
+  };
+
+  return {
+    routes: XR_ROUTES,
+    getService: (key: string) =>
+      withService && key === XR_SERVICE_TYPE ? service : null,
+    // xrViewHostRoute reads `runtime.port` to build the bundle origin.
+    port: 31337,
+  } as unknown as IAgentRuntime;
+}
+
+/**
+ * Serve the real production Hono app (built from `runtime.routes`) over a real
+ * loopback TCP socket. Bridges the Node request/response to Hono's standard
+ * `fetch` handler so assertions run against genuine HTTP — not an in-memory
+ * handler invocation.
+ */
+async function startServer(
+  runtime: IAgentRuntime,
+  isAuthorized: () => boolean = () => true,
+): Promise<string> {
+  const app = buildHonoAppForRuntime(runtime, { isAuthorized });
+
+  const server = http.createServer((req, res) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk) => chunks.push(chunk as Buffer));
+    req.on("end", () => {
+      void (async () => {
+        const url = `http://127.0.0.1${req.url ?? "/"}`;
+        const method = req.method ?? "GET";
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(req.headers)) {
+          if (value === undefined) continue;
+          headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+        }
+        const hasBody = method !== "GET" && method !== "HEAD";
+        const request = new Request(url, {
+          method,
+          headers,
+          body: hasBody && chunks.length ? Buffer.concat(chunks) : undefined,
+        });
+
+        const response = await app.fetch(request);
+
+        res.statusCode = response.status;
+        response.headers.forEach((value, key) => {
+          res.setHeader(key, value);
+        });
+        const buf = Buffer.from(await response.arrayBuffer());
+        res.end(buf);
+      })();
+    });
+  });
+
+  servers.push(server);
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const { port } = server.address() as AddressInfo;
+  return `http://127.0.0.1:${port}`;
+}
+
+describe("plugin-xr routes (real dispatch)", () => {
+  it("serves /xr/status with the connected-device list when the service is present", async () => {
+    const connectedAt = new Date("2024-01-01T00:00:00.000Z");
+    const base = await startServer(
+      makeRuntime({
+        connections: [
+          { id: "conn-a", deviceType: "quest3", connectedAt },
+          { id: "conn-b", deviceType: "xreal", connectedAt },
+        ],
+        recentFrameIds: ["conn-a"],
+      }),
+    );
+
+    const res = await fetch(`${base}/xr/status`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("application/json");
+
+    const body = (await res.json()) as {
+      connected: boolean;
+      connections: Array<{
+        id: string;
+        deviceType: string;
+        connectedAt: string;
+        hasRecentFrame: boolean;
+      }>;
+    };
+    expect(body.connected).toBe(true);
+    expect(body.connections).toHaveLength(2);
+    expect(body.connections[0]).toEqual({
+      id: "conn-a",
+      deviceType: "quest3",
+      connectedAt: "2024-01-01T00:00:00.000Z",
+      hasRecentFrame: true,
+    });
+    expect(body.connections[1].hasRecentFrame).toBe(false);
+  });
+
+  it("reports connected:false when the service has no active connections", async () => {
+    const base = await startServer(makeRuntime({ connections: [] }));
+    const res = await fetch(`${base}/xr/status`);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      connected: boolean;
+      connections: unknown[];
+    };
+    expect(body.connected).toBe(false);
+    expect(body.connections).toEqual([]);
+  });
+
+  it("returns 503 from /xr/status when the XR service is unavailable", async () => {
+    const base = await startServer(makeRuntime({ withService: false }));
+    const res = await fetch(`${base}/xr/status`);
+    expect(res.status).toBe(503);
+    const body = (await res.json()) as { error: string };
+    expect(body.error).toContain("XR service not running");
+  });
+
+  it("enforces the auth gate on the non-public /xr/status route", async () => {
+    const base = await startServer(makeRuntime(), () => false);
+    const res = await fetch(`${base}/xr/status`);
+    expect(res.status).toBe(401);
+    expect(((await res.json()) as { error: string }).error).toBe(
+      "Unauthorized",
+    );
+  });
+
+  it("serves /xr/connect as an HTML pairing page when authorized", async () => {
+    const base = await startServer(makeRuntime());
+    const res = await fetch(`${base}/xr/connect`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("text/html");
+    const html = await res.text();
+    expect(html).toContain("<!DOCTYPE html>");
+    expect(html).toContain("Connect XR Headset");
+  });
+
+  it("auth-gates /xr/connect when the request is unauthorized", async () => {
+    const base = await startServer(makeRuntime(), () => false);
+    const res = await fetch(`${base}/xr/connect`);
+    expect(res.status).toBe(401);
+  });
+
+  it("serves /xr/views with views, count, and live connections", async () => {
+    const base = await startServer(
+      makeRuntime({
+        connections: [
+          {
+            id: "conn-a",
+            deviceType: "quest3",
+            connectedAt: new Date("2024-01-01T00:00:00.000Z"),
+          },
+        ],
+      }),
+    );
+    const res = await fetch(`${base}/xr/views`);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      views: unknown[];
+      count: number;
+      connections: Array<{ id: string; deviceType: string }>;
+    };
+    expect(Array.isArray(body.views)).toBe(true);
+    expect(body.count).toBe(body.views.length);
+    expect(body.connections).toEqual([{ id: "conn-a", deviceType: "quest3" }]);
+  });
+
+  it("serves /xr/view-host/:id HTML with the extracted view id", async () => {
+    const base = await startServer(makeRuntime());
+    const res = await fetch(`${base}/xr/view-host/wallet`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("text/html");
+    const html = await res.text();
+    expect(html).toContain('data-view-id="wallet"');
+    expect(html).toContain("/api/views/wallet/bundle.js");
+    expect(res.headers.get("content-security-policy")).toContain("esm.sh");
+  });
+
+  it("serves /xr/simulator.js according to whether the emulator bundle is built", async () => {
+    const base = await startServer(makeRuntime());
+    const res = await fetch(`${base}/xr/simulator.js`);
+
+    // The route's two real branches: 200 + JS when the simulator bundle has
+    // been built, 404 + a build hint otherwise. Both are exercised here over
+    // real HTTP; which one fires depends on whether `simulator:build` has run.
+    if (res.status === 200) {
+      expect(res.headers.get("content-type")).toContain(
+        "application/javascript",
+      );
+      const js = await res.text();
+      expect(js.length).toBeGreaterThan(0);
+    } else {
+      expect(res.status).toBe(404);
+      const body = (await res.json()) as { error: string; hint: string };
+      expect(body.error).toContain("Emulator bundle not built");
+      expect(body.hint).toContain("simulator");
+    }
+  });
+});

package/src/__tests__/vision-pipeline.test.ts

@@ -0,0 +1,73 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { ModelType } from "@elizaos/core";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { VisionPipeline } from "../services/vision-pipeline.ts";
+
+function makeRuntime(result = "a desk with a laptop"): IAgentRuntime {
+  return {
+    useModel: vi.fn().mockResolvedValue(result),
+  } as unknown as IAgentRuntime;
+}
+
+const FRAME_HEADER = {
+  type: "frame" as const,
+  ts: Date.now(),
+  width: 1280,
+  height: 720,
+  format: "jpeg" as const,
+};
+
+describe("VisionPipeline", () => {
+  let pipeline: VisionPipeline;
+
+  beforeEach(() => {
+    pipeline = new VisionPipeline();
+  });
+
+  it("stores and retrieves the latest frame", () => {
+    const data = Buffer.alloc(512, 0xff);
+    pipeline.storeFrame("conn1", FRAME_HEADER, data);
+    const frame = pipeline.getLatestFrame("conn1");
+    expect(frame).toBeDefined();
+    expect(frame?.data).toBe(data);
+  });
+
+  it("returns undefined for an unknown connection", () => {
+    expect(pipeline.getLatestFrame("unknown")).toBeUndefined();
+  });
+
+  it("clears frames on clear()", () => {
+    pipeline.storeFrame("conn1", FRAME_HEADER, Buffer.alloc(128));
+    pipeline.clear("conn1");
+    expect(pipeline.getLatestFrame("conn1")).toBeUndefined();
+  });
+
+  it("describeFrame calls IMAGE_DESCRIPTION model with data URL", async () => {
+    const runtime = makeRuntime("a red chair");
+    const data = Buffer.from([0xff, 0xd8, 0xff]); // Minimal JPEG header bytes.
+    pipeline.storeFrame("conn1", FRAME_HEADER, data);
+
+    const result = await pipeline.describeFrame(runtime, "conn1");
+
+    expect(runtime.useModel).toHaveBeenCalledWith(
+      ModelType.IMAGE_DESCRIPTION,
+      expect.objectContaining({
+        imageUrl: expect.stringContaining("data:image/jpeg;base64,"),
+      }),
+    );
+    expect(result).toBe("a red chair");
+  });
+
+  it("describeFrame returns null when no frame exists", async () => {
+    const runtime = makeRuntime();
+    const result = await pipeline.describeFrame(runtime, "conn1");
+    expect(result).toBeNull();
+    expect(runtime.useModel).not.toHaveBeenCalled();
+  });
+
+  it("hasRecentFrame returns true when frame exists", () => {
+    pipeline.storeFrame("conn1", FRAME_HEADER, Buffer.alloc(64));
+    expect(pipeline.hasRecentFrame("conn1")).toBe(true);
+    expect(pipeline.hasRecentFrame("conn2")).toBe(false);
+  });
+});

package/src/__tests__/xr-bundle-coverage.test.ts

@@ -0,0 +1,303 @@
+/**
+ * XR view bundle coverage — validates that every registered XR view plugin
+ * has a built dist/views/bundle.js that is non-empty, valid JavaScript,
+ * and exports the component named in the plugin manifest.
+ *
+ * This is the "real elizaOS plugin infrastructure" layer the simulator tests
+ * cannot reach: it proves that the actual view content (the React component
+ * that loads inside the XR shell) is built, present, and structurally sound.
+ *
+ * What is tested:
+ *   - bundle.js exists for all 18 source-buildable plugins
+ *   - bundle.js is non-empty and contains built view content
+ *   - bundle.js contains the componentExport name from the manifest
+ *   - bundle.js is valid JavaScript (no JSON or HTML accidentally written there)
+ *   - The plugin manifest and bundle agree on componentExport
+ */
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const repoRoot = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../../..",
+);
+
+function readFile(relPath: string): string {
+  return readFileSync(resolve(repoRoot, relPath), "utf8");
+}
+
+function fileExists(relPath: string): boolean {
+  return existsSync(resolve(repoRoot, relPath));
+}
+
+function fileSize(relPath: string): number {
+  const p = resolve(repoRoot, relPath);
+  if (!existsSync(p)) return 0;
+  return statSync(p).size;
+}
+
+function bundlePathFor(pluginDir: string): string {
+  return `${pluginDir}/dist/views/bundle.js`;
+}
+
+function missingBundlePaths(): string[] {
+  return PLUGIN_BUNDLES.map(({ pluginDir }) => bundlePathFor(pluginDir)).filter(
+    (bundlePath) => !fileExists(bundlePath),
+  );
+}
+
+// Parses viewType/id/componentExport/bundlePath from plugin source
+function extractXrViews(
+  source: string,
+): Array<{ id: string; componentExport: string; bundlePath: string }> {
+  const results: Array<{
+    id: string;
+    componentExport: string;
+    bundlePath: string;
+  }> = [];
+  // Match view objects with viewType: "xr"
+  const viewsStart = source.indexOf("views:");
+  if (viewsStart === -1) return results;
+  const arrayStart = source.indexOf("[", viewsStart);
+  if (arrayStart === -1) return results;
+  let depth = 0;
+  let arrayEnd = -1;
+  for (let i = arrayStart; i < source.length; i++) {
+    if (source[i] === "[") depth++;
+    if (source[i] === "]") depth--;
+    if (depth === 0) {
+      arrayEnd = i;
+      break;
+    }
+  }
+  if (arrayEnd === -1) return results;
+  const body = source.slice(arrayStart + 1, arrayEnd);
+  const objects: string[] = [];
+  let start = -1;
+  depth = 0;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    }
+    if (body[i] === "}") {
+      depth--;
+      if (depth === 0 && start !== -1) {
+        objects.push(body.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  for (const obj of objects) {
+    // Source-level mirror of core's `getViewModalities`: a view renders on the
+    // explicit `modalities: [...]` list when present, otherwise the single
+    // `viewType` (default "gui"). The view is an XR view when "xr" is among them.
+    const modalitiesMatch = obj.match(/modalities:\s*\[([^\]]*)\]/);
+    const modalities = modalitiesMatch
+      ? [...modalitiesMatch[1].matchAll(/"([^"]+)"/g)].map((m) => m[1])
+      : [obj.match(/viewType:\s*"([^"]+)"/)?.[1] ?? "gui"];
+    if (!modalities.includes("xr")) continue;
+    const id = obj.match(/\bid:\s*"([^"]+)"/)?.[1];
+    const componentExport = obj.match(/componentExport:\s*"([^"]+)"/)?.[1];
+    const bundlePath = obj.match(/bundlePath:\s*"([^"]+)"/)?.[1];
+    if (id && componentExport && bundlePath) {
+      results.push({ id, componentExport, bundlePath });
+    }
+  }
+  return results;
+}
+
+// The 18 plugin manifests → (plugin directory, manifest path)
+const PLUGIN_BUNDLES: Array<{ pluginDir: string; manifestPath: string }> = [
+  {
+    pluginDir: "plugins/plugin-companion",
+    manifestPath: "plugins/plugin-companion/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-contacts",
+    manifestPath: "plugins/plugin-contacts/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-hyperliquid-app",
+    manifestPath: "plugins/plugin-hyperliquid-app/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-messages",
+    manifestPath: "plugins/plugin-messages/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/app-model-tester",
+    manifestPath: "plugins/app-model-tester/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-phone",
+    manifestPath: "plugins/plugin-phone/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-polymarket-app",
+    manifestPath: "plugins/plugin-polymarket-app/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-shopify-ui",
+    manifestPath: "plugins/plugin-shopify-ui/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-steward-app",
+    manifestPath: "plugins/plugin-steward-app/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-vincent",
+    manifestPath: "plugins/plugin-vincent/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-wallet-ui",
+    manifestPath: "plugins/plugin-wallet-ui/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-feed",
+    manifestPath: "plugins/plugin-feed/src/index.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-app-control",
+    manifestPath: "plugins/plugin-app-control/src/index.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-screenshare",
+    manifestPath: "plugins/plugin-screenshare/src/index.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-task-coordinator",
+    manifestPath: "plugins/plugin-task-coordinator/src/index.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-trajectory-logger",
+    manifestPath: "plugins/plugin-trajectory-logger/src/plugin.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-training",
+    manifestPath: "plugins/plugin-training/src/setup-routes.ts",
+  },
+  {
+    pluginDir: "plugins/plugin-facewear",
+    manifestPath: "plugins/plugin-facewear/src/index.ts",
+  },
+];
+
+describe("XR view bundle coverage — all 18 plugin bundles built and valid", () => {
+  it("declares dist/views/bundle.js for every plugin with an XR view", () => {
+    const missingDeclarations: string[] = [];
+    for (const { pluginDir, manifestPath } of PLUGIN_BUNDLES) {
+      const xrViews = extractXrViews(readFile(manifestPath));
+      if (xrViews.length === 0) {
+        missingDeclarations.push(pluginDir);
+      }
+    }
+    expect(
+      missingDeclarations,
+      "plugins without view build declarations",
+    ).toEqual([]);
+  });
+
+  it("dist/views/bundle.js exists for every plugin with an XR view", () => {
+    expect(
+      missingBundlePaths(),
+      "plugins with missing XR view bundles (run each plugin's build:views)",
+    ).toEqual([]);
+  });
+
+  it("built bundle.js files are non-empty (at least 1 KB of content)", () => {
+    const tooSmall: string[] = [];
+    for (const { pluginDir } of PLUGIN_BUNDLES) {
+      const bundlePath = bundlePathFor(pluginDir);
+      const size = fileSize(bundlePath);
+      if (size < 1024) {
+        tooSmall.push(`${bundlePath}: ${size} bytes`);
+      }
+    }
+    expect(tooSmall, "bundles too small to contain real content").toEqual([]);
+  });
+
+  it("every bundle.js starts with valid JavaScript (not HTML or JSON)", () => {
+    const invalid: string[] = [];
+    for (const { pluginDir } of PLUGIN_BUNDLES) {
+      const bundlePath = bundlePathFor(pluginDir);
+      if (!fileExists(bundlePath)) {
+        invalid.push(`${bundlePath}: missing`);
+        continue;
+      }
+      const first = readFile(bundlePath).trimStart().slice(0, 20);
+      if (first.startsWith("<") || first.startsWith("{")) {
+        invalid.push(`${bundlePath}: starts with "${first}"`);
+      }
+    }
+    expect(invalid, "bundles with invalid content type").toEqual([]);
+  });
+
+  it("every bundle.js contains the componentExport declared in the plugin manifest", () => {
+    const mismatches: string[] = [];
+    for (const { pluginDir, manifestPath } of PLUGIN_BUNDLES) {
+      const bundlePath = bundlePathFor(pluginDir);
+      if (!fileExists(bundlePath)) {
+        mismatches.push(`${bundlePath}: missing`);
+        continue;
+      }
+
+      const manifestSource = readFile(manifestPath);
+      const xrViews = extractXrViews(manifestSource);
+      const bundle = readFile(bundlePath);
+
+      for (const view of xrViews) {
+        // componentExport may be a full path like "@pkg/name#ExportName" — extract just the export name
+        const exportName = view.componentExport.includes("#")
+          ? (view.componentExport.split("#").pop() ?? view.componentExport)
+          : view.componentExport;
+        if (!bundle.includes(exportName)) {
+          mismatches.push(
+            `${pluginDir}: bundle does not contain export "${exportName}" (from manifest componentExport "${view.componentExport}" for view "${view.id}")`,
+          );
+        }
+      }
+    }
+    expect(
+      mismatches,
+      "bundles missing their declared componentExport",
+    ).toEqual([]);
+  });
+
+  it("bundle.js size is consistent with real plugin content", () => {
+    // A real built view bundle should be at least 5 KB. Empty or skeletal files are typically < 1 KB.
+    const tooSmall: string[] = [];
+    for (const { pluginDir } of PLUGIN_BUNDLES) {
+      const bundlePath = `${pluginDir}/dist/views/bundle.js`;
+      const size = fileSize(bundlePath);
+      if (size > 0 && size < 5000) {
+        tooSmall.push(
+          `${bundlePath}: ${size} bytes (expected ≥ 5 KB for real content)`,
+        );
+      }
+    }
+    expect(tooSmall, "suspiciously small bundles").toEqual([]);
+  });
+
+  it("plugin manifest bundlePath uses the standard view bundle location", () => {
+    const mismatches: string[] = [];
+    for (const { pluginDir, manifestPath } of PLUGIN_BUNDLES) {
+      const manifestSource = readFile(manifestPath);
+      const xrViews = extractXrViews(manifestSource);
+      for (const view of xrViews) {
+        if (view.bundlePath !== "dist/views/bundle.js") {
+          mismatches.push(
+            `${pluginDir}: manifest says bundlePath="${view.bundlePath}"`,
+          );
+        }
+      }
+    }
+    expect(
+      mismatches,
+      "manifest bundlePath using non-standard locations",
+    ).toEqual([]);
+  });
+});