@synnaxlabs/client 0.56.2 → 0.57.0

package/src/rack/rack.spec.ts

@@ -1,171 +0,0 @@
-// Copyright 2026 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import { id, TimeStamp, zod } from "@synnaxlabs/x";
-import { describe, expect, it } from "vitest";
-
-import { type rack } from "@/rack";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("Rack", () => {
-  describe("create", () => {
-    it("should create a single rack", async () => {
-      const r = await client.racks.create({ name: "test" });
-      expect(r.key).toBeGreaterThan(0n);
-    });
-    it("should return an error if the rack doesn't have a name", async () => {
-      // @ts-expect-error - Testing for error
-      await expect(client.racks.create({})).rejects.toThrow(zod.ParseError);
-    });
-    it("should create a rack with a custom status", async () => {
-      const customStatus: rack.Status = {
-        key: "",
-        name: "",
-        variant: "success",
-        message: "Custom rack status",
-        description: "Rack is running",
-        time: TimeStamp.now(),
-        details: { rack: 0 },
-      };
-      const r = await client.racks.create({
-        name: "rack-with-status",
-        status: customStatus,
-      });
-      expect(r.key).toBeGreaterThan(0n);
-      const retrieved = await client.racks.retrieve({
-        key: r.key,
-        includeStatus: true,
-      });
-      expect(retrieved.status).toBeDefined();
-      expect(retrieved.status?.variant).toBe("success");
-      expect(retrieved.status?.message).toBe("Custom rack status");
-      expect(retrieved.status?.description).toBe("Rack is running");
-      expect(retrieved.status?.details?.rack).toBe(r.key);
-    });
-  });
-  describe("update", () => {
-    it("should update a rack if the key is provided", async () => {
-      const r = await client.racks.create({ name: "test" });
-      const updated = await client.racks.create({
-        key: r.key,
-        name: "updated",
-      });
-      expect(updated.name).toBe("updated");
-      const retrieved = await client.racks.retrieve({ key: r.key });
-      expect(retrieved.name).toBe("updated");
-    });
-  });
-  describe("retrieve", () => {
-    it("should retrieve a rack by its key", async () => {
-      const r = await client.racks.create({ name: "test" });
-      const retrieved = await client.racks.retrieve({ key: r.key });
-      expect(retrieved.key).toBe(r.key);
-      expect(retrieved.name).toBe("test");
-    });
-    it("should retrieve a rack by its name", async () => {
-      const name = `${TimeStamp.now().toString()}-${Math.random()}`;
-      const r = await client.racks.create({ name });
-      const retrieved = await client.racks.retrieve({ name });
-      expect(retrieved.key).toBe(r.key);
-      expect(retrieved.name).toEqual(name);
-    });
-    it("should retrieve racks by search term", async () => {
-      const prefix = `searchable-rack-${id.create()}`;
-      const names = [`${prefix}-1`, `${prefix}-2`];
-      await client.racks.create(names.map((name) => ({ name })));
-      await expect
-        .poll(async () => {
-          const results = await client.racks.retrieve({ searchTerm: prefix });
-          return results.map((r) => r.name).sort();
-        })
-        .toEqual(names);
-    });
-  });
-  describe("integrations", () => {
-    it("should create a rack with integrations and retrieve them", async () => {
-      const r = await client.racks.create({
-        name: "rack-with-integrations",
-        integrations: ["ni", "opc", "modbus"],
-      });
-      const retrieved = await client.racks.retrieve({ key: r.key });
-      expect(retrieved.integrations).toEqual(["ni", "opc", "modbus"]);
-    });
-    it("should filter racks by integration", async () => {
-      const r1 = await client.racks.create({
-        name: "rack-ni-opc",
-        integrations: ["ni", "opc"],
-      });
-      const r2 = await client.racks.create({
-        name: "rack-modbus-only",
-        integrations: ["modbus"],
-      });
-      const results = await client.racks.retrieve({ integration: "ni" });
-      const keys = results.map((r) => r.key);
-      expect(keys).toContain(r1.key);
-      expect(keys).not.toContain(r2.key);
-    });
-    it("should update integrations on upsert", async () => {
-      const r = await client.racks.create({
-        name: "rack-update-integrations",
-        integrations: ["ni"],
-      });
-      await client.racks.create({
-        key: r.key,
-        name: "rack-update-integrations",
-        integrations: ["ni", "opc", "arc"],
-      });
-      const retrieved = await client.racks.retrieve({ key: r.key });
-      expect(retrieved.integrations).toEqual(["ni", "opc", "arc"]);
-    });
-  });
-  describe("tasks", () => {
-    it("should list the tasks on a rack", async () => {
-      const r = await client.racks.create({ name: "test" });
-      const tasks = await r.listTasks();
-      expect(tasks).toHaveLength(0);
-    });
-  });
-  describe("status", () => {
-    it("should include the rack's status when includeStatus is true", async () => {
-      const r = await client.racks.create({ name: "test" });
-      let status: rack.Status | undefined;
-      await expect
-        .poll(async () => {
-          const retrieved = await client.racks.retrieve({
-            key: r.key,
-            includeStatus: true,
-          });
-          status = retrieved.status;
-          return status;
-        })
-        .toBeDefined();
-      expect(status?.details?.rack).toBe(r.key);
-    });
-    it("should include the status for multiple racks", async () => {
-      const r1 = await client.racks.create({ name: "test1" });
-      const r2 = await client.racks.create({ name: "test2" });
-      let statuses: (rack.Status | undefined)[] = [];
-      await expect
-        .poll(async () => {
-          const retrieved = await client.racks.retrieve({
-            keys: [r1.key, r2.key],
-            includeStatus: true,
-          });
-          statuses = retrieved.map((r) => r.status);
-          return statuses.every((s) => s != null);
-        })
-        .toBe(true);
-      expect(statuses).toHaveLength(2);
-      expect(statuses[0]?.details?.rack).toBe(r1.key);
-      expect(statuses[1]?.details?.rack).toBe(r2.key);
-    });
-  });
-});

