spree_api 2.4.0.rc2 → 2.4.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 000f3c59be99481b14b2742325d274f133cabc00
-  data.tar.gz: 01625468afdfecc7484af058fc6e74bb23e3f0a9
+  metadata.gz: b712d43706678d3c8d2bdc20f8d43fff8c97bd2e
+  data.tar.gz: cd84829e4d96b32d0da411588a7531b6855668a4
 SHA512:
-  metadata.gz: 3b8c446b4667837e62be864f8293a1fbd5c4a24d2c0fd467197b1c50c3c55f6065ac0fe192b72825c2eee20cdb232464c6e73bc45b354008153cfbdf43c06e52
-  data.tar.gz: 779a8935320852f6b76df950fb1e444c79a2fff2f5ce9989408d909d30ab9e4f003c681d6b26c32b2327457d08cfac108158b5f287c80083b9d07daecd5d4435
+  metadata.gz: ba4fb81a81896f4851cc69fd23a3816b77ef4b8ec7f484cb08dcfbc78a39a9ce136d3b64bcce8610a97b34a497e259b8a2e8724af4fad664d73bbf426acb1218
+  data.tar.gz: 8be64b301511026a1b6c22f938a1dc7d42b8ea651c65c70ba180a07437ae7be511decfdac3c5327d1480b0e8fe14bb2e081162fc59e10d027c79defd19bc432c

data/app/controllers/spree/api/base_controller.rb

@@ -142,11 +142,9 @@ module Spree
       end
 
       def find_product(id)
-        begin
-          product_scope.friendly.find(id.to_s)
-        rescue ActiveRecord::RecordNotFound
-          product_scope.find(id)
-        end
+        product_scope.friendly.find(id.to_s)
+      rescue ActiveRecord::RecordNotFound
+        product_scope.find(id)
       end
 
       def product_scope
@@ -168,7 +166,7 @@ module Spree
       end
 
       def product_includes
-        [ :option_types, variants: variants_associations, master: variants_associations ]
+        [ :option_types, :taxons, product_properties: :property, variants: variants_associations, master: variants_associations ]
       end
 
       def order_id

data/app/controllers/spree/api/option_types_controller.rb

@@ -3,9 +3,9 @@ module Spree
     class OptionTypesController < Spree::Api::BaseController
       def index
         if params[:ids]
-          @option_types = Spree::OptionType.accessible_by(current_ability, :read).where(:id => params[:ids].split(','))
+          @option_types = Spree::OptionType.includes(:option_values).accessible_by(current_ability, :read).where(id: params[:ids].split(','))
         else
-          @option_types = Spree::OptionType.accessible_by(current_ability, :read).load.ransack(params[:q]).result
+          @option_types = Spree::OptionType.includes(:option_values).accessible_by(current_ability, :read).load.ransack(params[:q]).result
         end
         respond_with(@option_types)
       end

data/app/controllers/spree/api/orders_controller.rb

@@ -59,7 +59,15 @@ module Spree
         find_order(true)
         authorize! :update, @order, order_token
 
-        if @order.contents.update_cart(order_params)
+        result = if request.patch?
+          # This will update the order without a checkout reset.
+          @order.update_attributes(order_params)
+        else
+          # This will reset checkout back to address and delete all shipments.
+          @order.contents.update_cart(order_params)
+        end
+
+        if result
           user_id = params[:order][:user_id]
           if current_api_user.has_spree_role?('admin') && user_id
             @order.associate_user!(Spree.user_class.find(user_id))

data/app/controllers/spree/api/return_authorizations_controller.rb

@@ -45,15 +45,6 @@ module Spree
         end
       end
 
-      def receive
-        @return_authorization = order.return_authorizations.accessible_by(current_ability, :update).find(params[:id])
-        if @return_authorization.receive
-          respond_with @return_authorization, default_template: :show
-        else
-          invalid_resource!(@return_authorization)
-        end
-      end
-
       def cancel
         @return_authorization = order.return_authorizations.accessible_by(current_ability, :update).find(params[:id])
         if @return_authorization.cancel

