test(services): add comprehensive tests for untested service modules

Add tests for sessionService, guildService, seedService, and
initResourceDownloadList. Expand coverage for encryptionHelpers
(encryptAndSend) and questService (getBlockHashsFromQuestHash).

Key coverage gains: seedService 0→100%, initResourceDownloadList 0→97%,
encryptionHelpers 15→89%, questService 22→89%. Overall 56%→63%.

Author: Houmgaor

src/services/crypto/encryptionHelpers.spec.ts

@@ -1,16 +1,61 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../../model/session', () => ({
+  default: {
+    updateOne: vi.fn().mockResolvedValue({}),
+    deleteOne: vi.fn().mockResolvedValue({}),
+    deleteMany: vi.fn().mockResolvedValue({}),
+    find: vi.fn().mockResolvedValue([]),
+  },
+}));
+
 import {
   clearAllSessions,
   decryptAndParse,
+  encryptAndSend,
   getSessionCount,
   getAllActiveSessions,
   getSessionStats,
   getPerformanceStats,
   verifySessionToken,
   generateUniqueId,
   findSessionsByUser,
+  getSessionInfo,
 } from './encryptionHelpers.js';
 import { EncryptionService } from './encryptionService.js';
+import type { Response, Request } from 'express';
+
+function makeReq(overrides: Record<string, unknown> = {}): Request {
+  return {
+    body: {},
+    query: {},
+    ip: '127.0.0.1',
+    socket: { remoteAddress: '127.0.0.1' },
+    get: (header: string) => (header === 'User-Agent' ? 'TestAgent/1.0' : undefined),
+    ...overrides,
+  } as unknown as Request;
+}
+
+function makeRes(): Response & { _status: number; _data: Buffer | null; _headers: Record<string, string> } {
+  const res = {
+    _status: 0,
+    _data: null as Buffer | null,
+    _headers: {} as Record<string, string>,
+    status(code: number) {
+      res._status = code;
+      return res;
+    },
+    header(name: string, value: string) {
+      res._headers[name] = value;
+      return res;
+    },
+    send(data: Buffer) {
+      res._data = data;
+      return res;
+    },
+  };
+  return res as unknown as Response & { _status: number; _data: Buffer | null; _headers: Record<string, string> };
+}
 
 describe('encryptionHelpers - session management', () => {
   beforeEach(() => {
@@ -82,3 +127,113 @@ describe('decryptAndParse', () => {
     expect(() => decryptAndParse(Buffer.alloc(0))).toThrow();
   });
 });
+
+describe('encryptAndSend', () => {
+  const encryptionService = new EncryptionService();
+
+  beforeEach(() => {
+    clearAllSessions();
+  });
+
+  it('sends encrypted response with correct status and content type', () => {
+    const req = makeReq({ body: { user_id: 'u1' } });
+    const res = makeRes();
+
+    encryptAndSend({ result: 'ok' }, res, req);
+
+    expect(res._status).toBe(200);
+    expect(res._headers['Content-Type']).toBe('application/octet-stream');
+    expect(res._data).toBeInstanceOf(Buffer);
+  });
+
+  it('response decrypts to valid JSON with protocol fields', () => {
+    const req = makeReq({ body: { user_id: 'u1' } });
+    const res = makeRes();
+
+    encryptAndSend({ result: 'ok' }, res, req);
+
+    const decrypted = JSON.parse(
+      encryptionService.decrypt(res._data!).replace(/\0+$/, '').trim(),
+    ) as Record<string, unknown>;
+    expect(decrypted.result).toBe('ok');
+    expect(decrypted.res_ver).toBe(282);
+    expect(decrypted.banner_ver).toBe(91);
+    expect(decrypted.app_ver).toBe('09.03.06');
+    expect(decrypted.session_id).toEqual(expect.any(String));
+    expect(decrypted.error_code).toBe(0);
+    expect(decrypted.now_time).toEqual(expect.any(Number));
+  });
+
+  it('includes custom error codes in response', () => {
+    const req = makeReq({ body: { user_id: 'u1' } });
+    const res = makeRes();
+
+    encryptAndSend({}, res, req, 4004, 2, 'not_auth');
+
+    const decrypted = JSON.parse(
+      encryptionService.decrypt(res._data!).replace(/\0+$/, '').trim(),
+    ) as Record<string, unknown>;
+    expect(decrypted.error_code).toBe(4004);
+    expect(decrypted.error_category).toBe(2);
+    expect(decrypted.error_detail).toBe('not_auth');
+  });
+
+  it('sends with custom status code', () => {
+    const req = makeReq({ body: { user_id: 'u1' } });
+    const res = makeRes();
+
+    encryptAndSend({}, res, req, 0, 0, '', 400);
+
+    expect(res._status).toBe(400);
+  });
+
+  it('creates session for userId path', () => {
+    const req = makeReq({ body: { user_id: 'user-42' } });
+    const res = makeRes();
+
+    encryptAndSend({}, res, req);
+
+    const session = getSessionInfo('user_user-42');
+    expect(session).toBeDefined();
+    expect(session!.account_id).toBe('user-42');
+  });
+
+  it('reuses existing session for same userId', () => {
+    const req = makeReq({ body: { user_id: 'user-42' } });
+    const res1 = makeRes();
+    const res2 = makeRes();
+
+    encryptAndSend({}, res1, req);
+    const firstSession = getSessionInfo('user_user-42');
+    const firstToken = firstSession!.session_token;
+
+    encryptAndSend({}, res2, req);
+    const secondSession = getSessionInfo('user_user-42');
+    expect(secondSession!.session_token).toBe(firstToken);
+  });
+
+  it('creates session for clientSessionToken path (session_id in body)', () => {
+    const req = makeReq({ body: { session_id: 'client-tok-1' } });
+    const res = makeRes();
+
+    encryptAndSend({}, res, req);
+
+    // Should create a session keyed by client token
+    const decrypted = JSON.parse(
+      encryptionService.decrypt(res._data!).replace(/\0+$/, '').trim(),
+    ) as Record<string, unknown>;
+    expect(decrypted.session_id).toEqual(expect.any(String));
+  });
+
+  it('creates session for device fallback path (no userId, no session_id)', () => {
+    const req = makeReq();
+    const res = makeRes();
+
+    encryptAndSend({}, res, req);
+
+    const all = getAllActiveSessions();
+    expect(all.length).toBeGreaterThanOrEqual(1);
+    const deviceSession = all.find((s) => s.key.startsWith('device_'));
+    expect(deviceSession).toBeDefined();
+  });
+});