solidus_api 2.2.2 → 2.3.0.beta1

data/spec/{controllers → requests}/spree/api/option_types_controller_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionTypesController, type: :controller do
-    render_views
+  describe Api::OptionTypesController, type: :request do
 
     let(:attributes) { [:id, :name, :position, :presentation] }
     let!(:option_value) { create(:option_value) }
@@ -19,7 +18,7 @@ module Spree
     end
 
     it "can list all option types" do
-      api_get :index
+      get spree.api_option_types_path
       expect(json_response.count).to eq(1)
       expect(json_response.first).to have_attributes(attributes)
 
@@ -28,7 +27,7 @@ module Spree
 
     it "can search for an option type" do
       create(:option_type, name: "buzz")
-      api_get :index, q: { name_cont: option_type.name }
+      get spree.api_option_types_path, params: { q: { name_cont: option_type.name } }
       expect(json_response.count).to eq(1)
       expect(json_response.first).to have_attributes(attributes)
     end
@@ -36,38 +35,41 @@ module Spree
     it "can retrieve a list of specific option types" do
       option_type_1 = create(:option_type)
       create(:option_type)
-      api_get :index, ids: "#{option_type.id},#{option_type_1.id}"
+      get spree.api_option_types_path, params: { ids: "#{option_type.id},#{option_type_1.id}" }
       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
+      get spree.api_option_type_path(option_type)
       expect(json_response).to have_attributes(attributes)
       check_option_values(json_response["option_values"])
     end
 
     it "cannot create a new option type" do
-      api_post :create, option_type: {
-                        name: "Option Type",
-                        presentation: "Option Type"
-                      }
+      post spree.api_option_types_path, params: {
+        option_type: {
+          name: "Option Type",
+          presentation: "Option Type"
+        }
+      }
       assert_unauthorized!
     end
 
     it "cannot alter an option type" do
       original_name = option_type.name
-      api_put :update, id: option_type.id,
-                        option_type: {
-                          name: "Option Type"
-                        }
+      put spree.api_option_type_path(option_type), params: {
+        option_type: {
+          name: "Option Type"
+        }
+      }
       assert_not_found!
       expect(option_type.reload.name).to eq(original_name)
     end
 
     it "cannot delete an option type" do
-      api_delete :destroy, id: option_type.id
+      delete spree.api_option_type_path(option_type)
       assert_not_found!
       expect { option_type.reload }.not_to raise_error
     end
@@ -76,23 +78,23 @@ module Spree
       sign_in_as_admin!
 
       it "can create an option type" do
-        api_post :create, option_type: {
-                          name: "Option Type",
-                          presentation: "Option Type"
-                        }
+        post spree.api_option_types_path, params: {
+          option_type: {
+            name: "Option Type",
+            presentation: "Option Type"
+          }
+        }
         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: {}
+        post spree.api_option_types_path, params: { option_type: {} }
         expect(response.status).to eq(422)
       end
 
       it "can update an option type" do
-        api_put :update, id: option_type.id, option_type: {
-                              name: "Option Type"
-                            }
+        put spree.api_option_type_path(option_type.id), params: { option_type: { name: "Option Type" } }
         expect(response.status).to eq(200)
 
         option_type.reload
@@ -100,14 +102,12 @@ module Spree
       end
 
       it "cannot update an option type with invalid attributes" do
-        api_put :update, id: option_type.id, option_type: {
-                          name: ""
-                         }
+        put spree.api_option_type_path(option_type.id), params: { option_type: { name: "" } }
         expect(response.status).to eq(422)
       end
 
       it "can delete an option type" do
-        api_delete :destroy, id: option_type.id
+        delete spree.api_option_type_path(option_type.id)
         expect(response.status).to eq(204)
       end
     end

data/spec/{controllers → requests}/spree/api/option_values_controller_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionValuesController, type: :controller do
-    render_views
+  describe Api::OptionValuesController, type: :request do
 
     let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_name] }
     let!(:option_value) { create(:option_value) }
@@ -25,7 +24,7 @@ module Spree
       end
 
       it "can retrieve a list of all option values" do
-        api_get :index
+        get spree.api_option_values_path
         expect(json_response.count).to eq(2)
         expect(json_response.first).to have_attributes(attributes)
       end
@@ -35,14 +34,14 @@ module Spree
       let(:resource_scoping) { { option_type_id: option_type.id } }
 
       it "can list all option values" do
