opensoma 0.4.0 → 0.5.0

package/src/shared/utils/toz.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  assertDurationInRange,
+  buildBranchIdsParam,
+  buildStartTimeParam,
+  formatDuration,
+  formatPhone,
+  formatStartTime,
+  parseDurationKey,
+  parseEmail,
+  parsePhone,
+} from './toz'
+
+describe('formatDuration', () => {
+  it('formats hours+minutes as HHMM', () => {
+    expect(formatDuration(120)).toBe('0200')
+    expect(formatDuration(150)).toBe('0230')
+    expect(formatDuration(180)).toBe('0300')
+    expect(formatDuration(90)).toBe('0130')
+  })
+
+  it('throws on invalid input', () => {
+    expect(() => formatDuration(0)).toThrow()
+    expect(() => formatDuration(-30)).toThrow()
+    expect(() => formatDuration(1.5)).toThrow()
+  })
+})
+
+describe('parseDurationKey', () => {
+  it('parses HHMM keys to minutes', () => {
+    expect(parseDurationKey('0200')).toBe(120)
+    expect(parseDurationKey('0230')).toBe(150)
+    expect(parseDurationKey('1300')).toBe(780)
+  })
+
+  it('throws on invalid key', () => {
+    expect(() => parseDurationKey('0')).toThrow()
+    expect(() => parseDurationKey('abcd')).toThrow()
+    expect(() => parseDurationKey('20000')).toThrow()
+  })
+})
+
+describe('formatStartTime / buildStartTimeParam', () => {
+  it('splits HH:MM', () => {
+    expect(formatStartTime('10:00')).toEqual({ hour: '10', minute: '00' })
+    expect(formatStartTime('9:30')).toEqual({ hour: '09', minute: '30' })
+  })
+
+  it('joins to 4-digit param', () => {
+    expect(buildStartTimeParam('10:00')).toBe('1000')
+    expect(buildStartTimeParam('9:05')).toBe('0905')
+  })
+
+  it('rejects invalid time', () => {
+    expect(() => formatStartTime('1000')).toThrow()
+    expect(() => formatStartTime('25:00')).not.toThrow()
+  })
+})
+
+describe('buildBranchIdsParam', () => {
+  it('joins with trailing comma', () => {
+    expect(buildBranchIdsParam([27])).toBe('27,')
+    expect(buildBranchIdsParam([27, 145])).toBe('27,145,')
+    expect(buildBranchIdsParam([27, 145, 19, 20, 15, 139, 134, 30, 149])).toBe('27,145,19,20,15,139,134,30,149,')
+  })
+
+  it('rejects empty list', () => {
+    expect(() => buildBranchIdsParam([])).toThrow()
+  })
+})
+
+describe('parsePhone', () => {
+  it('parses standard 010-XXXX-YYYY', () => {
+    expect(parsePhone('010-1234-5678')).toEqual({ phone1: '010', phone2: '1234', phone3: '5678' })
+  })
+
+  it('parses 010 with no dashes', () => {
+    expect(parsePhone('01012345678')).toEqual({ phone1: '010', phone2: '1234', phone3: '5678' })
+  })
+
+  it('parses old 011-XXX-YYYY', () => {
+    expect(parsePhone('011-123-4567')).toEqual({ phone1: '011', phone2: '123', phone3: '4567' })
+  })
+
+  it('rejects unsupported prefix', () => {
+    expect(() => parsePhone('012-1234-5678')).toThrow()
+  })
+
+  it('rejects invalid length', () => {
+    expect(() => parsePhone('010-12-34')).toThrow()
+  })
+})
+
+describe('formatPhone', () => {
+  it('joins to dashed format', () => {
+    expect(formatPhone({ phone1: '010', phone2: '1234', phone3: '5678' })).toBe('010-1234-5678')
+  })
+})
+
+describe('parseEmail', () => {
+  it('uses select option for known domain', () => {
+    expect(parseEmail('user@gmail.com')).toEqual({ email1: 'user', email2: 'gmail.com', email3: '' })
+    expect(parseEmail('me@naver.com')).toEqual({ email1: 'me', email2: 'naver.com', email3: '' })
+  })
+
+  it('uses 직접입력 for custom domain', () => {
+    expect(parseEmail('user@customdomain.io')).toEqual({
+      email1: 'user',
+      email2: '직접입력',
+      email3: 'customdomain.io',
+    })
+  })
+
+  it('rejects malformed email', () => {
+    expect(() => parseEmail('userdomain.com')).toThrow()
+    expect(() => parseEmail('@domain.com')).toThrow()
+    expect(() => parseEmail('user@')).toThrow()
+  })
+})
+
+describe('assertDurationInRange', () => {
+  it('accepts 120-180', () => {
+    expect(() => assertDurationInRange(120)).not.toThrow()
+    expect(() => assertDurationInRange(150)).not.toThrow()
+    expect(() => assertDurationInRange(180)).not.toThrow()
+  })
+
+  it('rejects out-of-range', () => {
+    expect(() => assertDurationInRange(60)).toThrow()
+    expect(() => assertDurationInRange(210)).toThrow()
+  })
+})

