@things-factory/auth-base 10.1.4 → 10.1.7

package/tests/role-mutation-db.test.ts

@@ -0,0 +1,263 @@
+/**
+ * 역할 만들기·고치기·지우기 — **실패했을 때 무엇을 말하나**를 실 DB 로 태운다.
+ *
+ * 이 셋은 권한 편집 화면이 서는 자리인데, 세 갈래의 실패가 전부 잘못된 말로 나가고 있었다.
+ *
+ *  ① 부모 도메인의 역할을 고치려 하면 `role.name` 에서 TypeError → 500. 화면은 이유를 모른다.
+ *     목록은 상속으로 부모 역할까지 보여 주므로(`inherited: Include`) **실제로 자주 닿는다.**
+ *  ② `privileges` 없는 patch(이름만 고치기)도 `patch.privileges.map` 에서 500.
+ *  ③ `deleteRole` 의 catch 가 무엇이 났든 「사용 중이라 지울 수 없다」로 401 을 던졌다 —
+ *     못 찾은 것도 그렇게 말했다. 관리자는 있지도 않은 사용자를 떼러 갔다.
+ *
+ * 그리고 `deleteRoles`(복수)는 **도메인을 아예 안 봤다** — id 만 알면 남의 도메인 역할이 지워졌다.
+ *
+ * 지시자는 여기서 안 돈다(스키마 층이다). 게이트는 `privilege-directive.test.ts` 가 본다.
+ */
+
+import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
+import { authDataSource } from './db'
+import { loadCompiled } from './compiled'
+
+const { Role } = loadCompiled('service/role/role')
+const { Privilege } = loadCompiled('service/privilege/privilege')
+const { User } = loadCompiled('service/user/user')
+const { RoleMutation } = loadCompiled('service/role/role-mutation')
+
+const mutation = new RoleMutation()
+
+let parent: any
+let child: any
+let stranger: any
+let actor: any
+let boardQuery: any
+let boardMutation: any
+
+async function loadDomain(id: string) {
+  return await getRepository(Domain).findOneBy({ id })
+}
+
+/** 리졸버가 실제로 쓰는 것만 담는다 — `tx`·`domain`·`user`·`t`·`throw`. */
+function context(domain: any) {
+  return {
+    state: { domain, user: actor, tx: authDataSource().manager },
+    t: (key: string, params: any = {}) => `${key}${params.x ? `:${params.x}` : ''}`,
+    throw: (status: number, message: string) => {
+      throw new Error(`${status} ${message}`)
+    }
+  } as any
+}
+
+beforeAll(async () => {
+  await openAuthDatabase()
+})
+
+afterAll(async () => {
+  await closeAuthDatabase()
+})
+
+beforeEach(async () => {
+  await resetAuthDatabase()
+
+  const domainRepository = getRepository(Domain)
+  const savedParent = await domainRepository.save({ name: 'HQ', subdomain: 'hq' })
+  const savedChild = await domainRepository.save({ name: 'Plant A', subdomain: 'plant-a', parent: savedParent })
+  const savedStranger = await domainRepository.save({ name: 'Other', subdomain: 'other' })
+
+  parent = await loadDomain(savedParent.id)
+  child = await loadDomain(savedChild.id)
+  stranger = await loadDomain(savedStranger.id)
+
+  const privilegeRepository = getRepository(Privilege)
+  boardQuery = await privilegeRepository.save({ name: 'query', category: 'board' })
+  boardMutation = await privilegeRepository.save({ name: 'mutation', category: 'board' })
+
+  const salt = User.generateSalt()
+  actor = await getRepository(User).save({
+    username: 'admin',
+    email: 'admin@example.com',
+    name: 'Admin',
+    salt,
+    status: 'activated',
+    domains: [child]
+  })
+})
+
+async function makeRole(name: string, domain: any, privileges: any[] = [], users: any[] = []) {
+  return await getRepository(Role).save({ name, domain, privileges, users })
+}
+
+describe('고치기', () => {
+  it('권한을 갈아 끼운다', async () => {
+    const role = await makeRole('viewer', child, [boardQuery])
+
+    await mutation.updateRole(role.id, { privileges: [{ id: boardMutation.id }] } as any, context(child))
+
+    const saved = await getRepository(Role).findOne({ where: { id: role.id }, relations: ['privileges'] })
+    expect(saved.privileges.map((p: any) => p.id)).toEqual([boardMutation.id])
+  })
+
+  it('`privileges` 를 안 보내면 권한을 건드리지 않는다 — 이름만 고치는 호출이 있다', async () => {
+    /* 예전에는 이 호출이 `patch.privileges.map` 에서 TypeError 로 500 이었다. */
+    const role = await makeRole('viewer', child, [boardQuery])
+
+    await mutation.updateRole(role.id, { name: 'reader' } as any, context(child))
+
+    const saved = await getRepository(Role).findOne({ where: { id: role.id }, relations: ['privileges'] })
+    expect(saved.name).toBe('reader')
+    expect(saved.privileges.map((p: any) => p.id)).toEqual([boardQuery.id])
+  })
+
+  it('부모 도메인의 역할은 어디서 고치는지 말하고 거절한다', async () => {
+    /*
+     * 목록에 보이는 것과 고칠 수 있는 것이 다르다. 예전에는 여기서 TypeError 가 나 500 이었고
+     * 화면은 「알 수 없는 오류」만 보여 줬다.
+     */
+    const role = await makeRole('shared', parent, [boardQuery])
+
+    await expect(mutation.updateRole(role.id, { name: 'mine' } as any, context(child))).rejects.toThrow(
+      /parent domain/
+    )
+  })
+
+  it('같은 이름이 이미 있으면 거절한다', async () => {
+    await makeRole('viewer', child)
+    const role = await makeRole('editor', child)
+
+    await expect(mutation.updateRole(role.id, { name: 'viewer' } as any, context(child))).rejects.toThrow(
+      'role name is duplicated'
+    )
+  })
+})
+
+describe('지우기 — 하나', () => {
+  it('아무도 안 가진 역할은 지운다', async () => {
+    const role = await makeRole('unused', child, [boardQuery])
+
+    expect(await mutation.deleteRole(role.id, context(child))).toBe(true)
+    expect(await getRepository(Role).findOneBy({ id: role.id })).toBeNull()
+  })
+
+  it('가진 사람이 있으면 그 이유로 거절한다', async () => {
+    const role = await makeRole('in-use', child, [boardQuery], [actor])
+
+    await expect(mutation.deleteRole(role.id, context(child))).rejects.toThrow('currently in use')
+    expect(await getRepository(Role).findOneBy({ id: role.id })).not.toBeNull()
+  })
+
+  it('부모 도메인의 역할을 「사용 중」이라고 말하지 않는다', async () => {
+    /*
+     * 이것이 옛 구현의 가장 나쁜 점이었다 — 못 찾은 것을 「사용 중」이라고 말했으므로 관리자는
+     * 있지도 않은 사용자를 찾아 떼려 했다.
+     */
+    const role = await makeRole('shared', parent)
+
+    await expect(mutation.deleteRole(role.id, context(child))).rejects.toThrow(/parent domain/)
+    await expect(mutation.deleteRole(role.id, context(child))).rejects.not.toThrow(/in use/)
+  })
+})
+
+describe('지우기 — 여럿', () => {
+  it('남의 도메인 역할은 id 를 알아도 안 지운다', async () => {
+    const mine = await makeRole('mine', child)
+    const theirs = await makeRole('theirs', stranger)
+
+    await mutation.deleteRoles([mine.id, theirs.id], context(child))
+
+    expect(await getRepository(Role).findOneBy({ id: mine.id })).toBeNull()
+    expect(await getRepository(Role).findOneBy({ id: theirs.id })).not.toBeNull()
+  })
+
+  it('사용 중인 역할은 남긴다 — 하나 지우기와 같은 규칙이다', async () => {
+    const unused = await makeRole('unused', child)
+    const inUse = await makeRole('in-use', child, [], [actor])
+
+    await mutation.deleteRoles([unused.id, inUse.id], context(child))
+
+    expect(await getRepository(Role).findOneBy({ id: unused.id })).toBeNull()
+    expect(await getRepository(Role).findOneBy({ id: inUse.id })).not.toBeNull()
+  })
+})
+
+/**
+ * 격자에서 여러 줄을 고쳐 한 번에 보내는 길.
+ *
+ * 목록 화면이 `dirtyRecords` 를 `cuFlag` 와 함께 보낸다. 여기서 지키는 것은 하나가 제일 크다 —
+ * **`privileges` 를 안 보낸 patch 가 권한을 비우지 않는 것.** 격자는 이름만 고치는데 그것이
+ * 권한을 지우면 그 역할이 아무것도 안 여는 역할이 된다.
+ */
+describe('격자에서 여럿 저장', () => {
+  it('`+` 는 만들고 `M` 은 고친다', async () => {
+    const existing = await makeRole('viewer', child, [boardQuery])
+
+    await mutation.updateMultipleRole(
+      [
+        { cuFlag: '+', name: 'operator', description: '현장' },
+        { cuFlag: 'M', id: existing.id, name: 'reader' }
+      ] as any,
+      context(child)
+    )
+
+    const roles = await getRepository(Role).find({ where: { domain: { id: child.id } } })
+    expect(roles.map((r: any) => r.name).sort()).toEqual(['operator', 'reader'])
+  })
+
+  it('이름만 고쳐도 권한은 그대로다 — 격자는 권한을 안 보낸다', async () => {
+    /*
+     * 이것이 이 자리의 가장 조용한 결함이 될 수 있었다. 관리자가 격자에서 오타를 고쳤는데
+     * 그 역할이 아무것도 안 여는 역할이 되면, 그 역할을 가진 사람들이 다음 로그인에 막힌다.
+     */
+    const role = await makeRole('viewer', child, [boardQuery, boardMutation])
+
+    await mutation.updateMultipleRole([{ cuFlag: 'M', id: role.id, name: 'reader' }] as any, context(child))
+
+    const saved = await getRepository(Role).findOne({ where: { id: role.id }, relations: ['privileges'] })
+    expect(saved.privileges.map((p: any) => p.id).sort()).toEqual([boardMutation.id, boardQuery.id].sort())
+  })
+
+  it('`cuFlag` 가 없는 줄은 아무것도 하지 않는다 — 짐작해서 만들지 않는다', async () => {
+    await mutation.updateMultipleRole([{ name: 'ghost' }] as any, context(child))
+
+    expect(await getRepository(Role).findOneBy({ name: 'ghost' })).toBeNull()
+  })
+
+  it('부모 도메인의 역할을 고치려 하면 어디서 고치는지 말한다', async () => {
+    const role = await makeRole('shared', parent)
+
+    await expect(
+      mutation.updateMultipleRole([{ cuFlag: 'M', id: role.id, name: 'mine' }] as any, context(child))
+    ).rejects.toThrow(/parent domain/)
+  })
+
+  it('이름 없이 만들려 하면 거절한다', async () => {
+    await expect(mutation.updateMultipleRole([{ cuFlag: '+', name: '  ' }] as any, context(child))).rejects.toThrow()
+  })
+
+  it('같은 이름으로 만들려 하면 거절한다', async () => {
+    await makeRole('operator', child)
+
+    await expect(
+      mutation.updateMultipleRole([{ cuFlag: '+', name: 'operator' }] as any, context(child))
+    ).rejects.toThrow('role name is duplicated')
+  })
+})
+
+describe('만들기', () => {
+  it('내 도메인에 만들고 고른 권한을 붙인다', async () => {
+    const created = await mutation.createRole(
+      { name: 'operator', privileges: [{ id: boardQuery.id }] } as any,
+      context(child)
+    )
+
+    const saved = await getRepository(Role).findOne({ where: { id: created.id }, relations: ['privileges', 'domain'] })
+    expect(saved.domain.id).toBe(child.id)
+    expect(saved.privileges.map((p: any) => p.id)).toEqual([boardQuery.id])
+  })
+
+  it('같은 도메인에 같은 이름은 안 만든다', async () => {
+    await makeRole('operator', child)
+
+    await expect(mutation.createRole({ name: 'operator' } as any, context(child))).rejects.toThrow(
+      'role name is duplicated'
+    )
+  })
+})