data/app/controllers/spree/api/taxons_controller.rb

@@ -6,9 +6,9 @@ module Spree
           @taxons = taxonomy.root.children
         else
           if params[:ids]
-            @taxons = Spree::Taxon.accessible_by(current_ability, :read).where(id: params[:ids].split(','))
+            @taxons = Spree::Taxon.includes(:children).accessible_by(current_ability, :read).where(id: params[:ids].split(','))
           else
-            @taxons = Spree::Taxon.accessible_by(current_ability, :read).order(:taxonomy_id, :lft).ransack(params[:q]).result
+            @taxons = Spree::Taxon.includes(:children).accessible_by(current_ability, :read).order(:taxonomy_id, :lft).ransack(params[:q]).result
           end
         end
 
@@ -65,7 +65,7 @@ module Spree
         # Products#index does not do the sorting.
         taxon = Spree::Taxon.find(params[:id])
         @products = taxon.products.ransack(params[:q]).result
-        @products = @products.page(params[:page]).per(500 || params[:per_page])
+        @products = @products.page(params[:page]).per(params[:per_page] || 500)
         render "spree/api/products/index"
       end
 

data/app/helpers/spree/api/api_helpers.rb

@@ -15,8 +15,6 @@ module Spree
         :shipment_attributes,
         :taxonomy_attributes,
         :taxon_attributes,
-        :inventory_unit_attributes,
-        :return_authorization_attributes,
         :address_attributes,
         :country_attributes,
         :state_attributes,

data/app/views/spree/api/orders/show.v1.rabl

@@ -46,3 +46,7 @@ end
 node :permissions do
   { can_update: current_ability.can?(:update, root_object) }
 end
+
+child :valid_credit_cards => :credit_cards do
+  extends "spree/api/credit_cards/show"
+end

data/app/views/spree/api/products/show.v1.rabl

@@ -21,3 +21,7 @@ end
 child :product_properties => :product_properties do
   attributes *product_property_attributes
 end
+
+child :taxons => :taxons do
+  extends "spree/api/taxons/show"
+end

data/app/views/spree/api/shipments/small.v1.rabl

@@ -31,3 +31,7 @@ child :manifest => :manifest do
   node(:quantity) { |m| m.quantity }
   node(:states) { |m| m.states }
 end
+
+child :adjustments => :adjustments do
+  extends "spree/api/adjustments/show"
+end

data/lib/spree/api/testing_support/helpers.rb

@@ -12,23 +12,23 @@ module Spree
         end
 
         def assert_not_found!
-          json_response.should == { "error" => "The resource you were looking for could not be found." }
-          response.status.should == 404
+          expect(json_response).to eq({ "error" => "The resource you were looking for could not be found." })
+          expect(response.status).to eq 404
         end
 
         def assert_unauthorized!
-          json_response.should == { "error" => "You are not authorized to perform that action." }
-          response.status.should == 401
+          expect(json_response).to eq({ "error" => "You are not authorized to perform that action." })
+          expect(response.status).to eq 401
         end
 
         def stub_authentication!
-          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 }
         end
 
         # This method can be overriden (with a let block) inside a context
         # For instance, if you wanted to have an admin user instead.
         def current_api_user
-          @current_api_user ||= stub_model(Spree::LegacyUser, :email => "spree@example.com")
+          @current_api_user ||= stub_model(Spree::LegacyUser, email: "spree@example.com")
         end
 
         def image(filename)

data/lib/spree/api/testing_support/setup.rb

@@ -5,8 +5,8 @@ module Spree
         def sign_in_as_admin!
           let!(:current_api_user) do
             user = stub_model(Spree::LegacyUser)
-            user.stub_chain(:spree_roles, :pluck).and_return(["admin"])
-            user.stub(:has_spree_role?).with("admin").and_return(true)
+            allow(user).to receive_message_chain(:spree_roles, :pluck).and_return(["admin"])
+            allow(user).to receive(:has_spree_role?).with("admin").and_return(true)
             user
           end
         end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::AddressesController do