package/src/ranger/access.spec.ts

@@ -1,115 +0,0 @@
-// Copyright 2026 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import { TimeRange } from "@synnaxlabs/x";
-import { describe, expect, it } from "vitest";
-
-import { AuthError, NotFoundError } from "@/errors";
-import { ranger } from "@/ranger";
-import { createTestClientWithPolicy } from "@/testutil/access";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("range", () => {
-  describe("access control", () => {
-    it("should deny access when no retrieve policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [],
-        actions: [],
-      });
-      const randomRange = await client.ranges.create({
-        name: "test",
-        timeRange: new TimeRange(1n, 1000n),
-        color: "#E774D0",
-      });
-      await expect(userClient.ranges.retrieve(randomRange.key)).rejects.toThrow(
-        AuthError,
-      );
-    });
-
-    it("should allow the caller to retrieve ranges with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [ranger.ontologyID("")],
-        actions: ["retrieve"],
-      });
-      const randomRange = await client.ranges.create({
-        name: "test",
-        timeRange: new TimeRange(1n, 1000n),
-        color: "#E774D0",
-      });
-      const retrieved = await userClient.ranges.retrieve(randomRange.key);
-      expect(retrieved.key).toBe(randomRange.key);
-      expect(retrieved.name).toBe(randomRange.name);
-    });
-
-    it("should allow the caller to create ranges with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [ranger.ontologyID("")],
-        actions: ["create"],
-      });
-      await userClient.ranges.create({
-        name: "test",
-        timeRange: new TimeRange(1n, 1000n),
-        color: "#E774D0",
-      });
-    });
-
-    it("should deny access when no create policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [ranger.ontologyID("")],
-        actions: [],
-      });
-      await expect(
-        userClient.ranges.create({
-          name: "test",
-          timeRange: new TimeRange(1n, 1000n),
-          color: "#E774D0",
-        }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to delete ranges with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [ranger.ontologyID("")],
-        actions: ["delete"],
-      });
-      const randomRange = await client.ranges.create({
-        name: "test",
-        timeRange: new TimeRange(1n, 1000n),
-        color: "#E774D0",
-      });
-      await userClient.ranges.delete(randomRange.key);
-      await expect(userClient.ranges.retrieve(randomRange.key)).rejects.toThrow(
-        NotFoundError,
-      );
-    });
-
-    it("should deny access when no delete policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [ranger.ontologyID("")],
-        actions: [],
-      });
-      const randomRange = await client.ranges.create({
-        name: "test",
-        timeRange: new TimeRange(1n, 1000n),
-        color: "#E774D0",
-      });
-      await expect(userClient.ranges.delete(randomRange.key)).rejects.toThrow(
-        AuthError,
-      );
-    });
-  });
-});

