@jskit-ai/users-core 0.1.4

package/test/avatarService.test.js

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Readable } from "node:stream";
+import { createService } from "../src/server/accountProfile/avatarService.js";
+
+function createRepositoryDouble(initialProfile) {
+  const state = {
+    profile: { ...initialProfile }
+  };
+
+  return {
+    state,
+    async findByIdentity() {
+      return { ...state.profile };
+    },
+    async findById() {
+      return { ...state.profile };
+    },
+    async updateAvatarById(userId, avatar = {}) {
+      state.profile = {
+        ...state.profile,
+        id: Number(userId),
+        avatarStorageKey: avatar.avatarStorageKey || null,
+        avatarVersion: avatar.avatarVersion == null ? null : String(avatar.avatarVersion)
+      };
+      return { ...state.profile };
+    },
+    async clearAvatarById(userId) {
+      state.profile = {
+        ...state.profile,
+        id: Number(userId),
+        avatarStorageKey: null,
+        avatarVersion: null
+      };
+      return { ...state.profile };
+    }
+  };
+}
+
+test("avatarService uploadForUser stores bytes and updates profile avatar fields", async () => {
+  const repository = createRepositoryDouble({
+    id: 7,
+    authProvider: "local",
+    authProviderUserId: "u-7",
+    email: "test@example.com",
+    displayName: "Tester",
+    avatarStorageKey: null,
+    avatarVersion: null
+  });
+
+  const savedPayloads = [];
+  const avatarStorageService = {
+    async saveAvatar(payload) {
+      savedPayloads.push(payload);
+      return {
+        storageKey: "users/avatars/7/avatar"
+      };
+    }
+  };
+
+  const avatarService = createService({
+    userProfilesRepository: repository,
+    avatarStorageService
+  });
+
+  const user = {
+    authProvider: "local",
+    authProviderUserId: "u-7"
+  };
+
+  const result = await avatarService.uploadForUser(user, {
+    mimeType: "image/png",
+    stream: Readable.from([Buffer.from([0x89, 0x50, 0x4e, 0x47])])
+  });
+
+  assert.equal(savedPayloads.length, 1);
+  assert.equal(savedPayloads[0].userId, 7);
+  assert.ok(Buffer.isBuffer(savedPayloads[0].buffer));
+  assert.equal(result.profile.avatarStorageKey, "users/avatars/7/avatar");
+  assert.equal(typeof result.profile.avatarVersion, "string");
+});
+
+test("avatarService clearForUser removes stored avatar and clears profile fields", async () => {
+  const repository = createRepositoryDouble({
+    id: 7,
+    authProvider: "local",
+    authProviderUserId: "u-7",
+    email: "test@example.com",
+    displayName: "Tester",
+    avatarStorageKey: "users/avatars/7/avatar",
+    avatarVersion: "123"
+  });
+
+  const deletedKeys = [];
+  const avatarStorageService = {
+    async deleteAvatar(storageKey) {
+      deletedKeys.push(storageKey);
+    }
+  };
+
+  const avatarService = createService({
+    userProfilesRepository: repository,
+    avatarStorageService
+  });
+
+  const profile = await avatarService.clearForUser({
+    authProvider: "local",
+    authProviderUserId: "u-7"
+  });
+
+  assert.deepEqual(deletedKeys, ["users/avatars/7/avatar"]);
+  assert.equal(profile.avatarStorageKey, null);
+  assert.equal(profile.avatarVersion, null);
+});

