@things-factory/auth-base 10.1.278 → 10.1.280

package/tests/has-privilege-db.test.ts

@@ -1,198 +0,0 @@
-/**
- * `User.hasPrivilege` — **질의**를 실 DB 로 태운다.
- *
- * 이 함수가 이름 있는 권한 판정의 마지막 자리다(`checkPermission` 이 소유권 우회를 지나면 여기로
- * 온다). `permission-gate.test.ts` 는 그 앞의 규칙만 보고 이 함수는 목으로 대신했다 — 즉
- * **역할·권한·도메인 상속이 실제로 어떻게 이어지는지는 시험된 적이 없었다.**
- *
- * 열린 방 509개를 닫는 일이 이 질의 위에 선다. 지시자를 다 달아 놓고 질의가 틀리면, 닫은 것이
- * 아니라 **아무도 못 들어오게 만든 것**이 된다.
- *
- * ── 상속 규약 ───────────────────────────────────────────────────────────────
- * 역할은 도메인에 정의되고 자식 도메인이 **부모 1단**을 상속한다
- * (`applyDomainInheritanceFilter` 가 단일 소스: `domain IN (자기, 부모)`).
- * 그래서 판정은 「어느 도메인에 정의된 역할인가」를 보고, 「어느 도메인에서 부여받았나」는
- * 체크인 게이트(`checkin-domain-rule`)가 본다 — 그쪽은 순수 시험이 따로 있다.
- *
- * ⚠ `parentId` 는 `@RelationId` 라 **저장소로 읽은 도메인에만** 실린다. 손으로 만든 객체를
- *   넘기면 상속 경로가 조용히 성립하지 않는다. 그래서 아래는 전부 다시 읽어서 넘긴다.
- */
-
-import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
-import { loadCompiled } from './compiled'
-
-const { User } = loadCompiled('service/user/user')
-const { Role } = loadCompiled('service/role/role')
-const { Privilege } = loadCompiled('service/privilege/privilege')
-
-let parent: any
-let child: any
-let sibling: any
-let grandchild: any
-let boardMutation: any
-
-/** `parentId` 가 실리도록 저장소로 다시 읽는다. */
-async function loadDomain(id: string) {
-  return await getRepository(Domain).findOneBy({ id })
-}
-
-async function makeRole(name: string, domain: any, privileges: any[]) {
-  return await getRepository(Role).save({ name, domain, privileges })
-}
-
-async function makeUser(memberOf: any[], roles: any[]) {
-  const salt = User.generateSalt()
-
-  return await getRepository(User).save({
-    username: `kim-${Math.random().toString(36).slice(2, 8)}`,
-    email: `kim-${Math.random().toString(36).slice(2, 8)}@example.com`,
-    name: 'Kim',
-    salt,
-    status: 'activated',
-    domains: memberOf,
-    roles
-  })
-}
-
-beforeAll(async () => {
-  await openAuthDatabase()
-})
-
-beforeEach(async () => {
-  await resetAuthDatabase()
-
-  const p = await getRepository(Domain).save({ name: 'group', subdomain: 'group' })
-  parent = await loadDomain(p.id)
-
-  const c = await getRepository(Domain).save({ name: 'plant-a', subdomain: 'plant-a', parent })
-  child = await loadDomain(c.id)
-
-  const s = await getRepository(Domain).save({ name: 'plant-b', subdomain: 'plant-b', parent })
-  sibling = await loadDomain(s.id)
-
-  const g = await getRepository(Domain).save({ name: 'line-1', subdomain: 'line-1', parent: child })
-  grandchild = await loadDomain(g.id)
-
-  boardMutation = await getRepository(Privilege).save({ name: 'mutation', category: 'board' })
-})
-
-afterAll(async () => {
-  await closeAuthDatabase()
-})
-
-describe('자기 도메인의 역할', () => {
-  it('그 도메인에서 통과한다', async () => {
-    const role = await makeRole('editor', child, [boardMutation])
-    const user = await makeUser([child], [role])
-
-    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
-  })
-
-  it('권한이 다르면 통과하지 못한다', async () => {
-    const role = await makeRole('editor', child, [boardMutation])
-    const user = await makeUser([child], [role])
-
-    expect(await User.hasPrivilege('query', 'board', child, user)).toBe(false)
-    expect(await User.hasPrivilege('mutation', 'twin', child, user)).toBe(false)
-  })
-
-  it('역할이 없으면 통과하지 못한다', async () => {
-    const user = await makeUser([child], [])
-
-    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(false)
-  })
-
-  it('역할은 있는데 권한이 안 붙어 있으면 통과하지 못한다', async () => {
-    const role = await makeRole('viewer', child, [])
-    const user = await makeUser([child], [role])
-
-    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(false)
-  })
-})
-
-describe('부모 도메인의 역할 — 1단 상속', () => {
-  it('부모에 정의된 역할이 자식 도메인에서 통과한다', async () => {
-    const role = await makeRole('group-editor', parent, [boardMutation])
-    const user = await makeUser([child], [role])
-
-    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
-  })
-
-  it('할아버지 도메인의 역할은 손자에서 통과하지 못한다 — 상속은 1단이다', async () => {
-    const role = await makeRole('group-editor', parent, [boardMutation])
-    const user = await makeUser([grandchild], [role])
-
-    expect(await User.hasPrivilege('mutation', 'board', grandchild, user)).toBe(false)
-  })
-
-  it('형제 도메인의 역할은 통과하지 못한다', async () => {
-    const role = await makeRole('b-editor', sibling, [boardMutation])
-    const user = await makeUser([child], [role])
-
-    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(false)
-  })
-})
-
-describe('⚠ 이 질의가 멤버십을 보지 않는다', () => {
-  it('그 도메인의 멤버가 아니어도 역할만 있으면 통과한다', async () => {
-    /*
-     * 결함이 아니다 — 나누어 맡긴 것이다. 멤버십은 체크인 게이트가 강제하고
-     * (`checkin-domain-rule` 이 `memberDomainIds` 를 AND 조건으로 건다), 여기까지 온 요청은
-     * 이미 그 문을 지났다.
-     *
-     * 다만 **이 함수를 그 문 밖에서 부르면 격리가 성립하지 않는다.** 미들웨어를 타지 않는
-     * 경로(주기 작업·내부 호출)에서 쓸 때 그 사실을 알고 있어야 한다.
-     */
-    const role = await makeRole('editor', child, [boardMutation])
-    const user = await makeUser([sibling], [role])
-
-    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
-  })
-})
-
-describe('parentId 가 안 실린 도메인 객체', () => {
-  it('손으로 만든 객체를 넘기면 상속이 성립하지 않는다', async () => {
-    /*
-     * `parentId` 는 `@RelationId` 라 저장소로 읽은 엔티티에만 실린다. 그래서 `{ id }` 만 담은
-     * 객체를 넘기면 상속 경로가 **조용히** 사라진다 — 부모 역할로 들어오던 사람이 거절된다.
-     * 부르는 쪽이 온전히 적재된 도메인을 넘겨야 한다는 뜻이고, 그것을 시험으로 못 박아 둔다.
-     */
-    const role = await makeRole('group-editor', parent, [boardMutation])
-    const user = await makeUser([child], [role])
-
-    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
-    expect(await User.hasPrivilege('mutation', 'board', { id: child.id } as any, user)).toBe(false)
-  })
-})
-
-describe('getPrivilegesByDomain', () => {
-  it('자기 도메인과 부모 도메인의 권한을 함께 돌려준다', async () => {
-    const boardQuery = await getRepository(Privilege).save({ name: 'query', category: 'board' })
-    const twinMutation = await getRepository(Privilege).save({ name: 'mutation', category: 'twin' })
-
-    const parentRole = await makeRole('group-editor', parent, [twinMutation])
-    const childRole = await makeRole('editor', child, [boardMutation, boardQuery])
-    const user = await makeUser([child], [parentRole, childRole])
-
-    const granted = await User.getPrivilegesByDomain(user, child)
-
-    expect(granted).toEqual(
-      expect.arrayContaining([
-        { category: 'board', privilege: 'mutation' },
-        { category: 'board', privilege: 'query' },
-        { category: 'twin', privilege: 'mutation' }
-      ])
-    )
-    expect(granted).toHaveLength(3)
-  })
-
-  it('같은 권한을 두 역할로 받아도 한 번만 돌려준다', async () => {
-    const one = await makeRole('editor-1', child, [boardMutation])
-    const two = await makeRole('editor-2', child, [boardMutation])
-    const user = await makeUser([child], [one, two])
-
-    const granted = await User.getPrivilegesByDomain(user, child)
-
-    expect(granted).toEqual([{ category: 'board', privilege: 'mutation' }])
-  })
-})

