fix(tests): resolve test failures on GitHub Actions

- Fix WisdomGate quota checker tests: update to use 'session' option instead of 'apiKey'
- Fix admin-auth test hanging: remove circular import from index.ts by using env var
- Fix quota-enforcer tests: add beforeAll hook to ensure migrations run
- Add error handling for missing quota_state table in test cleanup

All 714 tests now pass

Author: mcowger

packages/backend/src/index.ts

@@ -58,6 +58,7 @@ if (!process.env.ADMIN_KEY) {
       if (parsed?.adminKey) {
         adminKeyFromYaml = parsed.adminKey;
         process.env.ADMIN_KEY = adminKeyFromYaml;
+        process.env.ADMIN_KEY_FROM_YAML = 'true';
 
         // Print large ASCII banner warning
         logger.error('');

packages/backend/src/routes/management/__tests__/admin-auth.test.ts

@@ -9,6 +9,13 @@ import { UsageStorageService } from '../../../services/usage-storage';
 import { DebugManager } from '../../../services/debug-manager';
 import { SelectorFactory } from '../../../services/selectors/factory';
 
+// Helper to close Fastify instances after tests
+const closeFastify = async (fastify: FastifyInstance | undefined) => {
+  if (fastify) {
+    await fastify.close();
+  }
+};
+
 const BASE_CONFIG = {
   providers: {},
   models: {},
@@ -76,6 +83,10 @@ describe('GET /v0/management/auth/verify', () => {
     await fastify.ready();
   });
 
+  afterAll(async () => {
+    await closeFastify(fastify);
+  });
+
   it('returns 200 with { ok: true } when the correct admin key is provided', async () => {
     const res = await fastify.inject({
       method: 'GET',
@@ -147,6 +158,10 @@ describe('Management route protection', () => {
     await fastify.ready();
   });
 
+  afterAll(async () => {
+    await closeFastify(fastify);
+  });
+
   it('rejects GET /v0/management/cooldowns without admin key', async () => {
     const res = await fastify.inject({
       method: 'GET',
@@ -261,6 +276,13 @@ describe('v1 inference routes are unaffected by admin key auth', () => {
     await fastify.ready();
   });
 
+  afterAll(async () => {
+    await closeFastify(fastify);
+    // Clean up singletons to prevent test hangs
+    SelectorFactory.setUsageStorage(null as any);
+    DebugManager.getInstance().setStorage(null as any);
+  });
+
   it('accepts a v1 request using a valid API key (no admin key needed)', async () => {
     const res = await fastify.inject({
       method: 'POST',

packages/backend/src/routes/management/config.ts

@@ -8,7 +8,6 @@ import {
   McpServerConfigSchema,
 } from '../../config';
 import { ConfigService } from '../../services/config-service';
-import { adminKeyFromYaml } from '../../index';
 
 export async function registerConfigRoutes(fastify: FastifyInstance) {
   const configService = ConfigService.getInstance();
@@ -17,8 +16,10 @@ export async function registerConfigRoutes(fastify: FastifyInstance) {
 
   fastify.get('/v0/management/config/status', async (_request, reply) => {
     try {
+      // Check if ADMIN_KEY was loaded from YAML (deprecated, but kept for backward compatibility)
+      const adminKeyFromYaml = process.env.ADMIN_KEY_FROM_YAML === 'true';
       return reply.send({
-        adminKeyFromYaml: !!adminKeyFromYaml,
+        adminKeyFromYaml: adminKeyFromYaml,
       });
     } catch (e: any) {
       return reply.code(500).send({ error: 'Internal server error' });

packages/backend/src/services/quota/checkers/__tests__/wisdomgate-checker.test.ts

@@ -3,14 +3,14 @@ import type { QuotaCheckerConfig } from '../../../../types/quota';
 import { WisdomGateQuotaChecker } from '../wisdomgate-checker';
 import { QuotaCheckerFactory } from '../../quota-checker-factory';
 
-const makeConfig = (apiKey = 'test_api_key'): QuotaCheckerConfig => ({
+const makeConfig = (session = 'test_session_token'): QuotaCheckerConfig => ({
   id: 'wisdomgate-test',
   provider: 'wisdomgate',
   type: 'wisdomgate',
   enabled: true,
   intervalMinutes: 30,
   options: {
-    apiKey,
+    session,
   },
 });
 
@@ -27,22 +27,33 @@ describe('WisdomGateQuotaChecker', () => {
     expect(QuotaCheckerFactory.isRegistered('wisdomgate')).toBe(true);
   });
 
-  it('queries balance with Bearer token and returns subscription quota with dollars', async () => {
+  it('queries balance with session cookie and returns monthly subscription quota with dollars', async () => {
     let capturedUrl: string | undefined;
-    let capturedAuthorization: string | undefined;
+    let capturedCookie: string | undefined;
 
     setFetchMock(async (input: RequestInfo | URL, init?: RequestInit) => {
       capturedUrl = String(input);
       const headers = new Headers(init?.headers);
-      capturedAuthorization = headers.get('Authorization') ?? undefined;
+      capturedCookie = headers.get('Cookie') ?? undefined;
 
       return new Response(
         JSON.stringify({
-          available_balance: 23.852028,
-          package_balance: 23.848028,
-          cash_balance: 0.004,
-          token_balance: 23.852028,
-          is_token_unlimited_quota: false,
+          object: 'billing_details',
+          total_usage: 76.147972,
+          total_available: 23.852028,
+          regular_amount: 100,
+          package_details: [
+            {
+              package_id: 'pkg_123',
+              title: 'Test Package',
+              amount: 23.852028,
+              total_amount: 100,
+              expiry_time: 1735689600,
+              expiry_date: '2025-01-01',
+              begin_time: 1704067200,
+              begin_date: '2024-01-01',
+            },
+          ],
         }),
         {
           status: 200,
@@ -51,22 +62,24 @@ describe('WisdomGateQuotaChecker', () => {
       );
     });
 
-    const checker = new WisdomGateQuotaChecker(makeConfig('my-api-key'));
+    const checker = new WisdomGateQuotaChecker(makeConfig('my-session-token'));
     const result = await checker.checkQuota();
 
-    expect(capturedUrl).toBe('https://wisdom-gate.juheapi.com/v1/users/me/balance');
-    expect(capturedAuthorization).toBe('Bearer my-api-key');
+    expect(capturedUrl).toBe('https://wisgate.ai/api/dashboard/billing/usage/details');
+    expect(capturedCookie).toBe('session=my-session-token');
 
     expect(result.success).toBe(true);
     expect(result.error).toBeUndefined();
     expect(result.windows).toHaveLength(1);
 
     const window = result.windows?.[0];
-    expect(window?.windowType).toBe('subscription');
+    expect(window?.windowType).toBe('monthly');
     expect(window?.unit).toBe('dollars');
+    expect(window?.limit).toBe(100);
+    expect(window?.used).toBeCloseTo(76.147972, 6);
     expect(window?.remaining).toBeCloseTo(23.852028, 6);
-    expect(window?.description).toBe('Wisdom Gate account balance');
-    expect(window?.resetsAt).toBeUndefined();
+    expect(window?.description).toBe('Wisdom Gate monthly subscription');
+    expect(window?.resetsAt).toBeInstanceOf(Date);
   });
 
   it('returns error for non-200 response', async () => {
@@ -88,11 +101,22 @@ describe('WisdomGateQuotaChecker', () => {
       capturedUrl = String(input);
       return new Response(
         JSON.stringify({
-          available_balance: 10,
-          package_balance: 10,
-          cash_balance: 0,
-          token_balance: 10,
-          is_token_unlimited_quota: false,
+          object: 'billing_details',
+          total_usage: 0,
+          total_available: 10,
+          regular_amount: 10,
+          package_details: [
+            {
+              package_id: 'pkg_123',
+              title: 'Test Package',
+              amount: 10,
+              total_amount: 10,
+              expiry_time: 1735689600,
+              expiry_date: '2025-01-01',
+              begin_time: 1704067200,
+              begin_date: '2024-01-01',
+            },
+          ],
         }),
         { status: 200, headers: { 'Content-Type': 'application/json' } }
       );
@@ -105,16 +129,18 @@ describe('WisdomGateQuotaChecker', () => {
       enabled: true,
       intervalMinutes: 30,
       options: {
-        apiKey: 'test-key',
-        endpoint: 'https://custom.endpoint.example.com/v1/users/me/balance',
+        session: 'test-session',
+        endpoint: 'https://custom.endpoint.example.com/api/dashboard/billing/usage/details',
       },
     });
 
     await checker.checkQuota();
-    expect(capturedUrl).toBe('https://custom.endpoint.example.com/v1/users/me/balance');
+    expect(capturedUrl).toBe(
+      'https://custom.endpoint.example.com/api/dashboard/billing/usage/details'
+    );
   });
 
-  it('throws error when apiKey option is missing', async () => {
+  it('throws error when session option is missing', async () => {
     const checker = new WisdomGateQuotaChecker({
       id: 'wisdomgate-test',
       provider: 'wisdomgate',

packages/backend/test/quota-enforcer.test.ts

@@ -1,7 +1,8 @@
-import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach, beforeAll, mock } from 'bun:test';
 import { QuotaEnforcer, QuotaCheckResult } from '../src/services/quota/quota-enforcer';
 import { setConfigForTesting, PlexusConfig } from '../src/config';
 import { getDatabase } from '../src/db/client';
+import { runMigrations } from '../src/db/migrate';
 import * as sqliteSchema from '../drizzle/schema/sqlite';
 import { eq } from 'drizzle-orm';
 
@@ -33,10 +34,22 @@ describe('QuotaEnforcer', () => {
   let quotaEnforcer: QuotaEnforcer;
   let db: ReturnType<typeof getDatabase>;
 
+  beforeAll(async () => {
+    // Ensure migrations are run before tests
+    await runMigrations();
+  });
+
   beforeEach(async () => {
     // Reset database state
     db = getDatabase();
-    await db.delete(sqliteSchema.quotaState);
+    try {
+      await db.delete(sqliteSchema.quotaState);
+    } catch (e: any) {
+      // Table might not exist yet, ignore
+      if (!e.message?.includes('no such table')) {
+        throw e;
+      }
+    }
 
     // Reset config
     setConfigForTesting(createTestConfig());
@@ -47,7 +60,14 @@ describe('QuotaEnforcer', () => {
 
   afterEach(async () => {
     // Clean up test data
-    await db.delete(sqliteSchema.quotaState);
+    try {
+      await db.delete(sqliteSchema.quotaState);
+    } catch (e: any) {
+      // Table might not exist, ignore
+      if (!e.message?.includes('no such table')) {
+        throw e;
+      }
+    }
   });
 
   describe('checkQuota', () => {