@things-factory/auth-base 10.1.4 → 10.1.7

package/tests/role-template.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Role templates — the registry and what it refuses.
+ *
+ * The refusals are the interesting part. A template that registers happily and then grants
+ * nothing is the quiet failure this design exists to avoid, so the checks that make noise
+ * are the ones pinned here.
+ */
+
+import { loadCompiled } from './compiled'
+
+const {
+  registerRoleTemplate,
+  roleTemplates,
+  roleTemplateById,
+  computedRoleTemplates,
+  allRoleTemplates,
+  unknownTemplateGrants
+} = loadCompiled('service/role-template/role-template')
+
+beforeEach(() => {
+  ;(process as any)['ROLE_TEMPLATES'] = {}
+  ;(process as any).PRIVILEGES = {
+    'board query': ['board', 'query'],
+    'board mutation': ['board', 'mutation'],
+    'order query': ['order', 'query'],
+    'worklist query': ['worklist', 'query'],
+    'worklist mutation': ['worklist', 'mutation']
+  }
+})
+
+describe('declaring a template', () => {
+  it('can be found again by id', () => {
+    registerRoleTemplate({
+      id: 'plant.production-lead',
+      name: 'PRODUCTION-LEAD',
+      grants: [{ category: 'worklist', axes: ['query', 'mutation'] }]
+    })
+
+    expect(roleTemplateById('plant.production-lead')!.name).toBe('PRODUCTION-LEAD')
+    expect(roleTemplates()).toHaveLength(1)
+  })
+})
+
+describe('what registration refuses', () => {
+  it('refuses a template with no grants written at all', () => {
+    expect(() => registerRoleTemplate({ id: 'x', name: 'X' } as any)).toThrow(/no grants/)
+  })
+
+  it('accepts an empty list — a seat that opens nothing on purpose, for approval routing', () => {
+    registerRoleTemplate({ id: 'twin.quality-inspector', name: 'QUALITY-INSPECTOR', grants: [] })
+
+    expect(roleTemplateById('twin.quality-inspector')!.grants).toEqual([])
+  })
+
+  it('refuses a grant with no axes', () => {
+    expect(() => registerRoleTemplate({ id: 'x', name: 'X', grants: [{ category: 'board', axes: [] }] })).toThrow(
+      /no axes/
+    )
+  })
+
+  it('refuses the same id twice', () => {
+    registerRoleTemplate({ id: 'x', name: 'X', grants: [] })
+
+    expect(() => registerRoleTemplate({ id: 'x', name: 'Y', grants: [] })).toThrow(/declared twice/)
+  })
+
+  it('accepts the same role name from two applications — one seat, declared twice', () => {
+    registerRoleTemplate({ id: 'plant.qi', name: 'QUALITY-INSPECTOR', grants: [{ category: 'board', axes: ['query'] }] })
+    registerRoleTemplate({ id: 'twin.qi', name: 'QUALITY-INSPECTOR', grants: [] })
+
+    expect(roleTemplates().filter(one => one.name === 'QUALITY-INSPECTOR')).toHaveLength(2)
+  })
+})
+
+describe('names this installation does not declare', () => {
+  it('points at grants that would silently open nothing after a category rename', () => {
+    registerRoleTemplate({
+      id: 'plant.x',
+      name: 'X',
+      grants: [
+        { category: 'board', axes: ['query'] },
+        { category: 'board-ai', axes: ['query', 'mutation'] }
+      ]
+    })
+
+    expect(unknownTemplateGrants(roleTemplateById('plant.x')!)).toEqual(['board-ai:query', 'board-ai:mutation'])
+  })
+
+  it('reports nothing when every named privilege is installed', () => {
+    registerRoleTemplate({ id: 'plant.y', name: 'Y', grants: [{ category: 'order', axes: ['query'] }] })
+
+    expect(unknownTemplateGrants(roleTemplateById('plant.y')!)).toEqual([])
+  })
+})
+
+describe('the two templates the framework computes', () => {
+  it('gives the viewer every category that declares a query axis', () => {
+    const viewer = computedRoleTemplates().find(one => one.id === 'framework.viewer')!
+
+    expect(viewer.grants.map(grant => grant.category).sort()).toEqual(['board', 'order', 'worklist'])
+    expect(viewer.grants.every(grant => grant.axes.join() === 'query')).toBe(true)
+  })
+
+  it('gives the administrator everything declared', () => {
+    const administrator = computedRoleTemplates().find(one => one.id === 'framework.administrator')!
+    const pairs = administrator.grants.flatMap(grant => grant.axes.map(axis => `${grant.category}:${axis}`)).sort()
+
+    expect(pairs).toEqual(['board:mutation', 'board:query', 'order:query', 'worklist:mutation', 'worklist:query'])
+  })
+
+  it('widens only the administrator when a new axis is declared', () => {
+    ;(process as any).PRIVILEGES['board execute'] = ['board', 'execute']
+
+    const administrator = computedRoleTemplates().find(one => one.id === 'framework.administrator')!
+    const viewer = computedRoleTemplates().find(one => one.id === 'framework.viewer')!
+
+    expect(administrator.grants.find(grant => grant.category === 'board')!.axes).toContain('execute')
+    expect(viewer.grants.find(grant => grant.category === 'board')!.axes).toEqual(['query'])
+  })
+
+  it('offers the computed two alongside whatever applications declared', () => {
+    registerRoleTemplate({ id: 'plant.z', name: 'Z', grants: [] })
+
+    expect(allRoleTemplates().map(one => one.id)).toEqual(['framework.viewer', 'framework.administrator', 'plant.z'])
+  })
+})

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)
+  })
+})