package/src/shared/utils/toz.ts

@@ -0,0 +1,100 @@
+import {
+  TOZ_EMAIL_DOMAIN_CUSTOM,
+  TOZ_EMAIL_DOMAINS,
+  TOZ_MAX_DURATION_MINUTES,
+  TOZ_MIN_DURATION_MINUTES,
+  TOZ_PHONE_PREFIXES,
+} from '../../constants'
+
+export interface ParsedPhone {
+  phone1: string
+  phone2: string
+  phone3: string
+}
+
+export interface ParsedEmail {
+  email1: string
+  email2: string
+  email3: string
+}
+
+export function formatDuration(minutes: number): string {
+  if (!Number.isInteger(minutes) || minutes <= 0) {
+    throw new Error(`Invalid duration minutes: ${minutes}`)
+  }
+  const hh = Math.floor(minutes / 60)
+  const mm = minutes % 60
+  return `${String(hh).padStart(2, '0')}${String(mm).padStart(2, '0')}`
+}
+
+export function parseDurationKey(key: string): number {
+  if (!/^\d{4}$/.test(key)) {
+    throw new Error(`Invalid duration key: ${key}`)
+  }
+  const hh = Number.parseInt(key.slice(0, 2), 10)
+  const mm = Number.parseInt(key.slice(2, 4), 10)
+  return hh * 60 + mm
+}
+
+export function formatStartTime(time: string): { hour: string; minute: string } {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(time)
+  if (!match) {
+    throw new Error(`Invalid time: ${time} (expected HH:MM)`)
+  }
+  return { hour: match[1].padStart(2, '0'), minute: match[2] }
+}
+
+export function buildStartTimeParam(time: string): string {
+  const { hour, minute } = formatStartTime(time)
+  return `${hour}${minute}`
+}
+
+export function buildBranchIdsParam(branchIds: readonly number[]): string {
+  if (branchIds.length === 0) {
+    throw new Error('At least one branchId is required')
+  }
+  return `${branchIds.join(',')},`
+}
+
+export function parsePhone(phone: string): ParsedPhone {
+  const digits = phone.replace(/[^0-9]/g, '')
+  const prefix = TOZ_PHONE_PREFIXES.find((p) => digits.startsWith(p))
+  if (!prefix) {
+    throw new Error(`Unsupported phone prefix in: ${phone}`)
+  }
+  const rest = digits.slice(prefix.length)
+  if (rest.length !== 7 && rest.length !== 8) {
+    throw new Error(`Invalid phone number: ${phone}`)
+  }
+  const split = rest.length - 4
+  return {
+    phone1: prefix,
+    phone2: rest.slice(0, split),
+    phone3: rest.slice(split),
+  }
+}
+
+export function formatPhone(parsed: ParsedPhone): string {
+  return `${parsed.phone1}-${parsed.phone2}-${parsed.phone3}`
+}
+
+export function parseEmail(email: string): ParsedEmail {
+  const at = email.indexOf('@')
+  if (at <= 0 || at === email.length - 1) {
+    throw new Error(`Invalid email: ${email}`)
+  }
+  const local = email.slice(0, at)
+  const domain = email.slice(at + 1)
+  const known = (TOZ_EMAIL_DOMAINS as readonly string[]).includes(domain)
+  return known
+    ? { email1: local, email2: domain, email3: '' }
+    : { email1: local, email2: TOZ_EMAIL_DOMAIN_CUSTOM, email3: domain }
+}
+
+export function assertDurationInRange(minutes: number): void {
+  if (minutes < TOZ_MIN_DURATION_MINUTES || minutes > TOZ_MAX_DURATION_MINUTES) {
+    throw new Error(
+      `SW마에스트로 partnership requires duration between ${TOZ_MIN_DURATION_MINUTES / 60}h and ${TOZ_MAX_DURATION_MINUTES / 60}h (got ${minutes} minutes)`,
+    )
+  }
+}

