mega-framework 0.1.4 → 0.1.6

package/sample/crud/test/apps/main/email-job.test.js

@@ -1,76 +0,0 @@
-// @ts-check
-/**
- * EmailJob 단위 테스트 — 'demo' 캐시 native(incr/expire/lpush/ltrim)를 가짜로 갈음해 NATS 없이 run() 의 세
- * 모드(ok/flaky/fail) 흐름과 이벤트 기록을 검증한다. 실 큐/재시도/DLQ 는 통합 검증(E2E)이 커버한다.
- */
-import { describe, test, expect, vi } from 'vitest'
-import { EmailJob } from '../../../apps/main/jobs/email-job.js'
-
-/** 시도 카운터(incr) + 이벤트 LIST 를 추적하는 가짜 ctx. */
-function makeCtx() {
-  /** @type {Map<string, number>} */
-  const counters = new Map()
-  /** @type {string[]} */
-  const events = []
-  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 @param {string} v */
-    async lpush(_k, v) {
-      events.unshift(v)
-      return events.length
-    },
-    ltrim: vi.fn(async () => 'OK'),
-  }
-  const ctx = { log: { debug() {} }, cache: (/** @type {string} */ a) => (a === 'demo' ? { native } : null) }
-  return { ctx, events, native }
-}
-
-describe('EmailJob.run — ok 모드', () => {
-  test('첫 시도에 sent 를 반환하고 sent 이벤트를 남긴다', async () => {
-    const { ctx, events } = makeCtx()
-    const job = new EmailJob()
-    const r = await job.run({ id: 'e1', to: 'a@b.c', mode: 'ok' }, /** @type {any} */ (ctx))
-    expect(r).toEqual({ id: 'e1', status: 'sent', attempt: 1 })
-    expect(JSON.parse(events[0])).toMatchObject({ id: 'e1', status: 'sent', attempt: 1 })
-  })
-})
-
-describe('EmailJob.run — flaky 모드', () => {
-  test('1번째 시도는 throw(재시도 유발), 2번째 시도에 성공한다', async () => {
-    const { ctx, events } = makeCtx()
-    const job = new EmailJob()
-    const payload = { id: 'e2', to: 'a@b.c', mode: /** @type {const} */ ('flaky') }
-    await expect(job.run(payload, /** @type {any} */ (ctx))).rejects.toThrow(/transient failure on attempt 1/)
-    expect(JSON.parse(events[0])).toMatchObject({ status: 'retry', attempt: 1 })
-    // 같은 잡 재실행(재시도) → 시도 카운터 2 → 성공.
-    const r = await job.run(payload, /** @type {any} */ (ctx))
-    expect(r).toEqual({ id: 'e2', status: 'sent', attempt: 2 })
-    expect(JSON.parse(events[0])).toMatchObject({ status: 'sent', attempt: 2 })
-  })
-})
-
-describe('EmailJob.run — fail 모드', () => {
-  test('매 시도 throw 하고 failed 이벤트를 남긴다(재시도 소진 시 DLQ 로 라우팅됨)', async () => {
-    const { ctx, events } = makeCtx()
-    const job = new EmailJob()
-    const payload = { id: 'e3', to: 'a@b.c', mode: /** @type {const} */ ('fail') }
-    await expect(job.run(payload, /** @type {any} */ (ctx))).rejects.toThrow(/permanent failure on attempt 1/)
-    await expect(job.run(payload, /** @type {any} */ (ctx))).rejects.toThrow(/permanent failure on attempt 2/)
-    expect(JSON.parse(events[0])).toMatchObject({ status: 'failed', attempt: 2 })
-  })
-})
-
-describe('EmailJob 설정', () => {
-  test('subject/bus/concurrency/retries 가 정본 값과 일치한다', () => {
-    expect(EmailJob.subject).toBe('demo.email')
-    expect(EmailJob.bus).toBe('jobs')
-    expect(EmailJob.retries).toBe(2)
-    expect(EmailJob.concurrency).toBe(2)
-  })
-})

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

