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

###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

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

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

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
$helperfirstNameslug(str)
$utilslastNameshuffle(array)
$scopecompanytitleCase(str)
$localStorageemailreplacePattern(pattern)
$requestboolrandomElement(elements)
$consoleimage(width,height)randomNumber(range)
$helperguidrandomNumberRange(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;