spree_api 2.4.0.rc2 → 2.4.0.rc3

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionTypesController do
+  describe Api::OptionTypesController, :type => :controller do
     render_views
 
     let(:attributes) { [:id, :name, :position, :presentation] }
@@ -13,15 +13,15 @@ module Spree
     end
 
     def check_option_values(option_values)
-      option_values.count.should == 1
-      option_values.first.should have_attributes([:id, :name, :presentation,
+      expect(option_values.count).to eq(1)
+      expect(option_values.first).to have_attributes([:id, :name, :presentation,
                                                   :option_type_name, :option_type_id])
     end
 
     it "can list all option types" do
       api_get :index
-      json_response.count.should == 1
-      json_response.first.should have_attributes(attributes)
+      expect(json_response.count).to eq(1)
+      expect(json_response.first).to have_attributes(attributes)
 
       check_option_values(json_response.first["option_values"])
     end
@@ -29,22 +29,22 @@ module Spree
     it "can search for an option type" do
       create(:option_type, :name => "buzz")
       api_get :index, :q => { :name_cont => option_type.name }
-      json_response.count.should == 1
-      json_response.first.should have_attributes(attributes)
+      expect(json_response.count).to eq(1)
+      expect(json_response.first).to have_attributes(attributes)
     end
 
-    it "can retreive a list of specific option types" do
+    it "can retrieve a list of specific option types" do
       option_type_1 = create(:option_type)
       option_type_2 = create(:option_type)
       api_get :index, :ids => "#{option_type.id},#{option_type_1.id}"
-      json_response.count.should == 2
+      expect(json_response.count).to eq(2)
 
       check_option_values(json_response.first["option_values"])
     end
 
     it "can list a single option type" do
       api_get :show, :id => option_type.id
-      json_response.should have_attributes(attributes)
+      expect(json_response).to have_attributes(attributes)
       check_option_values(json_response["option_values"])
     end
 
@@ -63,13 +63,13 @@ module Spree
                           :name => "Option Type"
                         }
       assert_not_found!
-      option_type.reload.name.should == original_name
+      expect(option_type.reload.name).to eq(original_name)
     end
 
     it "cannot delete an option type" do
       api_delete :destroy, :id => option_type.id
       assert_not_found!
-      lambda { option_type.reload }.should_not raise_error
+      expect { option_type.reload }.not_to raise_error
     end
 
     context "as an admin" do
@@ -80,13 +80,13 @@ module Spree
                           :name => "Option Type",
                           :presentation => "Option Type"
                         }
-        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 "cannot create an option type with invalid attributes" do
         api_post :create, :option_type => {}
-        response.status.should == 422
+        expect(response.status).to eq(422)
       end
 
       it "can update an option type" do
@@ -94,22 +94,22 @@ module Spree
         api_put :update, :id => option_type.id, :option_type => {
                               :name => "Option Type",
                             }
-        response.status.should == 200
+        expect(response.status).to eq(200)
 
         option_type.reload
-        option_type.name.should == "Option Type"
+        expect(option_type.name).to eq("Option Type")
       end
 
       it "cannot update an option type with invalid attributes" do
         api_put :update, :id => option_type.id, :option_type => {
                           :name => ""
                          }
-        response.status.should == 422
+        expect(response.status).to eq(422)
       end
 
       it "can delete an option type" do
         api_delete :destroy, :id => option_type.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionValuesController do
+  describe Api::OptionValuesController, :type => :controller do
     render_views
 
     let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_name] }
@@ -13,8 +13,8 @@ module Spree
     end
 
     def check_option_values(option_values)