@@ -1,68 +0,0 @@
-// @ts-check
-/**
- * GuideService 단위 테스트 — 레포 루트 docs/guide 의 실제 마크다운을 읽어 목록·렌더를 검증한다.
- * 가이드 파일은 정적 자산이라 가짜를 두지 않고 실물을 읽는다(서버사이드 렌더 결과의 핵심 계약만 확인).
- */
-import { describe, test, expect } from 'vitest'
-import { GuideService } from '../../../apps/main/services/guide-service.js'
-import { MegaNotFoundError } from 'mega-framework/errors'
-
-/** ctx 최소 스텁 — GuideService 는 ctx.log.debug 만 쓴다. */
-function makeCtx() {
-  return /** @type {any} */ ({ log: { debug() {} } })
-}
-
-describe('GuideService — listGuides', () => {
-  test('docs/guide 의 모든 가이드를 slug·title 로 나열한다(번호순)', async () => {
-    const svc = new GuideService(makeCtx())
-    const guides = await svc.listGuides()
-    expect(guides.length).toBeGreaterThanOrEqual(8)
-    // 파일명 오름차순 = 가이드 번호순.
-    const slugs = guides.map((g) => g.slug)
-    expect(slugs).toEqual([...slugs].sort())
-    // 각 항목은 비어있지 않은 slug·title 을 가진다.
-    for (const g of guides) {
-      expect(g.slug).toMatch(/^[a-z0-9-]+$/)
-      expect(g.title.length).toBeGreaterThan(0)
-    }
-  })
-
-  test('title 은 파일의 첫 H1 텍스트다', async () => {
-    const svc = new GuideService(makeCtx())
-    const guides = await svc.listGuides()
-    const cli = guides.find((g) => g.slug === '01-cli')
-    expect(cli?.title).toBe('CLI 사용법')
-  })
-})
-
-describe('GuideService — renderGuide', () => {
-  test('마크다운을 HTML 로 렌더하고 코드블록을 highlight.js 로 하이라이트한다', async () => {
-    const svc = new GuideService(makeCtx())
-    const guide = await svc.renderGuide('01-cli')
-    expect(guide.slug).toBe('01-cli')
-    // 코드블록은 hljs 클래스 + 언어 클래스를 받는다(서버사이드 하이라이트). 01-cli 는 bash 예시가 있다.
-    expect(guide.html).toContain('<code class="hljs language-bash">')
-    // highlight.js 가 토큰을 span 으로 감쌌다.
-    expect(guide.html).toContain('hljs-')
-  })
-
-  test('헤딩에 목차 앵커용 id 를 단다(github-slugger 규칙)', async () => {
-    const svc = new GuideService(makeCtx())
-    const guide = await svc.renderGuide('01-cli')
-    // "## mega g / generate" → 슬러그 "mega-g--generate"(목차 링크 #mega-g--generate 와 일치).
-    expect(guide.html).toContain('id="mega-g--generate"')
-    // "## 설치 + 빠른 시작" → "설치--빠른-시작"(한글 보존).
-    expect(guide.html).toContain('id="설치--빠른-시작"')
-  })
-
-  test('존재하지 않는 slug 는 MegaNotFoundError 를 던진다', async () => {
-    const svc = new GuideService(makeCtx())
-    await expect(svc.renderGuide('does-not-exist')).rejects.toBeInstanceOf(MegaNotFoundError)
-  })
-
-  test('경로 조작 slug 는 형식 검증에서 막힌다(MegaNotFoundError)', async () => {
-    const svc = new GuideService(makeCtx())
-    await expect(svc.renderGuide('../../etc/passwd')).rejects.toBeInstanceOf(MegaNotFoundError)
-    await expect(svc.renderGuide('01-cli/../02-router-controller')).rejects.toBeInstanceOf(MegaNotFoundError)
-  })
-})

