solidus_api 2.2.2 → 2.3.0.beta1

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

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::PaymentsController, type: :controller do
-    render_views
+  describe Spree::Api::PaymentsController, type: :request do
     let!(:order) { create(:order) }
     let!(:payment) { create(:payment, order: order) }
     let!(:attributes) {
@@ -11,8 +10,6 @@ module Spree
        :created_at, :updated_at]
     }
 
-    let(:resource_scoping) { { order_id: order.to_param } }
-
     before do
       stub_authentication!
     end
@@ -24,12 +21,12 @@ module Spree
         end
 
         it "can view the payments for their order" do
-          api_get :index
+          get spree.api_order_payments_path(order)
           expect(json_response["payments"].first).to have_attributes(attributes)
         end
 
         it "can learn how to create a new payment" do
-          api_get :new
+          get spree.new_api_order_payment_path(order)
           expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
           expect(json_response["payment_methods"]).not_to be_empty
           expect(json_response["payment_methods"].first).to have_attributes([:id, :name, :description])
@@ -37,31 +34,20 @@ module Spree
 
         context "payment source is not required" do
           before do
-            allow_any_instance_of(Spree::Gateway::Bogus).to receive(:source_required?).and_return(false)
+            allow_any_instance_of(Spree::PaymentMethod::BogusCreditCard).to receive(:source_required?).and_return(false)
           end
 
           it "can create a new payment" do
-            api_post :create, payment: { payment_method_id: PaymentMethod.first.id, amount: 50 }
+            post spree.api_order_payments_path(order), params: { payment: { payment_method_id: PaymentMethod.first.id, amount: 50 } }
             expect(response.status).to eq(201)
             expect(json_response).to have_attributes(attributes)
           end
-
-          context "disallowed payment method" do
-            it "does not create a new payment" do
-              PaymentMethod.first.update!(available_to_users: false)
-
-              expect {
-                api_post :create, payment: { payment_method_id: PaymentMethod.first.id, amount: 50 }
-              }.not_to change { Spree::Payment.count }
-              expect(response.status).to eq(404)
-            end
-          end
         end
 
         context "payment source is required" do
           context "no source is provided" do
             it "returns errors" do
-              api_post :create, payment: { payment_method_id: PaymentMethod.first.id, amount: 50 }
+              post spree.api_order_payments_path(order), params: { payment: { payment_method_id: PaymentMethod.first.id, amount: 50 } }
               expect(response.status).to eq(422)
               expect(json_response['error']).to eq("Invalid resource. Please fix errors and try again.")
               expect(json_response['errors']['source']).to eq(["can't be blank"])
@@ -70,7 +56,7 @@ module Spree
 
           context "source is provided" do
             it "can create a new payment" do
-              api_post :create, payment: { payment_method_id: PaymentMethod.first.id, amount: 50, source_attributes: { gateway_payment_profile_id: 1 } }
+              post spree.api_order_payments_path(order), params: { payment: { payment_method_id: PaymentMethod.first.id, amount: 50, source_attributes: { gateway_payment_profile_id: 1 } } }
               expect(response.status).to eq(201)
               expect(json_response).to have_attributes(attributes)
             end
@@ -78,17 +64,17 @@ module Spree
         end
 
         it "can view a pre-existing payment's details" do
-          api_get :show, id: payment.to_param
+          get spree.api_order_payment_path(order, payment)
           expect(json_response).to have_attributes(attributes)
         end
 
         it "cannot update a payment" do
-          api_put :update, id: payment.to_param, payment: { amount: 2.01 }
+          put spree.api_order_payment_path(order, payment), params: { payment: { amount: 2.01 } }
           assert_unauthorized!
         end
 
         it "cannot authorize a payment" do
-          api_put :authorize, id: payment.to_param
+          put spree.authorize_api_order_payment_path(order, payment)
           assert_unauthorized!
         end
       end
@@ -99,12 +85,12 @@ module Spree
         end
 
         it "cannot view payments for somebody else's order" do
-          api_get :index, order_id: order.to_param
+          get spree.api_order_payments_path(order)
           assert_unauthorized!
         end
 
         it "can view the payments for an order given the order token" do
-          api_get :index, order_id: order.to_param, order_token: order.guest_token
+          get spree.api_order_payments_path(order), params: { order_token: order.guest_token }
           expect(json_response["payments"].first).to have_attributes(attributes)
         end
       end
@@ -114,7 +100,7 @@ module Spree
       sign_in_as_admin!
 
       it "can view the payments on any order" do
