@dxos/client-services 0.1.30-next.7c60cd3 → 0.1.30

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

@@ -0,0 +1,252 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { expect } from 'chai';
+import assert from 'node:assert';
+import waitForExpect from 'wait-for-expect';
+
+import { Trigger } from '@dxos/async';
+import { Space } from '@dxos/client';
+import { raise } from '@dxos/debug';
+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';
+
+// TODO(burdon): Use as set-up for test suite.
+// TODO(burdon): Timeouts and progress callback/events.
+
+describe('Client services', () => {
+  test('creates client with remote server', async () => {
+    const testBuilder = new TestBuilder();
+
+    const peer = testBuilder.createClientServicesHost();
+    await peer.open();
+    afterTest(() => peer.close());
+
+    const [client, server] = testBuilder.createClientServer(peer);
+    void server.open();
+    afterTest(() => server.close());
+
+    await client.initialize();
+    afterTest(() => client.destroy());
+    expect(client.initialized).to.be.true;
+  });
+
+  test('creates clients with multiple peers connected via memory transport', async () => {
+    const testBuilder = new TestBuilder();
+
+    {
+      const peer1 = testBuilder.createClientServicesHost();
+      await peer1.open();
+      afterTest(() => peer1.close());
+
+      {
+        const [client1a, server1a] = testBuilder.createClientServer(peer1);
+        void server1a.open();
+        await client1a.initialize();
+        afterTest(() => Promise.all([client1a.destroy(), server1a.close()]));
+        expect(client1a.initialized).to.be.true;
+
+        await client1a.halo.createIdentity();
+      }
+      {
+        const [client1b, server1b] = testBuilder.createClientServer(peer1);
+        void server1b.open();
+        await client1b.initialize();
+        afterTest(() => Promise.all([client1b.destroy(), server1b.close()]));
+        expect(client1b.initialized).to.be.true;
+
+        // TODO(burdon): Test profile is available.
+      }
+    }
+
+    {
+      const peer2 = testBuilder.createClientServicesHost();
+      await peer2.open();
+      afterTest(() => peer2.close());
+
+      {
+        const [client2a, server2a] = testBuilder.createClientServer(peer2);
+        void server2a.open();
+        await client2a.initialize();
+        afterTest(() => Promise.all([client2a.destroy(), server2a.close()]));
+        expect(client2a.initialized).to.be.true;
+
+        await client2a.halo.createIdentity();
+      }
+    }
+  });
+
+  test('creates identity and invites peer', async () => {
+    const testBuilder = new TestBuilder();
+
+    const peer1 = testBuilder.createClientServicesHost();
+    const peer2 = testBuilder.createClientServicesHost();
+
+    await peer1.open();
+    await peer2.open();
+
+    const [client1, server1] = testBuilder.createClientServer(peer1);
+    const [client2, server2] = testBuilder.createClientServer(peer2);
+
+    // Don't wait (otherwise will block).
+    {
+      void server1.open();
+      void server2.open();
+
+      await client1.initialize();
+      await client2.initialize();
+
+      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))
+      });
+    }
+
+    // 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!.identityKey);
+    expect(invitation2.identityKey).to.deep.eq(client2.halo.identity!.identityKey);
+    expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
+    expect(invitation2.state).to.eq(Invitation.State.SUCCESS);
+
+    // Check devices.
+    // TODO(burdon): Incorrect number of devices.
+    await waitForExpect(async () => {
+      expect(client1.halo.getDevices()).to.have.lengthOf(2);
+      expect(client2.halo.getDevices()).to.have.lengthOf(2);
+    });
+  });
+
+  test('synchronizes data between two spaces after completing invitation', async () => {
+    const testBuilder = new TestBuilder();
+
+    const peer1 = testBuilder.createClientServicesHost();
+    const peer2 = testBuilder.createClientServicesHost();
+
+    await peer1.open();
+    await peer2.open();
+
+    const [client1, server1] = testBuilder.createClientServer(peer1);
+    const [client2, server2] = testBuilder.createClientServer(peer2);
+
+    // Don't wait (otherwise will block).
+    {
+      void server1.open();
+      void server2.open();
+
+      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(), 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.echo.createSpace();
+    log('createSpace', { key: space1.key });
+    const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
+
+    observable1.subscribe({
+      onConnecting: (invitation) => {
+        const observable2 = client2.echo.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);
+
+    log('Invitation complete');
+
+    // TODO(burdon): Space should now be available?
+    const trigger = new Trigger<Space>();
+    await waitForExpect(() => {
+      const space2 = client2.echo.getSpace(invitation2.spaceKey!);
+      assert(space2);
+      expect(space2).to.exist;
+      trigger.wake(space2);
+    });
+
+    const space2 = await trigger.wait();
+
+    for (const space of [space1, space2]) {
+      await waitForExpect(() => {
+        expect(space.getMembers()).to.deep.equal([
+          {
+            identity: {
+              identityKey: client1.halo.identity!.identityKey,
+              profile: {
+                displayName: 'Peer 1'
+              }
+            },
+            presence: SpaceMember.PresenceState.ONLINE
+          },
+          {
+            identity: {
+              identityKey: client2.halo.identity!.identityKey,
+              profile: {
+                displayName: 'Peer 2'
+              }
+            },
+            presence: SpaceMember.PresenceState.ONLINE
+          }
+        ]);
+      }, 3_000);
+    }
+
+    await syncItems(space1.internal.db, space2.internal.db);
+  });
+});

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

@@ -0,0 +1,143 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { Client } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { Runtime } from '@dxos/protocols/proto/dxos/config';
+import { createStorage, StorageType } from '@dxos/random-access-storage';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder } from '../testing';
+
+chai.use(chaiAsPromised);
+
+describe('Client', () => {
+  test('creates client with embedded services', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    await client.initialize();
+    afterTest(() => client.destroy());
+    expect(client.initialized).to.be.true;
+  });
+
+  test('initialize and destroy multiple times', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    await client.initialize();
+    await client.initialize();
+    expect(client.initialized).to.be.true;
+
+    await client.destroy();
+    await client.destroy();
+    expect(client.initialized).to.be.false;
+  });
+
+  test('closes and reopens', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    await client.initialize();
+    expect(client.initialized).to.be.true;
+
+    await client.destroy();
+    expect(client.initialized).to.be.false;
+
+    await client.initialize();
+    expect(client.initialized).to.be.true;
+
+    await client.destroy();
+    expect(client.initialized).to.be.false;
+  });
+
+  test('create space before identity', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    await client.initialize();
+    afterTest(() => client.destroy());
+    await expect(client.echo.createSpace()).to.eventually.be.rejectedWith(
+      'This device has no HALO identity available.'
+    );
+  }).timeout(1_000);
+
+  // TODO(burdon): Memory store is reset on close (feed store is closed).
+  test.skip('creates identity then resets the memory storage', async () => {
+    const config = new Config();
+    const testBuilder = new TestBuilder(config);
+    await runTest(testBuilder);
+  });
+
+  test('creates identity then resets the node storage', async () => {
+    const config = await getNodeConfig(true);
+    const testBuilder = new TestBuilder(config);
+    await runTest(testBuilder);
+  }).onlyEnvironments('nodejs');
+});
+
+// TODO(burdon): Factor out.
+const getNodeConfig = async (reset = false) => {
+  const path = '/tmp/dxos/client/test/packlets/test';
+  if (reset) {
+    // TODO(burdon): Reconcile StorageType and ConfigProto types.
+    const storage = createStorage({ type: StorageType.NODE, root: path });
+    await storage.reset();
+  }
+
+  // TODO(burdon): Update API.
+  // TODO(burdon): Config not required if remote.
+  return new Config({
+    version: 1,
+    runtime: {
+      client: {
+        storage: {
+          persistent: true,
+          storageType: Runtime.Client.Storage.StorageDriver.NODE,
+          path // TODO(burdon): Change to root.
+        }
+      }
+    }
+  });
+};
+
+// TODO(burdon): Develop test-suite.
+const runTest = async (testBuilder: TestBuilder) => {
+  const client = new Client({ services: testBuilder.createLocal() });
+  const displayName = 'test-user';
+
+  {
+    // Create identity.
+    await client.initialize();
+    expect(client.halo.identity).not.to.exist;
+    const identity = await client.halo.createIdentity({ displayName });
+    expect(client.halo.identity).to.deep.eq(identity);
+    await client.destroy();
+  }
+
+  {
+    // Should throw trying to create another.
+    await client.initialize();
+    expect(client.halo.identity).to.exist;
+    // TODO(burdon): Error type.
+    await expect(client.halo.createIdentity({ displayName })).to.be.rejected;
+  }
+
+  {
+    // Reset storage.
+    // TODO(burdon): Reset doesn't work in memory (create store test).
+    await client.reset();
+  }
+
+  {
+    // Start again.
+    await client.initialize();
+    await client.halo.createIdentity({ displayName });
+    expect(client.halo.identity).to.exist;
+    await client.destroy();
+  }
+};

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

