acts_as_api 0.4.4 → 1.0.0

data/spec/support/it_supports.rb

@@ -1,3 +1,3 @@
 RSpec.configure do |c|
   c.alias_it_should_behave_like_to :it_supports, 'supports:'
-end
+end

data/spec/support/model_examples/associations.rb

@@ -1,271 +1,262 @@
-shared_examples_for "including an association in the api template" do
+shared_examples_for 'including an association in the api template' do
+  describe 'which does not acts_as_api' do
+    subject(:response) { @luke.as_api_response(:include_tasks) }
 
-  describe "which doesn't acts_as_api" do
-
-    before(:each) do
-      @response = @luke.as_api_response(:include_tasks)
+    it 'returns a hash' do
+      expect(response).to be_kind_of(Hash)
     end
 
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    it 'returns the correct number of fields' do
+      expect(response).to have(1).keys
     end
 
-    it "returns the correct number of fields" do
-      @response.should have(1).keys
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:tasks)
     end
 
-    it "returns all specified fields" do
-      @response.keys.should include(:tasks)
+    it 'returns the correct values for the specified fields' do
+      expect(response[:tasks]).to be_an Array
+      expect(response[:tasks].size).to eq(3)
     end
 
-    it "returns the correct values for the specified fields" do
-      @response[:tasks].should be_an Array
-      @response[:tasks].should have(3).tasks
-    end
-
-    it "should contain the associated sub models" do
-      @response[:tasks].should include(@destroy_deathstar, @study_with_yoda, @win_rebellion)
+    it 'should contain the associated sub models' do
+      expect(response[:tasks]).to include(@destroy_deathstar, @study_with_yoda, @win_rebellion)
     end
   end
 
-  describe "which does acts_as_api" do
-
-    context "has_many" do
-
+  describe 'which does acts_as_api' do
+    context 'has_many' do
       before(:each) do
         Task.acts_as_api
         Task.api_accessible :include_tasks do |t|
           t.add :heading
           t.add :done
         end
-        @response = @luke.as_api_response(:include_tasks)
       end
 
-      it "returns a hash" do
-        @response.should be_kind_of(Hash)
+      subject(:response) { @luke.as_api_response(:include_tasks) }
+
+      it 'returns a hash' do
+        expect(response).to be_kind_of(Hash)
       end
 
-      it "returns the correct number of fields" do
-        @response.should have(1).keys
+      it 'returns the correct number of fields' do
+        expect(response).to have(1).keys
       end
 
-      it "returns all specified fields" do
-        @response.keys.should include(:tasks)
+      it 'returns all specified fields' do
+        expect(response.keys).to include(:tasks)
       end
 
-      it "returns the correct values for the specified fields" do
-        @response[:tasks].should be_an Array
-        @response[:tasks].should have(3).tasks
+      it 'returns the correct values for the specified fields' do
+        expect(response[:tasks]).to be_an Array
+        expect(response[:tasks].size).to eq(3)
       end
 
-      it "contains the associated child models with the determined api template" do
-        @response[:tasks].each do |task|
-          task.keys.should include(:heading, :done)
-          task.keys.should have(2).attributes
+      it 'contains the associated child models with the determined api template' do
+        response[:tasks].each do |task|
+          expect(task.keys).to include(:heading, :done)
+          expect(task.keys.size).to eq(2)
         end
       end
 
-      it "contains the correct data of the child models" do
-        task_hash = [  @destroy_deathstar, @study_with_yoda, @win_rebellion  ].collect{|t| { :done => t.done, :heading => t.heading } }
-        @response[:tasks].should eql task_hash
+      it 'contains the correct data of the child models' do
+        task_hash = [@destroy_deathstar, @study_with_yoda, @win_rebellion].collect { |t| { done: t.done, heading: t.heading } }
+        expect(response[:tasks]).to eql task_hash
       end
     end
 
-    context "has_one" do
-
+    context 'has_one' do
       before(:each) do
         Profile.acts_as_api
         Profile.api_accessible :include_profile do |t|
           t.add :avatar
           t.add :homepage
         end
-        @response = @luke.as_api_response(:include_profile)
       end
 
-      it "returns a hash" do
-        @response.should be_kind_of(Hash)
-      end
+      subject(:response) { @luke.as_api_response(:include_profile) }
 
-      it "returns the correct number of fields" do
-        @response.should have(1).keys
+      it 'returns a hash' do
+        expect(response).to be_kind_of(Hash)
       end
 
-      it "returns all specified fields" do
-        @response.keys.should include(:profile)
+      it 'returns the correct number of fields' do
+        expect(response).to have(1).keys
       end
 