package/src/token-extractor.test.ts

@@ -104,6 +104,25 @@ describe('TokenExtractor', () => {
     ])
   })
 
+  test('extracts plaintext cookie from opensoma.dev host', async () => {
+    const home = await makeTempDir()
+    const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
+    createCookieDbWithPlaintext(dbPath, 'opensoma-dev-session', 0, 'opensoma.dev')
+
+    const extractor = new TokenExtractor('linux', home)
+    expect(await extractor.extract()).toEqual({ sessionCookie: 'opensoma-dev-session' })
+  })
+
+  test('decrypts encrypted cookie from opensoma.dev host on Linux', async () => {
+    const home = await makeTempDir()
+    const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
+    const encrypted = encryptLinuxCookie('opensoma-dev-encrypted')
+    createCookieDbWithEncrypted(dbPath, encrypted, 'opensoma.dev')
+
+    const extractor = new TokenExtractor('linux', home)
+    expect(await extractor.extract()).toEqual({ sessionCookie: 'opensoma-dev-encrypted' })
+  })
+
   test('decrypts encrypted cookie on Linux', async () => {
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
@@ -148,26 +167,32 @@ function createCookieFile(filePath: string): void {
   writeFileSync(filePath, '')
 }
 
-function createCookieDbWithPlaintext(filePath: string, value: string, lastAccessUtc = 0): void {
+function createCookieDbWithPlaintext(
+  filePath: string,
+  value: string,
+  lastAccessUtc = 0,
+  hostKey = 'swmaestro.ai',
+): void {
   mkdirSync(dirname(filePath), { recursive: true })
   const db = new Database(filePath)
   db.run(
     'CREATE TABLE cookies (host_key TEXT, name TEXT, value TEXT, encrypted_value BLOB, creation_utc INTEGER, expires_utc INTEGER, is_httponly INTEGER, has_expires INTEGER, is_persistent INTEGER, priority INTEGER, samesite INTEGER, source_scheme INTEGER, is_secure INTEGER, path TEXT, last_access_utc INTEGER, last_update_utc INTEGER, source_port INTEGER, source_type INTEGER)',
   )
   db.run(
-    "INSERT INTO cookies (host_key, name, value, encrypted_value, last_access_utc) VALUES ('swmaestro.ai', 'JSESSIONID', ?, '', ?)",
-    [value, lastAccessUtc],
+    "INSERT INTO cookies (host_key, name, value, encrypted_value, last_access_utc) VALUES (?, 'JSESSIONID', ?, '', ?)",
+    [hostKey, value, lastAccessUtc],
   )
   db.close()
 }
 
-function createCookieDbWithEncrypted(filePath: string, encrypted: Buffer): void {
+function createCookieDbWithEncrypted(filePath: string, encrypted: Buffer, hostKey = 'swmaestro.ai'): void {
   mkdirSync(dirname(filePath), { recursive: true })
   const db = new Database(filePath)
   db.run(
     'CREATE TABLE cookies (host_key TEXT, name TEXT, value TEXT, encrypted_value BLOB, creation_utc INTEGER, expires_utc INTEGER, is_httponly INTEGER, has_expires INTEGER, is_persistent INTEGER, priority INTEGER, samesite INTEGER, source_scheme INTEGER, is_secure INTEGER, path TEXT, last_access_utc INTEGER, last_update_utc INTEGER, source_port INTEGER, source_type INTEGER)',
   )
-  db.run("INSERT INTO cookies (host_key, name, value, encrypted_value) VALUES ('swmaestro.ai', 'JSESSIONID', '', ?)", [
+  db.run("INSERT INTO cookies (host_key, name, value, encrypted_value) VALUES (?, 'JSESSIONID', '', ?)", [
+    hostKey,
     encrypted,
   ])
   db.close()

package/src/token-extractor.ts

@@ -8,7 +8,7 @@ import { basename, dirname, join } from 'node:path'
 const require = createRequire(import.meta.url)
 
 const COOKIE_QUERY =
-  "SELECT encrypted_value, last_access_utc, value FROM cookies WHERE host_key LIKE '%swmaestro.ai' AND name = 'JSESSIONID' ORDER BY last_access_utc DESC LIMIT 1"
+  "SELECT encrypted_value, last_access_utc, value FROM cookies WHERE (host_key LIKE '%swmaestro.ai' OR host_key LIKE '%opensoma.dev') AND name = 'JSESSIONID' ORDER BY last_access_utc DESC LIMIT 1"
 const CHROMIUM_SALT = 'saltysalt'
 const CHROMIUM_IV = Buffer.alloc(16, 0x20)
 const PROFILE_DIR_PATTERN = /^Profile\s+\d+$/
@@ -124,11 +124,36 @@ function queryCookieDb(dbPath: string): CookieRow | undefined {
   }
 }
 
+export type TokenExtractorOptions = {
+  platform?: NodeJS.Platform
+  homeDirectory?: string
+  debug?: boolean
+}
+
 export class TokenExtractor {
-  constructor(
-    private readonly platform: NodeJS.Platform = process.platform,
-    private readonly homeDirectory: string = homedir(),
-  ) {}
+  private readonly platform: NodeJS.Platform
+  private readonly homeDirectory: string
+  private readonly debugEnabled: boolean
+
+  constructor(options?: TokenExtractorOptions)
+  constructor(platform?: NodeJS.Platform, homeDirectory?: string, debug?: boolean)
+  constructor(platformOrOptions?: NodeJS.Platform | TokenExtractorOptions, homeDirectory?: string, debug?: boolean) {
+    if (typeof platformOrOptions === 'object' && platformOrOptions !== null) {
+      this.platform = platformOrOptions.platform ?? process.platform
+      this.homeDirectory = platformOrOptions.homeDirectory ?? homedir()
+      this.debugEnabled = platformOrOptions.debug ?? false
+    } else {
+      this.platform = platformOrOptions ?? process.platform
+      this.homeDirectory = homeDirectory ?? homedir()
+      this.debugEnabled = debug ?? false
+    }
+  }
+
+  private log(...args: unknown[]): void {
+    if (!this.debugEnabled) return
+    const message = args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')
+    process.stderr.write(`[extract] ${message}\n`)
+  }
 
   async extract(): Promise<{ sessionCookie: string } | null> {
     const candidates = await this.extractCandidates()
@@ -143,28 +168,35 @@ export class TokenExtractor {
 
   async extractCandidates(): Promise<ExtractedSessionCandidate[]> {
     const candidates = new Map<string, ExtractedSessionCandidate>()
+    const cookieDatabases = this.findCookieDatabases()
+    this.log(`Found ${cookieDatabases.length} cookie database(s)`)
 
-    for (const databasePath of this.findCookieDatabases()) {
+    for (const databasePath of cookieDatabases) {
       const browser = this.getBrowserByPath(databasePath)
       if (!browser) {
+        this.log(`Skipping ${databasePath} (no matching browser config)`)
         continue
       }
 
       const profile = basename(dirname(databasePath))
+      this.log(`Processing ${browser.name} / ${profile}`)
 
       const tempDirectory = mkdtempSync(join(tmpdir(), 'opensoma-cookie-db-'))
       const tempDatabasePath = join(tempDirectory, 'Cookies')
 
       try {
         copySqliteDatabase(databasePath, tempDatabasePath)
+        this.log(`  Copied DB to ${tempDatabasePath}`)
 
         const row = queryCookieDb(tempDatabasePath)
         if (!row) {
+          this.log('  No JSESSIONID cookie found')
           continue
         }
 
         const plaintextValue = normalizeCookieText(row.value)
         if (plaintextValue) {
+          this.log(`  Found plaintext cookie (${plaintextValue.length} chars)`)
           this.addCandidate(candidates, {
             browser: browser.name,
             lastAccessUtc: this.normalizeLastAccessUtc(row.last_access_utc),
@@ -176,29 +208,40 @@ export class TokenExtractor {
 
         const encryptedValue = normalizeCookieBytes(row.encrypted_value)
         if (!encryptedValue || encryptedValue.length === 0) {
+          this.log('  No plaintext or encrypted value')
           continue
         }
 
+        this.log(`  Decrypting encrypted cookie (${encryptedValue.length} bytes)...`)
         const decryptedValue = await this.decryptCookie(encryptedValue, browser.name)
         if (decryptedValue) {
+          this.log(`  Decrypted successfully (${decryptedValue.length} chars)`)
           this.addCandidate(candidates, {
             browser: browser.name,
             lastAccessUtc: this.normalizeLastAccessUtc(row.last_access_utc),
             profile,
             sessionCookie: decryptedValue,
           })
+        } else {
+          this.log('  Decryption returned empty value')
         }
-      } catch {
+      } catch (error) {
+        this.log(`  Error: ${error instanceof Error ? error.message : String(error)}`)
       } finally {
         rmSync(tempDirectory, { recursive: true, force: true })
       }
     }
 
+    this.log(`Total unique candidates: ${candidates.size}`)
     return [...candidates.values()].sort((left, right) => right.lastAccessUtc - left.lastAccessUtc)
   }
 
   findCookieDatabases(): string[] {
-    return BROWSERS.flatMap((browser) => this.findBrowserCookieDatabases(browser))
+    const results = BROWSERS.flatMap((browser) => this.findBrowserCookieDatabases(browser))
+    if (results.length === 0) {
+      this.log('No cookie databases found. Searched browsers:', BROWSERS.map((b) => b.name).join(', '))
+    }
+    return results
   }
 
   private async decryptCookie(encryptedValue: Buffer, browserName: string): Promise<string> {
@@ -207,14 +250,18 @@ export class TokenExtractor {
     }
 
     if (this.platform === 'linux') {
+      this.log('  Using Linux PBKDF2 decryption')
       return this.decryptChromiumValue(encryptedValue, pbkdf2Sync('peanuts', CHROMIUM_SALT, 1, 16, 'sha1'))
     }
 
     if (this.platform === 'darwin') {
+      this.log(`  Fetching macOS Keychain key for ${browserName}...`)
       const key = await this.getMacOSEncryptionKey(browserName)
+      this.log('  Keychain key obtained')
       return this.decryptChromiumValue(encryptedValue, key)
     }
 
+    this.log(`  Unsupported platform for decryption: ${this.platform}`)
     return ''
   }
 
@@ -224,11 +271,10 @@ export class TokenExtractor {
       throw new Error(`Unsupported browser: ${browserName}`)
     }
 
-    const password = execSync(
-      `security find-generic-password -s ${JSON.stringify(browser.keychainService)} -a ${JSON.stringify(browser.keychainAccount)} -w`,
-      { encoding: 'utf8' },
-    ).trimEnd()
+    const command = `security find-generic-password -s ${JSON.stringify(browser.keychainService)} -a ${JSON.stringify(browser.keychainAccount)} -w`
+    this.log(`  Keychain command: ${command}`)
 
+    const password = execSync(command, { encoding: 'utf8' }).trimEnd()
     return pbkdf2Sync(password, CHROMIUM_SALT, 1003, 16, 'sha1')
   }
 
@@ -266,14 +312,20 @@ export class TokenExtractor {
   private findBrowserCookieDatabases(browser: BrowserConfig): string[] {
     const browserRoot = this.getBrowserRoot(browser)
     if (!browserRoot || !existsSync(browserRoot)) {
+      this.log(`${browser.name}: not found at ${browserRoot ?? '(unsupported platform)'}`)
       return []
     }
 
-    return readdirSync(browserRoot, { withFileTypes: true })
+    const profiles = readdirSync(browserRoot, { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && this.isSupportedProfileDirectory(entry.name))
       .sort((left, right) => left.name.localeCompare(right.name))
+
+    const databases = profiles
       .map((entry) => join(browserRoot, entry.name, 'Cookies'))
       .filter((databasePath) => existsSync(databasePath))
+
+    this.log(`${browser.name}: ${profiles.length} profile(s), ${databases.length} cookie DB(s)`)
+    return databases
   }
 
   private getBrowserRoot(browser: BrowserConfig): string | null {

package/src/toz-formatters.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, it } from 'bun:test'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import {
+  isReservationConfirmSuccess,
+  parseBookingPageBranches,
+  parseBookingPageMeetings,
+  parseMypageReservations,
+  parseTozBoothes,
+  parseTozDurations,
+  parseTozReserved,
+} from './toz-formatters'
+
+const FIXTURES_DIR = join(__dirname, '__fixtures__', 'toz')
+
+function readFixture(name: string): string {
+  return readFileSync(join(FIXTURES_DIR, name), 'utf8')
+}
+
+function readJsonFixture<T>(name: string): T {
+  return JSON.parse(readFixture(name)) as T
+}
+
+describe('parseBookingPageBranches', () => {
+  it('extracts all 9 SW마에스트로 partner branches', () => {
+    const html = readFixture('toz_booking.html')
+    const branches = parseBookingPageBranches(html)
+
+    expect(branches).toEqual([
+      { id: 27, name: '강남토즈타워점' },
+      { id: 145, name: '강남컨퍼런스센터' },
+      { id: 19, name: '양재점' },
+      { id: 20, name: '건대점' },
+      { id: 15, name: '선릉점' },
+      { id: 139, name: '마이스 역삼센터' },
+      { id: 134, name: '마이스 광화문센터' },
+      { id: 30, name: '신촌비즈센터' },
+      { id: 149, name: '홍대점' },
+    ])
+  })
+})
+
+describe('parseBookingPageMeetings', () => {
+  it('extracts meeting options excluding placeholder and 새모임', () => {
+    const html = readFixture('toz_booking.html')
+    const meetings = parseBookingPageMeetings(html)
+
+    expect(meetings.length).toBeGreaterThan(50)
+    expect(meetings[0]).toEqual({ id: 2305094, name: '멘토특강_김현동 님' })
+    expect(meetings.find((m) => m.id === 2322942)).toEqual({
+      id: 2322942,
+      name: '자유멘토링_SW마에스트로',
+    })
+
+    expect(meetings.find((m) => m.name === '[새 모임]')).toBeUndefined()
+    for (const meeting of meetings) {
+      expect(Number.isInteger(meeting.id)).toBe(true)
+      expect(meeting.id).toBeGreaterThan(0)
+    }
+  })
+})
+
+describe('parseTozDurations', () => {
+  it('parses duration JSON with computed minutes', () => {
+    const json = readJsonFixture('toz_duration.json')
+    const durations = parseTozDurations(json)
+
+    expect(durations[0]).toEqual({ key: '0200', value: '2시간', minutes: 120 })
+    expect(durations[1]).toEqual({ key: '0230', value: '2시간 30분', minutes: 150 })
+    expect(durations[2]).toEqual({ key: '0300', value: '3시간', minutes: 180 })
+  })
+
+  it('returns [] for non-array', () => {
+    expect(parseTozDurations(null)).toEqual([])
+    expect(parseTozDurations({})).toEqual([])
+  })
+})
+
+describe('parseTozBoothes', () => {
+  it('parses booth JSON array', () => {
+    const json = readJsonFixture('toz_boothes.json')
+    const boothes = parseTozBoothes(json)
+
+    expect(boothes).toHaveLength(3)
+    expect(boothes[0]).toEqual({
+      id: 740,
+      name: '304 _ A',
+      branchName: '토즈타워점',
+      branchTel: '02-3454-0116',
+      minUseUserCount: 1,
+      enableMaxUserCount: 2,
+      boothGroupName: '2인부스 A타입',
+      boothGroupUrl: 'https://moim.toz.co.kr/branchDetail?branch_id=28&url=&path=',
+      boothMemoForUser: '15,000원(기본2시간)  / 기업, 학생할인 적용',
+      isLargeBooth: false,
+    })
+  })
+
+  it('throws on non-SUCCESS error response', () => {
+    const error = [{ resultMsg: '예약 가능한 부스가 없습니다.' }]
+    expect(() => parseTozBoothes(error)).toThrow('예약 가능한 부스가 없습니다.')
+  })
+
+  it('returns [] for empty', () => {
+    expect(parseTozBoothes([])).toEqual([])
+    expect(parseTozBoothes(null)).toEqual([])
+  })
+})
+
+describe('parseTozReserved', () => {
+  it('parses successful booth reservation response', () => {
+    const reserved = parseTozReserved({
+      result: 'SUCCESS',
+      resultMsg: 'abc-123',
+      branchName: '토즈타워점',
+      branchTel: '02-3454-0116',
+      boothGroupName: '2인부스 A타입',
+      boothIsLarge: false,
+      entitys: [],
+    })
+
+    expect(reserved).toEqual({
+      reservationId: 'abc-123',
+      branchName: '토즈타워점',
+      branchTel: '02-3454-0116',
+      boothGroupName: '2인부스 A타입',
+      isLargeBooth: false,
+    })
+  })
+
+  it('throws on failure response', () => {
+    expect(() => parseTozReserved({ result: 'FAIL', resultMsg: '이미 예약된 부스입니다.' })).toThrow(
+      '이미 예약된 부스입니다.',
+    )
+  })
+})
+
+describe('isReservationConfirmSuccess', () => {
+  it('detects standard success', () => {
+    expect(isReservationConfirmSuccess('예약 되었습니다.')).toBe(true)
+  })
+
+  it('detects large-booth success', () => {
+    expect(isReservationConfirmSuccess('대형부스 예약 신청되었습니다. 지점에서 확인 전화를 드릴 예정입니다.')).toBe(
+      true,
+    )
+  })
+
+  it('rejects error messages', () => {
+    expect(isReservationConfirmSuccess('인증번호가 올바르지 않습니다.')).toBe(false)
+  })
+})
+
+describe('parseMypageReservations', () => {
+  it('returns empty array when no reservations', () => {
+    const html = readFixture('toz_mypage_response.html')
+    expect(parseMypageReservations(html)).toEqual([])
+  })
+
+  it('parses synthetic reservation row', () => {
+    const html = `
+      <html><body>
+        <table class="reservation"><thead><tr><th>NO</th></tr></thead><tbody>
+          <tr><td colspan="7">예약 요청 정보가 없습니다.</td></tr>
+        </tbody></table>
+        <table class="reservation"><thead></thead><tbody>
+          <tr>
+            <td>1</td>
+            <td>자유멘토링_홍길동</td>
+            <td>2026-04-21</td>
+            <td>14:00 ~ 16:00</td>
+            <td>토즈타워점</td>
+            <td>304 _ A</td>
+            <td>2026-04-17 18:45</td>
+            <td>예약완료 <a href="javascript:destroyReservation(987654)">취소</a></td>
+          </tr>
+        </tbody></table>
+      </body></html>
+    `
+
+    expect(parseMypageReservations(html)).toEqual([
+      {
+        no: 1,
+        reservationId: 987654,
+        meetingName: '자유멘토링_홍길동',
+        date: '2026-04-21',
+        startTime: '14:00',
+        endTime: '16:00',
+        branchName: '토즈타워점',
+        boothName: '304 _ A',
+        reservedAt: '2026-04-17 18:45',
+        status: '예약완료 취소',
+      },
+    ])
+  })
+})