-        api_get :index
+        get spree.api_order_payments_path(order)
         expect(response.status).to eq(200)
         expect(json_response["payments"].first).to have_attributes(attributes)
       end
@@ -123,12 +109,12 @@ module Spree
         before { @payment = create(:payment, order: order) }
 
         it "can view all payments on an order" do
-          api_get :index
+          get spree.api_order_payments_path(order)
           expect(json_response["count"]).to eq(2)
         end
 
         it 'can control the page size through a parameter' do
-          api_get :index, per_page: 1
+          get spree.api_order_payments_path(order), params: { per_page: 1 }
           expect(json_response['count']).to eq(1)
           expect(json_response['current_page']).to eq(1)
           expect(json_response['pages']).to eq(2)
@@ -139,7 +125,7 @@ module Spree
         context "updating" do
           it "can update" do
             payment.update_attributes(state: 'pending')
-            api_put :update, id: payment.to_param, payment: { amount: 2.01 }
+            put spree.api_order_payment_path(order, payment), params: { payment: { amount: 2.01 } }
             expect(response.status).to eq(200)
             expect(payment.reload.amount).to eq(2.01)
           end
@@ -147,14 +133,14 @@ module Spree
           context "update fails" do
             it "returns a 422 status when the amount is invalid" do
               payment.update_attributes(state: 'pending')
-              api_put :update, id: payment.to_param, payment: { amount: 'invalid' }
+              put spree.api_order_payment_path(order, payment), params: { payment: { amount: 'invalid' } }
               expect(response.status).to eq(422)
               expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
             end
 
             it "returns a 403 status when the payment is not pending" do
               payment.update_attributes(state: 'completed')
-              api_put :update, id: payment.to_param, payment: { amount: 2.01 }
+              put spree.api_order_payment_path(order, payment), params: { payment: { amount: 2.01 } }
               expect(response.status).to eq(403)
               expect(json_response["error"]).to eq("This payment cannot be updated because it is completed.")
             end
@@ -163,7 +149,7 @@ module Spree
 
         context "authorizing" do
           it "can authorize" do
-            api_put :authorize, id: payment.to_param
+            put spree.authorize_api_order_payment_path(order, payment)
             expect(response.status).to eq(200)
             expect(payment.reload.state).to eq("pending")
           end
@@ -171,8 +157,8 @@ module Spree
           context "authorization fails" do
             before do
               fake_response = double(success?: false, to_s: "Could not authorize card")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:authorize).and_return(fake_response)
-              api_put :authorize, id: payment.to_param
+              expect_any_instance_of(Spree::PaymentMethod::BogusCreditCard).to receive(:authorize).and_return(fake_response)
+              put spree.authorize_api_order_payment_path(order, payment)
             end
 
             it "returns a 422 status" do
@@ -190,7 +176,7 @@ module Spree
 
         context "capturing" do
           it "can capture" do
-            api_put :capture, id: payment.to_param
+            put spree.capture_api_order_payment_path(order, payment)
             expect(response.status).to eq(200)
             expect(payment.reload.state).to eq("completed")
           end
@@ -198,11 +184,11 @@ module Spree
           context "capturing fails" do
             before do
               fake_response = double(success?: false, to_s: "Insufficient funds")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:capture).and_return(fake_response)
+              expect_any_instance_of(Spree::PaymentMethod::BogusCreditCard).to receive(:capture).and_return(fake_response)
             end
 
             it "returns a 422 status" do
-              api_put :capture, id: payment.to_param
+              put spree.capture_api_order_payment_path(order, payment)
               expect(response.status).to eq(422)
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Insufficient funds"
@@ -212,7 +198,7 @@ module Spree
 
         context "purchasing" do
           it "can purchase" do
-            api_put :purchase, id: payment.to_param
+            put spree.purchase_api_order_payment_path(order, payment)
             expect(response.status).to eq(200)
             expect(payment.reload.state).to eq("completed")
           end
@@ -220,11 +206,11 @@ module Spree
           context "purchasing fails" do
             before do
               fake_response = double(success?: false, to_s: "Insufficient funds")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:purchase).and_return(fake_response)
+              expect_any_instance_of(Spree::PaymentMethod::BogusCreditCard).to receive(:purchase).and_return(fake_response)
             end
 
             it "returns a 422 status" do
-              api_put :purchase, id: payment.to_param
+              put spree.purchase_api_order_payment_path(order, payment)
               expect(response.status).to eq(422)
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Insufficient funds"
@@ -234,7 +220,7 @@ module Spree
 
         context "voiding" do
           it "can void" do
