tessl/npm-egg-mock

Mock testing library for Egg.js applications with comprehensive mocking capabilities for HTTP, services, contexts, and testing utilities

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Context and Session Mocking

Name: tessl/npm-egg-mock
Author: tessl

Comprehensive mocking capabilities for Egg.js contexts, sessions, cookies, and HTTP headers with full request simulation and lifecycle management.

Capabilities

Context Mocking

Create and manage mocked Egg.js contexts with custom data and request simulation.

/**
 * 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);

Usage Examples:

// 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' }
});

Session Mocking

Mock session data with automatic save method injection and session lifecycle management.

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

Usage Examples:

// 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({});

Cookie Mocking

Mock HTTP cookies with comprehensive cookie management and retrieval capabilities.

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

Usage Examples:

// 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 });

Header Mocking

Mock HTTP request headers with case-insensitive header matching and flexible header management.

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

Usage Examples:

// 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({});

Request Mocking

Low-level request object mocking with comprehensive request property simulation.

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

Usage Examples:

// 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'
  }
});

Context Storage Integration

Integration with Egg.js context storage for proper context isolation and async context management.

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

Usage Examples:

// 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
});

Context Property Access

Access mocked context properties and verify context state during testing.

Usage Examples:

// 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);

Install with Tessl CLI