-      it "returns the correct values for the specified fields" do
-        @response[:profile].should be_a Hash
-        @response[:profile].should have(2).attributes
+      it 'returns all specified fields' do
+        expect(response.keys).to include(:profile)
       end
 
-      it "contains the associated child models with the determined api template" do
-        @response[:profile].keys.should include(:avatar, :homepage)
+      it 'returns the correct values for the specified fields' do
+        expect(response[:profile]).to be_a Hash
+        expect(response[:profile].size).to eq(2)
       end
 
-      it "contains the correct data of the child models" do
-        profile_hash = { :avatar => @luke.profile.avatar, :homepage => @luke.profile.homepage }
-        @response[:profile].should eql profile_hash
+      it 'contains the associated child models with the determined api template' do
+        expect(response[:profile].keys).to include(:avatar, :homepage)
       end
 
+      it 'contains the correct data of the child models' do
+        profile_hash = { avatar: @luke.profile.avatar, homepage: @luke.profile.homepage }
+        expect(response[:profile]).to eql profile_hash
+      end
     end
   end
 
-  describe "which does acts_as_api, but with using another template name" do
-
+  describe 'which does acts_as_api, but with using another template name' do
     before(:each) do
       Task.acts_as_api
       Task.api_accessible :other_template do |t|
         t.add :description
         t.add :time_spent
       end
-      @response = @luke.as_api_response(:other_sub_template)
     end
 
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    subject(:response) { @luke.as_api_response(:other_sub_template) }
+
+    it 'returns a hash' do
+      expect(response).to be_kind_of(Hash)
     end
 
-    it "returns the correct number of fields" do
-      @response.should have(2).keys
+    it 'returns the correct number of fields' do
+      expect(response).to have(2).keys
     end
 
-    it "returns all specified fields" do
-      @response.keys.should include(:first_name)
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:first_name)
     end
 
-    it "returns the correct values for the specified fields" do
-      @response.values.should include(@luke.first_name)
+    it 'returns the correct values for the specified fields' do
+      expect(response.values).to include(@luke.first_name)
     end
 
-    it "returns all specified fields" do
-      @response.keys.should include(:tasks)
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:tasks)
     end
 
-    it "returns the correct values for the specified fields" do
-      @response[:tasks].should be_an Array
-      @response[:tasks].should have(3).tasks
+    it 'returns the correct values for the specified fields' do
+      expect(response[:tasks]).to be_an Array
+      expect(response[:tasks].size).to eq(3)
     end
 
-    it "contains the associated child models with the determined api template" do
-      @response[:tasks].each do |task|
-        task.keys.should include(:description, :time_spent)
-        task.keys.should have(2).attributes
+    it 'contains the associated child models with the determined api template' do
+      response[:tasks].each do |task|
+        expect(task.keys).to include(:description, :time_spent)
+        expect(task.keys.size).to eq(2)
       end
     end
 
-    it "contains the correct data of the child models" do
-      task_hash = [  @destroy_deathstar, @study_with_yoda, @win_rebellion  ].collect{|t| { :description => t.description, :time_spent => t.time_spent } }
-      @response[:tasks].should eql task_hash
+    it 'contains the correct data of the child models' do
+      task_hash = [@destroy_deathstar, @study_with_yoda, @win_rebellion].collect { |t| { description: t.description, time_spent: t.time_spent } }
+      expect(response[:tasks]).to eql task_hash
     end
   end
 
-  describe "that is scoped" do
-
+  describe 'that is scoped' do
     before(:each) do
       # extend task model with scope
-      #class Task < ActiveRecord::Base
       Task.class_eval do
-        scope :completed, -> { where(:done => true) }
+        scope :completed, -> { where(done: true) }
       end
       Task.acts_as_api
       Task.api_accessible :include_completed_tasks do |t|
         t.add :heading
         t.add :done
       end
-
-      @response = @luke.as_api_response(:include_completed_tasks)
     end
 
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    subject(:response) { @luke.as_api_response(:include_completed_tasks) }
+
+    it 'returns a hash' do
+      expect(response).to be_kind_of(Hash)
     end
 
-    it "returns the correct number of fields" do
-      @response.should have(1).keys
+    it 'returns the correct number of fields' do
+      expect(response.size).to eq(1)
     end
 
-    it "returns all specified fields" do
-      @response.keys.should include(:completed_tasks)
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:completed_tasks)
     end
 
-    it "returns the correct values for the specified fields" do
-      @response[:completed_tasks].should be_an Array
-      @response[:completed_tasks].should have(2).tasks
+    it 'returns the correct values for the specified fields' do
+      expect(response[:completed_tasks]).to be_an Array
+      expect(response[:completed_tasks].size).to eq(2)
     end
 