-            api_put :void, id: payment.to_param
+            put spree.void_api_order_payment_path(order, payment)
             expect(response.status).to eq 200
             expect(payment.reload.state).to eq "void"
           end
@@ -242,11 +228,11 @@ module Spree
           context "voiding fails" do
             before do
               fake_response = double(success?: false, to_s: "NO REFUNDS")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:void).and_return(fake_response)
+              expect_any_instance_of(Spree::PaymentMethod::BogusCreditCard).to receive(:void).and_return(fake_response)
             end
 
             it "returns a 422 status" do
-              api_put :void, id: payment.to_param
+              put spree.void_api_order_payment_path(order, payment)
               expect(response.status).to eq 422
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "NO REFUNDS"

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

@@ -2,8 +2,7 @@ require 'spec_helper'
 require 'shared_examples/protect_product_actions'
 
 module Spree
-  describe Spree::Api::ProductPropertiesController, type: :controller do
-    render_views
+  describe Spree::Api::ProductPropertiesController, type: :request do
 
     let!(:product) { create(:product) }
     let!(:property_1) { product.product_properties.create(property_name: "My Property 1", value: "my value 1", position: 0) }
@@ -22,19 +21,19 @@ module Spree
       end
 
       it "can not see a list of product properties" do
-        api_get :index
+        get spree.api_product_product_properties_path(product)
         expect(response.status).to eq(404)
       end
     end
 
     it "can see a list of all product properties" do
-      api_get :index
+      get spree.api_product_product_properties_path(product)
       expect(json_response["product_properties"].count).to eq 2
       expect(json_response["product_properties"].first).to have_attributes(attributes)
     end
 
     it "can control the page size through a parameter" do
-      api_get :index, per_page: 1
+      get spree.api_product_product_properties_path(product), params: { per_page: 1 }
       expect(json_response['product_properties'].count).to eq(1)
       expect(json_response['current_page']).to eq(1)
       expect(json_response['pages']).to eq(2)
@@ -43,34 +42,34 @@ module Spree
     it 'can query the results through a parameter' do
       Spree::ProductProperty.last.update_attribute(:value, 'loose')
       property = Spree::ProductProperty.last
-      api_get :index, q: { value_cont: 'loose' }
+      get spree.api_product_product_properties_path(product), params: { q: { value_cont: 'loose' } }
       expect(json_response['count']).to eq(1)
       expect(json_response['product_properties'].first['value']).to eq property.value
     end
 
     it "can see a single product_property" do
-      api_get :show, id: property_1.property_name
+      get spree.api_product_product_property_path(product, property_1.property_name)
       expect(json_response).to have_attributes(attributes)
     end
 
     it "can learn how to create a new product property" do
-      api_get :new
+      get spree.new_api_product_product_property_path(product)
       expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
       expect(json_response["required_attributes"]).to be_empty
     end
 
     it "cannot create a new product property if not an admin" do
-      api_post :create, product_property: { property_name: "My Property 3" }
+      post spree.api_product_product_properties_path(product), params: { product_property: { property_name: "My Property 3" } }
       assert_unauthorized!
     end
 
     it "cannot update a product property" do
-      api_put :update, id: property_1.property_name, product_property: { value: "my value 456" }
+      put spree.api_product_product_property_path(product, property_1.property_name), params: { product_property: { value: "my value 456" } }
       assert_unauthorized!
     end
 
     it "cannot delete a product property" do
-      api_delete :destroy, id: property_1.property_name
+      delete spree.api_product_product_property_path(product, property_1.property_name)
       assert_unauthorized!
       expect { property_1.reload }.not_to raise_error
     end
@@ -80,34 +79,33 @@ module Spree
 
       it "can create a new product property" do
         expect do
-          api_post :create, product_property: { property_name: "My Property 3", value: "my value 3" }
+          post spree.api_product_product_properties_path(product), params: { product_property: { property_name: "My Property 3", value: "my value 3" } }
         end.to change(product.product_properties, :count).by(1)
         expect(json_response).to have_attributes(attributes)
         expect(response.status).to eq(201)
       end
 
       it "can update a product property" do
-        api_put :update, id: property_1.property_name, product_property: { value: "my value 456" }
+        put spree.api_product_product_property_path(product, property_1.property_name), params: { product_property: { value: "my value 456" } }
         expect(response.status).to eq(200)
       end
 
       it "can delete a product property" do
