or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

application-creation.mdcontext-session-mocking.mdenvironment-configuration.mdhttp-client-mocking.mdhttp-testing-utilities.mdindex.mdlogging-assertions.mdmock-restoration.mdservice-mocking.md
tile.json

tessl/npm-egg-mock

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

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/egg-mock@5.15.x

To install, run

npx @tessl/cli install tessl/npm-egg-mock@5.15.0

index.mddocs/

egg-mock

egg-mock is a comprehensive mock testing library specifically designed for Egg.js applications, plugins, and custom frameworks. It inherits all functionality from the mm (node_modules/mm) library while adding Egg-specific enhancements for creating mock servers, testing applications in both single and cluster modes, and providing extensive mocking capabilities for HTTP requests, services, contexts, sessions, cookies, and CSRF tokens.

Package Information

  • Package Name: egg-mock
  • Package Type: npm
  • Language: JavaScript/TypeScript
  • Installation: npm install egg-mock --save-dev

Core Imports

const mm = require('egg-mock');

For ES modules:

import mm from 'egg-mock';

For bootstrap testing:

const { assert, app, mock } = require('egg-mock/bootstrap');

Basic Usage

const mm = require('egg-mock');

describe('some test', () => {
  let app;
  before(() => {
    app = mm.app({
      baseDir: 'apps/foo'
    });
    return app.ready();
  });
  after(() => app.close());

  it('should request /', () => {
    return app.httpRequest()
      .get('/')
      .expect(200);
  });
});

Architecture

egg-mock is built around several key components:

  • Mock Applications: Single and cluster application instances that replicate Egg.js behavior in tests
  • Context Mocking: Complete context, session, cookie, and header mocking capabilities
  • Service Mocking: Method-level mocking for Egg.js services with error simulation
  • HTTP Client Mocking: Full HTTP request/response mocking with urllib integration
  • Logging Utilities: Log collection and assertion tools for testing log output
  • Bootstrap Integration: Test setup utilities for streamlined test configuration

Capabilities

Application Creation

Core functionality for creating mock Egg.js applications in single and cluster modes with comprehensive lifecycle management.

/**
 * Create a mocked Egg application instance
 * @param {MockOption} [options] - Configuration options
 * @returns {MockApplication} Mocked application instance
 */
function app(options);

/**
 * Create a mocked cluster application for testing with supertest
 * @param {MockOption} [options] - Configuration options  
 * @returns {ClusterApplication} Cluster application instance
 */
function cluster(options);

interface MockOption {
  baseDir?: string;
  plugins?: any;
  framework?: string;
  cache?: boolean;
  coverage?: boolean;
  clean?: boolean;
}

Application Creation

Context and Session Mocking

Comprehensive mocking capabilities for Egg.js contexts, sessions, cookies, and HTTP headers with full 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);

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

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

Context and Session Mocking

Service Mocking

Method-level mocking for Egg.js services with support for custom implementations, error simulation, and both synchronous and asynchronous operations.

/**
 * Mock a service method
 * @param {string|Object} service - Service name or service class
 * @param {string} methodName - Method name to mock
 * @param {Function|Object|Error} fn - Mock implementation or return value
 * @returns {Application} Application instance for chaining
 */
app.mockService(service, methodName, fn);

/**
 * Mock a service method to return an error
 * @param {string|Object} service - Service name or service class
 * @param {string} methodName - Method name to mock
 * @param {Error|string} [err] - Error to throw
 * @returns {Application} Application instance for chaining
 */
app.mockServiceError(service, methodName, err);

Service Mocking

HTTP Client Mocking

Complete HTTP client mocking system with urllib integration, supporting URL patterns, method filtering, and comprehensive response configuration.

/**
 * Mock HTTP client requests
 * @param {string|RegExp} mockUrl - URL pattern to mock
 * @param {string|string[]} [mockMethod] - HTTP methods to mock
 * @param {MockHttpClientResult} mockResult - Mock response configuration
 * @returns {Application} Application instance
 */
app.mockHttpclient(mockUrl, mockMethod, mockResult);

/**
 * Get mock HTTP agent for urllib
 * @returns {MockAgent} MockAgent instance
 */
app.mockAgent();

type MockHttpClientResult = ResultObject | ResultFunction | string;

interface ResultObject {
  data?: string | object | Buffer;
  status?: number;
  headers?: any;
  delay?: number;
  persist?: boolean;
  repeats?: number;
}

HTTP Client Mocking

HTTP Testing Utilities

Supertest integration and enhanced testing utilities for making HTTP requests with custom assertion methods and comprehensive test coverage.

/**
 * Create supertest request instance
 * @returns {SupertestRequest} HTTP testing object with methods
 */
app.httpRequest();

interface SupertestRequest {
  get(url: string): EggTest;
  post(url: string): EggTest;
  put(url: string): EggTest;
  delete(url: string): EggTest;
  patch(url: string): EggTest;
  head(url: string): EggTest;
  options(url: string): EggTest;
}

interface EggTest {
  unexpectHeader(name: string, callback?: Function): EggTest;
  expectHeader(name: string, callback?: Function): EggTest;
}

HTTP Testing Utilities

Logging and Assertions

Log collection, monitoring, and assertion utilities for testing log output with pattern matching and multi-logger support.

/**
 * Start collecting logger messages for testing
 * @param {string|Logger} [logger] - Logger instance or name
 */
app.mockLog(logger);

/**
 * Assert that a string/pattern exists in logs
 * @param {string|RegExp} str - String or pattern to find
 * @param {string|Logger} [logger] - Logger instance or name
 */
app.expectLog(str, logger);

/**
 * Assert that a string/pattern does not exist in logs
 * @param {string|RegExp} str - String or pattern that should not be found
 * @param {string|Logger} [logger] - Logger instance or name
 */
app.notExpectLog(str, logger);

Logging and Assertions

Environment and Configuration

Environment variable mocking, server configuration, and global settings management for comprehensive test environment setup.

/**
 * Mock the server environment of Egg
 * @param {EnvType} env - Environment name
 */
mm.env(env);

/**
 * Mock console log level
 * @param {LogLevel} level - Logger level
 */
mm.consoleLevel(level);

/**
 * Set EGG_HOME path
 * @param {string} homePath - Home directory path
 */
mm.home(homePath);

type EnvType = 'default' | 'test' | 'prod' | 'local' | 'unittest' | string;
type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'NONE';

Environment and Configuration

Mock Restoration

Comprehensive mock cleanup and restoration utilities for maintaining test isolation and preventing test interference.

/**
 * Restore all mocks (enhanced version of mm.restore)
 * @returns {Promise<void>} Promise that resolves when restoration is complete
 */
async mm.restore();

/**
 * Restore all application-specific mocks
 * @returns {Application} Application instance
 */
app.mockRestore();

/**
 * Restore mock HTTP agent
 * @returns {Promise<void>} Promise that resolves when agent is restored
 */
async app.mockAgentRestore();

Mock Restoration