-      option_values.count.should == 1
-      option_values.first.should have_attributes([:id, :name, :presentation,
+      expect(option_values.count).to eq(1)
+      expect(option_values.first).to have_attributes([:id, :name, :presentation,
                                                   :option_type_name, :option_type_id])
     end
 
@@ -24,10 +24,10 @@ module Spree
         create(:option_value, :option_type => create(:option_type))
       end
 
-      it "can retreive a list of all option values" do
+      it "can retrieve a list of all option values" do
         api_get :index
-        json_response.count.should == 2
-        json_response.first.should have_attributes(attributes)
+        expect(json_response.count).to eq(2)
+        expect(json_response.first).to have_attributes(attributes)
       end
     end
 
@@ -36,27 +36,27 @@ module Spree
 
       it "can list all option values" do
         api_get :index
-        json_response.count.should == 1
-        json_response.first.should have_attributes(attributes)
+        expect(json_response.count).to eq(1)
+        expect(json_response.first).to have_attributes(attributes)
       end
 
       it "can search for an option type" do
         create(:option_value, :name => "buzz")
         api_get :index, :q => { :name_cont => option_value.name }
-        json_response.count.should == 1
-        json_response.first.should have_attributes(attributes)
+        expect(json_response.count).to eq(1)
+        expect(json_response.first).to have_attributes(attributes)
       end
 
-      it "can retreive a list of option types" do
+      it "can retrieve a list of option types" do
         option_value_1 = create(:option_value, :option_type => option_type)
         option_value_2 = create(:option_value, :option_type => option_type)
         api_get :index, :ids => [option_value.id, option_value_1.id]
-        json_response.count.should == 2
+        expect(json_response.count).to eq(2)
       end
 
       it "can list a single option value" do
         api_get :show, :id => option_value.id
-        json_response.should have_attributes(attributes)
+        expect(json_response).to have_attributes(attributes)
       end
 
       it "cannot create a new option value" do
@@ -74,13 +74,13 @@ module Spree
                             :name => "Option Value"
                           }
         assert_not_found!
-        option_type.reload.name.should == original_name
+        expect(option_type.reload.name).to eq(original_name)
       end
 
       it "cannot delete an option value" do
         api_delete :destroy, :id => option_type.id
         assert_not_found!
-        lambda { option_type.reload }.should_not raise_error
+        expect { option_type.reload }.not_to raise_error
       end
 
       context "as an admin" do
@@ -91,13 +91,13 @@ module Spree
                             :name => "Option Value",
                             :presentation => "Option Value"
                           }
-          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 "cannot create an option type with invalid attributes" do
           api_post :create, :option_value => {}
-          response.status.should == 422
+          expect(response.status).to eq(422)
         end
 
         it "can update an option value" do
@@ -105,14 +105,14 @@ module Spree
           api_put :update, :id => option_value.id, :option_value => {
                                 :name => "Option Value",
                               }
-          response.status.should == 200
+          expect(response.status).to eq(200)
 
           option_value.reload
-          option_value.name.should == "Option Value"
+          expect(option_value.name).to eq("Option Value")
         end
 
         it "permits the correct attributes" do
-          controller.should_receive(:permitted_option_value_attributes)
+          expect(controller).to receive(:permitted_option_value_attributes)
           api_put :update, :id => option_value.id, :option_value => {
                             :name => ""
                            }
@@ -122,12 +122,12 @@ module Spree
           api_put :update, :id => option_value.id, :option_value => {
                             :name => ""
                            }
-          response.status.should == 422
+          expect(response.status).to eq(422)
         end
 
         it "can delete an option value" do
           api_delete :destroy, :id => option_value.id
-          response.status.should == 204
+          expect(response.status).to eq(204)
         end
       end
     end

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'spree/testing_support/bar_ability'
 
 module Spree
-  describe Api::OrdersController do
+  describe Api::OrdersController, :type => :controller do
     render_views
 
     let!(:order) { create(:order) }
@@ -19,11 +19,11 @@ module Spree
     let(:address_params) { { :country_id => Country.first.id, :state_id => State.first.id } }
 
     let(:billing_address) { { :firstname => "Tiago", :lastname => "Motta", :address1 => "Av Paulista",
-                              :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
+                              :city => "Sao Paulo", :zipcode => "35762", :phone => "12345678",
                               :country_id => Country.first.id, :state_id => State.first.id} }
 
     let(:shipping_address) { { :firstname => "Tiago", :lastname => "Motta", :address1 => "Av Paulista",
-                               :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
+                               :city => "Sao Paulo", :zipcode => "35762", :phone => "12345678",
                                :country_id => Country.first.id, :state_id => State.first.id} }
 
     let(:current_api_user) do
