acts_as_api 0.4.4 → 1.0.0

data/spec/support/model_examples/enabled.rb

@@ -1,10 +1,9 @@
-shared_examples_for "acts_as_api is enabled" do
-
-  it "indicates that acts_as_api is enabled" do
-    User.acts_as_api?.should == true
+shared_examples_for 'acts_as_api is enabled' do
+  it 'indicates that acts_as_api is enabled' do
+    expect(User.acts_as_api?).to eq(true)
   end
 
-  it "does respond to api_accessible" do
-    User.should respond_to :api_accessible
+  it 'does respond to api_accessible' do
+    expect(User).to respond_to :api_accessible
   end
 end

data/spec/support/model_examples/extending.rb

@@ -1,112 +1,105 @@
-shared_examples_for "extending a given api template" do
-
-  describe "multiple times" do
-
+shared_examples_for 'extending a given api template' do
+  describe 'multiple times' do
     before(:each) do
       User.api_accessible :public do |t|
         t.add :first_name
       end
 
-      User.api_accessible :for_buddies, :extend => :public do |t|
+      User.api_accessible :for_buddies, extend: :public do |t|
         t.add :age
       end
 
-      User.api_accessible :private, :extend => :for_buddies do |t|
+      User.api_accessible :private, extend: :for_buddies do |t|
         t.add :last_name
       end
-      @response = @luke.as_api_response(:private)
     end
 
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
-    end
+    subject(:response) { @luke.as_api_response(:private) }
 
-    it "returns the correct number of fields" do
-      @response.should have(3).keys
+    it 'returns a hash' do
+      expect(response).to be_kind_of(Hash)
     end
 
-    it "returns all specified fields" do
-      @response.keys.sort_by(&:to_s).should eql([:age, :first_name, :last_name])
+    it 'returns the correct number of fields' do
+      expect(response).to have(3).keys
     end
 
-    it "returns the correct values for the specified fields" do
-      @response.values.sort_by(&:to_s).should eql([@luke.age, @luke.first_name, @luke.last_name].sort_by(&:to_s))
+    it 'returns all specified fields' do
+      expect(response.keys.sort_by(&:to_s)).to eql([:age, :first_name, :last_name])
     end
 
+    it 'returns the correct values for the specified fields' do
+      expect(response.values.sort_by(&:to_s)).to eql([@luke.age, @luke.first_name, @luke.last_name].sort_by(&:to_s))
+    end
   end
 
-  describe "and removing a former added value" do
+  describe 'and removing a former added value' do
+    subject(:response) { @luke.as_api_response(:age_and_first_name) }
 
-    before(:each) do
-      @response = @luke.as_api_response(:age_and_first_name)
+    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(2).keys
     end
 
-    it "returns the correct number of fields" do
-      @response.should have(2).keys
+    it 'returns all specified fields' do
+      expect(response.keys.sort_by(&:to_s)).to eql([:first_name, :age].sort_by(&:to_s))
     end
 
-    it "returns all specified fields" do
-      @response.keys.sort_by(&:to_s).should eql([:first_name, :age].sort_by(&:to_s))
+    it 'returns the correct values for the specified fields' do
+      expect(response.values.sort_by(&:to_s)).to eql([@luke.first_name, @luke.age].sort_by(&:to_s))
     end
-
-    it "returns the correct values for the specified fields" do
-      @response.values.sort_by(&:to_s).should eql([@luke.first_name, @luke.age].sort_by(&:to_s))
-    end
-
   end
 
