instant-api 0.1.1

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

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

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe InstantApi::Controller::BuildResource do
+  let(:controller)       { Object.new }
+  let(:model_class_name) { 'Aclass' }
+
+  subject { InstantApi::Controller::BuildResource.new(controller, model_class_name) }
+
+  describe '#build' do
+    before { subject.build }
+
+    context 'call to resource' do
+      let(:resource) { Object.new }
+      let(:params)   { {id: 3} }
+      let(:request)  { double(:request, path: '/a/3')}
+      class Aclass; end
+
+      before do
+        controller.should_receive(:params).and_return(params)
+        controller.should_receive(:request).and_return(request)
+        Aclass.should_receive(:find).with(3).and_return(resource)
+      end
+
+      it { controller.send(:resource).should eq(resource) }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe InstantApi::Controller::BuildShow do
+  let(:controller) { Object.new }
+
+  subject { InstantApi::Controller::BuildShow.new(controller) }
+
+  describe '#build' do
+    before { subject.build }
+
+    it { controller.respond_to?(:show).should be_true }
+
+    context 'call to show' 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.show.should be_true }
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe InstantApi::Controller::BuildUpdate do
+  let(:controller)       { Object.new }
+  let(:model_class_name) { 'OtherClass' }
+
+  subject { InstantApi::Controller::BuildUpdate.new(controller, model_class_name) }
+
+  describe '#build' do
+    before { subject.build }
+
+    it { controller.respond_to?(:update).should be_true }
+
+    describe '#update' do
+      let(:resource)      { double('resource', valid?: true, invalid?: false) }
+      let(:strong_params) { Object.new }
+
+      before do
+        resource.should_receive(:update_attributes!).with(strong_params)
+
+        controller.should_receive(:resource).any_number_of_times.and_return(resource)
+        controller.should_receive(:check_strong_parameters).and_return(strong_params)
+        controller.should_receive(:render).with(json: resource).and_return(true)
+      end
+
+      it { controller.update.should be_true }
+    end
+
+    describe '#check_strong_parameters' do
+      context 'with strong parameters' do
+        let(:params)           { Object.new }
+        let(:params_require)   { Object.new }
+        let(:model_class_name) { 'AnotherClass' }
+        class AnotherClass
+          def self.strong_parameters
+            'a'
+          end
+        end
+
+        before do
+          params.should_receive(:require).with(:another_class).and_return(params_require)
+          params_require.should_receive(:permit).with('a').and_return(true)
+          controller.should_receive(:params).and_return(params)
+        end
+
+        it { controller.send(:check_strong_parameters).should be_true }
+      end
+
+      context 'without strong parameters' do
+        let(:params)         { Object.new }
+        let(:params_require) { Object.new }
+        let(:model_class_name) { 'OtherClass' }
+        class OtherClass; end
+
+
+        before do
+          params.should_receive(:require).with(:other_class).and_return(params_require)
+          params_require.should_receive(:permit!).and_return(true)
+          controller.should_receive(:params).and_return(params)
+        end
+
+        it { controller.send(:check_strong_parameters).should be_true }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'instant_api/controller/builder'
+
+describe InstantApi::Controller::Builder do
+  subject { InstantApi::Controller::Builder.new('users', [:index, :show]) }
+
+  describe '#build_class' do
+    it do
+      controller = subject.build_class
+
+      instance = controller.new
+      instance.respond_to?(:show).should be_true
+      instance.respond_to?(:index).should be_true
+      instance.respond_to?(:edit).should be_false
+    end
+
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'instant_api/controller/parameters'
+
+describe InstantApi::Controller::Parameters do
+  subject { InstantApi::Controller::Parameters.new(params, request_path) }
+
+  describe '#[]' do
+    let(:request_path) { '/users' }
+
+    context 'a string key' do
+      let(:params) { { 'id' => 3 } }
+      it { subject['id'].should eq(3) }
+    end
+
+    context 'a symbol key' do
+      let(:params) { { id: 3 } }
+      it { subject[:id].should eq(3) }
+    end
+
+    context 'remove internal rails params' do
+      %w(controller action format _method only_path).each do |param|
+        let(:params) { { param => 'hi' } }
+        it { subject[param].should be_nil }
+      end
+    end
+  end
+
+  describe '#resources' do
+    let(:params) { Hash.new }
+
+    context 'return the resources' do
+      let(:request_path) { '/users/2/addresses' }
+      it { subject.resources.should eq([:users, :addresses]) }
+    end
+
+    context 'ignore trailing /' do
+      let(:request_path) { '/users/2/addresses/' }
+      it { subject.resources.should eq([:users, :addresses]) }
+    end
+
+    context 'ignore trailing /' do
+      let(:request_path) { '/users/2/addresses/2/ ' }
+      it { subject.resources.should eq([:users, :addresses]) }
+    end
+
+    context 'remove the rails methods' do
+      %w(new edit).each do |method|
+        let(:request_path) { "/users/2/addresses/#{method}" }
+        it { subject.resources.should eq([:users, :addresses]) }
+      end
+    end
+  end
+end