package/src/ranger/alias/payload.spec.ts

@@ -1,52 +0,0 @@
-// Copyright 2026 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import { describe, expect, it } from "vitest";
-
-import { ranger } from "@/ranger";
-
-describe("alias", () => {
-  describe("ontologyID", () => {
-    it("should create an ontology ID with the correct type and composite key", () => {
-      const id = ranger.alias.ontologyID("range-uuid-123", 42);
-      expect(id.type).toBe("range-alias");
-      expect(id.key).toBe("range-uuid-123---42");
-    });
-
-    it("should match the key format produced by createKey", () => {
-      const rangeKey = "abc-def";
-      const channelKey = 7;
-      const id = ranger.alias.ontologyID(rangeKey, channelKey);
-      const key = ranger.alias.createKey({ range: rangeKey, channel: channelKey });
-      expect(id.key).toBe(key);
-    });
-  });
-
-  describe("TYPE_ONTOLOGY_ID", () => {
-    it("should have the correct type and an empty key", () => {
-      expect(ranger.alias.TYPE_ONTOLOGY_ID.type).toBe("range-alias");
-      expect(ranger.alias.TYPE_ONTOLOGY_ID.key).toBe("");
-    });
-  });
-
-  describe("createKey", () => {
-    it("should create a composite key from range and channel", () => {
-      const key = ranger.alias.createKey({ range: "my-range", channel: 10 });
-      expect(key).toBe("my-range---10");
-    });
-  });
-
-  describe("decodeDeleteChange", () => {
-    it("should decode a composite key into range and channel", () => {
-      const decoded = ranger.alias.decodeDeleteChange("my-range---10");
-      expect(decoded.range).toBe("my-range");
-      expect(decoded.channel).toBe(10);
-    });
-  });
-});

package/src/ranger/ranger.spec.ts

