@things-factory/auth-base 10.1.278 → 10.1.280

package/tests/permission-gate.test.ts

@@ -1,228 +0,0 @@
-/**
- * 인가 게이트(`checkPermission`) 판정 시험.
- *
- * 이 함수가 플랫폼의 **모든** 권한 판정의 마지막 자리다 — `@privilege` 지시자와
- * `auth-private-process-router`·`integration-base` 의 시나리오 실행이 모두 여기로 모인다.
- * 그런데 저장소의 시험 316개 중 이 함수를 부르는 것이 없었다. 리빌딩 전에 **지금 무엇을 하는지**
- * 를 고정한다.
- *
- * ## 이 시험이 고정하는 사실 중 둘은 「옳다」가 아니라 「지금 그렇다」다
- *
- *  ① **선언이 없으면 통과한다** — 게이트가 opt-in 이라는 뜻이고, 지시자를 잊은 리졸버는
- *    조용히 열린다(무선언 mutation 509개). 「닫힘을 기본으로」는 결정 대기 사항이다.
- *  ② **unsafeIP + 이름 없는 선언**의 규칙이 뒤집혀 있다 — 안전하지 않은 IP 에서 *더* 열린다.
- *    아래 해당 케이스에 그 자리를 표시해 두었다. 정책이 정해지면 시험을 먼저 바꾼다.
- *
- * 두 사실은 정책 결정(`docs/design/auth-rebuild.md` §1 · §7)이 나오기 전에는 바꾸지 않는다.
- * 시험이 지금 거동을 붙잡고 있으므로, 바꿀 때 무엇이 달라지는지 보인다.
- */
-
-import { loadCompiled } from './compiled'
-
-const { checkPermission } = loadCompiled('utils/check-permission')
-const { User } = loadCompiled('service/user/user')
-
-const DOMAIN = { id: 'domain-1', subdomain: 'plant-a' } as any
-const USER = { id: 'user-1', domains: [DOMAIN] } as any
-
-/** 역할 기반 판정(`User.hasPrivilege`)은 DB 를 본다 — 판정 규칙만 보려고 그 답을 고정한다. */
-function withRolePrivilege(answer: boolean) {
-  User.hasPrivilege = jest.fn().mockResolvedValue(answer)
-  return User.hasPrivilege
-}
-
-/**
- * 소유권 판정은 `process` 에 실린다(`domain-authenticate-middleware` 가 설치한다).
- * 게이트가 **자기 안에 없는 것에 의존**한다는 사실 자체가 아래 마지막 케이스의 주제다.
- */
-function withOwnership({ owner = false, superUser = false } = {}) {
-  ;(process as any).domainOwnerGranted = jest.fn().mockResolvedValue(owner)
-  ;(process as any).superUserGranted = jest.fn().mockResolvedValue(superUser)
-}
-
-beforeEach(() => {
-  withOwnership()
-  withRolePrivilege(false)
-})
-
-afterEach(() => {
-  delete (process as any).domainOwnerGranted
-  delete (process as any).superUserGranted
-})
-
-describe('선언이 없는 자리', () => {
-  it('선언이 없으면 통과한다 — 게이트는 opt-in 이다', async () => {
-    for (const nothing of [undefined, null]) {
-      expect(await checkPermission(nothing, USER, DOMAIN)).toBe(true)
-    }
-  })
-
-  it('사용자도 도메인도 없어도 통과한다 — 선언이 없으면 아무것도 보지 않는다', async () => {
-    expect(await checkPermission(undefined, undefined, undefined)).toBe(true)
-  })
-})
-
-describe('이름이 있는 권한 (category + privilege)', () => {
-  const NAMED = { category: 'board', privilege: 'mutation' }
-
-  it('역할이 그 권한을 가지면 통과한다', async () => {
-    const hasPrivilege = withRolePrivilege(true)
-
-    expect(await checkPermission(NAMED, USER, DOMAIN)).toBe(true)
-    expect(hasPrivilege).toHaveBeenCalledWith('mutation', 'board', DOMAIN, USER)
-  })
-
-  it('역할이 없으면 거절한다', async () => {
-    expect(await checkPermission(NAMED, USER, DOMAIN)).toBe(false)
-  })
-
-  it('소유권이 선언되지 않았으면 소유자여도 역할로만 판정한다', async () => {
-    withOwnership({ owner: true, superUser: true })
-
-    /* 선언에 owner/super 가 없다 — 우회는 **선언한 자리에서만** 일어난다. */
-    expect(await checkPermission(NAMED, USER, DOMAIN)).toBe(false)
-  })
-})
-
-describe('소유권 우회 (domainOwnerGranted / superUserGranted)', () => {
-  const OWNER_GRANTED = { category: 'board', privilege: 'mutation', owner: true }
-  const SUPER_GRANTED = { category: 'board', privilege: 'mutation', super: true }
-
-  it('도메인 소유자는 역할 없이 통과한다', async () => {
-    withOwnership({ owner: true })
-    const hasPrivilege = withRolePrivilege(false)
-
-    expect(await checkPermission(OWNER_GRANTED, USER, DOMAIN)).toBe(true)
-    /* 역할은 아예 보지 않는다 — 그래서 admin 계정으로는 거절 경로를 볼 수 없다. */
-    expect(hasPrivilege).not.toHaveBeenCalled()
-  })
-
-  it('수퍼유저는 역할 없이 통과한다', async () => {
-    withOwnership({ superUser: true })
-
-    expect(await checkPermission(SUPER_GRANTED, USER, DOMAIN)).toBe(true)
-  })
-
-  it('선언이 owner 만인데 수퍼유저이면 우회하지 않는다', async () => {
-    withOwnership({ superUser: true })
-
-    expect(await checkPermission(OWNER_GRANTED, USER, DOMAIN)).toBe(false)
-  })
-})
-
-describe('이름이 없는 선언 — 소유권만으로 판정한다', () => {
-  it('소유권만 선언한 자리는 소유자에게 열린다', async () => {
-    withOwnership({ owner: true })
-
-    expect(await checkPermission({ owner: true }, USER, DOMAIN)).toBe(true)
-  })
-
-  it('소유자가 아니면 닫힌다 — 값은 `false` 다', async () => {
-    /* 2026-10-02 까지는 `(true && false) || (undefined && …)` = `undefined` 가 나왔다. 선언한 타입은
-       `Promise<boolean>` 이었고, `=== false` 로 받는 소비처가 생기는 순간 조용히 통과할 자리였다.
-       판정이 이유를 내게 되면서(`judgePermission`, ADR-0103) 값이 타입과 같아졌다. */
-    const decision = await checkPermission({ owner: true }, USER, DOMAIN)
-
-    expect(decision).toBe(false)
-  })
-
-  it('refuses an object that names nothing', async () => {
-    /* `{}` is not `!privilegeObject`, so it passes the first gate and falls out falsy here.
-       The unsafe-address block below asserts the same answer, which is the point: it used to
-       answer the opposite. `privilege-directive.ts` refuses to build this shape at all now,
-       but `checkPermission` is exported and reachable without it. */
-    expect(await checkPermission({}, USER, DOMAIN)).toBeFalsy()
-  })
-})
-
-describe('금지 목록 (prohibitedPrivileges)', () => {
-  const NAMED = { category: 'board', privilege: 'mutation' }
-  const PROHIBITED = [{ category: 'board', privilege: 'mutation' }]
-
-  it('금지된 권한은 역할이 있어도 거절한다', async () => {
-    withRolePrivilege(true)
-
-    expect(await checkPermission(NAMED, USER, DOMAIN, false, PROHIBITED)).toBe(false)
-  })
-
-  it('다른 권한의 금지는 영향이 없다', async () => {
-    withRolePrivilege(true)
-
-    expect(
-      await checkPermission(NAMED, USER, DOMAIN, false, [{ category: 'board', privilege: 'query' }])
-    ).toBe(true)
-  })
-
-  it('소유권 우회가 금지 목록보다 먼저 판정된다 — 금지 목록은 소유자를 막지 못한다', async () => {
-    withOwnership({ owner: true })
-
-    expect(
-      await checkPermission({ ...NAMED, owner: true }, USER, DOMAIN, false, PROHIBITED)
-    ).toBe(true)
-  })
-})
-
-describe('안전하지 않은 IP (unsafeIP)', () => {
-  const NAMED = { category: 'board', privilege: 'mutation' }
-
-  it('이름이 있는 권한은 소유권을 무시하고 역할로만 판정한다', async () => {
-    withOwnership({ owner: true, superUser: true })
-    withRolePrivilege(false)
-
-    expect(await checkPermission({ ...NAMED, owner: true, super: true }, USER, DOMAIN, true)).toBe(false)
-  })
-
-  it('역할이 있으면 안전하지 않은 IP 에서도 통과한다', async () => {
-    withRolePrivilege(true)
-
-    expect(await checkPermission(NAMED, USER, DOMAIN, true)).toBe(true)
-  })
-
-  it('금지 목록은 안전하지 않은 IP 에서 그대로 적용된다', async () => {
-    withRolePrivilege(true)
-
-    expect(
-      await checkPermission(NAMED, USER, DOMAIN, true, [{ category: 'board', privilege: 'mutation' }])
-    ).toBe(false)
-  })
-
-  /*
-   * ── An unsafe address is never the more permissive of the two ────────────────
-   * These two were marked 뒤집힘 and pinned the opposite answer until 2026-09-15. The rule
-   * read `return !domainOwnerGranted && !superUserGranted`: "ownership does not apply from an
-   * unsafe address" came out as the declaration inverted rather than as a refusal, so an
-   * object naming nothing opened from an unsafe address and closed from a safe one.
-   *
-   * The architect found the same asymmetry from the other side on 2026-09-15, looking at what
-   * a field would do if someone wrote `@privilege()` wanting "signed in is enough".
-   */
-  it('refuses a declaration resting on ownership alone', async () => {
-    withOwnership({ owner: true })
-
-    expect(await checkPermission({ owner: true }, USER, DOMAIN, true)).toBe(false)
-  })
-
-  it('refuses an object that names nothing, the same as a safe address does', async () => {
-    expect(await checkPermission({}, USER, DOMAIN, true)).toBe(false)
-    expect(await checkPermission({}, USER, DOMAIN, false)).toBeFalsy()
-  })
-})
-
-describe('게이트가 자기 밖에 의존하는 것', () => {
-  it('소유권 판정자가 설치되지 않은 경로에서 부르면 던진다', async () => {
-    delete (process as any).domainOwnerGranted
-
-    /* `domain-authenticate-middleware` 가 `process` 에 심는다. 미들웨어를 타지 않는
-       호출 경로(작업 스케줄러·구독 밖 내부 호출)에서 소유권을 선언한 자리를 판정하면
-       판정이 아니라 예외가 된다. */
-    await expect(checkPermission({ owner: true }, USER, DOMAIN)).rejects.toThrow()
-  })
-
-  it('소유권을 선언하지 않은 자리는 판정자가 없어도 동작한다', async () => {
-    delete (process as any).domainOwnerGranted
-    delete (process as any).superUserGranted
-    withRolePrivilege(true)
-
-    expect(await checkPermission({ category: 'board', privilege: 'mutation' }, USER, DOMAIN)).toBe(true)
-  })
-})