@@ -36,6 +36,28 @@ module Spree
       stub_authentication!
     end
 
+    describe 'PATCH #update' do
+      subject { api_patch :update, id: order.to_param, order: { email: "foo@bar.com" } }
+
+      before do
+        allow_any_instance_of(Spree::Order).to receive_messages :user => current_api_user
+      end
+
+      it 'should be ok' do
+        expect(subject).to be_ok
+      end
+
+      it 'should not invoke OrderContents#update_cart' do
+        expect_any_instance_of(Spree::OrderContents).to_not receive(:update_cart)
+        subject
+      end
+
+      it 'should update the email' do
+        subject
+        expect(order.reload.email).to eq('foo@bar.com')
+      end
+    end
+
     it "cannot view all orders" do
       api_get :index
       assert_unauthorized!
@@ -46,7 +68,7 @@ module Spree
 
       it "returns a 401" do
         api_get :mine
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
@@ -57,40 +79,40 @@ module Spree
       it "can view all of their own orders" do
         api_get :mine
 
-        response.status.should == 200
-        json_response["pages"].should == 1
-        json_response["current_page"].should == 1
-        json_response["orders"].length.should == 1
-        json_response["orders"].first["number"].should == order.number
-        json_response["orders"].first["line_items"].length.should == 1
-        json_response["orders"].first["line_items"].first["id"].should == line_item.id
+        expect(response.status).to eq(200)
+        expect(json_response["pages"]).to eq(1)
+        expect(json_response["current_page"]).to eq(1)
+        expect(json_response["orders"].length).to eq(1)
+        expect(json_response["orders"].first["number"]).to eq(order.number)
+        expect(json_response["orders"].first["line_items"].length).to eq(1)
+        expect(json_response["orders"].first["line_items"].first["id"]).to eq(line_item.id)
       end
 
       it "can filter the returned results" do
         api_get :mine, q: {completed_at_not_null: 1}
 
-        response.status.should == 200
-        json_response["orders"].length.should == 0
+        expect(response.status).to eq(200)
+        expect(json_response["orders"].length).to eq(0)
       end
 
       it "returns orders in reverse chronological order by completed_at" do
         order.update_columns completed_at: Time.now
 
         order2 = Order.create user: order.user, completed_at: Time.now - 1.day
-        order2.created_at.should > order.created_at
+        expect(order2.created_at).to be > order.created_at
         order3 = Order.create user: order.user, completed_at: nil
-        order3.created_at.should > order2.created_at
+        expect(order3.created_at).to be > order2.created_at
         order4 = Order.create user: order.user, completed_at: nil
-        order4.created_at.should > order3.created_at
+        expect(order4.created_at).to be > order3.created_at
 
         api_get :mine
-        response.status.should == 200
-        json_response["pages"].should == 1
-        json_response["orders"].length.should == 4
-        json_response["orders"][0]["number"].should == order.number
-        json_response["orders"][1]["number"].should == order2.number
-        json_response["orders"][2]["number"].should == order4.number
-        json_response["orders"][3]["number"].should == order3.number
+        expect(response.status).to eq(200)
+        expect(json_response["pages"]).to eq(1)
+        expect(json_response["orders"].length).to eq(4)
+        expect(json_response["orders"][0]["number"]).to eq(order.number)
+        expect(json_response["orders"][1]["number"]).to eq(order2.number)
+        expect(json_response["orders"][2]["number"]).to eq(order4.number)
+        expect(json_response["orders"][3]["number"]).to eq(order3.number)
       end
     end
 
@@ -138,42 +160,63 @@ module Spree
     end
 
     it "can view their own order" do
-      Order.any_instance.stub :user => current_api_user
+      allow_any_instance_of(Order).to receive_messages :user => current_api_user
       api_get :show, :id => order.to_param