package/sample/crud/test/apps/main/hash-task.test.js

@@ -1,30 +0,0 @@
-// @ts-check
-/**
- * hash.task(sha256Loop) 단위 테스트 — 워커 task 함수가 결정적(deterministic)으로 SHA-256 을 N회 체인 해시하는지
- * 검증한다. 워커 경계(worker_threads) 없이 함수만 직접 호출해 로직을 본다.
- */
-import { describe, test, expect } from 'vitest'
-import { createHash } from 'node:crypto'
-import { sha256Loop } from '../../../apps/main/workers/hash.task.js'
-
-/** @param {string} input @param {number} rounds */
-function expected(input, rounds) {
-  let d = input
-  for (let i = 0; i < rounds; i++) d = createHash('sha256').update(d).digest('hex')
-  return d
-}
-
-describe('sha256Loop', () => {
-  test('rounds 회 체인 해시 결과가 결정적이다', async () => {
-    const r = await sha256Loop({ input: 'mega', rounds: 1 })
-    expect(r).toEqual({ digest: expected('mega', 1), rounds: 1 })
-    const r3 = await sha256Loop({ input: 'mega', rounds: 3 })
-    expect(r3.digest).toBe(expected('mega', 3))
-    expect(r3.rounds).toBe(3)
-  })
-
-  test('input 미지정 시 기본 입력(mega)을 쓴다', async () => {
-    const r = await sha256Loop({ rounds: 2 })
-    expect(r.digest).toBe(expected('mega', 2))
-  })
-})

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

@@ -1,88 +0,0 @@
-// @ts-check
-/**
- * JobsDemoService 단위 테스트 — events()/dlq() 읽기 로직을 가짜 redis/NATS 핸들로 검증한다. enqueue(실 NATS
- * publish)와 워커 소비·재시도·DLQ 라우팅은 통합 검증(E2E)이 커버한다.
- */
-import { describe, test, expect } from 'vitest'
-import { JobsDemoService } from '../../../apps/main/services/jobs-demo-service.js'
-import { EmailJob } from '../../../apps/main/jobs/email-job.js'
-
-/**
- * @param {{ events?: string[], jsm?: any }} [opts]
- */
-function makeCtx({ events = [], jsm } = {}) {
-  const cache = {
-    native: {
-      /** @param {string} _k @param {number} start @param {number} stop */
-      async lrange(_k, start, stop) {
-        return events.slice(start, stop + 1)
-      },
-    },
-  }
-  const bus = { native: { jetstreamManager: async () => jsm } }
-  const ctx = {
-    log: { debug() {} },
-    cache: (/** @type {string} */ a) => (a === 'demo' ? cache : null),
-    bus: (/** @type {string} */ a) => (a === 'jobs' ? bus : null),
-  }
-  return { ctx }
-}
-
-/** code 프로퍼티를 단 에러(JetStream 404 모사). @param {string} code */
-function apiError(code) {
-  const e = new Error(`api error ${code}`)
-  Object.assign(e, { code })
-  return e
-}
-
-describe('JobsDemoService.events', () => {
-  test('redis LIST 의 JSON 문자열들을 파싱해 돌려준다', async () => {
-    const raw = [JSON.stringify({ id: 'e1', status: 'sent', attempt: 1 })]
-    const { ctx } = makeCtx({ events: raw })
-    const svc = new JobsDemoService(/** @type {any} */ (ctx))
-    const out = await svc.events()
-    expect(out).toEqual([{ id: 'e1', status: 'sent', attempt: 1 }])
-  })
-})
-
-describe('JobsDemoService.dlq', () => {
-  test('DLQ 스트림 미존재(404) 시 빈 상태를 돌려준다', async () => {
-    const jsm = { streams: { info: async () => { throw apiError('404') } } }
-    const { ctx } = makeCtx({ jsm })
-    const svc = new JobsDemoService(/** @type {any} */ (ctx))
-    expect(await svc.dlq()).toEqual({ count: 0, latest: null })
-  })
-
-  test('메시지가 있으면 카운트 + 가장 최근 1건을 돌려준다', async () => {
-    const body = {
-      originalSubject: EmailJob.subject,
-      failedAt: '2026-06-07T00:00:00.000Z',
-      deliveryCount: 3,
-      error: { name: 'Error', message: 'boom' },
-      payload: { id: 'e3', mode: 'fail' },
-    }
-    const jsm = {
-      streams: {
-        info: async () => ({ state: { messages: 2 } }),
-        getMessage: async () => ({ json: () => body }),
-      },
-    }
-    const { ctx } = makeCtx({ jsm })
-    const svc = new JobsDemoService(/** @type {any} */ (ctx))
-    const out = await svc.dlq()
-    expect(out.count).toBe(2)
-    expect(out.latest).toEqual({
-      failedAt: body.failedAt,
-      deliveryCount: 3,
-      error: 'boom',
-      payload: { id: 'e3', mode: 'fail' },
-    })
-  })
-
-  test('info 가 404 가 아닌 에러면 전파한다(인프라 장애를 묻지 않음)', async () => {
-    const jsm = { streams: { info: async () => { throw apiError('503') } } }
-    const { ctx } = makeCtx({ jsm })
-    const svc = new JobsDemoService(/** @type {any} */ (ctx))
-    await expect(svc.dlq()).rejects.toThrow(/503/)
-  })
-})

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

