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

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

@@ -0,0 +1,163 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { createDefaultModelFactory } from '@dxos/client';
+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 { 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 syncItemsLocal = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
+  await testLocalDatabase(db1, db2);
+  await testLocalDatabase(db2, db1);
+};
+
+export class HostTestBuilder {
+  public readonly signalContext = new MemorySignalManagerContext();
+
+  createPeer(): TestPeer {
+    return new TestPeer(this.signalContext);
+  }
+}
+
+export type TestPeerProps = {
+  storage?: Storage;
+  feedStore?: FeedStore<any>;
+  metadataStore?: MetadataStore;
+  keyring?: Keyring;
+  networkManager?: NetworkManager;
+  spaceManager?: SpaceManager;
+  snapshotStore?: SnapshotStore;
+};
+
+export class TestPeer {
+  private _props: TestPeerProps = {};
+
+  constructor(private readonly signalContext: MemorySignalManagerContext) {}
+
+  get storage() {
+    return (this._props.storage ??= createStorage({ type: StorageType.RAM }));
+  }
+
+  get keyring() {
+    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
+  }
+
+  get feedStore() {
+    return (this._props.feedStore ??= new FeedStore({
+      factory: new FeedFactory({
+        root: this.storage.createDirectory('feeds'),
+        signer: this.keyring,
+        hypercore: {
+          valueEncoding
+        }
+      })
+    }));
+  }
+
+  get metadataStore() {
+    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
+  }
+
+  get snapshotStore() {
+    return (this._props.snapshotStore ??= new SnapshotStore(this.storage.createDirectory('snapshots')));
+  }
+
+  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
+    }));
+  }
+}
+
+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.
+  };
+};

package/src/packlets/testing/index.ts

@@ -3,5 +3,6 @@
 //
 
 export * from './credential-utils';
+export * from './host-test-builder';
 export * from './invitation-utils';
 export * from './test-builder';

package/src/packlets/testing/invitation-utils.ts

@@ -5,11 +5,10 @@
 import assert from 'node:assert';
 
 import { Trigger } from '@dxos/async';
+import { InvitationsHandler } from '@dxos/client';
 import { raise } from '@dxos/debug';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
-import { InvitationsHandler } from '../invitations';
-
 export const performInvitation = async <T>(host: InvitationsHandler<T>, guest: InvitationsHandler<T>, context: T) => {
   const done1 = new Trigger<Invitation>(); // peer 1 connected.
   const done2 = new Trigger<Invitation>(); // peer 2 connected.

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

@@ -1,162 +1,180 @@
 //
-// 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';
+import assert from 'node:assert';
 
-//
-// TODO(burdon): Replace with test builder.
-//
-
-export const createServiceHost = (config: Config, signalManagerContext: MemorySignalManagerContext) => {
-  const networkManager = new NetworkManager({
-    signalManager: new MemorySignalManager(signalManagerContext),
-    transportFactory: MemoryTransportFactory
-  });
+import { asyncTimeout, Trigger } from '@dxos/async';
+import { Client, ClientServices, ClientServicesProxy, createDefaultModelFactory, Invitation } from '@dxos/client';
+import { Config } from '@dxos/config';
+import { raise } from '@dxos/debug';
+import { DocumentModel } from '@dxos/document-model';
+import { DatabaseBackendProxy, genesisMutation } from '@dxos/echo-db';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+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'
+      }
+    }
+  }
+});
 
-  return new ClientServicesHost({
-    config,
-    networkManager
-  });
-};
+/**
+ * Client builder supports different configurations, incl. signaling, transports, storage.
+ */
+export class TestBuilder {
+  private readonly _config: Config;
 
-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);
-};
+  public storage?: Storage;
 
-export const createPeers = async (numPeers: number) => {
-  const signalContext = new MemorySignalManagerContext();
+  // prettier-ignore
+  constructor (
+    config?: Config,
+    private readonly _modelFactory = createDefaultModelFactory(),
+    private readonly _signalManagerContext = new MemorySignalManagerContext()
+  ) {
+    this._config = config ?? new Config();
+  }
 
-  return await Promise.all(
-    Array.from(Array(numPeers)).map(async () => {
-      const peer = createServiceContext({ signalContext });
-      await peer.open();
-      return peer;
-    })
-  );
-};
+  get config(): Config {
+    return this._config;
+  }
 