-      response.status.should == 200
-      json_response.should have_attributes(attributes)
-      json_response["adjustments"].should be_empty
+      expect(response.status).to eq(200)
+      expect(json_response).to have_attributes(attributes)
+      expect(json_response["adjustments"]).to be_empty
+    end
+
+    context 'when shipment adjustments are present' do
+      let(:adjustment) { FactoryGirl.create(:adjustment, order: order) }
+
+      before do
+        allow_any_instance_of(Order).to receive_messages :user => current_api_user
+        shipment = FactoryGirl.create(:shipment, order: order)
+        shipment.adjustments << adjustment
+      end
+
+      subject { api_get :show, :id => order.to_param }
+
+      it 'contains adjustments in JSON' do
+        subject
+        # Test to insure shipment has adjustments
+        shipment = json_response['shipments'][0]
+        expect(shipment).to_not be_nil
+        expect(shipment['adjustments'][0]).not_to be_empty
+        expect(shipment['adjustments'][0]['label']).to eq(adjustment.label)
+      end
     end
 
     it "orders contain the basic checkout steps" do
-      Order.any_instance.stub :user => current_api_user
+      allow_any_instance_of(Order).to receive_messages :user => current_api_user
       api_get :show, :id => order.to_param
-      response.status.should == 200
-      json_response["checkout_steps"].should == ["address", "delivery", "complete"]
+      expect(response.status).to eq(200)
+      expect(json_response["checkout_steps"]).to eq(["address", "delivery", "complete"])
     end
 
     # Regression test for #1992
     it "can view an order not in a standard state" do
-      Order.any_instance.stub :user => current_api_user
+      allow_any_instance_of(Order).to receive_messages :user => current_api_user
       order.update_column(:state, 'shipped')
       api_get :show, :id => order.to_param
     end
 
     it "can not view someone else's order" do
-      Order.any_instance.stub :user => stub_model(Spree::LegacyUser)
+      allow_any_instance_of(Order).to receive_messages :user => stub_model(Spree::LegacyUser)
       api_get :show, :id => order.to_param
       assert_unauthorized!
     end
 
     it "can view an order if the token is known" do
       api_get :show, :id => order.to_param, :order_token => order.guest_token
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "can view an order if the token is passed in header" do
       request.headers["X-Spree-Order-Token"] = order.guest_token
       api_get :show, :id => order.to_param
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     context "with BarAbility registered" do
@@ -182,12 +225,12 @@ module Spree
 
       it "can view an order" do
         user = mock_model(Spree::LegacyUser)
-        user.stub_chain(:spree_roles, :pluck).and_return(["bar"])
-        user.stub(:has_spree_role?).with('bar').and_return(true)
-        user.stub(:has_spree_role?).with('admin').and_return(false)
-        controller.stub try_spree_current_user: user
+        allow(user).to receive_message_chain(:spree_roles, :pluck).and_return(["bar"])
+        allow(user).to receive(:has_spree_role?).with('bar').and_return(true)
+        allow(user).to receive(:has_spree_role?).with('admin').and_return(false)
+        allow(controller).to receive_messages try_spree_current_user: user
         api_get :show, :id => order.to_param
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
     end
 
@@ -205,19 +248,19 @@ module Spree
 
     it "can create an order" do
       api_post :create, :order => { :line_items => { "0" => { :variant_id => variant.to_param, :quantity => 5 } } }
-      response.status.should == 201
+      expect(response.status).to eq(201)
 
       order = Order.last
-      order.line_items.count.should == 1
-      order.line_items.first.variant.should == variant
-      order.line_items.first.quantity.should == 5
-
-      json_response['number'].should be_present
-      json_response["token"].should_not be_blank
-      json_response["state"].should == "cart"
-      order.user.should == current_api_user
-      order.email.should == current_api_user.email
-      json_response["user_id"].should == current_api_user.id
+      expect(order.line_items.count).to eq(1)
+      expect(order.line_items.first.variant).to eq(variant)
+      expect(order.line_items.first.quantity).to eq(5)
+
+      expect(json_response['number']).to be_present
+      expect(json_response["token"]).not_to be_blank
+      expect(json_response["state"]).to eq("cart")
+      expect(order.user).to eq(current_api_user)
+      expect(order.email).to eq(current_api_user.email)
+      expect(json_response["user_id"]).to eq(current_api_user.id)
     end
 
     it "assigns email when creating a new order" do
