mega-framework 0.1.4 → 0.1.6

package/sample/crud/test/apps/main/perf.integration.test.js

@@ -1,202 +0,0 @@
-// @ts-check
-/**
- * /perf 벤치마크 통합 테스트(ADR-174) — 실 postgres+mongo+redis(캐시·세션)로 sample/crud 를 부팅하고
- * 인증된 HTTP 경로로 각 어댑터 시나리오를 실행한다. in-process 시나리오(http/json/crypto)는 단위 테스트가
- * 커버하므로, 여기서는 어댑터 왕복(db.pg/db.mongo/cache.redis/session)과 스키마 검증·가드·teardown 을 본다.
- *
- * 인프라(pg·redis·mongo) env 가 없으면 통째로 skip 한다. 필요한 env(.env): DATABASE_URL·REDIS_SESSION_URL·
- * REDIS_RATE_URL·REDIS_DEMO_URL·MONGO_URL·SESSION_SECRET.
- */
-import { describe, test, expect, beforeAll, afterAll } from 'vitest'
-import { bootApp, MegaShutdown } from 'mega-framework'
-import { fileURLToPath } from 'node:url'
-import { dirname, resolve } from 'node:path'
-import { User } from '../../../apps/main/models/user.js'
-
-// 프로젝트 루트(mega.config.js 가 있는 sample/crud) — 이 파일 기준 상위 4단계.
-const PROJECT = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')
-
-// .env 가 DATABASE_URL 대신 PG_URL 만 줄 수 있으므로(로컬 관례) 매핑한다.
-if (!process.env.DATABASE_URL && process.env.PG_URL) process.env.DATABASE_URL = process.env.PG_URL
-
-const hasInfra = Boolean(
-  process.env.DATABASE_URL &&
-    process.env.REDIS_SESSION_URL &&
-    process.env.REDIS_RATE_URL &&
-    process.env.REDIS_DEMO_URL &&
-    process.env.MONGO_URL &&
-    process.env.SESSION_SECRET,
-)
-const d = hasInfra ? describe : describe.skip
-
-/** set-cookie 를 누적 쿠키 jar 에 반영(maxAge=0 → 삭제). @param {any} res @param {Record<string,string>} jar */
-function applyCookies(res, jar) {
-  const raw = res.headers['set-cookie']
-  const arr = Array.isArray(raw) ? raw : raw ? [raw] : []
-  for (const c of arr) {
-    const pair = String(c).split(';')[0]
-    const eq = pair.indexOf('=')
-    if (eq === -1) continue
-    const name = pair.slice(0, eq).trim()
-    const val = pair.slice(eq + 1).trim()
-    if (val === '') delete jar[name]
-    else jar[name] = val
-  }
-}
-
-/** @param {Record<string,string>} jar @returns {string} Cookie 헤더. */
-function cookieHeader(jar) {
-  return Object.entries(jar).map(([k, v]) => `${k}=${v}`).join('; ')
-}
-
-/** 렌더된 폼 HTML 에서 hidden `_csrf` 토큰을 뽑는다. @param {string} html @returns {string} */
-function csrfFrom(html) {
-  const m = /name="_csrf" value="([^"]+)"/.exec(html)
-  if (!m) throw new Error('csrf token not found in form HTML')
-  return m[1]
-}
-
-/** urlencoded 폼 바디 직렬화. @param {Record<string,string>} fields @returns {string} */
-function form(fields) {
-  return Object.entries(fields).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join('&')
-}
-
-d('/perf 벤치마크 E2E — sample/crud 실 pg+mongo+redis (ADR-174)', () => {
-  /** @type {Awaited<ReturnType<typeof bootApp>>} */
-  let boot
-  /** @type {any} */
-  let fastify
-  /** @type {Record<string,string>} 로그인 세션 쿠키 jar. */
-  const jar = {}
-  const EMAIL = `itest-perf-${Date.now()}@example.com`
-  const PASSWORD = 'secret-pass-123'
-  const NAME = 'Perf Tester'
-
-  /**
-   * 인증 쿠키로 /perf/run 을 호출한다(JSON — CSRF 토큰 면제, Origin 헤더 없으면 비브라우저로 통과, ADR-051).
-   * @param {object} body @returns {Promise<any>} inject 응답.
-   */
-  function runPerf(body) {
-    return fastify.inject({
-      method: 'POST',
-      url: '/perf/run',
-      headers: { cookie: cookieHeader(jar), 'content-type': 'application/json', accept: 'application/json' },
-      payload: JSON.stringify(body),
-    })
-  }
-
-  beforeAll(async () => {
-    MegaShutdown._reset()
-    boot = await bootApp(PROJECT, { listen: false })
-    const app = boot.megaApps.find((a) => a.name === 'main')
-    fastify = app?.fastify
-    await fastify.ready()
-    await User.query('CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT NOT NULL, email TEXT NOT NULL UNIQUE, created_at TIMESTAMPTZ NOT NULL DEFAULT now())')
-    await User.query('ALTER TABLE users ADD COLUMN IF NOT EXISTS password_hash TEXT')
-    await User.query('ALTER TABLE users ADD COLUMN IF NOT EXISTS last_login_at TIMESTAMPTZ')
-    await User.query('DELETE FROM users WHERE email = $1', [EMAIL])
-
-    // 회원가입 → 자동 로그인 → 세션 쿠키 확보(가드된 /perf 접근에 필요).
-    const regForm = await fastify.inject({ method: 'GET', url: '/register' })
-    applyCookies(regForm, jar)
-    const reg = await fastify.inject({
-      method: 'POST',
-      url: '/register',
-      headers: { cookie: cookieHeader(jar), 'content-type': 'application/x-www-form-urlencoded' },
-      payload: form({ _csrf: csrfFrom(regForm.body), name: NAME, email: EMAIL, password: PASSWORD }),
-    })
-    applyCookies(reg, jar)
-  })
-
-  afterAll(async () => {
-    if (!boot) return
-    await User.query('DELETE FROM users WHERE email = $1', [EMAIL]).catch(() => {})
-    await boot.ctx.db('primary').query('DROP TABLE IF EXISTS perf_bench').catch(() => {})
-    await fastify?.close().catch(() => {})
-    const app = boot.megaApps.find((a) => a.name === 'main')
-    await app?.sessionStore?.disconnect().catch(() => {})
-    await boot.ctx.cache('rate').disconnect().catch(() => {})
-    await boot.ctx.cache('demo').disconnect().catch(() => {})
-    await boot.ctx.db('mongo').disconnect().catch(() => {})
-    await boot.ctx.db('primary').disconnect().catch(() => {})
-    MegaShutdown._reset()
-  })
-
-  test('비로그인: /perf 는 로그인으로 302', async () => {
-    const res = await fastify.inject({ method: 'GET', url: '/perf' })
-    expect(res.statusCode).toBe(302)
-    expect(res.headers.location).toBe('/auth/login')
-  })
-
-  test('로그인 후 /perf UI 200', async () => {
-    const res = await fastify.inject({ method: 'GET', url: '/perf', headers: { cookie: cookieHeader(jar) } })
-    expect(res.statusCode).toBe(200)
-    expect(res.body).toContain('perf.js')
-  })
-
-  test('스키마: 미지원 scenario → 400', async () => {
-    const res = await runPerf({ scenario: 'bogus', iterations: 10 })
-    expect(res.statusCode).toBe(400)
-  })
-
-  test('스키마: iterations 상한 초과 → 400', async () => {
-    const res = await runPerf({ scenario: 'http.echo', iterations: 100001 })
-    expect(res.statusCode).toBe(400)
-  })
-
-  test('http.echo — 200, 전부 성공', async () => {
-    const res = await runPerf({ scenario: 'http.echo', iterations: 100 })
-    expect(res.statusCode).toBe(200)
-    const env = JSON.parse(res.body)
-    expect(env.ok).toBe(true)
-    expect(env.data.ok).toBe(100)
-    expect(env.data.fail).toBe(0)
-    expect(env.data.rps).toBeGreaterThan(0)
-  })
-
-  test('cache.redis.setGet — 실 redis 왕복 전부 성공', async () => {
-    const res = await runPerf({ scenario: 'cache.redis.setGet', iterations: 50, payloadSize: 128 })
-    expect(res.statusCode).toBe(200)
-    const env = JSON.parse(res.body)
-    expect(env.data.ok).toBe(50)
-    expect(env.data.fail).toBe(0)
-  })
-
-  test('session.createRead — 실 세션 스토어 왕복 전부 성공', async () => {
-    const res = await runPerf({ scenario: 'session.createRead', iterations: 50 })
-    expect(res.statusCode).toBe(200)
-    const env = JSON.parse(res.body)
-    expect(env.data.ok).toBe(50)
-    expect(env.data.fail).toBe(0)
-  })
-
-  test('db.pg.insertSelect — 실 postgres 왕복 전부 성공 + teardown 으로 잔여 0', async () => {
-    const res = await runPerf({ scenario: 'db.pg.insertSelect', iterations: 50 })
-    expect(res.statusCode).toBe(200)
-    const env = JSON.parse(res.body)
-    expect(env.data.ok).toBe(50)
-    expect(env.data.fail).toBe(0)
-    // teardown(DELETE WHERE run_id) 후 이 실행이 남긴 행은 없어야 한다(다른 run 부재 시 총 0).
-    const left = await boot.ctx.db('primary').query('SELECT count(*)::int AS c FROM perf_bench')
-    expect(left.rows[0].c).toBe(0)
-  })
-
-  test('db.mongo.insertFind — 실 mongo 왕복 전부 성공 + teardown 으로 잔여 0', async () => {
-    const res = await runPerf({ scenario: 'db.mongo.insertFind', iterations: 50 })
-    expect(res.statusCode).toBe(200)
-    const env = JSON.parse(res.body)
-    expect(env.data.ok).toBe(50)
-    expect(env.data.fail).toBe(0)
-    const left = await boot.ctx.db('mongo').native.collection('perf_bench').countDocuments({})
-    expect(left).toBe(0)
-  })
-
-  test('crypto.hash — 동시성 clamp(>4 → 4) 가 결과에 표시', async () => {
-    const res = await runPerf({ scenario: 'crypto.hash', iterations: 3, concurrency: 16 })
-    expect(res.statusCode).toBe(200)
-    const env = JSON.parse(res.body)
-    expect(env.data.ok).toBe(3)
-    expect(env.data.concurrency).toBe(4)
-    expect(env.data.clamped.concurrency).toEqual({ requested: 16, applied: 4 })
-  })
-})

