spree_api 2.3.4 → 2.3.5

data/spec/controllers/spree/api/taxons_controller_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::TaxonsController do
+  describe Api::TaxonsController, :type => :controller do
     render_views
 
     let(:taxonomy) { create(:taxonomy) }
@@ -20,19 +20,19 @@ module Spree
       it "gets all taxons for a taxonomy" do
         api_get :index, :taxonomy_id => taxonomy.id
 
-        json_response['taxons'].first['name'].should eq taxon.name
+        expect(json_response['taxons'].first['name']).to eq taxon.name
         children = json_response['taxons'].first['taxons']
-        children.count.should eq 1
-        children.first['name'].should eq taxon2.name
-        children.first['taxons'].count.should eq 1
+        expect(children.count).to eq 1
+        expect(children.first['name']).to eq taxon2.name
+        expect(children.first['taxons'].count).to eq 1
       end
 
       # Regression test for #4112
       it "does not include children when asked not to" do
         api_get :index, :taxonomy_id => taxonomy.id, :without_children => 1
 
-        json_response['taxons'].first['name'].should eq(taxon.name)
-        json_response['taxons'].first['taxons'].should be_nil
+        expect(json_response['taxons'].first['name']).to eq(taxon.name)
+        expect(json_response['taxons'].first['taxons']).to be_nil
       end
 
       it "paginates through taxons" do
@@ -57,8 +57,8 @@ module Spree
             let(:name) { "Ruby" }
 
             it "returns an array including the matching taxon" do
-              json_response['taxons'].count.should == 1
-              json_response['taxons'].first['name'].should eq "Ruby"
+              expect(json_response['taxons'].count).to eq(1)
+              expect(json_response['taxons'].first['name']).to eq "Ruby"
             end
           end
 
@@ -66,8 +66,8 @@ module Spree
             let(:name) { "Imaginary" }
 
             it 'returns an empty array of taxons' do
-              json_response.keys.should include('taxons')
-              json_response['taxons'].count.should == 0
+              expect(json_response.keys).to include('taxons')
+              expect(json_response['taxons'].count).to eq(0)
             end
           end
         end
@@ -76,11 +76,11 @@ module Spree
           it "gets all taxons" do
             api_get :index
 
-            json_response['taxons'].first['name'].should eq taxonomy.root.name
+            expect(json_response['taxons'].first['name']).to eq taxonomy.root.name
             children = json_response['taxons'].first['taxons']
-            children.count.should eq 1
-            children.first['name'].should eq taxon.name
-            children.first['taxons'].count.should eq 1
+            expect(children.count).to eq 1
+            expect(children.first['name']).to eq taxon.name
+            expect(children.first['taxons'].count).to eq 1
           end
         end
       end
@@ -88,23 +88,23 @@ module Spree
       it "gets a single taxon" do
         api_get :show, :id => taxon.id, :taxonomy_id => taxonomy.id
 
-        json_response['name'].should eq taxon.name
-        json_response['taxons'].count.should eq 1
+        expect(json_response['name']).to eq taxon.name
+        expect(json_response['taxons'].count).to eq 1
       end
 
       it "gets all taxons in JSTree form" do
         api_get :jstree, :taxonomy_id => taxonomy.id, :id => taxon.id
         response = json_response.first
-        response["data"].should eq(taxon2.name)
-        response["attr"].should eq({ "name" => taxon2.name, "id" => taxon2.id})
-        response["state"].should eq("closed")
+        expect(response["data"]).to eq(taxon2.name)
+        expect(response["attr"]).to eq({ "name" => taxon2.name, "id" => taxon2.id})
+        expect(response["state"]).to eq("closed")
       end
 
       it "can learn how to create a new taxon" do
         api_get :new, :taxonomy_id => taxonomy.id
-        json_response["attributes"].should == attributes.map(&:to_s)
+        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
         required_attributes = json_response["required_attributes"]
-        required_attributes.should include("name")
+        expect(required_attributes).to include("name")
       end
 
       it "cannot create a new taxon if not an admin" do
@@ -128,48 +128,48 @@ module Spree
 
       it "can create" do
         api_post :create, :taxonomy_id => taxonomy.id, :taxon => { :name => "Colors" }
-        json_response.should have_attributes(attributes)
-        response.status.should == 201
+        expect(json_response).to have_attributes(attributes)
+        expect(response.status).to eq(201)
 
-        taxonomy.reload.root.children.count.should eq 2
+        expect(taxonomy.reload.root.children.count).to eq 2
         taxon = Spree::Taxon.where(:name => 'Colors').first
 