-  describe "and inherit a field using another template name", :meow => true do
-
+  describe 'and inherit a field 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
-      User.api_accessible :extending_other_template, :extend => :other_sub_template
-      @response = @luke.as_api_response(:extending_other_template)
+      User.api_accessible :extending_other_template, extend: :other_sub_template
     end
 
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    subject(:response) { @luke.as_api_response(:extending_other_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
-
-end
+end

data/spec/support/model_examples/methods.rb

@@ -1,23 +1,19 @@
-shared_examples_for "calling a method in the api template" do
+shared_examples_for 'calling a method in the api template' do
+  subject(:response) { @luke.as_api_response(:only_full_name) }
 
-  before(:each) do
-    @response = @luke.as_api_response(:only_full_name)
+  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 by name' do
+    expect(response.keys).to include(:full_name)
   end
 
-  it "returns all specified fields by name" do
-    @response.keys.should include(:full_name)
+  it 'returns the correct values for the specified fields' do
+    expect(response.values).to include(@luke.full_name)
   end
-
-  it "returns the correct values for the specified fields" do
-    @response.values.should include(@luke.full_name)
-  end
-
-end
+end

data/spec/support/model_examples/options.rb

@@ -1,53 +1,47 @@
-shared_examples_for "options" do
-
-  describe "options in the api template" do
-
+shared_examples_for 'options' do
+  describe 'options in the api template' do
     before :each do
       User.api_accessible :with_options do |t|
-        t.add lambda{|model,options| options }, :as => :options
+        t.add ->(_, options) { options }, as: :options
         t.add :profile
-        t.add :first_name, :if => lambda{|m,options| options[:with_name] }
+        t.add :first_name, if: ->(_, options) { options[:with_name] }
       end
 
       Profile.acts_as_api
       Profile.api_accessible :with_options do |t|
-        t.add lambda{|model,options| options }, :as => :options
+        t.add ->(_, options) { options }, as: :options
       end
 
       Task.acts_as_api
       Task.api_accessible :other_template do |t|
         t.add :description
         t.add :time_spent
-        t.add lambda{|model,options| options }, :as => :options
+        t.add ->(_, options) { options }, as: :options
       end
     end
 
-    context "as_api_response accept options" do
-      before :each do 
-        @response = @luke.as_api_response(:with_options, :loc => [12, 13])
-      end
+    context 'as_api_response accept options' do
+      subject(:response) { @luke.as_api_response(:with_options, loc: [12, 13]) }
 
-      it "returns the options field as specified" do
-        @response[:options][:loc].should      == [12, 13]
+      it 'returns the options field as specified' do
+        expect(response[:options][:loc]).to eq([12, 13])
       end
 
-      it "returns the option for the associations " do
-        @response[:profile][:options][:loc].should      == [12, 13]
+      it 'returns the option for the associations ' do
+        expect(response[:profile][:options][:loc]).to eq([12, 13])
       end
-
     end
 
-    context "allowed_to_render accept options" do
-      it "should not contains first_name when options[:with_name] is false" do
-        @response = @luke.as_api_response(:with_options, :with_name => false)
-        @response.should_not     include(:first_name)
+    context 'allowed_to_render accept options' do
+      it 'should not contains first_name when options[:with_name] is false' do
+        response = @luke.as_api_response(:with_options, with_name: false)
+        expect(response).not_to include(:first_name)
       end
 
-      it "should contains first_name when options[:with_name] is true" do
-        @response = @luke.as_api_response(:with_options, :with_name => true)
-        @response[:first_name].should     == 'Luke'
+      it 'should contains first_name when options[:with_name] is true' do
+        response = @luke.as_api_response(:with_options, with_name: true)
+        expect(response[:first_name]).to eq('Luke')
       end
     end
-
   end
 end

data/spec/support/model_examples/renaming.rb

@@ -1,50 +1,41 @@
-shared_examples_for "renaming" do
+shared_examples_for 'renaming' do
+  describe 'an attribute in the api template' do
+    subject(:response) { @luke.as_api_response(:rename_last_name) }
 
-  describe "an attribute in the api template" do
-
-    before(:each) do
-      @response = @luke.as_api_response(:rename_last_name)
-    end
-
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    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(:family_name)
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:family_name)
     end
 
-    it "returns the correct values for the specified fields" do
-      @response.values.should include(@luke.last_name)
+    it 'returns the correct values for the specified fields' do
+      expect(response.values).to include(@luke.last_name)
     end
-
   end
 
-  describe "the node/key of a method in the api template" do
+  describe 'the node/key of a method in the api template' do
+    subject(:response) { @luke.as_api_response(:rename_full_name) }
 
-    before(:each) do
-      @response = @luke.as_api_response(:rename_full_name)
+    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(:other_full_name)
     end
 
-    it "returns all specified fields" do
-      @response.keys.should include(:other_full_name)
+    it 'returns the correct values for the specified fields' do
+      expect(response.values).to include(@luke.full_name)
     end
-
-    it "returns the correct values for the specified fields" do
-      @response.values.should include(@luke.full_name)
-    end
-
   end
 end

data/spec/support/model_examples/simple.rb

@@ -1,23 +1,19 @@
-shared_examples_for "listing attributes in the api template" do
+shared_examples_for 'listing attributes in the api template' do
+  subject(:response) { @luke.as_api_response(:name_only) }
 
-  before(:each) do
-    @response = @luke.as_api_response(:name_only)
+  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(2).keys
   end
 
-  it "returns the correct number of fields" do
-    @response.should have(2).keys
+  it 'returns the specified fields only' do
+    expect(response.keys).to include(:first_name, :last_name)
   end
 
-  it "returns the specified fields only" do
-    @response.keys.should include(:first_name, :last_name)
+  it 'the specified fields have the correct value' do
+    expect(response.values).to include(@luke.first_name, @luke.last_name)
   end
-
-  it "the specified fields have the correct value" do
-    @response.values.should include(@luke.first_name, @luke.last_name)
-  end
-
 end

data/spec/support/model_examples/sub_nodes.rb

@@ -1,105 +1,93 @@
-shared_examples_for "creating a sub hash in the api template" do
+shared_examples_for 'creating a sub hash in the api template' do
+  describe 'and putting an attribute in it' do
+    subject(:response) { @luke.as_api_response(:sub_node) }
 
-  describe "and putting an attribute in it" do
-
-    before(:each) do
-      @response = @luke.as_api_response(:sub_node)
-    end
-
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    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(:sub_nodes)
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:sub_nodes)
     end
 