@@ -228,12 +271,12 @@ module Spree
 
     # Regression test for #3404
     it "can specify additional parameters for a line item" do
-      Order.should_receive(:create!).and_return(order = Spree::Order.new)
-      order.stub(:associate_user!)
-      order.stub_chain(:contents, :add).and_return(line_item = double('LineItem'))
-      line_item.should_receive(:update_attributes!).with("special" => true)
+      expect(Order).to receive(:create!).and_return(order = Spree::Order.new)
+      allow(order).to receive(:associate_user!)
+      allow(order).to receive_message_chain(:contents, :add).and_return(line_item = double('LineItem'))
+      expect(line_item).to receive(:update_attributes!).with("special" => true)
 
-      controller.stub(permitted_line_item_attributes: [:id, :variant_id, :quantity, :special])
+      allow(controller).to receive_messages(permitted_line_item_attributes: [:id, :variant_id, :quantity, :special])
       api_post :create, :order => {
         :line_items => {
           "0" => {
@@ -241,7 +284,7 @@ module Spree
           }
         }
       }
-      response.status.should == 201
+      expect(response.status).to eq(201)
     end
 
     it "cannot arbitrarily set the line items price" do
@@ -259,8 +302,8 @@ module Spree
 
     context "admin user imports order" do
       before do
-        current_api_user.stub has_spree_role?: true
-        current_api_user.stub_chain :spree_roles, pluck: ["admin"]
+        allow(current_api_user).to receive_messages has_spree_role?: true
+        allow(current_api_user).to receive_message_chain :spree_roles, pluck: ["admin"]
       end
 
       it "is able to set any default unpermitted attribute" do
@@ -272,10 +315,10 @@ module Spree
 
     # Regression test for #3404
     it "does not update line item needlessly" do
-      Order.should_receive(:create!).and_return(order = Spree::Order.new)
-      order.stub(:associate_user!)
-      order.stub_chain(:contents, :add).and_return(line_item = double('LineItem'))
-      line_item.should_not_receive(:update_attributes)
+      expect(Order).to receive(:create!).and_return(order = Spree::Order.new)
+      allow(order).to receive(:associate_user!)
+      allow(order).to receive_message_chain(:contents, :add).and_return(line_item = double('LineItem'))
+      expect(line_item).not_to receive(:update_attributes)
       api_post :create, :order => {
         :line_items => {
           "0" => {
@@ -286,10 +329,10 @@ module Spree
     end
 
     it "can create an order without any parameters" do
-      lambda { api_post :create }.should_not raise_error
-      response.status.should == 201
+      expect { api_post :create }.not_to raise_error
+      expect(response.status).to eq(201)
       order = Order.last
-      json_response["state"].should == "cart"
+      expect(json_response["state"]).to eq("cart")
     end
 
     context "working with an order" do
@@ -300,20 +343,20 @@ module Spree
 
       let(:address_params) { { :country_id => Country.first.id, :state_id => State.first.id } }
       let(:billing_address) { { :firstname => "Tiago", :lastname => "Motta", :address1 => "Av Paulista",
-                                :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
+                                :city => "Sao Paulo", :zipcode => "35762", :phone => "12345678",
                                 :country_id => Country.first.id, :state_id => State.first.id} }
       let(:shipping_address) { { :firstname => "Tiago", :lastname => "Motta", :address1 => "Av Paulista",
-                                 :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
+                                 :city => "Sao Paulo", :zipcode => "35762", :phone => "12345678",
                                  :country_id => Country.first.id, :state_id => State.first.id} }
 
       before do
-        Spree::LineItem.stub(:find_by_id).and_return(Spree::LineItem.new)
-        Order.any_instance.stub :user => current_api_user
+        allow(Spree::LineItem).to receive(:find_by_id).and_return(Spree::LineItem.new)
+        allow_any_instance_of(Order).to receive_messages :user => current_api_user
         order.next # Switch from cart to address
         order.bill_address = nil
         order.ship_address = nil
         order.save
-        order.state.should == "address"
+        expect(order.state).to eq("address")
       end
 
       def clean_address(address)
@@ -339,9 +382,9 @@ module Spree
           }
         }
 
-        response.status.should == 200
-        json_response['line_items'].count.should == 1
-        json_response['line_items'].first['quantity'].should == 10
+        expect(response.status).to eq(200)
+        expect(json_response['line_items'].count).to eq(1)
+        expect(json_response['line_items'].first['quantity']).to eq(10)
       end
 
       it "adds an extra line item" do
@@ -353,11 +396,11 @@ module Spree
           }
         }
 