package/tests/identity-confirmation.test.ts

@@ -1,146 +0,0 @@
-/**
- * `@recentConfirmation` (ADR-0168) - the seam. A door that asks for a recent confirmation opens only when the
- * person confirmed in this browser within the last ten minutes, as themself; passing does not lengthen it. Built as SDL the way
- * `privilege-directive.test.ts` builds its schema - the wrapper sees only the field, `context.state` and the cookies.
- */
-
-import { graphql } from 'graphql'
-import { makeExecutableSchema } from '@graphql-tools/schema'
-import jwt from 'jsonwebtoken'
-
-import { loadCompiled } from './compiled'
-
-const { privilegeDirectiveTypeDefs, privilegeDirectiveResolver } = loadCompiled('service/privilege/privilege-directive')
-const confirmation = loadCompiled('service/identity-confirmation/identity-confirmation')
-const { SECRET } = loadCompiled('utils/get-secret')
-const { User } = loadCompiled('service/user/user')
-
-const DOMAIN = { id: 'domain-1', subdomain: 'office' }
-const KIM = { id: 'kim', domains: [DOMAIN] }
-const LEE = { id: 'lee', domains: [DOMAIN] }
-
-const typeDefs = `
-  type Query {
-    myPayslips: String @privilege(category: "office-self", privilege: "query") @recentConfirmation
-    myLeave: String @privilege(category: "office-self", privilege: "query")
-  }
-`
-
-function buildSchema(defs = typeDefs) {
-  return privilegeDirectiveResolver(
-    makeExecutableSchema({
-      typeDefs: [privilegeDirectiveTypeDefs, confirmation.recentConfirmationDirectiveTypeDefs, defs],
-      resolvers: { Query: { myPayslips: () => 'slips', myLeave: () => 'leave' } }
-    })
-  )
-}
-
-/** A browser: the cookies it holds between requests. */
-function browser() {
-  const jar = new Map<string, string>()
-  const options = new Map<string, any>()
-  return {
-    jar,
-    options,
-    cookies: {
-      get: (name: string) => jar.get(name) || undefined,
-      set: (name: string, value: string, option: any) => (jar.set(name, value), options.set(name, option))
-    }
-  }
-}
-
-function run(schema: any, field: string, user: any, at: ReturnType<typeof browser>) {
-  return graphql({ schema, source: `{ ${field} }`, contextValue: { state: { domain: DOMAIN, user }, cookies: at.cookies } })
-}
-
-const refusalOf = (result: any) => result.errors?.[0]?.extensions?.refusal?.code
-
-beforeEach(() => {
-  User.hasPrivilege = jest.fn().mockResolvedValue(true)
-  ;(process as any).domainOwnerGranted = jest.fn().mockResolvedValue(false)
-  ;(process as any).superUserGranted = jest.fn().mockResolvedValue(false)
-})
-
-afterEach(() => {
-  delete (process as any).domainOwnerGranted
-  delete (process as any).superUserGranted
-})
-
-it('refuses a door that asks for it when the person has not confirmed, with a code the screen can name', async () => {
-  const result = await run(buildSchema(), 'myPayslips', KIM, browser())
-
-  expect(result.data?.myPayslips ?? null).toBeNull()
-  expect(refusalOf(result)).toBe('identity-confirmation-required')
-  expect(result.errors?.[0]?.extensions?.code).toBe('IDENTITY_CONFIRMATION_REQUIRED')
-})
-
-it('opens it after the person confirmed, and does not lengthen the confirmation as it passes', async () => {
-  const at = browser()
-  confirmation.rememberConfirmation({ cookies: at.cookies }, KIM.id)
-  const given = at.jar.get('identity_confirmed')
-
-  await new Promise(resolve => setTimeout(resolve, 1100))
-  const result = await run(buildSchema(), 'myPayslips', KIM, at)
-
-  expect(result.errors).toBeUndefined()
-  expect(result.data).toEqual({ myPayslips: 'slips' })
-  expect(at.jar.get('identity_confirmed')).toBe(given)
-  expect(at.options.get('identity_confirmed')).toMatchObject({ httpOnly: true, maxAge: 10 * 60 * 1000 })
-})
-
-it('holds for ten minutes from the moment it was given, and says until when', () => {
-  const at = browser()
-  const before = Date.now()
-  confirmation.rememberConfirmation({ cookies: at.cookies }, KIM.id)
-
-  const until = confirmation.confirmedUntil({ cookies: at.cookies }, KIM.id).getTime()
-  expect(until).toBeGreaterThanOrEqual(Math.floor(before / 1000) * 1000 + 10 * 60 * 1000)
-  expect(until).toBeLessThanOrEqual(Date.now() + 10 * 60 * 1000)
-  expect(confirmation.confirmedUntil({ cookies: at.cookies }, LEE.id)).toBeNull()
-})
-
-it("does not open on another person's confirmation", async () => {
-  const at = browser()
-  confirmation.rememberConfirmation({ cookies: at.cookies }, LEE.id)
-
-  expect(refusalOf(await run(buildSchema(), 'myPayslips', KIM, at))).toBe('identity-confirmation-required')
-})
-
-it('does not open on an expired confirmation, a forged one, or one let go', async () => {
-  const expired = browser()
-  expired.jar.set('identity_confirmed', jwt.sign({ sub: KIM.id, purpose: 'identity-confirmation' }, SECRET, { expiresIn: -10 }))
-  expect(refusalOf(await run(buildSchema(), 'myPayslips', KIM, expired))).toBe('identity-confirmation-required')
-
-  const forged = browser()
-  forged.jar.set('identity_confirmed', jwt.sign({ sub: KIM.id, purpose: 'identity-confirmation' }, 'another secret', { expiresIn: 300 }))
-  expect(refusalOf(await run(buildSchema(), 'myPayslips', KIM, forged))).toBe('identity-confirmation-required')
-
-  const signedIn = browser()
-  signedIn.jar.set('identity_confirmed', jwt.sign({ sub: KIM.id }, SECRET, { expiresIn: 300 }))
-  expect(refusalOf(await run(buildSchema(), 'myPayslips', KIM, signedIn))).toBe('identity-confirmation-required')
-
-  const leftAlone = browser()
-  confirmation.rememberConfirmation({ cookies: leftAlone.cookies }, KIM.id)
-  confirmation.forgetConfirmation({ cookies: leftAlone.cookies })
-  expect(refusalOf(await run(buildSchema(), 'myPayslips', KIM, leftAlone))).toBe('identity-confirmation-required')
-})
-
-it('asks the privilege first - a person without it is refused for the privilege, confirmed or not', async () => {
-  User.hasPrivilege = jest.fn().mockResolvedValue(false)
-  const at = browser()
-  confirmation.rememberConfirmation({ cookies: at.cookies }, KIM.id)
-
-  const result = await run(buildSchema(), 'myPayslips', KIM, at)
-  expect(result.errors?.[0]?.extensions?.code).not.toBe('IDENTITY_CONFIRMATION_REQUIRED')
-})
-
-it('leaves a door that does not ask alone', async () => {
-  const result = await run(buildSchema(), 'myLeave', KIM, browser())
-
-  expect(result.errors).toBeUndefined()
-  expect(result.data).toEqual({ myLeave: 'leave' })
-})
-
-it('refuses to build a door that asks for the confirmation without a privilege beside it', () => {
-  expect(() => buildSchema('type Query { myPayslips: String @recentConfirmation myLeave: String }')).toThrow('has no @privilege beside it')
-})