package/tests/picture-reducer.test.ts

@@ -1,25 +0,0 @@
-import { SET_PICTURE, SET_PROFILE } from '../client/actions/auth'
-import auth from '../client/reducers/auth'
-
-/** The signed-in person's picture, which the header's avatar draws (`auth.picture`). */
-describe('the signed-in person\'s picture', () => {
-  const picture = { picture: '/attachment/face.png', left: 0, top: 0, zoom: 1 }
-
-  it('starts with none - the avatar draws a monogram', () => {
-    expect(auth(undefined, { type: '@@INIT' }).picture).toBeNull()
-  })
-
-  it('★ is set by SET_PICTURE and survives a later profile', () => {
-    let state = auth(undefined, { type: SET_PICTURE, picture })
-    state = auth(state, { type: SET_PROFILE, user: { name: '남상혁' } })
-
-    expect(state.picture).toEqual(picture)
-    expect(state.user).toEqual({ name: '남상혁' })
-  })
-
-  it('a missing picture clears it', () => {
-    const state = auth(auth(undefined, { type: SET_PICTURE, picture }), { type: SET_PICTURE, picture: undefined })
-
-    expect(state.picture).toBeNull()
-  })
-})

package/tests/privilege-axis.test.ts

@@ -1,157 +0,0 @@
-/**
- * The axis vocabulary — who owns it, and what a value outside it does.
- *
- * The framework used to accept any string as an axis. `@privilege(privilege: "mutaiton")`
- * registered a pair in `process['PRIVILEGES']` that nobody would ever be granted: a gate shut
- * forever, with nothing anywhere to read. Closing the axis to `query | mutation` in the
- * framework would have fixed that and broken dssp's 40 declarations, so the owner declares
- * and the framework asks.
- */
-
-import { loadCompiled } from './compiled'
-
-const { declareAxes, declaredAxes, isDeclaredAxis, readOnlyAxes, readOnlyAxesAreKnown, DEFAULT_AXES } = loadCompiled(
-  'service/privilege/privilege-axis'
-)
-
-beforeEach(() => {
-  delete (process as any).PRIVILEGE_AXES
-})
-
-afterEach(() => {
-  delete (process as any).PRIVILEGE_AXES
-})
-
-describe('an installation that declares nothing', () => {
-  it('gets query and mutation', () => {
-    expect([...declaredAxes()].sort()).toEqual(['mutation', 'query'])
-    expect(DEFAULT_AXES).toEqual(['query', 'mutation'])
-  })
-
-  it('still refuses a value outside them', () => {
-    /*
-     * The defaults are a vocabulary, not an off switch. An installation that forgot to declare
-     * is the common case, and it is the one that most needs the typo caught.
-     */
-    expect(isDeclaredAxis('query')).toBe(true)
-    expect(isDeclaredAxis('mutaiton')).toBe(false)
-  })
-})
-
-describe('an installation that declares its own words', () => {
-  it('accepts them', () => {
-    declareAxes(['read', 'input', 'finalize'])
-
-    expect(isDeclaredAxis('read')).toBe(true)
-    expect(isDeclaredAxis('finalize')).toBe(true)
-  })
-
-  it('replaces the defaults rather than adding to them', () => {
-    /*
-     * A house that says "my axes are read and input" has said what its axes are. Keeping
-     * query and mutation alongside would let a declaration use a word this installation
-     * does not actually mean, which is the thing being prevented.
-     */
-    declareAxes(['read', 'input'])
-
-    expect(isDeclaredAxis('query')).toBe(false)
-    expect([...declaredAxes()].sort()).toEqual(['input', 'read'])
-  })
-})
-
-describe('more than one module declaring', () => {
-  it('takes the union, because one installation mixes vocabularies', () => {
-    /*
-     * This is dssp: `project` is declared with query/mutation while `kpi` uses eight words of
-     * its own, in the same installation. Each module says what it uses.
-     */
-    declareAxes(['query', 'mutation'])
-    declareAxes(['read', 'assessment'])
-
-    expect([...declaredAxes()].sort()).toEqual(['assessment', 'mutation', 'query', 'read'])
-  })
-
-  it('does not treat the same axis twice as a conflict', () => {
-    /* Two modules reaching for `read` independently is the case this is built for. */
-    declareAxes(['read'])
-    declareAxes(['read'])
-
-    expect([...declaredAxes()]).toEqual(['read'])
-  })
-})
-
-describe('what declareAxes refuses', () => {
-  it('refuses an empty list, which would refuse every declaration', () => {
-    expect(() => declareAxes([])).toThrow(/at least one axis/)
-    expect(() => declareAxes(undefined as any)).toThrow(/at least one axis/)
-  })
-
-  it('refuses a value that is not a word', () => {
-    expect(() => declareAxes([''])).toThrow(/non-empty strings/)
-    expect(() => declareAxes(['  '])).toThrow(/non-empty strings/)
-    expect(() => declareAxes([null as any])).toThrow(/non-empty strings/)
-  })
-
-  it('changes nothing when it refuses', () => {
-    declareAxes(['read'], { readOnly: ['read'] })
-
-    expect(() => declareAxes(['input', ''])).toThrow()
-
-    /*
-     * Every value is checked before any is stored, so a refused call leaves the vocabulary as
-     * it was. An earlier draft added axes as it walked the list and stopped at the bad one,
-     * which left `input` declared by a call that threw.
-     */
-    expect(isDeclaredAxis('input')).toBe(false)
-    expect(isDeclaredAxis('read')).toBe(true)
-  })
-
-  it('refuses a read-only axis that is not in the same call', () => {
-    /*
-     * A typo here is the quietest kind: `readOnly: ['querry']` would mark nothing, VIEWER
-     * would lose every category of this module, and the screen would count the shortfall
-     * correctly and present it as fact.
-     */
-    expect(() => declareAxes(['query', 'mutation'], { readOnly: ['querry'] })).toThrow(/not in the same call/)
-    expect(() => declareAxes(['read'], { readOnly: ['query'] })).toThrow(/Declared here: read/)
-  })
-})
-
-describe('which axes are read-only', () => {
-  it('defaults to query when nobody declared anything', () => {
-    /* The vocabulary and the answer to "which half is safe" travel together. */
-    expect([...readOnlyAxes()]).toEqual(['query'])
-    expect(readOnlyAxesAreKnown()).toBe(true)
-  })
-
-  it('is unknown when a house declared its own words and did not say', () => {
-    declareAxes(['read', 'input', 'finalize'])
-
-    expect(readOnlyAxes().size).toBe(0)
-    expect(readOnlyAxesAreKnown()).toBe(false)
-  })
-
-  it('takes the union across modules, like the axes themselves', () => {
-    declareAxes(['query', 'mutation'], { readOnly: ['query'] })
-    declareAxes(['read', 'finalize'], { readOnly: ['read'] })
-
-    expect([...readOnlyAxes()].sort()).toEqual(['query', 'read'])
-  })
-
-  it('does not mean the operation is a @Query', () => {
-    /*
-     * `exportLabelStudioAnnotations` is declared `@Mutation` and gated on `label-studio:query`
-     * [읽었음 task-management.ts:200-204]. It calls an external API's export and returns what
-     * comes back; nothing in our database moves. The axis is the correct one, and a role
-     * holding only that axis still changes nothing.
-     *
-     * This test carries no assertion about that file — it cannot, from here. It exists so the
-     * next person reading `readOnly` finds the distinction spelled out beside the code rather
-     * than only in a comment they might skip.
-     */
-    declareAxes(['query', 'mutation'], { readOnly: ['query'] })
-
-    expect(readOnlyAxes().has('query')).toBe(true)
-    expect(readOnlyAxes().has('mutation')).toBe(false)
-  })
-})