data/spec/unit/lib/instant_api/model/active_record_query_builder_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'instant_api/controller/parameters'
+require 'instant_api/model/builder'
+require 'instant_api/model/active_record_query_builder'
+
+describe InstantApi::Model::ActiveRecordQueryBuilder do
+  subject      { InstantApi::Model::ActiveRecordQueryBuilder.new(model) }
+  let(:params) { InstantApi::Controller::Parameters.new(rails_params, request_path) }
+
+  let(:user)    { create(:user) }
+  let(:address) { create(:address, user_id: user.id) }
+  let(:country) { create(:country, address_id: address.id) }
+
+  let(:another_user)    { create(:user) }
+  let(:another_address) { create(:address, user_id: another_user.id) }
+  let(:another_country) { create(:country, address_id: another_address.id) }
+
+  describe '#query' do
+    context 'returns all first level model' do
+      let(:model)        { User }
+      let(:rails_params) { Hash.new }
+      let(:request_path) { '/users' }
+      it { subject.query(params).should eq([user]) }
+    end
+
+    context 'return all second level model' do
+      let(:model)        { Address }
+      let(:rails_params) { { user_id: user.id } }
+      let(:request_path) { "/users/#{user.id}/addresses" }
+
+      it { subject.query(params).should eq([address]) }
+    end
+
+    context 'additional parameters' do
+      let(:model)        { Address }
+      let(:rails_params) { { user_id: user.id, city: 'Barcelona' } }
+      let(:request_path) { "/users/#{user.id}/addresses" }
+      let(:address2) { create(:address, user_id: user.id, city: 'Barcelona') }
+      let(:address3) { create(:address, user_id: user.id, city: 'Madrid') }
+
+      it { subject.query(params).should eq([address2]) }
+    end
+
+    context 'query second level model with an invalid id, returns nothing' do
+      let(:model)        { Address }
+      let(:rails_params) { { user_id: user.id } }
+      let(:request_path) { "/users/#{user.id}/addresses/#{another_address.id}" }
+
+      it { subject.query(params).should be_empty }
+    end
+
+    context 'return all third level model' do
+      let(:model)        { Country }
+      let(:rails_params) { { user_id: user.id, address_id: address.id } }
+      let(:request_path) { "/users/#{user.id}/addresses/#{address.id}/countries" }
+
+      it { subject.query(params).should eq([country]) }
+    end
+
+    context 'query third level model with an invalid id, returns nothing' do
+      let(:model)        { Country }
+      let(:rails_params) { { user_id: user.id, address_id: another_address.id } }
+      let(:request_path) { "/users/#{user.id}/addresses/#{another_address.id}/countries" }
+
+      it { subject.query(params).should be_empty }
+    end
+
+    context 'return all third level model with additional params' do
+      let(:model)        { Country }
+      let(:rails_params) { { user_id: user.id, address_id: address.id } }
+      let(:request_path) { "/users/#{user.id}/addresses/#{address.id}/countries" }
+
+      context 'return data' do
+        before { rails_params[:name] = country.name }
+        it { subject.query(params).should eq([country]) }
+      end
+
+      # TODO
+      #context 'return nothins' do
+      #  before { params[:name] = country.name + 'nothing' }
+      #  it { subject.query(params).should be_empty }
+      #end
+    end
+
+    context 'has_and_belongs_to_many' do
+      let(:movie) { create(:movie, countries: [country]) }
+      before { country.movies = [movie] }
+
+      let(:model) { Country }
+      let(:rails_params) { { movie_id: movie.id } }
+      let(:request_path) { "/movies/#{movie.id}/countries" }
+
+      it { subject.query(params).should eq([country]) }
+    end
+  end
+
+  describe '#find_first' do
+    context 'returns first level model' do
+      let(:model)        { User }
+      let(:rails_params) { { id: user.id } }
+      let(:request_path) { "/users/#{user.id}" }
+      it { subject.find_first(params).should eq(user) }
+    end
+
+    context 'raises exception if no item exists' do
+      let(:model)        { User }
+      let(:rails_params) { { id: user.id + another_user.id } }
+      let(:request_path) { "/users/#{user.id}" }
+      it { expect { subject.find_first(params) }.to raise_error(ActiveRecord::RecordNotFound) }
+    end
+
+    context 'raises exception if no id is passed' do
+      let(:model)        { User }
+      let(:rails_params) { Hash.new }
+      let(:request_path) { "/users/#{user.id}" }
+      it { expect { subject.find_first(params) }.to raise_error(ActiveRecord::RecordNotFound) }
+    end
+
+    context 'returns second level model' do
+      let(:model)        { Address }
+      let(:rails_params) { { user_id: user.id, id: address.id } }
+      let(:request_path) { "/users/#{user.id}/addresses/#{address.id}" }
+      it { subject.find_first(params).should eq(address) }
+    end
+
+    context 'second level model with invalid id, raises exception' do
+      let(:model)        { Address }
+      let(:rails_params) { { user_id: user.id, id: another_address.id } }
+      let(:request_path) { "/users/#{user.id}/addresses/#{another_address.id}" }
+      it { expect { subject.find_first(params) }.to raise_error(ActiveRecord::RecordNotFound) }
+    end
+  end
+end

