@friggframework/test 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.dba001a.0

package/index.js

@@ -5,7 +5,22 @@ const {
 } = require('./override-environment');
 const globalTeardown = require('./jest-global-teardown');
 const globalSetup = require('./jest-global-setup');
-const Authenticator = require('./Authenticator')
+const Authenticator = require('./Authenticator');
+
+// Router test utilities are loaded lazily to avoid jest.fn() errors during
+// global setup (when Jest globals aren't available yet)
+let _routerTestUtils = null;
+
+/**
+ * Lazily load router test utilities (only when called from test context)
+ * @returns {Object} Router test utilities
+ */
+const getRouterTestUtils = () => {
+    if (!_routerTestUtils) {
+        _routerTestUtils = require('./router-test-utils');
+    }
+    return _routerTestUtils;
+};
 
 module.exports = {
     TestMongo,
@@ -13,5 +28,8 @@ module.exports = {
     restoreEnvironment,
     globalTeardown,
     globalSetup,
-    Authenticator
+    Authenticator,
+    // Router test utilities - use getRouterTestUtils() for lazy loading
+    getRouterTestUtils,
+    // Direct import path is available: require('@friggframework/test/router-test-utils')
 };

package/jest-global-setup.js

@@ -1,10 +1,20 @@
 const { TestMongo } = require('./mongodb');
-const {overrideEnvironment} = require('./override-environment');
+const { overrideEnvironment } = require('./override-environment');
 
 module.exports = async function () {
     if (!process.env.STAGE) {
         overrideEnvironment({ STAGE: 'dev' });
     }
-    global.testMongo = new TestMongo();
-    await global.testMongo.start();
+
+    // Only start MongoDB for integration tests
+    // Unit tests should not depend on MongoDB
+    const isIntegrationTest =
+        process.argv.includes('--group=integration') || process.env.TEST_TYPE === 'integration';
+
+    if (isIntegrationTest || (!process.argv.includes('--group=unit') && !process.env.TEST_TYPE)) {
+        global.testMongo = new TestMongo();
+        await global.testMongo.start();
+    } else {
+        console.log('Skipping MongoDB setup for unit tests');
+    }
 };

package/jest-global-teardown.js

@@ -1,5 +1,10 @@
-const { restoreEnvironment } = require('./override-environment')
+const { restoreEnvironment } = require('./override-environment');
+
 module.exports = async function () {
     restoreEnvironment();
-    await global.testMongo.stop();
+
+    // Only stop MongoDB if it was started
+    if (global.testMongo) {
+        await global.testMongo.stop();
+    }
 };

package/package.json

@@ -1,24 +1,35 @@
 {
   "name": "@friggframework/test",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.548.c8ae0ca.0",
+  "version": "2.0.0--canary.545.dba001a.0",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
+    "@hapi/boom": "^10.0.1",
     "eslint": "^8.22.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-json": "^3.1.0",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-no-only-tests": "^3.0.0",
     "eslint-plugin-yaml": "^0.5.0",
+    "express": "^4.21.2",
     "jest-runner-groups": "^2.2.0",
     "mongodb-memory-server": "^8.9.0",
     "open": "^8.4.2"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.548.c8ae0ca.0",
-    "@friggframework/prettier-config": "2.0.0--canary.548.c8ae0ca.0",
+    "@friggframework/eslint-config": "2.0.0--canary.545.dba001a.0",
+    "@friggframework/prettier-config": "2.0.0--canary.545.dba001a.0",
     "jest": "^29.7.0",
-    "prettier": "^2.7.1"
+    "prettier": "^2.7.1",
+    "supertest": "^7.2.2"
+  },
+  "peerDependencies": {
+    "supertest": ">=7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "supertest": {
+      "optional": true
+    }
   },
   "scripts": {
     "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
@@ -39,5 +50,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c8ae0ca7837ba8393e3617be15c941607627c16b"
+  "gitHead": "dba001affb699d55b0684fa236af8a5f67ddf852"
 }

package/router-test-utils/index.js

