opensoma 0.5.0 → 0.5.1

package/src/shared/utils/mentoring-params.test.ts

@@ -1,44 +1,44 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 
 import { MENU_NO, REPORT_CD } from '../../constants'
 import { buildMentoringListParams, parseSearchQuery } from './mentoring-params'
 
 describe('parseSearchQuery', () => {
-  test('plain text defaults to title', () => {
+  it('defaults plain text to a title search', () => {
     expect(parseSearchQuery('OpenCode')).toEqual({ field: 'title', value: 'OpenCode' })
   })
 
-  test('title: prefix', () => {
+  it('parses the "title:" prefix as a title search', () => {
     expect(parseSearchQuery('title:OpenCode')).toEqual({ field: 'title', value: 'OpenCode' })
   })
 
-  test('author: prefix', () => {
+  it('parses the "author:" prefix as an author search', () => {
     expect(parseSearchQuery('author:전수열')).toEqual({ field: 'author', value: '전수열' })
   })
 
-  test('author:@me sets me flag', () => {
+  it('sets the "me" flag when parsing "author:@me"', () => {
     expect(parseSearchQuery('author:@me')).toEqual({ field: 'author', value: '@me', me: true })
   })
 
-  test('content: prefix', () => {
+  it('parses the "content:" prefix as a content search', () => {
     expect(parseSearchQuery('content:하네스')).toEqual({ field: 'content', value: '하네스' })
   })
 
-  test('unknown prefix treated as plain title search', () => {
+  it('treats an unknown prefix as a plain title search', () => {
     expect(parseSearchQuery('foo:bar')).toEqual({ field: 'title', value: 'foo:bar' })
   })
 
-  test('value with colons preserves everything after first colon', () => {
+  it('preserves everything after the first colon when the value contains colons', () => {
     expect(parseSearchQuery('title:foo:bar')).toEqual({ field: 'title', value: 'foo:bar' })
   })
 })
 
 describe('buildMentoringListParams', () => {
-  test('no options returns only menuNo', () => {
+  it('returns only menuNo when no options are passed', () => {
     expect(buildMentoringListParams()).toEqual({ menuNo: MENU_NO.MENTORING })
   })
 
-  test('status maps open to A, closed to C', () => {
+  it('maps status open to "A" and closed to "C"', () => {
     expect(buildMentoringListParams({ status: 'open' })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchStatMentolec: 'A',
@@ -49,7 +49,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('type maps public and lecture to report codes', () => {
+  it('maps type public and lecture to their report codes', () => {
     expect(buildMentoringListParams({ type: 'public' })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchGubunMentolec: REPORT_CD.PUBLIC_MENTORING,
@@ -60,7 +60,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('title search sets searchCnd=1', () => {
+  it('sets searchCnd=1 for a title search', () => {
     expect(buildMentoringListParams({ search: { field: 'title', value: 'OpenCode' } })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchCnd: '1',
@@ -68,7 +68,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('author search sets searchCnd=2', () => {
+  it('sets searchCnd=2 for an author search', () => {
     expect(buildMentoringListParams({ search: { field: 'author', value: '전수열' } })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchCnd: '2',
@@ -76,7 +76,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('author:@me with user sets searchId and userNm', () => {
+  it('sets searchId and searchWrd from the current user when "author:@me" is used', () => {
     expect(
       buildMentoringListParams({
         search: { field: 'author', value: '@me', me: true },
@@ -90,7 +90,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('search composes with status and type', () => {
+  it('composes search with status and type filters', () => {
     expect(
       buildMentoringListParams({
         status: 'open',
@@ -108,7 +108,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('page sets pageIndex', () => {
+  it('sets pageIndex from the page option', () => {
     expect(buildMentoringListParams({ page: 3 })).toEqual({
       menuNo: MENU_NO.MENTORING,
       pageIndex: '3',

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

@@ -1,9 +1,9 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 
-import { resolveVenue } from './swmaestro'
+import { buildRoomReservationPayload, resolveVenue } from './swmaestro'
 
 describe('resolveVenue', () => {
-  test('adds 토즈- prefix to bare toz location names', () => {
+  it('prepends "토즈-" to bare TOZ location names', () => {
     expect(resolveVenue('광화문점')).toBe('토즈-광화문점')
     expect(resolveVenue('양재점')).toBe('토즈-양재점')
     expect(resolveVenue('강남컨퍼런스센터점')).toBe('토즈-강남컨퍼런스센터점')
@@ -14,17 +14,17 @@ describe('resolveVenue', () => {
     expect(resolveVenue('홍대점')).toBe('토즈-홍대점')
   })
 
-  test('passes through already-prefixed toz locations', () => {
+  it('passes through TOZ locations that already have the prefix', () => {
     expect(resolveVenue('토즈-광화문점')).toBe('토즈-광화문점')
     expect(resolveVenue('토즈-강남역토즈타워점')).toBe('토즈-강남역토즈타워점')
   })
 
-  test('resolves 신촌비즈니스센터점 to 연수센터-7', () => {
+  it('resolves "신촌비즈니스센터점" to "연수센터-7"', () => {
     expect(resolveVenue('신촌비즈니스센터점')).toBe('연수센터-7')
     expect(resolveVenue('토즈-신촌비즈니스센터점')).toBe('연수센터-7')
   })
 
-  test('passes through non-toz venues unchanged', () => {
+  it('passes through non-TOZ venues unchanged', () => {
     expect(resolveVenue('온라인(Webex)')).toBe('온라인(Webex)')
     expect(resolveVenue('스페이스 A1')).toBe('스페이스 A1')
     expect(resolveVenue('스페이스 M1')).toBe('스페이스 M1')
@@ -33,12 +33,91 @@ describe('resolveVenue', () => {
     expect(resolveVenue('(엑스퍼트) 외부_카페')).toBe('(엑스퍼트) 외부_카페')
   })
 
-  test('trims whitespace from input', () => {
+  it('trims surrounding whitespace from the input', () => {
     expect(resolveVenue('  강남역토즈타워점  ')).toBe('토즈-강남역토즈타워점')
     expect(resolveVenue(' 스페이스 A1 ')).toBe('스페이스 A1')
   })
 
-  test('passes through unknown venues unchanged', () => {
+  it('passes through unknown venues unchanged', () => {
     expect(resolveVenue('기타 장소')).toBe('기타 장소')
   })
 })
+
+describe('buildRoomReservationPayload', () => {
+  it('sets rentEndde to the last selected slot so the server reserves only the chosen slots', () => {
+    const payload = buildRoomReservationPayload({
+      roomId: 17,
+      date: '2026-04-20',
+      slots: ['13:00', '13:30'],
+      title: '회의',
+    })
+
+    expect(payload.rentBgnde).toBe('2026-04-20 13:00:00')
+    expect(payload.rentEndde).toBe('2026-04-20 13:30:00')
+    expect(payload['time[0]']).toBe('13:00')
+    expect(payload['time[1]']).toBe('13:30')
+    expect(payload['time[2]']).toBeUndefined()
+    expect(payload['chkData_1']).toBe('2026-04-20|13:00|17')
+    expect(payload['chkData_2']).toBe('2026-04-20|13:30|17')
+    expect(payload['chkData_3']).toBeUndefined()
+  })
+
+  it('handles a single-slot reservation', () => {
+    const payload = buildRoomReservationPayload({
+      roomId: 17,
+      date: '2026-04-20',
+      slots: ['13:00'],
+      title: '회의',
+    })
+
+    expect(payload.rentBgnde).toBe('2026-04-20 13:00:00')
+    expect(payload.rentEndde).toBe('2026-04-20 13:00:00')
+    expect(payload['time[0]']).toBe('13:00')
+    expect(payload['time[1]']).toBeUndefined()
+  })
+
+  it('handles a reservation ending at the last available slot', () => {
+    const payload = buildRoomReservationPayload({
+      roomId: 17,
+      date: '2026-04-20',
+      slots: ['23:00', '23:30'],
+      title: '회의',
+    })
+
+    expect(payload.rentBgnde).toBe('2026-04-20 23:00:00')
+    expect(payload.rentEndde).toBe('2026-04-20 23:30:00')
+  })
+
+  it('rejects non-consecutive slots', () => {
+    expect(() =>
+      buildRoomReservationPayload({
+        roomId: 17,
+        date: '2026-04-20',
+        slots: ['13:00', '14:00'],
+        title: '회의',
+      }),
+    ).toThrow('Time slots must be consecutive')
+  })
+
+  it('rejects invalid time slots', () => {
+    expect(() =>
+      buildRoomReservationPayload({
+        roomId: 17,
+        date: '2026-04-20',
+        slots: ['25:00'],
+        title: '회의',
+      }),
+    ).toThrow('Invalid time slot')
+  })
+
+  it('rejects empty slot lists', () => {
+    expect(() =>
+      buildRoomReservationPayload({
+        roomId: 17,
+        date: '2026-04-20',
+        slots: [],
+        title: '회의',
+      }),
+    ).toThrow('At least one time slot is required')
+  })
+})

package/src/shared/utils/swmaestro.ts

@@ -142,17 +142,12 @@ export function buildRoomReservationPayload(params: {
 
   const firstSlot = params.slots[0]
   const lastSlot = params.slots[params.slots.length - 1]
-  const endSlot = TIME_SLOTS[TIME_SLOTS.indexOf(lastSlot) + 1]
-
-  if (!endSlot) {
-    throw new Error('Reservation end time is out of range')
-  }
 
   const payload: Record<string, string> = {
     menuNo: MENU_NO.ROOM,
     itemId: String(params.roomId),
     rentBgnde: `${params.date} ${firstSlot}:00`,
-    rentEndde: `${params.date} ${endSlot}:00`,
+    rentEndde: `${params.date} ${lastSlot}:00`,
     title: params.title,
     rentDt: params.date,
     rentNum: String(params.attendees ?? 1),

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

@@ -52,9 +52,12 @@ describe('formatStartTime / buildStartTimeParam', () => {
     expect(buildStartTimeParam('9:05')).toBe('0905')
   })
 
-  it('rejects invalid time', () => {
+  it('rejects time without colon separator', () => {
     expect(() => formatStartTime('1000')).toThrow()
-    expect(() => formatStartTime('25:00')).not.toThrow()
+  })
+
+  it('accepts out-of-range hours because the format matches', () => {
+    expect(formatStartTime('25:00')).toEqual({ hour: '25', minute: '00' })
   })
 })
 
@@ -120,13 +123,15 @@ describe('parseEmail', () => {
 })
 
 describe('assertDurationInRange', () => {
-  it('accepts 120-180', () => {
-    expect(() => assertDurationInRange(120)).not.toThrow()
-    expect(() => assertDurationInRange(150)).not.toThrow()
-    expect(() => assertDurationInRange(180)).not.toThrow()
+  it('accepts boundary and interior values', () => {
+    expect(assertDurationInRange(120)).toBeUndefined()
+    expect(assertDurationInRange(150)).toBeUndefined()
+    expect(assertDurationInRange(180)).toBeUndefined()
   })
 
-  it('rejects out-of-range', () => {
+  it('rejects values just outside the boundary', () => {
+    expect(() => assertDurationInRange(119)).toThrow()
+    expect(() => assertDurationInRange(181)).toThrow()
     expect(() => assertDurationInRange(60)).toThrow()
     expect(() => assertDurationInRange(210)).toThrow()
   })

package/src/token-extractor.test.ts

@@ -1,5 +1,5 @@
 import { Database } from 'bun:sqlite'
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, describe, expect, it } from 'bun:test'
 import { execSync } from 'node:child_process'
 import { createCipheriv, pbkdf2Sync } from 'node:crypto'
 import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
@@ -22,7 +22,7 @@ afterEach(() => {
 })
 
 describe('TokenExtractor', () => {
-  test('finds cookie databases for all browsers on macOS', async () => {
+  it('finds cookie databases for every supported browser on macOS', async () => {
     const home = await makeTempDir()
 
     for (const browser of BROWSERS) {
@@ -38,7 +38,7 @@ describe('TokenExtractor', () => {
     }
   })
 
-  test('finds cookie databases for all browsers on Linux', async () => {
+  it('finds cookie databases for every supported browser on Linux', async () => {
     const home = await makeTempDir()
 
     for (const browser of BROWSERS) {
@@ -51,12 +51,12 @@ describe('TokenExtractor', () => {
     expect(paths).toHaveLength(BROWSERS.length)
   })
 
-  test('returns null when no cookie databases exist', async () => {
+  it('returns null when no cookie databases exist', async () => {
     const extractor = new TokenExtractor('linux', await makeTempDir())
     expect(await extractor.extract()).toBeNull()
   })
 
-  test('extracts plaintext cookie value', async () => {
+  it('extracts a plaintext cookie value', async () => {
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
     createCookieDbWithPlaintext(dbPath, 'my-session-id')
@@ -65,7 +65,7 @@ describe('TokenExtractor', () => {
     expect(await extractor.extract()).toEqual({ sessionCookie: 'my-session-id' })
   })
 
-  test('finds cookie databases across numbered browser profiles', async () => {
+  it('finds cookie databases across numbered browser profiles', async () => {
     const home = await makeTempDir()
     createCookieFile(join(home, '.config', 'google-chrome', 'Default', 'Cookies'))
     createCookieFile(join(home, '.config', 'google-chrome', 'Profile 1', 'Cookies'))
@@ -80,7 +80,7 @@ describe('TokenExtractor', () => {
     ])
   })
 
-  test('extractCandidates keeps the newest unique cookie across profiles', async () => {
+  it('keeps the newest unique cookie across profiles when collecting candidates', async () => {
     const home = await makeTempDir()
     createCookieDbWithPlaintext(join(home, '.config', 'google-chrome', 'Default', 'Cookies'), 'stale-session', 10)
     createCookieDbWithPlaintext(join(home, '.config', 'google-chrome', 'Profile 1', 'Cookies'), 'valid-session', 20)
@@ -104,7 +104,7 @@ describe('TokenExtractor', () => {
     ])
   })
 
-  test('extracts plaintext cookie from opensoma.dev host', async () => {
+  it('extracts a plaintext cookie from the 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')
@@ -113,7 +113,7 @@ describe('TokenExtractor', () => {
     expect(await extractor.extract()).toEqual({ sessionCookie: 'opensoma-dev-session' })
   })
 
-  test('decrypts encrypted cookie from opensoma.dev host on Linux', async () => {
+  it('decrypts an encrypted cookie from the 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')
@@ -123,7 +123,7 @@ describe('TokenExtractor', () => {
     expect(await extractor.extract()).toEqual({ sessionCookie: 'opensoma-dev-encrypted' })
   })
 
-  test('decrypts encrypted cookie on Linux', async () => {
+  it('decrypts an encrypted cookie on Linux', async () => {
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
     const encrypted = encryptLinuxCookie('decrypted-session')
@@ -133,7 +133,7 @@ describe('TokenExtractor', () => {
     expect(await extractor.extract()).toEqual({ sessionCookie: 'decrypted-session' })
   })
 
-  test('extracts plaintext cookie under Node.js (compiled ESM)', async () => {
+  it('extracts a plaintext cookie when running under Node.js (compiled ESM)', async () => {
     execSync('bun run build', { cwd: join(import.meta.dir, '..'), stdio: 'pipe' })
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
@@ -144,7 +144,7 @@ describe('TokenExtractor', () => {
     expect(JSON.parse(result.trim())).toEqual({ sessionCookie: 'node-test-session' })
   })
 
-  test('extracts encrypted cookie under Node.js (compiled ESM)', async () => {
+  it('extracts an encrypted cookie when running under Node.js (compiled ESM)', async () => {
     execSync('bun run build', { cwd: join(import.meta.dir, '..'), stdio: 'pipe' })
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')

package/src/toz-http.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, mock, test } from 'bun:test'
+import { afterEach, describe, expect, it, mock } from 'bun:test'
 
 import { TOZ_BASE_URL } from './constants'
 import { TozHttp } from './toz-http'
@@ -11,7 +11,7 @@ afterEach(() => {
 })
 
 describe('TozHttp', () => {
-  test('bootstrap GETs index.htm to seed JSESSIONID', async () => {
+  it('seeds JSESSIONID by GETting index.htm during bootstrap', async () => {
     const fetchMock = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
       expect(String(input)).toBe(`${TOZ_BASE_URL}/index.htm`)
       expect(init?.method).toBe('GET')
@@ -26,7 +26,7 @@ describe('TozHttp', () => {
     expect(fetchMock).toHaveBeenCalledTimes(1)
   })
 
-  test('bootstrap is no-op when JSESSIONID already set', async () => {
+  it('skips bootstrap when JSESSIONID is already set', async () => {
     const fetchMock = mock(async () => createResponse('ok'))
     globalThis.fetch = fetchMock as typeof fetch
 
@@ -37,7 +37,7 @@ describe('TozHttp', () => {
     expect(http.getSessionCookie()).toBe('EXISTING')
   })
 
-  test('post sends URL-encoded body with required headers and cookie', async () => {
+  it('sends URL-encoded POST bodies with the required headers and cookie', async () => {
     const fetchMock = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
       expect(String(input)).toBe(`${TOZ_BASE_URL}/ajaxGetEnableBoothes.htm`)
       expect(init?.method).toBe('POST')
@@ -65,7 +65,7 @@ describe('TozHttp', () => {
     expect(text).toBe('[]')
   })
 
-  test('postJson parses JSON response', async () => {
+  it('parses the JSON body returned by postJson', async () => {
     globalThis.fetch = mock(async () => createResponse('{"result":"SUCCESS","resultMsg":"abc"}')) as typeof fetch
 
     const http = new TozHttp({ sessionCookie: 'ABC' })
@@ -74,25 +74,25 @@ describe('TozHttp', () => {
     expect(json).toEqual({ result: 'SUCCESS', resultMsg: 'abc' })
   })
 
-  test('postText trims plain-text response', async () => {
+  it('trims the plain-text body returned by postText', async () => {
     globalThis.fetch = mock(async () => createResponse('SUCCESS\n')) as typeof fetch
 
     const http = new TozHttp({ sessionCookie: 'ABC' })
     expect(await http.postText('/ajaxHpVerify.htm', {})).toBe('SUCCESS')
   })
 
-  test('strips JSESSIONID= prefix when constructed with full cookie string', async () => {
+  it('strips the "JSESSIONID=" prefix when constructed with a full cookie string', async () => {
     const http = new TozHttp({ sessionCookie: 'JSESSIONID=XYZ789' })
     expect(http.getSessionCookie()).toBe('XYZ789')
     expect(http.getCookies()).toEqual({ JSESSIONID: 'XYZ789' })
   })
 
-  test('constructor with cookies map preserves all cookies', async () => {
+  it('preserves every cookie when constructed with a cookies map', async () => {
     const http = new TozHttp({ cookies: { JSESSIONID: 'A', other: 'B' } })
     expect(http.getCookies()).toEqual({ JSESSIONID: 'A', other: 'B' })
   })
 
-  test('throws on non-2xx response', async () => {
+  it('throws on a non-2xx response', async () => {
     globalThis.fetch = mock(async () =>
       createResponse('Server Error', [], 'text/html', { status: 500 }),
     ) as typeof fetch
@@ -101,7 +101,7 @@ describe('TozHttp', () => {
     await expect(http.get('/index.htm')).rejects.toThrow(/HTTP 500/)
   })
 
-  test('refuses to follow cross-origin redirects (no cookie leak)', async () => {
+  it('refuses to follow cross-origin redirects to prevent cookie leaks', async () => {
     globalThis.fetch = mock(async (input: RequestInfo | URL) => {
       const url = String(input)
       if (url.endsWith('/index.htm')) {
@@ -114,7 +114,7 @@ describe('TozHttp', () => {
     await expect(http.get('/index.htm')).rejects.toThrow(/cross-origin redirect/)
   })
 
-  test('follows same-origin redirects normally', async () => {
+  it('follows same-origin redirects normally', async () => {
     let hit = 0
     globalThis.fetch = mock(async (input: RequestInfo | URL) => {
       const url = String(input)