data/spec/unit/lib/instant_api/model/builder_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+require 'instant_api/model/builder'
+
+describe InstantApi::Model::Builder do
+  subject { InstantApi::Model::Builder.new(params, model, true) }
+
+  describe '#build' do
+    let(:model)   { User }
+    let(:params)  { { user: data }.with_indifferent_access }
+
+    context 'successful' do
+      context 'string parameter' do
+        let(:data) { { email: 'a' } }
+        it { validate_record(subject.build, :email, 'a') }
+      end
+
+      context 'integer parameter' do
+        let(:data) { { age: 1 } }
+        it { validate_record(subject.build, :age, 1) }
+      end
+
+      context 'date parameter' do
+        let(:data)    { { born_at: '01/03/1974' } }
+        let(:born_at) { Date.parse(data[:born_at]) }
+        it { validate_record(subject.build, :born_at, born_at) }
+      end
+
+      context 'datetime parameter' do
+        let(:data)          { { registered_at: '10:29 01/03/1974' } }
+        let(:registered_at) { DateTime.parse(data[:registered_at]) }
+        it { validate_record(subject.build, :registered_at, registered_at) }
+      end
+
+      context 'decimal parameter' do
+        let(:data)  { { money: '10.99' } }
+        let(:money) { BigDecimal.new('10.99') }
+        it { validate_record(subject.build, :money, money) }
+      end
+
+      context 'boolean parameter' do
+        context 'value true' do
+          let(:data) { { terms_accepted: 1 } }
+          it { validate_record(subject.build, :terms_accepted, true) }
+        end
+
+        context 'value false' do
+          let(:data) { { terms_accepted: 0 } }
+          it { validate_record(subject.build, :terms_accepted, false) }
+        end
+      end
+
+      context 'build nested model' do
+        let(:data) { { addresses: { street: 'a' } }.with_indifferent_access }
+
+        it 'creates a record' do
+          record = subject.build
+          record.valid?.should be_true
+          record.addresses.size.should eq(1)
+        end
+      end
+    end
+
+    context 'nested objects' do
+      let(:model) { A }
+      let(:params) do
+        { a: { value: 'a', b: { value: 'b', c: { value: 'c' } } } }.with_indifferent_access
+      end
+
+      context 'successful' do
+        it 'build the nested objects' do
+          record = subject.build
+
+          record.value.should eq('a')
+          record.b.size.should eq(1)
+          record.b.first.value.should eq('b')
+          record.b.first.c.size.should eq(1)
+          record.b.first.c.first.value.should eq('c')
+        end
+      end
+    end
+
+    context 'has_one' do
+      let(:model) { A }
+      let(:params) do
+        { a: { value: 'a', c: { value: 'c' } } }.with_indifferent_access
+      end
+
+      it 'build the nested objects' do
+        record = subject.build
+
+        record.valid?.should be_true
+        record.value.should eq('a')
+        record.c.value.should eq('c')
+        record.c.a.value.should eq('a')
+      end
+    end
+
+    context 'has_many' do
+      let(:model) { A }
+      let(:params) do
+        { a: { value: 'a', b: { value: 'b' } } }.with_indifferent_access
+      end
+
+      it 'build the nested objects' do
+        record = subject.build
+
+        record.valid?.should be_true
+        record.value.should eq('a')
+        record.b.map(&:value).to_a.should eq(['b'])
+        record.b.first.a.should eq(record)
+      end
+    end
+
+    context 'belongs_to' do
+      let(:model) { B }
+      let(:params) do
+        { b: { value: 'b', a: { value: 'a' } } }.with_indifferent_access
+      end
+
+      it 'build the nested objects' do
+        record = subject.build
+
+        record.valid?.should be_true
+        record.value.should eq('b')
+        record.a.value.should eq('a')
+        record.a.b.to_a.should eq([record])
+      end
+    end
+
+    context 'has_and_belongs_to_many' do
+      let(:model) { A }
+      let(:params) do
+        { a: { value: 'a', d: { value: 'd' } } }.with_indifferent_access
+      end
+
+      it 'build the nested objects' do
+        record = subject.build
+
+        record.valid?.should be_true
+        record.value.should eq('a')
+        record.d.map(&:value).to_a.should eq(['d'])
+        record.d.first.a.to_a.should eq([record])
+      end
+    end
+
+    context 'failed' do
+      let(:data) { { email: 'a' } }
+      after  { User.reset_callbacks(:validate) }
+
+      context 'mandatory parameter' do
+        let(:data) { Hash.new }
+        before     { User.class_eval { validates_presence_of :email } }
+
+        it {
+          begin
+            validate_error(subject.build, :email, "can't be blank")
+          rescue
+            puts $!.message
+            puts $!.backtrace
+
+          end
+            }
+      end
+
+      context 'length validations' do
+        before { User.class_eval { validates :email, length: { minimum: 2 } } }
+
+        it { validate_error(subject.build, :email, 'is too short (minimum is 2 characters)') }
+      end
+
+      context 'acceptance validation' do
+        before { User.class_eval { validates_acceptance_of :terms, allow_nil: false } }
+
+        it { validate_error(subject.build, :terms, 'must be accepted') }
+      end
+
+      context 'confirmation validation' do
+        let(:data) { { email: 'a', email_confirmation: 'b' } }
+        before { User.class_eval { validates :email, confirmation: true } }
+
+        it { validate_error(subject.build, :email_confirmation, "doesn't match Email") }
+      end
+
+      context 'exclusion validation' do
+        before { User.class_eval { validates :email, exclusion: { in: %w(a b) } } }
+
+        it { validate_error(subject.build, :email, 'is reserved') }
+      end
+
+      context 'format validation' do
+        before { User.class_eval { validates :email, format: { with: /[0-9]/ } } }
+
+        it { validate_error(subject.build, :email, 'is invalid') }
+      end
+
+      context 'inclusion validation' do
+        before { User.class_eval { validates :email, inclusion: { in: %w(b c) } } }
+
+        it { validate_error(subject.build, :email, 'is not included in the list') }
+      end
+
+      context 'numericality validation' do
+        before { User.class_eval { validates :email, numericality: true } }
+
+        it { validate_error(subject.build, :email, 'is not a number') }
+      end
+
+      context 'absence validation' do
+        before { User.class_eval { validates :email, absence: true } }
+
+        it { validate_error(subject.build, :email, 'must be blank') }
+      end
+
+      context 'uniqueness validation' do
+        before do
+          User.create!(data)
+          User.class_eval { validates :email, uniqueness: true }
+        end
+
+        it { validate_error(subject.build, :email, 'has already been taken', 1) }
+      end
+    end
+
+    private
+    def validate_error(record, field, msg, count = 0)
+      record.valid?.should be_false
+      record.errors.size.should eq(1)
+      record.errors[field].should eq([msg])
+      record.class.count.should eq(count)
+    end
+
+    def validate_record(record, field, value)
+      record.valid?.should be_true
+      record.send(field).should eq(value)
+    end
+  end
+end