@@ -1,85 +0,0 @@
-// @ts-check
-/**
- * LogsDemoService 단위 테스트 — 실제 logger emit(레벨 화이트리스트) + 안전 메타데이터만 redis 이력에 저장
- * (시크릿 제외)하는지 검증한다. MegaTracing.currentTraceIds 를 가짜로, redis native 를 가짜로 둔다.
- */
-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() } }
-})
-
-import { MegaTracing } from 'mega-framework'
-import { LogsDemoService } from '../../../apps/main/services/logs-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 log = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() }
-  const ctx = { log, requestId: 'req-1', cache: (/** @type {string} */ a) => (a === 'demo' ? { native } : null) }
-  return { ctx, lists, log }
-}
-
-beforeEach(() => {
-  vi.clearAllMocks()
-  vi.mocked(MegaTracing.currentTraceIds).mockReturnValue({ traceId: 'tr', spanId: 'sp' })
-})
-
-describe('LogsDemoService — emit', () => {
-  test('선택 레벨로 실제 logger 를 호출하고 안전 메타만 이력에 저장한다(시크릿 제외)', async () => {
-    const { ctx, lists, log } = makeCtx()
-    const svc = new LogsDemoService(/** @type {any} */ (ctx))
-    const r = await svc.emit('warn', '  hello  ')
-    expect(r).toMatchObject({ level: 'warn', message: 'hello', traceId: 'tr' })
-    expect(log.warn).toHaveBeenCalledTimes(1)
-    // logger payload 엔 시연용 시크릿이 들어가지만(콘솔 redact 시연), redis 이력엔 시크릿이 없어야 한다.
-    const stored = (lists.get(LogsDemoService.RECENT_KEY) ?? []).map((s) => JSON.parse(s))
-    expect(stored[0]).toMatchObject({ level: 'warn', message: 'hello', traceId: 'tr', reqId: 'req-1' })
-    expect(JSON.stringify(stored[0])).not.toContain('password')
-    expect(JSON.stringify(stored[0])).not.toContain('demo-token')
-  })
-
-  test('허용되지 않은 레벨은 info 로 폴백', async () => {
-    const { ctx, log } = makeCtx()
-    const svc = new LogsDemoService(/** @type {any} */ (ctx))
-    const r = await svc.emit('fatal', 'x')
-    expect(r.level).toBe('info')
-    expect(log.info).toHaveBeenCalledTimes(1)
-  })
-
-  test('빈 메시지는 기본 문구로 대체', async () => {
-    const { ctx } = makeCtx()
-    const svc = new LogsDemoService(/** @type {any} */ (ctx))
-    const r = await svc.emit('info', '   ')
-    expect(r.message.length).toBeGreaterThan(0)
-  })
-})
-
-describe('LogsDemoService — snapshot', () => {
-  test('최근 emit 메타 목록 + 레벨 화이트리스트를 돌려준다', async () => {
-    const { ctx } = makeCtx()
-    const svc = new LogsDemoService(/** @type {any} */ (ctx))
-    await svc.emit('info', 'a')
-    await svc.emit('error', 'b')
-    const snap = await svc.snapshot()
-    expect(snap.recent).toHaveLength(2)
-    expect(snap.recent[0]).toMatchObject({ message: 'b', level: 'error' })
-    expect(snap.levels).toEqual(['debug', 'info', 'warn', 'error'])
-  })
-})

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

