@jskit-ai/workspaces-core 0.1.14 → 0.1.16

package/templates/packages/main/src/shared/resources/workspaceSettingsFields.js

@@ -7,11 +7,11 @@ import {
   DEFAULT_WORKSPACE_DARK_PALETTE,
   DEFAULT_WORKSPACE_LIGHT_PALETTE,
   coerceWorkspaceThemeColor
-} from "@jskit-ai/users-core/shared/settings";
+} from "@jskit-ai/workspaces-core/shared/settings";
 import {
   defineField,
   resetWorkspaceSettingsFields
-} from "@jskit-ai/users-core/shared/resources/workspaceSettingsFields";
+} from "@jskit-ai/workspaces-core/shared/resources/workspaceSettingsFields";
 
 function normalizeHexColor(value) {
   const color = normalizeText(value);

package/test/registerServiceRealtimeEvents.test.js

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerWorkspaceMembers } from "../src/server/workspaceMembers/registerWorkspaceMembers.js";
+import { registerWorkspacePendingInvitations } from "../src/server/workspacePendingInvitations/registerWorkspacePendingInvitations.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("workspace register functions publish members/invites/workspace-list realtime events", async () => {
+  const membersApp = createAppDouble();
+  registerWorkspaceMembers(membersApp.app);
+  const members = findServiceCall(membersApp.serviceCalls, "workspaces.members.service");
+  assert.equal(members?.metadata?.events?.updateMemberRole?.[0]?.realtime?.event, "workspace.members.changed");
+  assert.equal(members?.metadata?.events?.updateMemberRole?.[1]?.realtime?.event, "users.bootstrap.changed");
+  assert.equal(members?.metadata?.events?.removeMember?.[0]?.realtime?.event, "workspace.members.changed");
+  assert.equal(members?.metadata?.events?.removeMember?.[1]?.realtime?.event, "users.bootstrap.changed");
+  assert.equal(members?.metadata?.events?.createInvite?.[0]?.realtime?.event, "workspace.invites.changed");
+  assert.equal(members?.metadata?.events?.createInvite?.[1]?.realtime?.event, "users.bootstrap.changed");
+  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");
+  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.realtime?.event, "users.bootstrap.changed");
+  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, "workspaces.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.invitations.pending.changed"));
+  assert.ok(acceptInviteRealtimeEvents.includes("users.bootstrap.changed"));
+  assert.ok(acceptInviteRealtimeEvents.includes("workspaces.changed"));
+  assert.ok(acceptInviteRealtimeEvents.includes("workspace.members.changed"));
+  assert.ok(acceptInviteRealtimeEvents.includes("workspace.invites.changed"));
+
+  const acceptedMembersChange = acceptInviteEvents.find(
+    (entry) => entry?.realtime?.event === "workspace.members.changed"
+  );
+  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"
+  );
+  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.invitations.pending.changed"));
+  assert.ok(refuseInviteRealtimeEvents.includes("users.bootstrap.changed"));
+  assert.ok(refuseInviteRealtimeEvents.includes("workspace.invites.changed"));
+});

package/test/registerWorkspaceDirectory.test.js

@@ -0,0 +1,31 @@
+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",
+    "workspace.workspaces.read",
+    "workspace.workspaces.update"
+  ]);
+});

package/test/registerWorkspaceSettings.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerWorkspaceSettings } from "../src/server/workspaceSettings/registerWorkspaceSettings.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, "workspaces.settings.service");
+  assert.equal(typeof serviceCalls[0].factory, "function");
+  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[0]?.realtime?.event, "workspace.settings.changed");
+  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");
+  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[1]?.realtime?.audience, "event_scope");
+  assert.equal(actionCalls.length, 1);
+});