@@ -0,0 +1,535 @@
+/**
+ * @file Router Test Utilities
+ * @description Shared test utilities for Express router testing in Frigg Framework
+ *
+ * These utilities reduce boilerplate and ensure consistency across router tests.
+ * Use these helpers to:
+ * - Create mock repositories with standard interfaces
+ * - Set up Express apps with authentication middleware
+ * - Handle Boom errors properly in test environments
+ * - Generate consistent test data
+ *
+ * @example
+ * const { createTestApp, createMockRepositories, mockData } = require('@friggframework/test/router-test-utils');
+ *
+ * describe('My Router', () => {
+ *     let app, mocks;
+ *
+ *     beforeEach(() => {
+ *         mocks = createMockRepositories();
+ *         app = createTestApp({ router: myRouter, mocks });
+ *     });
+ * });
+ */
+
+const express = require('express');
+const Boom = require('@hapi/boom');
+
+// ============================================================================
+// Mock Data Generators
+// ============================================================================
+
+/**
+ * Helper to safely get jest.fn() - returns a real mock in test context, noop otherwise
+ * @returns {Function} Jest mock function or noop
+ */
+const createMockFn = (implementation) => {
+    if (typeof jest !== 'undefined' && jest.fn) {
+        return implementation ? jest.fn(implementation) : jest.fn();
+    }
+    // Return a noop function with mock properties for non-Jest environments
+    const fn = implementation || (() => {});
+    fn.mockReturnValue = (val) => {
+        fn._mockReturnValue = val;
+        return fn;
+    };
+    fn.mockResolvedValue = (val) => {
+        fn._mockResolvedValue = val;
+        return fn;
+    };
+    fn.mockImplementation = (impl) => {
+        fn._mockImplementation = impl;
+        return fn;
+    };
+    return fn;
+};
+
+/**
+ * Default mock user object
+ * @type {Object}
+ */
+const createMockUser = (overrides = {}) => ({
+    id: 'user-123',
+    appUserId: 'app-user-123',
+    username: 'testuser',
+    email: 'test@example.com',
+    getId: createMockFn(() => overrides.id || 'user-123'),
+    ...overrides,
+});
+
+/**
+ * Default mock credential object
+ * @type {Object}
+ */
+const createMockCredential = (overrides = {}) => ({
+    id: 'cred-123',
+    type: 'hubspot',
+    userId: 'user-123',
+    authIsValid: true,
+    status: 'AUTHORIZED',
+    externalId: 'ext-123',
+    entityCount: 2,
+    createdAt: '2025-01-25T10:00:00.000Z',
+    updatedAt: '2025-01-25T10:00:00.000Z',
+    data: {
+        access_token: 'test-access-token',
+        refresh_token: 'test-refresh-token',
+    },
+    ...overrides,
+});
+
+/**
+ * Default mock entity object
+ * @type {Object}
+ */
+const createMockEntity = (overrides = {}) => ({
+    id: 'entity-123',
+    entityType: 'ACCOUNT',
+    credential: 'cred-123',
+    credentialId: 'cred-123',
+    userId: 'user-123',
+    externalId: 'ext-account-123',
+    name: 'Test Account',
+    authIsValid: true,
+    type: 'hubspot',
+    ...overrides,
+});
+
+/**
+ * Default mock integration object
+ * @type {Object}
+ */
+const createMockIntegration = (overrides = {}) => ({
+    id: 'integration-123',
+    name: 'Test Integration',
+    userId: 'user-123',
+    config: {},
+    entities: ['entity-123'],
+    createdAt: '2025-01-25T10:00:00.000Z',
+    updatedAt: '2025-01-25T10:00:00.000Z',
+    ...overrides,
+});
+
+/**
+ * Default mock module definition object
+ * @type {Object}
+ */
+const createMockModuleDefinition = (overrides = {}) => {
+    const defaults = {
+        moduleName: 'hubspot',
+        definition: {
+            getDisplayName: () => overrides.displayName || 'HubSpot',
+            getDescription: () => overrides.description || 'Connect to HubSpot CRM',
+            getAuthType: () => overrides.authType || 'oauth2',
+            getAuthStepCount: () => overrides.stepCount || 1,
+            getCapabilities: () => overrides.capabilities || ['contacts', 'companies', 'deals'],
+            getAuthRequirementsForStep: jest.fn().mockResolvedValue({
+                type: overrides.authType || 'oauth2',
+                data: {
+                    url: 'https://app.hubspot.com/oauth/authorize?client_id=test',
+                    scopes: ['crm.objects.contacts.read', 'crm.objects.companies.read'],
+                },
+            }),
+            processAuthorizationStep: jest.fn(),
+        },
+        apiClass: jest.fn(),
+    };
+
+    return {
+        ...defaults,
+        ...overrides,
+        definition: {
+            ...defaults.definition,
+            ...(overrides.definition || {}),
+        },
+    };
+};
+
+/**
+ * Collection of mock data generators
+ */
+const mockData = {
+    createMockUser,
+    createMockCredential,
+    createMockEntity,
+    createMockIntegration,
+    createMockModuleDefinition,
+
+    // Pre-created instances for quick use
+    user: createMockUser(),
+    credential: createMockCredential(),
+    entity: createMockEntity(),
+    integration: createMockIntegration(),
+};
+
+// ============================================================================
+// Mock Repository Factories
+// ============================================================================
+
+/**
+ * Create a mock user repository with standard interface
+ * @param {Object} overrides - Method overrides
+ * @returns {Object} Mock user repository
+ */
+const createMockUserRepository = (overrides = {}) => ({
+    findById: jest.fn().mockResolvedValue(mockData.user),
+    findOne: jest.fn().mockResolvedValue(mockData.user),
+    findByToken: jest.fn().mockResolvedValue(mockData.user),
+    getSessionToken: jest.fn().mockResolvedValue({ user: 'user-123', token: 'valid-token' }),
+    findIndividualUserById: jest.fn().mockResolvedValue(mockData.user),
+    findOrganizationUserById: jest.fn().mockResolvedValue(null),
+    findByEmail: jest.fn().mockResolvedValue(mockData.user),
+    findUserById: jest.fn().mockResolvedValue(mockData.user),
+    save: jest.fn(),
+    update: jest.fn(),
+    ...overrides,
+});
+
+/**
+ * Create a mock credential repository with standard interface
+ * @param {Object} overrides - Method overrides
+ * @returns {Object} Mock credential repository
+ */
+const createMockCredentialRepository = (overrides = {}) => ({
+    findById: jest.fn(),
+    findByIdForUser: jest.fn(),
+    findCredential: jest.fn().mockResolvedValue([]),
+    findCredentialById: jest.fn(),
+    save: jest.fn(),
+    update: jest.fn(),
+    updateCredential: jest.fn(),
+    deleteCredentialById: jest.fn().mockResolvedValue({ deletedCount: 1 }),
+    ...overrides,
+});
+
+/**
+ * Create a mock module repository with standard interface
+ * @param {Object} overrides - Method overrides
+ * @returns {Object} Mock module repository
+ */
+const createMockModuleRepository = (overrides = {}) => ({
+    findById: jest.fn(),
+    findByIdForUser: jest.fn(),
+    findByUserId: jest.fn().mockResolvedValue([]),
+    findByUserIdAndType: jest.fn(),
+    findModuleById: jest.fn(),
+    save: jest.fn(),
+    update: jest.fn(),
+    ...overrides,
+});
+
+/**
+ * Create a mock integration repository with standard interface
+ * @param {Object} overrides - Method overrides
+ * @returns {Object} Mock integration repository
+ */
+const createMockIntegrationRepository = (overrides = {}) => ({
+    findById: jest.fn(),
+    findByIdForUser: jest.fn(),
+    findByUserId: jest.fn().mockResolvedValue([]),
+    save: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+    ...overrides,
+});
+
+/**
+ * Create a mock authorization session repository
+ * @param {Object} overrides - Method overrides
+ * @returns {Object} Mock authorization session repository
+ */
+const createMockAuthorizationSessionRepository = (overrides = {}) => ({
+    findBySessionId: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+    ...overrides,
+});
+
+/**
+ * Create all mock repositories at once
+ * @param {Object} overrides - Per-repository overrides
+ * @returns {Object} All mock repositories
+ */
+const createMockRepositories = (overrides = {}) => ({
+    userRepository: createMockUserRepository(overrides.user),
+    credentialRepository: createMockCredentialRepository(overrides.credential),
+    moduleRepository: createMockModuleRepository(overrides.module),
+    integrationRepository: createMockIntegrationRepository(overrides.integration),
+    authorizationSessionRepository: createMockAuthorizationSessionRepository(overrides.authorizationSession),
+});
+
+// ============================================================================
+// Mock API Requester
+// ============================================================================
+
+/**
+ * Create a mock API requester for proxy tests
+ * @param {Object} overrides - Method overrides
+ * @returns {Object} Mock API requester
+ */
+const createMockApiRequester = (overrides = {}) => ({
+    request: jest.fn().mockResolvedValue({
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+        data: { success: true },
+    }),
+    _get: jest.fn(),
+    _post: jest.fn(),
+    _put: jest.fn(),
+    _patch: jest.fn(),
+    _delete: jest.fn(),
+    addAuthHeaders: jest.fn().mockResolvedValue({}),
+    ...overrides,
+});
+
+/**
+ * Create a mock module factory
+ * @param {Object} apiRequester - Mock API requester to use
+ * @returns {Object} Mock module factory
+ */
+const createMockModuleFactory = (apiRequester = createMockApiRequester()) => ({
+    getModuleInstance: jest.fn().mockResolvedValue({
+        api: apiRequester,
+    }),
+});
+
+// ============================================================================
+// Express App Setup
+// ============================================================================
+
+/**
+ * Boom error handler middleware for Express
+ * Converts Boom errors to proper HTTP responses
+ * @param {Error} err - Error object
+ * @param {Object} req - Express request
+ * @param {Object} res - Express response
+ * @param {Function} next - Next middleware
+ */
+const boomErrorHandler = (err, req, res, next) => {
+    if (Boom.isBoom(err)) {
+        const { statusCode, payload } = err.output;
+        return res.status(statusCode).json({
+            error: payload.message,
+            message: payload.message,
+            statusCode: payload.statusCode,
+            ...err.data,
+        });
+    }
+
+    // Handle non-Boom errors
+    console.error('Unhandled error:', err);
+    return res.status(500).json({
+        error: 'Internal Server Error',
+        message: err.message,
+        statusCode: 500,
+    });
+};
+
+/**
+ * Create authentication middleware for testing
+ * @param {Object} options - Configuration options
+ * @param {Object} options.mockUser - User to inject on successful auth
+ * @param {string} options.validToken - Token that will be considered valid (default: 'valid-token')
+ * @returns {Function} Express middleware
+ */
+const createAuthMiddleware = ({ mockUser = mockData.user, validToken = 'valid-token' } = {}) => {
+    return (req, res, next) => {
+        const authHeader = req.headers.authorization;
+
+        if (!authHeader) {
+            return next(Boom.unauthorized('No authentication provided'));
+        }
+
+        const token = authHeader.replace('Bearer ', '');
+
+        if (token === validToken) {
+            req.user = mockUser;
+            return next();
+        }
+
+        return next(Boom.unauthorized('Invalid token'));
+    };
+};
+
+/**
+ * Create a test Express app with common configuration
+ * @param {Object} options - Configuration options
+ * @param {Object} options.router - Express router to mount
+ * @param {string} options.basePath - Base path for router (default: '/')
+ * @param {Object} options.mockUser - User to inject on auth (default: mockData.user)
+ * @param {boolean} options.useAuth - Whether to use auth middleware (default: true)
+ * @param {string} options.validToken - Valid token string (default: 'valid-token')
+ * @returns {Object} Express app instance
+ */
+const createTestApp = ({
+    router,
+    basePath = '/',
+    mockUser = mockData.user,
+    useAuth = true,
+    validToken = 'valid-token',
+} = {}) => {
+    const app = express();
+    app.use(express.json());
+
+    if (useAuth) {
+        app.use(createAuthMiddleware({ mockUser, validToken }));
+    }
+
+    if (router) {
+        app.use(basePath, router);
+    }
+
+    // Add Boom error handler (must be after routes)
+    app.use(boomErrorHandler);
+
+    return app;
+};
+
+// ============================================================================
+// Database Config Mock
+// ============================================================================
+
+/**
+ * Standard database config mock object
+ * Use this to mock '../database/config' in tests
+ */
+const databaseConfigMock = {
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+};
+
+// ============================================================================
+// App Definition Mock
+// ============================================================================
+
+/**
+ * Create a mock app definition
+ * @param {Object} overrides - Override specific properties
+ * @returns {Object} Mock app definition
+ */
+const createMockAppDefinition = (overrides = {}) => ({
+    integrations: overrides.integrations || [
+        createMockModuleDefinition({ moduleName: 'hubspot' }),
+        createMockModuleDefinition({
+            moduleName: 'salesforce',
+            displayName: 'Salesforce',
+            description: 'Connect to Salesforce CRM',
+            capabilities: ['accounts', 'contacts', 'opportunities'],
+        }),
+    ],
+    userConfig: {
+        usePassword: true,
+        primary: 'individual',
+        authModes: {
+            friggToken: true,
+        },
+        ...(overrides.userConfig || {}),
+    },
+    ...overrides,
+});
+
+// ============================================================================
+// Test Helpers
+// ============================================================================
+
+/**
+ * Helper to make authenticated requests
+ * @param {Object} app - Express app
+ * @param {string} token - Auth token (default: 'valid-token')
+ * @returns {Object} Supertest agent with auth header set
+ */
+const authenticatedRequest = (request, token = 'valid-token') => {
+    return {
+        get: (url) => request.get(url).set('Authorization', `Bearer ${token}`),
+        post: (url) => request.post(url).set('Authorization', `Bearer ${token}`),
+        put: (url) => request.put(url).set('Authorization', `Bearer ${token}`),
+        patch: (url) => request.patch(url).set('Authorization', `Bearer ${token}`),
+        delete: (url) => request.delete(url).set('Authorization', `Bearer ${token}`),
+    };
+};
+
+/**
+ * Setup common jest mocks for repository factories
+ * Call this at the top of your test file after imports
+ * @param {Object} factoryMocks - Map of factory name to mock repository
+ */
+const setupRepositoryFactoryMocks = ({
+    createUserRepository,
+    createCredentialRepository,
+    createModuleRepository,
+    createIntegrationRepository,
+    createAuthorizationSessionRepository,
+    loadAppDefinition,
+    mocks,
+}) => {
+    if (createUserRepository && mocks.userRepository) {
+        createUserRepository.mockReturnValue(mocks.userRepository);
+    }
+    if (createCredentialRepository && mocks.credentialRepository) {
+        createCredentialRepository.mockReturnValue(mocks.credentialRepository);
+    }
+    if (createModuleRepository && mocks.moduleRepository) {
+        createModuleRepository.mockReturnValue(mocks.moduleRepository);
+    }
+    if (createIntegrationRepository && mocks.integrationRepository) {
+        createIntegrationRepository.mockReturnValue(mocks.integrationRepository);
+    }
+    if (createAuthorizationSessionRepository && mocks.authorizationSessionRepository) {
+        createAuthorizationSessionRepository.mockReturnValue(mocks.authorizationSessionRepository);
+    }
+    if (loadAppDefinition) {
+        loadAppDefinition.mockReturnValue(createMockAppDefinition());
+    }
+};
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+module.exports = {
+    // Mock data generators
+    mockData,
+    createMockUser,
+    createMockCredential,
+    createMockEntity,
+    createMockIntegration,
+    createMockModuleDefinition,
+
+    // Repository mocks
+    createMockUserRepository,
+    createMockCredentialRepository,
+    createMockModuleRepository,
+    createMockIntegrationRepository,
+    createMockAuthorizationSessionRepository,
+    createMockRepositories,
+
+    // API/Factory mocks
+    createMockApiRequester,
+    createMockModuleFactory,
+
+    // Express app utilities
+    createTestApp,
+    createAuthMiddleware,
+    boomErrorHandler,
+
+    // Config mocks
+    databaseConfigMock,
+    createMockAppDefinition,
+
+    // Test helpers
+    authenticatedRequest,
+    setupRepositoryFactoryMocks,
+};