-    it "contains the associated child models with the determined api template" do
-      @response[:completed_tasks].each do |task|
-        task.keys.should include(:heading, :done)
-        task.keys.should have(2).attributes
+    it 'contains the associated child models with the determined api template' do
+      response[:completed_tasks].each do |task|
+        expect(task.keys).to include(:heading, :done)
+        expect(task.keys.size).to eq(2)
       end
     end
 
-    it "contains the correct data of the child models" do
-      task_hash = [  @destroy_deathstar, @study_with_yoda  ].collect{|t| { :done => t.done, :heading => t.heading } }
-      @response[:completed_tasks].should eql task_hash
+    it 'contains the correct data of the child models' do
+      task_hash = [@destroy_deathstar, @study_with_yoda].collect { |t| { done: t.done, heading: t.heading } }
+      expect(response[:completed_tasks]).to eql task_hash
     end
   end
 
-  describe "handling nil values" do
-
-    context "has_many" do
-
+  describe 'handling nil values' do
+    context 'has_many' do
       before(:each) do
         Task.acts_as_api
         Task.api_accessible :include_tasks do |t|
           t.add :heading
           t.add :done
         end
-        @response = @han.as_api_response(:include_tasks)
       end
 
-      it "returns a hash" do
-        @response.should be_kind_of(Hash)
-      end
+      subject(:response) { @han.as_api_response(:include_tasks) }
 
-      it "returns the correct number of fields" do
-        @response.should have(1).keys
+      it 'returns a hash' do
+        expect(response).to be_kind_of(Hash)
       end
 
-      it "returns all specified fields" do
-        @response.keys.should include(:tasks)
+      it 'returns the correct number of fields' do
+        expect(response).to have(1).keys
       end
 
-      it "returns the correct values for the specified fields" do
-        @response[:tasks].should be_kind_of(Array)
+      it 'returns all specified fields' do
+        expect(response.keys).to include(:tasks)
       end
 
-      it "contains no associated child models" do
-        @response[:tasks].should have(0).items
+      it 'returns the correct values for the specified fields' do
+        expect(response[:tasks]).to be_kind_of(Array)
       end
 
+      it 'contains no associated child models' do
+        expect(response[:tasks]).to have(0).items
+      end
     end
 
-    context "has one" do
+    context 'has one' do
       before(:each) do
         Profile.acts_as_api
         Profile.api_accessible :include_profile do |t|
           t.add :avatar
           t.add :homepage
         end
-        @response = @han.as_api_response(:include_profile)
       end
 
-      it "returns a hash" do
-        @response.should be_kind_of(Hash)
+      subject(:response) { @han.as_api_response(:include_profile) }
+
+      it 'returns a hash' do
+        expect(response).to be_kind_of(Hash)
       end
 
-      it "returns the correct number of fields" do
-        @response.should have(1).keys
+      it 'returns the correct number of fields' do
+        expect(response).to have(1).keys
       end
 
-      it "returns all specified fields" do
-        @response.keys.should include(:profile)
+      it 'returns all specified fields' do
+        expect(response.keys).to include(:profile)
       end
 
-      it "returns nil for the association" do
-        @response[:profile].should be_nil
+      it 'returns nil for the association' do
+        expect(response[:profile]).to be_nil
       end
     end
   end

data/spec/support/model_examples/callbacks.rb

@@ -1,38 +1,28 @@
-shared_examples_for "defining a model callback" do
-
-  describe "for a" do
-    
-    describe "around_api_response" do
-      
-      it "skips rendering if not yielded" do
+shared_examples_for 'defining a model callback' do
+  describe 'for a' do
+    describe 'around_api_response' do
+      it 'skips rendering if not yielded' do
         @luke.skip_api_response = true
-        @luke.as_api_response(:name_only).keys.should include(:skipped)
+        expect(@luke.as_api_response(:name_only).keys).to include(:skipped)
       end
-      
-      it "renders if yielded" do
-        @luke.as_api_response(:name_only).keys.should_not include(:skipped)
+
+      it 'renders if yielded' do
+        expect(@luke.as_api_response(:name_only).keys).not_to include(:skipped)
       end
-    
     end
-    
-    describe "before_api_response" do 
-      
-      it "is called properly" do
+
+    describe 'before_api_response' do
+      it 'is called properly' do
         @luke.as_api_response(:name_only)
-        @luke.before_api_response_called?.should eql(true)
+        expect(@luke.before_api_response_called?).to eql(true)
       end
-      
     end
-    
-    describe "after_api_response" do 
-      
-      it "is called properly" do
+
+    describe 'after_api_response' do
+      it 'is called properly' do
         @luke.as_api_response(:name_only)
-        @luke.after_api_response_called?.should eql(true)
+        expect(@luke.after_api_response_called?).to eql(true)
       end
-      
     end
-    
   end
-
-end
+end