@@ -1,90 +0,0 @@
-// @ts-check
-/**
- * MetricsDemoService 단위 테스트 — Prometheus exposition 텍스트 파서(parseLine/parse/sum)와 snapshot 요약을
- * 검증한다. snapshot 은 collectCluster() 를 가짜로 갈음해 redis·실 메트릭 없이 집계 로직만 본다.
- */
-import { describe, test, expect, vi } from 'vitest'
-
-vi.mock('mega-framework', async (importOriginal) => {
-  const actual = /** @type {any} */ (await importOriginal())
-  return { ...actual, collectCluster: vi.fn() }
-})
-
-import { collectCluster } from 'mega-framework'
-import { MetricsDemoService } from '../../../apps/main/services/metrics-demo-service.js'
-
-const SAMPLE = [
-  '# HELP mega_http_requests_total total',
-  '# TYPE mega_http_requests_total counter',
-  'mega_http_requests_total{method="GET",route="/",status_code="200",app="main"} 3',
-  'mega_http_requests_total{method="GET",route="/users",status_code="200",app="main"} 5',
-  'mega_http_requests_total{method="POST",route="/users",status_code="400",app="main"} 1',
-  'mega_http_requests_total{method="GET",route="/x",status_code="500",app="main"} 2',
-  'mega_jobs_total{queue="email",event="enqueued"} 4',
-  'mega_jobs_total{queue="email",event="processed"} 3',
-  'mega_jobs_total{queue="email",event="dlq"} 1',
-  'mega_ws_messages_total{type="message.send",ns="/ws/chat",app="main"} 7',
-  'mega_process_memory_bytes{kind="heapUsed"} 10485760',
-  'mega_process_memory_bytes{kind="rss"} 52428800',
-  'mega_process_uptime_seconds 123.5',
-  'mega_process_cpu_seconds_total{type="user"} 1.5',
-  'mega_process_cpu_seconds_total{type="system"} 0.5',
-].join('\n')
-
-function makeCtx() {
-  return { log: { debug() {} } }
-}
-
-describe('MetricsDemoService — parseLine', () => {
-  test('주석/빈 줄은 null, 라벨 있는/없는 샘플은 파싱된다', () => {
-    expect(MetricsDemoService.parseLine('# HELP x')).toBeNull()
-    expect(MetricsDemoService.parseLine('   ')).toBeNull()
-    expect(MetricsDemoService.parseLine('mega_x 0')).toEqual({ name: 'mega_x', labels: {}, value: 0 })
-    expect(MetricsDemoService.parseLine('mega_x{a="1",b="y"} 4.5')).toEqual({
-      name: 'mega_x',
-      labels: { a: '1', b: 'y' },
-      value: 4.5,
-    })
-  })
-
-  test('값이 숫자가 아니면 null', () => {
-    expect(MetricsDemoService.parseLine('mega_x abc')).toBeNull()
-  })
-})
-
-describe('MetricsDemoService — sum', () => {
-  test('패밀리 합산 + 라벨 필터', () => {
-    const samples = MetricsDemoService.parse(SAMPLE)
-    expect(MetricsDemoService.sum(samples, 'mega_http_requests_total')).toBe(11)
-    expect(MetricsDemoService.sum(samples, 'mega_jobs_total', (l) => l.event === 'enqueued')).toBe(4)
-    expect(MetricsDemoService.sum(samples, 'mega_process_cpu_seconds_total')).toBe(2)
-  })
-})
-
-describe('MetricsDemoService — snapshot', () => {
-  test('collect() 결과를 HTTP/잡/WS/process 요약으로 정리한다', async () => {
-    vi.mocked(collectCluster).mockResolvedValue(SAMPLE)
-    const svc = new MetricsDemoService(/** @type {any} */ (makeCtx()))
-    const snap = await svc.snapshot()
-
-    expect(snap.enabled).toBe(true)
-    expect(snap.http.total).toBe(11)
-    expect(snap.http.byClass).toEqual({ '2xx': 8, '3xx': 0, '4xx': 1, '5xx': 2 })
-    expect(snap.http.topRoutes[0]).toEqual({ route: '/users', count: 6 })
-    expect(snap.jobs).toEqual({ enqueued: 4, processed: 3, retried: 0, dlq: 1 })
-    expect(snap.ws.total).toBe(7)
-    expect(snap.ws.byType).toEqual([{ type: 'message.send', count: 7 }])
-    expect(snap.process.heapUsedMb).toBeCloseTo(10, 5)
-    expect(snap.process.rssMb).toBeCloseTo(50, 5)
-    expect(snap.process.uptimeSec).toBe(123.5)
-    expect(snap.process.cpuSec).toBe(2)
-  })
-
-  test('메트릭 OFF(collect 빈 문자열)면 enabled=false', async () => {
-    vi.mocked(collectCluster).mockResolvedValue('')
-    const svc = new MetricsDemoService(/** @type {any} */ (makeCtx()))
-    const snap = await svc.snapshot()
-    expect(snap.enabled).toBe(false)
-    expect(snap.http.total).toBe(0)
-  })
-})

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