-        taxon.parent_id.should eq taxonomy.root.id
-        taxon.taxonomy_id.should eq taxonomy.id
+        expect(taxon.parent_id).to eq taxonomy.root.id
+        expect(taxon.taxonomy_id).to eq taxonomy.id
       end
 
       it "can update the position in the list" do
         taxonomy.root.children << taxon2
         api_put :update, :taxonomy_id => taxonomy.id, :id => taxon.id, :taxon => {:parent_id => taxon.parent_id, :child_index => 2 }
-        response.status.should == 200
-        taxonomy.reload.root.children[0].should eql taxon2
-        taxonomy.reload.root.children[1].should eql taxon
+        expect(response.status).to eq(200)
+        expect(taxonomy.reload.root.children[0]).to eql taxon2
+        expect(taxonomy.reload.root.children[1]).to eql taxon
       end
 
       it "cannot create a new taxon with invalid attributes" do
         api_post :create, :taxonomy_id => taxonomy.id, :taxon => {}
-        response.status.should == 422
-        json_response["error"].should == "Invalid resource. Please fix errors and try again."
+        expect(response.status).to eq(422)
+        expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
         errors = json_response["errors"]
 
-        taxonomy.reload.root.children.count.should eq 1
+        expect(taxonomy.reload.root.children.count).to eq 1
       end
 
       it "cannot create a new taxon with invalid taxonomy_id" do
         api_post :create, :taxonomy_id => 1000, :taxon => { :name => "Colors" }
-        response.status.should == 422
-        json_response["error"].should == "Invalid resource. Please fix errors and try again."
+        expect(response.status).to eq(422)
+        expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
 
         errors = json_response["errors"]
-        errors["taxonomy_id"].should_not be_nil
-        errors["taxonomy_id"].first.should eq "Invalid taxonomy id."
+        expect(errors["taxonomy_id"]).not_to be_nil
+        expect(errors["taxonomy_id"].first).to eq "Invalid taxonomy id."
 
-        taxonomy.reload.root.children.count.should eq 1
+        expect(taxonomy.reload.root.children.count).to eq 1
       end
 
       it "can destroy" do
         api_delete :destroy, :taxonomy_id => taxonomy.id, :id => taxon.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
     end
 

data/spec/controllers/spree/api/unauthenticated_products_controller_spec.rb

@@ -2,7 +2,7 @@ require 'shared_examples/protect_product_actions'
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ProductsController do
+  describe Spree::Api::ProductsController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -13,10 +13,10 @@ module Spree
 
       it "retreives a list of products" do
         api_get :index
-        json_response["products"].first.should have_attributes(attributes)
-        json_response["count"].should == 1
-        json_response["current_page"].should == 1
-        json_response["pages"].should == 1
+        expect(json_response["products"].first).to have_attributes(attributes)
+        expect(json_response["count"]).to eq(1)
+        expect(json_response["current_page"]).to eq(1)
+        expect(json_response["pages"]).to eq(1)
       end
 
       it_behaves_like "modifying product actions are restricted"

data/spec/controllers/spree/api/users_controller_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::UsersController do
+  describe Api::UsersController, :type => :controller do
     render_views
 
     let(:user) { create(:user) }
@@ -12,13 +12,13 @@ module Spree
 
     context "as a normal user" do
       before do
-        controller.stub :try_spree_current_user => user
+        allow(controller).to receive_messages :try_spree_current_user => user
       end
 
       it "can get own details" do
         api_get :show, :id => user.id
 
-        json_response['email'].should eq user.email
+        expect(json_response['email']).to eq user.email
       end
 
       it "cannot get other users details" do
@@ -29,19 +29,19 @@ module Spree
 
       it "can learn how to create a new user" do
         api_get :new
-        json_response["attributes"].should == attributes.map(&:to_s)
+        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
       end
 
       it "can create a new user" do
         api_post :create, :user => { :email => 'new@example.com', :password => 'spree123', :password_confirmation => 'spree123' }
-        json_response['email'].should eq 'new@example.com'
+        expect(json_response['email']).to eq 'new@example.com'
       end
 
       # there's no validations on LegacyUser?
       xit "cannot create a new user with invalid attributes" do
         api_post :create, :user => {}
-        response.status.should == 422
-        json_response["error"].should == "Invalid resource. Please fix errors and try again."
+        expect(response.status).to eq(422)
+        expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
         errors = json_response["errors"]
       end
 
