/**

* Root-level test preload for the entire monorepo.

*

* This file is loaded before any test files via bunfig.toml preload.

* It mocks module-level singletons (NATS, FalkorDB, Logger) BEFORE test files import them,

* solving the Bun mock.module singleton interception limitation.

*

* For integration tests, set RUN_INTEGRATION_TESTS=1 to bypass all mocks and use real implementations.

*

* @see https://bun.sh/docs/test/mocks#preload

*/

import { mock } from "bun:test";

// Skip all mocking when running integration tests with real containers

const isIntegrationTest = process.env.RUN_INTEGRATION_TESTS === "1";

if (isIntegrationTest) {

console.log("[test-preload] Integration test mode: skipping all mocks");

}

// =============================================================================

// PostgreSQL Mocks (for Observatory OAuth tests)

// =============================================================================

// Mock pg Pool for ESM compatibility

// The pg package doesn't export Pool from its ESM entry point, so we mock it here

const mockPgQuery = mock(async () => ({ rows: [] }));

if (!isIntegrationTest) {

mock.module("pg", () => ({

Pool: class MockPool {

query = mockPgQuery;

},

default: {

Pool: class MockPool {

query = mockPgQuery;

},

},

}));

}

// =============================================================================

// FalkorDB Mocks

// =============================================================================

const mockQuery = mock(async () => []);

const mockConnect = mock(async () => {});

const mockIsConnected = mock(() => false);

const mockDisconnect = mock(async () => {});

const mockFalkorClient = {

query: mockQuery,

connect: mockConnect,

isConnected: mockIsConnected,

disconnect: mockDisconnect,

};

// Mock FalkorClient class that implements GraphClient interface

class MockFalkorClient {

query = mockQuery;

connect = mockConnect;

isConnected = mockIsConnected;

disconnect = mockDisconnect;

}

// Mock TenantAwareFalkorClient

const mockSelectTenantGraph = mock(async () => ({

query: mockQuery,

}));

const mockEnsureTenantGraph = mock(async () => ({

query: mockQuery,

}));

class MockTenantAwareFalkorClient {

selectTenantGraph = mockSelectTenantGraph;

ensureTenantGraph = mockEnsureTenantGraph;

}

// Create singleton factory mocks that ALWAYS return the same object

const createFalkorClientMock = Object.assign(() => mockFalkorClient, {

mock: { calls: [] as unknown[][] },

mockClear: () => {

createFalkorClientMock.mock.calls = [];

},

});

if (!isIntegrationTest) {

mock.module("@engram/storage/falkor", () => ({

createFalkorClient: createFalkorClientMock,

FalkorClient: MockFalkorClient,

TenantAwareFalkorClient: MockTenantAwareFalkorClient,

}));

}

// Also mock blob store

const mockBlobStore = {

save: mock(async () => "blob://test"),

load: mock(async () => Buffer.from("{}")),

exists: mock(async () => false),

};

// Create a mock NATS client for @engram/storage

const mockNatsClientInstance = {

getConsumer: mock(async () => ({

subscribe: mock(async () => {}),

run: mock(async () => {}),

disconnect: mock(async () => {}),

})),

getProducer: mock(async () => ({

send: mock(async () => {}),

disconnect: mock(async () => {}),

})),

sendEvent: mock(async () => {}),

connect: mock(async () => {}),

disconnect: mock(async () => {}),

};

// Mock NatsClient class

class MockNatsClient {

getConsumer = mock(async () => ({

subscribe: mock(async () => {}),

run: mock(async () => {}),

disconnect: mock(async () => {}),

}));

getProducer = mock(async () => ({

send: mock(async () => {}),

disconnect: mock(async () => {}),

}));

sendEvent = mock(async () => {});

connect = mock(async () => {});

disconnect = mock(async () => {});

}

// Create singleton factory mocks for main @engram/storage entry point

const createNatsClientMock = Object.assign(() => mockNatsClientInstance, {

mock: { calls: [] as unknown[][] },

mockClear: () => {

createNatsClientMock.mock.calls = [];

},

});

const createBlobStoreMock = Object.assign(() => mockBlobStore, {

mock: { calls: [] as unknown[][] },

mockClear: () => {

createBlobStoreMock.mock.calls = [];

},

});

// Mock the main @engram/storage entry point (re-exports)

if (!isIntegrationTest) {

mock.module("@engram/storage", () => ({

createFalkorClient: createFalkorClientMock,

FalkorClient: MockFalkorClient,

TenantAwareFalkorClient: MockTenantAwareFalkorClient,

createBlobStore: createBlobStoreMock,

createNatsClient: createNatsClientMock,

NatsClient: MockNatsClient,

}));

}

// =============================================================================

// NATS Mocks

// =============================================================================

const mockSubscribe = mock(async (_channel: string, _callback: (data: unknown) => void) => {

return mock(); // Returns unsubscribe function

});

const mockSubscribeToConsumerStatus = mock(async (_callback: (data: unknown) => void) => {

return mock(); // Returns unsubscribe function

});

const mockNatsConnect = mock(async () => {});

const mockNatsDisconnect = mock(async () => {});

const mockNatsPubSubSubscriber = {

connect: mockNatsConnect,

subscribe: mockSubscribe,

subscribeToConsumerStatus: mockSubscribeToConsumerStatus,

disconnect: mockNatsDisconnect,

};

