ExpressMocker

WIP Alpha 0.0.2 Not full tested. Not for production.

A small FAKE REST web server for your daily development.

Features
Installation
Command Line Usage
Template system
Storing data
Direct raw base64 Output
API Reference

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

Installing

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.

Running

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

Force exit ;-)

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

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

Template system

Basic Templating

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"
	    }
    ]
}

Using GET/POST vars

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}}"
}

Custom template methods

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 !!"
}

Possible Injections in your functions

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;

express-mocker