-        api_get :index
+        get spree.api_option_values_path
         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 }
+        get spree.api_option_values_path, params: { q: { name_cont: option_value.name } }
         expect(json_response.count).to eq(1)
         expect(json_response.first).to have_attributes(attributes)
       end
@@ -50,35 +49,39 @@ module Spree
       it "can retrieve a list of option types" do
         option_value_1 = create(:option_value, option_type: option_type)
         create(:option_value, option_type: option_type)
-        api_get :index, ids: [option_value.id, option_value_1.id]
+        get spree.api_option_values_path, params: { ids: [option_value.id, option_value_1.id] }
         expect(json_response.count).to eq(2)
       end
 
       it "can list a single option value" do
-        api_get :show, id: option_value.id
+        get spree.api_option_value_path(option_value.id)
         expect(json_response).to have_attributes(attributes)
       end
 
       it "cannot create a new option value" do
-        api_post :create, option_value: {
-                          name: "Option Value",
-                          presentation: "Option Value"
-                        }
+        post spree.api_option_type_option_values_path(option_type), params: {
+                          option_value: {
+                                            name: "Option Value",
+                                            presentation: "Option Value"
+                                          }
+        }
         assert_unauthorized!
       end
 
       it "cannot alter an option value" do
         original_name = option_type.name
-        api_put :update, id: option_type.id,
-                          option_value: {
-                            name: "Option Value"
+        put spree.api_option_value_path(option_value.id), params: {
+                            id: option_type.id,
+                            option_value: {
+                              name: "Option Value"
+                            }
                           }
         assert_not_found!
         expect(option_type.reload.name).to eq(original_name)
       end
 
       it "cannot delete an option value" do
-        api_delete :destroy, id: option_type.id
+        delete spree.api_option_value_path(option_value)
         assert_not_found!
         expect { option_type.reload }.not_to raise_error
       end
@@ -87,23 +90,25 @@ module Spree
         sign_in_as_admin!
 
         it "can create an option value" do
-          api_post :create, option_value: {
-                            name: "Option Value",
-                            presentation: "Option Value"
-                          }
+          post spree.api_option_type_option_values_path(option_type), params: {
+                            option_value: {
+                                              name: "Option Value",
+                                              presentation: "Option Value",
+                                            }
+          }
           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: {}
+          post spree.api_option_type_option_values_path(option_type), params: { option_value: {name: ""} }
           expect(response.status).to eq(422)
         end
 
         it "can update an option value" do
-          api_put :update, id: option_value.id, option_value: {
+          put spree.api_option_value_path(option_value.id), params: { option_value: {
                                 name: "Option Value"
-                              }
+                              } }
           expect(response.status).to eq(200)
 
           option_value.reload
@@ -111,21 +116,19 @@ module Spree
         end
 
         it "permits the correct attributes" do
-          expect(controller).to receive(:permitted_option_value_attributes)
-          api_put :update, id: option_value.id, option_value: {
-                            name: ""
-                           }
+          expect_any_instance_of(Spree::Api::OptionValuesController).to receive(:permitted_option_value_attributes)
+          put spree.api_option_value_path(option_value), params: { option_value: { name: "" } }
         end
 
         it "cannot update an option value with invalid attributes" do
-          api_put :update, id: option_value.id, option_value: {
+          put spree.api_option_value_path(option_value), params: { option_value: {
                             name: ""
-                           }
+                           } }
           expect(response.status).to eq(422)
         end
 
         it "can delete an option value" do
-          api_delete :destroy, id: option_value.id
+          delete spree.api_option_value_path(option_value)
           expect(response.status).to eq(204)
         end
       end

data/spec/{controllers → requests}/spree/api/orders_controller_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 require 'spree/testing_support/bar_ability'
 
 module Spree
-  describe Api::OrdersController, type: :controller do
-    render_views
+  describe Api::OrdersController, type: :request do
     let!(:order) { create(:order) }
     let(:variant) { create(:variant) }
     let(:line_item) { create(:line_item) }
@@ -32,52 +31,29 @@ module Spree
     describe "POST create" do
       let(:target_user) { create :user }
       let(:date_override) { Time.parse('2015-01-01') }
-      let(:attributes) { { user_id: target_user.id, created_at: date_override, email: target_user.email } }
 
-      subject { api_post :create, order: attributes }
+      subject do
+        post spree.api_orders_path, params: { order: { user_id: target_user.id, created_at: date_override, email: target_user.email } }
+        response
+      end
 
       context "when the current user cannot administrate the order" do
-        stub_authorization! do |_|
+        custom_authorization! do |_|
           can :create, Spree::Order
         end
 
-        it "does not include unpermitted params, or allow overriding the user", focus: true do
+        it "does not include unpermitted params, or allow overriding the user" do
           subject
-          expect(response).to be_success
           order = Spree::Order.last
           expect(order.user).to eq current_api_user
           expect(order.email).to eq target_user.email
         end
 
         it { is_expected.to be_success }
-
-        context 'creating payment' do
-          let(:attributes) { super().merge(payments_attributes: [{ payment_method_id: payment_method.id }]) }
-
-          context "with allowed payment method" do
-            let!(:payment_method) { create(:check_payment_method, name: "allowed" ) }
-            it { is_expected.to be_success }
-            it "creates a payment" do
-              expect {
-                subject
-              }.to change { Spree::Payment.count }.by(1)
-            end
-          end
-
-          context "with disallowed payment method" do
-            let!(:payment_method) { create(:check_payment_method, name: "forbidden", available_to_users: false) }
-            it { is_expected.to be_not_found }
-            it "creates no payments" do
-              expect {
-                subject
-              }.not_to change { Spree::Payment.count }
-            end
-          end
-        end
       end
 
       context "when the current user can administrate the order" do
-        stub_authorization! do |_|
+        custom_authorization! do |_|
           can [:admin, :create], Spree::Order
         end
 
@@ -91,16 +67,30 @@ module Spree
 
         it { is_expected.to be_success }
       end
+
+      context 'when the line items have custom attributes' do
+        it "can create an order with line items that have custom permitted attributes" do
+          PermittedAttributes.line_item_attributes << { options: [:some_option] }
+          expect_any_instance_of(Spree::LineItem).to receive(:some_option=).once.with('4')
+          post spree.api_orders_path, params: { order: { line_items: { "0" => { variant_id: variant.to_param, quantity: 5, options: { some_option: 4 } } } } }
+          expect(response.status).to eq(201)
+          order = Order.last
+          expect(order.line_items.count).to eq(1)
+        end
+      end
     end
 
     describe "PUT update" do
       let(:user) { create :user }
       let(:order_params) { { number: "anothernumber", user_id: user.id, email: "foo@foobar.com" } }
       let(:can_admin) { false }
-      subject { api_put :update, id: order.to_param, order: order_params }
+      subject do
+        put spree.api_order_path(order), params: { order: order_params }
+        response
+      end
 
       context "when the user cannot administer the order" do
-        stub_authorization! do |_|
+        custom_authorization! do |_|
           can [:update], Spree::Order
         end
 
@@ -123,34 +113,10 @@ module Spree
             subject
           }.to_not change{ order.reload.number }
         end