-    it "returns the correct values for the specified fields" do
-      @response[:sub_nodes].should be_a Hash
+    it 'returns the correct values for the specified fields' do
+      expect(response[:sub_nodes]).to be_a Hash
     end
 
-    it "provides the correct number of sub nodes" do
-      @response[:sub_nodes].should have(1).keys
+    it 'provides the correct number of sub nodes' do
+      expect(response[:sub_nodes]).to have(1).keys
     end
 
-    it "provides the correct sub nodes values" do
-      @response[:sub_nodes][:foo].should eql("something")
+    it 'provides the correct sub nodes values' do
+      expect(response[:sub_nodes][:foo]).to eql('something')
     end
   end
 
-  describe "multiple times and putting an attribute in it" do
-
-    before(:each) do
-      @response = @luke.as_api_response(:nested_sub_node)
-    end
+  describe 'multiple times and putting an attribute in it' do
+    subject(:response) { @luke.as_api_response(:nested_sub_node) }
 
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    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(:sub_nodes)
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:sub_nodes)
     end
 
-    it "returns the correct values for the specified fields" do
-      @response[:sub_nodes].should be_a Hash
+    it 'returns the correct values for the specified fields' do
+      expect(response[:sub_nodes]).to be_a Hash
     end
 
-    it "provides the correct number of sub nodes" do
-      @response[:sub_nodes].should have(1).keys
+    it 'provides the correct number of sub nodes' do
+      expect(response[:sub_nodes]).to have(1).keys
     end
 
-    it "provides the correct number of sub nodes in the second level" do
-      @response[:sub_nodes][:foo].should have(1).keys
+    it 'provides the correct number of sub nodes in the second level' do
+      expect(response[:sub_nodes][:foo]).to have(1).keys
     end
 
-    it "provides the correct sub nodes values" do
-      @response[:sub_nodes][:foo].tap do |foo|
+    it 'provides the correct sub nodes values' do
+      response[:sub_nodes][:foo].tap do |foo|
         foo[:bar].tap do |bar|
-          bar.should eql(@luke.last_name)
+          expect(bar).to eql(@luke.last_name)
         end
       end
     end
-
   end
 
-  describe "using a method" do
-
-    before(:each) do
-      @response = @luke.as_api_response(:nested_sub_hash)
-    end
+  describe 'using a method' do
+    subject(:response) { @luke.as_api_response(:nested_sub_hash) }
 
-    it "returns a hash" do
-      @response.should be_kind_of(Hash)
+    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(:sub_hash)
+    it 'returns all specified fields' do
+      expect(response.keys).to include(:sub_hash)
     end
 
-    it "provides the correct number of sub nodes" do
-      @response[:sub_hash].should have(2).keys
+    it 'provides the correct number of sub nodes' do
+      expect(response[:sub_hash]).to have(2).keys
     end
 
-    it "provides the correct sub nodes" do
-      @response[:sub_hash].keys.should include(:foo, :hello)
+    it 'provides the correct sub nodes' do
+      expect(response[:sub_hash].keys).to include(:foo, :hello)
     end
 
-    it "provides the correct values in its sub nodes" do
-      @response[:sub_hash].values.should include("bar", "world")
+    it 'provides the correct values in its sub nodes' do
+      expect(response[:sub_hash].values).to include('bar', 'world')
     end
-
   end
-end
+end