package/tests/token-issuance.test.ts

@@ -0,0 +1,240 @@
+/**
+ * 토큰 발급 시험 — **우리 토큰이 무엇을 말하는가.**
+ *
+ * 사람·애플리케이션·어플라이언스 세 종류의 주체가 모두 JWT 로 들어온다. 저장소의 시험 316개
+ * 중 발급을 부르는 것이 없었다. 여기서 고정하는 것은 「무엇이 실려 있나」와 「무엇이 실려
+ * 있지 않나」다. **없는 것 쪽이 더 중요하다** (`docs/design/auth-rebuild.md` §4):
+ *
+ *  · `jti` 가 없다  → 발급한 토큰을 **가리킬 수 없다** = 폐기 수단이 없다.
+ *                     로그아웃은 쿠키만 지우고, 복사된 토큰은 만료까지 살아 있다.
+ *  · `kid` 가 없다  → 두 키를 동시에 신뢰할 수 없다 = 서명 키를 **교체할 수 없다**.
+ *  · 사람 토큰에 도메인이 없다 → 도메인은 `x-things-factory-domain` 헤더가 정한다.
+ *
+ * 폐기·회전을 넣을 때 이 시험들이 먼저 깨져야 한다. 「`jti` 가 없다」가 깨지는 것이 곧
+ * 대장이 생겼다는 증거다.
+ */
+
+import jwt from 'jsonwebtoken'
+
+import { loadCompiled } from './compiled'
+
+const { User } = loadCompiled('service/user/user')
+const { Appliance } = loadCompiled('service/appliance/appliance')
+const { Application } = loadCompiled('service/application/application')
+const { SECRET } = loadCompiled('utils/get-secret')
+
+const DAY = 24 * 60 * 60
+const YEAR = 365.25 * DAY /* jsonwebtoken 의 `ms` 는 '1y' 를 365.25일로 읽는다 */
+
+const DOMAIN = { id: 'domain-1', subdomain: 'plant-a' }
+const APPLIANCE = { id: 'appliance-1', name: 'gate-scanner' }
+
+function decode(token: string) {
+  return jwt.decode(token, { complete: true }) as any
+}
+
+function lifetime(payload: any) {
+  return payload.exp - payload.iat
+}
+
+function personToken(overrides: any = {}) {
+  const user = new User()
+  Object.assign(user, { id: 'user-1', username: 'kim', email: 'kim@example.com', ...overrides })
+  return user.sign()
+}
+
+describe('사람 토큰 (User.sign)', () => {
+  it('실려 있는 것은 username · email 과 표준 클레임뿐이다', async () => {
+    const { payload } = decode(await personToken())
+
+    expect(Object.keys(payload).sort()).toEqual(['email', 'exp', 'iat', 'iss', 'sub', 'username'])
+    expect(payload).toMatchObject({
+      username: 'kim',
+      email: 'kim@example.com',
+      iss: 'hatiolab.com',
+      sub: 'user'
+    })
+  })
+
+  it('username 이 없으면 email 을 username 자리에 넣는다', async () => {
+    const { payload } = decode(await personToken({ username: undefined }))
+
+    expect(payload.username).toBe('kim@example.com')
+  })
+
+  it('사용자 id 를 싣지 않는다 — 토큰은 username 으로 사람을 가리킨다', async () => {
+    const { payload } = decode(await personToken())
+
+    expect(payload.id).toBeUndefined()
+  })
+
+  it('기본 수명은 7일이다', async () => {
+    const { payload } = decode(await personToken())
+
+    expect(lifetime(payload)).toBe(7 * DAY)
+  })
+
+  it('넘긴 도메인은 버려진다 — 토큰에 도메인이 없다', async () => {
+    /* `signin` 은 `user.sign({ subdomain: domain?.subdomain })` 로 부르는데(signin.ts:95)
+       `sign` 은 `expiresIn` 만 꺼내 쓴다(user.ts:186). 넘긴 값이 조용히 사라진다. */
+    const user = new User()
+    Object.assign(user, { id: 'user-1', username: 'kim', email: 'kim@example.com' })
+
+    const { payload } = decode(await user.sign({ subdomain: 'plant-a' }))
+
+    expect(payload.subdomain).toBeUndefined()
+    expect(payload.domain).toBeUndefined()
+  })
+})
+
+describe('어플라이언스 토큰 (Appliance.generateAccessToken)', () => {
+  it('주체 종류와 어플라이언스 id, 도메인을 싣는다', () => {
+    const { payload } = decode(Appliance.generateAccessToken(DOMAIN, { id: 'appuser-1' }, APPLIANCE))
+
+    expect(payload).toMatchObject({
+      id: 'appuser-1',
+      userType: 'appliance',
+      appliance: { id: 'appliance-1' },
+      status: 'activated',
+      domain: { subdomain: 'plant-a' },
+      sub: 'access-token'
+    })
+  })
+
+  it('기본 수명이 1년이다', () => {
+    /* 설정 `applianceJwtExpiresIn` 이 없을 때의 값(appliance.ts:131).
+       이 토큰은 DB 에 평문으로도 남는다(appliance-mutation.ts:64,70). */
+    const { payload } = decode(Appliance.generateAccessToken(DOMAIN, { id: 'appuser-1' }, APPLIANCE))
+
+    expect(lifetime(payload)).toBe(YEAR)
+  })
+})
+
+describe('애플리케이션 토큰 (Application)', () => {
+  const SCOPES = ['reader', 'approver']
+
+  it('access token 은 30일, refresh token 은 1년이다', () => {
+    const access = decode(Application.generateAccessToken(DOMAIN, { id: 'appuser-1' }, 'APPKEY', SCOPES))
+    const refresh = decode(Application.generateRefreshToken(DOMAIN, { id: 'appuser-1' }, 'APPKEY', SCOPES))
+
+    expect(lifetime(access.payload)).toBe(30 * DAY)
+    expect(lifetime(refresh.payload)).toBe(YEAR)
+    expect(access.payload.sub).toBe('access-token')
+    expect(refresh.payload.sub).toBe('refresh-token')
+  })
+
+  it('appKey 와 scope 를 싣는다 — scope 는 그 도메인의 역할 이름이다', () => {
+    /* `oauth2-server.ts:131` 이 `roles: scopes` 로 저장하고 `:240` 이 `name: In(scopes)` 로
+       역할을 찾는다. 즉 scope 어휘가 따로 없고 역할 이름이 곧 scope 다 — 역할 이름을 바꾸면
+       이미 발급된 토큰의 scope 가 조용히 뜻을 잃는다. */
+    const { payload } = decode(Application.generateAccessToken(DOMAIN, { id: 'appuser-1' }, 'APPKEY', SCOPES))
+
+    expect(payload).toMatchObject({
+      userType: 'application',
+      application: { appKey: 'APPKEY' },
+      scope: SCOPES
+    })
+  })
+
+  it('auth code 는 1분 살고 왕복한다', () => {
+    const code = Application.generateAuthCode('kim@example.com', 'APPKEY', 'plant-a', ['reader'], 'state-1')
+    const { payload } = decode(code)
+
+    expect(lifetime(payload)).toBe(60)
+    expect(Application.verifyAuthCode(code)).toMatchObject({
+      email: 'kim@example.com',
+      appKey: 'APPKEY',
+      subdomain: 'plant-a',
+      scopes: ['reader'],
+      state: 'state-1'
+    })
+  })
+
+  it('appKey 와 appSecret 은 16바이트 hex 다', () => {
+    expect(Application.generateAppKey()).toMatch(/^[0-9a-f]{32}$/)
+    expect(Application.generateAppSecret()).toMatch(/^[0-9a-f]{32}$/)
+    expect(Application.generateAppKey()).not.toBe(Application.generateAppKey())
+  })
+})
+
+describe('`iat` 은 초로 절삭된다 — 밀리초 시각과 견주면 새 토큰이 옛것으로 보인다', () => {
+  /*
+   * 폐기를 「무효 목록 없이」 하려는 설계가 반드시 밟는 자리다. 사람 행에는
+   * `passwordUpdatedAt`(밀리초를 가진 `Date`)이 있고, 토큰에는 `iat`(초)이 있다. 그래서
+   * `decoded.iat * 1000 < user.passwordUpdatedAt` 로 「그 시각 앞에 발급된 토큰을 끊는다」를
+   * 만들면, **비밀번호를 바꾼 그 사람의 새 토큰까지 끊긴다** — `change-pwd.ts` 가 같은 초에
+   * 칸을 쓰고(:81) 토큰을 발급하기(:99) 때문이다.
+   *
+   * 대장(발급 기록)을 두면 안 생기는 문제이므로, 이 시험은 고칠 대상이 아니라
+   * **설계가 이 사실을 알고 있어야 한다는 표시**다.
+   */
+  /*
+   * ⚠ 이 시험은 **시계에 기대고 있었고 6번에 1번쯤 빨갛게 났다** (2026-09-10).
+   *
+   * 30번을 7ms 간격으로 돌면서 「전부 옛것으로 보인다」를 단정했는데, 그 단정이 틀리는 순간이
+   * 둘 있었다. 둘 다 결함이 아니라 **관측이 성립하지 않은 회차**다.
+   *
+   *   밀리초가 정확히 000     절삭이 아무것도 안 깎는다 — 그 한 순간만 비교가 우연히 안전하다
+   *   두 줄 사이에 초가 넘어감   `passwordUpdatedAt` 과 토큰이 **다른 초**다 — 전제가 「같은 초」다
+   *
+   * 그래서 회차를 세는 대신 **관측이 성립한 회차만** 보고, 그런 회차가 하나도 없으면 조용히
+   * 초록이 되지 않게 따로 단정한다. 시계를 목으로 바꾸지 않는 이유는 재는 대상이 **발급기가
+   * 실제로 넣는 `iat`** 이기 때문이다.
+   */
+  it('같은 초에 찍은 밀리초 시각보다 새 토큰의 `iat` 이 앞선다', async () => {
+    const ROUNDS = 30
+    let observed = 0
+    let looksOlder = 0
+
+    for (let round = 0; round < ROUNDS; round++) {
+      /* change-pwd.ts 의 순서: 먼저 `passwordUpdatedAt` 을 쓰고, 그 다음 발급한다. */
+      const passwordUpdatedAt = new Date()
+      const { payload } = decode(await personToken())
+
+      const sameSecond = Math.floor(passwordUpdatedAt.getTime() / 1000) === payload.iat
+      const truncates = passwordUpdatedAt.getMilliseconds() !== 0
+
+      if (sameSecond && truncates) {
+        observed++
+        if (payload.iat * 1000 < passwordUpdatedAt.getTime()) looksOlder++
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 7))
+    }
+
+    /* 성립한 회차가 없으면 위 단정이 「0 === 0」으로 통과한다 — 그것은 초록이 아니다. */
+    expect(observed).toBeGreaterThan(0)
+    expect(looksOlder).toBe(observed)
+  })
+})
+
+describe('세 종류의 토큰이 공유하는 것 — 그리고 없는 것', () => {
+  /** 사람·어플라이언스·애플리케이션·auth code 를 한 자리에 모아 같은 질문을 던진다. */
+  async function everyToken(): Promise<[string, string][]> {
+    return [
+      ['사람', await personToken()],
+      ['어플라이언스', Appliance.generateAccessToken(DOMAIN, { id: 'appuser-1' }, APPLIANCE)],
+      ['애플리케이션', Application.generateAccessToken(DOMAIN, { id: 'appuser-1' }, 'APPKEY', ['reader'])],
+      ['auth code', Application.generateAuthCode('kim@example.com', 'APPKEY', 'plant-a', ['reader'], 's')]
+    ]
+  }
+
+  it('어느 토큰에도 `jti` 가 없다 — 발급한 것을 가리킬 수 없으니 폐기할 수 없다', async () => {
+    for (const [kind, token] of await everyToken()) {
+      expect({ kind, jti: decode(token).payload.jti }).toEqual({ kind, jti: undefined })
+    }
+  })
+
+  it('어느 토큰에도 `kid` 가 없다 — 서명 키를 교체할 수 없다', async () => {
+    for (const [kind, token] of await everyToken()) {
+      expect({ kind, kid: decode(token).header.kid }).toEqual({ kind, kid: undefined })
+    }
+  })
+
+  it('모든 토큰이 같은 대칭키로 HS256 서명된다 — 검증하는 곳은 서명도 할 수 있다', async () => {
+    for (const [kind, token] of await everyToken()) {
+      expect({ kind, alg: decode(token).header.alg }).toEqual({ kind, alg: 'HS256' })
+      expect(() => jwt.verify(token, SECRET)).not.toThrow()
+    }
+  })
+})