@dxos/client-services 0.1.41 → 0.1.45-next.45667d4

package/src/packlets/tests/invitations.test.ts

@@ -1,389 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-import chai, { expect } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import assert from 'node:assert';
-import waitForExpect from 'wait-for-expect';
-
-import { asyncChain, asyncTimeout } from '@dxos/async';
-import { Client, InvitationsProxy, Space, SpaceProxy } from '@dxos/client';
-import { ConnectionState, Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { afterTest, describe, test } from '@dxos/test';
-
-import { InvitationsServiceImpl } from '../invitations';
-import { LocalClientServices, ServiceContext } from '../services';
-import { DataSpace } from '../spaces';
-import {
-  createIdentity,
-  createPeers,
-  performInvitation,
-  PerformInvitationParams,
-  Result,
-  TestBuilder
-} from '../testing';
-
-chai.use(chaiAsPromised);
-
-const closeAfterTest = async (peer: ServiceContext) => {
-  afterTest(() => peer.close());
-  return peer;
-};
-
-const successfulInvitation = async ({
-  host,
-  guest,
-  hostResult: { invitation: hostInvitation, error: hostError },
-  guestResult: { invitation: guestInvitation, error: guestError }
-}: {
-  host: ServiceContext;
-  guest: ServiceContext;
-  hostResult: Result;
-  guestResult: Result;
-}) => {
-  expect(hostError).to.be.undefined;
-  expect(guestError).to.be.undefined;
-  expect(hostInvitation?.state).to.eq(Invitation.State.SUCCESS);
-  expect(guestInvitation?.state).to.eq(Invitation.State.SUCCESS);
-
-  switch (hostInvitation!.kind) {
-    case Invitation.Kind.SPACE:
-      expect(guestInvitation!.spaceKey).to.exist;
-      expect(hostInvitation!.spaceKey).to.deep.eq(guestInvitation!.spaceKey);
-      break;
-
-    case Invitation.Kind.DEVICE:
-      expect(hostInvitation!.identityKey).not.to.exist;
-      expect(guestInvitation!.identityKey).to.deep.eq(host.identityManager.identity!.identityKey);
-      expect(guestInvitation!.identityKey).to.deep.eq(guest.identityManager.identity!.identityKey);
-
-      // Check devices.
-      // TODO(burdon): Incorrect number of devices.
-      await waitForExpect(() => {
-        expect(host.identityManager.identity!.authorizedDeviceKeys.size).to.eq(2);
-        expect(guest.identityManager.identity!.authorizedDeviceKeys.size).to.eq(2);
-      });
-      // console.log(host.identityManager.identity!.authorizedDeviceKeys.size);
-      // console.log(guest.identityManager.identity!.authorizedDeviceKeys.size);
-      break;
-  }
-};
-
-const testSuite = (getParams: () => PerformInvitationParams, getPeers: () => [ServiceContext, ServiceContext]) => {
-  test('no auth', async () => {
-    const [host, guest] = getPeers();
-    const [hostResult, guestResult] = await Promise.all(performInvitation(getParams()));
-    await successfulInvitation({ host, guest, hostResult, guestResult });
-  });
-
-  test('with shared secret', async () => {
-    const [host, guest] = getPeers();
-    const params = getParams();
-    const [hostResult, guestResult] = await Promise.all(
-      performInvitation({
-        ...params,
-        options: { ...params.options, authMethod: Invitation.AuthMethod.SHARED_SECRET }
-      })
-    );
-
-    await successfulInvitation({ host, guest, hostResult, guestResult });
-  });
-
-  test('invalid auth code', async () => {
-    const [host, guest] = getPeers();
-    const params = getParams();
-    let attempt = 1;
-    const [hostResult, guestResult] = await Promise.all(
-      performInvitation({
-        ...params,
-        options: { ...params.options, authMethod: Invitation.AuthMethod.SHARED_SECRET },
-        hooks: {
-          guest: {
-            onReady: (invitation) => {
-              if (attempt === 0) {
-                // Force retry.
-                void invitation.authenticate('000000');
-                attempt++;
-                return true;
-              }
-
-              return false;
-            }
-          }
-        }
-      })
-    );
-
-    expect(attempt).to.eq(1);
-    await successfulInvitation({ host, guest, hostResult, guestResult });
-  });
-
-  test('max auth code retries', async () => {
-    const params = getParams();
-    let attempt = 0;
-    const [hostPromise, guestPromise] = performInvitation({
-      ...params,
-      options: { ...params.options, authMethod: Invitation.AuthMethod.SHARED_SECRET },
-      hooks: {
-        guest: {
-          onReady: (invitation) => {
-            // Force retry.
-            void invitation.authenticate('000000');
-            attempt++;
-            return true;
-          }
-        }
-      }
-    });
-    const guestResult = await guestPromise;
-
-    expect(attempt).to.eq(3);
-    expect(guestResult.error).to.exist;
-    await expect(asyncTimeout(hostPromise, 100)).to.be.rejected;
-  });
-
-  test('invitation timeout', async () => {
-    const params = getParams();
-    const [hostResult, guestResult] = await Promise.all(
-      performInvitation({
-        ...params,
-        options: { ...params.options, authMethod: Invitation.AuthMethod.SHARED_SECRET, timeout: 1 }
-      })
-    );
-
-    expect(hostResult.invitation?.state).to.eq(Invitation.State.TIMEOUT);
-    expect(guestResult.invitation?.state).to.eq(Invitation.State.TIMEOUT);
-  });
-
-  test('host cancels invitation', async () => {
-    const params = getParams();
-    const [hostResult, guestResult] = await Promise.all(
-      performInvitation({
-        ...params,
-        options: { ...params.options, authMethod: Invitation.AuthMethod.SHARED_SECRET },
-        hooks: {
-          host: {
-            onConnected: (invitation) => {
-              void invitation.cancel();
-              return true;
-            }
-          }
-        }
-      })
-    );
-
-    expect(hostResult.invitation?.state).to.eq(Invitation.State.CANCELLED);
-    expect(guestResult.error).to.exist;
-  });
-
-  test('guest cancels invitation', async () => {
-    const params = getParams();
-    const [hostPromise, guestPromise] = performInvitation({
-      ...params,
-      options: { ...params.options, authMethod: Invitation.AuthMethod.SHARED_SECRET },
-      hooks: {
-        guest: {
-          onConnected: (invitation) => {
-            void invitation.cancel();
-            return true;
-          }
-        }
-      }
-    });
-    const guestResult = await guestPromise;
-
-    expect(guestResult.invitation?.state).to.eq(Invitation.State.CANCELLED);
-    await expect(asyncTimeout(hostPromise, 100)).to.be.rejected;
-  });
-
-  test('network error', async () => {
-    const [, guest] = getPeers();
-    const params = getParams();
-    const [hostPromise, guestPromise] = performInvitation({
-      ...params,
-      options: { ...params.options, authMethod: Invitation.AuthMethod.SHARED_SECRET },
-      hooks: {
-        guest: {
-          onConnected: () => {
-            void guest.networkManager.setConnectionState(ConnectionState.OFFLINE);
-            return true;
-          }
-        }
-      }
-    });
-    const guestResult = await guestPromise;
-
-    expect(guestResult.error).to.exist;
-    await expect(asyncTimeout(hostPromise, 100)).to.be.rejected;
-
-    // Test cleanup fails if the guest is offline.
-    await guest.networkManager.setConnectionState(ConnectionState.ONLINE);
-  });
-};
-
-describe('Invitations', () => {
-  describe('ServiceContext', () => {
-    describe('space', () => {
-      let host: ServiceContext;
-      let guest: ServiceContext;
-      let space: DataSpace;
-
-      beforeEach(async () => {
-        const peers = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
-        host = peers[0];
-        guest = peers[1];
-        space = await host.dataSpaceManager!.createSpace();
-      });
-
-      testSuite(
-        () => ({
-          host,
-          guest,
-          options: { kind: Invitation.Kind.SPACE, spaceKey: space.key }
-        }),
-        () => [host, guest]
-      );
-    });
-
-    describe('device', () => {
-      let host: ServiceContext;
-      let guest: ServiceContext;
-
-      beforeEach(async () => {
-        const peers = await asyncChain<ServiceContext>([closeAfterTest])(createPeers(2));
-        host = peers[0];
-        guest = peers[1];
-        await host.createIdentity();
-      });
-
-      testSuite(
-        () => ({ host, guest, options: { kind: Invitation.Kind.DEVICE } }),
-        () => [host, guest]
-      );
-    });
-  });
-
-  describe('InvitationsProxy', () => {
-    describe('space', () => {
-      let hostContext: ServiceContext;
-      let guestContext: ServiceContext;
-      let host: InvitationsProxy;
-      let guest: InvitationsProxy;
-      let space: DataSpace;
-
-      beforeEach(async () => {
-        const peers = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
-        hostContext = peers[0];
-        guestContext = peers[1];
-        assert(hostContext.dataSpaceManager);
-        assert(guestContext.dataSpaceManager);
-
-        const hostService = new InvitationsServiceImpl(hostContext.invitations, (invitation) =>
-          hostContext.getInvitationHandler(invitation)
-        );
-        const guestService = new InvitationsServiceImpl(guestContext.invitations, (invitation) =>
-          guestContext.getInvitationHandler(invitation)
-        );
-
-        space = await hostContext.dataSpaceManager.createSpace();
-        host = new InvitationsProxy(hostService, () => ({ kind: Invitation.Kind.SPACE, spaceKey: space.key }));
-        guest = new InvitationsProxy(guestService, () => ({ kind: Invitation.Kind.SPACE }));
-
-        afterTest(() => space.close());
-      });
-
-      testSuite(
-        () => ({ host, guest }),
-        () => [hostContext, guestContext]
-      );
-    });
-
-    describe('device', () => {
-      let hostContext: ServiceContext;
-      let guestContext: ServiceContext;
-      let host: InvitationsProxy;
-      let guest: InvitationsProxy;
-
-      beforeEach(async () => {
-        const peers = await asyncChain<ServiceContext>([closeAfterTest])(createPeers(2));
-        hostContext = peers[0];
-        guestContext = peers[1];
-
-        await hostContext.identityManager.createIdentity();
-
-        const hostService = new InvitationsServiceImpl(hostContext.invitations, (invitation) =>
-          hostContext.getInvitationHandler(invitation)
-        );
-
-        const guestService = new InvitationsServiceImpl(guestContext.invitations, (invitation) =>
-          guestContext.getInvitationHandler(invitation)
-        );
-
-        host = new InvitationsProxy(hostService, () => ({ kind: Invitation.Kind.DEVICE }));
-        guest = new InvitationsProxy(guestService, () => ({ kind: Invitation.Kind.DEVICE }));
-      });
-
-      testSuite(
-        () => ({ host, guest }),
-        () => [hostContext, guestContext]
-      );
-    });
-  });
-
-  describe('HaloProxy', () => {
-    let host: Client;
-    let guest: Client;
-
-    beforeEach(async () => {
-      const testBuilder = new TestBuilder();
-
-      host = new Client({ services: testBuilder.createLocal() });
-      guest = new Client({ services: testBuilder.createLocal() });
-      await host.initialize();
-      await guest.initialize();
-
-      await host.halo.createIdentity({ displayName: 'Peer' });
-
-      afterTest(() => Promise.all([host.destroy()]));
-      afterTest(() => Promise.all([guest.destroy()]));
-    });
-
-    testSuite(
-      () => ({ host: host.halo, guest: guest.halo }),
-      () => [
-        (host.services as LocalClientServices).host._serviceContext,
-        (guest.services as LocalClientServices).host._serviceContext
-      ]
-    );
-  });
-
-  describe('EchoProxy', () => {
-    let host: Client;
-    let guest: Client;
-    let space: Space;
-    beforeEach(async () => {
-      const testBuilder = new TestBuilder();
-
-      host = new Client({ services: testBuilder.createLocal() });
-      guest = new Client({ services: testBuilder.createLocal() });
-      await host.initialize();
-      await guest.initialize();
-      await host.halo.createIdentity({ displayName: 'Peer 1' });
-      await guest.halo.createIdentity({ displayName: 'Peer 2' });
-
-      afterTest(() => Promise.all([host.destroy()]));
-      afterTest(() => Promise.all([guest.destroy()]));
-
-      space = await host.createSpace();
-    });
-
-    testSuite(
-      () => ({ host: space as SpaceProxy, guest }),
-      () => [
-        (host.services as LocalClientServices).host._serviceContext,
-        (guest.services as LocalClientServices).host._serviceContext
-      ]
-    );
-  });
-});

package/src/packlets/tests/shared-worker.test.ts

@@ -1,92 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import chai, { expect } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-
-import { sleep } from '@dxos/async';
-import { Client, ClientServicesProxy, fromIFrame } from '@dxos/client';
-import { Config } from '@dxos/config';
-import { createLinkedPorts } from '@dxos/rpc';
-import { describe, test, afterTest } from '@dxos/test';
-import { MaybePromise, Provider } from '@dxos/util';
-
-import { TestBuilder } from '../testing';
-import { IFrameProxyRuntime, WorkerRuntime } from '../vault';
-
-chai.use(chaiAsPromised);
-
-const setup = (getConfig: Provider<MaybePromise<Config>>) => {
-  const workerRuntime = new WorkerRuntime(getConfig);
-
-  const systemPorts = createLinkedPorts();
-  const appPorts = createLinkedPorts();
-  const shellPorts = createLinkedPorts();
-  void workerRuntime.createSession({
-    systemPort: systemPorts[1],
-    appPort: appPorts[1],
-    shellPort: shellPorts[1]
-  });
-  const clientProxy = new IFrameProxyRuntime({
-    config: getConfig,
-    systemPort: systemPorts[0],
-    shellPort: shellPorts[0]
-  });
-  const client = new Client({
-    services: new ClientServicesProxy(appPorts[0])
-  });
-
-  return { workerRuntime, clientProxy, client };
-};
-
-describe('Shared worker', () => {
-  test('client connects to the worker', async () => {
-    const { workerRuntime, clientProxy, client } = setup(() => new Config({}));
-
-    await Promise.all([workerRuntime.start(), clientProxy.open('*'), client.initialize()]);
-
-    await client.halo.createIdentity();
-  });
-
-  test('initialization errors get propagated to the client', async () => {
-    const { workerRuntime, clientProxy, client } = setup(async () => {
-      await sleep(1);
-      throw new Error('Test error');
-    });
-
-    const promise = Promise.all([
-      // This error should be propagated to client.initialize() call.
-      workerRuntime.start().catch(() => {}),
-      clientProxy.open('*').catch(() => {})
-    ]);
-
-    await expect(client.initialize()).to.be.rejectedWith('Test error');
-
-    await promise;
-  });
-
-  test('host can be initialized after client', async () => {
-    const { workerRuntime, clientProxy, client } = setup(async () => {
-      await sleep(5);
-      return new Config({});
-    });
-
-    await Promise.all([workerRuntime.start(), clientProxy.open('*'), client.initialize()]);
-
-    await client.halo.createIdentity();
-  });
-
-  // TODO(burdon): Browser-only.
-  test.skip('creates client with remote iframe', async () => {
-    const testBuilder = new TestBuilder();
-
-    const client = new Client({
-      services: fromIFrame(testBuilder.config)
-    });
-
-    await client.initialize();
-    afterTest(() => client.destroy());
-    expect(client.initialized).to.be.true;
-  });
-});

package/src/packlets/tests/spaces-invitations.test.ts

@@ -1,46 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-import { expect } from 'chai';
-
-import { Client, Invitation, SpaceProxy } from '@dxos/client';
-import { log } from '@dxos/log';
-import { afterTest, describe, test } from '@dxos/test';
-
-import { performInvitation, TestBuilder, testSpace } from '../testing';
-
-describe('Spaces/invitations', () => {
-  test('creates a space and invites a peer', async () => {
-    const testBuilder = new TestBuilder();
-
-    const client1 = new Client({ services: testBuilder.createLocal() });
-    const client2 = new Client({ services: testBuilder.createLocal() });
-    await client1.initialize();
-    await client2.initialize();
-    await client1.halo.createIdentity({ displayName: 'Peer 1' });
-    await client2.halo.createIdentity({ displayName: 'Peer 2' });
-
-    log('initialized');
-
-    afterTest(() => Promise.all([client1.destroy()]));
-    afterTest(() => Promise.all([client2.destroy()]));
-
-    const space1 = await client1.createSpace();
-    log('createSpace', { key: space1.key });
-    const [{ invitation: hostInvitation }, { invitation: guestInvitation }] = await Promise.all(
-      performInvitation({
-        host: space1 as SpaceProxy,
-        guest: client2
-      })
-    );
-    expect(guestInvitation?.spaceKey).to.deep.eq(space1.key);
-    expect(hostInvitation?.spaceKey).to.deep.eq(guestInvitation?.spaceKey);
-    expect(hostInvitation?.state).to.eq(Invitation.State.SUCCESS);
-
-    {
-      const space = await client2.getSpace(guestInvitation!.spaceKey!)!.waitUntilReady();
-      await testSpace(space.internal.db);
-    }
-  });
-});

package/src/packlets/tests/spaces.test.ts

@@ -1,147 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-import { expect } from 'chai';
-
-import { asyncTimeout, Trigger } from '@dxos/async';
-import { Client, Space, SpaceProxy } from '@dxos/client';
-import { Config } from '@dxos/config';
-import { log } from '@dxos/log';
-import { createStorage, StorageType } from '@dxos/random-access-storage';
-import { describe, test, afterTest } from '@dxos/test';
-
-import { performInvitation, TestBuilder, testSpace } from '../testing';
-
-describe('Spaces', () => {
-  test('creates a space', async () => {
-    const testBuilder = new TestBuilder();
-    testBuilder.storage = createStorage({ type: StorageType.RAM });
-
-    const client = new Client({ services: testBuilder.createLocal() });
-    await client.initialize();
-    afterTest(() => client.destroy());
-
-    await client.halo.createIdentity({ displayName: 'test-user' });
-
-    // TODO(burdon): Extend basic queries.
-    const space = await client.createSpace();
-    await testSpace(space.internal.db);
-
-    expect(space.members.get()).to.be.length(1);
-  });
-
-  // TODO(dmaretskyi): Test suit for different conditions/storages.
-  test.skip('creates a space on webfs', async () => {
-    const testBuilder = new TestBuilder();
-    // testBuilder.storage = createStorage({ type: StorageType.WEBFS });
-
-    const host = testBuilder.createClientServicesHost();
-    await host.open();
-    afterTest(() => host.close());
-    const [client, server] = testBuilder.createClientServer(host);
-    void server.open();
-    afterTest(() => server.close());
-    await client.initialize();
-    afterTest(() => client.destroy());
-
-    await client.halo.createIdentity({ displayName: 'test-user' });
-
-    // TODO(burdon): Extend basic queries.
-    const space = await client.createSpace();
-    await testSpace(space.internal.db);
-
-    expect(space.members.get()).to.be.length(1);
-  });
-
-  test('creates a space re-opens the client', async () => {
-    const testBuilder = new TestBuilder(new Config({ version: 1 }));
-    testBuilder.storage = createStorage({ type: StorageType.RAM });
-
-    const client = new Client({ services: testBuilder.createLocal() });
-    await client.initialize();
-    await client.halo.createIdentity({ displayName: 'test-user' });
-
-    let itemId: string;
-    {
-      // TODO(burdon): API (client.echo/client.halo).
-      const space = await client.createSpace();
-      const {
-        objectsUpdated: [item]
-      } = await testSpace(space.internal.db);
-      itemId = item.id;
-      expect(space.members.get()).to.be.length(1);
-    }
-
-    await client.destroy();
-
-    log.break();
-
-    await client.initialize();
-
-    {
-      // TODO(dmaretskyi): Replace with helper?.
-      const spaceTrigger = new Trigger<Space>();
-      if (client.spaces.get()[0]) {
-        spaceTrigger.wake(client.spaces.get()[0]);
-      }
-      client.spaces.subscribe(() => {
-        if (client.spaces.get()[0]) {
-          spaceTrigger.wake(client.spaces.get()[0]);
-        }
-      });
-      const space = await spaceTrigger.wait({ timeout: 500 });
-      await space.waitUntilReady();
-
-      const item = space.internal.db._itemManager.getItem(itemId)!;
-      expect(item).to.exist;
-    }
-
-    await client.destroy();
-  });
-
-  test('post and listen to messages', async () => {
-    const testBuilder = new TestBuilder();
-
-    const client1 = new Client({ services: testBuilder.createLocal() });
-    const client2 = new Client({ services: testBuilder.createLocal() });
-    await client1.initialize();
-    await client2.initialize();
-    await client1.halo.createIdentity({ displayName: 'Peer 1' });
-    await client2.halo.createIdentity({ displayName: 'Peer 2' });
-
-    log('initialized');
-
-    afterTest(() => Promise.all([client1.destroy()]));
-    afterTest(() => Promise.all([client2.destroy()]));
-
-    const space1 = await client1.createSpace();
-    log('createSpace', { key: space1.key });
-    const [, { invitation: guestInvitation }] = await Promise.all(
-      performInvitation({ host: space1 as SpaceProxy, guest: client2 })
-    );
-    const space2 = await client2.getSpace(guestInvitation!.spaceKey!)!.waitUntilReady();
-
-    const hello = new Trigger();
-    {
-      space2.listen('hello', (message) => {
-        expect(message.channelId).to.include('hello');
-        expect(message.payload).to.deep.contain({ data: 'Hello, world!' });
-        hello.wake();
-      });
-      await space1.postMessage('hello', { data: 'Hello, world!' });
-    }
-
-    const goodbye = new Trigger();
-    {
-      space2.listen('goodbye', (message) => {
-        expect(message.channelId).to.include('goodbye');
-        expect(message.payload).to.deep.contain({ data: 'Goodbye' });
-        goodbye.wake();
-      });
-      await space1.postMessage('goodbye', { data: 'Goodbye' });
-    }
-
-    await asyncTimeout(Promise.all([hello.wait(), goodbye.wait()]), 200);
-  });
-});