package/tests/list-inheritance-db.test.ts

@@ -1,127 +0,0 @@
-/**
- * A list reads this domain's rows only - whatever `inherited` the caller sent (2026-10-02).
- *
- * `getQueryBuilderFromListParams` honours `inherited: Include | Only`, so a list that hands the client's ListParam
- * through lets a child domain read its parent's rows. For these lists a parent's rows are another tenant's
- * configuration or people, and no screen asks for them: the query pins `inherited` to None. The same pin as
- * `accessRequests` (access-request-db.test.ts).
- *
- * Roles are not here - the role screens ask for the parent's roles on purpose (assignable scope, docs/design/auth-rebuild.md).
- */
-
-import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
-import { loadCompiled } from './compiled'
-
-const { User } = loadCompiled('service/user/user')
-const { AuthProvider } = loadCompiled('service/auth-provider/auth-provider')
-const { AuthProviderQuery } = loadCompiled('service/auth-provider/auth-provider-query')
-const { Appliance } = loadCompiled('service/appliance/appliance')
-const { ApplianceQuery } = loadCompiled('service/appliance/appliance-query')
-const { Application } = loadCompiled('service/application/application')
-const { ApplicationQuery } = loadCompiled('service/application/application-query')
-const { Partner } = loadCompiled('service/partner/partner')
-const { PartnerQuery } = loadCompiled('service/partner/partner-query')
-
-let parent: any
-let child: any
-let partnerDomain: any
-let parentUser: any
-let childUser: any
-
-async function makeUser(name: string, domains: any[]) {
-  return await getRepository(User).save({
-    username: name,
-    email: `${name}@example.com`,
-    name,
-    salt: User.generateSalt(),
-    status: 'activated',
-    domains
-  })
-}
-
-const from = (domain: any, user: any) => ({ state: { domain, user } }) as any
-const ONLY = { inherited: 'Only' } as any
-
-beforeAll(async () => {
-  await openAuthDatabase()
-})
-
-afterAll(async () => {
-  await closeAuthDatabase()
-})
-
-beforeEach(async () => {
-  await resetAuthDatabase()
-
-  const savedParent = await getRepository(Domain).save({ name: 'Plant A', subdomain: 'plant-a' })
-  parent = await getRepository(Domain).findOneBy({ id: savedParent.id })
-  const savedChild = await getRepository(Domain).save({ name: 'Plant A-1', subdomain: 'plant-a-1', parent })
-  child = await getRepository(Domain).findOneBy({ id: savedChild.id })
-  partnerDomain = await getRepository(Domain).save({ name: 'Vendor', subdomain: 'vendor' })
-
-  parentUser = await makeUser('parent-admin', [parent])
-  childUser = await makeUser('child-admin', [child])
-})
-
-/*
- * Each list: the parent reads its own row (so an empty answer below is the pin, not a broken fixture), and the
- * child asking for the parent's with `inherited: Only` reads nothing.
- */
-const LISTS: [string, () => Promise<any>, (params: any, context: any) => Promise<any>][] = [
-  [
-    'auth providers',
-    () => getRepository(AuthProvider).save({ domain: parent, type: 'keycloak', clientSecret: 'parent-secret' }),
-    (params, context) => new AuthProviderQuery().authProviders(params, context)
-  ],
-  [
-    'appliances',
-    () => getRepository(Appliance).save({ domain: parent, name: 'gate', serialNo: 'gate-SN', brand: 'Acme', model: 'X1' }),
-    (params, context) => new ApplianceQuery().appliances(params, context)
-  ],
-  [
-    'edges',
-    () => getRepository(Appliance).save({ domain: parent, name: 'edge', serialNo: 'edge-SN', brand: 'Acme', model: 'X1' }),
-    (params, context) => new ApplianceQuery().edges(params, context)
-  ],
-  [
-    'applications',
-    () =>
-      getRepository(Application).save({
-        domain: parent,
-        name: 'billing',
-        email: 'billing@acme.z',
-        url: 'https://billing.example.com',
-        redirectUrl: 'https://billing.example.com/callback',
-        status: 0,
-        type: 'OTHERS',
-        appSecret: 'parent-app-secret'
-      }),
-    (params, context) => new ApplicationQuery().applications(params, context)
-  ],
-  [
-    'partners',
-    () => getRepository(Partner).save({ domain: parent, partnerDomain, requestedAt: new Date() }),
-    (params, context) => new PartnerQuery().partners(params, context)
-  ]
-]
-
-describe.each(LISTS)('%s', (_name, seed, list) => {
-  it("★ the parent reads its own row - the fixture is real", async () => {
-    await seed()
-    const answer = await list({}, from(parent, parentUser))
-    expect(answer.items).toHaveLength(1)
-  })
-
-  it("★ a child domain asking for the parent's with inherited: Only reads nothing", async () => {
-    await seed()
-    const answer = await list(ONLY, from(child, childUser))
-    expect(answer.items).toEqual([])
-    expect(answer.total).toBe(0)
-  })
-
-  it("a child domain asking with inherited: Include reads nothing of the parent's", async () => {
-    await seed()
-    const answer = await list({ inherited: 'Include' }, from(child, childUser))
-    expect(answer.items).toEqual([])
-  })
-})