-        api_delete :destroy, id: property_1.property_name
+        delete spree.api_product_product_property_path(product, property_1.property_name)
         expect(response.status).to eq(204)
         expect { property_1.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
 
     context "with product identified by id" do
-      let(:resource_scoping) { { product_id: product.id } }
       it "can see a list of all product properties" do
-        api_get :index
+        get spree.api_product_product_properties_path(product)
         expect(json_response["product_properties"].count).to eq 2
         expect(json_response["product_properties"].first).to have_attributes(attributes)
       end
 
       it "can see a single product_property by id" do
-        api_get :show, id: property_1.id
+        get spree.api_product_product_property_path(product, property_1.id)
         expect(json_response).to have_attributes(attributes)
       end
     end

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

@@ -2,8 +2,7 @@ require 'spec_helper'
 require 'shared_examples/protect_product_actions'
 
 module Spree
-  describe Spree::Api::ProductsController, type: :controller do
-    render_views
+  describe Spree::Api::ProductsController, type: :request do
 
     let!(:product) { create(:product) }
     let!(:inactive_product) { create(:product, available_on: Time.current.tomorrow, name: "inactive") }
@@ -39,7 +38,7 @@ module Spree
         end
 
         it "returns unique products" do
-          api_get :index
+          get spree.api_products_path
           product_ids = json_response["products"].map { |p| p["id"] }
           expect(product_ids.uniq.count).to eq(product_ids.count)
         end
@@ -50,7 +49,7 @@ module Spree
       end
 
       it "retrieves a list of products" do
-        api_get :index
+        get spree.api_products_path
         expect(json_response["products"].first).to have_attributes(show_attributes)
         expect(json_response["total_count"]).to eq(1)
         expect(json_response["current_page"]).to eq(1)
@@ -59,7 +58,7 @@ module Spree
       end
 
       it "retrieves a list of products by id" do
-        api_get :index, ids: [product.id]
+        get spree.api_products_path, params: { ids: [product.id] }
         expect(json_response["products"].first).to have_attributes(show_attributes)
         expect(json_response["total_count"]).to eq(1)
         expect(json_response["current_page"]).to eq(1)
@@ -71,14 +70,14 @@ module Spree
         before { product.master.prices.create currency: "EUR", amount: 22 }
 
         it "returns distinct products only" do
-          api_get :index
+          get spree.api_products_path
           expect(assigns(:products).map(&:id).uniq).to eq assigns(:products).map(&:id)
         end
       end
 
       it "retrieves a list of products by ids string" do
         second_product = create(:product)
-        api_get :index, ids: [product.id, second_product.id].join(",")
+        get spree.api_products_path, params: { ids: [product.id, second_product.id].join(",") }
         expect(json_response["products"].first).to have_attributes(show_attributes)
         expect(json_response["products"][1]).to have_attributes(show_attributes)
         expect(json_response["total_count"]).to eq(2)
@@ -88,19 +87,19 @@ module Spree
       end
 
       it "does not return inactive products when queried by ids" do
-        api_get :index, ids: [inactive_product.id]
+        get spree.api_products_path, params: { ids: [inactive_product.id] }
         expect(json_response["count"]).to eq(0)
       end
 
       it "does not list unavailable products" do
-        api_get :index
+        get spree.api_products_path
         expect(json_response["products"].first["name"]).not_to eq("inactive")
       end
 
       context "pagination" do
         it "can select the next page of products" do
           create(:product)
-          api_get :index, page: 2, per_page: 1
+          get spree.api_products_path, params: { page: 2, per_page: 1 }
           expect(json_response["products"].first).to have_attributes(show_attributes)
           expect(json_response["total_count"]).to eq(2)
           expect(json_response["current_page"]).to eq(2)
@@ -109,7 +108,7 @@ module Spree
 
         it 'can control the page size through a parameter' do
           create(:product)
-          api_get :index, per_page: 1
+          get spree.api_products_path, params: { per_page: 1 }
           expect(json_response['count']).to eq(1)
           expect(json_response['total_count']).to eq(2)
           expect(json_response['current_page']).to eq(1)
@@ -119,7 +118,7 @@ module Spree
 
       it "can search for products" do
         create(:product, name: "The best product in the world")
-        api_get :index, q: { name_cont: "best" }
+        get spree.api_products_path, params: { q: { name_cont: "best" } }
         expect(json_response["products"].first).to have_attributes(show_attributes)
         expect(json_response["count"]).to eq(1)
       end
@@ -131,7 +130,7 @@ module Spree
         product.set_property("spree", "rocks")
         product.taxons << create(:taxon)
 
-        api_get :show, id: product.to_param
+        get spree.api_product_path(product)
 
         expect(json_response).to have_attributes(show_attributes)
         expect(json_response['variants'].first).to have_attributes([:name,
@@ -161,7 +160,7 @@ module Spree
         before { Config.track_inventory_levels = false }
 
         it "still displays valid json with total_on_hand Float::INFINITY" do
-          api_get :show, id: product.to_param
+          get spree.api_product_path(product)
           expect(response).to be_ok
           expect(json_response[:total_on_hand]).to eq nil
         end
@@ -177,27 +176,27 @@ module Spree
         end
 
         specify do
-          api_get :show, id: product.to_param
+          get spree.api_product_path(product)
           expect(json_response["slug"]).to match(/and-1-ways/)
           product.destroy
 
-          api_get :show, id: other_product.id
+          get spree.api_product_path(other_product)
           expect(json_response["slug"]).to match(/droids/)
         end
       end
 
       it "cannot see inactive products" do
-        api_get :show, id: inactive_product.to_param
+        get spree.api_product_path(inactive_product)
         assert_not_found!
       end
 
       it "returns a 404 error when it cannot find a product" do
-        api_get :show, id: "non-existant"
+        get spree.api_product_path("non-existant")
         assert_not_found!
       end
 
       it "can learn how to create a new product" do
-        api_get :new
+        get spree.new_api_product_path
         expect(json_response["attributes"]).to eq(new_attributes.map(&:to_s))
         required_attributes = json_response["required_attributes"]
         expect(required_attributes).to include("name")
@@ -215,7 +214,7 @@ module Spree
       sign_in_as_admin!
 
       it "can see all products" do
-        api_get :index
+        get spree.api_products_path
         expect(json_response["products"].count).to eq(2)
         expect(json_response["count"]).to eq(2)
         expect(json_response["current_page"]).to eq(1)
@@ -229,21 +228,23 @@ module Spree
         end
 
         it "does not include deleted products" do
-          api_get :index
+          get spree.api_products_path
           expect(json_response["products"].count).to eq(2)
         end
 
         it "can include deleted products" do
-          api_get :index, show_deleted: 1
+          get spree.api_products_path, params: { show_deleted: 1 }
           expect(json_response["products"].count).to eq(3)
         end
       end
 
       describe "creating a product" do
         it "can create a new product" do
-          api_post :create, product: { name: "The Other Product",
-                                          price: 19.99,
-                                          shipping_category_id: create(:shipping_category).id }
+          post spree.api_products_path, params: {
+                                          product: { name: "The Other Product",
+                                                                          price: 19.99,
+                                                                          shipping_category_id: create(:shipping_category).id }
+          }
           expect(json_response).to have_attributes(base_attributes)
           expect(response.status).to eq(201)
         end
@@ -251,7 +252,7 @@ module Spree
         it "creates with embedded variants" do
           product_data[:variants] = [attributes_for_variant, attributes_for_variant]
 
-          api_post :create, product: product_data
+          post spree.api_products_path, params: { product: product_data }
           expect(response.status).to eq 201
 
           variants = json_response['variants']
@@ -268,7 +269,7 @@ module Spree
               value: "cotton"
             }]
 
-          api_post :create, product: product_data
+          post spree.api_products_path, params: { product: product_data }
 
           expect(json_response['product_properties'][0]['property_name']).to eq('fabric')
           expect(json_response['product_properties'][0]['value']).to eq('cotton')
@@ -277,7 +278,7 @@ module Spree
         it "can create a new product with option_types" do
           product_data[:option_types] = ['size', 'color']
 
-          api_post :create, product: product_data
+          post spree.api_products_path, params: { product: product_data }
           expect(json_response['option_types'].count).to eq(2)
         end
 
@@ -286,23 +287,23 @@ module Spree
                    price: 19.99,
                    shipping_category: "Free Ships" }
 