-
-        context 'creating payment' do
-          let(:order_params) { super().merge(payments_attributes: [{ payment_method_id: payment_method.id }]) }
-
-          context "with allowed payment method" do
-            let!(:payment_method) { create(:check_payment_method, name: "allowed" ) }
-            it { is_expected.to be_success }
-            it "creates a payment" do
-              expect {
-                subject
-              }.to change { Spree::Payment.count }.by(1)
-            end
-          end
-
-          context "with disallowed payment method" do
-            let!(:payment_method) { create(:check_payment_method, name: "forbidden", available_to_users: false) }
-            it { is_expected.to be_not_found }
-            it "creates no payments" do
-              expect {
-                subject
-              }.not_to change { Spree::Payment.count }
-            end
-          end
-        end
       end
 
       context "when the user can administer the order" do
-        stub_authorization! do |_|
+        custom_authorization! do |_|
           can [:admin, :update], Spree::Order
         end
 
@@ -168,7 +134,7 @@ module Spree
     end
 
     it "cannot view all orders" do
-      api_get :index
+      get spree.api_orders_path
       assert_unauthorized!
     end
 
@@ -176,7 +142,7 @@ module Spree
       let(:current_api_user) { nil }
 
       it "returns a 401" do
-        api_get :mine
+        get spree.api_my_orders_path
         expect(response.status).to eq(401)
       end
     end
@@ -187,8 +153,7 @@ module Spree
       let(:order) { create(:order, line_items: [line_item], store: store) }
 
       it "can view all of their own orders for the current store" do
