spree_api 2.3.4 → 2.3.5

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::PaymentsController do
+  describe Spree::Api::PaymentsController, :type => :controller do
     render_views
     let!(:order) { create(:order) }
     let!(:payment) { create(:payment, :order => order) }
@@ -18,30 +18,30 @@ module Spree
     context "as a user" do
       context "when the order belongs to the user" do
         before do
-          Order.any_instance.stub :user => current_api_user
+          allow_any_instance_of(Order).to receive_messages :user => current_api_user
         end
 
         it "can view the payments for their order" do
           api_get :index
-          json_response["payments"].first.should have_attributes(attributes)
+          expect(json_response["payments"].first).to have_attributes(attributes)
         end
 
         it "can learn how to create a new payment" do
           api_get :new
-          json_response["attributes"].should == attributes.map(&:to_s)
-          json_response["payment_methods"].should_not be_empty
-          json_response["payment_methods"].first.should have_attributes([:id, :name, :description])
+          expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
+          expect(json_response["payment_methods"]).not_to be_empty
+          expect(json_response["payment_methods"].first).to have_attributes([:id, :name, :description])
         end
 
         it "can create a new payment" do
           api_post :create, :payment => { :payment_method_id => PaymentMethod.first.id, :amount => 50 }
-          response.status.should == 201
-          json_response.should have_attributes(attributes)
+          expect(response.status).to eq(201)
+          expect(json_response).to have_attributes(attributes)
         end
 
         it "can view a pre-existing payment's details" do
           api_get :show, :id => payment.to_param
-          json_response.should have_attributes(attributes)
+          expect(json_response).to have_attributes(attributes)
         end
 
         it "cannot update a payment" do
@@ -57,7 +57,7 @@ module Spree
 
       context "when the order does not belong to the user" do
         before do
-          Order.any_instance.stub :user => stub_model(LegacyUser)
+          allow_any_instance_of(Order).to receive_messages :user => stub_model(LegacyUser)
         end
 
         it "cannot view payments for somebody else's order" do
@@ -67,7 +67,7 @@ module Spree
 
         it "can view the payments for an order given the order token" do
           api_get :index, :order_id => order.to_param, :order_token => order.guest_token
-          json_response["payments"].first.should have_attributes(attributes)
+          expect(json_response["payments"].first).to have_attributes(attributes)
         end
       end
     end
@@ -77,8 +77,8 @@ module Spree
 
       it "can view the payments on any order" do
         api_get :index
-        response.status.should == 200
-        json_response["payments"].first.should have_attributes(attributes)
+        expect(response.status).to eq(200)
+        expect(json_response["payments"].first).to have_attributes(attributes)
       end
 
       context "multiple payments" do
@@ -86,20 +86,20 @@ module Spree
 
         it "can view all payments on an order" do
           api_get :index
-          json_response["count"].should == 2
+          expect(json_response["count"]).to eq(2)
         end
 
         it 'can control the page size through a parameter' do
           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
           api_get :index, :q => { :response_code_cont => '999' }
-          json_response['count'].should == 1
-          json_response['payments'].first['response_code'].should eq @payment.response_code
+          expect(json_response['count']).to eq(1)
+          expect(json_response['payments'].first['response_code']).to eq @payment.response_code
         end
       end
 
@@ -108,23 +108,23 @@ module Spree
           it "can update" do
             payment.update_attributes(:state => 'pending')
             api_put :update, :id => payment.to_param, :payment => { :amount => 2.01 }
-            response.status.should == 200
-            payment.reload.amount.should == 2.01
+            expect(response.status).to eq(200)
+            expect(payment.reload.amount).to eq(2.01)
           end
 
           context "update fails" do
             it "returns a 422 status when the amount is invalid" do
               payment.update_attributes(:state => 'pending')
               api_put :update, :id => payment.to_param, :payment => { :amount => 'invalid' }
-              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.")
             end
 
             it "returns a 403 status when the payment is not pending" do
               payment.update_attributes(:state => 'completed')
               api_put :update, :id => payment.to_param, :payment => { :amount => 2.01 }
-              response.status.should == 403
-              json_response["error"].should == "This payment cannot be updated because it is completed."
+              expect(response.status).to eq(403)
+              expect(json_response["error"]).to eq("This payment cannot be updated because it is completed.")
             end
           end
         end
@@ -132,26 +132,26 @@ module Spree
         context "authorizing" do
           it "can authorize" do
             api_put :authorize, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "pending"
+            expect(response.status).to eq(200)
+            expect(payment.reload.state).to eq("pending")
           end
 
           context "authorization fails" do
             before do
               fake_response = double(:success? => false, :to_s => "Could not authorize card")