@@ -1,68 +0,0 @@
-// @ts-check
-/**
- * NoteService 단위 테스트(ADR-157) — 모델(static)을 스파이로 갈음해 mongo 없이 비즈니스 로직(검증·404)을
- * 검증한다. 실 mongo CRUD 는 demo-flow.integration.test.js 가 커버한다.
- */
-import { describe, test, expect, vi, afterEach } from 'vitest'
-import { NoteService } from '../../../apps/main/services/note-service.js'
-import { Note } from '../../../apps/main/models/note.js'
-
-/** @returns {NoteService} */
-function makeService() {
-  return new NoteService(/** @type {any} */ ({ log: { debug() {} } }))
-}
-
-afterEach(() => vi.restoreAllMocks())
-
-describe('NoteService', () => {
-  test('list → Note.list 위임', async () => {
-    vi.spyOn(Note, 'list').mockResolvedValue([/** @type {any} */ ({ id: 'a', title: 't', body: 'b' })])
-    expect(await makeService().list()).toEqual([{ id: 'a', title: 't', body: 'b' }])
-  })
-
-  test('get — 존재하면 반환', async () => {
-    vi.spyOn(Note, 'findById').mockResolvedValue(/** @type {any} */ ({ id: 'x', title: 't' }))
-    expect(await makeService().get('x')).toEqual({ id: 'x', title: 't' })
-  })
-
-  test('get — 없으면 MegaNotFoundError(404)', async () => {
-    vi.spyOn(Note, 'findById').mockResolvedValue(null)
-    await expect(makeService().get('nope')).rejects.toMatchObject({ status: 404, code: 'note.not_found' })
-  })
-
-  test('create — 제목 누락 시 MegaValidationError(400)', async () => {
-    await expect(makeService().create({ title: '   ', body: 'b' })).rejects.toMatchObject({ status: 400, code: 'note.invalid' })
-  })
-
-  test('create — 제목 길이 초과 시 MegaValidationError(400)', async () => {
-    const long = 'x'.repeat(NoteService.MAX_TITLE + 1)
-    await expect(makeService().create({ title: long })).rejects.toMatchObject({ status: 400, code: 'note.invalid' })
-  })
-
-  test('create — 정상 생성(trim 후 위임)', async () => {
-    const spy = vi.spyOn(Note, 'create').mockResolvedValue(/** @type {any} */ ({ id: 'n1', title: 'memo', body: 'hi' }))
-    const r = await makeService().create({ title: ' memo ', body: ' hi ' })
-    expect(r).toMatchObject({ id: 'n1', title: 'memo' })
-    expect(spy).toHaveBeenCalledWith({ title: 'memo', body: 'hi' })
-  })
-
-  test('update — 없으면 MegaNotFoundError(404)', async () => {
-    vi.spyOn(Note, 'update').mockResolvedValue(null)
-    await expect(makeService().update('gone', { title: 't' })).rejects.toMatchObject({ status: 404, code: 'note.not_found' })
-  })
-
-  test('update — 정상 수정', async () => {
-    vi.spyOn(Note, 'update').mockResolvedValue(/** @type {any} */ ({ id: 'n1', title: 'new' }))
-    expect(await makeService().update('n1', { title: ' new ', body: '' })).toMatchObject({ id: 'n1', title: 'new' })
-  })
-
-  test('remove — 없으면 MegaNotFoundError(404)', async () => {
-    vi.spyOn(Note, 'remove').mockResolvedValue(false)
-    await expect(makeService().remove('gone')).rejects.toMatchObject({ status: 404, code: 'note.not_found' })
-  })
-
-  test('remove — 성공 시 { deleted: true }', async () => {
-    vi.spyOn(Note, 'remove').mockResolvedValue(true)
-    expect(await makeService().remove('n1')).toEqual({ deleted: true })
-  })
-})

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

