The fastest way to prototype API in your Rails application
MIT License
The fastest way to prototype API with most real dummy data, and provide them to other team members.
Instead of creating many new controllers and actions, and sending random data like "First name #{rand(100)}"
you'll get real data for developing/testing.
Gem has a syntax similar to rails routes, factory bot, and uses faker to generate dummy data.
Features:
Installation process is very simple.
gem 'fake_api'
to the Gemfilebundle install
mount FakeApi::Engine => '/api'
rails g fake_api Product
. It will generate factory and routing files.app/fake_api/*.rb
, define your routing and factories.localhost:300/api/projects.json
(see step 5) or localhost:300/api/projects.xml
(to return XML in API response)You can keep your routing and factories in many files.
Sample of the factory:
# app/fake_api/factory.rb
class Factory < FakeApi::Factoring
# Example of User object
# you can see that it will generate link to fake image
factory(:user) do
{
id: rand(100),
first_name: Faker::Name.first_name,
last_name: Faker::Name.first_name,
avatar_url: Faker::Avatar.image(size: '128x128'),
age: rand(100)
}
end
# heare you can put "relations" to other factories
# see "author" node
factory(:project) do
{
id: rand(1_000),
title: Faker::Company.name,
description: Faker::Company.catch_phrase,
type: Faker::Company.type,
author: object(:user)
}
end
# or have factory which contains from the list of Projects and a single user
factory(:complex) do
{
projects: create_list(:project, 2),
user: object(:user)
}
end
end
And sample of routing:
# app/fake_api/app_routing.rb
class AppRouting < FakeApi::Routing
get('/projects').and_return { create_list(:project, 5) }.with_status(202).with_headers({TOKEN: "SECRET"})
get(%r{/projects/\d+$}).and_return { object(:project) }
post('/projects').and_return { object(:project).merge({created: 'ok'}) }
delete(%r{/projects/\d+$}).and_return { { result: :deleted } }.with_status(333)
post('/auth')
.and_return { { status: "OK" } }
.with_cookies({x: "A"})
.with_session({y: "B"})
.with_headers({token: "C"})
end
create_list(:factory_name, 10)
to create an array of 10 factories.object(:factory_nane)
to return a factoryget/post/put/patch/delete
to define routeand_return
to specify the response. This response will be converted to FORMAT (json, xml, js, csv(for arrays) etc)with_cookies
to list returned cookieswith_session
to list changes in sessionwith_headers
to list returned headersDeveloping standalone version of the gem:
cd test
rackup -p 3000 -o 0.0.0.0
Edit config.ru
to change example code.
This is an example how you can start just fake_api server and define your factories and responses just inside one single file.
Please check example below and instructions how to start fakea_api in standalone mode.
Since this is a rack app it could be just deployed to the server.
# start it:
# rackup -p 3000 -o 0.0.0.0
# create file
# config.ru
require 'rubygems'
require 'fake_api/standalone'
factory(:user) do
{
id: rand(100),
first_name: Faker::Name.first_name,
last_name: Faker::Name.last_name,
age: rand(100)
}
end
get('/users').and_return do
create_list(:user, 5)
end
get(%r{/users/\d+$}).and_return do
object(:user)
end
run FakeApi::Standalone.app on: '/api'
Theare is only one thing which is not convinient is a need to restart server after code changes.
You are welcome to contribute.
The gem is available as open source under the terms of the MIT License.