@dxos/client-services 0.1.35 → 0.1.36

package/src/packlets/tests/client-services.test.ts

@@ -7,13 +7,12 @@ import assert from 'node:assert';
 import waitForExpect from 'wait-for-expect';
 
 import { Trigger } from '@dxos/async';
-import { Client, Space } from '@dxos/client';
-import { raise } from '@dxos/debug';
+import { Client, Space, SpaceProxy } from '@dxos/client';
 import { log } from '@dxos/log';
 import { Invitation, SpaceMember } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test, afterTest } from '@dxos/test';
 
-import { syncItems, TestBuilder } from '../testing';
+import { performInvitation, syncItems, TestBuilder } from '../testing';
 
 // TODO(burdon): Use as set-up for test suite.
 // TODO(burdon): Timeouts and progress callback/events.
@@ -116,48 +115,20 @@ describe('Client services', () => {
       await client1.halo.createIdentity();
     }
 
-    const success1 = new Trigger<Invitation>();
-    const success2 = new Trigger<Invitation>();
-
-    const authenticationCode = new Trigger<string>();
-
-    {
-      const observable1 = client1.halo.createInvitation();
-      observable1.subscribe({
-        onConnecting: (invitation) => {
-          const observable2 = client2.halo.acceptInvitation(invitation);
-          observable2.subscribe({
-            onAuthenticating: async () => {
-              await observable2.authenticate(await authenticationCode.wait());
-            },
-            onSuccess: (invitation: Invitation) => {
-              // TODO(burdon): No device.
-              // expect(guest.identityManager.identity!.authorizedDeviceKeys.size).to.eq(1);
-              success2.wake(invitation);
-            },
-            onError: (err: Error) => raise(new Error(err.message))
-          });
-        },
-        onConnected: (invitation: Invitation) => {
-          assert(invitation.authenticationCode);
-          authenticationCode.wake(invitation.authenticationCode);
-        },
-        onSuccess: (invitation: Invitation) => {
-          success1.wake(invitation);
-        },
-        onCancelled: () => raise(new Error()),
-        onTimeout: (err: Error) => raise(new Error(err.message)),
-        onError: (err: Error) => raise(new Error(err.message))
-      });
-    }
+    const [{ invitation: hostInvitation }, { invitation: guestInvitation }] = await Promise.all(
+      performInvitation({
+        host: client1.halo,
+        guest: client2.halo,
+        options: { authMethod: Invitation.AuthMethod.SHARED_SECRET }
+      })
+    );
 
     // Check same identity.
-    const [invitation1, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
-    expect(invitation1.identityKey).not.to.exist;
-    expect(invitation2.identityKey).to.deep.eq(client1.halo.identity.get()!.identityKey);
-    expect(invitation2.identityKey).to.deep.eq(client2.halo.identity.get()!.identityKey);
-    expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
-    expect(invitation2.state).to.eq(Invitation.State.SUCCESS);
+    expect(hostInvitation!.identityKey).not.to.exist;
+    expect(guestInvitation?.identityKey).to.deep.eq(client1.halo.identity.get()!.identityKey);
+    expect(guestInvitation?.identityKey).to.deep.eq(client2.halo.identity.get()!.identityKey);
+    expect(hostInvitation?.state).to.eq(Invitation.State.SUCCESS);
+    expect(guestInvitation?.state).to.eq(Invitation.State.SUCCESS);
 
     // Check devices.
     // TODO(burdon): Incorrect number of devices.
@@ -194,48 +165,34 @@ describe('Client services', () => {
     afterTest(() => Promise.all([client1.destroy(), server1.close(), peer1.close()]));
     afterTest(() => Promise.all([client2.destroy(), server2.close(), peer2.close()]));
 
-    const success1 = new Trigger<Invitation>();
-    const success2 = new Trigger<Invitation>();
-
-    const space1 = await client1.createSpace();
-    log('createSpace', { key: space1.key });
-    const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
-
-    observable1.subscribe({
-      onConnecting: (invitation) => {
-        const observable2 = client2.acceptInvitation(invitation);
-        observable2.subscribe({
-          onSuccess: (invitation: Invitation) => {
-            success2.wake(invitation);
-          },
-          onError: (err: Error) => raise(err)
-        });
-      },
-      onSuccess: (invitation) => {
-        log('onSuccess');
-        success1.wake(invitation);
-      },
-      onError: (err) => raise(err)
-    });
+    const hostSpace = await client1.createSpace();
+    log('createSpace', { key: hostSpace.key });
+    const [{ invitation: hostInvitation }, { invitation: guestInvitation }] = await Promise.all(
+      performInvitation({
+        host: hostSpace as SpaceProxy,
+        guest: client2,
+        options: { authMethod: Invitation.AuthMethod.SHARED_SECRET }
+      })
+    );
 
-    const [invitation1, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
-    expect(invitation1.spaceKey).to.deep.eq(invitation2.spaceKey);
-    expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
+    expect(guestInvitation?.spaceKey).to.deep.eq(hostSpace.key);
+    expect(hostInvitation?.spaceKey).to.deep.eq(guestInvitation?.spaceKey);
+    expect(hostInvitation?.state).to.eq(Invitation.State.SUCCESS);
 
     log('Invitation complete');
 
     // TODO(burdon): Space should now be available?
     const trigger = new Trigger<Space>();
     await waitForExpect(() => {
-      const space2 = client2.getSpace(invitation2.spaceKey!);
-      assert(space2);
-      expect(space2).to.exist;
-      trigger.wake(space2);
+      const guestSpace = client2.getSpace(guestInvitation!.spaceKey!);
+      assert(guestSpace);
+      expect(guestSpace).to.exist;
+      trigger.wake(guestSpace);
     });
 
-    const space2 = await trigger.wait();
+    const guestSpace = await trigger.wait();
 
-    for (const space of [space1, space2]) {
+    for (const space of [hostSpace, guestSpace]) {
       await waitForExpect(() => {
         expect(space.members.get()).to.deep.equal([
           {
@@ -260,6 +217,6 @@ describe('Client services', () => {
       }, 3_000);
     }
 
-    await syncItems(space1.internal.db, space2.internal.db);
+    await syncItems(hostSpace.internal.db, guestSpace.internal.db);
   });
 });

package/src/packlets/tests/halo-profile.test.ts

@@ -4,12 +4,10 @@
 
 import { expect } from 'chai';
 
-import { Trigger } from '@dxos/async';
 import { Client } from '@dxos/client';
-import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test, afterTest } from '@dxos/test';
 
-import { TestBuilder } from '../testing';
+import { performInvitation, TestBuilder } from '../testing';
 
 describe('Halo', () => {
   test('creates a identity', async () => {
@@ -42,31 +40,7 @@ describe('Halo', () => {
     afterTest(() => client2.destroy());
     await client2.initialize();
 
-    const done1 = new Trigger();
-    const done2 = new Trigger();
-    const invitation = client1.halo.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
-    invitation.subscribe({
-      onConnecting: (invitation) => {
-        const invitation2 = client2.halo.acceptInvitation(invitation, { type: Invitation.Type.INTERACTIVE_TESTING });
-        invitation2.subscribe({
-          onSuccess: () => {
-            done2.wake();
-          },
-          onError: (error) => {
-            throw error;
-          }
-        });
-      },
-      onSuccess: async (invitation) => {
-        done1.wake();
-      },
-      onError: (error) => {
-        throw error;
-      }
-    });
-
-    await done1.wait();
-    await done2.wait();
+    await Promise.all(performInvitation({ host: client1.halo, guest: client2.halo }));
 
     expect(await client1.halo.devices.get()).to.have.lengthOf(2);
     expect(await client2.halo.devices.get()).to.have.lengthOf(2);

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

@@ -0,0 +1,389 @@
+//
+// 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/spaces-invitations.test.ts

@@ -4,13 +4,11 @@
 
 import { expect } from 'chai';
 
-import { Trigger } from '@dxos/async';
-import { Client, Invitation } from '@dxos/client';
-import { raise } from '@dxos/debug';
+import { Client, Invitation, SpaceProxy } from '@dxos/client';
 import { log } from '@dxos/log';
 import { afterTest, describe, test } from '@dxos/test';
 
-import { TestBuilder, testSpace } from '../testing';
+import { performInvitation, TestBuilder, testSpace } from '../testing';
 
 describe('Spaces/invitations', () => {
   test('creates a space and invites a peer', async () => {
@@ -28,36 +26,20 @@ describe('Spaces/invitations', () => {
     afterTest(() => Promise.all([client1.destroy()]));
     afterTest(() => Promise.all([client2.destroy()]));
 
-    const success1 = new Trigger<Invitation>();
-    const success2 = new Trigger<Invitation>();
-
     const space1 = await client1.createSpace();
     log('createSpace', { key: space1.key });
-    const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
-
-    observable1.subscribe({
-      onConnecting: (invitation) => {
-        const observable2 = client2.acceptInvitation(invitation);
-        observable2.subscribe({
-          onSuccess: (invitation: Invitation) => {
-            success2.wake(invitation);
-          },
-          onError: (err: Error) => raise(err)
-        });
-      },
-      onSuccess: (invitation) => {
-        log('onSuccess');
-        success1.wake(invitation);
-      },
-      onError: (err) => raise(err)
-    });
-
-    const [invitation1, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
-    expect(invitation1.spaceKey).to.deep.eq(invitation2.spaceKey);
-    expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
+    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(invitation2.spaceKey!)!.waitUntilReady();
+      const space = await client2.getSpace(guestInvitation!.spaceKey!)!.waitUntilReady();
       await testSpace(space.internal.db);
     }
   });