opensoma 0.5.0 → 0.6.0

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

@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'bun:test'
+
+import { MENU_NO } from '../../constants'
+import { buildTeamListParams, parseTeamSearchQuery } from './team-params'
+
+describe('parseTeamSearchQuery', () => {
+  it('defaults plain text to an all-fields search', () => {
+    expect(parseTeamSearchQuery('전수열')).toEqual({ field: 'all', value: '전수열' })
+  })
+
+  it('parses the "team:" prefix as a team-name search', () => {
+    expect(parseTeamSearchQuery('team:오픈소마')).toEqual({ field: 'team', value: '오픈소마' })
+  })
+
+  it('parses the "member:" prefix as a member-name search', () => {
+    expect(parseTeamSearchQuery('member:김철수')).toEqual({ field: 'member', value: '김철수' })
+  })
+
+  it('parses the "mentor:" prefix as a mentor-name search', () => {
+    expect(parseTeamSearchQuery('mentor:전수열')).toEqual({ field: 'mentor', value: '전수열' })
+  })
+
+  it('parses the "project:" prefix as a project-name search', () => {
+    expect(parseTeamSearchQuery('project:Previzion')).toEqual({ field: 'project', value: 'Previzion' })
+  })
+
+  it('parses the "all:" prefix as an all-fields search', () => {
+    expect(parseTeamSearchQuery('all:전수열')).toEqual({ field: 'all', value: '전수열' })
+  })
+
+  it('sets the "me" flag when parsing "mentor:@me"', () => {
+    expect(parseTeamSearchQuery('mentor:@me')).toEqual({ field: 'mentor', value: '@me', me: true })
+  })
+
+  it('sets the "me" flag when parsing "member:@me"', () => {
+    expect(parseTeamSearchQuery('member:@me')).toEqual({ field: 'member', value: '@me', me: true })
+  })
+
+  it('does not set the "me" flag for "team:@me" or "project:@me"', () => {
+    expect(parseTeamSearchQuery('team:@me')).toEqual({ field: 'team', value: '@me' })
+    expect(parseTeamSearchQuery('project:@me')).toEqual({ field: 'project', value: '@me' })
+  })
+
+  it('treats an unknown prefix as a plain all-fields search', () => {
+    expect(parseTeamSearchQuery('foo:bar')).toEqual({ field: 'all', value: 'foo:bar' })
+  })
+
+  it('preserves everything after the first colon when the value contains colons', () => {
+    expect(parseTeamSearchQuery('team:foo:bar')).toEqual({ field: 'team', value: 'foo:bar' })
+  })
+})
+
+describe('buildTeamListParams', () => {
+  it('returns only menuNo when no options are passed', () => {
+    expect(buildTeamListParams()).toEqual({ menuNo: MENU_NO.TEAM })
+  })
+
+  it('omits search params when search is not provided', () => {
+    expect(buildTeamListParams({})).toEqual({ menuNo: MENU_NO.TEAM })
+  })
+
+  it('sets searchCnd="" for an all-fields search', () => {
+    expect(buildTeamListParams({ search: { field: 'all', value: '전수열' } })).toEqual({
+      menuNo: MENU_NO.TEAM,
+      searchCnd: '',
+      searchWrd: '전수열',
+    })
+  })
+
+  it('sets searchCnd=1 for a member-name search', () => {
+    expect(buildTeamListParams({ search: { field: 'member', value: '김철수' } })).toEqual({
+      menuNo: MENU_NO.TEAM,
+      searchCnd: '1',
+      searchWrd: '김철수',
+    })
+  })
+
+  it('sets searchCnd=2 for a mentor-name search', () => {
+    expect(buildTeamListParams({ search: { field: 'mentor', value: '전수열' } })).toEqual({
+      menuNo: MENU_NO.TEAM,
+      searchCnd: '2',
+      searchWrd: '전수열',
+    })
+  })
+
+  it('sets searchCnd=3 for a project-name search', () => {
+    expect(buildTeamListParams({ search: { field: 'project', value: 'Previzion' } })).toEqual({
+      menuNo: MENU_NO.TEAM,
+      searchCnd: '3',
+      searchWrd: 'Previzion',
+    })
+  })
+
+  it('sets searchCnd=4 for a team-name search', () => {
+    expect(buildTeamListParams({ search: { field: 'team', value: '오픈소마' } })).toEqual({
+      menuNo: MENU_NO.TEAM,
+      searchCnd: '4',
+      searchWrd: '오픈소마',
+    })
+  })
+
+  it('substitutes the current user name when "mentor:@me" is used', () => {
+    expect(
+      buildTeamListParams({
+        search: { field: 'mentor', value: '@me', me: true },
+        user: { userId: 'neo@example.com', userNm: '전수열' },
+      }),
+    ).toEqual({
+      menuNo: MENU_NO.TEAM,
+      searchCnd: '2',
+      searchWrd: '전수열',
+    })
+  })
+
+  it('substitutes the current user name when "member:@me" is used', () => {
+    expect(
+      buildTeamListParams({
+        search: { field: 'member', value: '@me', me: true },
+        user: { userId: 'neo@example.com', userNm: '강동우' },
+      }),
+    ).toEqual({
+      menuNo: MENU_NO.TEAM,
+      searchCnd: '1',
+      searchWrd: '강동우',
+    })
+  })
+
+  it('does not emit a searchId param (the native team page does not accept it)', () => {
+    const params = buildTeamListParams({
+      search: { field: 'mentor', value: '@me', me: true },
+      user: { userId: 'neo@example.com', userNm: '전수열' },
+    })
+    expect(params).not.toHaveProperty('searchId')
+  })
+
+  it('omits search params when "@me" is requested but the user identity is unavailable', () => {
+    expect(buildTeamListParams({ search: { field: 'mentor', value: '@me', me: true } })).toEqual({
+      menuNo: MENU_NO.TEAM,
+    })
+  })
+})

package/src/shared/utils/team-params.ts

@@ -0,0 +1,53 @@
+import { MENU_NO } from '../../constants'
+import type { UserIdentity } from '../../http'
+
+const SEARCH_FIELD_MAP: Record<string, string> = {
+  all: '',
+  member: '1',
+  mentor: '2',
+  project: '3',
+  team: '4',
+}
+
+export interface TeamSearchQuery {
+  field: 'all' | 'member' | 'mentor' | 'project' | 'team'
+  value: string
+  me?: boolean
+}
+
+export function parseTeamSearchQuery(raw: string): TeamSearchQuery {
+  const colonIndex = raw.indexOf(':')
+  if (colonIndex === -1) {
+    return { field: 'all', value: raw }
+  }
+
+  const field = raw.slice(0, colonIndex) as TeamSearchQuery['field']
+  if (!(field in SEARCH_FIELD_MAP)) {
+    return { field: 'all', value: raw }
+  }
+
+  const value = raw.slice(colonIndex + 1)
+  const me = (field === 'mentor' || field === 'member') && value === '@me'
+  return me ? { field, value, me } : { field, value }
+}
+
+export function buildTeamListParams(options?: {
+  search?: TeamSearchQuery
+  user?: UserIdentity
+}): Record<string, string> {
+  const params: Record<string, string> = { menuNo: MENU_NO.TEAM }
+
+  if (options?.search) {
+    if (options.search.me) {
+      if (options.user) {
+        params.searchCnd = SEARCH_FIELD_MAP[options.search.field]
+        params.searchWrd = options.user.userNm
+      }
+    } else {
+      params.searchCnd = SEARCH_FIELD_MAP[options.search.field]
+      params.searchWrd = options.search.value
+    }
+  }
+
+  return params
+}

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)