@@ -82,7 +82,7 @@ module Spree
 
       it "can delete itself" do
         api_delete :destroy, :id => user.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
 
       it "cannot delete other user" do
@@ -94,9 +94,9 @@ module Spree
         2.times { create(:user) }
         api_get :index
 
-        Spree.user_class.count.should eq 3
-        json_response['count'].should eq 1
-        json_response['users'].size.should eq 1
+        expect(Spree.user_class.count).to eq 3
+        expect(json_response['count']).to eq 1
+        expect(json_response['users'].size).to eq 1
       end
     end
 
@@ -104,48 +104,48 @@ module Spree
       sign_in_as_admin!
 
       it "gets all users" do
-        Spree::LegacyUser.stub(:find_by).with(hash_including(:spree_api_key)) { current_api_user }
+        allow(Spree::LegacyUser).to receive(:find_by).with(hash_including(:spree_api_key)) { current_api_user }
 
         2.times { create(:user) }
 
         api_get :index
-        Spree.user_class.count.should eq 2
-        json_response['count'].should eq 2
-        json_response['users'].size.should eq 2
+        expect(Spree.user_class.count).to eq 2
+        expect(json_response['count']).to eq 2
+        expect(json_response['users'].size).to eq 2
       end
 
       it 'can control the page size through a parameter' do
         2.times { create(:user) }
         api_get :index, :per_page => 1
-        json_response['count'].should == 1
-        json_response['current_page'].should == 1
-        json_response['pages'].should == 2
+        expect(json_response['count']).to eq(1)
+        expect(json_response['current_page']).to eq(1)
+        expect(json_response['pages']).to eq(2)
       end
 
       it 'can query the results through a paramter' do
         expected_result = create(:user, :email => 'brian@spreecommerce.com')
         api_get :index, :q => { :email_cont => 'brian' }
-        json_response['count'].should == 1
-        json_response['users'].first['email'].should eq expected_result.email
+        expect(json_response['count']).to eq(1)
+        expect(json_response['users'].first['email']).to eq expected_result.email
       end
 
       it "can create" do
         api_post :create, :user => { :email => "new@example.com", :password => 'spree123', :password_confirmation => 'spree123' }
-        json_response.should have_attributes(attributes)
-        response.status.should == 201
+        expect(json_response).to have_attributes(attributes)
+        expect(response.status).to eq(201)
       end
 
       it "can destroy user without orders" do
         user.orders.destroy_all
         api_delete :destroy, :id => user.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
 
       it "cannot destroy user with orders" do
         create(:completed_order_with_totals, :user => user)
         api_delete :destroy, :id => user.id
-        json_response["exception"].should eq "Spree::Core::DestroyWithOrdersError"
-        response.status.should == 422
+        expect(json_response["exception"]).to eq "Spree::Core::DestroyWithOrdersError"
+        expect(response.status).to eq(422)
       end
 
     end

data/spec/controllers/spree/api/variants_controller_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::VariantsController do
+  describe Api::VariantsController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -22,32 +22,32 @@ module Spree
     it "can see a paginated list of variants" do
       api_get :index
       first_variant = json_response["variants"].first
-      first_variant.should have_attributes(show_attributes)
-      first_variant["stock_items"].should be_present
-      json_response["count"].should == 1
-      json_response["current_page"].should == 1
-      json_response["pages"].should == 1
+      expect(first_variant).to have_attributes(show_attributes)
+      expect(first_variant["stock_items"]).to be_present
+      expect(json_response["count"]).to eq(1)
+      expect(json_response["current_page"]).to eq(1)
+      expect(json_response["pages"]).to eq(1)
     end
 
     it 'can control the page size through a parameter' do
       create(:variant)
       api_get :index, :per_page => 1
-      json_response['count'].should == 1
-      json_response['current_page'].should == 1
-      json_response['pages'].should == 3
+      expect(json_response['count']).to eq(1)
+      expect(json_response['current_page']).to eq(1)
+      expect(json_response['pages']).to eq(3)
     end
 
     it 'can query the results through a paramter' do
       expected_result = create(:variant, :sku => 'FOOBAR')
       api_get :index, :q => { :sku_cont => 'FOO' }
-      json_response['count'].should == 1
-      json_response['variants'].first['sku'].should eq expected_result.sku
+      expect(json_response['count']).to eq(1)
+      expect(json_response['variants'].first['sku']).to eq expected_result.sku
     end
 
     it "variants returned contain option values data" do
       api_get :index
       option_values = json_response["variants"].last["option_values"]