-        request.env['SERVER_NAME'] = store.url
-        api_get :mine
+        get spree.api_my_orders_path, headers: { 'SERVER_NAME' => store.url }
 
         expect(response.status).to eq(200)
         expect(json_response["pages"]).to eq(1)
@@ -200,16 +165,14 @@ module Spree
       end
 
       it "cannot view orders for a different store" do
-        request.env['SERVER_NAME'] = "foo"
-        api_get :mine
+        get spree.api_my_orders_path, headers: { 'SERVER_NAME' => 'foo' }
 
         expect(response.status).to eq(200)
         expect(json_response["orders"].length).to eq(0)
       end
 
       it "can filter the returned results" do
-        request.env['SERVER_NAME'] = store.url
-        api_get :mine, q: { completed_at_not_null: 1 }
+        get spree.api_my_orders_path, params: { q: { completed_at_not_null: 1 } }, headers: { 'SERVER_NAME' => store.url }
 
         expect(response.status).to eq(200)
         expect(json_response["orders"].length).to eq(0)
@@ -225,8 +188,7 @@ module Spree
         order4 = Order.create user: order.user, completed_at: nil, created_at: 0.days.ago, store: store
         expect(order4.created_at).to be > order3.created_at
 
-        request.env['SERVER_NAME'] = store.url
-        api_get :mine
+        get spree.api_my_orders_path, headers: { 'SERVER_NAME' => store.url }
         expect(response.status).to eq(200)
         expect(json_response["pages"]).to eq(1)
         orders = json_response["orders"]
@@ -242,14 +204,14 @@ module Spree
       let!(:order) { create(:order, line_items: [line_item]) }
 
       it "uses the user's last_incomplete_spree_order logic with the current store" do
-        expect(current_api_user).to receive(:last_incomplete_spree_order).with(store: controller.current_store)
-        api_get :current, format: 'json'
+        expect(current_api_user).to receive(:last_incomplete_spree_order).with(store: Spree::Store.default)
+        get spree.api_current_order_path(format: 'json')
       end
     end
 
     it "can view their own order" do
       allow_any_instance_of(Order).to receive_messages user: current_api_user
-      api_get :show, id: order.to_param
+      get spree.api_order_path(order)
       expect(response.status).to eq(200)
       expect(json_response).to have_attributes(attributes)
       expect(json_response["adjustments"]).to be_empty
@@ -259,7 +221,7 @@ module Spree
       let(:order) { create :order_with_line_items }
       let(:adjustment) { FactoryGirl.create(:adjustment, adjustable: order, order: order) }
 
-      subject { api_get :show, id: order.to_param }
+      subject { get spree.api_order_path(order) }
 
       before do
         allow_any_instance_of(Order).to receive_messages user: current_api_user
@@ -310,7 +272,7 @@ module Spree
 
     it "orders contain the basic checkout steps" do
       allow_any_instance_of(Order).to receive_messages user: current_api_user
-      api_get :show, id: order.to_param
+      get spree.api_order_path(order)
       expect(response.status).to eq(200)
       expect(json_response["checkout_steps"]).to eq(%w[address delivery confirm complete])
     end
@@ -319,23 +281,22 @@ module Spree
     it "can view an order not in a standard state" do
       allow_any_instance_of(Order).to receive_messages user: current_api_user
       order.update_column(:state, 'shipped')
-      api_get :show, id: order.to_param
+      get spree.api_order_path(order)
     end
 
     it "can not view someone else's order" do
       allow_any_instance_of(Order).to receive_messages user: stub_model(Spree::LegacyUser)
-      api_get :show, id: order.to_param
+      get spree.api_order_path(order)
       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
+      get spree.api_order_path(order), params: { order_token: order.guest_token }
       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
+      get spree.api_order_path(order), headers: { "X-Spree-Order-Token" => order.guest_token }
       expect(response.status).to eq(200)
     end
 
@@ -346,7 +307,7 @@ module Spree
       it "can view an order" do
         user = build(:user, spree_roles: [Spree::Role.new(name: 'bar')])
         allow(Spree.user_class).to receive_messages find_by: user
-        api_get :show, id: order.to_param
+        get spree.api_order_path(order)
         expect(response.status).to eq(200)
       end
     end