package/test/avatarStorageService.test.js

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createService, __testables } from "../src/server/accountProfile/avatarStorageService.js";
+
+function createStorageDouble() {
+  const values = new Map();
+  return {
+    async getItemRaw(key) {
+      return values.has(key) ? values.get(key) : null;
+    },
+    async setItemRaw(key, value) {
+      values.set(key, value);
+    },
+    async removeItem(key) {
+      values.delete(key);
+    }
+  };
+}
+
+test("avatarStorageService builds stable storage key by user id", () => {
+  assert.equal(__testables.buildAvatarStorageKey(7), "users/avatars/7/avatar");
+  assert.throws(() => __testables.buildAvatarStorageKey(0), /positive integer user id/);
+});
+
+test("avatarStorageService detects common avatar mime types", () => {
+  assert.equal(
+    __testables.detectAvatarMimeTypeFromBuffer(Buffer.from([0xff, 0xd8, 0xff, 0xdb])),
+    "image/jpeg"
+  );
+  assert.equal(
+    __testables.detectAvatarMimeTypeFromBuffer(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])),
+    "image/png"
+  );
+  assert.equal(
+    __testables.detectAvatarMimeTypeFromBuffer(
+      Buffer.from([0x52, 0x49, 0x46, 0x46, 0x11, 0x22, 0x33, 0x44, 0x57, 0x45, 0x42, 0x50])
+    ),
+    "image/webp"
+  );
+});
+
+test("avatarStorageService saves, reads, and deletes avatar bytes", async () => {
+  const storage = createStorageDouble();
+  const avatarStorageService = createService({ storage });
+  const payload = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+  const saved = await avatarStorageService.saveAvatar({
+    userId: 42,
+    buffer: payload
+  });
+  assert.equal(saved.storageKey, "users/avatars/42/avatar");
+
+  const loaded = await avatarStorageService.readAvatar(saved.storageKey);
+  assert.equal(loaded?.mimeType, "image/png");
+  assert.ok(Buffer.isBuffer(loaded?.buffer));
+  assert.equal(loaded?.buffer?.toString("hex"), payload.toString("hex"));
+
+  await avatarStorageService.deleteAvatar(saved.storageKey);
+  const missing = await avatarStorageService.readAvatar(saved.storageKey);
+  assert.equal(missing, null);
+});

package/test/consoleService.test.js

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createService } from "../src/server/consoleSettings/consoleService.js";
+
+function createFixture(initialOwnerUserId = null) {
+  const state = {
+    ownerUserId: initialOwnerUserId
+  };
+
+  const service = createService({
+    consoleSettingsRepository: {
+      async ensureOwnerUserId(userId) {
+        const normalizedUserId = Number(userId);
+        if (!state.ownerUserId) {
+          state.ownerUserId = normalizedUserId;
+        }
+        return state.ownerUserId;
+      }
+    }
+  });
+
+  return { service, state };
+}
+
+test("consoleService seeds the first authenticated user as console owner", async () => {
+  const { service, state } = createFixture();
+
+  const firstOwner = await service.ensureInitialConsoleMember(7);
+  const secondAttempt = await service.ensureInitialConsoleMember(9);
+
+  assert.equal(firstOwner, 7);
+  assert.equal(secondAttempt, 7);
+  assert.equal(state.ownerUserId, 7);
+});
+
+test("consoleService.requireConsoleOwner denies authenticated non-owners", async () => {
+  const { service } = createFixture(7);
+
+  await assert.rejects(
+    () =>
+      service.requireConsoleOwner({
+        actor: {
+          id: 9
+        }
+      }),
+    (error) => error?.status === 403
+  );
+});
+
+test("consoleService.requireConsoleOwner requires authentication", async () => {
+  const { service } = createFixture(7);
+
+  await assert.rejects(
+    () => service.requireConsoleOwner({}),
+    (error) => error?.status === 401
+  );
+});