+  describe Api::AddressesController, :type => :controller do
     render_views
 
     before do
@@ -12,27 +12,27 @@ module Spree
 
     context "with their own address" 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 "gets an address" do
         api_get :show, :id => @address.id, :order_id => @order.number
-        json_response['address1'].should eq @address.address1
+        expect(json_response['address1']).to eq @address.address1
       end
 
       it "updates an address" do
         api_put :update, :id => @address.id, :order_id => @order.number,
                          :address => { :address1 => "123 Test Lane" }
-        json_response['address1'].should eq '123 Test Lane'
+        expect(json_response['address1']).to eq '123 Test Lane'
       end
 
       it "receives the errors object if address is invalid" do
         api_put :update, :id => @address.id, :order_id => @order.number,
                          :address => { :address1 => "" }
 
-        json_response['error'].should_not be_nil
-        json_response['errors'].should_not be_nil
-        json_response['errors']['address1'].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']['address1'].first).to eq "can't be blank"
       end
     end
 
@@ -42,7 +42,7 @@ module Spree
         @order.ship_address = nil
       end
 
-      it "cannot retreive address information" do
+      it "cannot retrieve address information" do
         api_get :show, :id => @address.id, :order_id => @order.number
         assert_unauthorized!
       end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 class FakesController < Spree::Api::BaseController
 end
 
-describe Spree::Api::BaseController do
+describe Spree::Api::BaseController, :type => :controller do
   render_views
   controller(Spree::Api::BaseController) do
     def index
@@ -14,14 +14,14 @@ describe Spree::Api::BaseController do
   context "signed in as a user using an authentication extension" do
     before do
       user = double(:email => "spree@example.com")
-      user.stub_chain :spree_roles, pluck: []
-      controller.stub :try_spree_current_user => user
+      allow(user).to receive_message_chain :spree_roles, pluck: []
+      allow(controller).to receive_messages :try_spree_current_user => user
     end
 
     it "can make a request" do
       api_get :index
-      json_response.should == { "products" => [] }
-      response.status.should == 200
+      expect(json_response).to eq({ "products" => [] })
+      expect(response.status).to eq(200)
     end
   end
 
@@ -31,19 +31,19 @@ describe Spree::Api::BaseController do
     context "with a correct order token" do
       it "succeeds" do
         api_get :index, order_token: order.guest_token, order_id: order.number
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "succeeds with an order_number parameter" do
         api_get :index, order_token: order.guest_token, order_number: order.number
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
     end
 
     context "with an incorrect order token" do
       it "returns unauthorized" do
         api_get :index, order_token: "NOT_A_TOKEN", order_id: order.number
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
@@ -51,29 +51,29 @@ describe Spree::Api::BaseController do
   context "cannot make a request to the API" do
     it "without an API key" do
       api_get :index
-      json_response.should == { "error" => "You must specify an API key." }
-      response.status.should == 401
+      expect(json_response).to eq({ "error" => "You must specify an API key." })
+      expect(response.status).to eq(401)
     end
 
     it "with an invalid API key" do
       request.headers["X-Spree-Token"] = "fake_key"
       get :index, {}
-      json_response.should == { "error" => "Invalid API key (fake_key) specified." }
-      response.status.should == 401
+      expect(json_response).to eq({ "error" => "Invalid API key (fake_key) specified." })
+      expect(response.status).to eq(401)
     end
 
     it "using an invalid token param" do
       get :index, :token => "fake_key"
-      json_response.should == { "error" => "Invalid API key (fake_key) specified." }
+      expect(json_response).to eq({ "error" => "Invalid API key (fake_key) specified." })
     end
   end
 
   it 'handles exceptions' do
-    subject.should_receive(:authenticate_user).and_return(true)
-    subject.should_receive(:load_user_roles).and_return(true)
-    subject.should_receive(:index).and_raise(Exception.new("no joy"))
+    expect(subject).to receive(:authenticate_user).and_return(true)
+    expect(subject).to receive(:load_user_roles).and_return(true)
+    expect(subject).to receive(:index).and_raise(Exception.new("no joy"))
     get :index, :token => "fake_key"