@@ -0,0 +1,94 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+// @dxos/test platform=nodejs
+
+import { expect } from 'chai';
+
+import { asyncTimeout, Trigger } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { verifyPresentation } from '@dxos/credentials';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder } from '../testing';
+
+describe('Halo', () => {
+  test('presentation', async () => {
+    const config = new Config({
+      version: 1,
+      runtime: {
+        client: {
+          storage: {
+            persistent: true, // TODO(burdon): Note required if path set.
+            path: `/tmp/dxos/client/${PublicKey.random().toHex()}`
+          }
+        }
+      }
+    });
+
+    const testBuilder = new TestBuilder(config);
+
+    {
+      const client = new Client({ config, services: testBuilder.createLocal() });
+      afterTest(() => client.destroy());
+      await client.initialize();
+
+      await client.halo.createIdentity({ displayName: 'test-user' });
+      expect(client.halo.identity).exist;
+
+      const credentials = client.halo.queryCredentials({ type: 'dxos.halo.credentials.AdmittedFeed' });
+      const trigger = new Trigger();
+      credentials.subscribe({
+        onUpdate: (credentials) => {
+          if (credentials.length >= 2) {
+            trigger.wake();
+          }
+        },
+        onError: (err) => log.catch(err)
+      });
+      await asyncTimeout(trigger.wait(), 500);
+
+      const nonce = new Uint8Array([0, 0, 0, 0]);
+      const presentation = await client.halo.presentCredentials({
+        ids: credentials.value!.map(({ id }) => id!),
+        nonce: new Uint8Array([0, 0, 0, 0])
+      });
+      expect(presentation.credentials?.length).to.equal(2);
+      expect(await verifyPresentation(presentation)).to.deep.equal({ kind: 'pass' });
+      expect(presentation.proofs![0].nonce).to.deep.equal(nonce);
+    }
+  });
+
+  test('query credentials', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client.destroy());
+    await client.initialize();
+
+    await client.halo.createIdentity({ displayName: 'test-user' });
+    expect(client.halo.identity).exist;
+
+    const credentials = client.halo.queryCredentials({ type: 'dxos.halo.credentials.AdmittedFeed' });
+
+    const trigger = new Trigger();
+    credentials.subscribe({
+      onUpdate: () => {
+        if (credentials.value?.length === 2) {
+          trigger.wake();
+        }
+      },
+      onError: (error) => {
+        throw error;
+      }
+    });
+    await asyncTimeout(trigger.wait(), 500);
+
+    expect(credentials.value!.every((cred) => cred.subject.assertion['@type'] === 'dxos.halo.credentials.AdmittedFeed'))
+      .to.be.true;
+  });
+});

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

