node package manager

express-mocker

A simple Mockup Server for REST services that can generate fake data based on simple JSON templates.

ExpressMocker

WIP Alpha 0.0.2 Not full tested. Not for production.

A small FAKE REST web server for your daily development.

Features

  • Small

  • Configured via json or by an included Dashboard

  • Uses ExpressJS

  • Define an endpoint and return JSON data based on a template object

  • FakeData generator to use in templates

  • Simple NodeJS implemented localStorage instance to store things

  • Custom methods can be defined in templates

  • Can generate SVG imagen on the fly

  • Custom methods can use "Injected" arguments

    • $request // $request object containing GET/POST data
    • $localStorage // localStorage "one file" node implementation
    • $console // debug to node console from the template
    • $helper // access DataFackerHelper methods
    • $utils // access DataFackerUtils methods

Installation

You need nodejs installed and running in your system.

Clone locally the repository.

Go to your local source folder an type:

	sudo npm install -g

This will install "express-mocker" globally.

Command Line Usage

First we need to initialize our express-mocker instance in some dir. To initialize it in any wanted directory type:

express-mocker --install
express-mocker --forceInstall // Overwrites your files!!!

This will create a subdir named "express-mocker" with some config files.

In a dir containing the express-mocker dir type:

express-mocker

This will run express-mocker with the default config.json port and verbose options.

Now you can go to your browser and type this address to acces the dashboard.

http://127.0.0.1:7878/express-mocker

You can also use this command line flags:

express-mocker --port <port> // sets the port
express-mocker --quiet	   // force run in quiet mode

In the case you need to force close the port you can use this command:

express-mocker --die <port> // closes the port

Template system

ExpressMocker uses a simple template system defined by a javascript object:

var jsonmocker =
{
	"static": "value", // static value
	"fakeName": "{{firstName}}", // run firstName helper
	"staticArray": [10, 20], // static array
	"dynamicArray": [
		"$repeat(2)", // next item in array will be repeated 2 times
		{
			"name": "{{firstName}} {{lastName}}",
			"age": "{{random(80)}}"
		}
	]
}

This will output something like this:

{
	"static": "value",
	"fakeName": "Shea",
	"staticArray": [ 10,20 ],
	"dynamicArray": [
    	{
        	"name": "Baron Green",
        	"age": "69"
    	},
    	{
        	"name": "Abdullah Gibson",
    	    "age": "48"
	    }
    ]
}
var jsonmocker = 
{
	"property":"{{var-name}}"
}

So for:

/test/:myVar/:mySecondVar

We can the take the values as:

var jsonmocker = 
{
	 "request_myVar":"{{myVar}}"
	,"request_mySecondVar":"{{mySecondVar}}"
}

You can define custom methods for use in your templates.

var jsonmocker = 
{
	"hello":"{{customMethod}}",
	"hello25":"{{customMethodWithParams(25)}}",
	"customMethod": function(){
		return "World!!"
	},
	"customMethodWithParams":function(numberOfWorlds){
		return "World "+numberOfWorlds+" !!"
	}
}

Output

{
	"hello":"World!!",
	"hello25":"World 25 !!"
}		

ExpressMocker uses a simple Injection system with this injections available:

  • $request // $request object containing GET/POST data
  • $localStorage // localStorage "one file" node implementation
  • $console // debug to node console from the template
  • $helper // access DataFackerHelper methods
  • $utils // access DataFackerUtils methods

Using it in your custom methods is simple as:

var jsonmocker =
{
	// REMEMBER!! You must put FIRST the non Injected params
	customTelephone:function( prefix, $utils )
	{
		return $utils.replacePattern( prefix+'.4##.##.##.##');
	},
	"phone":"{{customTelephone('+33')}}"
}	

Output

{
	"phone":"+33.456.78.90"
}	

Storing data

A special key $preprocessRequest is reserved to indicate the template that request preprocesing must be done.

Here is where we can use the $localStorage injection most time.

A simple fake GET user registration can be done via:

For this route:

/user/register/:user/:password

var jsonmocker =
{
	"$preprocessRequest":function( $localStorate, $request )
	{
		$localStorate.setItem
		(
			'singleUserStore',
			JSON.stringify
			(
				{
					user:$request.params('user),
					password:$request.params('password)
				}
			)
		);
	},
	"code":100		
}

Calling:

/user/register/test/1234

Will generate a singleUserStore key with a JSON representation of the user object.

Direct raw base64 Output

A special key $content key "is reserved to indicate that the value of this key must be processed as a base64 output stream.

var jsonmocker =
{
	"$content":"data:image/gif;base64,R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
}

This will ouput a 1pix gif image ;-) or call it with the provided image function:

var jsonmocker =
{
	"$content":"{{image(320,480)}}"
}

API Reference

Injectors $helper $utils
$helper firstName slug(str)
$utils lastName shuffle(array)
$scope company titleCase(str)
$localStorage email replacePattern(pattern)
$request bool randomElement(elements)
$console image(width,height) randomNumber(range)
$helper guid randomNumberRange(start,end)
loremWords
lorem

$scope

The $scope object lets you access your other template methods.

{
	hello:function(){ return 'Hello' },
	world:function(){ return 'world!!' },
	helloWorld:function($scope){
		return $scope.hello()+$scope.world();
	}
	"output":"{{helloWorld}}"
}

$localStorage

Use it as it was the client localStorage but with disk storage.

See more at the project page: https://github.com/coolaj86/node-dom-storage

$request

Provides access to the query params and the processed body headers.

params( id:string ):string;
Returns the request query parameter specified by id. 
body( id:string ):any;
Returns the request body object specified by id. 

$console

Provides a unified form ( with quiet mode ) to log messages to the console.

Supported methods:

  • log(…rest)
  • info(…rest)
  • error(…rest)
  • success(…rest)

$helper

firstName
{{firstName}} 
Returns a random First Name. 
lastName
{{lastName} 

Returns a random Last Name.
company
{{company}}
Returns a random Company name.
email
{{email}}
Returns a random generated email.
bool
{{bool}}
Returns a random boolean value.
image(width,height)
{{image(width,height)}}
Returns a random base64 encoded svg image.
guid
{{guid}}
Returns a random Globally unique identifier.
loremWords(number)
{{loremWords(number)}}
Returns a random number of loremipsum words.
lorem( paragraphs,html=false,sentenceWords=(15-45) )
{{lorem(5)}}
Returns a loremipsum string composed of n paragraphs.

{{lorem(5,true)}}
If html is true it will add <p> tags for each paragraph.

{{lorem(5,true,15)}}
Determine words per sentence. Default is a random value 15-45

$utils

slug(str:string):string
{{slug('some long texy')}}
Returns a slugged version of str.
shuffle(array:any[]):any[]
{{shuffle(array)}}
Returns a randomided version of the provided array.
titleCase(str:string):string
{{titleCase(str)}}
Returns a titleCase representation of str.
replacePattern(pattern):string
{{replacePattern('####-UUUU-LLLL')}}
Processes the provided pattern replacing:

# by a number.
U by a uppercase letter.
L by a lowercase letter.
randomElement(elements:any[]):any
{{randomElement([10,\"demo\",true])}}
Returns a random element from the provided array.
randomNumber(max)
{{randomNumber(25)}}
Returns a random number between 0 and max;
randomNumberRange(start,end)
{{randomNumberRange(5,10)}}
Returns a random number between start and end;