-    json_response.should == { "exception" => "no joy" }
+    expect(json_response).to eq({ "exception" => "no joy" })
   end
 
   it "maps semantic keys to nested_attributes keys" do
@@ -84,12 +84,12 @@ describe Spree::Api::BaseController do
                    'name' => 'test order' }
 
     mapped = subject.map_nested_attributes_keys(klass, attributes)
-    mapped.has_key?('line_items_attributes').should be true
-    mapped.has_key?('name').should be true
+    expect(mapped.has_key?('line_items_attributes')).to be true
+    expect(mapped.has_key?('name')).to be true
   end
 
   it "lets a subclass override the product associations that are eager-loaded" do
-    controller.respond_to?(:product_includes, true).should be
+    expect(controller.respond_to?(:product_includes, true)).to be
   end
 
   describe '#error_during_processing' do
@@ -116,8 +116,8 @@ describe Spree::Api::BaseController do
 
     before do
       user = double(email: "spree@example.com")
-      user.stub_chain :spree_roles, pluck: []
-      controller.stub try_spree_current_user: user
+      allow(user).to receive_message_chain :spree_roles, pluck: []
+      allow(controller).to receive_messages try_spree_current_user: user
       routes.draw { get 'foo' => 'fakes#foo' }
     end
 

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CheckoutsController do
+  describe Api::CheckoutsController, :type => :controller do
     render_views
 
     before(:each) do
@@ -31,39 +31,39 @@ module Spree
       end
 
       before(:each) do
-        Order.any_instance.stub(:confirmation_required? => true)
-        Order.any_instance.stub(:payment_required? => true)
+        allow_any_instance_of(Order).to receive_messages(:confirmation_required? => true)
+        allow_any_instance_of(Order).to receive_messages(:payment_required? => true)
       end
 
       it "should transition a recently created order from cart to address" do
-        order.state.should eq "cart"
-        order.email.should_not be_nil
+        expect(order.state).to eq "cart"
+        expect(order.email).not_to be_nil
         api_put :update, :id => order.to_param, :order_token => order.guest_token
-        order.reload.state.should eq "address"
+        expect(order.reload.state).to eq "address"
       end
 
       it "should transition a recently created order from cart to address with order token in header" do
-        order.state.should eq "cart"
-        order.email.should_not be_nil
+        expect(order.state).to eq "cart"
+        expect(order.email).not_to be_nil
         request.headers["X-Spree-Order-Token"] = order.guest_token
         api_put :update, :id => order.to_param
-        order.reload.state.should eq "address"
+        expect(order.reload.state).to eq "address"
       end
 
       it "can take line_items_attributes as a parameter" do
         line_item = order.line_items.first
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
                          :order => { :line_items_attributes => { 0 => { :id => line_item.id, :quantity => 1 } } }
-        response.status.should == 200
-        order.reload.state.should eq "address"
+        expect(response.status).to eq(200)
+        expect(order.reload.state).to eq "address"
       end
 
       it "can take line_items as a parameter" do
         line_item = order.line_items.first
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
                          :order => { :line_items => { 0 => { :id => line_item.id, :quantity => 1 } } }
-        response.status.should == 200
-        order.reload.state.should eq "address"
+        expect(response.status).to eq(200)
+        expect(order.reload.state).to eq "address"
       end
 
       it "will return an error if the order cannot transition" do
@@ -73,7 +73,7 @@ module Spree
         order.update_column(:state, "address")
         api_put :update, :id => order.to_param, :order_token => order.guest_token
         # Order has not transitioned
-        response.status.should == 422
+        expect(response.status).to eq(422)
       end
 
       context "transitioning to delivery" do
@@ -101,10 +101,10 @@ module Spree
                     :bill_address_attributes => address,
                     :ship_address_attributes => address
                   }
