Files
game_voice_recorder/app/test/auth.test.ts
EJClaw b230443409 v1.3.3: 따라갈 사람 목록 · 롤 채팅 OCR 제거 · 표시 이름(실명 숨기기)
- 따라갈 사람: 봇이 서버를 지켜보기 전 멤버 요청을 사이트 서버가 forbidden 으로 거절하고 앱이 오류를 숨겨 빈 목록이 됐다
  → 가입한 서버면 지켜보기 전에도 응답(source.members 가 멤버 확인), 앱은 오류 · 다시 불러오기 표시
  → 내 계정 → 관리자(GET /app/admins) → 이름순, 녹음할 서버를 바꾸면 봇을 다시 붙여 새 서버를 지켜봄
- 롤 채팅 OCR 제거: 앱 설정 · 마법사 · 진단 · lol.ts · 워커 ocr.py/ocr_* op · pywinrt/mss/Pillow · win-ci ocr_lang
  롤은 게임 중 전체/팀 채팅 API 가 없어 LCU(챔피언 선택 · 게임 후) + r3dlog(남아 있을 때, LCU 채팅을 지우지 않고 추가)
- 표시 이름: 서버 store.displayNames (세션 · 앱 유저 · 접속 기록 이름까지 바꿈), GET /app/names, PUT /app/admin/names,
  cli name. 앱은 받아서 users · 지난 범인 분석 이름을 바꾸고 이후 디스코드 이름 대신 저장. 관리자 탭에 편집 UI
- 저장소 시연 · 테스트 데이터 · 화면 캡처 · 계획서 PDF 의 실제 이름을 가짜 이름으로 교체
- 테스트: 앱 41 · 서버 16 · 워커 39 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 02:42:57 +09:00

270 lines
13 KiB
TypeScript

