matrix-rust-sdk/bindings/matrix-sdk-crypto-nodejs/tests/identifiers.test.js

const {
    UserId,
    DeviceId,
    DeviceKeyId,
    DeviceKeyAlgorithm,
    DeviceKeyAlgorithmName,
    RoomId,
    ServerName,
} = require("../");

describe(UserId.name, () => {
    test("cannot be invalid", () => {
        expect(() => {
            new UserId("@foobar");
        }).toThrow();
    });

    const user = new UserId("@foo:bar.org");

    test("localpart is present", () => {
        expect(user.localpart).toStrictEqual("foo");
    });

    test("server name is present", () => {
        expect(user.serverName).toBeInstanceOf(ServerName);
    });

    test("user ID is not historical", () => {
        expect(user.isHistorical()).toStrictEqual(false);
    });

    test("can read the user ID as a string", () => {
        expect(user.toString()).toStrictEqual("@foo:bar.org");
    });
});

describe(DeviceId.name, () => {
    const device = new DeviceId("foo");

    test("can read the device ID as a string", () => {
        expect(device.toString()).toStrictEqual("foo");
    });
});

describe(DeviceKeyId.name, () => {
    for (const deviceKey of [
        {
            name: "ed25519",
            id: "ed25519:foobar",
            algorithmName: DeviceKeyAlgorithmName.Ed25519,
            algorithm: "ed25519",
            deviceId: "foobar",
        },

        {
            name: "curve25519",
            id: "curve25519:foobar",
            algorithmName: DeviceKeyAlgorithmName.Curve25519,
            algorithm: "curve25519",
            deviceId: "foobar",
        },

        {
            name: "signed curve25519",
            id: "signed_curve25519:foobar",
            algorithmName: DeviceKeyAlgorithmName.SignedCurve25519,
            algorithm: "signed_curve25519",
            deviceId: "foobar",
        },

        {
            name: "unknown",
            id: "hello:foobar",
            algorithmName: DeviceKeyAlgorithmName.Unknown,
            algorithm: "hello",
            deviceId: "foobar",
        },
    ]) {
        test(`${deviceKey.name} algorithm`, () => {
            const dk = new DeviceKeyId(deviceKey.id);

            expect(dk.algorithm.name).toStrictEqual(deviceKey.algorithmName);
            expect(dk.algorithm.toString()).toStrictEqual(deviceKey.algorithm);
            expect(dk.deviceId.toString()).toStrictEqual(deviceKey.deviceId);
            expect(dk.toString()).toStrictEqual(deviceKey.id);
        });
    }
});

describe("DeviceKeyAlgorithmName", () => {
    test("has the correct variants", () => {
        expect(DeviceKeyAlgorithmName.Ed25519).toStrictEqual(0);
        expect(DeviceKeyAlgorithmName.Curve25519).toStrictEqual(1);
        expect(DeviceKeyAlgorithmName.SignedCurve25519).toStrictEqual(2);
        expect(DeviceKeyAlgorithmName.Unknown).toStrictEqual(3);
    });
});

describe(RoomId.name, () => {
    test("cannot be invalid", () => {
        expect(() => {
            new RoomId("!foo");
        }).toThrow();
    });

    const room = new RoomId("!foo:bar.org");

    test("localpart is present", () => {
        expect(room.localpart).toStrictEqual("foo");
    });

    test("server name is present", () => {
        expect(room.serverName).toBeInstanceOf(ServerName);
    });

    test("can read the room ID as string", () => {
        expect(room.toString()).toStrictEqual("!foo:bar.org");
    });
});

describe(ServerName.name, () => {
    test("cannot be invalid", () => {
        expect(() => {
            new ServerName("@foobar");
        }).toThrow();
    });

    test("host is present", () => {
        expect(new ServerName("foo.org").host).toStrictEqual("foo.org");
    });

    test("port can be optional", () => {
        expect(new ServerName("foo.org").port).toStrictEqual(null);
        expect(new ServerName("foo.org:1234").port).toStrictEqual(1234);
    });

    test("server is not an IP literal", () => {
        expect(new ServerName("foo.org").isIpLiteral()).toStrictEqual(false);
    });
});