@dxos/client-services 0.1.13 → 0.1.16

package/src/packlets/invitations/space-invitations-handler.test.ts

@@ -2,15 +2,15 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'assert';
 import { expect } from 'chai';
+import assert from 'node:assert';
 
 import { asyncChain, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { ObjectModel } from '@dxos/object-model';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { afterTest } from '@dxos/testutils';
+import { describe, test, afterTest } from '@dxos/test';
 
 import { ServiceContext } from '../services';
 import { createIdentity, createPeers, syncItems } from '../testing';
@@ -20,8 +20,8 @@ const closeAfterTest = async (peer: ServiceContext) => {
   return peer;
 };
 
-describe('services/space-invitations-handler', function () {
-  it('genesis', async function () {
+describe('services/space-invitations-handler', () => {
+  test('genesis', async () => {
     const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
 
     const space = await peer.spaceManager!.createSpace();
@@ -30,13 +30,13 @@ describe('services/space-invitations-handler', function () {
     await space.close();
   });
 
-  it('genesis with database mutations', async function () {
+  test('genesis with database mutations', async () => {
     const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
     const space = await peer.spaceManager!.createSpace();
 
     {
       const item = await space.database!.createItem<ObjectModel>({ type: 'test' });
-      void item.model.set('name', 'test');
+      await item.model.set('name', 'test');
     }
 
     {
@@ -47,12 +47,13 @@ describe('services/space-invitations-handler', function () {
     await space.close();
   });
 
-  it('creates and accepts invitation', async function () {
+  test('creates and accepts invitation with retry', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     const complete1 = new Trigger<PublicKey>();
     const complete2 = new Trigger<PublicKey>();
 
+    let attempt = 0;
     const authenticationCode = new Trigger<string>();
 
     const space1 = await host.spaceManager!.createSpace();
@@ -66,7 +67,12 @@ describe('services/space-invitations-handler', function () {
             expect(invitation1.swarmKey).to.eq(invitation2.swarmKey);
           },
           onAuthenticating: async () => {
-            await observable2.authenticate(await authenticationCode.wait());
+            if (attempt++ === 0) {
+              // Force retry.
+              await observable2.authenticate('000000');
+            } else {
+              await observable2.authenticate(await authenticationCode.wait());
+            }
           },
           onSuccess: (invitation: Invitation) => {
             complete2.wake(invitation.spaceKey!);
@@ -104,7 +110,7 @@ describe('services/space-invitations-handler', function () {
     }
   });
 
-  it('cancels invitation', async function () {
+  test('cancels invitation', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     const cancelled = new Trigger();

package/src/packlets/invitations/space-invitations-handler.ts

@@ -2,30 +2,42 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 
-import { sleep, Trigger } from '@dxos/async';
-import { createAdmissionCredentials, generatePasscode } from '@dxos/credentials';
+import { scheduleTask, sleep, Trigger } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { createAdmissionCredentials, generatePasscode, getCredentialAssertion } from '@dxos/credentials';
 import { SigningContext, Space, SpaceManager } from '@dxos/echo-db';
 import { writeMessages } from '@dxos/feed-store';
+import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { createProtocolFactory, NetworkManager, StarTopology, SwarmConnection } from '@dxos/network-manager';
-import { createRpcPlugin, RpcPlugin } from '@dxos/protocol-plugin-rpc';
+import { createTeleportProtocolFactory, NetworkManager, StarTopology, SwarmConnection } from '@dxos/network-manager';
 import { schema } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { createProtoRpcPeer } from '@dxos/rpc';
+import {
+  AuthenticationRequest,
+  AuthenticationResponse,
+  Introduction,
+  SpaceAdmissionCredentials,
+  SpaceAdmissionRequest,
+  SpaceHostService
+} from '@dxos/protocols/proto/dxos/halo/invitations';
+import { ExtensionContext } from '@dxos/teleport';
 
 import {
   AuthenticatingInvitationProvider,
+  AUTHENTICATION_CODE_LENGTH,
   CancellableInvitationObservable,
   InvitationObservableProvider,
-  AUTHENTICATION_CODE_LENGTH,
   INVITATION_TIMEOUT,
   ON_CLOSE_DELAY
 } from './invitations';
 import { AbstractInvitationsHandler, InvitationsOptions } from './invitations-handler';
+import { RpcExtension } from './rpc-extension';
+
+const MAX_OTP_ATTEMPTS = 3;
 
 /**
  * Handles the life-cycle of Space invitations between peers.
@@ -35,7 +47,8 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
   constructor(
     networkManager: NetworkManager,
     private readonly _spaceManager: SpaceManager,
-    private readonly _signingContext: SigningContext
+    private readonly _signingContext: SigningContext,
+    private readonly _keyring: Keyring
   ) {
     super(networkManager);
   }
@@ -49,6 +62,7 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
     assert(type !== Invitation.Type.OFFLINE);
     assert(space);
 
+    // TODO(dmaretskyi): Add invitation kind: halo/space.
     const invitation: Invitation = {
       type,
       invitationId: PublicKey.random().toHex(),
@@ -57,115 +71,132 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
       authenticationCode: generatePasscode(AUTHENTICATION_CODE_LENGTH)
     };
 
+    const ctx = new Context({
+      onError: (err) => {
+        void ctx.dispose();
+        observable.callback.onError(err);
+      }
+    });
+
     // TODO(burdon): Stop anything pending.
     const observable = new InvitationObservableProvider(async () => {
       await swarmConnection?.close();
     });
 
     let authenticationCode: string;
+    let authenticationRetry = 0;
+
     const complete = new Trigger<PublicKey>();
-    const plugin = new RpcPlugin(async (port) => {
+
+    // Called for every connecting peer.
+    const createExtension = (): HostSpaceInvitationExtension => {
       let guestProfile: ProfileDocument | undefined;
 
-      const peer = createProtoRpcPeer({
-        exposed: {
-          SpaceHostService: schema.getService('dxos.halo.invitations.SpaceHostService')
-        },
-        handlers: {
-          SpaceHostService: {
-            requestAdmission: async ({ profile }) => {
-              log('responding with admission offer', {
-                guestProfile: profile,
-                host: this._signingContext.deviceKey,
-                spaceKey: space.key
-              });
+      const hostInvitationExtension = new HostSpaceInvitationExtension({
+        introduce: async ({ profile }) => {
+          log('guest introduced itself', {
+            guestProfile: profile,
+            host: this._signingContext.deviceKey,
+            spaceKey: space.key
+          });
 
-              guestProfile = profile;
+          guestProfile = profile;
 
-              // TODO(burdon): Is this the right place to set this state?
-              // TODO(dmaretskyi): Should we expose guest's profile in this callback?
-              observable.callback.onAuthenticating?.(invitation);
-              return {
-                spaceKey: space.key,
-                genesisFeedKey: space.genesisFeedKey
-              };
-            },
+          // TODO(burdon): Is this the right place to set this state?
+          // TODO(dmaretskyi): Should we expose guest's profile in this callback?
+          observable.callback.onAuthenticating?.(invitation);
+        },
 
-            authenticate: async ({ authenticationCode: code }) => {
-              log('received authentication request', { authenticationCode: code });
+        authenticate: async ({ authenticationCode: code }) => {
+          log('received authentication request', { authenticationCode: code });
+          let status = AuthenticationResponse.Status.OK;
+          if (invitation.authenticationCode) {
+            if (authenticationRetry++ > MAX_OTP_ATTEMPTS) {
+              status = AuthenticationResponse.Status.INVALID_OPT_ATTEMPTS;
+            } else if (code !== invitation.authenticationCode) {
+              status = AuthenticationResponse.Status.INVALID_OTP;
+            } else {
               authenticationCode = code;
-            },
-
-            presentAdmissionCredentials: async ({ identityKey, deviceKey, controlFeedKey, dataFeedKey }) => {
-              try {
-                // Check authenticated.
-                if (invitation.type === undefined || invitation.type === Invitation.Type.INTERACTIVE) {
-                  if (
-                    invitation.authenticationCode === undefined ||
-                    authenticationCode !== invitation.authenticationCode
-                  ) {
-                    invitation.authenticationCode &&
-                      log.error('bad auth code', { code: authenticationCode, expected: invitation.authenticationCode });
-                    throw new Error('authentication code not set');
-                  }
-                }
+            }
+          }
 
-                log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
-                // TODO(burdon): Check if already admitted.
-                await writeMessages(
-                  space.controlPipeline.writer,
-                  await createAdmissionCredentials(
-                    this._signingContext.credentialSigner,
-                    identityKey,
-                    deviceKey,
-                    space.key,
-                    controlFeedKey,
-                    dataFeedKey,
-                    guestProfile
-                  )
-                );
-
-                // Updating credentials complete.
-                complete.wake(deviceKey);
-              } catch (err) {
-                // TODO(burdon): Generic RPC callback to report error to client.
-                observable.callback.onError(err);
-                throw err; // Propagate error to guest.
+          return { status };
+        },
+
+        requestAdmission: async ({ identityKey, deviceKey, controlFeedKey, dataFeedKey }) => {
+          try {
+            // Check authenticated.
+            if (invitation.type !== Invitation.Type.INTERACTIVE_TESTING) {
+              if (invitation.authenticationCode === undefined || invitation.authenticationCode !== authenticationCode) {
+                throw new Error(`invalid authentication code: ${authenticationCode}`);
               }
             }
+
+            log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
+            // TODO(burdon): Check if already admitted.
+            const credentials = await createAdmissionCredentials(
+              this._signingContext.credentialSigner,
+              identityKey,
+              deviceKey,
+              space.key,
+              controlFeedKey,
+              dataFeedKey,
+              space.genesisFeedKey,
+              guestProfile
+            );
+
+            // TODO(dmaretskyi): Refactor.
+            assert(credentials[0]['@type'] === 'dxos.echo.feed.CredentialsMessage');
+            const spaceMemberCredential = credentials[0].credential;
+            assert(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+
+            await writeMessages(space.controlPipeline.writer, credentials);
+
+            // Updating credentials complete.
+            complete.wake(deviceKey);
+
+            return { credential: spaceMemberCredential };
+          } catch (err) {
+            // TODO(burdon): Generic RPC callback to report error to client.
+            observable.callback.onError(err);
+            throw err; // Propagate error to guest.
           }
         },
-        port
-      });
 
-      try {
-        await peer.open();
-        log('connected', { host: this._signingContext.deviceKey });
-        observable.callback.onConnected?.(invitation);
-        const deviceKey = await complete.wait({ timeout });
-        log('admitted guest', { host: this._signingContext.deviceKey, guest: deviceKey });
-        observable.callback.onSuccess(invitation);
-      } catch (err) {
-        if (!observable.cancelled) {
-          log.error('failed', err);
-          observable.callback.onError(err);
+        onOpen: () => {
+          scheduleTask(ctx, async () => {
+            try {
+              log('connected', { host: this._signingContext.deviceKey });
+              observable.callback.onConnected?.(invitation);
+              const deviceKey = await complete.wait({ timeout });
+              log('admitted guest', { host: this._signingContext.deviceKey, guest: deviceKey });
+              observable.callback.onSuccess(invitation);
+            } catch (err) {
+              if (!observable.cancelled) {
+                log.error('failed', err);
+                observable.callback.onError(err);
+              }
+            } finally {
+              await sleep(ON_CLOSE_DELAY);
+              await ctx.dispose();
+            }
+          });
         }
-      } finally {
-        await sleep(ON_CLOSE_DELAY);
-        await peer.close();
-        await swarmConnection!.close();
-      }
-    });
+      });
+      return hostInvitationExtension;
+    };
 
-    setTimeout(async () => {
+    scheduleTask(ctx, async () => {
       const topic = invitation.swarmKey!;
-      const peerId = PublicKey.random(); // Use anonymous key.
-      swarmConnection = await this._networkManager.joinSwarm({
+      const swarmConnection = await this._networkManager.joinSwarm({
         topic,
         peerId: topic,
-        protocol: createProtocolFactory(topic, peerId, [plugin]),
+        protocolProvider: createTeleportProtocolFactory(async (teleport) => {
+          teleport.addExtension('dxos.halo.invitations', createExtension());
+        }),
         topology: new StarTopology(topic)
       });
+      ctx.onDispose(() => swarmConnection.close());
 
       observable.callback.onConnecting?.(invitation);
     });
@@ -180,99 +211,209 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<Space> {
    */
   acceptInvitation(invitation: Invitation, options?: InvitationsOptions): AuthenticatingInvitationProvider {
     const { timeout = INVITATION_TIMEOUT } = options ?? {};
-    let swarmConnection: SwarmConnection | undefined;
+
+    const ctx = new Context({
+      onError: (err) => {
+        void ctx.dispose();
+        observable.callback.onError(err);
+      }
+    });
 
     const authenticated = new Trigger<string>();
     const observable = new AuthenticatingInvitationProvider({
       onCancel: async () => {
-        await swarmConnection?.close();
+        await ctx.dispose();
       },
 
-      // TODO(burdon): Consider retry.
       onAuthenticate: async (code: string) => {
+        // TODO(burdon): Reset creates a race condition? Event?
         authenticated.wake(code);
       }
     });
 
     let connectionCount = 0;
     const complete = new Trigger();
-    const plugin = createRpcPlugin(async (port) => {
-      const peer = createProtoRpcPeer({
-        requested: {
-          SpaceHostService: schema.getService('dxos.halo.invitations.SpaceHostService')
-        },
-        port
-      });
 
-      try {
-        await peer.open();
-        // TODO(burdon): Bug where guest may create multiple connections.
-        if (++connectionCount > 1) {
-          throw new Error(`multiple connections detected: ${connectionCount}`);
-        }
+    const createExtension = (): GuestSpaceInvitationExtension => {
+      const extension = new GuestSpaceInvitationExtension({
+        onOpen: () => {
+          scheduleTask(ctx, async () => {
+            try {
+              // TODO(burdon): Bug where guest may create multiple connections.
+              if (++connectionCount > 1) {
+                throw new Error(`multiple connections detected: ${connectionCount}`);
+              }
 
-        log('connected', { guest: this._signingContext.deviceKey });
-        observable.callback.onConnected?.(invitation);
+              log('connected', { guest: this._signingContext.deviceKey });
+              observable.callback.onConnected?.(invitation);
 
-        // 1. Send request.
-        log('sending admission request', { guest: this._signingContext.deviceKey });
-        const { spaceKey, genesisFeedKey } = await peer.rpc.SpaceHostService.requestAdmission({
-          profile: this._signingContext.profile
-        });
+              // 1. Introduce guest to host.
+              log('introduce', { guest: this._signingContext.deviceKey });
+              await extension.rpc.SpaceHostService.introduce({
+                profile: this._signingContext.profile
+              });
 
-        // 2. Get authentication code.
-        // TODO(burdon): Test timeout (options for timeouts at different steps).
-        if (invitation.type === undefined || invitation.type === Invitation.Type.INTERACTIVE) {
-          log('guest waiting for authentication code...');
-          observable.callback.onAuthenticating?.(invitation);
-          const authenticationCode = await authenticated.wait({ timeout });
-          log('sending authentication request');
-          await peer.rpc.SpaceHostService.authenticate({ authenticationCode });
-        }
+              // 2. Get authentication code.
+              // TODO(burdon): Test timeout (options for timeouts at different steps).
+              if (invitation.type === undefined || invitation.type === Invitation.Type.INTERACTIVE) {
+                for (let attempt = 1; attempt <= MAX_OTP_ATTEMPTS; attempt++) {
+                  log('guest waiting for authentication code...');
+                  observable.callback.onAuthenticating?.(invitation);
+                  const authenticationCode = await authenticated.wait({ timeout });
+
+                  log('sending authentication request');
+                  const response = await extension.rpc.SpaceHostService.authenticate({ authenticationCode });
+                  if (response.status === undefined || response.status === AuthenticationResponse.Status.OK) {
+                    break;
+                  }
 
-        // 3. Create local space.
-        // TODO(burdon): Abandon if does not complete (otherwise retry will fail).
-        const space = await this._spaceManager.acceptSpace({ spaceKey, genesisFeedKey });
-
-        // 4. Send admission credentials to host (with local space keys).
-        log('presenting admission credentials', { guest: this._signingContext.deviceKey, spaceKey: space.key });
-        await peer.rpc.SpaceHostService.presentAdmissionCredentials({
-          identityKey: this._signingContext.identityKey,
-          deviceKey: this._signingContext.deviceKey,
-          controlFeedKey: space.controlFeedKey,
-          dataFeedKey: space.dataFeedKey
-        });
-
-        // 5. Success.
-        log('admitted by host', { guest: this._signingContext.deviceKey, spaceKey: space.key });
-        complete.wake();
-      } catch (err) {
-        if (!observable.cancelled) {
-          log.warn('failed', err);
-          observable.callback.onError(err);
+                  if (response.status === AuthenticationResponse.Status.INVALID_OTP) {
+                    if (attempt === MAX_OTP_ATTEMPTS) {
+                      throw new Error(`Maximum retry attempts: ${MAX_OTP_ATTEMPTS}`);
+                    } else {
+                      log('retrying invalid code', { attempt });
+                      authenticated.reset();
+                    }
+                  }
+                }
+              }
+              // 3. Generate a pair of keys for our feeds.
+              const controlFeedKey = await this._keyring.createKey();
+              const dataFeedKey = await this._keyring.createKey();
+
+              // 4. Send admission credentials to host (with local space keys).
+              log('request admission', { guest: this._signingContext.deviceKey });
+              const { credential } = await extension.rpc.SpaceHostService.requestAdmission({
+                identityKey: this._signingContext.identityKey,
+                deviceKey: this._signingContext.deviceKey,
+                controlFeedKey,
+                dataFeedKey
+              });
+
+              // TODO(dmaretskyi): Record credential in our HALO.
+
+              // 4. Create local space.
+              const assertion = getCredentialAssertion(credential);
+              assert(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
+              assert(credential.subject.id.equals(this._signingContext.identityKey));
+
+              const space = await this._spaceManager.acceptSpace({
+                spaceKey: assertion.spaceKey,
+                genesisFeedKey: assertion.genesisFeedKey,
+                controlFeedKey,
+                dataFeedKey
+              });
+
+              // 5. Success.
+              log('admitted by host', { guest: this._signingContext.deviceKey, spaceKey: space.key });
+              complete.wake();
+            } catch (err) {
+              if (!observable.cancelled) {
+                log.warn('auth failed', err);
+                observable.callback.onError(err);
+              }
+            } finally {
+              await ctx.dispose();
+            }
+          });
         }
-      } finally {
-        await peer.close();
-      }
-    });
+      });
+      return extension;
+    };
 
-    setTimeout(async () => {
+    scheduleTask(ctx, async () => {
       assert(invitation.swarmKey);
       const topic = invitation.swarmKey;
-      const peerId = PublicKey.random(); // Use anonymous key.
-      swarmConnection = await this._networkManager.joinSwarm({
+      const swarmConnection = await this._networkManager.joinSwarm({
         topic,
         peerId: PublicKey.random(),
-        protocol: createProtocolFactory(topic, peerId, [plugin]),
+        protocolProvider: createTeleportProtocolFactory(async (teleport) => {
+          teleport.addExtension('dxos.halo.invitations', createExtension());
+        }),
         topology: new StarTopology(topic)
       });
+      ctx.onDispose(() => swarmConnection.close());
 
       observable.callback.onConnecting?.(invitation);
       await complete.wait();
       observable.callback.onSuccess(invitation);
-      await swarmConnection.close();
+      await ctx.dispose();
     });
 
     return observable;
   }
 }
+
+type HostSpaceInvitationExtensionCallbacks = {
+  // Deliberately not async to not block the extensions opening.
+  onOpen: () => void;
+
+  introduce: (introduction: Introduction) => Promise<void>;
+  authenticate: (request: AuthenticationRequest) => Promise<AuthenticationResponse>;
+  requestAdmission: (request: SpaceAdmissionRequest) => Promise<SpaceAdmissionCredentials>;
+};
+
+/**
+ * Host's side for a connection to a concrete peer in p2p network during invitation.
+ */
+class HostSpaceInvitationExtension extends RpcExtension<{}, { SpaceHostService: SpaceHostService }> {
+  constructor(private readonly _callbacks: HostSpaceInvitationExtensionCallbacks) {
+    super({
+      exposed: {
+        SpaceHostService: schema.getService('dxos.halo.invitations.SpaceHostService')
+      }
+    });
+  }
+
+  protected override async getHandlers(): Promise<{ SpaceHostService: SpaceHostService }> {
+    return {
+      // TODO(dmaretskyi): For now this is just forwarding the data to callbacks since we don't have session-specific logic.
+      // Perhaps in the future we will have more complex logic here.
+      SpaceHostService: {
+        introduce: async (params) => {
+          return this._callbacks.introduce(params);
+        },
+
+        authenticate: async (credentials) => {
+          return this._callbacks.authenticate(credentials);
+        },
+
+        requestAdmission: async (credentials) => {
+          return this._callbacks.requestAdmission(credentials);
+        }
+      }
+    };
+  }
+
+  override async onOpen(context: ExtensionContext) {
+    await super.onOpen(context);
+    this._callbacks.onOpen();
+  }
+}
+
+type GuestSpaceInvitationExtensionCallbacks = {
+  // Deliberately not async to not block the extensions opening.
+  onOpen: () => void;
+};
+
+/**
+ * Guest's side for a connection to a concrete peer in p2p network during invitation.
+ */
+class GuestSpaceInvitationExtension extends RpcExtension<{ SpaceHostService: SpaceHostService }, {}> {
+  constructor(private readonly _callbacks: GuestSpaceInvitationExtensionCallbacks) {
+    super({
+      requested: {
+        SpaceHostService: schema.getService('dxos.halo.invitations.SpaceHostService')
+      }
+    });
+  }
+
+  protected override async getHandlers() {
+    return {};
+  }
+
+  override async onOpen(context: ExtensionContext) {
+    await super.onOpen(context);
+    this._callbacks.onOpen();
+  }
+}

package/src/packlets/invitations/space-invitations-service.test.ts

@@ -2,13 +2,13 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'assert';
 import { expect } from 'chai';
+import assert from 'node:assert';
 
 import { asyncChain, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { Invitation, SpaceInvitationsService } from '@dxos/protocols/proto/dxos/client/services';
-import { afterTest } from '@dxos/testutils';
+import { describe, test, afterTest } from '@dxos/test';
 
 import { ServiceContext } from '../services';
 import { createIdentity, createPeers } from '../testing';
@@ -20,8 +20,8 @@ const closeAfterTest = async (peer: ServiceContext) => {
   return peer;
 };
 
-describe('services/space-invitation-service', function () {
-  it('creates space and invites peer', async function () {
+describe('services/space-invitation-service', () => {
+  test('creates space and invites peer', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     assert(host.spaceManager);
@@ -82,7 +82,7 @@ describe('services/space-invitation-service', function () {
     expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
   });
 
-  it('creates space and cancels invitation', async function () {
+  test('creates space and cancels invitation', async () => {
     const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     assert(host.spaceManager);