@@ -1,121 +0,0 @@
-// @ts-check
-/**
- * PerfService 단위 테스트(ADR-174) — 통계 함수(percentile/summarize)의 정확성과, 인프라가 필요 없는
- * in-process 시나리오(http/json/crypto)의 실행·clamp·검증을 다룬다. 어댑터 왕복 시나리오(db/cache/session)는
- * 실 백엔드 의존이라 통합/수동 검증 몫이다(perf-service 는 ctx.db/cache/app 접근만 위임).
- */
-import { describe, test, expect } from 'vitest'
-import { PerfService, percentile, summarize, SCENARIO_LIMITS } from '../../../apps/main/services/perf-service.js'
-
-/** 로그만 있는 최소 ctx — in-process 시나리오는 db/cache/app 을 안 건드린다. */
-function makeCtx() {
-  return { log: { debug() {}, warn() {} } }
-}
-
-describe('percentile', () => {
-  test('nearest-rank — 정렬된 1..10 에서 표준 백분위', () => {
-    const sorted = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    expect(percentile(sorted, 50)).toBe(5)
-    expect(percentile(sorted, 90)).toBe(9)
-    expect(percentile(sorted, 95)).toBe(10)
-    expect(percentile(sorted, 99)).toBe(10)
-    expect(percentile(sorted, 100)).toBe(10)
-  })
-
-  test('단일 표본은 모든 백분위가 그 값', () => {
-    expect(percentile([42], 50)).toBe(42)
-    expect(percentile([42], 99)).toBe(42)
-  })
-
-  test('빈 표본은 0', () => {
-    expect(percentile([], 50)).toBe(0)
-  })
-})
-
-describe('summarize', () => {
-  test('avg/min/max/ok/fail 과 백분위를 정확히 계산', () => {
-    const samples = [10, 20, 30, 40, 50] // 미정렬 입력도 정렬해 처리
-    const s = summarize(samples, 100, 5)
-    expect(s.ok).toBe(5)
-    expect(s.fail).toBe(0)
-    expect(s.min).toBe(10)
-    expect(s.max).toBe(50)
-    expect(s.avg).toBe(30)
-    expect(s.p50).toBe(30)
-    expect(s.durationMs).toBe(100)
-    // rps = total(5) / wallSec(0.1) = 50
-    expect(s.rps).toBe(50)
-  })
-
-  test('성공 표본 < total 이면 fail 로 채워진다', () => {
-    const s = summarize([5, 5], 50, 4)
-    expect(s.ok).toBe(2)
-    expect(s.fail).toBe(2)
-  })
-
-  test('표본 0 이면 통계는 0, fail=total', () => {
-    const s = summarize([], 10, 3)
-    expect(s.ok).toBe(0)
-    expect(s.fail).toBe(3)
-    expect(s.avg).toBe(0)
-    expect(s.p99).toBe(0)
-  })
-})
-
-describe('PerfService.run — in-process 시나리오', () => {
-  test('http.echo — 전부 성공, 통계 필드 존재', async () => {
-    const svc = new PerfService(makeCtx())
-    const r = await svc.run({ scenario: 'http.echo', iterations: 50 })
-    expect(r.scenario).toBe('http.echo')
-    expect(r.iterations).toBe(50)
-    expect(r.ok).toBe(50)
-    expect(r.fail).toBe(0)
-    expect(r.rps).toBeGreaterThan(0)
-    expect(typeof r.p95).toBe('number')
-    expect(r.clamped).toBeUndefined()
-  })
-
-  test('http.jsonLarge — payloadSize 반영, 전부 성공', async () => {
-    const svc = new PerfService(makeCtx())
-    const r = await svc.run({ scenario: 'http.jsonLarge', iterations: 20, payloadSize: 2048 })
-    expect(r.payloadSize).toBe(2048)
-    expect(r.ok).toBe(20)
-    expect(r.fail).toBe(0)
-  })
-
-  test('crypto.aspRoundtrip — encrypt→decrypt 왕복 전부 성공', async () => {
-    const svc = new PerfService(makeCtx())
-    const r = await svc.run({ scenario: 'crypto.aspRoundtrip', iterations: 30, payloadSize: 128 })
-    expect(r.ok).toBe(30)
-    expect(r.fail).toBe(0)
-  })
-})
-
-describe('PerfService.run — clamp + 검증', () => {
-  test('crypto.hash — 동시성이 시나리오 상한(4)으로 clamp 되고 결과에 표시', async () => {
-    const svc = new PerfService(makeCtx())
-    // iterations 3 은 상한(500) 이내라 그대로, concurrency 8 은 상한(4)으로 줄어든다.
-    const r = await svc.run({ scenario: 'crypto.hash', iterations: 3, concurrency: 8 })
-    expect(r.iterations).toBe(3)
-    expect(r.concurrency).toBe(4)
-    expect(r.ok).toBe(3)
-    expect(r.clamped).toBeDefined()
-    expect(r.clamped.concurrency).toEqual({ requested: 8, applied: 4 })
-    expect(r.clamped.iterations).toBeUndefined()
-  })
-
-  test('crypto.hash — concurrency 미지정 시 시나리오 디폴트(1) 적용, clamp 없음', async () => {
-    const svc = new PerfService(makeCtx())
-    const r = await svc.run({ scenario: 'crypto.hash', iterations: 2 })
-    expect(r.concurrency).toBe(SCENARIO_LIMITS['crypto.hash'].defConc)
-    expect(r.concurrency).toBe(1)
-    expect(r.clamped).toBeUndefined()
-  })
-
-  test('미지원 시나리오는 MegaValidationError', async () => {
-    const svc = new PerfService(makeCtx())
-    await expect(svc.run({ scenario: 'bogus.scenario', iterations: 1 })).rejects.toMatchObject({
-      code: 'perf.unknown_scenario',
-    })
-  })
-})