spree_api 3.3.0.rc1 → 3.3.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26fb8c0927a1d6b2423649295a3dd8ea7aeb798f
-  data.tar.gz: 914d854628f209659d0693b408b5aedc24bf6a5c
+  metadata.gz: 23d326e39ca317d532c54546890bd3983f95c502
+  data.tar.gz: e75a525d378f3a1448040ee11f1220737a2db6f6
 SHA512:
-  metadata.gz: 254a9e9ba85214262fa672d11d259df4dfbdb141d25a94747d0984d77e926618070ba9662a549e8a6ccd83c902fd696ababfbc7f56db9ac762e7615055d88c16
-  data.tar.gz: 76cee411a30b7d769e76a74e9ad3146610005e34fc413cb032d98b24122a2ac16f8a5158d4b77f127d32d1668a93698f39c4656463c79b1292478450efc3ca68
+  metadata.gz: 032b7f4f3abcbab1843cd5bf1992e5c2fc60993f02a79dcef12881d252bace12e764cade45734a32e691a36f1658f00c1e45f47c76252ed7ee1bf60b25a8b8ce
+  data.tar.gz: 6219755053eb139c06e9601360adadb7c0f8f96e326c78e4a66b961577dc2e3bd63d50f51c46e306f2820148704dadf652c72197f0ce2643fd9785c9dabb9645

data/app/controllers/spree/api/v1/users_controller.rb

@@ -6,7 +6,15 @@ module Spree
         rescue_from Spree::Core::DestroyWithOrdersError, with: :error_during_processing
 
         def index
-          @users = Spree.user_class.accessible_by(current_ability,:read).ransack(params[:q]).result.page(params[:page]).per(params[:per_page])
+          @users = Spree.user_class.accessible_by(current_ability, :read)
+
+          @users = if params[:ids]
+                     @users.ransack(id_in: params[:ids].split(','))
+                   else
+                     @users.ransack(params[:q])
+                   end
+
+          @users = @users.result.page(params[:page]).per(params[:per_page])
           expires_in 15.minutes, public: true
           headers['Surrogate-Control'] = "max-age=#{15.minutes}"
           respond_with(@users)

data/config/routes.rb

@@ -121,7 +121,13 @@ Spree::Core::Engine.add_routes do
     end
 
     spree_path = Rails.application.routes.url_helpers.try(:spree_path, trailing_slash: true) || '/'