package/tests/role-privileges-db.test.ts

@@ -0,0 +1,226 @@
+/**
+ * `rolePrivileges` — 권한 편집 화면이 드는 **한 번의 질의**를 실 DB 로 태운다.
+ *
+ * 이 질의는 두 가지를 함께 답한다: 「무엇이 있나」와 「이 역할이 무엇을 갖나」. 화면이 그것을
+ * 질의 둘로 받으면 짝짓기를 화면이 해야 하는데, 옛 화면은 그 짝을 역할 **이름**으로 맞췄고
+ * 부모 도메인에 같은 이름의 역할이 있으면 남의 권한을 그렸다.
+ *
+ * 그리고 이 질의는 얼마 전까지 **원시 SQL** 이었다. 셋을 동시에 잃고 있었다 —
+ * `roleId` 문자열 이어 붙이기, `THEN true`(MSSQL 에 없는 리터럴), 도메인 무시. 아래 시험이
+ * 그 셋 중 되돌아올 수 있는 둘을 붙잡는다.
+ *
+ * ⚠ sqlite 로는 방언 문제를 **못 본다**(`tests/db.ts`). 그것은 원시 SQL 을 안 쓰는 것으로만
+ *   막힌다. 그래서 이 시험은 「관계로 읽는다」는 결과를 지키고, 방언은 코드에서 지운다.
+ */
+
+import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
+import { loadCompiled } from './compiled'
+
+const { Role } = loadCompiled('service/role/role')
+const { Privilege } = loadCompiled('service/privilege/privilege')
+const { User } = loadCompiled('service/user/user')
+const { RoleQuery } = loadCompiled('service/role/role-query')
+
+const query = new RoleQuery()
+
+let parent: any
+let child: any
+let stranger: any
+let boardQuery: any
+let boardMutation: any
+
+/** `parentId` 는 `@RelationId` 라 저장소로 읽은 도메인에만 실린다. */
+async function loadDomain(id: string) {
+  return await getRepository(Domain).findOneBy({ id })
+}
+
+/** 지시자가 없으므로 리졸버 본문을 직접 부른다 — 게이트는 `privilege-directive.test.ts` 가 본다. */
+function ask(roleId: string, domain: any) {
+  return query.rolePrivileges(roleId, { state: { domain } } as any)
+}
+
+function askUserRoles(userId: string, domain: any) {
+  return query.userRoles(userId, { state: { domain } } as any)
+}
+
+beforeAll(async () => {
+  await openAuthDatabase()
+})
+
+afterAll(async () => {
+  await closeAuthDatabase()
+})
+
+beforeEach(async () => {
+  await resetAuthDatabase()
+
+  const domainRepository = getRepository(Domain)
+
+  const savedParent = await domainRepository.save({ name: 'HQ', subdomain: 'hq' })
+  const savedChild = await domainRepository.save({ name: 'Plant A', subdomain: 'plant-a', parent: savedParent })
+  const savedStranger = await domainRepository.save({ name: 'Other', subdomain: 'other' })
+
+  parent = await loadDomain(savedParent.id)
+  child = await loadDomain(savedChild.id)
+  stranger = await loadDomain(savedStranger.id)
+
+  const privilegeRepository = getRepository(Privilege)
+  boardQuery = await privilegeRepository.save({ name: 'query', category: 'board' })
+  boardMutation = await privilegeRepository.save({ name: 'mutation', category: 'board' })
+})
+
+describe('가진 것과 안 가진 것', () => {
+  it('전체 권한을 돌려주고, 가진 것에만 표시한다', async () => {
+    const role = await getRepository(Role).save({ name: 'viewer', domain: child, privileges: [boardQuery] })
+
+    const rows = await ask(role.id, child)
+
+    expect(rows).toHaveLength(2)
+    expect(rows.find(row => row.id === boardQuery.id).assigned).toBe(true)
+    expect(rows.find(row => row.id === boardMutation.id).assigned).toBe(false)
+  })
+
+  it('아무것도 없는 역할에도 목록을 준다 — 편집을 시작할 수 있어야 한다', async () => {
+    const role = await getRepository(Role).save({ name: 'blank', domain: child, privileges: [] })
+
+    const rows = await ask(role.id, child)
+
+    expect(rows).toHaveLength(2)
+    expect(rows.every(row => row.assigned === false)).toBe(true)
+  })
+})
+
+describe('도메인 범위', () => {
+  it('부모 도메인의 역할은 볼 수 있다 — 상속으로 목록에 나오는 것과 같은 범위다', async () => {
+    const role = await getRepository(Role).save({ name: 'shared', domain: parent, privileges: [boardMutation] })
+
+    const rows = await ask(role.id, child)
+
+    expect(rows.find(row => row.id === boardMutation.id).assigned).toBe(true)
+  })
+
+  it('남의 도메인 역할은 못 본다 — id 를 알아도 답하지 않는다', async () => {
+    const role = await getRepository(Role).save({ name: 'theirs', domain: stranger, privileges: [boardMutation] })
+
+    expect(await ask(role.id, child)).toEqual([])
+  })
+
+  it('자식 도메인의 역할도 못 본다 — 상속은 위로 한 단이고 아래로는 없다', async () => {
+    const role = await getRepository(Role).save({ name: 'local', domain: child, privileges: [boardQuery] })
+
+    expect(await ask(role.id, parent)).toEqual([])
+  })
+})
+
+describe('없는 역할', () => {
+  it('빈 목록을 준다 — 「전체 권한을 아무것도 안 가진 역할」로 보이지 않는다', async () => {
+    /*
+     * 이 구별이 화면에서 중요하다. 전체 목록을 주면서 `assigned` 를 전부 거짓으로 두면
+     * 화면은 「권한이 하나도 없는 역할」을 그리고, 관리자가 저장하면 **실제로** 그렇게 된다.
+     */
+    expect(await ask('00000000-0000-0000-0000-000000000000', child)).toEqual([])
+  })
+})
+
+describe('부러지지 않는다', () => {
+  it('id 자리에 SQL 을 넣어도 던지지 않고 빈 목록을 준다', async () => {
+    /*
+     * 옛 구현은 이 문자열을 SQL 에 그대로 이어 붙였다. `user:query` 를 가진 사람이 닿는
+     * 자리이므로 그것으로 충분히 위험했다. 지금은 값으로만 쓰인다.
+     */
+    expect(await ask("' OR 1=1 --", child)).toEqual([])
+  })
+})
+
+/**
+ * 목록이 쓰는 **수**.
+ *
+ * 목록이 「이 역할이 무엇을 여나」를 말하려고 권한 **행**을 받고 있었다 — 역할 20개에
+ * 5,731 bytes · 69ms 대 518 bytes · 7ms(UX 레인 실측). 행을 안 받고 수를 받는다.
+ */
+describe('권한 수', () => {
+  it('가진 것만 센다', async () => {
+    const role = await getRepository(Role).save({ name: 'viewer', domain: child, privileges: [boardQuery] })
+
+    expect(await query.privilegeCount(role)).toBe(1)
+  })
+
+  it('하나도 없으면 0 이다 — 「모른다」가 아니라 0 이다', async () => {
+    const role = await getRepository(Role).save({ name: 'blank', domain: child, privileges: [] })
+
+    expect(await query.privilegeCount(role)).toBe(0)
+  })
+
+  it('다른 역할의 권한을 세지 않는다', async () => {
+    await getRepository(Role).save({ name: 'other', domain: child, privileges: [boardQuery, boardMutation] })
+    const mine = await getRepository(Role).save({ name: 'mine', domain: child, privileges: [boardQuery] })
+
+    expect(await query.privilegeCount(mine)).toBe(1)
+  })
+})
+
+/**
+ * 한 사람의 역할 — `rolePrivileges` 와 **같은 결함을 갖고 있던** 자리.
+ *
+ * 원시 SQL 로 `userId` 를 이어 붙이고, MSSQL 에 없는 `THEN true` 를 쓰고, `FROM roles` 로
+ * **도메인을 아예 안 봤다.** 한 자리를 고쳤으면 두 번째 자리도 재야 한다.
+ */
+describe('사용자의 역할', () => {
+  async function makeUser(roles: any[]) {
+    const salt = User.generateSalt()
+    return await getRepository(User).save({
+      username: `u-${Math.random().toString(36).slice(2, 8)}`,
+      email: `u-${Math.random().toString(36).slice(2, 8)}@example.com`,
+      name: 'Kim',
+      salt,
+      status: 'activated',
+      domains: [child],
+      roles
+    })
+  }
+
+  it('부여할 수 있는 전체를 주고, 가진 것에만 표시한다', async () => {
+    const held = await getRepository(Role).save({ name: 'held', domain: child })
+    await getRepository(Role).save({ name: 'free', domain: child })
+    const user = await makeUser([held])
+
+    const rows = await askUserRoles(user.id, child)
+
+    expect(rows).toHaveLength(2)
+    expect(rows.find(row => row.id === held.id).assigned).toBe(true)
+    expect(rows.find(row => row.name === 'free').assigned).toBe(false)
+  })
+
+  it('부모 도메인의 역할도 준다 — 상속이 부여 범위다', async () => {
+    await getRepository(Role).save({ name: 'shared', domain: parent })
+    const user = await makeUser([])
+
+    expect((await askUserRoles(user.id, child)).map((row: any) => row.name)).toEqual(['shared'])
+  })
+
+  it('남의 도메인 역할은 주지 않는다 — 예전에는 전부 줬다', async () => {
+    await getRepository(Role).save({ name: 'theirs', domain: stranger })
+    await getRepository(Role).save({ name: 'mine', domain: child })
+    const user = await makeUser([])
+
+    expect((await askUserRoles(user.id, child)).map((row: any) => row.name)).toEqual(['mine'])
+  })
+
+  it('없는 사용자에게도 목록을 준다 — 가진 것이 0 인 것과 같다', async () => {
+    await getRepository(Role).save({ name: 'mine', domain: child })
+
+    const rows = await askUserRoles('00000000-0000-0000-0000-000000000000', child)
+
+    expect(rows).toHaveLength(1)
+    expect(rows[0].assigned).toBe(false)
+  })
+
+  it('id 자리에 SQL 을 넣어도 던지지 않는다', async () => {
+    await getRepository(Role).save({ name: 'mine', domain: child })
+
+    const rows = await askUserRoles("' OR 1=1 --", child)
+
+    expect(rows).toHaveLength(1)
+    expect(rows[0].assigned).toBe(false)
+  })
+})

