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

package/src/packlets/testing/test-builder.ts

@@ -1,162 +1,140 @@
 //
-// Copyright 2022 DXOS.org
+// Copyright 2020 DXOS.org
 //
 
-import { Config } from '@dxos/config';
-import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
-import {
-  SnapshotStore,
-  DataPipelineControllerImpl,
-  MetadataStore,
-  SigningContext,
-  SpaceManager,
-  valueEncoding
-} from '@dxos/echo-pipeline';
-import { testLocalDatabase } from '@dxos/echo-pipeline/testing';
-import { FeedFactory, FeedStore } from '@dxos/feed-store';
-import { Keyring } from '@dxos/keyring';
-import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
-import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
-import { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
-
-import { createDefaultModelFactory, ClientServicesHost, ServiceContext } from '../services';
-
-//
-// TODO(burdon): Replace with test builder.
-//
-
-export const createServiceHost = (config: Config, signalManagerContext: MemorySignalManagerContext) => {
-  const networkManager = new NetworkManager({
-    signalManager: new MemorySignalManager(signalManagerContext),
-    transportFactory: MemoryTransportFactory
-  });
-
-  return new ClientServicesHost({
-    config,
-    networkManager
-  });
-};
-
-export const createServiceContext = ({
-  signalContext = new MemorySignalManagerContext(),
-  storage = createStorage({ type: StorageType.RAM })
-}: {
-  signalContext?: MemorySignalManagerContext;
-  storage?: Storage;
-} = {}) => {
-  const networkManager = new NetworkManager({
-    signalManager: new MemorySignalManager(signalContext),
-    transportFactory: MemoryTransportFactory
-  });
-
-  const modelFactory = createDefaultModelFactory();
-  return new ServiceContext(storage, networkManager, modelFactory);
-};
-
-export const createPeers = async (numPeers: number) => {
-  const signalContext = new MemorySignalManagerContext();
-
-  return await Promise.all(
-    Array.from(Array(numPeers)).map(async () => {
-      const peer = createServiceContext({ signalContext });
-      await peer.open();
-      return peer;
-    })
-  );
-};
-
-export const createIdentity = async (peer: ServiceContext) => {
-  await peer.createIdentity();
-  return peer;
-};
-
-// TODO(burdon): Remove @dxos/client-testing.
-// TODO(burdon): Create builder and make configurable.
-export const syncItems = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
-  await testLocalDatabase(db1, db2);
-  await testLocalDatabase(db2, db1);
-};
-
-export class TestBuilder {
-  public readonly signalContext = new MemorySignalManagerContext();
+import assert from 'node:assert';
 
-  createPeer(): TestPeer {
-    return new TestPeer(this.signalContext);
+import { asyncTimeout } from '@dxos/async';
+import { Client, ClientServices, ClientServicesProxy, createDefaultModelFactory } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { DocumentModel } from '@dxos/document-model';
+import { DatabaseBackendProxy, genesisMutation } from '@dxos/echo-db';
+import { PublicKey } from '@dxos/keys';
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import { createWebRTCTransportFactory, MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { Storage } from '@dxos/random-access-storage';
+import { createLinkedPorts, createProtoRpcPeer, ProtoRpcPeer } from '@dxos/rpc';
+
+import { ClientServicesHost, LocalClientServices } from '../services';
+
+export const testConfigWithLocalSignal = new Config({
+  version: 1,
+  runtime: {
+    services: {
+      signal: {
+        // TODO(burdon): Port numbers and global consts?
+        server: 'ws://localhost:4000/.well-known/dx/signal'
+      }
+    }
   }
-}
+});
 
-export type TestPeerProps = {
-  storage?: Storage;
-  feedStore?: FeedStore<any>;
-  metadataStore?: MetadataStore;
-  keyring?: Keyring;
-  networkManager?: NetworkManager;
-  spaceManager?: SpaceManager;
-  snapshotStore?: SnapshotStore;
-};
-
-export class TestPeer {
-  private _props: TestPeerProps = {};
+/**
+ * Client builder supports different configurations, incl. signaling, transports, storage.
+ */
+export class TestBuilder {
+  private readonly _config: Config;
 
-  constructor(private readonly signalContext: MemorySignalManagerContext) {}
+  public storage?: Storage;
 
-  get storage() {
-    return (this._props.storage ??= createStorage({ type: StorageType.RAM }));
+  // prettier-ignore
+  constructor (
+    config?: Config,
+    private readonly _modelFactory = createDefaultModelFactory(),
+    private readonly _signalManagerContext = new MemorySignalManagerContext()
+  ) {
+    this._config = config ?? new Config();
   }
 
-  get keyring() {
-    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
+  get config(): Config {
+    return this._config;
   }
 
-  get feedStore() {
-    return (this._props.feedStore ??= new FeedStore({
-      factory: new FeedFactory({
-        root: this.storage.createDirectory('feeds'),
-        signer: this.keyring,
-        hypercore: {
-          valueEncoding
-        }
-      })
-    }));
+  /**
+   * Get network manager using local shared memory or remote signal manager.
+   */
+  get networkManager() {
+    const signalServer = this._config.get('runtime.services.signal.server');
+    if (signalServer) {
+      return new NetworkManager({
+        log: true,
+        signalManager: new WebsocketSignalManager([signalServer]),
+        transportFactory: createWebRTCTransportFactory({
+          iceServers: this._config.get('runtime.services.ice')
+        })
+      });
+    }
+
+    // Memory transport with shared context.
+    return new NetworkManager({
+      log: true,
+      signalManager: new MemorySignalManager(this._signalManagerContext),
+      transportFactory: MemoryTransportFactory
+    });
   }
 
-  get metadataStore() {
-    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
+  /**
+   * Create backend service handlers.
+   */
+  createClientServicesHost() {
+    return new ClientServicesHost({
+      config: this._config,
+      modelFactory: this._modelFactory,
+      networkManager: this.networkManager,
+      storage: this.storage
+    });
   }
 
-  get snapshotStore() {
-    return (this._props.snapshotStore ??= new SnapshotStore(this.storage.createDirectory('snapshots')));
+  /**
+   * Create local services host.
+   */
+  createLocal() {
+    return new LocalClientServices({
+      config: this._config,
+      modelFactory: this._modelFactory,
+      networkManager: this.networkManager,
+      storage: this.storage
+    });
   }
 
-  get networkManager() {
-    return (this._props.networkManager ??= new NetworkManager({
-      signalManager: new MemorySignalManager(this.signalContext),
-      transportFactory: MemoryTransportFactory
-    }));
-  }
-
-  get spaceManager() {
-    return (this._props.spaceManager ??= new SpaceManager({
-      feedStore: this.feedStore,
-      networkManager: this.networkManager
-    }));
+  /**
+   * Create client/server.
+   */
+  createClientServer(host: ClientServicesHost = this.createClientServicesHost()): [Client, ProtoRpcPeer<{}>] {
+    const [proxyPort, hostPort] = createLinkedPorts();
+    const server = createProtoRpcPeer({
+      exposed: host.descriptors,
+      handlers: host.services as ClientServices,
+      port: hostPort
+    });
+    // TODO(dmaretskyi): Refactor.
+
+    const client = new Client({ services: new ClientServicesProxy(proxyPort) });
+    return [client, server];
   }
 }
 
-export const createSigningContext = async (keyring: Keyring): Promise<SigningContext> => {
-  const identityKey = await keyring.createKey();
-  const deviceKey = await keyring.createKey();
-
-  return {
-    identityKey,
-    deviceKey,
-    credentialSigner: createCredentialSignerWithChain(
-      keyring,
-      {
-        credential: await new CredentialGenerator(keyring, identityKey, deviceKey).createDeviceAuthorization(deviceKey)
-      },
-      deviceKey
-    ),
-    recordCredential: async () => {} // No-op.
-  };
+export const testSpace = async (create: DatabaseBackendProxy, check: DatabaseBackendProxy = create) => {
+  const objectId = PublicKey.random().toHex();
+
+  const result = create.mutate(genesisMutation(objectId, DocumentModel.meta.type));
+
+  await result.getReceipt();
+  // TODO(dmaretskiy): await result.waitToBeProcessed()
+  assert(create._itemManager.entities.has(result.objectsCreated[0].id));
+
+  await asyncTimeout(
+    check._itemManager.update.waitForCondition(() => check._itemManager.entities.has(objectId)),
+    1000
+  );
+
+  return result;
+};
+
+export const syncItems = async (db1: DatabaseBackendProxy, db2: DatabaseBackendProxy) => {
+  // Check item replicated from 1 => 2.
+  await testSpace(db1, db2);
+
+  // Check item replicated from 2 => 1.
+  await testSpace(db2, db1);
 };

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();
+  }
+};