Context and Session Mocking

/**
 * Create a mocked context
 * @param {Object} [data] - Context data to mock
 * @param {Object} [options] - Mock context options
 * @returns {Context} Mocked context instance
 */
app.mockContext(data, options);

/**
 * Execute function within a mocked context scope
 * @param {Function} fn - Function to execute within context
 * @param {Object} [data] - Context data to mock
 * @returns {Promise<any>} Promise resolving to function result
 */
app.mockContextScope(fn, data);

// Basic context mocking
const ctx = app.mockContext({
  user: {
    name: 'Jason',
    id: 123
  }
});
console.log(ctx.user.name); // 'Jason'

// Context with custom headers
const ctx = app.mockContext({
  headers: {
    'x-custom-header': 'value',
    'authorization': 'Bearer token123'
  }
});

// Context scope execution
const result = await app.mockContextScope(async (ctx) => {
  return ctx.service.user.getProfile(123);
}, {
  user: { id: 123, role: 'admin' }
});

// Context with custom request data
const ctx = app.mockContext({
  method: 'POST',
  url: '/api/users',
  body: { name: 'Alice', email: 'alice@example.com' },
  query: { include: 'profile' }
});

/**
 * Mock session data
 * @param {Object} data - Session data to mock
 * @returns {Application} Application instance for chaining
 */
app.mockSession(data);

// Basic session mocking
app.mockSession({
  user: {
    id: 123,
    name: 'Alice'
  },
  isLogin: true
});

// Session with complex data
app.mockSession({
  user: {
    id: 456,
    name: 'Bob',
    role: 'admin',
    permissions: ['read', 'write', 'delete']
  },
  preferences: {
    theme: 'dark',
    language: 'en'
  },
  lastActivity: new Date('2023-01-01')
});

// Chaining with other mocks
app.mockSession({ userId: 123 })
   .mockCookies({ sessionId: 'abc123' })
   .mockHeaders({ 'user-agent': 'test-client' });

// Empty session (clears session)
app.mockSession({});

/**
 * Mock cookies
 * @param {Object} cookies - Cookie data to mock
 * @returns {Application} Application instance for chaining
 */
app.mockCookies(cookies);

// Basic cookie mocking
app.mockCookies({
  sessionId: 'abc123',
  theme: 'dark',
  language: 'en'
});

// Cookie with special characters
app.mockCookies({
  'user-token': 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
  'tracking-id': 'GA1.2.123456789.0123456789'
});

// Numeric and boolean cookie values
app.mockCookies({
  userId: 123,
  isLoggedIn: true,
  cartCount: 5
});

// Clear cookies
app.mockCookies({});

// Chaining cookie mocking
app.mockCookies({ sessionId: 'abc123' })
   .mockSession({ userId: 123 });

/**
 * Mock HTTP headers
 * @param {Object} headers - Headers to mock
 * @returns {Application} Application instance for chaining
 */
app.mockHeaders(headers);

// Basic header mocking
app.mockHeaders({
  'authorization': 'Bearer token123',
  'content-type': 'application/json',
  'user-agent': 'test-client/1.0'
});

// Custom headers
app.mockHeaders({
  'x-api-key': 'secret-key',
  'x-request-id': 'req-123-456',
  'x-forwarded-for': '192.168.1.1'
});

// Case variations (all work the same)
app.mockHeaders({
  'Content-Type': 'application/json',
  'AUTHORIZATION': 'Bearer token',
  'user-agent': 'test-client'
});

// Headers with complex values
app.mockHeaders({
  'accept': 'application/json, text/plain, */*',
  'accept-encoding': 'gzip, deflate, br',
  'cache-control': 'no-cache, no-store, must-revalidate'
});

// Clear headers
app.mockHeaders({});

/**
 * Mock request object
 * @param {Object} req - Request data to mock
 * @returns {Object} Mocked request object
 */
app.mockRequest(req);

// Basic request mocking
const req = app.mockRequest({
  method: 'POST',
  url: '/api/users',
  headers: {
    'content-type': 'application/json'
  }
});

// Request with query parameters
const req = app.mockRequest({
  method: 'GET',
  url: '/api/users?page=1&limit=10',
  query: { page: 1, limit: 10 },
  querystring: 'page=1&limit=10'
});

// Request with custom properties
const req = app.mockRequest({
  method: 'PUT',
  url: '/api/users/123',
  host: 'api.example.com',
  hostname: 'api.example.com',
  protocol: 'https',
  secure: true,
  socket: {
    remoteAddress: '192.168.1.100',
    remotePort: 45678
  }
});

// File upload request
const req = app.mockRequest({
  method: 'POST',
  url: '/upload',
  headers: {
    'content-type': 'multipart/form-data',
    'content-length': '1024'
  }
});

/**
 * Mock context options for storage integration
 */
interface MockContextOptions {
  /** Enable context storage mocking */
  mockCtxStorage?: boolean;
  /** Reuse existing context storage */
  reuseCtxStorage?: boolean;
}

// Context with storage integration (default)
const ctx = app.mockContext({
  user: { id: 123 }
}, {
  mockCtxStorage: true
});

// Context without storage mocking
const ctx = app.mockContext({
  user: { id: 123 }
}, {
  mockCtxStorage: false
});

// Context scope with storage
await app.mockContextScope(async (ctx) => {
  // ctx is properly set in async context storage
  const user = await ctx.service.user.getCurrent();
  return user;
}, {
  user: { id: 123, role: 'admin' }
});

// Disable storage reuse for isolated testing
const ctx = app.mockContext({
  user: { id: 123 }
}, {
  reuseCtxStorage: false
});

// Access mocked properties
const ctx = app.mockContext({
  user: { id: 123, name: 'Alice' },
  requestId: 'req-456'
});

// Verify context state
assert.equal(ctx.user.id, 123);
assert.equal(ctx.user.name, 'Alice');
assert.equal(ctx.requestId, 'req-456');

// Context with nested properties
const ctx = app.mockContext({
  config: {
    database: { host: 'localhost', port: 3306 },
    redis: { host: 'redis-server', port: 6379 }
  }
});

// Access nested properties
assert.equal(ctx.config.database.host, 'localhost');
assert.equal(ctx.config.redis.port, 6379);