instant-api 0.1.1

data/spec/functional/create_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Create', type: :controller do
+  let(:user_params) { attributes_for(:user) }
+
+  before do
+    @controller = InstantApi::Controller::Builder.new('users', [:create]).build_class.new
+  end
+
+  it 'successful' do
+    post(:create, user: user_params)
+
+    validate_user(JSON.parse(response.body).symbolize_keys, user_params)
+  end
+
+end

data/spec/functional/destroy_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'Destroy', type: :controller do
+  let!(:user) { create(:user) }
+
+  before do
+    @controller = InstantApi::Controller::Builder.new('users', [:destroy]).build_class.new
+  end
+
+  it 'successful' do
+    delete(:destroy, id: user.id)
+
+    response.should be_successful
+    User.where(id: user.id).should be_empty
+  end
+
+  it 'returns 404 when the resource does not exists' do
+    delete(:destroy, id: user.id + 1)
+    response.status.should eq(404)
+  end
+end

data/spec/functional/edit_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Edit', type: :controller do
+  let!(:user) { create(:user) }
+
+  before do
+    @controller = InstantApi::Controller::Builder.new('users', [:edit]).build_class.new
+  end
+
+  it 'successful' do
+    get(:edit, id: user.id)
+    response.should be_successful
+  end
+
+  it 'returns 404 when the resource does not exists' do
+    get(:edit, id: user.id + 1)
+    response.status.should eq(404)
+  end
+end

data/spec/functional/index_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe 'Index', type: :controller do
+  before do
+    @controller = InstantApi::Controller::Builder.new('users', [:index]).build_class.new
+  end
+
+  context 'returns empty data' do
+    it 'successful' do
+      get(:index)
+
+      json = JSON.parse(response.body).symbolize_keys
+      validate_pagination(json[:pagination], 0, 1, 10)
+      json[:collection].should be_empty
+    end
+  end
+
+  context 'pagination' do
+    let!(:user1) { create(:user) }
+    let!(:user2) { create(:user) }
+
+    context 'all in same page' do
+      let(:expected_collection) { [user1, user2] }
+
+      it 'return first user' do
+        get(:index)
+
+        json = JSON.parse(response.body).symbolize_keys
+        validate_pagination(json[:pagination], 2, 1, 10)
+        validate_user_collection(json[:collection], expected_collection)
+      end
+    end
+
+    context 'first page' do
+      let(:expected_collection) { [user1] }
+
+      it 'return first user' do
+        get(:index, page: 1, per_page: 1)
+
+        json = JSON.parse(response.body).symbolize_keys
+        validate_pagination(json[:pagination], 2, 1, 1)
+        validate_user_collection(json[:collection], expected_collection)
+      end
+    end
+
+    context 'second page' do
+      let(:expected_collection) { [user2] }
+
+      it 'record second user' do
+        get(:index, page: 2, per_page: 1)
+
+        json = JSON.parse(response.body).symbolize_keys
+        validate_pagination(json[:pagination], 2, 2, 1)
+        validate_user_collection(json[:collection], expected_collection)
+      end
+    end
+
+    context 'a page that does not exists' do
+      let(:expected_collection) { [] }
+
+      it 'returns nothing' do
+        get(:index, page: 2)
+
+        json = JSON.parse(response.body).symbolize_keys
+        validate_pagination(json[:pagination], 2, 2, 10)
+        validate_user_collection(json[:collection], expected_collection)
+      end
+    end
+
+    context 'invalid page number' do
+      let(:expected_collection) { [user1, user2] }
+
+      it 'returns first page' do
+        get(:index, page: 'a')
+
+        json = JSON.parse(response.body).symbolize_keys
+        validate_pagination(json[:pagination], 2, 1, 10)
+        validate_user_collection(json[:collection], expected_collection)
+      end
+    end
+  end
+end

data/spec/functional/new_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'New', type: :controller do
+  let!(:user) { create(:user) }
+
+  before do
+    @controller = InstantApi::Controller::Builder.new('users', [:new]).build_class.new
+  end
+
+  it 'successful' do
+    get(:new)
+    response.should be_successful
+  end
+end