package/tests/lock-recovery.test.ts

@@ -1,206 +0,0 @@
-/**
- * 잠긴 계정이 **어떤 경로로 풀리나** — 두 메일이 서로 다른 곳으로 간다.
- *
- * 계정이 잠기면 두 종류의 메일이 있을 수 있고, 템플릿이 거의 같아 눈으로는 잘 안 갈린다
- * (둘 다 `<title>reset password</title>` · 같은 레이아웃 · 본문 한 줄만 다르다). 구별되는 것은
- * 메일 **제목**뿐이다 — `Reset your password` 와 `Your account is locked`.
- *
- * 그런데 **결과가 다르다.** 비슷하게 보이면 안 되는 짝이라는 것을 여기서 못 박는다.
- * 템플릿 자체의 개선은 따로 대기 중이다.
- *
- * (관리자 경로 `activateUser` 는 `failCount` 를 0 으로 두고 `ACTIVATED` 로 되돌린다 —
- *  type-graphql 리졸버라 jest 에서 들 수 없어 여기서는 시험하지 않는다. 그 자리가 정식 경로다.)
- */
-
-import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
-import { loadCompiled } from './compiled'
-
-const { User } = loadCompiled('service/user/user')
-const { signin } = loadCompiled('controllers/signin')
-const { resetPassword } = loadCompiled('controllers/reset-password')
-const { unlockUser } = loadCompiled('controllers/unlock-user')
-const { VerificationToken, VerificationTokenType } = loadCompiled('service/verification-token/verification-token')
-const { saveVerificationToken } = loadCompiled('controllers/utils/save-verification-token')
-
-const OLD = 'Passw0rd!'
-const NEW = 'N3wPassw0rd!'
-
-let domain: any
-
-async function lockedUser() {
-  const salt = User.generateSalt()
-
-  return await getRepository(User).save({
-    username: 'kim',
-    email: 'kim@example.com',
-    name: 'Kim',
-    salt,
-    password: User.encode(OLD, salt),
-    status: 'locked',
-    failCount: 5,
-    domains: [domain]
-  })
-}
-
-/* Through the one writer, so the row carries its hash and expiry the way a mailed link's does. */
-async function giveToken(userId: string, token: string, type: string) {
-  await saveVerificationToken(userId, token, type)
-}
-
-/** `resetPassword` 가 컨텍스트에서 읽는 것만 담는다. */
-const context = { t: (key: string) => key, lng: 'en-US' }
-
-beforeAll(async () => {
-  await openAuthDatabase()
-})
-
-beforeEach(async () => {
-  await resetAuthDatabase()
-  domain = await getRepository(Domain).save({ name: 'plant-a', subdomain: 'plant-a' })
-})
-
-afterAll(async () => {
-  await closeAuthDatabase()
-})
-
-describe('재설정 메일 경로 (PASSWORD_RESET)', () => {
-  it('비밀번호는 바뀌지만 **잠금은 그대로다**', async () => {
-    /* `resetPassword` 는 `status` 를 건드리지 않는다 — 그 파일의 INACTIVE 검사도 주석 처리되어
-       있다. 그래서 이 메일은 「비밀번호를 잊었다」를 위한 것이고 「잠겼다」의 답이 아니다. */
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.PASSWORD_RESET)
-
-    await resetPassword('tok', NEW, 'kim@example.com', context)
-
-    const after = await getRepository(User).findOneBy({ id: user.id })
-    expect(User.verify(after.password, NEW, after.salt)).toBe(true)
-    expect(after.status).toBe('locked')
-    expect(after.failCount).toBe(5)
-  })
-
-  it('그래서 새 비밀번호로도 들어갈 수 없다', async () => {
-    /* `signin` 의 잠금 검사가 비밀번호 대조보다 먼저다. 사용자가 겪는 것은
-       「메일로 비밀번호를 바꿨는데 여전히 못 들어간다」다. */
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.PASSWORD_RESET)
-
-    await resetPassword('tok', NEW, 'kim@example.com', context)
-
-    await expect(signin({ username: 'kim', password: NEW })).rejects.toThrow()
-  })
-})
-
-describe('잠금 해제 메일 경로 (UNLOCK)', () => {
-  it('비밀번호를 바꾸고 잠금까지 되돌린다', async () => {
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    expect(await unlockUser('tok', NEW)).toBe(true)
-
-    const after = await getRepository(User).findOneBy({ id: user.id })
-    expect(after.status).toBe('activated')
-    expect(after.failCount).toBe(0)
-    expect(User.verify(after.password, NEW, after.salt)).toBe(true)
-  })
-
-  it('풀린 뒤에는 새 비밀번호로 들어간다', async () => {
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    await unlockUser('tok', NEW)
-
-    const result = await signin({ username: 'kim', password: NEW })
-    expect(result.token).toBeTruthy()
-  })
-
-  it('토큰을 한 번만 쓸 수 있다 — 두 번째는 거절한다(던지지 않는다)', async () => {
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    await unlockUser('tok', NEW)
-
-    /* 예전에는 토큰 행이 사라진 뒤 `findOne` 의 `null` 을 구조 분해해서 던졌고, 화면은 이유가
-       아니라 500 을 봤다. 지금은 거절로 돌아온다. */
-    expect(await unlockUser('tok', NEW)).toBe(false)
-  })
-
-  it('잠기지 않은 계정에는 아무 일도 하지 않는다', async () => {
-    const user = await lockedUser()
-    await getRepository(User).update({ id: user.id }, { status: 'activated', failCount: 0 })
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    /* `status != LOCKED` 이면 `false` 를 돌려준다(unlock-user.ts:48) — 비밀번호도 안 바뀐다. */
-    expect(await unlockUser('tok', NEW)).toBe(false)
-
-    const after = await getRepository(User).findOneBy({ id: user.id })
-    expect(User.verify(after.password, OLD, after.salt)).toBe(true)
-  })
-})
-
-describe('토큰 없는 요청 — 계정 탈취 회귀', () => {
-  /*
-   * ── 무엇이 가능했나 (2026-09-09, 고침) ──────────────────────────────────────
-   * `unlockUser` 가 `findOne({ where: { token, type: UNLOCK } })` 로 찾았는데, TypeORM 은
-   * `where` 에서 **`undefined` 조건을 떨어뜨린다.** 그래서 `token` 이 없으면 조건이
-   * `{ type: UNLOCK }` 만 남아 **누구의 해제 토큰이든** 맞았고, 그 계정의 비밀번호를 부르는
-   * 쪽이 준 값으로 바꿨다.
-   *
-   * 두 조각 다 자격 없이 손에 넣을 수 있었다. 남의 계정을 다섯 번 틀리면 잠기면서 해제 토큰이
-   * 만들어지고(그것을 막을 rate limit 이 없다), `/auth/unlock-user` 의 가드가
-   * `!(token || password)` 여서 **비밀번호만 담은 요청이 통과했다.**
-   *
-   * 실제로 전 과정을 태워 확인했다 — status `activated` · failCount 0 · 비밀번호는 공격자의
-   * 것 · 그 비밀번호로 로그인 성공.
-   *
-   * 두 자리를 다 고쳤다(컨트롤러의 요구 조건 · 라우터의 가드). 아래는 컨트롤러 쪽을 지킨다 —
-   * 라우터 가드가 되돌아가도 여기서 막힌다.
-   */
-  it('토큰 없이 부르면 잠긴 계정을 건드리지 못한다', async () => {
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    expect(await unlockUser(undefined, 'ATTACKERpass1!')).toBe(false)
-
-    const after = await getRepository(User).findOneBy({ id: user.id })
-    expect(after.status).toBe('locked')
-    expect(after.failCount).toBe(5)
-    expect(User.verify(after.password, 'ATTACKERpass1!', after.salt)).toBe(false)
-    expect(User.verify(after.password, OLD, after.salt)).toBe(true)
-  })
-
-  it('빈 문자열 토큰도 같다', async () => {
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    expect(await unlockUser('', 'ATTACKERpass1!')).toBe(false)
-
-    const after = await getRepository(User).findOneBy({ id: user.id })
-    expect(after.status).toBe('locked')
-  })
-
-  it('그 뒤에도 공격자의 비밀번호로 들어갈 수 없다', async () => {
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    await unlockUser(undefined, 'ATTACKERpass1!')
-
-    await expect(signin({ username: 'kim', password: 'ATTACKERpass1!' })).rejects.toThrow()
-  })
-
-  it('비밀번호 없이 부르면 거절한다 — 던지지 않는다', async () => {
-    /* 예전에는 `User.encode(undefined, salt)` 가 `crypto` 안에서 던져 500 이 됐다. */
-    const user = await lockedUser()
-    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
-
-    expect(await unlockUser('tok', undefined)).toBe(false)
-
-    const after = await getRepository(User).findOneBy({ id: user.id })
-    expect(after.status).toBe('locked')
-  })
-
-  it('없는 토큰은 거절한다 — 던지지 않는다', async () => {
-    await lockedUser()
-
-    expect(await unlockUser('no-such-token', NEW)).toBe(false)
-  })
-})