-      option_values.first.should have_attributes([:name,
+      expect(option_values.first).to have_attributes([:name,
                                                  :presentation,
                                                  :option_type_name,
                                                  :option_type_id])
@@ -58,8 +58,8 @@ module Spree
 
       api_get :index
 
-      json_response["variants"].last.should have_attributes([:images])
-      json_response['variants'].first['images'].first.should have_attributes([:attachment_file_name,
+      expect(json_response["variants"].last).to have_attributes([:images])
+      expect(json_response['variants'].first['images'].first).to have_attributes([:attachment_file_name,
                                                                                :attachment_width,
                                                                                :attachment_height,
                                                                                :attachment_content_type,
@@ -78,12 +78,12 @@ module Spree
 
       it "is not returned in the results" do
         api_get :index
-        json_response["variants"].count.should == 0
+        expect(json_response["variants"].count).to eq(0)
       end
 
       it "is not returned even when show_deleted is passed" do
         api_get :index, :show_deleted => true
-        json_response["variants"].count.should == 0
+        expect(json_response["variants"].count).to eq(0)
       end
     end
 
@@ -91,19 +91,19 @@ module Spree
       it "can select the next page of variants" do
         second_variant = create(:variant)
         api_get :index, :page => 2, :per_page => 1
-        json_response["variants"].first.should have_attributes(show_attributes)
-        json_response["total_count"].should == 3
-        json_response["current_page"].should == 2
-        json_response["pages"].should == 3
+        expect(json_response["variants"].first).to have_attributes(show_attributes)
+        expect(json_response["total_count"]).to eq(3)
+        expect(json_response["current_page"]).to eq(2)
+        expect(json_response["pages"]).to eq(3)
       end
     end
 
     it "can see a single variant" do
       api_get :show, :id => variant.to_param
-      json_response.should have_attributes(show_attributes)
-      json_response["stock_items"].should be_present
+      expect(json_response).to have_attributes(show_attributes)
+      expect(json_response["stock_items"]).to be_present
       option_values = json_response["option_values"]
-      option_values.first.should have_attributes([:name,
+      expect(option_values.first).to have_attributes([:name,
                                                  :presentation,
                                                  :option_type_name,
                                                  :option_type_id])
@@ -114,9 +114,9 @@ module Spree
 
       api_get :show, :id => variant.to_param
 
-      json_response.should have_attributes(show_attributes + [:images])
+      expect(json_response).to have_attributes(show_attributes + [:images])
       option_values = json_response["option_values"]
-      option_values.first.should have_attributes([:name,
+      expect(option_values.first).to have_attributes([:name,
                                                  :presentation,
                                                  :option_type_name,
                                                  :option_type_id])
@@ -124,8 +124,8 @@ module Spree
 
     it "can learn how to create a new variant" do
       api_get :new
-      json_response["attributes"].should == new_attributes.map(&:to_s)
-      json_response["required_attributes"].should be_empty
+      expect(json_response["attributes"]).to eq(new_attributes.map(&:to_s))
+      expect(json_response["required_attributes"]).to be_empty
     end
 
     it "cannot create a new variant if not an admin" do
@@ -141,7 +141,7 @@ module Spree
     it "cannot delete a variant" do
       api_delete :destroy, :id => variant.to_param
       assert_not_found!
-      lambda { variant.reload }.should_not raise_error
+      expect { variant.reload }.not_to raise_error
     end
 
     context "as an admin" do
@@ -156,28 +156,28 @@ module Spree
 
         it "are visible by admin" do
           api_get :index, :show_deleted => 1
-          json_response["variants"].count.should == 1
+          expect(json_response["variants"].count).to eq(1)
         end
       end
 
       it "can create a new variant" do
         api_post :create, :variant => { :sku => "12345" }
-        json_response.should have_attributes(new_attributes)
-        response.status.should == 201
-        json_response["sku"].should == "12345"
+        expect(json_response).to have_attributes(new_attributes)
+        expect(response.status).to eq(201)
+        expect(json_response["sku"]).to eq("12345")
 
-        variant.product.variants.count.should == 1
+        expect(variant.product.variants.count).to eq(1)
       end
 
       it "can update a variant" do
         api_put :update, :id => variant.to_param, :variant => { :sku => "12345" }
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "can delete a variant" do
         api_delete :destroy, :id => variant.to_param
-        response.status.should == 204
-        lambda { Spree::Variant.find(variant.id) }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { Spree::Variant.find(variant.id) }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end