-          json_response['state'].should == 'delivery'
-          json_response['bill_address']['firstname'].should == 'John'
-          json_response['ship_address']['firstname'].should == 'John'
-          response.status.should == 200
+          expect(json_response['state']).to eq('delivery')
+          expect(json_response['bill_address']['firstname']).to eq('John')
+          expect(json_response['ship_address']['firstname']).to eq('John')
+          expect(response.status).to eq(200)
         end
 
         # Regression test for #4498
@@ -129,25 +129,25 @@ module Spree
         shipping_rate = shipment.shipping_rates.where(:selected => false).first
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :shipments_attributes => { "0" => { :selected_shipping_rate_id => shipping_rate.id, :id => shipment.id } } }
-        response.status.should == 200
+        expect(response.status).to eq(200)
         # Find the correct shipment...
         json_shipment = json_response['shipments'].detect { |s| s["id"] == shipment.id }
         # Find the correct shipping rate for that shipment...
         json_shipping_rate = json_shipment['shipping_rates'].detect { |sr| sr["id"] == shipping_rate.id }
         # ... And finally ensure that it's selected
-        json_shipping_rate['selected'].should be true
+        expect(json_shipping_rate['selected']).to be true
         # Order should automatically transfer to payment because all criteria are met
-        json_response['state'].should == 'payment'
+        expect(json_response['state']).to eq('payment')
       end
 
       it "can update payment method and transition from payment to confirm" do
         order.update_column(:state, "payment")
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id }] }
-        json_response['state'].should == 'confirm'
-        json_response['payments'][0]['payment_method']['name'].should == @payment_method.name
-        json_response['payments'][0]['amount'].should == order.total.to_s
-        response.status.should == 200
+        expect(json_response['state']).to eq('confirm')
+        expect(json_response['payments'][0]['payment_method']['name']).to eq(@payment_method.name)
+        expect(json_response['payments'][0]['amount']).to eq(order.total.to_s)
+        expect(response.status).to eq(200)
       end
 
       it "can update payment method with source and transition from payment to confirm" do
@@ -163,9 +163,9 @@ module Spree
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id.to_s }],
                       :payment_source => { @payment_method.id.to_s => source_attributes } }
-        json_response['payments'][0]['payment_method']['name'].should == @payment_method.name
-        json_response['payments'][0]['amount'].should == order.total.to_s
-        response.status.should == 200
+        expect(json_response['payments'][0]['payment_method']['name']).to eq(@payment_method.name)
+        expect(json_response['payments'][0]['amount']).to eq(order.total.to_s)
+        expect(response.status).to eq(200)
       end
 
       it "returns errors when source is missing attributes" do
@@ -178,12 +178,12 @@ module Spree
             @payment_method.id.to_s => { name: "Spree" }
           }
 
-        response.status.should == 422
+        expect(response.status).to eq(422)
         cc_errors = json_response['errors']['payments.Credit Card']
-        cc_errors.should include("Number can't be blank")
-        cc_errors.should include("Month is not a number")
-        cc_errors.should include("Year is not a number")
-        cc_errors.should include("Verification Value can't be blank")
+        expect(cc_errors).to include("Number can't be blank")
+        expect(cc_errors).to include("Month is not a number")
+        expect(cc_errors).to include("Year is not a number")
+        expect(cc_errors).to include("Verification Value can't be blank")
       end
 
       it "allow users to reuse a credit card" do
@@ -199,17 +199,17 @@ module Spree
 
       it "can transition from confirm to complete" do
         order.update_column(:state, "confirm")
-        Spree::Order.any_instance.stub(:payment_required? => false)
+        allow_any_instance_of(Spree::Order).to receive_messages(:payment_required? => false)
         api_put :update, :id => order.to_param, :order_token => order.guest_token
-        json_response['state'].should == 'complete'
-        response.status.should == 200
+        expect(json_response['state']).to eq('complete')
+        expect(response.status).to eq(200)
       end
 
       it "returns the order if the order is already complete" do
         order.update_column(:state, "complete")
         api_put :update, :id => order.to_param, :order_token => order.guest_token