-              Spree::Gateway::Bogus.any_instance.should_receive(:authorize).and_return(fake_response)
+              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:authorize).and_return(fake_response)
               api_put :authorize, :id => payment.to_param
             end
 
             it "returns a 422 status" do
-              response.status.should == 422
+              expect(response.status).to eq(422)
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Could not authorize card"
             end
 
             it "does not raise a stack level error" do
               skip "Investigate why a payment.reload after the request raises 'stack level too deep'"
-              payment.reload.state.should == "failed"
+              expect(payment.reload.state).to eq("failed")
             end
           end
         end
@@ -159,19 +159,19 @@ module Spree
         context "capturing" do
           it "can capture" do
             api_put :capture, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "completed"
+            expect(response.status).to eq(200)
+            expect(payment.reload.state).to eq("completed")
           end
 
           context "capturing fails" do
             before do
               fake_response = double(:success? => false, :to_s => "Insufficient funds")
-              Spree::Gateway::Bogus.any_instance.should_receive(:capture).and_return(fake_response)
+              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:capture).and_return(fake_response)
             end
 
             it "returns a 422 status" do
               api_put :capture, :id => payment.to_param
-              response.status.should == 422
+              expect(response.status).to eq(422)
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Insufficient funds"
             end
@@ -181,19 +181,19 @@ module Spree
         context "purchasing" do
           it "can purchase" do
             api_put :purchase, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "completed"
+            expect(response.status).to eq(200)
+            expect(payment.reload.state).to eq("completed")
           end
 
           context "purchasing fails" do
             before do
               fake_response = double(:success? => false, :to_s => "Insufficient funds")
-              Spree::Gateway::Bogus.any_instance.should_receive(:purchase).and_return(fake_response)
+              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:purchase).and_return(fake_response)
             end
 
             it "returns a 422 status" do
               api_put :purchase, :id => payment.to_param
-              response.status.should == 422
+              expect(response.status).to eq(422)
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Insufficient funds"
             end
@@ -210,7 +210,7 @@ module Spree
           context "voiding fails" do
             before do
               fake_response = double(success?: false, to_s: "NO REFUNDS")
-              Spree::Gateway::Bogus.any_instance.should_receive(:void).and_return(fake_response)
+              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:void).and_return(fake_response)
             end
 
             it "returns a 422 status" do
@@ -230,28 +230,28 @@ module Spree
 
           it "can credit" do
             api_put :credit, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "completed"
+            expect(response.status).to eq(200)
+            expect(payment.reload.state).to eq("completed")
 
             # Ensure that a credit payment was created, and it has correct credit amount
             credit_payment = Payment.where(:source_type => 'Spree::Payment', :source_id => payment.id).last
-            credit_payment.amount.to_f.should == -45.75
+            expect(credit_payment.amount.to_f).to eq(-45.75)
           end
 
           context "crediting fails" do
             it "returns a 422 status" do
               fake_response = double(:success? => false, :to_s => "NO CREDIT FOR YOU")
-              Spree::Gateway::Bogus.any_instance.should_receive(:credit).and_return(fake_response)
+              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:credit).and_return(fake_response)
               api_put :credit, :id => payment.to_param
-              response.status.should == 422
+              expect(response.status).to eq(422)
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "NO CREDIT FOR YOU"
             end
 
             it "cannot credit over credit_allowed limit" do
               api_put :credit, :id => payment.to_param, :amount => 1000000
-              response.status.should == 422
-              json_response["error"].should == "This payment can only be credited up to 45.75. Please specify an amount less than or equal to this number."
+              expect(response.status).to eq(422)
+              expect(json_response["error"]).to eq("This payment can only be credited up to 45.75. Please specify an amount less than or equal to this number.")
             end
           end
         end

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'shared_examples/protect_product_actions'
 
 module Spree
-  describe Spree::Api::ProductPropertiesController do
+  describe Spree::Api::ProductPropertiesController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -23,40 +23,40 @@ module Spree
 
       it "can not see a list of product properties" do
         api_get :index
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     it "can see a list of all product properties" do
       api_get :index
-      json_response["product_properties"].count.should eq 2
-      json_response["product_properties"].first.should have_attributes(attributes)
+      expect(json_response["product_properties"].count).to eq 2
+      expect(json_response["product_properties"].first).to have_attributes(attributes)
     end
 
     it "can control the page size through a parameter" do
       api_get :index, :per_page => 1