@@ -0,0 +1,53 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+// @dxos/test platform=nodejs
+
+import { expect } from 'chai';
+
+import { waitForCondition } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { PublicKey } from '@dxos/keys';
+import { describe, test, afterTest } from '@dxos/test';
+
+import { TestBuilder } from '../testing';
+
+describe('Halo', () => {
+  test('reopens with persistent storage', async () => {
+    const config = new Config({
+      version: 1,
+      runtime: {
+        client: {
+          storage: {
+            persistent: true, // TODO(burdon): Note required if path set.
+            path: `/tmp/dxos/client/${PublicKey.random().toHex()}`
+          }
+        }
+      }
+    });
+
+    const testBuilder = new TestBuilder(config);
+
+    {
+      const client = new Client({ config, services: testBuilder.createLocal() });
+      afterTest(() => client.destroy());
+      await client.initialize();
+
+      await client.halo.createIdentity({ displayName: 'test-user' });
+      expect(client.halo.identity).exist;
+    }
+
+    {
+      const client = new Client({ config, services: testBuilder.createLocal() });
+      afterTest(() => client.destroy());
+      await client.initialize();
+
+      await waitForCondition(() => !!client.halo.identity);
+      expect(client.halo.identity).exist;
+      // TODO(burdon): Not working.
+      // expect(client.halo.identity!.displayName).to.eq('test-user');
+    }
+  });
+});

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

@@ -0,0 +1,74 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+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';
+
+describe('Halo', () => {
+  test('creates a identity', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client.destroy());
+    await client.initialize();
+
+    await client.halo.createIdentity({ displayName: 'test-user' });
+    expect(client.halo.identity).exist;
+
+    expect(await client.halo.getDevices()).to.have.lengthOf(1);
+    expect(client.halo.identity!.profile?.displayName).to.equal('test-user');
+  });
+
+  test('device invitations', async () => {
+    const testBuilder = new TestBuilder();
+
+    const client1 = new Client({ services: testBuilder.createLocal() });
+    afterTest(() => client1.destroy());
+    await client1.initialize();
+
+    await client1.halo.createIdentity({ displayName: 'test-user' });
+    expect(client1.halo.identity).exist;
+
+    expect(await client1.halo.getDevices()).to.have.lengthOf(1);
+
+    const client2 = new Client({ services: testBuilder.createLocal() });
+    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();
+
+    expect(await client1.halo.getDevices()).to.have.lengthOf(2);
+    expect(await client2.halo.getDevices()).to.have.lengthOf(2);
+  });
+});