@@ -354,12 +315,12 @@ module Spree
     it "cannot cancel an order that doesn't belong to them" do
       order.update_attribute(:completed_at, Time.current)
       order.update_attribute(:shipment_state, "ready")
-      api_put :cancel, id: order.to_param
+      put spree.cancel_api_order_path(order)
       assert_unauthorized!
     end
 
     it "can create an order" do
-      api_post :create, order: { line_items: { "0" => { variant_id: variant.to_param, quantity: 5 } } }
+      post spree.api_orders_path, params: { order: { line_items: { "0" => { variant_id: variant.to_param, quantity: 5 } } } }
       expect(response.status).to eq(201)
 
       order = Order.last
@@ -376,20 +337,25 @@ module Spree
     end
 
     it "assigns email when creating a new order" do
-      api_post :create, order: { email: "guest@spreecommerce.com" }
+      post spree.api_orders_path, params: { order: { email: "guest@spreecommerce.com" } }
       expect(json_response['email']).not_to eq controller.current_api_user
       expect(json_response['email']).to eq "guest@spreecommerce.com"
     end
 
     # Regression test for https://github.com/spree/spree/issues/3404
     it "can specify additional parameters for a line item" do
-      expect_any_instance_of(Spree::LineItem).to receive(:special=).with("foo")
-
-      allow(controller).to receive_messages(permitted_line_item_attributes: [:id, :variant_id, :quantity, :special])
-      api_post :create, order: {
-        line_items: {
-          "0" => {
-            variant_id: variant.to_param, quantity: 5, special: "foo"
+      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(hash_including("special" => "foo"))
+
+      allow_any_instance_of(Spree::Api::OrdersController).to receive_messages(permitted_line_item_attributes: [:id, :variant_id, :quantity, :special])
+      post spree.api_orders_path, params: {
+        order: {
+          line_items: {
+            "0" => {
+              variant_id: variant.to_param, quantity: 5, special: "foo"
+            }
           }
         }
       }
@@ -397,10 +363,12 @@ module Spree
     end
 
     it "cannot arbitrarily set the line items price" do
-      api_post :create, order: {
-        line_items: {
-          "0" => {
-            price: 33.0, variant_id: variant.to_param, quantity: 5
+      post spree.api_orders_path, params: {
+        order: {
+          line_items: {
+            "0" => {
+              price: 33.0, variant_id: variant.to_param, quantity: 5
+            }
           }
         }
       }
@@ -413,14 +381,14 @@ module Spree
       let!(:current_api_user) { create :admin_user }
 
       it "is able to set any default unpermitted attribute" do
-        api_post :create, order: { number: "WOW" }
+        post spree.api_orders_path, params: { order: { number: "WOW" } }
         expect(response.status).to eq 201
         expect(json_response['number']).to eq "WOW"
       end
     end
 
     it "can create an order without any parameters" do
-      api_post :create
+      post spree.api_orders_path
       expect(response.status).to eq(201)
       expect(json_response["state"]).to eq("cart")
     end
@@ -446,11 +414,11 @@ module Spree
       before { allow_any_instance_of(Order).to receive_messages user: current_api_user }
 
       it "updates quantities of existing line items" do
-        api_put :update, id: order.to_param, order: {
+        put spree.api_order_path(order), params: { order: {
           line_items: {
             "0" => { id: line_item.id, quantity: 10 }
           }
-        }
+        } }
 
         expect(response.status).to eq(200)
         expect(json_response['line_items'].count).to eq(1)
@@ -459,12 +427,12 @@ module Spree
 
       it "adds an extra line item" do
         variant2 = create(:variant)
-        api_put :update, id: order.to_param, order: {
+        put spree.api_order_path(order), params: { order: {
           line_items: {
             "0" => { id: line_item.id, quantity: 10 },
             "1" => { variant_id: variant2.id, quantity: 1 }
           }
-        }
+        } }
 
         expect(response.status).to eq(200)
         expect(json_response['line_items'].count).to eq(2)
@@ -474,11 +442,11 @@ module Spree
       end
 
       it "cannot change the price of an existing line item" do
-        api_put :update, id: order.to_param, order: {
+        put spree.api_order_path(order), params: { order: {
           line_items: {
             0 => { id: line_item.id, price: 0 }
           }
-        }
+        } }
 
         expect(response.status).to eq(200)
         expect(json_response['line_items'].count).to eq(1)
@@ -487,7 +455,7 @@ module Spree
       end
 
       it "can add billing address" do
-        api_put :update, id: order.to_param, order: { bill_address_attributes: billing_address }
+        put spree.api_order_path(order), params: { order: { bill_address_attributes: billing_address } }
 
         expect(order.reload.bill_address).to_not be_nil
       end
@@ -495,7 +463,7 @@ module Spree
       it "receives error message if trying to add billing address with errors" do
         billing_address[:firstname] = ""
 
-        api_put :update, id: order.to_param, order: { bill_address_attributes: billing_address }
+        put spree.api_order_path(order), params: { order: { bill_address_attributes: billing_address } }
 
         expect(json_response['error']).not_to be_nil
         expect(json_response['errors']).not_to be_nil
@@ -506,7 +474,7 @@ module Spree
         order.update_attributes!(ship_address_id: nil)
 
         expect {
-          api_put :update, id: order.to_param, order: { ship_address_attributes: shipping_address }
+          put spree.api_order_path(order), params: { order: { ship_address_attributes: shipping_address } }
         }.to change { order.reload.ship_address }.from(nil)
       end
 
@@ -515,7 +483,7 @@ module Spree
 
         shipping_address[:firstname] = ""
 
-        api_put :update, id: order.to_param, order: { ship_address_attributes: shipping_address }
+        put spree.api_order_path(order), params: { order: { ship_address_attributes: shipping_address } }
 
         expect(json_response['error']).not_to be_nil
         expect(json_response['errors']).not_to be_nil
@@ -525,7 +493,7 @@ module Spree
       it "cannot set the user_id for the order" do
         user = Spree.user_class.create
         original_id = order.user_id
-        api_post :update, id: order.to_param, order: { user_id: user.id }
+        put spree.api_order_path(order), params: { order: { user_id: user.id } }
         expect(response.status).to eq 200
         expect(json_response["user_id"]).to eq(original_id)
       end
@@ -534,11 +502,11 @@ module Spree
         before { order.create_proposed_shipments }
 
         it "clears out all existing shipments on line item udpate" do
-          api_put :update, id: order.to_param, order: {
+          put spree.api_order_path(order), params: { order: {
             line_items: {
               0 => { id: line_item.id, quantity: 10 }
             }
-          }
+          } }
           expect(order.reload.shipments).to be_empty
         end
       end
@@ -548,7 +516,7 @@ module Spree
 
         it "can empty an order" do
           create(:adjustment, order: order, adjustable: order)
-          api_put :empty, id: order.to_param
+          put spree.empty_api_order_path(order)
           expect(response.status).to eq(204)
           order.reload
           expect(order.line_items).to be_empty
@@ -558,19 +526,19 @@ module Spree
         it "can list its line items with images" do
           order.line_items.first.variant.images.create!(attachment: image("thinking-cat.jpg"))
 
-          api_get :show, id: order.to_param
+          get spree.api_order_path(order)
 
           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
+          get spree.api_order_path(order)
 
           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
+          get spree.api_order_path(order)
 
           expect(json_response['included_tax_total']).to eq('0.0')
           expect(json_response['additional_tax_total']).to eq('0.0')
@@ -584,7 +552,7 @@ module Spree
             order: order,
             adjustable: order.line_items.first)
           adjustment.update_column(:amount, 5)
-          api_get :show, id: order.to_param
+          get spree.api_order_path(order)
 
           adjustment = json_response['line_items'].first['adjustments'].first
           expect(adjustment['label']).to eq("10% off!")
@@ -593,7 +561,7 @@ module Spree
 
         it "lists payments source without gateway info" do
           order.payments.push payment = create(:payment)
-          api_get :show, id: order.to_param
+          get spree.api_order_path(order)
 
           source = json_response[:payments].first[:source]
           expect(source[:name]).to eq payment.source.name
@@ -620,14 +588,14 @@ module Spree
           end
 
           it "includes the ship_total in the response" do
-            api_get :show, id: order.to_param
+            get spree.api_order_path(order)
 
             expect(json_response['ship_total']).to eq '10.0'
             expect(json_response['display_ship_total']).to eq '$10.00'
           end
 
           it "returns available shipments for an order" do
-            api_get :show, id: order.to_param
+            get spree.api_order_path(order)
             expect(response.status).to eq(200)
             expect(json_response["shipments"]).not_to be_empty
             shipment = json_response["shipments"][0]
@@ -666,7 +634,7 @@ module Spree
       context "with no orders" do
         before { Spree::Order.delete_all }
         it "still returns a root :orders key" do
-          api_get :index
+          get spree.api_orders_path
           expect(json_response["orders"]).to eq([])
         end
       end
@@ -678,7 +646,7 @@ module Spree
         end
 
         it "returns unique orders" do
-          api_get :index
+          get spree.api_orders_path
 
           orders = json_response[:orders]
           expect(orders.count).to be >= 3
@@ -690,7 +658,7 @@ module Spree
 
       it "lists payments source with gateway info" do
         order.payments.push payment = create(:payment)
-        api_get :show, id: order.to_param
+        get spree.api_order_path(order)
 
         source = json_response[:payments].first[:source]
         expect(source[:name]).to eq payment.source.name
@@ -706,7 +674,7 @@ module Spree
         before { create(:order) }
 
         it "can view all orders" do
-          api_get :index
+          get spree.api_orders_path
           expect(json_response["orders"].first).to have_attributes(attributes)
           expect(json_response["count"]).to eq(2)
           expect(json_response["current_page"]).to eq(1)
@@ -715,7 +683,7 @@ module Spree
 
         # Test for https://github.com/spree/spree/issues/1763
         it "can control the page size through a parameter" do
-          api_get :index, per_page: 1
+          get spree.api_orders_path, params: { per_page: 1 }
           expect(json_response["orders"].count).to eq(1)
           expect(json_response["orders"].first).to have_attributes(attributes)
           expect(json_response["count"]).to eq(1)
@@ -733,7 +701,7 @@ module Spree
         let(:expected_result) { Spree::Order.last }
 
         it "can query the results through a parameter" do
-          api_get :index, q: { email_cont: 'spree' }
+          get spree.api_orders_path, params: { q: { email_cont: 'spree' } }
           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)
@@ -745,16 +713,18 @@ module Spree
 
       context "creation" do
         it "can create an order without any parameters" do
-          api_post :create
+          post spree.api_orders_path
           expect(response.status).to eq(201)
           expect(json_response["state"]).to eq("cart")
         end
 
         it "can arbitrarily set the line items price" do
-          api_post :create, order: {
-            line_items: {
-              "0" => {
-                price: 33.0, variant_id: variant.to_param, quantity: 5
+          post spree.api_orders_path, params: {
+            order: {
+              line_items: {
+                "0" => {
+                  price: 33.0, variant_id: variant.to_param, quantity: 5
+                }
               }
             }
           }
@@ -764,7 +734,7 @@ module Spree
 
         it "can set the user_id for the order" do
           user = Spree.user_class.create
-          api_post :create, order: { user_id: user.id }
+          post spree.api_orders_path, params: { order: { user_id: user.id } }
           expect(response.status).to eq 201
           expect(json_response["user_id"]).to eq(user.id)
         end
@@ -773,7 +743,7 @@ module Spree
       context "updating" do
         it "can set the user_id for the order" do
           user = Spree.user_class.create
-          api_post :update, id: order.number, order: { user_id: user.id }
+          put spree.api_order_path(order), params: { order: { user_id: user.id } }
           expect(response.status).to eq 200
           expect(json_response["user_id"]).to eq(user.id)
         end
@@ -790,7 +760,7 @@ module Spree
         end
 
         specify do
-          api_put :cancel, id: order.to_param
+          put spree.cancel_api_order_path(order)
           expect(json_response["state"]).to eq("canceled")
           expect(json_response["canceler_id"]).to eq(current_api_user.id)
         end
@@ -809,7 +779,7 @@ module Spree
         let(:order) { create(:order_with_line_items) }
 
         it 'applies the coupon' do
-          api_put :apply_coupon_code, id: order.to_param, coupon_code: promo_code.value
+          put spree.apply_coupon_code_api_order_path(order), params: { coupon_code: promo_code.value }
 
           expect(response.status).to eq 200
           expect(order.reload.promotions).to eq [promo]
@@ -826,7 +796,7 @@ module Spree
         let(:order) { create(:order) } # no line items to apply the code to
 
         it 'returns an error' do
-          api_put :apply_coupon_code, id: order.to_param, coupon_code: promo_code.value
+          put spree.apply_coupon_code_api_order_path(order), params: { coupon_code: promo_code.value }
 
           expect(response.status).to eq 422
           expect(order.reload.promotions).to eq []