or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

ajax-mocking.mddata-generation.mddata-validation.mdindex.mdrandom-data.mdutilities.md
tile.json

tessl/npm-mockjs

JavaScript library for generating random data and intercepting Ajax requests

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/mockjs@1.1.x

To install, run

npx @tessl/cli install tessl/npm-mockjs@1.1.0

index.mddocs/

Mock.js

Mock.js is a comprehensive JavaScript library that enables developers to generate simulated data according to data templates and intercept Ajax requests. It provides an intuitive syntax for data generation, supports various data types with flexible generation rules, and includes Ajax request/response mocking functionality that works with popular libraries like jQuery.

Package Information

  • Package Name: mockjs
  • Package Type: npm
  • Language: JavaScript
  • Installation: npm install mockjs

Core Imports

const Mock = require('mockjs');

For ES modules:

import Mock from 'mockjs';

Browser usage (UMD):

<script src="path/to/mock.js"></script>
<!-- Now available as global Mock -->

Basic Usage

const Mock = require('mockjs');

// Generate data from template
const data = Mock.mock({
  'list|1-10': [{
    'id|+1': 1,
    'name': '@name',
    'email': '@email',
    'address': '@city @county'
  }]
});

// Mock Ajax requests
Mock.mock('/api/users', 'get', {
  'users|5-10': [{
    'id|+1': 1,
    'name': '@name',
    'age|18-60': 1
  }]
});

// Generate individual random values
const randomName = Mock.mock('@name');
const randomEmail = Mock.mock('@email');

Architecture

Mock.js is built around several key components:

  • Template Engine: Processes data templates with generation rules using Mock.mock()
  • Random Data Generators: Extensive collection of functions for generating realistic fake data (Mock.Random)
  • Ajax Interception: XMLHttpRequest mocking system for intercepting and responding to requests (Mock.setup())
  • Validation System: Schema validation to verify real data against templates (Mock.valid())
  • Utility Functions: Helper functions for common operations (Mock.Util)

Capabilities

Data Generation

Core template-based data generation using rule syntax for creating realistic mock data structures. Perfect for testing, development, and prototyping.

/**
 * Generate mock data from a template
 * @param template - Data template with optional generation rules
 * @returns Generated mock data
 */
Mock.mock(template: any): any;

/**
 * Generate mock data from template with name context
 * @param template - Data template  
 * @param name - Property name for rule context
 * @returns Generated mock data
 */  
Mock.mock(template: any, name: string): any;

Data Generation

Random Data Functions

Extensive collection of random data generators for creating realistic fake data including names, addresses, dates, images, and more.

/**
 * Random data generator object containing all generator functions
 */
Mock.Random: {
  // Basic types
  boolean(min?: number, max?: number, current?: boolean): boolean;
  natural(min?: number, max?: number): number;
  integer(min?: number, max?: number): number;
  float(min?: number, max?: number, dmin?: number, dmax?: number): number;
  character(pool?: string): string;
  string(pool?: string, min?: number, max?: number): string;
  
  // Common data generators  
  name(middle?: boolean): string;
  email(domain?: string): string;
  url(protocol?: string, host?: string): string;
  date(format?: string): string;
  image(size?: string, background?: string, text?: string): string;
  
  // Helper functions
  pick(array: any[], min?: number, max?: number): any;
  shuffle(array: any[]): any[];
}

Random Data

Ajax Request Mocking

XMLHttpRequest interception system for mocking HTTP requests and responses, enabling independent frontend development.

/**
 * Mock HTTP requests by URL pattern
 * @param url - Request URL pattern (string or RegExp)
 * @param template - Response data template
 * @returns Mock instance for chaining
 */
Mock.mock(url: string | RegExp, template: any): typeof Mock;

/**
 * Mock HTTP requests by URL pattern and method  
 * @param url - Request URL pattern (string or RegExp)
 * @param method - HTTP method (get, post, put, delete, etc.)
 * @param template - Response data template or function
 * @returns Mock instance for chaining
 */
Mock.mock(url: string | RegExp, method: string, template: any | Function): typeof Mock;

/**
 * Configure XMLHttpRequest mock behavior
 * @param settings - Configuration options
 */
Mock.setup(settings: {
  timeout?: string;
  onAfterResponse?: Function;
}): void;

Ajax Mocking

Data Validation

Validation system for verifying that real data matches specified templates, useful for API contract testing.

/**
 * Validate data against a template schema
 * @param template - Data template schema
 * @param data - Real data to validate  
 * @returns Array of validation errors (empty if valid)
 */
Mock.valid(template: any, data: any): ValidationError[];

interface ValidationError {
  path: string[];
  type: string; 
  message: string;
  expected: any;
  actual: any;
}

Data Validation

JSON Schema Conversion

Convert Mock.js templates to JSON Schema format for external validation systems.

/**
 * Convert Mock.js template to JSON Schema
 * @param template - Mock.js data template
 * @returns JSON Schema representation of the template
 */
Mock.toJSONSchema(template: any): any;

Usage Examples:

const template = {
  'list|1-10': [{
    'id|+1': 1,
    name: '@name',
    'age|18-65': 1
  }]
};

const schema = Mock.toJSONSchema(template);
// Generated JSON Schema can be used with external validators

Utility Functions

Common utility functions for object manipulation, type checking, and string processing.

Mock.Util: {
  extend(target: any, ...sources: any[]): any;
  each(obj: any, iterator: Function, context?: any): void;
  type(obj: any): string;
  keys(obj: any): string[];
  values(obj: any): any[];
  heredoc(fn: Function): string;
}

Utilities

Types

// Template generation rules use | syntax
interface TemplateRule {
  // 'property|rule': value
  // Examples:
  // 'list|1-10': [] - generate 1-10 items  
  // 'id|+1': 1 - auto-increment starting from 1
  // 'name|3': 'x' - repeat string 3 times
  // 'flag|1-2': true - boolean with probability ratio
}

// Placeholder strings use @ syntax  
interface PlaceholderString {
  // '@function' or '@function(args)'
  // Examples: '@name', '@email', '@date(yyyy-MM-dd)'
}