@things-factory/auth-base 10.1.3 → 10.1.6

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,128 @@
+/**
+ * `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 { 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)
+}
+
+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([])
+  })
+})

package/tests/signin-policy.test.ts

@@ -0,0 +1,200 @@
+/**
+ * `signin` 의 상태 정책 — 실 DB 로 잠금까지 몰아 본다.
+ *
+ * 이 경로는 플랫폼에서 사람이 들어오는 **유일한 문**인데 시험이 하나도 없었다. 정책이 코드에
+ * 흩어져 있고(실패 셈, 잠금, `status` 분기 넷), 순서가 결과를 바꾼다 — 그래서 읽기만으로는
+ * 「이 계정이 왜 못 들어오나」를 말할 수 없다.
+ *
+ * ── 실제로 부르는 모양을 그대로 쓴다 ────────────────────────────────────────
+ * `signinMiddleware:20` 은 `signin({ username, password })` 를 **context 없이** 부른다.
+ * 그래서 시험도 context 를 넘기지 않는다 — 넘기면 시험이 화면보다 나은 조건에서 도는 것이 된다.
+ * 그 차이가 아래 「잠금 해제 메일」 케이스의 주제다.
+ */
+
+import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
+import { loadCompiled } from './compiled'
+
+const { User } = loadCompiled('service/user/user')
+const { signin } = loadCompiled('controllers/signin')
+const { VerificationToken } = loadCompiled('service/verification-token/verification-token')
+/* 오류 코드는 문자열이고 표기가 제각각이다(`'user not found'` · `'password-not-matched'`).
+   시험이 그 표기를 베껴 쓰면 코드를 고칠 때 시험만 조용히 틀린다 — 상수를 그대로 든다. */
+const CODES = loadCompiled('constants/error-code')
+
+const PASSWORD = 'Passw0rd!'
+const WRONG = 'Wr0ngPass!'
+
+let domain: any
+
+async function seedUser(overrides: any = {}) {
+  const salt = User.generateSalt()
+
+  return await getRepository(User).save({
+    username: 'kim',
+    email: 'kim@example.com',
+    name: 'Kim',
+    salt,
+    password: User.encode(PASSWORD, salt),
+    status: 'activated',
+    domains: [domain],
+    ...overrides
+  })
+}
+
+/** 실 경로와 같게 — context 없이 부른다. */
+const attempt = (password: string, username = 'kim') => signin({ username, password })
+
+async function reload(id: string) {
+  return await getRepository(User).findOneBy({ id })
+}
+
+beforeAll(async () => {
+  await openAuthDatabase()
+})
+
+beforeEach(async () => {
+  await resetAuthDatabase()
+  domain = await getRepository(Domain).save({ name: 'plant-a', subdomain: 'plant-a' })
+})
+
+afterAll(async () => {
+  await closeAuthDatabase()
+})
+
+describe('들어가기', () => {
+  it('맞는 비밀번호로 토큰과 소속 도메인을 받는다', async () => {
+    const user = await seedUser()
+
+    const result = await attempt(PASSWORD)
+
+    expect(result.token).toBeTruthy()
+    expect(result.user.id).toBe(user.id)
+    expect(result.domains.map((d: any) => d.subdomain)).toEqual(['plant-a'])
+  })
+
+  it('username 이 아니라 email 로도 들어간다', async () => {
+    await seedUser()
+
+    const result = await attempt(PASSWORD, 'kim@example.com')
+
+    expect(result.token).toBeTruthy()
+  })
+})
+
+describe('실패 셈과 잠금', () => {
+  it('틀릴 때마다 셈이 하나 오른다', async () => {
+    const user = await seedUser()
+
+    for (const expected of [1, 2, 3, 4]) {
+      await expect(attempt(WRONG)).rejects.toThrow()
+      expect((await reload(user.id)).failCount).toBe(expected)
+    }
+
+    /* 4회까지는 아직 열려 있다. */
+    expect((await reload(user.id)).status).toBe('activated')
+  })
+
+  it('다섯 번째에 잠긴다', async () => {
+    const user = await seedUser()
+
+    for (let i = 0; i < 5; i++) {
+      await expect(attempt(WRONG)).rejects.toThrow()
+    }
+
+    const locked = await reload(user.id)
+    expect(locked.status).toBe('locked')
+    expect(locked.failCount).toBe(5)
+  })
+
+  it('잠긴 뒤에는 **맞는 비밀번호도** 거절한다', async () => {
+    /* 잠금 검사가 비밀번호 대조보다 먼저 온다(signin.ts:39). 그래서 남이 남의 계정을
+       잠글 수 있고, 잠긴 뒤 본인도 못 들어온다 — 지금 정책이 그렇다. */
+    const user = await seedUser({ status: 'locked' })
+
+    await expect(attempt(PASSWORD)).rejects.toThrow()
+    expect((await reload(user.id)).status).toBe('locked')
+  })
+
+  it('성공하면 셈이 0 으로 돌아간다', async () => {
+    const user = await seedUser()
+
+    await expect(attempt(WRONG)).rejects.toThrow()
+    await expect(attempt(WRONG)).rejects.toThrow()
+    expect((await reload(user.id)).failCount).toBe(2)
+
+    await attempt(PASSWORD)
+    expect((await reload(user.id)).failCount).toBe(0)
+  })
+})
+
+describe('상태 분기', () => {
+  it('삭제된 계정은 비밀번호를 보기도 전에 거절한다', async () => {
+    const user = await seedUser({ status: 'deleted' })
+
+    await expect(attempt(PASSWORD)).rejects.toThrow()
+    /* 셈이 오르지 않는다 — 비밀번호 대조 앞에서 끊긴다. */
+    expect((await reload(user.id)).failCount).toBe(0)
+  })
+
+  it('미활성 계정은 비밀번호를 **맞춘 뒤에** 거절한다', async () => {
+    /* 순서가 뜻을 만든다: 틀리면 「비밀번호가 틀렸다」, 맞히면 「활성화되지 않았다」.
+       즉 미활성 계정에 대해 비밀번호 맞음/틀림이 응답으로 갈린다. */
+    const user = await seedUser({ status: 'inactive' })
+
+    await expect(attempt(WRONG)).rejects.toMatchObject({ errorCode: CODES.PASSWORD_NOT_MATCHED })
+    await expect(attempt(PASSWORD)).rejects.toMatchObject({ errorCode: CODES.USER_NOT_ACTIVATED })
+  })
+
+  it('없는 계정과 틀린 비밀번호가 다른 오류 코드로 갈린다', async () => {
+    await seedUser()
+
+    await expect(attempt(PASSWORD, 'nobody')).rejects.toMatchObject({ errorCode: CODES.USER_NOT_FOUND })
+    await expect(attempt(WRONG)).rejects.toMatchObject({ errorCode: CODES.PASSWORD_NOT_MATCHED })
+  })
+})
+
+describe('실패 응답에 실려 나가는 것', () => {
+  it('인증되지 않은 실패가 email 과 남은 시도 횟수를 함께 싣는다', async () => {
+    /* `detail` 이 화면까지 가는 경로가 있다. 아무 자격 없이 세 가지를 알 수 있다 —
+       그 계정이 있다는 것, 그 계정의 email, 그리고 잠기기까지 몇 번 남았는지. */
+    await seedUser()
+
+    await expect(attempt(WRONG)).rejects.toMatchObject({
+      detail: { username: 'kim', email: 'kim@example.com', failCount: 1 }
+    })
+  })
+})
+
+describe('잠금 해제 메일', () => {
+  it('잠기면 해제 토큰이 만들어진다', async () => {
+    /*
+     * ⚠ **부르는 쪽이 `await` 하지 않는다** — `signin.ts:40,58` 이 `sendUnlockUserEmail(...)` 을
+     * 띄워 놓고 곧바로 던진다. 그래서 시험이 바로 읽으면 **0건이 나온다.** 그 0건은 제품의
+     * 사실이 아니라 아직 도착하지 않은 쓰기다(처음에 그것을 「메일이 안 간다」로 읽었다).
+     *
+     * 여기서는 그 성질 자체를 고정한다: 즉시 읽으면 없고, 기다리면 있다. 언젠가 그 호출에
+     * `await` 가 붙으면 앞의 기대가 깨져서 알려 줄 것이다.
+     *
+     * 메일 발송 자체는 이 하네스로 확인하지 않는다 — `sendEmail` 이 `config.get('email')` 을
+     * 읽는데 시험 환경에는 그 설정이 없다(`emailInfo.sender` 에서 던진다). 발송은 운영 설정의
+     * 일이고, 실제로 도착하고 있음을 사용자가 확인했다.
+     */
+    const user = await seedUser()
+
+    for (let i = 0; i < 5; i++) {
+      await expect(attempt(WRONG)).rejects.toThrow()
+    }
+
+    expect((await reload(user.id)).status).toBe('locked')
+
+    /* 던진 직후에는 아직 없다 — 부르는 쪽이 기다리지 않기 때문이다. */
+    expect(await getRepository(VerificationToken).find()).toHaveLength(0)
+
+    await new Promise(resolve => setTimeout(resolve, 300))
+
+    const tokens = await getRepository(VerificationToken).find()
+    expect(tokens).toHaveLength(1)
+    expect(tokens[0].type).toBe('unlock')
+    expect(tokens[0].userId).toBe(user.id)
+  })
+})