data/spec/functional/show_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Show', type: :controller do
+  let(:user) { create(:user) }
+
+  before do
+    @controller = InstantApi::Controller::Builder.new('users', [:show]).build_class.new
+  end
+
+  it 'successful' do
+    get(:show, id: user.id)
+
+    validate_user(JSON.parse(response.body).symbolize_keys, user)
+  end
+
+  it 'returns 404 when the resource does not exists' do
+    get(:show, id: user.id + 1)
+    response.status.should eq(404)
+  end
+end

data/spec/functional/update_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'Update', type: :controller do
+  let(:user) { create(:user) }
+
+  before do
+    @controller = InstantApi::Controller::Builder.new('users', [:update]).build_class.new
+  end
+
+  it 'successful' do
+    put(:update, id: user.id, user: {email: 'hello@at.com'})
+
+    user[:email] = 'hello@at.com'
+    validate_user(JSON.parse(response.body).symbolize_keys, user)
+    response.should be_successful
+  end
+
+  it 'returns 404 when the resource does not exists' do
+    put(:update, id: user.id + 1, user: {email: 'hello@at.com'})
+    response.status.should eq(404)
+  end
+
+  context 'returns error' do
+    after { User.reset_callbacks(:validate) }
+
+    before { User.class_eval { validates :email, length: { minimum: 2 } } }
+
+    it 'error in email' do
+      put(:update, id: user.id, user: {email: 'a'})
+      validate_errors(response.body,
+                      [['email', ['is too short (minimum is 2 characters)']]])
+    end
+
+    context 'returns several errors' do
+      before do
+        User.class_eval { validates :age, numericality: { greater_than: 10 } }
+      end
+
+      it 'error in email and age' do
+        put(:update, id: user.id, user: {email: 'a', age: 3})
+        validate_errors(response.body,
+                        [['email', ['is too short (minimum is 2 characters)']],
+                         ['age', ['must be greater than 10']]])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../dummy/config/environment',  __FILE__)
+
+require 'rspec'
+require 'rspec/rails'
+require 'ffaker'
+require 'factory_girl'
+require 'webmock/rspec'
+require 'instant_api'
+
+require 'support/database_cleaner'
+require 'support/helpers'
+
+ActiveRecord::Migration.check_pending! if defined?(ActiveRecord::Migration)
+
+FactoryGirl.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryGirl.find_definitions
+
+RSpec.configure do |config|
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+  config.render_views = true
+
+  config.include RSpec::Rails::ControllerExampleGroup,
+                 type: :controller,
+                 example_group: {
+                     file_path: config.escaped_path(%w[spec unit controllers])
+                 }
+
+  config.include(FactoryGirl::Syntax::Methods)
+  config.include(Helpers)
+end

data/spec/support/database_cleaner.rb

@@ -0,0 +1,20 @@
+RSpec.configure do |config|
+  # disable rspec-rails wrapping of tests in a database transaction
+  config.use_transactional_fixtures = false
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/helpers.rb

@@ -0,0 +1,31 @@
+module Helpers
+  def validate_user(user, expected_user)
+    user[:id].should_not be_nil
+    user[:age].should eq(expected_user[:age])
+    Date.parse(user[:born_at]).should eq(expected_user[:born_at].to_date)
+    DateTime.parse(user[:registered_at]).to_i.should eq(expected_user[:registered_at].to_i)
+    user[:terms_accepted].should eq(expected_user[:terms_accepted])
+    user[:email].should eq(expected_user[:email])
+    BigDecimal.new(user[:money]).should eq(expected_user[:money])
+    user[:created_at].should_not be_nil
+    user[:updated_at].should_not be_nil
+  end
+
+  def validate_pagination(pagination, count, page, per_page)
+    pagination = pagination.symbolize_keys
+    pagination[:count].should eq(count)
+    pagination[:page].should eq(page)
+    pagination[:per_page].should eq(per_page)
+  end
+
+  def validate_user_collection(collection, expected_collection)
+    collection.each_with_index do |user, index|
+      validate_user(user.symbolize_keys, expected_collection[index])
+    end
+  end
+
+  def validate_errors(body, expected_errors)
+    json = JSON.parse(body).symbolize_keys
+    json[:errors].should eq(expected_errors)
+  end
+end