-        response.status.should == 200
-        json_response['line_items'].count.should == 2
-        json_response['line_items'][0]['quantity'].should == 10
-        json_response['line_items'][1]['variant_id'].should == variant2.id
-        json_response['line_items'][1]['quantity'].should == 1
+        expect(response.status).to eq(200)
+        expect(json_response['line_items'].count).to eq(2)
+        expect(json_response['line_items'][0]['quantity']).to eq(10)
+        expect(json_response['line_items'][1]['variant_id']).to eq(variant2.id)
+        expect(json_response['line_items'][1]['quantity']).to eq(1)
       end
 
       it "cannot change the price of an existing line item" do
@@ -367,8 +410,8 @@ module Spree
           }
         }
 
-        response.status.should == 200
-        json_response['line_items'].count.should == 1
+        expect(response.status).to eq(200)
+        expect(json_response['line_items'].count).to eq(1)
         expect(json_response['line_items'].first['price'].to_f).to_not eq(0)
         expect(json_response['line_items'].first['price'].to_f).to eq(line_item.variant.price)
       end
@@ -376,7 +419,7 @@ module Spree
       it "can add billing address" do
         api_put :update, :id => order.to_param, :order => { :bill_address_attributes => billing_address }
 
-        order.reload.bill_address.should_not be_nil
+        expect(order.reload.bill_address).to_not be_nil
       end
 
       it "receives error message if trying to add billing address with errors" do
@@ -384,28 +427,28 @@ module Spree
 
         api_put :update, :id => order.to_param, :order => { :bill_address_attributes => billing_address }
 
-        json_response['error'].should_not be_nil
-        json_response['errors'].should_not be_nil
-        json_response['errors']['bill_address.firstname'].first.should eq "can't be blank"
+        expect(json_response['error']).not_to be_nil
+        expect(json_response['errors']).not_to be_nil
+        expect(json_response['errors']['bill_address.firstname'].first).to eq "can't be blank"
       end
 
       it "can add shipping address" do
-        order.ship_address.should be_nil
+        expect(order.ship_address).to be_nil
 
         api_put :update, :id => order.to_param, :order => { :ship_address_attributes => shipping_address }
 
-        order.reload.ship_address.should_not be_nil
+        expect(order.reload.ship_address).not_to be_nil
       end
 
       it "receives error message if trying to add shipping address with errors" do
-        order.ship_address.should be_nil
+        expect(order.ship_address).to be_nil
         shipping_address[:firstname] = ""
 
         api_put :update, :id => order.to_param, :order => { :ship_address_attributes => shipping_address }
 
-        json_response['error'].should_not be_nil
-        json_response['errors'].should_not be_nil
-        json_response['errors']['ship_address.firstname'].first.should eq "can't be blank"
+        expect(json_response['error']).not_to be_nil
+        expect(json_response['errors']).not_to be_nil
+        expect(json_response['errors']['ship_address.firstname'].first).to eq "can't be blank"
       end
 
       it "cannot set the user_id for the order" do
@@ -413,7 +456,7 @@ module Spree
         original_id = order.user_id
         api_post :update, :id => order.to_param, :order => { user_id: user.id }
         expect(response.status).to eq 200
-        json_response["user_id"].should == original_id
+        expect(json_response["user_id"]).to eq(original_id)
       end
 
       context "order has shipments" do
@@ -433,17 +476,17 @@ module Spree
       context "with a line item" do
         let(:order_with_line_items) do
           order = create(:order_with_line_items)
