@kindgi/platform 0.1.2 → 0.1.4-rc.0

package/tests/team-binding.conformance.ts

@@ -12,6 +12,9 @@
  *   `updateRole`).
  * - `listForUser` returns memberships across teams within a tenant.
  * - Cross-tenant isolation on every reachable read.
+ * - Outcomes: `team-not-found` and `team-membership-not-found` from
+ *   writes on a missing row, `slug-conflict` from a slug the tenant
+ *   already has (another tenant may reuse it).
  */
 
 import { describe, expect, it } from 'vitest';
@@ -19,6 +22,7 @@ import { describe, expect, it } from 'vitest';
 import type { OrgId, TeamId, TenantId, UserId } from '@kindgi/types';
 
 import type { TeamBinding, TeamMembershipBinding } from '../src/team-binding.js';
+import type { TeamSpec } from '../src/types.js';
 
 const T1 = 'tenant-1' as TenantId;
 const T2 = 'tenant-2' as TenantId;
@@ -26,6 +30,14 @@ const U1 = 'user-1' as UserId;
 const U2 = 'user-2' as UserId;
 const ORG_A = 'org-a' as OrgId;
 
+/** Create a team the test expects to succeed; its id. */
+async function createTeam(teams: TeamBinding, tenantId: TenantId, spec: TeamSpec): Promise<TeamId> {
+  const outcome = await teams.create(tenantId, spec);
+  if (outcome.kind !== 'ok')
+    throw new Error(`expected the team to be created, got ${outcome.kind}`);
+  return outcome.teamId;
+}
+
 export function runTeamBindingConformance(
   makeBinding: () => {
     readonly teams: TeamBinding;
@@ -36,7 +48,7 @@ export function runTeamBindingConformance(
   describe(`${label} — team CRUD`, () => {
     it('creates + gets a team with orgId', async () => {
       const { teams } = makeBinding();
-      const id = await teams.create(T1, {
+      const id = await createTeam(teams, T1, {
         name: 'Litigation',
         slug: 'lit',
         orgId: ORG_A,
@@ -49,27 +61,27 @@ export function runTeamBindingConformance(
 
     it('creates a cross-org team (no orgId)', async () => {
       const { teams } = makeBinding();
-      const id = await teams.create(T1, { name: 'Cross', slug: 'cross' });
+      const id = await createTeam(teams, T1, { name: 'Cross', slug: 'cross' });
       const got = await teams.get(T1, id);
       expect(got?.orgId).toBeUndefined();
     });
 
     it('updates a team; orgId=null clears the FK', async () => {
       const { teams } = makeBinding();
-      const id = await teams.create(T1, {
+      const id = await createTeam(teams, T1, {
         name: 'Litigation',
         slug: 'lit',
         orgId: ORG_A,
       });
-      await teams.update(T1, id, { orgId: null });
+      expect(await teams.update(T1, id, { orgId: null })).toEqual({ kind: 'ok' });
       const got = await teams.get(T1, id);
       expect(got?.orgId).toBeUndefined();
     });
 
     it('lists teams filtered by orgId', async () => {
       const { teams } = makeBinding();
-      await teams.create(T1, { name: 'A', slug: 'a', orgId: ORG_A });
-      await teams.create(T1, { name: 'B', slug: 'b' });
+      await createTeam(teams, T1, { name: 'A', slug: 'a', orgId: ORG_A });
+      await createTeam(teams, T1, { name: 'B', slug: 'b' });
       const inOrg = await teams.list(T1, { orgId: ORG_A });
       expect(inOrg.items).toHaveLength(1);
       expect(inOrg.items[0]?.name).toBe('A');
@@ -77,7 +89,7 @@ export function runTeamBindingConformance(
 
     it('deletes a team + cascades memberships', async () => {
       const { teams, memberships } = makeBinding();
-      const id = await teams.create(T1, { name: 'X', slug: 'x' });
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
       await memberships.add(T1, { teamId: id, userId: U1, role: 'member' });
       await teams.delete(T1, id);
       const page = await memberships.listForUser(T1, U1, {});
@@ -88,29 +100,37 @@ export function runTeamBindingConformance(
   describe(`${label} — cross-tenant isolation`, () => {
     it('team get across tenants returns undefined', async () => {
       const { teams } = makeBinding();
-      const id = await teams.create(T1, { name: 'X', slug: 'x' });
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
       expect(await teams.get(T2, id)).toBeUndefined();
     });
 
     it('team list across tenants does not leak', async () => {
       const { teams } = makeBinding();
-      await teams.create(T1, { name: 'X', slug: 'x' });
+      await createTeam(teams, T1, { name: 'X', slug: 'x' });
       const page = await teams.list(T2, {});
       expect(page.items).toEqual([]);
     });
 
-    it('adding a membership under wrong tenant errors', async () => {
+    it('adding a membership under wrong tenant → team-not-found', async () => {
       const { teams, memberships } = makeBinding();
-      const id = await teams.create(T1, { name: 'X', slug: 'x' });
-      await expect(
-        memberships.add(T2, { teamId: id, userId: U1, role: 'member' }),
-      ).rejects.toThrow();
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
+      expect(await memberships.add(T2, { teamId: id, userId: U1, role: 'member' })).toEqual({
+        kind: 'team-not-found',
+      });
+      expect((await memberships.list(T1, id, {})).items).toEqual([]);
+    });
+
+    it('update under wrong tenant → team-not-found', async () => {
+      const { teams } = makeBinding();
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
+      expect(await teams.update(T2, id, { name: 'Y' })).toEqual({ kind: 'team-not-found' });
+      expect((await teams.get(T1, id))?.name).toBe('X');
     });
 
     it('listForUser across tenants only returns tenant-scoped memberships', async () => {
       const { teams, memberships } = makeBinding();
-      const t1Team = await teams.create(T1, { name: 'A', slug: 'a' });
-      const t2Team = await teams.create(T2, { name: 'B', slug: 'b' });
+      const t1Team = await createTeam(teams, T1, { name: 'A', slug: 'a' });
+      const t2Team = await createTeam(teams, T2, { name: 'B', slug: 'b' });
       await memberships.add(T1, { teamId: t1Team, userId: U1, role: 'member' });
       await memberships.add(T2, { teamId: t2Team, userId: U1, role: 'member' });
       const t1Page = await memberships.listForUser(T1, U1, {});
@@ -125,10 +145,14 @@ export function runTeamBindingConformance(
   describe(`${label} — membership idempotency`, () => {
     it('add on existing membership is a no-op (does NOT overwrite role)', async () => {
       const { teams, memberships } = makeBinding();
-      const id = await teams.create(T1, { name: 'X', slug: 'x' });
-      await memberships.add(T1, { teamId: id, userId: U1, role: 'admin' });
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
+      expect(await memberships.add(T1, { teamId: id, userId: U1, role: 'admin' })).toEqual({
+        kind: 'ok',
+      });
       // Re-add with a different role — should be a no-op, not a mutation.
-      await memberships.add(T1, { teamId: id, userId: U1, role: 'member' });
+      expect(await memberships.add(T1, { teamId: id, userId: U1, role: 'member' })).toEqual({
+        kind: 'ok',
+      });
       const page = await memberships.list(T1, id, {});
       expect(page.items).toHaveLength(1);
       expect(page.items[0]?.role).toBe('admin');
@@ -136,21 +160,32 @@ export function runTeamBindingConformance(
 
     it('remove on missing membership is a no-op', async () => {
       const { teams, memberships } = makeBinding();
-      const id = await teams.create(T1, { name: 'X', slug: 'x' });
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
       await expect(memberships.remove(T1, id, U1)).resolves.toBeUndefined();
     });
 
-    it('updateRole on missing membership errors', async () => {
+    it('updateRole on missing membership → team-membership-not-found', async () => {
       const { teams, memberships } = makeBinding();
-      const id = await teams.create(T1, { name: 'X', slug: 'x' });
-      await expect(memberships.updateRole(T1, id, U1, 'admin')).rejects.toThrow();
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
+      expect(await memberships.updateRole(T1, id, U1, 'admin')).toEqual({
+        kind: 'team-membership-not-found',
+      });
+    });
+
+    it('updateRole on a team in another tenant → team-not-found', async () => {
+      const { teams, memberships } = makeBinding();
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
+      await memberships.add(T1, { teamId: id, userId: U1, role: 'member' });
+      expect(await memberships.updateRole(T2, id, U1, 'admin')).toEqual({
+        kind: 'team-not-found',
+      });
     });
 
     it('updateRole on existing membership mutates the role', async () => {
       const { teams, memberships } = makeBinding();
-      const id = await teams.create(T1, { name: 'X', slug: 'x' });
+      const id = await createTeam(teams, T1, { name: 'X', slug: 'x' });
       await memberships.add(T1, { teamId: id, userId: U1, role: 'member' });
-      await memberships.updateRole(T1, id, U1, 'admin');
+      expect(await memberships.updateRole(T1, id, U1, 'admin')).toEqual({ kind: 'ok' });
       const page = await memberships.list(T1, id, {});
       expect(page.items[0]?.role).toBe('admin');
     });
@@ -159,9 +194,9 @@ export function runTeamBindingConformance(
   describe(`${label} — listForUser across teams`, () => {
     it('returns every team the user belongs to in the tenant', async () => {
       const { teams, memberships } = makeBinding();
-      const a = await teams.create(T1, { name: 'A', slug: 'a' });
-      const b = await teams.create(T1, { name: 'B', slug: 'b' });
-      const c = await teams.create(T1, { name: 'C', slug: 'c' });
+      const a = await createTeam(teams, T1, { name: 'A', slug: 'a' });
+      const b = await createTeam(teams, T1, { name: 'B', slug: 'b' });
+      const c = await createTeam(teams, T1, { name: 'C', slug: 'c' });
       await memberships.add(T1, { teamId: a, userId: U1, role: 'member' });
       await memberships.add(T1, { teamId: b, userId: U1, role: 'admin' });
       await memberships.add(T1, { teamId: c, userId: U2, role: 'member' });
@@ -172,4 +207,33 @@ export function runTeamBindingConformance(
       expect(teamIds.has(b)).toBe(true);
     });
   });
+
+  describe(`${label} — slug uniqueness`, () => {
+    it('create with a slug the tenant already has → slug-conflict', async () => {
+      const { teams } = makeBinding();
+      await createTeam(teams, T1, { name: 'Litigation', slug: 'lit' });
+      expect(await teams.create(T1, { name: 'Litigation 2', slug: 'lit' })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'lit',
+      });
+      expect((await teams.list(T1, {})).items).toHaveLength(1);
+    });
+
+    it('another tenant may use the same slug', async () => {
+      const { teams } = makeBinding();
+      await createTeam(teams, T1, { name: 'Litigation', slug: 'lit' });
+      expect((await teams.create(T2, { name: 'Litigation', slug: 'lit' })).kind).toBe('ok');
+    });
+
+    it("update to another team's slug → slug-conflict; the team is unchanged", async () => {
+      const { teams } = makeBinding();
+      await createTeam(teams, T1, { name: 'A', slug: 'a' });
+      const id = await createTeam(teams, T1, { name: 'B', slug: 'b' });
+      expect(await teams.update(T1, id, { slug: 'a' })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'a',
+      });
+      expect((await teams.get(T1, id))?.slug).toBe('b');
+    });
+  });
 }