data/spec/unit/lib/instant_api/controller/build_create_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe InstantApi::Controller::BuildCreate do
+  let(:controller)       { Object.new }
+  let(:model_class_name) { 'Aclass' }
+
+  subject { InstantApi::Controller::BuildCreate.new(controller, model_class_name) }
+
+  describe '#build' do
+    before { subject.build }
+
+    it { controller.respond_to?(:create).should be_true }
+
+    context 'call to create' do
+      let(:resource)   { double('resource', valid?: true, invalid?: false) }
+      let(:params)     { Object.new }
+      let(:parameters) { Object.new }
+      let(:builder)    { double(:builder, build: resource) }
+      class Aclass; end
+
+      before do
+        controller.should_receive(:params).and_return(params)
+        controller.stub_chain(:request, :path).and_return('/path')
+
+        InstantApi::Controller::Parameters.should_receive(:new).
+                                           with(params, '/path').
+                                           and_return(parameters)
+        InstantApi::Model::Builder.should_receive(:new).
+                                   with(parameters, Aclass, true).
+                                   and_return(builder)
+
+        controller.should_receive(:render).with({json: resource}).and_return(true)
+      end
+
+      it { controller.create.should be_true }
+    end
+  end
+end

data/spec/unit/lib/instant_api/controller/build_destroy_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe InstantApi::Controller::BuildDestroy do
+  let(:controller) { Object.new }
+
+  subject { InstantApi::Controller::BuildDestroy.new(controller) }
+
+  describe '#build' do
+    before { subject.build }
+
+    it { controller.respond_to?(:destroy).should be_true }
+
+    context 'call to destroy' do
+      let(:resource) { double(:resource, destroy!: true) }
+
+      before do
+        controller.should_receive(:resource).and_return(resource)
+        controller.should_receive(:render).with({status: 200, nothing: true}).
+                                           and_return(true)
+      end
+
+      it { controller.destroy.should be_true }
+    end
+  end
+end

data/spec/unit/lib/instant_api/controller/build_edit_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe InstantApi::Controller::BuildEdit do
+  let(:controller) { Object.new }
+
+  subject { InstantApi::Controller::BuildEdit.new(controller) }
+
+  describe '#build' do
+    before { subject.build }
+
+    it { controller.respond_to?(:edit).should be_true }
+
+    context 'call to edit' do
+      let(:resource) { Object.new }
+
+      before do
+        controller.should_receive(:resource).and_return(resource)
+        controller.should_receive(:render).with({json: resource}).and_return(true)
+      end
+
+      it { controller.edit.should be_true }
+    end
+  end
+end

data/spec/unit/lib/instant_api/controller/build_index_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe InstantApi::Controller::BuildIndex do
+  let(:controller)       { Object.new }
+  let(:model_class_name) { 'Aclass' }
+
+  subject { InstantApi::Controller::BuildIndex.new(controller, model_class_name) }
+
+  describe '#build' do
+    before { subject.build }
+
+    it { controller.respond_to?(:index).should be_true }
+
+    context 'call to index' do
+      let(:paginated_collection) { Object.new }
+      let(:params)               { Object.new }
+      let(:parameters)           { Object.new }
+      let(:request)              { double(:request, path: '/a') }
+      let(:response) do
+        {
+          collection: paginated_collection,
+          pagination: {
+            count: 7,
+            page: 3,
+            per_page: 5
+          }
+        }
+      end
+
+      before do
+        model_collection = InstantApi::Model::Collection.any_instance
+        model_collection.should_receive(:page).and_return(3)
+        model_collection.should_receive(:per_page).and_return(5)
+        model_collection.should_receive(:paginated_collection).and_return(paginated_collection)
+        model_collection.should_receive(:count).and_return(7)
+
+        InstantApi::Controller::Parameters.should_receive(:new).
+                                           with(params, request.path).
+                                           and_return(parameters)
+
+        controller.should_receive(:request).and_return(request)
+        controller.should_receive(:params).and_return(params)
+        controller.should_receive(:render).with(json: response).and_return(true)
+      end
+
+      it { controller.index.should be_true }
+    end
+  end
+end