-          create(:adjustment, :adjustable => order)
+          create(:adjustment, order: order, adjustable: order)
           order
         end
 
         it "can empty an order" do
-          order_with_line_items.adjustments.count.should be == 1
+          expect(order_with_line_items.adjustments.count).to eq(1)
           api_put :empty, :id => order_with_line_items.to_param
-          response.status.should == 204
+          expect(response.status).to eq(204)
           order_with_line_items.reload
-          order_with_line_items.line_items.should be_empty
-          order_with_line_items.adjustments.should be_empty
+          expect(order_with_line_items.line_items).to be_empty
+          expect(order_with_line_items.adjustments).to be_empty
         end
 
         it "can list its line items with images" do
@@ -451,22 +494,22 @@ module Spree
 
           api_get :show, :id => order.to_param
 
-          json_response['line_items'].first['variant'].should have_attributes([:images])
+          expect(json_response['line_items'].first['variant']).to have_attributes([:images])
         end
 
         it "lists variants product id" do
           api_get :show, :id => order.to_param
 
-          json_response['line_items'].first['variant'].should have_attributes([:product_id])
+          expect(json_response['line_items'].first['variant']).to have_attributes([:product_id])
         end
 
         it "includes the tax_total in the response" do
           api_get :show, :id => order.to_param
 
-          json_response['included_tax_total'].should == '0.0'
-          json_response['additional_tax_total'].should == '0.0'
-          json_response['display_included_tax_total'].should == '$0.00'
-          json_response['display_additional_tax_total'].should == '$0.00'
+          expect(json_response['included_tax_total']).to eq('0.0')
+          expect(json_response['additional_tax_total']).to eq('0.0')
+          expect(json_response['display_included_tax_total']).to eq('$0.00')
+          expect(json_response['display_additional_tax_total']).to eq('$0.00')
         end
 
         it "lists line item adjustments" do
@@ -478,8 +521,8 @@ module Spree
           api_get :show, :id => order.to_param
 
           adjustment = json_response['line_items'].first['adjustments'].first
-          adjustment['label'].should == "10% off!"
-          adjustment['amount'].should == "5.0"
+          expect(adjustment['label']).to eq("10% off!")
+          expect(adjustment['amount']).to eq("5.0")
         end
 
         it "lists payments source without gateway info" do
@@ -520,33 +563,33 @@ module Spree
 
           it "returns available shipments for an order" do
             api_get :show, :id => order.to_param
-            response.status.should == 200
-            json_response["shipments"].should_not be_empty
+            expect(response.status).to eq(200)
+            expect(json_response["shipments"]).not_to be_empty
             shipment = json_response["shipments"][0]
             # Test for correct shipping method attributes
             # Regression test for #3206
-            shipment["shipping_methods"].should_not be_nil
+            expect(shipment["shipping_methods"]).not_to be_nil
             json_shipping_method = shipment["shipping_methods"][0]
-            json_shipping_method["id"].should == shipping_method.id
-            json_shipping_method["name"].should == shipping_method.name
-            json_shipping_method["code"].should == shipping_method.code
-            json_shipping_method["zones"].should_not be_empty
-            json_shipping_method["shipping_categories"].should_not be_empty
+            expect(json_shipping_method["id"]).to eq(shipping_method.id)
+            expect(json_shipping_method["name"]).to eq(shipping_method.name)
+            expect(json_shipping_method["code"]).to eq(shipping_method.code)
+            expect(json_shipping_method["zones"]).not_to be_empty
+            expect(json_shipping_method["shipping_categories"]).not_to be_empty
 
             # Test for correct shipping rates attributes
             # Regression test for #3206
-            shipment["shipping_rates"].should_not be_nil
+            expect(shipment["shipping_rates"]).not_to be_nil
             shipping_rate = shipment["shipping_rates"][0]