-      json_response['product_properties'].count.should == 1
-      json_response['current_page'].should == 1
-      json_response['pages'].should == 2
+      expect(json_response['product_properties'].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 parameter' do
       Spree::ProductProperty.last.update_attribute(:value, 'loose')
       property = Spree::ProductProperty.last
       api_get :index, :q => { :value_cont => 'loose' }
-      json_response['count'].should == 1
-      json_response['product_properties'].first['value'].should eq property.value
+      expect(json_response['count']).to eq(1)
+      expect(json_response['product_properties'].first['value']).to eq property.value
     end
 
     it "can see a single product_property" do
       api_get :show, :id => property_1.property_name
-      json_response.should have_attributes(attributes)
+      expect(json_response).to have_attributes(attributes)
     end
 
     it "can learn how to create a new product property" do
       api_get :new
-      json_response["attributes"].should == attributes.map(&:to_s)
-      json_response["required_attributes"].should be_empty
+      expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
+      expect(json_response["required_attributes"]).to be_empty
     end
 
     it "cannot create a new product property if not an admin" do
@@ -72,7 +72,7 @@ module Spree
     it "cannot delete a product property" do
       api_delete :destroy, :property_name => property_1.property_name
       assert_unauthorized!
-      lambda { property_1.reload }.should_not raise_error
+      expect { property_1.reload }.not_to raise_error
     end
 
     context "as an admin" do
@@ -82,19 +82,19 @@ module Spree
         expect do
           api_post :create, :product_property => { :property_name => "My Property 3", :value => "my value 3" }
         end.to change(product.product_properties, :count).by(1)
-        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 update a product property" do
         api_put :update, :id => property_1.property_name, :product_property => { :value => "my value 456" }
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "can delete a product property" do
         api_delete :destroy, :id => property_1.property_name
-        response.status.should == 204
-        lambda { property_1.reload }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { property_1.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
 
@@ -102,13 +102,13 @@ module Spree
       let(:resource_scoping) { { :product_id => product.id } }
       it "can see a list of all product properties" do
         api_get :index
-        json_response["product_properties"].count.should eq 2
-        json_response["product_properties"].first.should have_attributes(attributes)
+        expect(json_response["product_properties"].count).to eq 2
+        expect(json_response["product_properties"].first).to have_attributes(attributes)
       end
 
       it "can see a single product_property by id" do
         api_get :show, :id => property_1.id
-        json_response.should have_attributes(attributes)
+        expect(json_response).to have_attributes(attributes)
       end
     end
 

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'shared_examples/protect_product_actions'
 
 module Spree
-  describe Spree::Api::ProductsController do
+  describe Spree::Api::ProductsController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -51,20 +51,20 @@ module Spree
 
       it "retrieves a list of products" do
         api_get :index
-        json_response["products"].first.should have_attributes(show_attributes)
-        json_response["total_count"].should == 1
-        json_response["current_page"].should == 1
-        json_response["pages"].should == 1
-        json_response["per_page"].should == Kaminari.config.default_per_page
+        expect(json_response["products"].first).to have_attributes(show_attributes)
+        expect(json_response["total_count"]).to eq(1)
+        expect(json_response["current_page"]).to eq(1)
+        expect(json_response["pages"]).to eq(1)
+        expect(json_response["per_page"]).to eq(Kaminari.config.default_per_page)
       end
 
       it "retrieves a list of products by id" do
         api_get :index, :ids => [product.id]
-        json_response["products"].first.should have_attributes(show_attributes)
-        json_response["total_count"].should == 1
-        json_response["current_page"].should == 1
-        json_response["pages"].should == 1
-        json_response["per_page"].should == Kaminari.config.default_per_page
+        expect(json_response["products"].first).to have_attributes(show_attributes)
+        expect(json_response["total_count"]).to eq(1)
+        expect(json_response["current_page"]).to eq(1)
+        expect(json_response["pages"]).to eq(1)
+        expect(json_response["per_page"]).to eq(Kaminari.config.default_per_page)
       end
 
       context "specifying a rabl template for a custom action" do
@@ -80,18 +80,18 @@ module Spree
         it "uses the specified custom template through the request header" do
           request.headers['X-Spree-Template'] = 'show'
           api_get :custom_show, :id => product.id
-          response.should render_template('spree/api/products/show')
+          expect(response).to render_template('spree/api/products/show')
         end
 
         it "uses the specified custom template through the template URL parameter" do
           api_get :custom_show, :id => product.id, :template => 'show'
-          response.should render_template('spree/api/products/show')
+          expect(response).to render_template('spree/api/products/show')
         end
 
         it "falls back to the default template if the specified template does not exist" do
           request.headers['X-Spree-Template'] = 'invoice'
           api_get :show, :id => product.id
-          response.should render_template('spree/api/products/show')
+          expect(response).to render_template('spree/api/products/show')
         end
       end
 
@@ -107,64 +107,64 @@ module Spree
       it "retrieves a list of products by ids string" do
         second_product = create(:product)
         api_get :index, :ids => [product.id, second_product.id].join(",")
-        json_response["products"].first.should have_attributes(show_attributes)
-        json_response["products"][1].should have_attributes(show_attributes)
-        json_response["total_count"].should == 2
-        json_response["current_page"].should == 1
-        json_response["pages"].should == 1
-        json_response["per_page"].should == Kaminari.config.default_per_page
+        expect(json_response["products"].first).to have_attributes(show_attributes)
+        expect(json_response["products"][1]).to have_attributes(show_attributes)
+        expect(json_response["total_count"]).to eq(2)
+        expect(json_response["current_page"]).to eq(1)
+        expect(json_response["pages"]).to eq(1)
+        expect(json_response["per_page"]).to eq(Kaminari.config.default_per_page)
       end
 
       it "does not return inactive products when queried by ids" do
         api_get :index, :ids => [inactive_product.id]
-        json_response["count"].should == 0
+        expect(json_response["count"]).to eq(0)
       end
 
       it "does not list unavailable products" do
         api_get :index
-        json_response["products"].first["name"].should_not eq("inactive")
+        expect(json_response["products"].first["name"]).not_to eq("inactive")
       end
 
       context "pagination" do
         it "can select the next page of products" do
           second_product = create(:product)
           api_get :index, :page => 2, :per_page => 1
-          json_response["products"].first.should have_attributes(show_attributes)
-          json_response["total_count"].should == 2
-          json_response["current_page"].should == 2
-          json_response["pages"].should == 2
+          expect(json_response["products"].first).to have_attributes(show_attributes)
+          expect(json_response["total_count"]).to eq(2)
+          expect(json_response["current_page"]).to eq(2)
+          expect(json_response["pages"]).to eq(2)
         end
 
         it 'can control the page size through a parameter' do
           create(:product)
           api_get :index, :per_page => 1
-          json_response['count'].should == 1
-          json_response['total_count'].should == 2
-          json_response['current_page'].should == 1
-          json_response['pages'].should == 2
+          expect(json_response['count']).to eq(1)
+          expect(json_response['total_count']).to eq(2)
+          expect(json_response['current_page']).to eq(1)
+          expect(json_response['pages']).to eq(2)
         end
       end
 
       context "jsonp" do
         it "retrieves a list of products of jsonp" do
           api_get :index, {:callback => 'callback'}
-          response.body.should =~ /^callback\(.*\)$/
-          response.header['Content-Type'].should include('application/javascript')
+          expect(response.body).to match(/^callback\(.*\)$/)
+          expect(response.header['Content-Type']).to include('application/javascript')
         end
 
         # Regression test for #4332
         it "does not escape quotes" do
           api_get :index, {:callback => 'callback'}
-          response.body.should =~ /^callback\({"count":1,"total_count":1/
-          response.header['Content-Type'].should include('application/javascript')
+          expect(response.body).to match(/^callback\({"count":1,"total_count":1/)
+          expect(response.header['Content-Type']).to include('application/javascript')
         end
       end
 
       it "can search for products" do
         create(:product, :name => "The best product in the world")
         api_get :index, :q => { :name_cont => "best" }
-        json_response["products"].first.should have_attributes(show_attributes)
-        json_response["count"].should == 1
+        expect(json_response["products"].first).to have_attributes(show_attributes)
+        expect(json_response["count"]).to eq(1)
       end
 
       it "gets a single product" do
@@ -173,14 +173,14 @@ module Spree
         product.variants.first.images.create!(:attachment => image("thinking-cat.jpg"))
         product.set_property("spree", "rocks")
         api_get :show, :id => product.to_param
-        json_response.should have_attributes(show_attributes)
-        json_response['variants'].first.should have_attributes([:name,
+        expect(json_response).to have_attributes(show_attributes)
+        expect(json_response['variants'].first).to have_attributes([:name,
                                                               :is_master,
                                                               :price,
                                                               :images,
                                                               :in_stock])
 
-        json_response['variants'].first['images'].first.should have_attributes([:attachment_file_name,
+        expect(json_response['variants'].first['images'].first).to have_attributes([:attachment_file_name,
                                                                                 :attachment_width,
                                                                                 :attachment_height,
                                                                                 :attachment_content_type,
@@ -189,7 +189,7 @@ module Spree
                                                                                 :product_url,
                                                                                 :large_url])
 
-        json_response["product_properties"].first.should have_attributes([:value,
+        expect(json_response["product_properties"].first).to have_attributes([:value,
                                                                          :product_id,
                                                                          :property_name])
       end
@@ -215,11 +215,11 @@ module Spree
 
         specify do
           api_get :show, :id => product.to_param
-          json_response["slug"].should =~ /and-1-ways/
+          expect(json_response["slug"]).to match(/and-1-ways/)
           product.destroy
 
           api_get :show, :id => other_product.id
-          json_response["slug"].should =~ /droids/
+          expect(json_response["slug"]).to match(/droids/)
         end
       end
 
@@ -235,11 +235,11 @@ module Spree
 
       it "can learn how to create a new product" do
         api_get :new
-        json_response["attributes"].should == new_attributes.map(&:to_s)
+        expect(json_response["attributes"]).to eq(new_attributes.map(&:to_s))
         required_attributes = json_response["required_attributes"]
-        required_attributes.should include("name")
-        required_attributes.should include("price")
-        required_attributes.should include("shipping_category_id")
+        expect(required_attributes).to include("name")
+        expect(required_attributes).to include("price")
+        expect(required_attributes).to include("shipping_category_id")
       end
 
       it_behaves_like "modifying product actions are restricted"
@@ -253,10 +253,10 @@ module Spree
 
       it "can see all products" do
         api_get :index
-        json_response["products"].count.should == 2
-        json_response["count"].should == 2
-        json_response["current_page"].should == 1
-        json_response["pages"].should == 1
+        expect(json_response["products"].count).to eq(2)
+        expect(json_response["count"]).to eq(2)
+        expect(json_response["current_page"]).to eq(1)
+        expect(json_response["pages"]).to eq(1)
       end
 
       # Regression test for #1626
@@ -267,12 +267,12 @@ module Spree
 
         it "does not include deleted products" do
           api_get :index
-          json_response["products"].count.should == 2
+          expect(json_response["products"].count).to eq(2)
         end
 
         it "can include deleted products" do
           api_get :index, :show_deleted => 1
-          json_response["products"].count.should == 3
+          expect(json_response["products"].count).to eq(3)
         end
       end
 
@@ -281,8 +281,8 @@ module Spree
           api_post :create, :product => { :name => "The Other Product",
                                           :price => 19.99,
                                           :shipping_category_id => create(:shipping_category).id }
-          json_response.should have_attributes(base_attributes)
-          response.status.should == 201
+          expect(json_response).to have_attributes(base_attributes)
+          expect(response.status).to eq(201)
         end
 
         it "creates with embedded variants" do
@@ -361,25 +361,25 @@ module Spree
 
           it "can still create a product" do
             api_post :create, :product => product_data, :token => "fake"
-            json_response.should have_attributes(show_attributes)
-            response.status.should == 201
+            expect(json_response).to have_attributes(show_attributes)
+            expect(response.status).to eq(201)
           end
         end
 
         it "cannot create a new product with invalid attributes" do
-          api_post :create, :product => {}
-          response.status.should == 422
-          json_response["error"].should == "Invalid resource. Please fix errors and try again."
+          api_post :create, product: {}
+          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.delete("slug") # Don't care about this one.
-          errors.keys.should =~ ["name", "price", "shipping_category_id"]
+          expect(errors.keys).to match_array(["name", "price", "shipping_category_id"])
         end
       end
 
       context 'updating a product' do
         it "can update a product" do
           api_put :update, :id => product.to_param, :product => { :name => "New and Improved Product!" }
-          response.status.should == 200
+          expect(response.status).to eq(200)
         end
 
         it "can create new option types on a product" do
@@ -424,9 +424,9 @@ module Spree
 
         it "cannot update a product with an invalid attribute" do
           api_put :update, :id => product.to_param, :product => { :name => "" }
-          response.status.should == 422
-          json_response["error"].should == "Invalid resource. Please fix errors and try again."
-          json_response["errors"]["name"].should == ["can't be blank"]
+          expect(response.status).to eq(422)
+          expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
+          expect(json_response["errors"]["name"]).to eq(["can't be blank"])
         end
 
         # Regression test for #4123
@@ -443,10 +443,10 @@ module Spree
       end
 
       it "can delete a product" do
-        product.deleted_at.should be_nil
+        expect(product.deleted_at).to be_nil
         api_delete :destroy, :id => product.to_param
-        response.status.should == 204
-        product.reload.deleted_at.should_not be_nil
+        expect(response.status).to eq(204)
+        expect(product.reload.deleted_at).not_to be_nil
       end
     end
   end