// 앱 로그인(core/auth.ts) ↔ 실제 사이트 서버 코드(site/server) 통합 테스트. 디스코드만 가짜.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import os from 'node:os';
import path from 'node:path';
import { buildServer } from '../../site/server/src/app.ts';
import { AppAuth } from '../src/core/auth.ts';
import { adminOnlyPaths } from '../src/core/roles.ts';
import { SettingsStore } from '../src/core/settings.ts';
const SUPER = '1352267557213573160';
const FRIEND = '111111111111111111';
const STRANGER = '222222222222222222';
const BOT = 'MTExMTExMTExMTExMTExMTEx.FAKE00.server-delivered-token-xxxxxxxx';
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-auth-'));
delete process.env.GVR_BOT_TOKEN;
async function fakeDiscord() {
const names: Record<string, string> = { [SUPER]: '관리자', [FRIEND]: '친구', [STRANGER]: '모르는사람' };
const srv = http.createServer((req, res) => {
const u = new URL(req.url!, 'http://x');
res.setHeader('content-type', 'application/json');
if (u.pathname === '/oauth2/token') {
let b = '';
req.on('data', (c) => (b += c));
req.on('end', () => res.end(JSON.stringify({ access_token: new URLSearchParams(b).get('code') })));
return;
}
if (u.pathname === '/users/@me') {
const id = String(req.headers.authorization).replace('Bearer ', '');
return res.end(JSON.stringify({ id, username: names[id], global_name: names[id], avatar: null }));
}
const m = /^\/users\/(\d+)$/.exec(u.pathname);
if (m && names[m[1]!]) return res.end(JSON.stringify({ id: m[1], username: names[m[1]!], global_name: names[m[1]!], avatar: null }));
res.statusCode = 404;
res.end('{}');
});
await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
return { url: `http://127.0.0.1:${(srv.address() as any).port}`, close: () => srv.close() };
}
async function stack() {
const dc = await fakeDiscord();
const { app } = await buildServer({
port: 0, host: '127.0.0.1', publicUrl: 'http://placeholder', clientId: 'cid', clientSecret: 's', botToken: BOT,
allowedGuilds: [], owners: [SUPER], superAdmins: [SUPER], sessionSecret: 'x'.repeat(32), dataDir: tmp(), webDir: '/nonexistent',
version: 'test', discordApi: dc.url, assetUpstream: {},
});
await app.listen({ host: '127.0.0.1', port: 0 });
const base = `http://127.0.0.1:${(app.server.address() as any).port}`;
/** 브라우저 흉내: 로그인 주소 → 디스코드(가짜) → 콜백. who = 디스코드에서 로그인한 계정 */
const browser = (who: string) => async (url: string) => {
const start = await fetch(url.replace('http://placeholder', base), { redirect: 'manual' });
const state = new URL(start.headers.get('location')!).searchParams.get('state')!;
const cookie = start.headers.getSetCookie()[0]!.split(';')[0]!;
await fetch(`${base}/auth/discord/callback?code=${who}&state=${encodeURIComponent(state)}`, { headers: { cookie }, redirect: 'manual' });
};
const settingsFor = (dir = tmp()) => {
const s = new SettingsStore(dir);
s.update({ site: { serverUrl: base } });
return s;
};
return { base, browser, settingsFor, close: async () => (await app.close(), dc.close()) };
}
test('앱 로그인: 등록된 아이디만 열리고, 겜녹이 봇 토큰은 로그인해도 앱에 오지 않는다', async () => {
const s = await stack();
try {
// 로그인 전: 토큰 없음 → 로그인 화면
const st = s.settingsFor();
const auth = new AppAuth(st, { version: '1.2.0', openUrl: s.browser(STRANGER), pollMs: 20 });
assert.equal((await auth.check()).status, 'signed_out');
assert.equal(st.activeBotToken(), null);
// 미등록 아이디 → 등록되지 않은 아이디, 토큰 없음
const r1 = await auth.login();
assert.equal(r1.status, 'not_registered');
assert.equal(r1.user?.id, STRANGER);
assert.equal(st.hasSecret('appToken'), false);
assert.equal(st.activeBotToken(), null);
// 최고 관리자 로그인 → 앱 토큰만 받는다. 봇 토큰은 서버 응답 어디에도 없다
const adminSt = s.settingsFor();
const admin = new AppAuth(adminSt, { version: '1.2.0', openUrl: s.browser(SUPER), pollMs: 20 });
const r2 = await admin.login();
assert.equal(r2.status, 'ok');
assert.equal(r2.role, 'superadmin');
assert.equal(adminSt.hasBuiltinBot, true);
assert.equal(adminSt.activeBotToken(), null);
const me = await (await fetch(`${s.base}/app/me`, { headers: { authorization: `Bearer ${adminSt.getSecret('appToken')}` } })).text();
assert.ok(me.includes(SUPER) && !me.includes(BOT) && !me.includes('botToken'), me);
// 최고 관리자가 친구 등록 (관리자 화면 API)
const list = await admin.adminAddUser(FRIEND, 'user');
assert.ok(list.users.some((u) => u.id === FRIEND && u.role === 'user'));
// 친구 로그인 → 일반 유저
const dir = tmp();
const frSt = s.settingsFor(dir);
const fr = new AppAuth(frSt, { version: '1.2.0', openUrl: s.browser(FRIEND), pollMs: 20 });
const r3 = await fr.login();
assert.equal(r3.status, 'ok');
assert.equal(r3.role, 'user');
assert.equal(frSt.activeBotToken(), null);
await assert.rejects(fr.adminAddUser(STRANGER, 'user'), /최고 관리자만/);
await assert.rejects(fr.adminUsers(), /관리자만/);
// 일반 유저도 관리자 아이디는 받는다 (따라갈 사람 목록 정렬). 유저 자신은 관리자가 아니다
const ids = await fr.adminIds();
assert.ok(ids.includes(SUPER) && !ids.includes(FRIEND));
await admin.adminSetRole(FRIEND, 'admin');
assert.ok((await fr.adminIds()).includes(FRIEND));
await admin.adminSetRole(FRIEND, 'user');
// 표시 이름 (실명 숨기기): 최고 관리자만 정하고, 정하면 서버가 저장한 이름 · 로그인 정보가 모두 그 이름이 된다
await assert.rejects(fr.adminSetDisplayName(FRIEND, '별명'), /최고 관리자만/);
assert.deepEqual((await admin.adminSetDisplayName(FRIEND, '별명')).names, { [FRIEND]: '별명' });
assert.deepEqual(await fr.displayNames(), { [FRIEND]: '별명' });
assert.equal((await fr.check()).user?.name, '별명');
const rows = (await admin.adminUsers()).users;
assert.equal(rows.find((u) => u.id === FRIEND)?.name, '별명');
assert.deepEqual((await admin.adminSetDisplayName(FRIEND, '')).names, {});
// 다시 켜도 (새 SettingsStore) 로그인 유지
assert.equal((await new AppAuth(s.settingsFor(dir), { version: '1.2.0', openUrl: () => undefined }).check()).status, 'ok');
// 봇 토큰은 이 PC 어디에도 저장되지 않는다 (테스트는 평문 codec 이라 secrets.bin 도 그대로 읽힌다)
for (const f of fs.readdirSync(dir)) assert.ok(!fs.readFileSync(path.join(dir, f), 'utf8').includes(BOT), f);
// 등록 해제 → 다음 확인에서 잠기고 앱 토큰을 지운다
await admin.adminRemoveUser(FRIEND);
const r4 = await fr.check();
assert.equal(r4.status, 'not_registered');
assert.equal(r4.user?.id, FRIEND);
assert.equal((await fr.check()).status, 'not_registered', '다시 확인해도 "등록되지 않은 아이디" 화면 유지');
assert.equal(frSt.activeBotToken(), null);
assert.equal(frSt.hasSecret('appToken'), false);
// 로그아웃 → 토큰 삭제, 서버에서도 무효
await admin.logout();
assert.equal(admin.state.status, 'signed_out');
assert.equal(adminSt.hasBuiltinBot, false);
} finally {
await s.close();
}
});
test('앱 로그인: 서버에 못 붙으면 마지막 확인 후 유예 기간까지만 쓴다', async () => {
const s = await stack();
const dir = tmp();
const st = s.settingsFor(dir);
const auth = new AppAuth(st, { version: '1.2.0', openUrl: s.browser(SUPER), pollMs: 20 });
assert.equal((await auth.login()).status, 'ok');
await s.close();
// 서버 꺼짐 → 마지막 확인이 방금이라 오프라인으로 계속
const r = await auth.check();
assert.equal(r.status, 'ok');
assert.equal(r.offline, true);
assert.equal(st.hasSecret('appToken'), true);
// 유예 기간이 지나면 막힌다 (토큰은 남겨 두어 서버가 돌아오면 다시 확인)
const late = new AppAuth(st, { version: '1.2.0', openUrl: () => undefined, offlineGraceMs: 0 });
const r2 = await late.check();
assert.equal(r2.status, 'error');
assert.match(r2.error!, /연결할 수 없습니다/);
assert.equal(st.hasSecret('appToken'), true);
});
test('관리자 전용 설정: 일반 유저가 바꾸면 안 되는 경로만 골라낸다', () => {
assert.deepEqual(adminOnlyPaths({ discord: { botMode: 'custom' } }), ['discord.botMode']);
assert.deepEqual(adminOnlyPaths({ discord: { guildId: 'g', ttsVoice: 'x' }, stt: { realtimeModel: 'small' } }), []);
assert.deepEqual(adminOnlyPaths({ discord: { ttsEnabled: false, ttsText: 'x', ttsVoice: 'y' } }), ['discord.ttsEnabled', 'discord.ttsText']);
assert.deepEqual(adminOnlyPaths({ storage: { retentionDays: 30, audioDir: 'D:/a' } }), ['storage.retentionDays']);
assert.deepEqual(adminOnlyPaths({ site: { deviceName: 'x' } }), ['site']);
assert.deepEqual(adminOnlyPaths({ finetune: { schedule: 'nightly' } }), ['finetune']);
assert.deepEqual(adminOnlyPaths({ firstRunDone: true, general: { sfx: false } }), []);
});
/** /app/me 응답을 서버가 처리한 뒤 앱에 늦게 도착하게 붙잡는다 (hold() 로 다음 요청 하나를 잡고, 반환값으로 놓아준다) */
function holdMe() {
const real = globalThis.fetch;
let gate: { promise: Promise<void>; release: () => void } | null = null;
globalThis.fetch = (async (input: any, init?: any) => {
const r = await real(input, init);
if (gate && String(input).endsWith('/app/me')) {
const g = gate;
gate = null;
await g.promise;
}
return r;
}) as typeof fetch;
return {
hold: () => {
let release!: () => void;
const promise = new Promise<void>((r) => (release = r));
gate = { promise, release };
return release;
},
restore: () => (globalThis.fetch = real),
};
}
test('늦은 확인 응답: 등록 해제로 잠긴 뒤 이전 확인의 200 이 와도 다시 열리지 않는다', async () => {
const s = await stack();
const h = holdMe();
try {
const admin = new AppAuth(s.settingsFor(), { version: 't', openUrl: s.browser(SUPER), pollMs: 20 });
await admin.login();
await admin.adminAddUser(FRIEND, 'user');
const st = s.settingsFor();
const fr = new AppAuth(st, { version: 't', openUrl: s.browser(FRIEND), pollMs: 20 });
assert.equal((await fr.login()).status, 'ok');
// A: 서버는 200 을 줬지만 응답이 늦게 온다
const release = h.hold();
const a = fr.check();
await new Promise((r) => setTimeout(r, 100));
// 그 사이 등록 해제 → B: 403 → 잠김
await admin.adminRemoveUser(FRIEND);
assert.equal((await fr.check()).status, 'not_registered');
// A 의 늦은 200 도착
release();
await a;
assert.equal(fr.state.status, 'not_registered', '늦은 200 이 잠금을 풀면 안 된다');
assert.equal(st.hasSecret('appToken'), false, '지운 앱 토큰이 되살아나면 안 된다');
assert.equal(st.hasSecret('auth'), false);
} finally {
h.restore();
await s.close();
}
});
test('늦은 확인 응답: 로그아웃 뒤 이전 확인의 200 이 와도 다시 열리지 않는다', async () => {
const s = await stack();
const h = holdMe();
try {
const st = s.settingsFor();
const auth = new AppAuth(st, { version: 't', openUrl: s.browser(SUPER), pollMs: 20 });
assert.equal((await auth.login()).status, 'ok');
const release = h.hold();
const a = auth.check();
await new Promise((r) => setTimeout(r, 100));
await auth.logout();
assert.equal(auth.state.status, 'signed_out');
release();
await a;
assert.equal(auth.state.status, 'signed_out', '늦은 200 이 로그아웃을 되돌리면 안 된다');
assert.equal(st.hasSecret('appToken'), false);
assert.equal(st.hasSecret('auth'), false);
} finally {
h.restore();
await s.close();
}
});
test('겹친 확인: 등록 해제 뒤 확인 두 개가 겹쳐도 "로그인 만료"가 아니라 "등록되지 않은 아이디"로 잠긴다', async () => {
// 봇 중계가 끊기며 바로 확인하는 사이 10분 확인 · 다시 확인 버튼이 겹치는 경우. 서버는 첫 403 에서 세션을 지워 뒤 확인은 401 을 받는다
const s = await stack();
try {
const admin = new AppAuth(s.settingsFor(), { version: 't', openUrl: s.browser(SUPER), pollMs: 20 });
await admin.login();
await admin.adminAddUser(FRIEND, 'user');
const fr = new AppAuth(s.settingsFor(), { version: 't', openUrl: s.browser(FRIEND), pollMs: 20 });
assert.equal((await fr.login()).status, 'ok');
await admin.adminRemoveUser(FRIEND);
await Promise.all([fr.check(), fr.check()]);
assert.equal(fr.state.status, 'not_registered');
assert.equal(fr.state.user?.id, FRIEND);
} finally {
await s.close();
}
});