package/test/repositoryContracts.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createRepository as createWorkspaceInvitesRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
+import { createRepository as createWorkspaceMembershipsRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
+import { createRepository as createWorkspacesRepository } from "../src/server/common/repositories/workspacesRepository.js";
+import { createRepository as createWorkspaceSettingsRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
+
+function createKnexStub() {
+  const knex = Object.assign(() => {
+    throw new Error("query execution not expected");
+  }, {
+    async transaction(work) {
+      return work({ trxId: "trx-1" });
+    }
+  });
+
+  return knex;
+}
+
+test("workspaces-core repositories expose withTransaction", async () => {
+  const knex = createKnexStub();
+  const repositories = [
+    createWorkspaceInvitesRepository(knex),
+    createWorkspaceMembershipsRepository(knex),
+    createWorkspacesRepository(knex),
+    createWorkspaceSettingsRepository(knex)
+  ];
+
+  for (const repository of repositories) {
+    assert.equal(typeof repository.withTransaction, "function");
+    const result = await repository.withTransaction(async (trx) => ({ id: trx.trxId }));
+    assert.deepEqual(result, { id: "trx-1" });
+  }
+});

package/test/resourcesCanonical.test.js

@@ -0,0 +1,74 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import "../test-support/registerDefaultSettingsFields.js";
+import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
+import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
+import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
+
+function assertResourceOperationMessages(resource, operationName, label) {
+  const operation = resource?.operations?.[operationName];
+  assert.equal(typeof operation, "object", `${label}.operations.${operationName} must exist.`);
+
+  const operationMessages = operation?.messages;
+  const resourceMessages = resource?.messages || resource?.operationMessages;
+  const resolvedMessages =
+    operationMessages && typeof operationMessages === "object"
+      ? operationMessages
+      : resourceMessages;
+
+  assert.equal(
+    typeof resolvedMessages,
+    "object",
+    `${label}.operations.${operationName} must resolve operation messages from operation.messages or resource.messages.`
+  );
+}
+
+test("workspaces-core resources expose messages for all operations", () => {
+  const resources = {
+    workspace: workspaceResource,
+    workspaceSettings: workspaceSettingsResource
+  };
+
+  for (const [label, resource] of Object.entries(resources)) {
+    for (const operationName of ["view", "list", "create", "replace", "patch"]) {
+      assertResourceOperationMessages(resource, operationName, label);
+    }
+  }
+});
+
+test("workspaces-core specialized resource operations expose messages and validators", () => {
+  const operationSpecs = [
+    { label: "workspaceMembers.rolesList", operation: workspaceMembersResource.operations.rolesList },
+    { label: "workspaceMembers.membersList", operation: workspaceMembersResource.operations.membersList },
+    { label: "workspaceMembers.updateMemberRole", operation: workspaceMembersResource.operations.updateMemberRole },
+    { label: "workspaceMembers.removeMember", operation: workspaceMembersResource.operations.removeMember },
+    { label: "workspaceMembers.invitesList", operation: workspaceMembersResource.operations.invitesList },
+    { label: "workspaceMembers.createInvite", operation: workspaceMembersResource.operations.createInvite },
+    { label: "workspaceMembers.revokeInvite", operation: workspaceMembersResource.operations.revokeInvite },
+    { label: "workspaceMembers.redeemInvite", operation: workspaceMembersResource.operations.redeemInvite }
+  ];
+
+  for (const { label, operation } of operationSpecs) {
+    assert.equal(typeof operation?.messages, "object", `${label}.messages must be an object.`);
+    assert.equal(typeof operation?.outputValidator?.schema, "object", `${label}.outputValidator.schema must exist.`);
+    if (operation?.bodyValidator) {
+      assert.equal(typeof operation.bodyValidator.schema, "object", `${label}.bodyValidator.schema must exist.`);
+    }
+    if (operation?.paramsValidator) {
+      assert.equal(typeof operation.paramsValidator.schema, "object", `${label}.paramsValidator.schema must exist.`);
+    }
+    if (operation?.queryValidator) {
+      assert.equal(typeof operation.queryValidator.schema, "object", `${label}.queryValidator.schema must exist.`);
+    }
+  }
+});
+
+test("workspaces-core no longer contains legacy shared/schema directory", () => {
+  const testFilePath = fileURLToPath(import.meta.url);
+  const packageRoot = path.resolve(path.dirname(testFilePath), "..");
+  const legacySchemaDir = path.join(packageRoot, "src", "shared", "schema");
+  assert.equal(existsSync(legacySchemaDir), false, "src/shared/schema must not exist.");
+});

package/test/roles.test.js

@@ -0,0 +1,159 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  createWorkspaceRoleCatalog,
+  cloneWorkspaceRoleCatalog,
+  resolveRolePermissions,
+  hasPermission
+} from "../src/shared/roles.js";
+
+test("createWorkspaceRoleCatalog resolves role descriptors only from appConfig.roleCatalog", () => {
+  const emptyCatalog = createWorkspaceRoleCatalog();
+  assert.deepEqual(emptyCatalog.roles, []);
+  assert.deepEqual(emptyCatalog.assignableRoleIds, []);
+  assert.equal(emptyCatalog.defaultInviteRole, "");
+  assert.equal(emptyCatalog.collaborationEnabled, false);
+
+  const appConfig = {
+    roleCatalog: {
+      workspace: {
+        defaultInviteRole: "editor"
+      },
+      roles: {
+        owner: {
+          assignable: false,
+          permissions: ["workspace.settings.update"]
+        },
+        editor: {
+          assignable: true,
+          permissions: ["crud.contacts.*"]
+        }
+      }
+    }
+  };
+  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
+  const editorRole = roleCatalog.roles.find((role) => role.id === "editor");
+
+  assert.equal(roleCatalog.defaultInviteRole, "editor");
+  assert.equal(roleCatalog.assignableRoleIds.includes("editor"), true);
+  assert.deepEqual(resolveRolePermissions("owner", appConfig), ["workspace.settings.update"]);
+  assert.equal(hasPermission(editorRole?.permissions, "crud.contacts.update"), true);
+});
+
+test("createWorkspaceRoleCatalog resolves inherited role permissions with parent permissions first", () => {
+  const appConfig = {
+    roleCatalog: {
+      workspace: {
+        defaultInviteRole: "member"
+      },
+      roles: {
+        member: {
+          assignable: true,
+          permissions: [
+            "workspace.settings.view",
+            "crud.contacts.list"
+          ]
+        },
+        admin: {
+          assignable: true,
+          inherits: "member",
+          permissions: [
+            "workspace.settings.update",
+            "workspace.members.manage",
+            "workspace.settings.view"
+          ]
+        }
+      }
+    }
+  };
+
+  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
+  const adminRole = roleCatalog.roles.find((role) => role.id === "admin");
+
+  assert.deepEqual(adminRole, {
+    id: "admin",
+    assignable: true,
+    permissions: [
+      "workspace.settings.view",
+      "crud.contacts.list",
+      "workspace.settings.update",
+      "workspace.members.manage"
+    ]
+  });
+});
+
+test("createWorkspaceRoleCatalog rejects unknown inherited roles", () => {
+  assert.throws(
+    () =>
+      createWorkspaceRoleCatalog({
+        roleCatalog: {
+          roles: {
+            admin: {
+              assignable: true,
+              inherits: "member",
+              permissions: []
+            }
+          }
+        }
+      }),
+    /inherits unknown role "member"/
+  );
+});
+
+test("createWorkspaceRoleCatalog rejects circular inherited roles", () => {
+  assert.throws(
+    () =>
+      createWorkspaceRoleCatalog({
+        roleCatalog: {
+          roles: {
+            member: {
+              assignable: true,
+              inherits: "admin",
+              permissions: []
+            },
+            admin: {
+              assignable: true,
+              inherits: "member",
+              permissions: []
+            }
+          }
+        }
+      }),
+    /circular inheritance/
+  );
+});
+
+test("cloneWorkspaceRoleCatalog normalizes role ids and returns detached arrays", () => {
+  const source = {
+    collaborationEnabled: true,
+    defaultInviteRole: "member",
+    roles: [
+      {
+        id: " MEMBER ",
+        assignable: true,
+        permissions: ["workspace.members.view"]
+      }
+    ],
+    assignableRoleIds: ["member"]
+  };
+
+  const cloned = cloneWorkspaceRoleCatalog(source);
+  assert.deepEqual(cloned, {
+    collaborationEnabled: true,
+    defaultInviteRole: "member",
+    roles: [
+      {
+        id: "member",
+        assignable: true,
+        permissions: ["workspace.members.view"]
+      }
+    ],
+    assignableRoleIds: ["member"]
+  });
+
+  cloned.roles[0].permissions.push("workspace.members.manage");
+  cloned.assignableRoleIds.push("admin");
+
+  assert.deepEqual(source.roles[0].permissions, ["workspace.members.view"]);
+  assert.deepEqual(source.assignableRoleIds, ["member"]);
+});

package/test/routeParamsValidator.test.js

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Type } from "@fastify/type-provider-typebox";
+import { compileRouteValidator } from "@jskit-ai/kernel/_testable";
+import { routeParamsValidator } from "../src/server/common/validators/routeParamsValidator.js";
+
+test("routeParamsValidator exposes a shared workspace route params validator", () => {
+  assert.equal(typeof routeParamsValidator.schema, "object");
+  assert.equal(typeof routeParamsValidator.normalize, "function");
+});
+
+test("workspace route validator pipeline uses the shared params validator and merges query arrays automatically", () => {
+  const paginationQueryValidator = Object.freeze({
+    schema: Type.Object(
+      {
+        cursor: Type.Optional(Type.String({ minLength: 1 })),
+        limit: Type.Optional(Type.String({ pattern: "^[0-9]+$" }))
+      },
+      { additionalProperties: false }
+    )
+  });
+  const searchQueryValidator = Object.freeze({
+    schema: Type.Object(
+      {
+        search: Type.Optional(Type.String({ minLength: 1 }))
+      },
+      { additionalProperties: false }
+    )
+  });
+
+  const compiled = compileRouteValidator({
+    paramsValidator: routeParamsValidator,
+    queryValidator: [paginationQueryValidator, searchQueryValidator]
+  });
+
+  assert.equal(compiled.schema.params.type, "object");
+  assert.equal(compiled.schema.params.additionalProperties, false);
+  assert.equal(typeof compiled.schema.params.properties.workspaceSlug, "object");
+  assert.equal(typeof compiled.schema.params.properties.memberUserId, "object");
+  assert.equal(typeof compiled.schema.params.properties.inviteId, "object");
+  assert.equal(typeof compiled.schema.params.properties.provider, "object");
+  assert.equal(compiled.input.params({ workspaceSlug: "  ACME  " }).workspaceSlug, "acme");
+
+  assert.equal(compiled.schema.querystring.type, "object");
+  assert.equal(compiled.schema.querystring.additionalProperties, false);
+  assert.equal(typeof compiled.schema.querystring.properties.cursor, "object");
+  assert.equal(typeof compiled.schema.querystring.properties.limit, "object");
+  assert.equal(typeof compiled.schema.querystring.properties.search, "object");
+});

