spree_api 2.3.4 → 2.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67164eec95e8c7df0bd09088a07ccf352031bcf5
-  data.tar.gz: fd296233701f4684bde99697a8e009b107e6d2e2
+  metadata.gz: bf48939c8d5c9e705d069f0e86a1cc25671797ac
+  data.tar.gz: 5bc9f3903e8d012c20f36469825b2bc24ab73742
 SHA512:
-  metadata.gz: e6a47aa15c09115f6b8aeb8677c5bc3cac9dd035ac799cd2b3454102b8ec5f2dcaf1a9deadad156dd7ee33168a0e88154e6f7f816af87e5831d5790f4fd12c62
-  data.tar.gz: 01f1be77baf5bd64995358b732ef6003e20cedf4d951fc799a51505bb3d1fe42a5503f2cdb64c457e666e9a1cf69f82d0f3f646d83cc2ad4e6fa653b52cded7f
+  metadata.gz: 173933e3f5cfdc718056035c232401e48cde88491280b912dd173378021a4bf304f1d5dd83c9bcd2e7951a87359a4ad24b3c64e0ac35e701f5fdfb70f733197f
+  data.tar.gz: faddf7e2c60e3d8eef60620f8ba971708ca81d12c783ce2d67d20dc6d03513d577847f6fc04b1ee762fbf0c23ab9930033309e1217f7c3aae0404ff4a9720b15

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

@@ -97,8 +97,8 @@ module Spree
         Rails.logger.error exception.message
         Rails.logger.error exception.backtrace.join("\n")
 
-        render :text => { :exception => exception.message }.to_json,
-          :status => 422 and return
+        render text: { exception: exception.message }.to_json,
+          status: 422 and return
       end
 
       def gateway_error(exception)

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/shipments_controller.rb

@@ -5,11 +5,11 @@ module Spree
       before_filter :find_and_update_shipment, only: [:ship, :ready, :add, :remove]
 
       def create
-        @order = Spree::Order.find_by!(number: params[:shipment][:order_id])
+        @order = Spree::Order.find_by!(number: params.fetch(:shipment).fetch(:order_id))
         authorize! :read, @order
         authorize! :create, Shipment
         quantity = params[:quantity].to_i
-        @shipment = @order.shipments.create(stock_location_id: params[:stock_location_id])
+        @shipment = @order.shipments.create(stock_location_id: params.fetch(:stock_location_id))
         @order.contents.add(variant, quantity, nil, @shipment)
 
         @shipment.save!

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

@@ -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

@@ -21,8 +21,6 @@ module Spree
         :country_attributes,
         :state_attributes,
         :adjustment_attributes,
-        :inventory_unit_attributes,
-        :return_authorization_attributes,
         :creditcard_attributes,
         :payment_source_attributes,
         :user_attributes,

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/app/views/spree/api/variants/small.v1.rabl

@@ -4,6 +4,8 @@ cache [I18n.locale, 'small_variant', root_object]
 node(:display_price) { |p| p.display_price.to_s }
 node(:options_text) { |v| v.options_text }
 node(:in_stock) { |v| v.in_stock? }
+node(:is_backorderable) { |v| v.is_backorderable? }
+node(:total_on_hand) { |v| v.total_on_hand }
 
 child :option_values => :option_values do
   attributes *option_value_attributes

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
 

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Api::BaseController do
+describe Spree::Api::BaseController, :type => :controller do
   render_views
   controller(Spree::Api::BaseController) do
     def index
@@ -11,14 +11,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
 
@@ -28,19 +28,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
@@ -48,29 +48,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
@@ -81,11 +81,11 @@ 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
 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