package/sample/crud/test/apps/main/redis-demo-service.test.js

@@ -1,98 +0,0 @@
-// @ts-check
-/**
- * RedisDemoService 단위 테스트(ADR-157) — 'demo' 캐시 어댑터(get/set/del + native incr/expire/ttl)와
- * User.count 를 가짜로 갈음해 redis 없이 카운터·캐시 로직을 검증한다. 실 redis 흐름은 통합 테스트가 커버한다.
- */
-import { describe, test, expect, vi, afterEach } from 'vitest'
-import { RedisDemoService } from '../../../apps/main/services/redis-demo-service.js'
-import { User } from '../../../apps/main/models/user.js'
-
-/**
- * incr/expire/ttl/get/set/del 을 추적하는 가짜 'demo' 캐시 어댑터 + 이를 돌려주는 ctx 를 만든다.
- * @param {{ store?: Map<string, any> }} [opts]
- */
-function makeCtx({ store = new Map() } = {}) {
-  /** @type {Map<string, number>} INCR 카운터(native). */
-  const counters = new Map()
-  const native = {
-    /** @param {string} k */
-    async incr(k) {
-      const n = (counters.get(k) ?? 0) + 1
-      counters.set(k, n)
-      return n
-    },
-    expire: vi.fn(async () => 1),
-    /** @param {string} k */
-    async ttl(k) {
-      return store.has(k) ? 30 : -2
-    },
-  }
-  const cache = {
-    native,
-    /** @param {string} k */
-    async get(k) {
-      return store.has(k) ? store.get(k) : null
-    },
-    /** @param {string} k @param {any} v */
-    async set(k, v) {
-      store.set(k, v)
-    },
-    /** @param {string} k */
-    async del(k) {
-      store.delete(k)
-    },
-  }
-  const ctx = { log: { debug() {} }, cache: (/** @type {string} */ alias) => (alias === 'demo' ? cache : null) }
-  return { ctx, native, store, counters }
-}
-
-afterEach(() => vi.restoreAllMocks())
-
-describe('RedisDemoService — 방문 카운터', () => {
-  test('recordVisit — total/today 가 매 호출마다 1씩 증가하고 당일 키에 EXPIRE 를 건다', async () => {
-    const { ctx, native } = makeCtx()
-    const svc = new RedisDemoService(/** @type {any} */ (ctx))
-    const first = await svc.recordVisit()
-    expect(first).toMatchObject({ total: 1, today: 1 })
-    expect(typeof first.date).toBe('string')
-    const second = await svc.recordVisit()
-    expect(second).toMatchObject({ total: 2, today: 2 })
-    // 당일 키 TTL 재설정이 매 방문마다 호출된다(rolling).
-    expect(native.expire).toHaveBeenCalledWith(RedisDemoService.VISITS_DAY_PREFIX + second.date, RedisDemoService.VISITS_DAY_TTL)
-    expect(native.expire).toHaveBeenCalledTimes(2)
-  })
-})
-
-describe('RedisDemoService — 쿼리 결과 캐시', () => {
-  test('miss → SQL 재계산 후 SET, isHit=false', async () => {
-    const { ctx, store } = makeCtx()
-    vi.spyOn(User, 'count').mockResolvedValue(7)
-    const svc = new RedisDemoService(/** @type {any} */ (ctx))
-    const r = await svc.getUserCountCached()
-    expect(r).toEqual({ value: 7, isHit: false, ttlSeconds: RedisDemoService.USER_COUNT_TTL })
-    // SET 으로 캐시에 채워졌다.
-    expect(store.get(RedisDemoService.USER_COUNT_KEY)).toBe(7)
-  })
-
-  test('hit → 캐시 값 반환, SQL 미실행, isHit=true + 남은 TTL', async () => {
-    const store = new Map([[RedisDemoService.USER_COUNT_KEY, 42]])
-    const { ctx } = makeCtx({ store })
-    const countSpy = vi.spyOn(User, 'count')
-    const svc = new RedisDemoService(/** @type {any} */ (ctx))
-    const r = await svc.getUserCountCached()
-    expect(r).toEqual({ value: 42, isHit: true, ttlSeconds: 30 })
-    expect(countSpy).not.toHaveBeenCalled()
-  })
-
-  test('clearUserCountCache — DEL 후 다음 조회는 miss', async () => {
-    const store = new Map([[RedisDemoService.USER_COUNT_KEY, 99]])
-    const { ctx } = makeCtx({ store })
-    vi.spyOn(User, 'count').mockResolvedValue(3)
-    const svc = new RedisDemoService(/** @type {any} */ (ctx))
-    await svc.clearUserCountCache()
-    expect(store.has(RedisDemoService.USER_COUNT_KEY)).toBe(false)
-    const r = await svc.getUserCountCached()
-    expect(r.isHit).toBe(false)
-    expect(r.value).toBe(3)
-  })
-})