-            shipping_rate["name"].should == json_shipping_method["name"]
-            shipping_rate["cost"].should == "10.0"
-            shipping_rate["selected"].should be true
-            shipping_rate["display_cost"].should == "$10.00"
-            shipping_rate["shipping_method_code"].should == json_shipping_method["code"]
+            expect(shipping_rate["name"]).to eq(json_shipping_method["name"])
+            expect(shipping_rate["cost"]).to eq("10.0")
+            expect(shipping_rate["selected"]).to be true
+            expect(shipping_rate["display_cost"]).to eq("$10.00")
+            expect(shipping_rate["shipping_method_code"]).to eq(json_shipping_method["code"])
 
-            shipment["stock_location_name"].should_not be_blank
+            expect(shipment["stock_location_name"]).not_to be_blank
             manifest_item = shipment["manifest"][0]
-            manifest_item["quantity"].should == 1
-            manifest_item["variant_id"].should == order.line_items.first.variant_id
+            expect(manifest_item["quantity"]).to eq(1)
+            expect(manifest_item["variant_id"]).to eq(order.line_items.first.variant_id)
           end
         end
       end
@@ -559,7 +602,7 @@ module Spree
         before { Spree::Order.delete_all }
         it "still returns a root :orders key" do
           api_get :index
-          json_response["orders"].should == []
+          expect(json_response["orders"]).to eq([])
         end
       end
 
@@ -612,20 +655,20 @@ module Spree
 
         it "can view all orders" do
           api_get :index
-          json_response["orders"].first.should have_attributes(attributes)
-          json_response["count"].should == 2
-          json_response["current_page"].should == 1
-          json_response["pages"].should == 1
+          expect(json_response["orders"].first).to have_attributes(attributes)
+          expect(json_response["count"]).to eq(2)
+          expect(json_response["current_page"]).to eq(1)
+          expect(json_response["pages"]).to eq(1)
         end
 
         # Test for #1763
         it "can control the page size through a parameter" do
           api_get :index, :per_page => 1
-          json_response["orders"].count.should == 1
-          json_response["orders"].first.should have_attributes(attributes)
-          json_response["count"].should == 1
-          json_response["current_page"].should == 1
-          json_response["pages"].should == 2
+          expect(json_response["orders"].count).to eq(1)
+          expect(json_response["orders"].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(2)
         end
       end
 
@@ -639,21 +682,21 @@ module Spree
 
         it "can query the results through a parameter" do
           api_get :index, :q => { :email_cont => 'spree' }
-          json_response["orders"].count.should == 1
-          json_response["orders"].first.should have_attributes(attributes)
-          json_response["orders"].first["email"].should == expected_result.email
-          json_response["count"].should == 1
-          json_response["current_page"].should == 1
-          json_response["pages"].should == 1
+          expect(json_response["orders"].count).to eq(1)
+          expect(json_response["orders"].first).to have_attributes(attributes)
+          expect(json_response["orders"].first["email"]).to eq(expected_result.email)
+          expect(json_response["count"]).to eq(1)
+          expect(json_response["current_page"]).to eq(1)
+          expect(json_response["pages"]).to eq(1)
         end
       end
 
       context "creation" do
         it "can create an order without any parameters" do
-          lambda { api_post :create }.should_not raise_error
-          response.status.should == 201
+          expect { api_post :create }.not_to raise_error
+          expect(response.status).to eq(201)
           order = Order.last
-          json_response["state"].should == "cart"
+          expect(json_response["state"]).to eq("cart")
         end
 
         it "can arbitrarily set the line items price" do
@@ -672,7 +715,7 @@ module Spree
           user = Spree.user_class.create
           api_post :create, :order => { user_id: user.id }
           expect(response.status).to eq 201
-          json_response["user_id"].should == user.id
+          expect(json_response["user_id"]).to eq(user.id)
         end
       end
 
@@ -681,7 +724,7 @@ module Spree
           user = Spree.user_class.create
           api_post :update, :id => order.number, :order => { user_id: user.id }
           expect(response.status).to eq 200
-          json_response["user_id"].should == user.id
+          expect(json_response["user_id"]).to eq(user.id)
         end
       end
 
@@ -697,7 +740,7 @@ module Spree
 
         specify do
           api_put :cancel, :id => order.to_param
-          json_response["state"].should == "canceled"
+          expect(json_response["state"]).to eq("canceled")
         end
       end
     end