-        json_response['number'].should == order.number
-        response.status.should == 200
+        expect(json_response['number']).to eq(order.number)
+        expect(response.status).to eq(200)
       end
 
       # Regression test for #3784
@@ -227,24 +227,24 @@ module Spree
           # Need to pass email as well so that validations succeed
           api_put :update, :id => order.to_param, :order_token => order.guest_token,
             :order => { :user_id => user.id, :email => "guest@spreecommerce.com" }
-          response.status.should == 200
-          json_response['user_id'].should == user.id
+          expect(response.status).to eq(200)
+          expect(json_response['user_id']).to eq(user.id)
         end
       end
 
       it "can assign an email to the order" do
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :email => "guest@spreecommerce.com" }
-        json_response['email'].should == "guest@spreecommerce.com"
-        response.status.should == 200
+        expect(json_response['email']).to eq("guest@spreecommerce.com")
+        expect(response.status).to eq(200)
       end
 
       it "can apply a coupon code to an order" do
         skip "ensure that the order totals are properly updated, see frontend orders_controller or checkout_controller as example"
 
         order.update_column(:state, "payment")
-        PromotionHandler::Coupon.should_receive(:new).with(order).and_call_original
-        PromotionHandler::Coupon.any_instance.should_receive(:apply).and_return({:coupon_applied? => true})
+        expect(PromotionHandler::Coupon).to receive(:new).with(order).and_call_original
+        expect_any_instance_of(PromotionHandler::Coupon).to receive(:apply).and_return({:coupon_applied? => true})
         api_put :update, :id => order.to_param, :order_token => order.guest_token, :order => { :coupon_code => "foobar" }
       end
     end
@@ -255,16 +255,16 @@ module Spree
         order.line_items.delete_all
         order.update_column(:email, "spree@example.com")
         api_put :next, :id => order.to_param, :order_token => order.guest_token
-        response.status.should == 422
-        json_response["errors"]["base"].should include(Spree.t(:there_are_no_items_for_this_order))
+        expect(response.status).to eq(422)
+        expect(json_response["errors"]["base"]).to include(Spree.t(:there_are_no_items_for_this_order))
       end
 
       it "can transition an order to the next state" do
         order.update_column(:email, "spree@example.com")
 
         api_put :next, :id => order.to_param, :order_token => order.guest_token
-        response.status.should == 200
-        json_response['state'].should == 'address'
+        expect(response.status).to eq(200)
+        expect(json_response['state']).to eq('address')
       end
 
       it "cannot transition if order email is blank" do
@@ -274,14 +274,14 @@ module Spree
         )
 
         api_put :next, :id => order.to_param, :order_token => order.guest_token
-        response.status.should == 422
-        json_response['error'].should =~ /could not be transitioned/
+        expect(response.status).to eq(422)
+        expect(json_response['error']).to match(/could not be transitioned/)
       end
 
       it "doesnt advance payment state if order has no payment" do
         order.update_column(:state, "payment")
         api_put :next, :id => order.to_param, :order_token => order.guest_token, :order => {}
-        json_response["errors"]["base"].should include(Spree.t(:no_payment_found))
+        expect(json_response["errors"]["base"]).to include(Spree.t(:no_payment_found))
       end
     end
 
@@ -289,13 +289,13 @@ module Spree
       let!(:order) { create(:order_with_line_items) }
 
       it 'continues to advance advances an order while it can move forward' do
-        Spree::Order.any_instance.should_receive(:next).exactly(3).times.and_return(true, true, false)
+        expect_any_instance_of(Spree::Order).to receive(:next).exactly(3).times.and_return(true, true, false)
         api_put :advance, :id => order.to_param, :order_token => order.guest_token
       end
 
       it 'returns the order' do
         api_put :advance, :id => order.to_param, :order_token => order.guest_token
-        json_response['id'].should == order.id
+        expect(json_response['id']).to eq(order.id)
       end
     end
   end