package/router-test-utils/index.test.js

@@ -0,0 +1,350 @@
+/**
+ * @file Router Test Utilities - Unit Tests
+ * @description Tests for the shared router test utilities
+ */
+
+const request = require('supertest');
+const express = require('express');
+const Boom = require('@hapi/boom');
+
+const {
+    // Mock data generators
+    mockData,
+    createMockUser,
+    createMockCredential,
+    createMockEntity,
+    createMockIntegration,
+    createMockModuleDefinition,
+
+    // Repository mocks
+    createMockUserRepository,
+    createMockCredentialRepository,
+    createMockModuleRepository,
+    createMockIntegrationRepository,
+    createMockAuthorizationSessionRepository,
+    createMockRepositories,
+
+    // API/Factory mocks
+    createMockApiRequester,
+    createMockModuleFactory,
+
+    // Express app utilities
+    createTestApp,
+    createAuthMiddleware,
+    boomErrorHandler,
+
+    // Config mocks
+    databaseConfigMock,
+    createMockAppDefinition,
+} = require('./index');
+
+describe('Router Test Utilities', () => {
+    describe('Mock Data Generators', () => {
+        describe('createMockUser', () => {
+            it('should create user with default values', () => {
+                const user = createMockUser();
+                expect(user.id).toBe('user-123');
+                expect(user.username).toBe('testuser');
+                expect(user.email).toBe('test@example.com');
+            });
+
+            it('should allow overriding values', () => {
+                const user = createMockUser({ id: 'custom-id', username: 'custom' });
+                expect(user.id).toBe('custom-id');
+                expect(user.username).toBe('custom');
+                expect(user.email).toBe('test@example.com'); // Default preserved
+            });
+
+            it('should include getId function', () => {
+                const user = createMockUser({ id: 'test-id' });
+                expect(user.getId()).toBe('test-id');
+            });
+        });
+
+        describe('createMockCredential', () => {
+            it('should create credential with default values', () => {
+                const cred = createMockCredential();
+                expect(cred.id).toBe('cred-123');
+                expect(cred.type).toBe('hubspot');
+                expect(cred.authIsValid).toBe(true);
+                expect(cred.data.access_token).toBeDefined();
+            });
+
+            it('should allow overriding values', () => {
+                const cred = createMockCredential({ type: 'salesforce', authIsValid: false });
+                expect(cred.type).toBe('salesforce');
+                expect(cred.authIsValid).toBe(false);
+            });
+        });
+
+        describe('createMockEntity', () => {
+            it('should create entity with default values', () => {
+                const entity = createMockEntity();
+                expect(entity.id).toBe('entity-123');
+                expect(entity.userId).toBe('user-123');
+                expect(entity.credentialId).toBe('cred-123');
+            });
+        });
+
+        describe('createMockIntegration', () => {
+            it('should create integration with default values', () => {
+                const integration = createMockIntegration();
+                expect(integration.id).toBe('integration-123');
+                expect(integration.userId).toBe('user-123');
+            });
+        });
+
+        describe('createMockModuleDefinition', () => {
+            it('should create module definition with default values', () => {
+                const def = createMockModuleDefinition();
+                expect(def.moduleName).toBe('hubspot');
+                expect(def.definition.getDisplayName()).toBe('HubSpot');
+                expect(def.definition.getAuthType()).toBe('oauth2');
+            });
+
+            it('should allow customization', () => {
+                const def = createMockModuleDefinition({
+                    moduleName: 'custom',
+                    displayName: 'Custom Service',
+                    authType: 'api-key',
+                });
+                expect(def.moduleName).toBe('custom');
+                expect(def.definition.getDisplayName()).toBe('Custom Service');
+                expect(def.definition.getAuthType()).toBe('api-key');
+            });
+        });
+
+        describe('mockData convenience object', () => {
+            it('should provide pre-created instances', () => {
+                expect(mockData.user).toBeDefined();
+                expect(mockData.credential).toBeDefined();
+                expect(mockData.entity).toBeDefined();
+                expect(mockData.integration).toBeDefined();
+            });
+        });
+    });
+
+    describe('Mock Repository Factories', () => {
+        describe('createMockUserRepository', () => {
+            it('should create repository with all methods', () => {
+                const repo = createMockUserRepository();
+                expect(repo.findById).toBeDefined();
+                expect(repo.findByToken).toBeDefined();
+                expect(repo.getSessionToken).toBeDefined();
+                expect(repo.findIndividualUserById).toBeDefined();
+            });
+
+            it('should have working mock implementations', async () => {
+                const repo = createMockUserRepository();
+                const user = await repo.findById('test');
+                expect(user.id).toBe('user-123');
+            });
+        });
+
+        describe('createMockCredentialRepository', () => {
+            it('should create repository with all methods', () => {
+                const repo = createMockCredentialRepository();
+                expect(repo.findById).toBeDefined();
+                expect(repo.findCredential).toBeDefined();
+                expect(repo.deleteCredentialById).toBeDefined();
+            });
+        });
+
+        describe('createMockRepositories', () => {
+            it('should create all repositories at once', () => {
+                const repos = createMockRepositories();
+                expect(repos.userRepository).toBeDefined();
+                expect(repos.credentialRepository).toBeDefined();
+                expect(repos.moduleRepository).toBeDefined();
+                expect(repos.integrationRepository).toBeDefined();
+                expect(repos.authorizationSessionRepository).toBeDefined();
+            });
+        });
+    });
+
+    describe('Mock API/Factory Utilities', () => {
+        describe('createMockApiRequester', () => {
+            it('should create API requester with all methods', () => {
+                const api = createMockApiRequester();
+                expect(api.request).toBeDefined();
+                expect(api._get).toBeDefined();
+                expect(api._post).toBeDefined();
+            });
+
+            it('should have working request mock', async () => {
+                const api = createMockApiRequester();
+                const response = await api.request({ method: 'GET', path: '/test' });
+                expect(response.status).toBe(200);
+                expect(response.data.success).toBe(true);
+            });
+        });
+
+        describe('createMockModuleFactory', () => {
+            it('should create factory with getModuleInstance', () => {
+                const factory = createMockModuleFactory();
+                expect(factory.getModuleInstance).toBeDefined();
+            });
+
+            it('should return module with api property', async () => {
+                const factory = createMockModuleFactory();
+                const instance = await factory.getModuleInstance('entity-123', 'user-123');
+                expect(instance.api).toBeDefined();
+                expect(instance.api.request).toBeDefined();
+            });
+        });
+    });
+
+    describe('Express App Utilities', () => {
+        describe('boomErrorHandler', () => {
+            it('should handle Boom errors', async () => {
+                const app = express();
+                app.get('/error', (req, res, next) => {
+                    next(Boom.notFound('Resource not found'));
+                });
+                app.use(boomErrorHandler);
+
+                const response = await request(app).get('/error');
+                expect(response.status).toBe(404);
+                expect(response.body.error).toBe('Resource not found');
+            });
+
+            it('should handle non-Boom errors', async () => {
+                const app = express();
+                app.get('/error', () => {
+                    throw new Error('Something went wrong');
+                });
+                app.use(boomErrorHandler);
+
+                const response = await request(app).get('/error');
+                expect(response.status).toBe(500);
+                expect(response.body.error).toBe('Internal Server Error');
+            });
+        });
+
+        describe('createAuthMiddleware', () => {
+            it('should authenticate valid token', async () => {
+                const app = express();
+                app.use(createAuthMiddleware());
+                app.get('/test', (req, res) => res.json({ user: req.user }));
+                app.use(boomErrorHandler);
+
+                const response = await request(app)
+                    .get('/test')
+                    .set('Authorization', 'Bearer valid-token');
+
+                expect(response.status).toBe(200);
+                expect(response.body.user.id).toBe('user-123');
+            });
+
+            it('should reject missing token', async () => {
+                const app = express();
+                app.use(createAuthMiddleware());
+                app.get('/test', (req, res) => res.json({ user: req.user }));
+                app.use(boomErrorHandler);
+
+                const response = await request(app).get('/test');
+                expect(response.status).toBe(401);
+            });
+
+            it('should reject invalid token', async () => {
+                const app = express();
+                app.use(createAuthMiddleware());
+                app.get('/test', (req, res) => res.json({ user: req.user }));
+                app.use(boomErrorHandler);
+
+                const response = await request(app)
+                    .get('/test')
+                    .set('Authorization', 'Bearer invalid-token');
+
+                expect(response.status).toBe(401);
+            });
+
+            it('should use custom valid token', async () => {
+                const app = express();
+                app.use(createAuthMiddleware({ validToken: 'custom-token' }));
+                app.get('/test', (req, res) => res.json({ user: req.user }));
+                app.use(boomErrorHandler);
+
+                const response = await request(app)
+                    .get('/test')
+                    .set('Authorization', 'Bearer custom-token');
+
+                expect(response.status).toBe(200);
+            });
+        });
+
+        describe('createTestApp', () => {
+            it('should create app with JSON parsing', async () => {
+                const router = express.Router();
+                router.post('/test', (req, res) => res.json(req.body));
+
+                const app = createTestApp({ router, useAuth: false });
+
+                const response = await request(app)
+                    .post('/test')
+                    .send({ data: 'test' });
+
+                expect(response.status).toBe(200);
+                expect(response.body.data).toBe('test');
+            });
+
+            it('should include auth middleware by default', async () => {
+                const router = express.Router();
+                router.get('/test', (req, res) => res.json({ ok: true }));
+
+                const app = createTestApp({ router });
+
+                const response = await request(app).get('/test');
+                expect(response.status).toBe(401);
+            });
+
+            it('should mount router at custom base path', async () => {
+                const router = express.Router();
+                router.get('/resource', (req, res) => res.json({ ok: true }));
+
+                const app = createTestApp({ router, basePath: '/api', useAuth: false });
+
+                const response = await request(app).get('/api/resource');
+                expect(response.status).toBe(200);
+            });
+
+            it('should include Boom error handler', async () => {
+                const router = express.Router();
+                router.get('/error', (req, res, next) => {
+                    next(Boom.badRequest('Invalid input'));
+                });
+
+                const app = createTestApp({ router, useAuth: false });
+
+                const response = await request(app).get('/error');
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('Invalid input');
+            });
+        });
+    });
+
+    describe('Config Mocks', () => {
+        describe('databaseConfigMock', () => {
+            it('should have expected properties', () => {
+                expect(databaseConfigMock.DB_TYPE).toBe('mongodb');
+                expect(databaseConfigMock.getDatabaseType()).toBe('mongodb');
+            });
+        });
+
+        describe('createMockAppDefinition', () => {
+            it('should create app definition with defaults', () => {
+                const def = createMockAppDefinition();
+                expect(def.integrations).toBeDefined();
+                expect(def.integrations.length).toBeGreaterThan(0);
+                expect(def.userConfig).toBeDefined();
+            });
+
+            it('should allow customization', () => {
+                const def = createMockAppDefinition({
+                    userConfig: { usePassword: false },
+                });
+                expect(def.userConfig.usePassword).toBe(false);
+            });
+        });
+    });
+});