-          api_post :create, product: hash
+          post spree.api_products_path, params: { product: hash }
           expect(response.status).to eq 201
 
-          shipping_id = ShippingCategory.find_by_name("Free Ships").id
+          shipping_id = ShippingCategory.find_by(name: "Free Ships").id
           expect(json_response['shipping_category_id']).to eq shipping_id
         end
 
         it "puts the created product in the given taxon" do
           product_data[:taxon_ids] = taxon_1.id.to_s
-          api_post :create, product: product_data
+          post spree.api_products_path, params: { product: product_data }
           expect(json_response["taxon_ids"]).to eq([taxon_1.id])
         end
 
         # Regression test for https://github.com/spree/spree/issues/4123
         it "puts the created product in the given taxons" do
           product_data[:taxon_ids] = [taxon_1.id, taxon_2.id].join(',')
-          api_post :create, product: product_data
+          post spree.api_products_path, params: { product: product_data }
           expect(json_response["taxon_ids"]).to eq([taxon_1.id, taxon_2.id])
         end
 
@@ -317,14 +318,14 @@ module Spree
           end
 
           it "can still create a product" do
-            api_post :create, product: product_data, token: "fake"
+            post spree.api_products_path, params: { product: product_data, token: "fake" }
             expect(json_response).to have_attributes(show_attributes)
             expect(response.status).to eq(201)
           end
         end
 
         it "cannot create a new product with invalid attributes" do