package/sample/crud/test/apps/main/tracing-demo-service.test.js

@@ -1,90 +0,0 @@
-// @ts-check
-/**
- * TracingDemoService 단위 테스트 — zipkinBase 파생, 현재 trace 기록(있을 때만), snapshot 을 검증한다.
- * MegaTracing(currentTraceIds/isEnabled)을 가짜로 갈음하고 redis native(lpush/ltrim/lrange)를 가짜로 둔다.
- */
-import { describe, test, expect, vi, beforeEach } from 'vitest'
-
-vi.mock('mega-framework', async (importOriginal) => {
-  const actual = /** @type {any} */ (await importOriginal())
-  return {
-    ...actual,
-    MegaTracing: { ...actual.MegaTracing, currentTraceIds: vi.fn(), isEnabled: vi.fn() },
-  }
-})
-
-import { MegaTracing } from 'mega-framework'
-import { TracingDemoService } from '../../../apps/main/services/tracing-demo-service.js'
-
-function makeCtx() {
-  /** @type {Map<string, string[]>} */
-  const lists = new Map()
-  const native = {
-    async lpush(/** @type {string} */ k, /** @type {string} */ v) {
-      const arr = lists.get(k) ?? []
-      arr.unshift(v)
-      lists.set(k, arr)
-      return arr.length
-    },
-    ltrim: vi.fn(async (/** @type {string} */ k, /** @type {number} */ _s, /** @type {number} */ stop) => {
-      lists.set(k, (lists.get(k) ?? []).slice(0, stop + 1))
-      return 'OK'
-    }),
-    async lrange(/** @type {string} */ k, /** @type {number} */ s, /** @type {number} */ e) {
-      return (lists.get(k) ?? []).slice(s, e + 1)
-    },
-  }
-  const ctx = { log: { debug() {} }, cache: (/** @type {string} */ a) => (a === 'demo' ? { native } : null) }
-  return { ctx, lists }
-}
-
-beforeEach(() => {
-  vi.clearAllMocks()
-})
-
-describe('TracingDemoService — zipkinBase', () => {
-  test('MEGA_OTEL_ZIPKIN_API 에서 /api/v2 를 떼 UI 루트를 만든다', () => {
-    const prev = process.env.MEGA_OTEL_ZIPKIN_API
-    process.env.MEGA_OTEL_ZIPKIN_API = 'http://zip.example:9411/api/v2'
-    expect(TracingDemoService.zipkinBase()).toBe('http://zip.example:9411')
-    delete process.env.MEGA_OTEL_ZIPKIN_API
-    expect(TracingDemoService.zipkinBase()).toBe('http://localhost:9411')
-    if (prev !== undefined) process.env.MEGA_OTEL_ZIPKIN_API = prev
-  })
-})
-
-describe('TracingDemoService — record', () => {
-  test('trace_id 가 있으면 이력 머리에 기록하고 traceId 를 돌려준다', async () => {
-    vi.mocked(MegaTracing.currentTraceIds).mockReturnValue({ traceId: 'abc', spanId: 'def' })
-    const { ctx, lists } = makeCtx()
-    const svc = new TracingDemoService(/** @type {any} */ (ctx))
-    const id = await svc.record('GET /demo/tracing')
-    expect(id).toBe('abc')
-    const stored = (lists.get(TracingDemoService.RECENT_KEY) ?? []).map((s) => JSON.parse(s))
-    expect(stored[0]).toMatchObject({ traceId: 'abc', spanId: 'def', route: 'GET /demo/tracing' })
-  })
-
-  test('trace_id 가 없으면(트레이싱 OFF) no-op + null', async () => {
-    vi.mocked(MegaTracing.currentTraceIds).mockReturnValue(null)
-    const { ctx, lists } = makeCtx()
-    const svc = new TracingDemoService(/** @type {any} */ (ctx))
-    const id = await svc.record('x')
-    expect(id).toBeNull()
-    expect(lists.get(TracingDemoService.RECENT_KEY)).toBeUndefined()
-  })
-})
-
-describe('TracingDemoService — snapshot', () => {
-  test('enabled/current/recent/zipkinBase 를 돌려준다', async () => {
-    vi.mocked(MegaTracing.isEnabled).mockReturnValue(true)
-    vi.mocked(MegaTracing.currentTraceIds).mockReturnValue({ traceId: 't1', spanId: 's1' })
-    const { ctx } = makeCtx()
-    const svc = new TracingDemoService(/** @type {any} */ (ctx))
-    await svc.record('GET /demo/tracing')
-    const snap = await svc.snapshot()
-    expect(snap.enabled).toBe(true)
-    expect(snap.current).toEqual({ traceId: 't1', spanId: 's1' })
-    expect(snap.recent).toHaveLength(1)
-    expect(snap.zipkinBase).toMatch(/^https?:\/\//)
-  })
-})

package/sample/crud/test/apps/main/upload-demo-service.test.js

@@ -1,61 +0,0 @@
-// @ts-check
-/**
- * UploadDemoService 단위 테스트 — saveUploads 결과 메타(파일명/크기/MIME)를 redis 이력에 기록하고 snapshot
- * 으로 최신순 반환하는지 검증한다. redis native(lpush/ltrim/lrange)를 가짜로 둔다.
- */
-import { describe, test, expect, vi } from 'vitest'
-import { UploadDemoService } from '../../../apps/main/services/upload-demo-service.js'
-
-function makeCtx() {
-  /** @type {Map<string, string[]>} */
-  const lists = new Map()
-  const native = {
-    async lpush(/** @type {string} */ k, /** @type {string} */ v) {
-      const arr = lists.get(k) ?? []
-      arr.unshift(v)
-      lists.set(k, arr)
-      return arr.length
-    },
-    ltrim: vi.fn(async (/** @type {string} */ k, /** @type {number} */ _s, /** @type {number} */ stop) => {
-      lists.set(k, (lists.get(k) ?? []).slice(0, stop + 1))
-      return 'OK'
-    }),
-    async lrange(/** @type {string} */ k, /** @type {number} */ s, /** @type {number} */ e) {
-      return (lists.get(k) ?? []).slice(s, e + 1)
-    },
-  }
-  const ctx = { log: { debug() {} }, cache: (/** @type {string} */ a) => (a === 'demo' ? { native } : null) }
-  return { ctx, lists }
-}
-
-describe('UploadDemoService — record', () => {
-  test('파일별로 메타를 이력 머리에 쌓는다(최신이 앞)', async () => {
-    const { ctx, lists } = makeCtx()
-    const svc = new UploadDemoService(/** @type {any} */ (ctx))
-    await svc.record([
-      { filename: 'a.png', bytes: 100, mimetype: 'image/png' },
-      { filename: 'b.pdf', bytes: 200, mimetype: 'application/pdf' },
-    ])
-    const stored = (lists.get(UploadDemoService.RECENT_KEY) ?? []).map((s) => JSON.parse(s))
-    expect(stored[0]).toMatchObject({ filename: 'b.pdf', bytes: 200, mimetype: 'application/pdf' })
-    expect(stored[1]).toMatchObject({ filename: 'a.png' })
-  })
-
-  test('빈 배열은 no-op', async () => {
-    const { ctx, lists } = makeCtx()
-    const svc = new UploadDemoService(/** @type {any} */ (ctx))
-    await svc.record([])
-    expect(lists.get(UploadDemoService.RECENT_KEY)).toBeUndefined()
-  })
-})
-
-describe('UploadDemoService — snapshot', () => {
-  test('최근 업로드 목록을 최신순으로 돌려준다', async () => {
-    const { ctx } = makeCtx()
-    const svc = new UploadDemoService(/** @type {any} */ (ctx))
-    await svc.record([{ filename: 'a.txt', bytes: 10, mimetype: 'text/plain' }])
-    const snap = await svc.snapshot()
-    expect(snap.recent).toHaveLength(1)
-    expect(snap.recent[0]).toMatchObject({ filename: 'a.txt', bytes: 10, mimetype: 'text/plain' })
-  })
-})

package/sample/crud/test/apps/main/user-service.test.js

@@ -1,65 +0,0 @@
-// @ts-check
-/**
- * UserService 단위 테스트 — 모델(static)을 스파이로 갈음해 DB 없이 비즈니스 로직(검증·404·409 매핑)을 검증.
- * 실 postgres CRUD 는 레포 E2E(scaffold/sample 검증)에서 확인.
- */
-import { describe, test, expect, vi, afterEach } from 'vitest'
-import { UserService } from '../../../apps/main/services/user-service.js'
-import { User } from '../../../apps/main/models/user.js'
-
-/** @returns {UserService} */
-function makeService() {
-  return new UserService(/** @type {any} */ ({ log: { debug() {} } }))
-}
-
-afterEach(() => vi.restoreAllMocks())
-
-describe('UserService', () => {
-  test('list → User.list 위임', async () => {
-    vi.spyOn(User, 'list').mockResolvedValue([/** @type {any} */ ({ id: 1, name: 'a', email: 'a@b.c' })])
-    expect(await makeService().list()).toEqual([{ id: 1, name: 'a', email: 'a@b.c' }])
-  })
-
-  test('get — 존재하면 반환', async () => {
-    vi.spyOn(User, 'findById').mockResolvedValue(/** @type {any} */ ({ id: 7 }))
-    expect(await makeService().get(7)).toEqual({ id: 7 })
-  })
-
-  test('get — 없으면 MegaNotFoundError(404)', async () => {
-    vi.spyOn(User, 'findById').mockResolvedValue(null)
-    await expect(makeService().get(99)).rejects.toMatchObject({ status: 404, code: 'user.not_found' })
-  })
-
-  test('create — name/email 누락 시 MegaValidationError(400)', async () => {
-    await expect(makeService().create({ name: '', email: '' })).rejects.toMatchObject({ status: 400, code: 'user.invalid' })
-  })
-
-  test('create — 정상 생성', async () => {
-    const spy = vi.spyOn(User, 'create').mockResolvedValue(/** @type {any} */ ({ id: 1, name: 'a', email: 'a@b.c' }))
-    const r = await makeService().create({ name: ' a ', email: ' a@b.c ' })
-    expect(r).toEqual({ id: 1, name: 'a', email: 'a@b.c' })
-    expect(spy).toHaveBeenCalledWith({ name: 'a', email: 'a@b.c' }) // trim 적용
-  })
-
-  test('create — postgres 23505 → MegaConflictError(409)', async () => {
-    vi.spyOn(User, 'create').mockRejectedValue(Object.assign(new Error('dup'), { code: '23505' }))
-    await expect(makeService().create({ name: 'a', email: 'a@b.c' })).rejects.toMatchObject({ status: 409, code: 'user.email_taken' })
-  })
-
-  test('update — 없으면 404', async () => {
-    vi.spyOn(User, 'update').mockResolvedValue(null)
-    await expect(makeService().update(99, { name: 'x' })).rejects.toMatchObject({ status: 404 })
-  })
-
-  test('update — postgres 23505 → MegaConflictError(409)', async () => {
-    vi.spyOn(User, 'update').mockRejectedValue(Object.assign(new Error('dup'), { code: '23505' }))
-    await expect(makeService().update(1, { email: 'taken@b.c' })).rejects.toMatchObject({ status: 409, code: 'user.email_taken' })
-  })
-
-  test('remove — 없으면 404, 있으면 deleted', async () => {
-    const spy = vi.spyOn(User, 'remove').mockResolvedValue(false)
-    await expect(makeService().remove(99)).rejects.toMatchObject({ status: 404 })
-    spy.mockResolvedValue(true)
-    expect(await makeService().remove(1)).toEqual({ deleted: true })
-  })
-})