@oneuptime/common 13.0.6 → 13.0.8

package/Tests/Utils/APIInstanceDispatch.test.ts

@@ -0,0 +1,311 @@
+// Must stay the first import: the client's URLs are built from HOST on load.
+import { DASHBOARD_ORIGIN } from "../UI/Utils/API/DashboardHost";
+import FakeAxiosServer, {
+  FakeTransport,
+  SentRequest,
+} from "../UI/Utils/API/FakeAxiosServer";
+import BaseAPI from "../../UI/Utils/API/API";
+import { IDENTITY_URL } from "../../UI/Config";
+import Navigation from "../../UI/Utils/Navigation";
+import User from "../../UI/Utils/User";
+import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
+import HTTPMethod from "../../Types/API/HTTPMethod";
+import HTTPResponse from "../../Types/API/HTTPResponse";
+import Headers from "../../Types/API/Headers";
+import Hostname from "../../Types/API/Hostname";
+import Protocol from "../../Types/API/Protocol";
+import Route from "../../Types/API/Route";
+import URL from "../../Types/API/URL";
+import APIException from "../../Types/Exception/ApiException";
+import { JSONObject } from "../../Types/JSON";
+import API, { APIRequestOptions, AuthRetryContext } from "../../Utils/API";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import axios from "axios";
+
+jest.mock("axios", () => {
+  // Keep the real helpers (axios.isAxiosError, AxiosError) and fake only the call.
+  return Object.assign(jest.fn(), jest.requireActual("axios"));
+});
+
+/*
+ * AN API INSTANCE IS ITS CLASS.
+ *
+ * `new BaseAPI(protocol, hostname).get(...)` used to forward to `API.get` - the
+ * base class, by name - so a request made through an INSTANCE silently lost
+ * everything its class adds: BaseAPI's refresh-and-replay on a 401, its error
+ * handling, its headers. A lapsed session on such a call surfaced as a bare 401
+ * where the same request made through `BaseAPI.get` recovered on its own.
+ *
+ * The instance methods now dispatch through `this.constructor`. These tests make
+ * the class of the instance observable - which refresh ran, which headers went
+ * out, which error handler saw the failure - for every instance method.
+ */
+
+const mockedAxios: FakeTransport = axios as unknown as FakeTransport;
+
+const REFRESH_URL: string = URL.fromString(IDENTITY_URL.toString())
+  .addRoute("/refresh-token")
+  .toString();
+
+const RESOURCE_URL: string = `${DASHBOARD_ORIGIN}/api/monitor/abc`;
+
+let server: FakeAxiosServer;
+
+let logoutSpy: jest.SpiedFunction<typeof User.logout>;
+
+let navigateSpy: jest.SpiedFunction<typeof Navigation.navigate>;
+
+type InstanceMethod = "get" | "delete" | "head" | "put" | "patch";
+
+const INSTANCE_METHODS: Array<[InstanceMethod, HTTPMethod]> = [
+  ["get", HTTPMethod.GET],
+  ["delete", HTTPMethod.DELETE],
+  ["head", HTTPMethod.HEAD],
+  ["put", HTTPMethod.PUT],
+  ["patch", HTTPMethod.PATCH],
+];
+
+type CallInstanceFunction = (
+  api: API,
+  method: InstanceMethod,
+  options: APIRequestOptions,
+) => Promise<HTTPResponse<JSONObject> | HTTPErrorResponse>;
+
+const callInstance: CallInstanceFunction = async (
+  api: API,
+  method: InstanceMethod,
+  options: APIRequestOptions,
+): Promise<HTTPResponse<JSONObject> | HTTPErrorResponse> => {
+  switch (method) {
+    case "get":
+      return await api.get<JSONObject>(options);
+    case "delete":
+      return await api.delete<JSONObject>(options);
+    case "head":
+      return await api.head<JSONObject>(options);
+    case "put":
+      return await api.put<JSONObject>(options);
+    case "patch":
+      return await api.patch<JSONObject>(options);
+  }
+};
+
+beforeEach(() => {
+  localStorage.clear();
+
+  server = new FakeAxiosServer(mockedAxios);
+
+  logoutSpy = jest.spyOn(User, "logout").mockImplementation((): void => {});
+
+  navigateSpy = jest
+    .spyOn(Navigation, "navigate")
+    .mockImplementation((): void => {});
+
+  jest
+    .spyOn(Navigation, "getCurrentRoute")
+    .mockReturnValue(new Route("/dashboard/home"));
+});
+
+afterEach(() => {
+  mockedAxios.mockReset();
+  jest.restoreAllMocks();
+  localStorage.clear();
+});
+
+describe("A BaseAPI instance refreshes a lapsed session like BaseAPI does", () => {
+  test.each(INSTANCE_METHODS)(
+    "instance %s: a 401 is refreshed and replayed",
+    async (method: InstanceMethod, httpMethod: HTTPMethod) => {
+      server
+        .on(httpMethod, RESOURCE_URL, [
+          { status: 401 },
+          { status: 200, data: { replayed: true } },
+        ])
+        .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+      const api: BaseAPI = new BaseAPI(
+        Protocol.HTTPS,
+        new Hostname("oneuptime.example.com"),
+      );
+
+      const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
+        await callInstance(api, method, {
+          url: URL.fromString(RESOURCE_URL),
+          data: { name: "db" },
+        });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.data).toEqual({ replayed: true });
+      expect(server.requestsTo(HTTPMethod.POST, REFRESH_URL)).toHaveLength(1);
+      expect(server.requestsTo(httpMethod, RESOURCE_URL)).toHaveLength(2);
+      expect(logoutSpy).not.toHaveBeenCalled();
+    },
+  );
+
+  test("an instance made with BaseAPI.fromURL is a BaseAPI, and refreshes too", async () => {
+    server
+      .on(HTTPMethod.GET, RESOURCE_URL, [{ status: 401 }, { status: 200 }])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+    const api: BaseAPI = BaseAPI.fromURL(
+      URL.fromString(`${DASHBOARD_ORIGIN}/api`),
+    );
+
+    expect(api).toBeInstanceOf(BaseAPI);
+
+    const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await api.get<JSONObject>({ url: URL.fromString(RESOURCE_URL) });
+
+    expect(response.statusCode).toBe(200);
+    expect(server.requestsTo(HTTPMethod.POST, REFRESH_URL)).toHaveLength(1);
+  });
+
+  test("a refused refresh through an instance ends in BaseAPI's logout, not a silent 401", async () => {
+    server
+      .on(HTTPMethod.GET, RESOURCE_URL, [{ status: 401 }])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 401 }]);
+
+    const api: BaseAPI = new BaseAPI(
+      Protocol.HTTPS,
+      new Hostname("oneuptime.example.com"),
+    );
+
+    const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await api.get<JSONObject>({ url: URL.fromString(RESOURCE_URL) });
+
+    expect(response.statusCode).toBe(401);
+    expect(logoutSpy).toHaveBeenCalled();
+    expect(navigateSpy).toHaveBeenCalledWith(new Route("/accounts/login"), {
+      forceNavigate: true,
+    });
+  });
+
+  test("BaseAPI's own headers go out on instance requests", async () => {
+    localStorage.setItem("project-permissions-hash", "hash-123");
+
+    server.on(HTTPMethod.GET, RESOURCE_URL, [{ status: 200 }]);
+
+    await new BaseAPI(
+      Protocol.HTTPS,
+      new Hostname("oneuptime.example.com"),
+    ).get({ url: URL.fromString(RESOURCE_URL) });
+
+    expect(server.sent[0]!.headers["project-permissions-hash"]).toBe(
+      "hash-123",
+    );
+  });
+});
+
+describe("The most-derived class is the one that answers", () => {
+  const STATUS_PAGE_REFRESH_URL: string =
+    "https://status.example.com/status-page-identity-api/refresh-token/abc";
+
+  class StatusPageLikeAPI extends BaseAPI {
+    protected static override getRefreshSessionUrl(): URL | null {
+      return URL.fromString(STATUS_PAGE_REFRESH_URL);
+    }
+
+    protected static override getSessionName(): string {
+      return "status-page-abc";
+    }
+  }
+
+  test("an instance of a BaseAPI subclass refreshes at the subclass's URL", async () => {
+    server
+      .on(HTTPMethod.PUT, RESOURCE_URL, [{ status: 401 }, { status: 200 }])
+      .on(HTTPMethod.POST, STATUS_PAGE_REFRESH_URL, [{ status: 200 }]);
+
+    const api: StatusPageLikeAPI = new StatusPageLikeAPI(
+      Protocol.HTTPS,
+      new Hostname("status.example.com"),
+    );
+
+    const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await api.put<JSONObject>({ url: URL.fromString(RESOURCE_URL) });
+
+    expect(response.statusCode).toBe(200);
+    expect(
+      server.requestsTo(HTTPMethod.POST, STATUS_PAGE_REFRESH_URL),
+    ).toHaveLength(1);
+    expect(server.requestsTo(HTTPMethod.POST, REFRESH_URL)).toHaveLength(0);
+  });
+
+  test("an instance of a plain API subclass uses that subclass's headers, refresh and error handler", async () => {
+    const handled: Array<number> = [];
+    const refreshedFor: Array<string> = [];
+
+    class CustomAPI extends API {
+      public static override getDefaultHeaders(): Headers {
+        return { "x-client": "custom" };
+      }
+
+      public static override handleError(
+        error: HTTPErrorResponse | APIException,
+      ): HTTPErrorResponse | APIException {
+        if (error instanceof HTTPErrorResponse) {
+          handled.push(error.statusCode);
+        }
+
+        return error;
+      }
+
+      protected static override async tryRefreshAuth(
+        context: AuthRetryContext,
+      ): Promise<boolean> {
+        refreshedFor.push(context.request.url.toString());
+        return true;
+      }
+    }
+
+    server.on(HTTPMethod.PATCH, RESOURCE_URL, [
+      { status: 401 },
+      { status: 500 },
+    ]);
+
+    const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await new CustomAPI(
+        Protocol.HTTPS,
+        new Hostname("oneuptime.example.com"),
+      ).patch<JSONObject>({ url: URL.fromString(RESOURCE_URL) });
+
+    expect(response.statusCode).toBe(500);
+    expect(refreshedFor).toEqual([RESOURCE_URL]);
+    expect(handled).toEqual([500]);
+
+    for (const request of server.sent) {
+      expect(request.headers["x-client"]).toBe("custom");
+    }
+  });
+});
+
+describe("A plain API instance is still the plain client", () => {
+  /*
+   * The bare client has no session to refresh and no login page to go to.
+   * Server-side callers and deliberately-bare browser calls (a status page's
+   * logout) depend on a 401 coming straight back.
+   */
+  test.each(INSTANCE_METHODS)(
+    "instance %s: a 401 comes straight back, with no refresh and no logout",
+    async (method: InstanceMethod, httpMethod: HTTPMethod) => {
+      server.on(httpMethod, RESOURCE_URL, [{ status: 401 }]);
+
+      const api: API = new API(
+        Protocol.HTTPS,
+        new Hostname("oneuptime.example.com"),
+      );
+
+      const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
+        await callInstance(api, method, { url: URL.fromString(RESOURCE_URL) });
+
+      expect(response).toBeInstanceOf(HTTPErrorResponse);
+      expect(response.statusCode).toBe(401);
+      expect(
+        server.sent.map((request: SentRequest): string => {
+          return request.url;
+        }),
+      ).toEqual([RESOURCE_URL]);
+      expect(logoutSpy).not.toHaveBeenCalled();
+      expect(navigateSpy).not.toHaveBeenCalled();
+    },
+  );
+});