-          api_post :create, product: { foo: :bar }
+          post spree.api_products_path, params: { product: { foo: :bar } }
           expect(response.status).to eq(422)
           expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
           errors = json_response["errors"]
@@ -334,17 +335,17 @@ module Spree
 
       context 'updating a product' do
         it "can update a product" do
-          api_put :update, id: product.to_param, product: { name: "New and Improved Product!" }
+          put spree.api_product_path(product), params: { product: { name: "New and Improved Product!" } }
           expect(response.status).to eq(200)
         end
 
         it "can create new option types on a product" do
-          api_put :update, id: product.to_param, product: { option_types: ['shape', 'color'] }
+          put spree.api_product_path(product), params: { product: { option_types: ['shape', 'color'] } }
           expect(json_response['option_types'].count).to eq(2)
         end
 
         it "can create new variants on a product" do
-          api_put :update, id: product.to_param, product: { variants: [attributes_for_variant, attributes_for_variant.merge(sku: "ABC-#{Kernel.rand(9999)}")] }
+          put spree.api_product_path(product), params: { product: { variants: [attributes_for_variant, attributes_for_variant.merge(sku: "ABC-#{Kernel.rand(9999)}")] } }
           expect(response.status).to eq 200
           expect(json_response['variants'].count).to eq(2) # 2 variants
 
@@ -361,7 +362,7 @@ module Spree
           }
           variant_id = product.variants.create!({ product: product }.merge(variant_hash)).id
 
-          api_put :update, id: product.to_param, product: {
+          put spree.api_product_path(product), params: { product: {
             variants: [
               variant_hash.merge(
                 id: variant_id.to_s,
@@ -369,7 +370,7 @@ module Spree
                 options: [{ name: "size", value: "large" }]
               )
             ]
-          }
+          } }
 
           expect(json_response['variants'].count).to eq(1)
           variants = json_response['variants'].select { |v| !v['is_master'] }
@@ -379,7 +380,7 @@ module Spree
         end
 
         it "cannot update a product with an invalid attribute" do
-          api_put :update, id: product.to_param, product: { name: "" }
+          put spree.api_product_path(product), params: { product: { name: "" } }
           expect(response.status).to eq(422)
           expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
           expect(json_response["errors"]["name"]).to eq(["can't be blank"])
@@ -387,20 +388,20 @@ module Spree
 
         # Regression test for https://github.com/spree/spree/issues/4123
         it "puts the created product in the given taxon" do
-          api_put :update, id: product.to_param, product: { taxon_ids: taxon_1.id.to_s }
+          put spree.api_product_path(product), params: { product: { taxon_ids: taxon_1.id.to_s } }
           expect(json_response["taxon_ids"]).to eq([taxon_1.id])
         end
 
         # Regression test for https://github.com/spree/spree/issues/4123
         it "puts the created product in the given taxons" do
-          api_put :update, id: product.to_param, product: { taxon_ids: [taxon_1.id, taxon_2.id].join(',') }
+          put spree.api_product_path(product), params: { product: { taxon_ids: [taxon_1.id, taxon_2.id].join(',') } }
           expect(json_response["taxon_ids"]).to match_array([taxon_1.id, taxon_2.id])
         end
       end
 
       it "can delete a product" do
         expect(product.deleted_at).to be_nil
-        api_delete :destroy, id: product.to_param
+        delete spree.api_product_path(product)
         expect(response.status).to eq(204)
         expect(product.reload.deleted_at).not_to be_nil
       end