Cameleon (not Chameleon!) is HTTP mock/stub server framework based on Rack. You can easily create HTTP server behaves as external system for your application.
All you have to do to create a new HTTP interface is simply make directory and put response file into the directory.
Features:
- Easy to create new HTTP interfaces (only to create directory and put response file into it)
- Simple API for "_switch.rb" (for selecting response file)
- Communicate in JSON, XML or any other format over HTTP
- Ready for RESTful API
You can install Cameleon using RubyGems as below:
$ gem install cameleon
Create a new Cameleon project using 'cameleon new' command.
$ cameleon new your_project_name
Move to the directory and start cameleon server.
$ cd your_project_name
$ cameleon server
OK, your server is now running. Test your server using curl.
$ curl http://localhost:9292
Hey, I am cameleon!
Edit response folder to change response whatever you want.
see README.md more detail.
Create HTTP interface such as:
- URL: GET /path/to/interface
- response: "ok"
Follow these lines:
$ mkdir -p response/path/to/interface
$ cd response/path/to/interface
$ echo "ok" > default.txt
Test the interface:
$ curl http://localhost:9292/path/to/interface
ok
You can also create a interface using "cameleon generate" command. To create a new interface "GET /path/to/foo", type:
$ cameleon generate path/to/foo
and test it.
$ curl http://localhost:9292/path/to/foo
edit me: response/path/to/foo/default
Edit the file as you need.
Create "_switch.rb" in your response directory to change the response by HTTP request. "_switch.rb" is pure Ruby file. You can write any logic you need in Ruby.
_switch.rb
# you can access URL parameters by 'params'
case params[:key]
when "foo"
# curl http://localhost:9292/gallery/params?key=foo
render "foo.txt"
when "bar"
# You can also use POST or PUT. See 'rest' more about hadling HTTP methods.
# curl -XPOST http://localhost:9292/gallery/params -d"key=bar"
render "bar.txt"
end
# if else, render "default" (any extention acceptable) file.
Call render method to select response file. When render called, evaluation of "_switch.rb" will be terminated and following code won't be interpreted.
Cameleon supports RESTful URI (including path variable) such as:
http://localhost:9292/resource/${category_name}/${id}
To create such URI, create directory as:
response/resource/$category_name/$id
Directory that name start with '$' is placeholder of the URI. If directory name is '$category_name/$id' and URI 'fiction/12', 'fiction' and '12' are mapped into params['category_name'] and params['id']. Then in your _switch.rb or response(erb) file, you can use params['category_name'] and params['id'] to access the path variable.
Cameleon can validate HTTP request body. Currently JSON format is supported. If you want to validate your request to Cameleon, add 'validation' attribute and 'type' sub-attribute as 'json' into your 'cameleon.yml' config file.
port: 9292
validation:
type: json
then put 'request.schema.json' into response directory. If your interface allows json request body like:
{"a": 1}
You should create 'request.schema.json' like:
{
"type" : "object",
"properties" : {
"a" : {
"type" : "integer",
"required" : true
}
}
}
Cameleon uses json-schema gem as validation engine, and it's based on JSON Schema Draft 3. See json-schema for more detail.
Notice:
Cameleon validates request body only in POST or PUT http method.
To use some libraries or your own modules on your _switch.rb, cameleon load initializer.rb on boot-time. You can write some code inside Cameleon::setup scope.
Cameleon::setup do |config|
require 'some_library'
config.foo = 'FOO'
end
config object can be referred as Cameleon.config in _switch.rb.
Cameleon.config.foo #=> 'FOO'
Create various samples using "cameleon gallery" command.
$ cd YOUR_CAMELEON_HOME
$ cameleon gallery
Check out response/gallery directory and "_switch.rb" to know some usage of APIs.
Cameleon is released under the MIT license.
Copyright (c) 2011 - 2015 daisuke sugimori (@daixque).