package/Tests/Utils/HTTPResponseBodyReader.test.ts

@@ -1,9 +1,10 @@
-import { describe, expect, test } from "@jest/globals";
+import { describe, expect, jest, test } from "@jest/globals";
 import BadDataException from "../../Types/Exception/BadDataException";
 import HTTPResponseBodyReader, {
   HTTPResponseBodyBudget,
 } from "../../Utils/HTTPResponseBodyReader";
 import { Readable } from "stream";
+import type { Mock, MockInstance } from "jest-mock";
 
 const read: (
   body: AsyncIterable<unknown>,
@@ -14,6 +15,7 @@ const read: (
     headers?: unknown;
     isHeadResponse?: boolean;
     maximumResponseBytes?: number;
+    signal?: AbortSignal;
   },
 ) => Promise<Buffer> = async (
   body: AsyncIterable<unknown>,
@@ -24,6 +26,7 @@ const read: (
     headers?: unknown;
     isHeadResponse?: boolean;
     maximumResponseBytes?: number;
+    signal?: AbortSignal;
   } = {},
 ): Promise<Buffer> => {
   return await HTTPResponseBodyReader.read(body, {
@@ -33,10 +36,194 @@ const read: (
     headers: options.headers,
     isHeadResponse: options.isHeadResponse,
     maximumResponseBytes: options.maximumResponseBytes,
+    signal: options.signal,
   });
 };
 
 describe("HTTPResponseBodyReader", () => {
+  test.each([200, 400, 503])(
+    "destroys a stalled status %s body and removes its listener on abort",
+    async (statusCode: number) => {
+      const controller: AbortController = new AbortController();
+      const addListener: MockInstance<AbortSignal["addEventListener"]> =
+        jest.spyOn(controller.signal, "addEventListener");
+      const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+        jest.spyOn(controller.signal, "removeEventListener");
+      const body: Readable = new Readable({ read: (): void => {} });
+      const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10);
+      const pending: Promise<Buffer> = read(body, budget, {
+        statusCode: statusCode,
+        signal: controller.signal,
+      });
+      const rejected: Promise<void> = expect(pending).rejects.toMatchObject({
+        name: "AbortError",
+      });
+
+      controller.abort();
+      await rejected;
+
+      expect(body.destroyed).toBe(true);
+      expect(budget.remainingBytes).toBe(10);
+      expect(removeListener).toHaveBeenCalledWith(
+        "abort",
+        addListener.mock.calls[0]![1],
+      );
+    },
+  );
+
+  test("destroys an already-aborted body without starting its iterator", async () => {
+    const controller: AbortController = new AbortController();
+    controller.abort();
+    const body: Readable = Readable.from([Buffer.from("unread")]);
+    const iterate: MockInstance<Readable[typeof Symbol.asyncIterator]> =
+      jest.spyOn(body, Symbol.asyncIterator);
+    const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+      jest.spyOn(controller.signal, "removeEventListener");
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10);
+
+    await expect(
+      read(body, budget, { signal: controller.signal }),
+    ).rejects.toMatchObject({ name: "AbortError" });
+
+    expect(iterate).not.toHaveBeenCalled();
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(10);
+    expect(removeListener).toHaveBeenCalledTimes(1);
+  });
+
+  test("removes its abort listener after a successful duck-typed stream", async () => {
+    const controller: AbortController = new AbortController();
+    const destroy: Mock<() => void> = jest.fn<() => void>();
+    const body: AsyncIterable<Buffer> & { destroy: () => void } = {
+      async *[Symbol.asyncIterator](): ReturnType<
+        AsyncIterable<Buffer>[typeof Symbol.asyncIterator]
+      > {
+        yield Buffer.from("data");
+      },
+      destroy: destroy,
+    };
+    const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+      jest.spyOn(controller.signal, "removeEventListener");
+
+    await expect(
+      read(body, new HTTPResponseBodyBudget(10), { signal: controller.signal }),
+    ).resolves.toEqual(Buffer.from("data"));
+    controller.abort();
+
+    expect(removeListener).toHaveBeenCalledTimes(1);
+    expect(destroy).not.toHaveBeenCalled();
+  });
+
+  test("removes its abort listener after the source iterator fails", async () => {
+    const controller: AbortController = new AbortController();
+    const destroy: Mock<() => void> = jest.fn<() => void>();
+    const sourceError: Error = new Error("source failed");
+    const body: AsyncIterable<Buffer> & { destroy: () => void } = {
+      [Symbol.asyncIterator](): AsyncIterator<Buffer> {
+        return {
+          next: (): Promise<IteratorResult<Buffer>> => {
+            return Promise.reject(sourceError);
+          },
+        };
+      },
+      destroy: destroy,
+    };
+    const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+      jest.spyOn(controller.signal, "removeEventListener");
+
+    await expect(
+      read(body, new HTTPResponseBodyBudget(10), { signal: controller.signal }),
+    ).rejects.toBe(sourceError);
+    controller.abort();
+
+    expect(removeListener).toHaveBeenCalledTimes(1);
+    expect(destroy).not.toHaveBeenCalled();
+  });
+
+  test.each(["declared length", "streamed length", "exhausted budget"])(
+    "removes its abort listener after rejecting %s",
+    async (failure: string) => {
+      const controller: AbortController = new AbortController();
+      const removeListener: MockInstance<AbortSignal["removeEventListener"]> =
+        jest.spyOn(controller.signal, "removeEventListener");
+      const body: Readable = Readable.from([Buffer.from("12345")]);
+      const destroy: MockInstance<Readable["destroy"]> = jest.spyOn(
+        body,
+        "destroy",
+      );
+      const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(
+        failure === "exhausted budget" ? 0 : 4,
+      );
+
+      await expect(
+        read(body, budget, {
+          signal: controller.signal,
+          headers:
+            failure === "declared length" ? { "content-length": "5" } : {},
+        }),
+      ).rejects.toBeInstanceOf(BadDataException);
+      const destroyCalls: number = destroy.mock.calls.length;
+      controller.abort();
+
+      expect(body.destroyed).toBe(true);
+      expect(removeListener).toHaveBeenCalledTimes(1);
+      expect(destroy).toHaveBeenCalledTimes(destroyCalls);
+    },
+  );
+
+  test("settles on abort without destroy and never charges a late chunk", async () => {
+    const controller: AbortController = new AbortController();
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10);
+    let resolveWaiting: () => void = (): void => {};
+    const waiting: Promise<void> = new Promise((resolve: () => void) => {
+      resolveWaiting = resolve;
+    });
+    let resolveLateChunk: (
+      chunk: IteratorResult<Buffer>,
+    ) => void = (): void => {};
+    const lateChunk: Promise<IteratorResult<Buffer>> = new Promise(
+      (resolve: (chunk: IteratorResult<Buffer>) => void) => {
+        resolveLateChunk = resolve;
+      },
+    );
+    let nextCalls: number = 0;
+    const body: AsyncIterable<Buffer> = {
+      [Symbol.asyncIterator](): AsyncIterator<Buffer> {
+        return {
+          next: (): Promise<IteratorResult<Buffer>> => {
+            nextCalls++;
+            if (nextCalls === 1) {
+              return Promise.resolve({
+                done: false,
+                value: Buffer.from("abc"),
+              });
+            }
+            resolveWaiting();
+            return lateChunk;
+          },
+        };
+      },
+    };
+    const pending: Promise<Buffer> = read(body, budget, {
+      signal: controller.signal,
+    });
+    const rejected: Promise<void> = expect(pending).rejects.toMatchObject({
+      name: "AbortError",
+    });
+
+    await waiting;
+    expect(budget.remainingBytes).toBe(7);
+    controller.abort();
+    await rejected;
+    resolveLateChunk({ done: false, value: Buffer.from("late") });
+    await new Promise<void>((resolve: () => void) => {
+      setTimeout(resolve, 0);
+    });
+
+    expect(budget.remainingBytes).toBe(7);
+    expect(nextCalls).toBe(2);
+  });
+
   test("charges sequential responses against one cumulative byte budget", async () => {
     const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(6);
 

package/Tests/Utils/Metrics/MetricEventScopeUrl.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "@jest/globals";
+import MetricExplorerUrl, {
+  MetricExplorerUrlParam,
+  SerializedMetricQuery,
+} from "../../../Utils/Metrics/MetricExplorerUrl";
+import { buildQueryConfigsFromSerializedQueries } from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/MetricConfigReconstruct";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+
+const RESOURCE_ID: string = "11111111-0000-4000-8000-000000000001";
+
+function roundTrip(config: MetricQueryConfigData): MetricQueryConfigData {
+  const params: Record<string, string> =
+    MetricExplorerUrl.buildQueryParamsFromMetricViewData({
+      queryConfigs: [config],
+      formulaConfigs: [],
+      startAndEndDate: null,
+    });
+  const parsed: Array<SerializedMetricQuery> =
+    MetricExplorerUrl.parseMetricQueriesParam(
+      params[MetricExplorerUrlParam.MetricQueries]!,
+    );
+  expect(parsed).toHaveLength(1);
+  return buildQueryConfigsFromSerializedQueries(parsed)[0]!;
+}
+
+describe("metric event scope URL round trip", () => {
+  test("preserves RUM identity without adding identifiers to the metric attribute filter", () => {
+    const config: MetricQueryConfigData = {
+      metricQueryData: {
+        filterData: {
+          metricName: "browser.page_load",
+          attributes: { environment: "prod" },
+        },
+      },
+      eventScope: {
+        primaryEntityId: new Includes([RESOURCE_ID]),
+        primaryEntityType: ServiceType.RealUserMonitor,
+      },
+    };
+    const rebuilt: MetricQueryConfigData = roundTrip(config);
+    expect(rebuilt.eventScope?.["primaryEntityId"]).toBeInstanceOf(Includes);
+    expect(
+      (rebuilt.eventScope?.["primaryEntityId"] as Includes).values,
+    ).toEqual([RESOURCE_ID]);
+    expect(rebuilt.eventScope?.["primaryEntityType"]).toBe(
+      ServiceType.RealUserMonitor,
+    );
+    expect(rebuilt.metricQueryData.filterData.attributes).toEqual({
+      environment: "prod",
+    });
+    expect(roundTrip(rebuilt).eventScope).toEqual(rebuilt.eventScope);
+  });
+
+  test("preserves all opaque inventory memberships through a share and reload", () => {
+    const rebuilt: MetricQueryConfigData = roundTrip({
+      metricQueryData: { filterData: { metricName: "cpu.usage" } },
+      eventScope: { entityKeys: new Includes(["entity-a", "entity-b"]) },
+    });
+    expect((rebuilt.eventScope?.["entityKeys"] as Includes).values).toEqual([
+      "entity-a",
+      "entity-b",
+    ]);
+    expect(rebuilt.metricQueryData.filterData.attributes).toEqual({});
+  });
+
+  test("keeps an explicitly empty scope distinct from a project-wide view", () => {
+    const rebuilt: MetricQueryConfigData = roundTrip({
+      metricQueryData: { filterData: { metricName: "", attributes: {} } },
+      eventScope: {},
+    });
+    expect(rebuilt.eventScope).toEqual({});
+  });
+
+  test.each([
+    null,
+    "bad-scope",
+    { entityKeys: { nested: "invalid" } },
+    { entityKeys: { _type: "Includes", value: [] } },
+  ])(
+    "sanitizing malformed scope %p cannot erase the explicit scope boundary",
+    (eventScope: unknown) => {
+      const parsed: Array<SerializedMetricQuery> =
+        MetricExplorerUrl.parseMetricQueriesParam(
+          JSON.stringify([{ metricName: "cpu.usage", eventScope }]),
+        );
+      expect(parsed[0]?.eventScope).toEqual({});
+      expect(
+        buildQueryConfigsFromSerializedQueries(parsed)[0]?.eventScope,
+      ).toEqual({});
+    },
+  );
+
+  test("older unscoped views stay unscoped", () => {
+    const rebuilt: MetricQueryConfigData = roundTrip({
+      metricQueryData: { filterData: { metricName: "cpu.usage" } },
+    });
+    expect(rebuilt.eventScope).toBeUndefined();
+  });
+});