package/tests/privilege-deprecation.test.ts

@@ -1,65 +0,0 @@
-/**
- * 유령 권한 판정 테스트.
- *
- * 계기: 트윈에서 조회 게이트 둘(`twin/query`)을 걷어낸 뒤 DB 에 그 행이 남았다. 부팅 동기화는 없는 행을
- * **추가만** 하고 사라진 지시자의 행을 지우지 않는다. 그래서 관리자는 역할에 붙일 수 있고 붙여도 아무
- * 일이 없는 권한을 목록에서 보게 된다.
- *
- * 이 판정이 틀리는 방향은 두 가지이고, 둘의 값이 다르다:
- *  · 살아 있는 권한을 유령이라고 하면 → 관리자가 **필요한 권한을 뗀다**(사용자가 못 쓰게 된다).
- *  · 유령을 살아 있다고 하면 → 목록이 조금 지저분한 상태로 남는다(지금과 같다).
- * 그래서 확신이 없을 때는 **유령이라고 말하지 않는다.**
- */
-
-import { declarationKey, isDeprecatedPrivilege } from '../server/service/privilege/privilege-deprecation.js'
-
-/** 지시자가 실제로 만드는 모양: `process['PRIVILEGES']['twin mutation'] = ['twin', 'mutation']`. */
-const declared = (...pairs: [string, string][]) =>
-  pairs.reduce((sum, [category, privilege]) => ({ ...sum, [declarationKey(category, privilege)]: [category, privilege] }), {})
-
-const TWIN_MUTATION = { category: 'twin', name: 'mutation' }
-const TWIN_QUERY = { category: 'twin', name: 'query' }
-
-describe('privilege deprecation', () => {
-  it('선언된 권한은 유령이 아니다', () => {
-    const declarations = declared(['twin', 'mutation'], ['board', 'query'])
-
-    expect(isDeprecatedPrivilege(declarations, TWIN_MUTATION)).toBe(false)
-  })
-
-  it('선언이 사라진 권한은 유령이다 — 이 작업의 계기 그대로', () => {
-    /* 트윈 조회 게이트를 걷어낸 뒤의 상태: mutation 은 선언되어 있고 query 는 아니다. */
-    const declarations = declared(['twin', 'mutation'])
-
-    expect(isDeprecatedPrivilege(declarations, TWIN_QUERY)).toBe(true)
-    expect(isDeprecatedPrivilege(declarations, TWIN_MUTATION)).toBe(false)
-  })
-
-  it('category 와 name 을 함께 본다 — 한쪽만 같은 것을 짝으로 세지 않는다', () => {
-    const declarations = declared(['twin', 'mutation'])
-
-    /* 이름이 같아도 다른 category 면 다른 권한이다(`query`/`mutation` 은 43개 category 가 공유한다). */
-    expect(isDeprecatedPrivilege(declarations, { category: 'board', name: 'mutation' })).toBe(true)
-    expect(isDeprecatedPrivilege(declarations, { category: 'twin', name: 'query' })).toBe(true)
-  })
-
-  it('선언이 하나도 없으면 판단하지 않는다 — 전부 유령이라 답하지 않는다', () => {
-    /* 스키마가 아직 구성되지 않았거나 전역이 비어 있는 상황. 거짓 경보보다 무판단이 정직하다. */
-    for (const empty of [{}, undefined, null]) {
-      expect(isDeprecatedPrivilege(empty, TWIN_MUTATION)).toBe(false)
-    }
-  })
-
-  it('반쪽 행은 어떤 선언과도 짝지을 수 없다', () => {
-    const declarations = declared(['twin', 'mutation'])
-
-    expect(isDeprecatedPrivilege(declarations, { category: 'twin' })).toBe(true)
-    expect(isDeprecatedPrivilege(declarations, { name: 'mutation' })).toBe(true)
-    expect(isDeprecatedPrivilege(declarations, {})).toBe(true)
-  })
-
-  it('키 모양이 지시자와 같다 — 이 규약이 어긋나면 전부 유령이 된다', () => {
-    /* `privilege-directive.ts` 가 `${category} ${privilege}` 로 넣는다. 공백 하나가 규약이다. */
-    expect(declarationKey('twin', 'mutation')).toBe('twin mutation')
-  })
-})