-    match 'v:api/*path', to: redirect("#{spree_path}api/v1/%{path}"), via: [:get, :post, :put, :patch, :delete]
+
+    match 'v:api/*path', to: redirect{ |params, request|
+      format = ".#{params[:format]}" unless params[:format].blank?
+      query  = "?#{request.query_string}" unless request.query_string.blank?
+
+      "#{spree_path}api/v1/#{params[:path]}#{format}#{query}"
+    }, via: [:get, :post, :put, :patch, :delete]
 
     match '*path', to: redirect{ |params, request|
       format = ".#{params[:format]}" unless params[:format].blank?

data/spree_api.gemspec

@@ -11,9 +11,8 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.2.7'
 
-  s.files         = `git ls-files`.split($\)
+  s.files         = `git ls-files`.split($\).reject { |f| f.match(/^spec/) }
   s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.name          = "spree_api"
   s.require_paths = ["lib"]
   s.version       = Spree.version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_api
 version: !ruby/object:Gem::Version
-  version: 3.3.0.rc1
+  version: 3.3.0.rc2
 platform: ruby
 authors:
 - Ryan Bigg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-02 00:00:00.000000000 Z
+date: 2017-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.3.0.rc1
+        version: 3.3.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.3.0.rc1
+        version: 3.3.0.rc2
 - !ruby/object:Gem::Dependency
   name: rabl
   requirement: !ruby/object:Gem::Requirement
@@ -213,50 +213,6 @@ files:
 - lib/spree/api/testing_support/setup.rb
 - lib/spree_api.rb
 - script/rails
-- spec/controllers/spree/api/base_controller_spec.rb
-- spec/controllers/spree/api/v1/addresses_controller_spec.rb
-- spec/controllers/spree/api/v1/checkouts_controller_spec.rb
-- spec/controllers/spree/api/v1/classifications_controller_spec.rb
-- spec/controllers/spree/api/v1/countries_controller_spec.rb
-- spec/controllers/spree/api/v1/credit_cards_controller_spec.rb
-- spec/controllers/spree/api/v1/customer_returns_controller_spec.rb
-- spec/controllers/spree/api/v1/images_controller_spec.rb
-- spec/controllers/spree/api/v1/inventory_units_controller_spec.rb
-- spec/controllers/spree/api/v1/line_items_controller_spec.rb
-- spec/controllers/spree/api/v1/option_types_controller_spec.rb
-- spec/controllers/spree/api/v1/option_values_controller_spec.rb
-- spec/controllers/spree/api/v1/orders_controller_spec.rb
-- spec/controllers/spree/api/v1/payments_controller_spec.rb
-- spec/controllers/spree/api/v1/product_properties_controller_spec.rb
-- spec/controllers/spree/api/v1/products_controller_spec.rb
-- spec/controllers/spree/api/v1/promotion_application_spec.rb
-- spec/controllers/spree/api/v1/promotions_controller_spec.rb
-- spec/controllers/spree/api/v1/properties_controller_spec.rb
-- spec/controllers/spree/api/v1/reimbursements_controller_spec.rb
-- spec/controllers/spree/api/v1/return_authorizations_controller_spec.rb
-- spec/controllers/spree/api/v1/shipments_controller_spec.rb
-- spec/controllers/spree/api/v1/states_controller_spec.rb
-- spec/controllers/spree/api/v1/stock_items_controller_spec.rb
-- spec/controllers/spree/api/v1/stock_locations_controller_spec.rb
-- spec/controllers/spree/api/v1/stock_movements_controller_spec.rb
-- spec/controllers/spree/api/v1/stores_controller_spec.rb
-- spec/controllers/spree/api/v1/tags_controller_spec.rb
-- spec/controllers/spree/api/v1/taxonomies_controller_spec.rb
-- spec/controllers/spree/api/v1/taxons_controller_spec.rb
-- spec/controllers/spree/api/v1/unauthenticated_products_controller_spec.rb
-- spec/controllers/spree/api/v1/users_controller_spec.rb
-- spec/controllers/spree/api/v1/variants_controller_spec.rb
-- spec/controllers/spree/api/v1/zones_controller_spec.rb
-- spec/fixtures/thinking-cat.jpg
-- spec/models/spree/legacy_user_spec.rb
-- spec/requests/rabl_cache_spec.rb
-- spec/requests/ransackable_attributes_spec.rb
-- spec/requests/version_spec.rb
-- spec/shared_examples/protect_product_actions.rb
-- spec/spec_helper.rb
-- spec/support/controller_hacks.rb
-- spec/support/database_cleaner.rb
-- spec/support/have_attributes_matcher.rb
 - spree_api.gemspec
 homepage: https://spreecommerce.com
 licenses:
@@ -278,52 +234,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Spree's API
-test_files:
-- spec/controllers/spree/api/base_controller_spec.rb
-- spec/controllers/spree/api/v1/addresses_controller_spec.rb
-- spec/controllers/spree/api/v1/checkouts_controller_spec.rb
-- spec/controllers/spree/api/v1/classifications_controller_spec.rb
-- spec/controllers/spree/api/v1/countries_controller_spec.rb
-- spec/controllers/spree/api/v1/credit_cards_controller_spec.rb
-- spec/controllers/spree/api/v1/customer_returns_controller_spec.rb
-- spec/controllers/spree/api/v1/images_controller_spec.rb
-- spec/controllers/spree/api/v1/inventory_units_controller_spec.rb
-- spec/controllers/spree/api/v1/line_items_controller_spec.rb
-- spec/controllers/spree/api/v1/option_types_controller_spec.rb
-- spec/controllers/spree/api/v1/option_values_controller_spec.rb
-- spec/controllers/spree/api/v1/orders_controller_spec.rb
-- spec/controllers/spree/api/v1/payments_controller_spec.rb
-- spec/controllers/spree/api/v1/product_properties_controller_spec.rb
-- spec/controllers/spree/api/v1/products_controller_spec.rb
-- spec/controllers/spree/api/v1/promotion_application_spec.rb
-- spec/controllers/spree/api/v1/promotions_controller_spec.rb
-- spec/controllers/spree/api/v1/properties_controller_spec.rb
-- spec/controllers/spree/api/v1/reimbursements_controller_spec.rb
-- spec/controllers/spree/api/v1/return_authorizations_controller_spec.rb
-- spec/controllers/spree/api/v1/shipments_controller_spec.rb
-- spec/controllers/spree/api/v1/states_controller_spec.rb
-- spec/controllers/spree/api/v1/stock_items_controller_spec.rb
-- spec/controllers/spree/api/v1/stock_locations_controller_spec.rb
-- spec/controllers/spree/api/v1/stock_movements_controller_spec.rb
-- spec/controllers/spree/api/v1/stores_controller_spec.rb
-- spec/controllers/spree/api/v1/tags_controller_spec.rb
-- spec/controllers/spree/api/v1/taxonomies_controller_spec.rb
-- spec/controllers/spree/api/v1/taxons_controller_spec.rb
-- spec/controllers/spree/api/v1/unauthenticated_products_controller_spec.rb
-- spec/controllers/spree/api/v1/users_controller_spec.rb
-- spec/controllers/spree/api/v1/variants_controller_spec.rb
-- spec/controllers/spree/api/v1/zones_controller_spec.rb
-- spec/fixtures/thinking-cat.jpg
-- spec/models/spree/legacy_user_spec.rb
-- spec/requests/rabl_cache_spec.rb
-- spec/requests/ransackable_attributes_spec.rb
-- spec/requests/version_spec.rb
-- spec/shared_examples/protect_product_actions.rb
-- spec/spec_helper.rb
-- spec/support/controller_hacks.rb
-- spec/support/database_cleaner.rb
-- spec/support/have_attributes_matcher.rb
+test_files: []

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

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-class FakesController < Spree::Api::BaseController
-end
-
-describe Spree::Api::BaseController, type: :controller do
-  render_views
-  controller(Spree::Api::BaseController) do
-    def index
-      render plain: { "products" => [] }.to_json
-    end
-  end
-
-  before do
-    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
-      r.draw { get 'index', to: 'spree/api/base#index' }
-    end
-  end
-
-  context "when validating based on an order token" do
-    let!(:order) { create :order }
-
-    context "with a correct order token" do
-      it "succeeds" do
-        api_get :index, order_token: order.guest_token, order_id: order.number
-        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
-        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
-        expect(response.status).to eq(401)
-      end
-    end
-  end
-
-  context "cannot make a request to the API" do
-    it "without an API key" do
-      api_get :index
-      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
-      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, params: { token: "fake_key" }
-      expect(json_response).to eq({ "error" => "Invalid API key (fake_key) specified." })
-    end
-  end
-
-  it 'handles parameter missing exceptions' do
-    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(ActionController::ParameterMissing.new('foo'))
-    get :index, params: { token: 'exception-message' }
-    expect(json_response).to eql('exception' => 'param is missing or the value is empty: foo')
-  end
-
-  it 'handles record invalid exceptions' do
-    expect(subject).to receive(:authenticate_user).and_return(true)
-    expect(subject).to receive(:load_user_roles).and_return(true)
-    resource = Spree::Product.new
-    resource.valid? # get some errors
-    expect(subject).to receive(:index).and_raise(ActiveRecord::RecordInvalid.new(resource))
-    get :index, params: { token: 'exception-message' }
-    expect(json_response).to eql('exception' => "Validation failed: Name can't be blank, Shipping Category can't be blank, Price can't be blank")
-  end
-
-  it "lets a subclass override the product associations that are eager-loaded" do
-    expect(controller.respond_to?(:product_includes, true)).to be
-  end
-end

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

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe Api::V1::AddressesController, type: :controller do
-    render_views
-
-    before do
-      stub_authentication!
-      @address = create(:address)
-      @order = create(:order, bill_address: @address)
-    end
-
-    context "with their own address" do
-      before do
-        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
-        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" }
-        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: "" }
-
-        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
-
-    context "on an address that does not belong to this order" do
-      before do
-        @order.bill_address_id = nil
-        @order.ship_address = nil
-      end
-
-      it "cannot retrieve address information" do
-        api_get :show, id: @address.id, order_id: @order.number
-        assert_unauthorized!
-      end
-
-      it "cannot update address information" do
-        api_get :update, id: @address.id, order_id: @order.number
-        assert_unauthorized!
-      end
-    end
-  end
-end

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