package/tests/role-template-seed-db.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Seeding a role from a template — against a real database.
+ *
+ * `role-template.test.ts` covers what the registry accepts. What it cannot cover is the
+ * part that touches rows, and that is where the rules with teeth are:
+ *
+ *  - the plant names the seat, not the template;
+ *  - an existing name is reused rather than duplicated, because approval lines hold a
+ *    role's id and a second row would leave them pointing at the one nobody edits;
+ *  - two templates on one name make the union, and privileges are never taken away;
+ *  - a privilege this installation does not declare is skipped, never invented.
+ */
+
+import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
+import { authDataSource } from './db'
+import { loadCompiled } from './compiled'
+
+const { Role } = loadCompiled('service/role/role')
+const { Privilege } = loadCompiled('service/privilege/privilege')
+const { User } = loadCompiled('service/user/user')
+const { RoleTemplateMutation } = loadCompiled('service/role-template/role-template-mutation')
+const { registerRoleTemplate } = loadCompiled('service/role-template/role-template')
+
+const mutation = new RoleTemplateMutation()
+
+let domain: any
+let actor: any
+let boardQuery: any
+let boardMutation: any
+
+function context() {
+  return {
+    state: { domain, user: actor, tx: authDataSource().manager }
+  } as any
+}
+
+async function privilegesOf(id: string): Promise<string[]> {
+  const role = await getRepository(Role).findOne({ where: { id }, relations: ['privileges'] })
+
+  return (role!.privileges || []).map((one: any) => `${one.category}:${one.name}`).sort()
+}
+
+beforeAll(async () => {
+  await openAuthDatabase()
+})
+
+afterAll(async () => {
+  await closeAuthDatabase()
+})
+
+beforeEach(async () => {
+  await resetAuthDatabase()
+  ;(process as any)['ROLE_TEMPLATES'] = {}
+
+  const saved = await getRepository(Domain).save({ name: 'Plant A', subdomain: 'plant-a' })
+  domain = await getRepository(Domain).findOneBy({ id: saved.id })
+
+  const privilegeRepository = getRepository(Privilege)
+  boardQuery = await privilegeRepository.save({ name: 'query', category: 'board' })
+  boardMutation = await privilegeRepository.save({ name: 'mutation', category: 'board' })
+
+  /* The gate reads this; seeding reads the rows above. Both have to agree. */
+  ;(process as any).PRIVILEGES = {
+    'board query': ['board', 'query'],
+    'board mutation': ['board', 'mutation']
+  }
+
+  actor = await getRepository(User).save({
+    username: 'admin',
+    email: 'admin@example.com',
+    name: 'Admin',
+    salt: User.generateSalt(),
+    status: 'activated',
+    domains: [domain]
+  })
+})
+
+describe('seeding', () => {
+  it('creates the role with the privileges the template names', async () => {
+    registerRoleTemplate({
+      id: 'plant.qi',
+      name: 'QUALITY-INSPECTOR',
+      grants: [{ category: 'board', axes: ['query'] }]
+    })
+
+    const role = await mutation.createRoleFromTemplate('plant.qi', undefined, context())
+
+    expect(role.name).toBe('QUALITY-INSPECTOR')
+    expect(await privilegesOf(role.id)).toEqual(['board:query'])
+  })
+
+  it('lets the plant name the seat itself', async () => {
+    registerRoleTemplate({ id: 'plant.qi', name: 'QUALITY-INSPECTOR', grants: [{ category: 'board', axes: ['query'] }] })
+
+    const role = await mutation.createRoleFromTemplate('plant.qi', '품질검사원', context())
+
+    expect(role.name).toBe('품질검사원')
+    expect(await privilegesOf(role.id)).toEqual(['board:query'])
+  })
+
+  it('makes a second seat from one template when the name differs — day shift and night shift', async () => {
+    registerRoleTemplate({ id: 'plant.qi', name: 'QUALITY-INSPECTOR', grants: [{ category: 'board', axes: ['query'] }] })
+
+    const day = await mutation.createRoleFromTemplate('plant.qi', 'QI-DAY', context())
+    const night = await mutation.createRoleFromTemplate('plant.qi', 'QI-NIGHT', context())
+
+    expect(day.id).not.toBe(night.id)
+    expect(await privilegesOf(day.id)).toEqual(['board:query'])
+    expect(await privilegesOf(night.id)).toEqual(['board:query'])
+  })
+
+  it('reuses an existing role of that name instead of creating a second one', async () => {
+    registerRoleTemplate({ id: 'plant.qi', name: 'QUALITY-INSPECTOR', grants: [{ category: 'board', axes: ['query'] }] })
+
+    const existing = await getRepository(Role).save({ name: 'QUALITY-INSPECTOR', domain, privileges: [] })
+    const role = await mutation.createRoleFromTemplate('plant.qi', undefined, context())
+
+    expect(role.id).toBe(existing.id)
+    expect(await getRepository(Role).count()).toBe(1)
+  })
+
+  it('adds the union when two applications declare the same seat', async () => {
+    registerRoleTemplate({ id: 'plant.qi', name: 'QUALITY-INSPECTOR', grants: [{ category: 'board', axes: ['query'] }] })
+    registerRoleTemplate({
+      id: 'twin.qi',
+      name: 'QUALITY-INSPECTOR',
+      grants: [{ category: 'board', axes: ['mutation'] }]
+    })
+
+    await mutation.createRoleFromTemplate('plant.qi', undefined, context())
+    const role = await mutation.createRoleFromTemplate('twin.qi', undefined, context())
+
+    expect(await privilegesOf(role.id)).toEqual(['board:mutation', 'board:query'])
+    expect(await getRepository(Role).count()).toBe(1)
+  })
+
+  it('leaves privileges the administrator added, and takes nothing away', async () => {
+    registerRoleTemplate({ id: 'plant.qi', name: 'QUALITY-INSPECTOR', grants: [{ category: 'board', axes: ['query'] }] })
+
+    const existing = await getRepository(Role).save({
+      name: 'QUALITY-INSPECTOR',
+      domain,
+      privileges: [boardMutation]
+    })
+
+    await mutation.createRoleFromTemplate('plant.qi', undefined, context())
+
+    expect(await privilegesOf(existing.id)).toEqual(['board:mutation', 'board:query'])
+  })
+
+  it('skips a privilege this installation does not declare rather than inventing the row', async () => {
+    registerRoleTemplate({
+      id: 'plant.x',
+      name: 'X',
+      grants: [
+        { category: 'board', axes: ['query'] },
+        { category: 'board-ai', axes: ['query'] }
+      ]
+    })
+
+    const role = await mutation.createRoleFromTemplate('plant.x', undefined, context())
+
+    expect(await privilegesOf(role.id)).toEqual(['board:query'])
+    expect(await getRepository(Privilege).count()).toBe(2)
+  })
+
+  it('refuses a template this installation does not have', async () => {
+    await expect(mutation.createRoleFromTemplate('plant.missing', undefined, context())).rejects.toThrow(
+      /no role template/
+    )
+  })
+
+  it('seeds the framework-computed administrator without any application declaring it', async () => {
+    const role = await mutation.createRoleFromTemplate('framework.administrator', undefined, context())
+
+    expect(role.name).toBe('ADMINISTRATOR')
+    expect(await privilegesOf(role.id)).toEqual(['board:mutation', 'board:query'])
+  })
+})