package/test/consoleSettingsService.test.js

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createService } from "../src/server/consoleSettings/consoleSettingsService.js";
+
+function createFixture({ deny = false } = {}) {
+  const calls = {
+    requireConsoleOwner: [],
+    updateSingleton: []
+  };
+
+  const service = createService({
+    consoleService: {
+      async requireConsoleOwner(context) {
+        calls.requireConsoleOwner.push(context || null);
+        if (deny) {
+          const error = new Error("Forbidden.");
+          error.status = 403;
+          throw error;
+        }
+      }
+    },
+    consoleSettingsRepository: {
+      async getSingleton() {
+        return {};
+      },
+      async updateSingleton(patch = {}) {
+        calls.updateSingleton.push({ ...patch });
+        return {};
+      }
+    }
+  });
+
+  return { service, calls };
+}
+
+test("consoleSettingsService.getSettings requires owner access and returns normalized payload", async () => {
+  const { service, calls } = createFixture();
+  const context = {
+    actor: {
+      id: 7
+    }
+  };
+
+  const response = await service.getSettings({ context });
+
+  assert.deepEqual(calls.requireConsoleOwner, [context]);
+  assert.deepEqual(response, {
+    settings: {}
+  });
+});
+
+test("consoleSettingsService.updateSettings requires owner access before writing", async () => {
+  const { service, calls } = createFixture();
+  const context = {
+    actor: {
+      id: 7
+    }
+  };
+
+  const response = await service.updateSettings(
+    {},
+    { context }
+  );
+
+  assert.deepEqual(calls.requireConsoleOwner, [context]);
+  assert.deepEqual(calls.updateSingleton, [{}]);
+  assert.deepEqual(response, {
+    settings: {}
+  });
+});
+
+test("consoleSettingsService denies access when owner validation fails", async () => {
+  const { service } = createFixture({ deny: true });
+
+  await assert.rejects(
+    () =>
+      service.getSettings({
+        context: {
+          actor: {
+            id: 9
+          }
+        }
+      }),
+    (error) => error?.status === 403
+  );
+});

package/test/exportsContract.test.js

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { evaluatePackageExportsContract } from "../../../tooling/test-support/exportsContract.mjs";
+
+const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(TEST_DIRECTORY, "..", "..", "..");
+const PACKAGE_DIR = path.join(REPO_ROOT, "packages", "users-core");
+
+test("users-core exports are explicit and aligned with production/template usage", () => {
+  const result = evaluatePackageExportsContract({
+    repoRoot: REPO_ROOT,
+    packageDir: PACKAGE_DIR,
+    packageId: "@jskit-ai/users-core"
+  });
+
+  assert.deepEqual(
+    result.wildcardExports,
+    [],
+    `users-core exports must be explicit. Remove wildcard keys: ${result.wildcardExports.join(", ")}`
+  );
+  assert.deepEqual(
+    result.missingRequiredExports,
+    [],
+    `users-core required exports missing: ${result.missingRequiredExports.join(", ")}`
+  );
+  assert.deepEqual(
+    result.missingExports,
+    [],
+    `users-core imports missing from package exports:\n${result.missingExports.join("\n")}`
+  );
+  assert.deepEqual(
+    result.staleExports,
+    [],
+    `Stale users-core exports found. Remove stale keys: ${result.staleExports.join(", ")}`
+  );
+});

package/test/registerAvatarMultipartSupport.test.js

@@ -0,0 +1,64 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
+import { registerAvatarMultipartSupport } from "../src/server/accountProfile/registerAvatarMultipartSupport.js";
+
+function createAppStub({ hasFastify = true, fastify = null } = {}) {
+  const resolvedFastify =
+    fastify ||
+    {
+      register: async () => {},
+      hasContentTypeParser: () => false
+    };
+
+  return {
+    has(token) {
+      if (token === KERNEL_TOKENS.Fastify) {
+        return hasFastify;
+      }
+      return false;
+    },
+    make(token) {
+      if (token === KERNEL_TOKENS.Fastify) {
+        return resolvedFastify;
+      }
+      return null;
+    }
+  };
+}
+
+test("registerAvatarMultipartSupport returns early when Fastify is not available", async () => {
+  const app = createAppStub({ hasFastify: false });
+  await assert.doesNotReject(async () => registerAvatarMultipartSupport(app));
+});
+
+test("registerAvatarMultipartSupport registers multipart parser only once", async () => {
+  let registerCount = 0;
+  const fastify = {
+    register: async () => {
+      registerCount += 1;
+    },
+    hasContentTypeParser: () => false
+  };
+  const app = createAppStub({ fastify });
+
+  await registerAvatarMultipartSupport(app);
+  await registerAvatarMultipartSupport(app);
+
+  assert.equal(registerCount, 1);
+});
+
+test("registerAvatarMultipartSupport skips registration when parser already exists", async () => {
+  let registerCount = 0;
+  const fastify = {
+    register: async () => {
+      registerCount += 1;
+    },
+    hasContentTypeParser: (contentType) => String(contentType || "").trim().toLowerCase() === "multipart"
+  };
+  const app = createAppStub({ fastify });
+
+  await registerAvatarMultipartSupport(app);
+
+  assert.equal(registerCount, 0);
+});