-export const createIdentity = async (peer: ServiceContext) => {
-  await peer.createIdentity();
-  return peer;
-};
+  /**
+   * 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
+    });
+  }
 
-// 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);
-};
+  /**
+   * Create backend service handlers.
+   */
+  createClientServicesHost() {
+    return new ClientServicesHost({
+      config: this._config,
+      modelFactory: this._modelFactory,
+      networkManager: this.networkManager,
+      storage: this.storage
+    });
+  }
 
-export class TestBuilder {
-  public readonly signalContext = new MemorySignalManagerContext();
+  /**
+   * Create local services host.
+   */
+  createLocal() {
+    return new LocalClientServices({
+      config: this._config,
+      modelFactory: this._modelFactory,
+      networkManager: this.networkManager,
+      storage: this.storage
+    });
+  }
 
-  createPeer(): TestPeer {
-    return new TestPeer(this.signalContext);
+  /**
+   * 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 type TestPeerProps = {
-  storage?: Storage;
-  feedStore?: FeedStore<any>;
-  metadataStore?: MetadataStore;
-  keyring?: Keyring;
-  networkManager?: NetworkManager;
-  spaceManager?: SpaceManager;
-  snapshotStore?: SnapshotStore;
-};
-
-export class TestPeer {
-  private _props: TestPeerProps = {};
-
-  constructor(private readonly signalContext: MemorySignalManagerContext) {}
+export const testSpace = async (create: DatabaseBackendProxy, check: DatabaseBackendProxy = create) => {
+  const objectId = PublicKey.random().toHex();
 
-  get storage() {
-    return (this._props.storage ??= createStorage({ type: StorageType.RAM }));
-  }
+  const result = create.mutate(genesisMutation(objectId, DocumentModel.meta.type));
 
-  get keyring() {
-    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
-  }
+  await result.batch.getReceipt();
+  // TODO(dmaretskiy): await result.waitToBeProcessed()
+  assert(create._itemManager.entities.has(result.objectsUpdated[0].id));
 
-  get feedStore() {
-    return (this._props.feedStore ??= new FeedStore({
-      factory: new FeedFactory({
-        root: this.storage.createDirectory('feeds'),
-        signer: this.keyring,
-        hypercore: {
-          valueEncoding
-        }
-      })
-    }));
-  }
+  await asyncTimeout(
+    check.itemUpdate.waitForCondition(() => check._itemManager.entities.has(objectId)),
+    1000
+  );
 
-  get metadataStore() {
-    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
-  }
+  return result;
+};
 
-  get snapshotStore() {
-    return (this._props.snapshotStore ??= new SnapshotStore(this.storage.createDirectory('snapshots')));
-  }
+export const syncItems = async (db1: DatabaseBackendProxy, db2: DatabaseBackendProxy) => {
+  // Check item replicated from 1 => 2.
+  await testSpace(db1, db2);
 
-  get networkManager() {
-    return (this._props.networkManager ??= new NetworkManager({
-      signalManager: new MemorySignalManager(this.signalContext),
-      transportFactory: MemoryTransportFactory
-    }));
-  }
+  // Check item replicated from 2 => 1.
+  await testSpace(db2, db1);
+};
 
-  get spaceManager() {
-    return (this._props.spaceManager ??= new SpaceManager({
-      feedStore: this.feedStore,
-      networkManager: this.networkManager
-    }));
-  }
-}
+export const joinCommonSpace = async ([initialPeer, ...peers]: Client[], spaceKey?: PublicKey): Promise<PublicKey> => {
+  const rootSpace = spaceKey ? initialPeer.echo.getSpace(spaceKey) : await initialPeer.echo.createSpace();
+  assert(rootSpace, 'Space not found.');
+
+  await Promise.all(
+    peers.map(async (peer) => {
+      const hostDone = new Trigger<Invitation>();
+      const guestDone = new Trigger<Invitation>();
+
+      const hostObservabli = rootSpace.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
+      log('invitation created');
+      hostObservabli.subscribe({
+        onConnecting: (invitation) => {
+          const guestObservable = peer.echo.acceptInvitation(invitation);
+          log('invitation accepted');
+
+          guestObservable.subscribe({
+            onSuccess: (invitation: Invitation) => {
+              guestDone.wake(invitation);
+              log('invitation guestDone');
+            },
+            onError: (err: Error) => raise(err)
+          });
+        },
+        onSuccess: (invitation) => {
+          hostDone.wake(invitation);
+          log('invitation hostDone');
+        },
+        onError: (err) => raise(err)
+      });
+
+      await Promise.all([hostDone.wait(), guestDone.wait()]);
+    })
+  );
 
-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.
-  };
+  return rootSpace.key;
 };