@@ -1,361 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe Api::V1::CheckoutsController, type: :controller do
-    render_views
-
-    shared_examples_for 'action which loads order using load_order_with_lock' do
-      before do
-        allow(controller).to receive(:load_order).with(true).and_return(true)
-      end
-
-      it 'should invoke load_order_with_lock' do
-        expect(controller).to receive(:load_order_with_lock).exactly(1).times
-      end
-
-      it 'should invoke load_order' do
-        expect(controller).to receive(:load_order).with(true).exactly(1).times.and_return(true)
-      end
-
-      context 'ensure no double_render_error' do
-        before do
-          def controller.load_order(*)
-            respond_with(@order, default_template: 'spree/api/v1/orders/show', status: 200)
-          end
-        end
-
-        it 'should not generate double_render_error' do
-          expect(response).to be_success
-        end
-      end
-
-      after do
-        send_request
-      end
-    end
-
-    before(:each) do
-      stub_authentication!
-      Spree::Config[:track_inventory_levels] = false
-      country_zone = create(:zone, name: 'CountryZone')
-      @state = create(:state)
-      @country = @state.country
-      country_zone.members.create(zoneable: @country)
-      create(:stock_location)
-
-      @shipping_method = create(:shipping_method, zones: [country_zone])
-      @payment_method = create(:credit_card_payment_method)
-    end
-
-    after do
-      Spree::Config[:track_inventory_levels] = true
-    end
-
-    context "PUT 'update'" do
-      let(:order) do
-        order = create(:order_with_line_items)
-        # Order should be in a pristine state
-        # Without doing this, the order may transition from 'cart' straight to 'delivery'
-        order.shipments.delete_all
-        order
-      end
-
-      before(:each) do
-        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
-        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
-        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
-        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
-        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 } } }
-        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 } } }
-        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
-        skip "not sure if this test is valid"
-        order.bill_address = nil
-        order.save
-        order.update_column(:state, "address")
-        api_put :update, id: order.to_param, order_token: order.guest_token
-        # Order has not transitioned
-        expect(response.status).to eq(422)
-      end
-
-      context "transitioning to delivery" do
-        before do
-          order.update_column(:state, "address")
-        end
-
-        let(:address) do
-          {
-            firstname:  'John',
-            lastname:   'Doe',
-            address1:   '7735 Old Georgetown Road',
-            city:       'Bethesda',
-            phone:      '3014445002',
-            zipcode:    '20814',
-            state_id:   @state.id,
-            country_id: @country.id
-          }
-        end
-
-        it "can update addresses and transition from address to delivery" do
-          api_put :update,
-            id: order.to_param, order_token: order.guest_token,
-            order: {
-              bill_address_attributes: address,
-              ship_address_attributes: address
-            }
-          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 Spec for #5389 & #5880
-        it "can update addresses but not transition to delivery w/o shipping setup" do
-          Spree::ShippingMethod.destroy_all
-          api_put :update,
-            id: order.to_param, order_token: order.guest_token,
-            order: {
-              bill_address_attributes: address,
-              ship_address_attributes: address
-            }
-          expect(json_response['error']).to eq(I18n.t(:could_not_transition, scope: "spree.api.order"))
-          expect(response.status).to eq(422)
-        end
-
-        # Regression test for #4498
-        it "does not contain duplicate variant data in delivery return" do
-          api_put :update,
-            id: order.to_param, order_token: order.guest_token,
-            order: {
-              bill_address_attributes: address,
-              ship_address_attributes: address
-            }
-          # Shipments manifests should not return the ENTIRE variant
-          # This information is already present within the order's line items
-          expect(json_response['shipments'].first['manifest'].first['variant']).to be_nil
-          expect(json_response['shipments'].first['manifest'].first['variant_id']).to_not be_nil
-        end
-      end
-
-      it "can update shipping method and transition from delivery to payment" do
-        order.update_column(:state, "delivery")
-        shipment = create(:shipment, order: order)
-        shipment.refresh_rates
-        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 } } }
-        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
-        expect(json_shipping_rate['selected']).to be true
-        # Order should automatically transfer to payment because all criteria are met
-        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 }] }
-        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
-        order.update_column(:state, "payment")
-        source_attributes = {
-          number: "4111111111111111",
-          month: 1.month.from_now.month,
-          year: 1.month.from_now.year,
-          verification_value: "123",
-          name: "Spree Commerce"
-        }
-
-        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 } }
-        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
-        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 }]
-          },
-          payment_source: {
-            @payment_method.id.to_s => { name: "Spree" }
-          }
-
-        expect(response.status).to eq(422)
-        cc_errors = json_response['errors']['payments.Credit Card']
-        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
-        order.update_column(:state, "payment")
-        credit_card = create(:credit_card, user_id: order.user_id, payment_method_id: @payment_method.id)
-
-        api_put :update, id: order.to_param, order_token: order.guest_token,
-          order: { existing_card: credit_card.id }
-
-        expect(response.status).to eq 200
-        expect(order.credit_cards).to match_array [credit_card]
-      end
-
-      it "can transition from confirm to complete" do
-        order.update_columns(state: 'confirm')
-        allow_any_instance_of(Spree::Order).to receive_messages(payment_required?: false)
-        api_put :update, id: order.to_param, order_token: order.guest_token
-        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_columns(completed_at: Time.current, state: 'complete')
-        api_put :update, id: order.to_param, order_token: order.guest_token
-        expect(json_response['number']).to eq(order.number)
-        expect(response.status).to eq(200)
-      end
-
-      # Regression test for #3784
-      it "can update the special instructions for an order" do
-        instructions = "Don't drop it. (Please)"
-        api_put :update, id: order.to_param, order_token: order.guest_token,
-          order: { special_instructions: instructions }
-        expect(json_response['special_instructions']).to eql(instructions)
-      end
-
-      context "as an admin" do
-        sign_in_as_admin!
-        it "can assign a user to the order" do
-          user = create(:user)
-          # 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.org" }
-          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.org" }
-        expect(json_response['email']).to eq("guest@spreecommerce.org")
-        expect(response.status).to eq(200)
-      end
-
-      it "can apply a coupon code to an order" do
-        order.update_column(:state, "payment")
-        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
-
-      def send_request
-        api_put :update, id: order.to_param, order_token: order.guest_token
-      end
-
-      it_should_behave_like 'action which loads order using load_order_with_lock'
-    end
-
-    context "PUT 'next'" do
-      let!(:order) { create(:order_with_line_items) }
-      it "cannot transition to address without a line item" do
-        order.line_items.delete_all
-        order.update_column(:email, "spree@example.com")
-        api_put :next, id: order.to_param, order_token: order.guest_token
-        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
-        expect(response.status).to eq(200)
-        expect(json_response['state']).to eq('address')
-      end
-
-      it "cannot transition if order email is blank" do
-        order.update_columns(
-          state: 'address',
-          email: nil
-        )
-
-        api_put :next, id: order.to_param, order_token: order.guest_token
-        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: {}
-        expect(json_response["errors"]["base"]).to include(Spree.t(:no_payment_found))
-      end
-
-      def send_request
-        api_put :next, id: order.to_param, order_token: order.guest_token
-      end
-
-      it_should_behave_like 'action which loads order using load_order_with_lock'
-    end
-
-    context "PUT 'advance'" do
-      let!(:order) { create(:order_with_line_items) }
-
-      it 'continues to advance advances an order while it can move forward' do
-        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
-        expect(json_response['id']).to eq(order.id)
-      end
-
-      def send_request
-        api_put :advance, id: order.to_param, order_token: order.guest_token
-      end
-
-      it_should_behave_like 'action which loads order using load_order_with_lock'
-    end
-  end
-end