package/test/settingsFieldRegistriesSingleton.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+async function importWithIdentity(url, identity) {
+  return import(`${url.href}?identity=${identity}`);
+}
+
+test("workspace settings field registries stay shared across module identities", async () => {
+  const workspaceModuleUrl = new URL("../src/shared/resources/workspaceSettingsFields.js", import.meta.url);
+
+  const workspaceA = await importWithIdentity(workspaceModuleUrl, "workspace-a");
+  const workspaceB = await importWithIdentity(workspaceModuleUrl, "workspace-b");
+  assert.equal(workspaceA.workspaceSettingsFields, workspaceB.workspaceSettingsFields);
+});

package/test/tenancyProfile.test.js

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACES,
+  WORKSPACE_SLUG_POLICY_NONE,
+  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
+  WORKSPACE_SLUG_POLICY_USER_SELECTED,
+  resolveTenancyProfile,
+  isWorkspacesTenancyMode
+} from "../src/shared/tenancyProfile.js";
+
+test("resolveTenancyProfile returns mode-specific workspace policy matrix", () => {
+  const noneProfile = resolveTenancyProfile({ tenancyMode: TENANCY_MODE_NONE });
+  assert.deepEqual(noneProfile, {
+    mode: TENANCY_MODE_NONE,
+    workspace: {
+      enabled: false,
+      autoProvision: false,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_NONE
+    }
+  });
+
+  const personalProfile = resolveTenancyProfile({ tenancyMode: TENANCY_MODE_PERSONAL });
+  assert.deepEqual(personalProfile, {
+    mode: TENANCY_MODE_PERSONAL,
+    workspace: {
+      enabled: true,
+      autoProvision: true,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
+    }
+  });
+
+  const workspaceProfile = resolveTenancyProfile({ tenancyMode: TENANCY_MODE_WORKSPACES });
+  assert.deepEqual(workspaceProfile, {
+    mode: TENANCY_MODE_WORKSPACES,
+    workspace: {
+      enabled: true,
+      autoProvision: false,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_USER_SELECTED
+    }
+  });
+});
+
+test("isWorkspacesTenancyMode is true only for workspace mode", () => {
+  assert.equal(isWorkspacesTenancyMode(TENANCY_MODE_WORKSPACES), true);
+  assert.equal(isWorkspacesTenancyMode(TENANCY_MODE_PERSONAL), false);
+  assert.equal(isWorkspacesTenancyMode(TENANCY_MODE_NONE), false);
+});
+
+test("resolveTenancyProfile allows explicit workspace self-create policy override", () => {
+  const workspaceProfile = resolveTenancyProfile({
+    tenancyMode: TENANCY_MODE_WORKSPACES,
+    tenancyPolicy: {
+      workspace: {
+        allowSelfCreate: true
+      }
+    }
+  });
+
+  assert.equal(workspaceProfile.mode, TENANCY_MODE_WORKSPACES);
+  assert.equal(workspaceProfile.workspace.allowSelfCreate, true);
+});