package/test/registerServiceRealtimeEvents.test.js

@@ -0,0 +1,160 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerAccountProfile } from "../src/server/accountProfile/registerAccountProfile.js";
+import { registerAccountPreferences } from "../src/server/accountPreferences/registerAccountPreferences.js";
+import { registerAccountNotifications } from "../src/server/accountNotifications/registerAccountNotifications.js";
+import { registerConsoleSettings } from "../src/server/consoleSettings/registerConsoleSettings.js";
+import { registerWorkspaceMembers } from "../src/server/workspaceMembers/registerWorkspaceMembers.js";
+import { registerWorkspacePendingInvitations } from "../src/server/workspacePendingInvitations/registerWorkspacePendingInvitations.js";
+import {
+  ACCOUNT_SETTINGS_CHANGED_EVENT,
+  CONSOLE_SETTINGS_CHANGED_EVENT,
+  USERS_BOOTSTRAP_CHANGED_EVENT,
+  WORKSPACE_MEMBERS_CHANGED_EVENT,
+  WORKSPACE_INVITES_CHANGED_EVENT,
+  WORKSPACES_CHANGED_EVENT,
+  WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT
+} from "../src/shared/events/usersEvents.js";
+
+function createAppDouble() {
+  const serviceCalls = [];
+
+  return {
+    serviceCalls,
+    app: {
+      singleton() {
+        return this;
+      },
+      service(token, factory, metadata) {
+        serviceCalls.push({
+          token,
+          factory,
+          metadata
+        });
+        return this;
+      },
+      actions() {
+        return this;
+      }
+    }
+  };
+}
+
+function findServiceCall(serviceCalls, token) {
+  return serviceCalls.find((entry) => entry.token === token) || null;
+}
+
+test("account register functions publish account.settings.changed for update operations", () => {
+  const profileApp = createAppDouble();
+  registerAccountProfile(profileApp.app);
+  const profile = findServiceCall(profileApp.serviceCalls, "users.accountProfile.service");
+  assert.equal(profile?.metadata?.events?.updateProfile?.[0]?.realtime?.event, ACCOUNT_SETTINGS_CHANGED_EVENT);
+  assert.equal(profile?.metadata?.events?.updateProfile?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+  assert.equal(profile?.metadata?.events?.uploadAvatar?.[0]?.realtime?.event, ACCOUNT_SETTINGS_CHANGED_EVENT);
+  assert.equal(profile?.metadata?.events?.uploadAvatar?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+  assert.equal(profile?.metadata?.events?.deleteAvatar?.[0]?.realtime?.event, ACCOUNT_SETTINGS_CHANGED_EVENT);
+  assert.equal(profile?.metadata?.events?.deleteAvatar?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+
+  const preferencesApp = createAppDouble();
+  registerAccountPreferences(preferencesApp.app);
+  const preferences = findServiceCall(preferencesApp.serviceCalls, "users.accountPreferences.service");
+  assert.equal(preferences?.metadata?.events?.updatePreferences?.[0]?.realtime?.event, ACCOUNT_SETTINGS_CHANGED_EVENT);
+  assert.equal(preferences?.metadata?.events?.updatePreferences?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+
+  const notificationsApp = createAppDouble();
+  registerAccountNotifications(notificationsApp.app);
+  const notifications = findServiceCall(notificationsApp.serviceCalls, "users.accountNotifications.service");
+  assert.equal(notifications?.metadata?.events?.updateNotifications?.[0]?.realtime?.event, ACCOUNT_SETTINGS_CHANGED_EVENT);
+  assert.equal(notifications?.metadata?.events?.updateNotifications?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+});
+
+test("console settings register publishes console.settings.changed", () => {
+  const payload = createAppDouble();
+  registerConsoleSettings(payload.app);
+  const consoleSettings = findServiceCall(payload.serviceCalls, "users.console.settings.service");
+  assert.equal(consoleSettings?.metadata?.events?.updateSettings?.[0]?.realtime?.event, CONSOLE_SETTINGS_CHANGED_EVENT);
+});
+
+test("workspace register functions publish members/invites/workspace-list realtime events", async () => {
+  const membersApp = createAppDouble();
+  registerWorkspaceMembers(membersApp.app);
+  const members = findServiceCall(membersApp.serviceCalls, "users.workspace.members.service");
+  assert.equal(members?.metadata?.events?.updateMemberRole?.[0]?.realtime?.event, WORKSPACE_MEMBERS_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.updateMemberRole?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.removeMember?.[0]?.realtime?.event, WORKSPACE_MEMBERS_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.removeMember?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.createInvite?.[0]?.realtime?.event, WORKSPACE_INVITES_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.createInvite?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.createInvite?.[1]?.entityId?.({ result: { createdInviteId: 91 } }), 91);
+  assert.equal(members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.preset, "event_scope");
+  assert.equal(typeof members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.userQuery, "function");
+  const createInviteAudienceQueryResult = await members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.userQuery({
+    knex() {
+      return {
+        join() {
+          return this;
+        },
+        where(field, value) {
+          assert.equal(field, "wi.id");
+          assert.equal(value, 91);
+          return this;
+        },
+        async first() {
+          return {
+            user_id: 55
+          };
+        }
+      };
+    },
+    event: {
+      entityId: 91
+    }
+  });
+  assert.deepEqual(createInviteAudienceQueryResult, [{ userId: 55 }]);
+  assert.equal(members?.metadata?.events?.revokeInvite?.[0]?.realtime?.event, WORKSPACE_INVITES_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.entityId?.({ result: { revokedInviteId: 19 } }), 19);
+  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.realtime?.audience?.preset, "event_scope");
+  assert.equal(typeof members?.metadata?.events?.revokeInvite?.[1]?.realtime?.audience?.userQuery, "function");
+
+  const pendingApp = createAppDouble();
+  registerWorkspacePendingInvitations(pendingApp.app);
+  const pending = findServiceCall(pendingApp.serviceCalls, "users.workspace.pending-invitations.service");
+  const acceptInviteEvents = Array.isArray(pending?.metadata?.events?.acceptInviteByToken)
+    ? pending.metadata.events.acceptInviteByToken
+    : [];
+  const acceptInviteRealtimeEvents = acceptInviteEvents.map((entry) => entry?.realtime?.event).filter(Boolean);
+  assert.ok(acceptInviteRealtimeEvents.includes(WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT));
+  assert.ok(acceptInviteRealtimeEvents.includes(USERS_BOOTSTRAP_CHANGED_EVENT));
+  assert.ok(acceptInviteRealtimeEvents.includes(WORKSPACES_CHANGED_EVENT));
+  assert.ok(acceptInviteRealtimeEvents.includes(WORKSPACE_MEMBERS_CHANGED_EVENT));
+  assert.ok(acceptInviteRealtimeEvents.includes(WORKSPACE_INVITES_CHANGED_EVENT));
+
+  const acceptedMembersChange = acceptInviteEvents.find(
+    (entry) => entry?.realtime?.event === WORKSPACE_MEMBERS_CHANGED_EVENT
+  );
+  assert.equal(acceptedMembersChange?.entityId?.({ result: { workspaceId: 9 } }), 9);
+  assert.deepEqual(
+    acceptedMembersChange?.realtime?.audience?.({
+      event: {
+        entityId: 9
+      }
+    }),
+    {
+      workspaceId: 9
+    }
+  );
+
+  const acceptedInvitesChange = acceptInviteEvents.find(
+    (entry) => entry?.realtime?.event === WORKSPACE_INVITES_CHANGED_EVENT
+  );
+  assert.equal(acceptedInvitesChange?.entityId?.({ result: { workspaceId: 9 } }), 9);
+
+  const refuseInviteEvents = Array.isArray(pending?.metadata?.events?.refuseInviteByToken)
+    ? pending.metadata.events.refuseInviteByToken
+    : [];
+  const refuseInviteRealtimeEvents = refuseInviteEvents.map((entry) => entry?.realtime?.event).filter(Boolean);
+  assert.ok(refuseInviteRealtimeEvents.includes(WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT));
+  assert.ok(refuseInviteRealtimeEvents.includes(USERS_BOOTSTRAP_CHANGED_EVENT));
+  assert.ok(refuseInviteRealtimeEvents.includes(WORKSPACE_INVITES_CHANGED_EVENT));
+});

package/test/registerWorkspaceDirectory.test.js

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerWorkspaceDirectory } from "../src/server/workspaceDirectory/registerWorkspaceDirectory.js";
+
+function createAppDouble() {
+  const actionBatches = [];
+
+  return {
+    actionBatches,
+    singleton() {},
+    actions(entries) {
+      actionBatches.push(Array.isArray(entries) ? entries : [entries]);
+    }
+  };
+}
+
+function listActionIds(app) {
+  return app.actionBatches.flat().map((entry) => String(entry?.id || ""));
+}
+
+test("registerWorkspaceDirectory registers workspace directory actions without resolving runtime tenancy tokens", () => {
+  const app = createAppDouble();
+
+  registerWorkspaceDirectory(app);
+  assert.deepEqual(listActionIds(app), ["workspace.workspaces.create", "workspace.workspaces.list"]);
+});

package/test/registerWorkspaceSettings.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerWorkspaceSettings } from "../src/server/workspaceSettings/registerWorkspaceSettings.js";
+import {
+  USERS_BOOTSTRAP_CHANGED_EVENT,
+  WORKSPACE_SETTINGS_CHANGED_EVENT
+} from "../src/shared/events/usersEvents.js";
+
+test("registerWorkspaceSettings registers workspace settings service realtime event metadata", () => {
+  const singletonBindings = new Map();
+  const actionCalls = [];
+  const serviceCalls = [];
+
+  const app = {
+    singleton(token, factory) {
+      singletonBindings.set(token, factory);
+      return this;
+    },
+    service(token, factory, metadata) {
+      serviceCalls.push({
+        token,
+        factory,
+        metadata
+      });
+      return this;
+    },
+    actions(definitions) {
+      actionCalls.push(definitions);
+      return this;
+    }
+  };
+
+  registerWorkspaceSettings(app);
+
+  assert.equal(singletonBindings.has("workspaceSettingsRepository"), true);
+  assert.equal(serviceCalls.length, 1);
+  assert.equal(serviceCalls[0].token, "users.workspace.settings.service");
+  assert.equal(typeof serviceCalls[0].factory, "function");
+  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[0]?.realtime?.event, WORKSPACE_SETTINGS_CHANGED_EVENT);
+  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[0]?.realtime?.audience, "event_scope");
+  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[1]?.realtime?.event, USERS_BOOTSTRAP_CHANGED_EVENT);
+  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[1]?.realtime?.audience, "event_scope");
+  assert.equal(actionCalls.length, 1);
+});