if (!isIntegrationTest) {

mock.module("@engram/storage/nats", () => ({

createNatsPubSubSubscriber: mock(() => mockNatsPubSubSubscriber),

createNatsPubSubPublisher: mock(() => ({

connect: mock(async () => {}),

publishSessionUpdate: mock(async () => {}),

publishGlobalSessionEvent: mock(async () => {}),

publishConsumerStatus: mock(async () => {}),

disconnect: mock(async () => {}),

})),

createNatsClient: mock(() => mockNatsClientInstance),

NatsClient: MockNatsClient,

}));

}

// =============================================================================

// Logger Mocks

// =============================================================================

const mockLoggerInfo = mock();

const mockLoggerWarn = mock();

const mockLoggerError = mock();

const mockLoggerDebug = mock();

const mockLoggerTrace = mock();

const mockLoggerFatal = mock();

const mockLogger = {

info: mockLoggerInfo,

warn: mockLoggerWarn,

error: mockLoggerError,

debug: mockLoggerDebug,

trace: mockLoggerTrace,

fatal: mockLoggerFatal,

};

if (!isIntegrationTest) {

mock.module("@engram/logger", () => ({

createNodeLogger: mock(() => mockLogger),

pino: {

destination: mock((_fd: number) => ({ write: mock() })),

},

withTraceContext: mock((logger: unknown, _context: unknown) => logger),

}));

}

// =============================================================================

// Observatory Path Alias Mocks (@lib/* -> ./lib/*)

// =============================================================================

// Mock @lib/device-auth to prevent module resolution errors in bun test

// This is needed because bun doesn't resolve Next.js path aliases

if (!isIntegrationTest) {

mock.module("@lib/device-auth", () => ({

generateDeviceCode: mock(() => "test-device-code"),

generateUserCode: mock(() => "ABCD-EFGH"),

generateAccessToken: mock(() => "egm_oauth_test_token"),

generateRefreshToken: mock(() => "egm_refresh_test_token"),

generateClientToken: mock(async () => ({

accessToken: "egm_client_test_token",

expiresIn: 3600,

tokenType: "DPoP",

scope: "memory:read",

})),

hashToken: mock((token: string) => `hashed_${token}`),

validateTokenChecksum: mock(() => true),

normalizeUserCode: mock((code: string) => code.toUpperCase().replace(/-/g, "")),

createDeviceCode: mock(async () => ({})),

findDeviceCodeByUserCode: mock(async () => null),

findDeviceCode: mock(async () => null),

authorizeDeviceCode: mock(async () => true),

denyDeviceCode: mock(async () => true),

updatePollTimestamp: mock(async () => ({ shouldSlowDown: false })),

pollForToken: mock(async () => ({})),

issueTokens: mock(async () => ({})),

refreshAccessToken: mock(async () => ({})),

validateAccessToken: mock(async () => null),

revokeToken: mock(async () => true),

listUserTokens: mock(async () => []),

computeTokenChecksum: mock(() => "abc123"),

}));

// Mock @lib/dpop for DPoP proof validation

mock.module("@lib/dpop", () => ({

validateDPoPProof: mock(async () => ({ valid: true, jwkThumbprint: "test-thumbprint" })),

createDPoPProof: mock(async () => "test-dpop-jwt"),

}));

// Mock @lib/client-registration for client validation

mock.module("@lib/client-registration", () => ({

validateClientCredentials: mock(async () => ({

valid: false,

error: "Client not found",

})),

registerClient: mock(async () => ({})),

getClient: mock(async () => null),

}));

}

// =============================================================================

// Export mocks for test files to access

// =============================================================================

declare global {

var __testMocks: {

pg: {

query: typeof mockPgQuery;

};

falkor: {

client: typeof mockFalkorClient;

query: typeof mockQuery;

connect: typeof mockConnect;

isConnected: typeof mockIsConnected;

disconnect: typeof mockDisconnect;

};

nats: {

subscriber: typeof mockNatsPubSubSubscriber;

subscribe: typeof mockSubscribe;

subscribeToConsumerStatus: typeof mockSubscribeToConsumerStatus;

connect: typeof mockNatsConnect;

disconnect: typeof mockNatsDisconnect;

};

logger: {

instance: typeof mockLogger;

info: typeof mockLoggerInfo;

warn: typeof mockLoggerWarn;

error: typeof mockLoggerError;

debug: typeof mockLoggerDebug;

trace: typeof mockLoggerTrace;

fatal: typeof mockLoggerFatal;

};

};

}

globalThis.__testMocks = {

pg: {

query: mockPgQuery,

},

falkor: {

client: mockFalkorClient,

query: mockQuery,

connect: mockConnect,

isConnected: mockIsConnected,

disconnect: mockDisconnect,

},

nats: {

subscriber: mockNatsPubSubSubscriber,

subscribe: mockSubscribe,

subscribeToConsumerStatus: mockSubscribeToConsumerStatus,

connect: mockNatsConnect,

disconnect: mockNatsDisconnect,

},

logger: {

instance: mockLogger,

info: mockLoggerInfo,

warn: mockLoggerWarn,

error: mockLoggerError,

debug: mockLoggerDebug,

trace: mockLoggerTrace,

fatal: mockLoggerFatal,

},

};