@@ -1,343 +0,0 @@
-// Copyright 2026 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import { DataType, id, math, TimeSpan, TimeStamp, uuid } from "@synnaxlabs/x";
-import { describe, expect, it } from "vitest";
-
-import { NotFoundError } from "@/errors";
-import { ranger } from "@/ranger";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("range", () => {
-  describe("payload", () => {
-    it("should validate the time range", () => {
-      const payload = ranger.payloadZ.parse({
-        name: "My New One Second Range",
-        key: uuid.create(),
-        timeRange: { start: 0, end: 1 },
-      });
-      expect(payload).toBeDefined();
-      expect(payload.timeRange.start.valueOf()).toBe(0n);
-      expect(payload.timeRange.end.valueOf()).toBe(1n);
-    });
-    it("should not validate the time range if it is invalid", () => {
-      const input = {
-        name: "My New One Second Range",
-        key: uuid.create(),
-        timeRange: { start: 1, end: 0 },
-      };
-      expect(() => ranger.payloadZ.parse(input)).toThrow(
-        "Time range start time must be before or equal to time range end time",
-      );
-    });
-    it("should validate the time range if the end is less than or equal to the maximum value of an int64", () => {
-      const input = {
-        name: "range with end greater than max int64",
-        key: uuid.create(),
-        timeRange: { start: 1, end: math.MAX_INT64 },
-      };
-      const payload = ranger.payloadZ.parse(input);
-      expect(payload).toBeDefined();
-      expect(payload.timeRange.end.valueOf()).toBe(math.MAX_INT64);
-    });
-    it("should not validate the time range if the end is greater than the maximum value of an int64", () => {
-      const input = {
-        name: "range with end greater than max int64",
-        key: uuid.create(),
-        timeRange: { start: 1, end: math.MAX_INT64 + 1n },
-      };
-      expect(() => ranger.payloadZ.parse(input)).toThrow(
-        "Time range end time must be less than or equal to the maximum value of an int64",
-      );
-    });
-    it("should validate the time range if start is greater than the minimum value of an int64", () => {
-      const input = {
-        name: "range with start greater than min int64",
-        key: uuid.create(),
-        timeRange: { start: math.MIN_INT64, end: 0 },
-      };
-      const payload = ranger.payloadZ.parse(input);
-      expect(payload).toBeDefined();
-      expect(payload.timeRange.start.valueOf()).toBe(math.MIN_INT64);
-      expect(payload.timeRange.end.valueOf()).toBe(0n);
-    });
-    it("should not validate the time range if start is less than the minimum value of an int64", () => {
-      const input = {
-        name: "range with start less than min int64",
-        key: uuid.create(),
-        timeRange: { start: -1n * 2n ** 63n - 1n, end: 0 },
-      };
-      expect(() => ranger.payloadZ.parse(input)).toThrow(
-        "Time range start time must be greater than or equal to the minimum value of an int64",
-      );
-    });
-  });
-  describe("create", () => {
-    it("should create a single range", async () => {
-      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
-      const range = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange,
-        color: "#E774D0",
-      });
-      expect(range.key).not.toHaveLength(0);
-      expect(timeRange).toEqual(range.timeRange);
-      expect(range.color).toEqual([231, 116, 208, 1]);
-    });
-    it("should create multiple ranges", async () => {
-      const ranges: ranger.New[] = [
-        {
-          name: "My New One Second Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        },
-        {
-          name: "My New Two Second Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(2)),
-        },
-      ];
-      const createdRanges = await client.ranges.create(ranges);
-      expect(createdRanges).toHaveLength(2);
-      expect(createdRanges[0].key).not.toHaveLength(0);
-      expect(createdRanges[1].key).not.toHaveLength(0);
-      expect(createdRanges[0].timeRange).toEqual(ranges[0].timeRange);
-      expect(createdRanges[1].timeRange).toEqual(ranges[1].timeRange);
-    });
-    it("should create a range with a parent", async () => {
-      const parentRange = await client.ranges.create({
-        name: "My New Parent Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      await client.ranges.create(
-        {
-          name: "My New Child Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        },
-        { parent: parentRange.ontologyID },
-      );
-      const children = await client.ontology.retrieveChildren(parentRange.ontologyID);
-      expect(children).toHaveLength(1);
-    });
-  });
-
-  describe("delete", () => {
-    it("should delete a single range", async () => {
-      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
-      const range = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange,
-      });
-      await client.ranges.delete(range.key);
-      await expect(async () => await client.ranges.retrieve(range.key)).rejects.toThrow(
-        NotFoundError,
-      );
-    });
-  });
-
-  describe("rename", () => {
-    it("should rename a single range", async () => {
-      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
-      const range = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange,
-      });
-      await client.ranges.rename(range.key, "My New One Second Range Renamed");
-      const renamed = await client.ranges.retrieve(range.key);
-      expect(renamed.name).toEqual("My New One Second Range Renamed");
-    });
-  });
-
-  describe("retrieve", () => {
-    it("should retrieve a range by key", async () => {
-      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
-      const range = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange,
-      });
-      const retrieved = await client.ranges.retrieve(range.key);
-      expect(retrieved.key).toEqual(range.key);
-      expect(retrieved.timeRange).toEqual(range.timeRange);
-    });
-    it("should retrieve a range by name", async () => {
-      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
-      const range = await client.ranges.create({
-        name: "My New Three Second Range",
-        timeRange,
-      });
-      const retrieved = await client.ranges.retrieve([range.name]);
-      expect(retrieved.length).toBeGreaterThan(0);
-      expect(retrieved[0].name).toEqual(range.name);
-    });
-    it("should retrieve ranges that overlap with the given time range", async () => {
-      const timeRange = TimeStamp.hours(500).spanRange(TimeSpan.seconds(1));
-      const range = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange,
-      });
-      const retrieved = await client.ranges.retrieve(timeRange);
-      expect(retrieved.length).toBeGreaterThan(0);
-      expect(retrieved.map((r) => r.key)).toContain(range.key);
-    });
-    it("should retrieve ranges by search term", async () => {
-      const prefix = `searchable-range-${id.create()}`;
-      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
-      const names = [`${prefix}-1`, `${prefix}-2`];
-      await client.ranges.create(names.map((name) => ({ name, timeRange })));
-      await expect
-        .poll(async () => {
-          const results = await client.ranges.retrieve({ searchTerm: prefix });
-          return results.map((r) => r.name).sort();
-        })
-        .toEqual(names);
-    });
-  });
-
-  describe("retrieveParent", () => {
-    it("should retrieve the parent of a range", async () => {
-      const parentRange = await client.ranges.create({
-        name: "My New Parent Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      const childRange = await client.ranges.create(
-        {
-          name: "My New Child Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        },
-        { parent: parentRange.ontologyID },
-      );
-      const parent = await childRange.retrieveParent();
-      expect(parent?.key).toEqual(parentRange.key);
-    });
-  });
-
-  describe("KV", () => {
-    it("should set, get, and delete a single key", async () => {
-      const rng = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      await rng.kv.set("foo", "bar");
-      const val = await rng.kv.get("foo");
-      expect(val).toEqual("bar");
-      await rng.kv.delete("foo");
-      await expect(async () => await rng.kv.get("foo")).rejects.toThrow(NotFoundError);
-    });
-
-    it("should set and get multiple keys", async () => {
-      const rng = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      await rng.kv.set({ foo: "bar", baz: "qux" });
-      const res = await rng.kv.list();
-      expect(res).toEqual({ foo: "bar", baz: "qux" });
-    });
-
-    it("should list all keys", async () => {
-      const rng = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      await rng.kv.set({ foo: "bar", baz: "qux" });
-      const res = await rng.kv.list();
-      expect(res).toEqual({ foo: "bar", baz: "qux" });
-    });
-  });
-
-  describe("label", () => {
-    it("should set and get a label for the range", async () => {
-      const rng = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      const label = await client.labels.create({
-        name: "My New Label",
-        color: "#E774D0",
-      });
-      await rng.addLabel(label.key);
-      const newRange = await client.ranges.retrieve({
-        keys: [rng.key],
-        includeLabels: true,
-      });
-      expect(newRange[0].labels).toHaveLength(1);
-      expect(newRange[0].labels?.[0]).toEqual(label);
-    });
-  });
-
-  describe("parent", () => {
-    it("should set and get a parent for the range", async () => {
-      const parent = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      const child = await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      await client.ontology.addChildren(parent.ontologyID, child.ontologyID);
-      const newParent = await client.ranges.retrieve({
-        keys: [child.key],
-        includeParent: true,
-      });
-      expect(newParent[0].parent).toEqual(parent.payload);
-    });
-  });
-
-  describe("Alias", () => {
-    describe("set + resolve", () => {
-      it("should set and resolve an alias for the range", async () => {
-        const ch = await client.channels.create({
-          name: id.create(),
-          dataType: DataType.FLOAT32,
-          virtual: true,
-        });
-        const rng = await client.ranges.create({
-          name: "My New One Second Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        });
-        await rng.setAlias(ch.key, "myalias");
-        const resolved = await rng.resolveAlias("myalias");
-        expect(resolved).toEqual(ch.key);
-      });
-    });
-    describe("deleteAlias", () => {
-      it("should remove an alias for the range", async () => {
-        const ch = await client.channels.create({
-          name: id.create(),
-          dataType: DataType.FLOAT32,
-          virtual: true,
-        });
-        const rng = await client.ranges.create({
-          name: "My New One Second Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        });
-        await rng.setAlias(ch.key, "myalias");
-        await rng.deleteAlias(ch.key);
-        expect(await rng.resolveAlias("myalias")).toBeUndefined();
-      });
-    });
-    describe("list", () => {
-      it("should list the aliases for the range", async () => {
-        const ch = await client.channels.create({
-          name: id.create(),
-          dataType: DataType.FLOAT32,
-          virtual: true,
-        });
-        const rng = await client.ranges.create({
-          name: "My New One Second Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        });
-        await rng.setAlias(ch.key, "myalias");
-        const aliases = await rng.listAliases();
-        expect(aliases).toEqual({ [ch.key]: "myalias" });
-      });
-    });
-  });
-});