solidus_api 2.2.2 → 2.3.0.beta1

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ClassificationsController, type: :controller do
+  describe Api::ClassificationsController, type: :request do
     let(:taxon) do
       taxon = create(:taxon)
 
@@ -18,7 +18,7 @@ module Spree
 
     context "as a user" do
       it "cannot change the order of a product" do
-        api_put :update, taxon_id: taxon, product_id: taxon.products.first, position: 1
+        put spree.api_classifications_path, params: { taxon_id: taxon, product_id: taxon.products.first, position: 1 }
         expect(response.status).to eq(401)
       end
     end
@@ -31,7 +31,7 @@ module Spree
       it "can change the order a product" do
         classification = taxon.classifications.find_by(product_id: last_product.id)
         expect(classification.position).to eq(3)
-        api_put :update, taxon_id: taxon.id, product_id: last_product.id, position: 0
+        put spree.api_classifications_path, params: { taxon_id: taxon.id, product_id: last_product.id, position: 0 }
         expect(response.status).to eq(200)
         expect(classification.reload.position).to eq(1)
       end
@@ -39,7 +39,7 @@ module Spree
       it "should touch the taxon" do
         taxon.update_attributes(updated_at: Time.current - 10.seconds)
         taxon_last_updated_at = taxon.updated_at
-        api_put :update, taxon_id: taxon.id, product_id: last_product.id, position: 0
+        put spree.api_classifications_path, params: { taxon_id: taxon.id, product_id: last_product.id, position: 0 }
         taxon.reload
         expect(taxon_last_updated_at.to_i).to_not eq(taxon.updated_at.to_i)
       end

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

@@ -1,22 +1,21 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ConfigController, type: :controller do
+  describe Api::ConfigController, type: :request do
     let!(:default_country) { create :country, iso: "US"}
-    render_views
 
     before do
       stub_authentication!
     end
 
     it "returns Spree::Money settings" do
-      api_get :money
+      get '/api/config/money'
       expect(response).to be_success
       expect(json_response["symbol"]).to eq("$")
     end
 
     it "returns some configuration settings" do
-      api_get :show
+      get '/api/config'
       expect(response).to be_success
       expect(json_response["default_country_iso"]).to eq("US")
       expect(json_response["default_country_id"]).to eq(default_country.id)

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

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CountriesController, type: :controller do
-    render_views
+  describe Api::CountriesController, type: :request do
 
     before do
       stub_authentication!
@@ -11,7 +10,7 @@ module Spree
     end
 
     it "gets all countries" do
-      api_get :index
+      get spree.api_countries_path
       expect(json_response['countries'].first['iso3']).to eq @country.iso3
     end
 
@@ -19,20 +18,20 @@ module Spree
       before { @zambia = create(:country, name: "Zambia") }
 
       it "can view all countries" do
-        api_get :index
+        get spree.api_countries_path
         expect(json_response['count']).to eq(2)
         expect(json_response['current_page']).to eq(1)
         expect(json_response['pages']).to eq(1)
       end
 
       it 'can query the results through a paramter' do
-        api_get :index, q: { name_cont: 'zam' }
+        get spree.api_countries_path, params: { q: { name_cont: 'zam' } }
         expect(json_response['count']).to eq(1)
         expect(json_response['countries'].first['name']).to eq @zambia.name
       end
 
       it 'can control the page size through a parameter' do
-        api_get :index, per_page: 1
+        get spree.api_countries_path, 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)
@@ -40,7 +39,7 @@ module Spree
     end
 
     it "includes states" do
-      api_get :show, id: @country.id
+      get spree.api_country_path(@country.id)
       states = json_response['states']
       expect(states.first['name']).to eq @state.name
     end

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

@@ -1,9 +1,8 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CreditCardsController, type: :controller do
+  describe Api::CreditCardsController, type: :request do
     describe '#index' do
-      render_views
 
       let!(:admin_user) do
         create(:admin_user)
@@ -20,7 +19,7 @@ module Spree
       end
 
       it "the user id doesn't exist" do
-        api_get :index, user_id: 1000
+        get spree.api_user_credit_cards_path(1000)
         expect(response.status).to eq(404)
       end
 
@@ -30,14 +29,14 @@ module Spree
         end
 
         it "no credit cards exist for user" do
-          api_get :index, user_id: normal_user.id
+          get spree.api_user_credit_cards_path(normal_user)
 
           expect(response.status).to eq(200)
           expect(json_response["pages"]).to eq(0)
         end
 
         it "can view all credit cards for user" do
-          api_get :index, user_id: current_api_user.id
+          get spree.api_user_credit_cards_path(current_api_user.id)
 
           expect(response.status).to eq(200)
           expect(json_response["pages"]).to eq(1)
@@ -55,13 +54,13 @@ module Spree
         let!(:card) { create(:credit_card, user_id: normal_user.id, gateway_customer_profile_id: "random") }
 
         it "can not view user" do
-          api_get :index, user_id: admin_user.id
+          get spree.api_user_credit_cards_path(admin_user.id)
 
           expect(response.status).to eq(404)
         end
 
         it "can view own credit cards" do
-          api_get :index, user_id: normal_user.id
+          get spree.api_user_credit_cards_path(normal_user.id)
 
           expect(response.status).to eq(200)
           expect(json_response["pages"]).to eq(1)
@@ -85,7 +84,7 @@ module Spree
 
         it 'updates the credit card' do
           expect {
-            api_put :update, id: credit_card.to_param, credit_card: { name: 'Jordan Brough' }
+            put spree.api_credit_card_path(credit_card.to_param), params: { credit_card: { name: 'Jordan Brough' } }
           }.to change {
             credit_card.reload.name
           }.from('Joe Shmoe').to('Jordan Brough')
@@ -96,7 +95,7 @@ module Spree
         let(:current_api_user) { create(:user) }
 
         it 'rejects the request' do
-          api_put :update, id: credit_card.to_param, credit_card: { name: 'Jordan Brough' }
+          put spree.api_credit_card_path(credit_card.to_param), params: { credit_card: { name: 'Jordan Brough' } }
           expect(response.status).to eq(401)
         end
       end

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

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ImagesController, type: :controller do
-    render_views
+  describe Spree::Api::ImagesController, type: :request do
 
     let!(:product) { create(:product) }
     let!(:attributes) {
@@ -20,11 +19,13 @@ module Spree
 
       it "can upload a new image for a variant" do
         expect do
-          api_post :create,
-                   image: { attachment: upload_image('thinking-cat.jpg'),
-                               viewable_type: 'Spree::Variant',
-                               viewable_id: product.master.to_param },
-                   product_id: product.id
+          post spree.api_product_images_path(product.id), params: {
+            image: {
+              attachment: upload_image('thinking-cat.jpg'),
+              viewable_type: 'Spree::Variant',
+              viewable_id: product.master.to_param
+            },
+          }
           expect(response.status).to eq(201)
           expect(json_response).to have_attributes(attributes)
         end.to change(Image, :count).by(1)
@@ -34,26 +35,26 @@ module Spree
         let!(:product_image) { product.master.images.create!(attachment: image('thinking-cat.jpg')) }
 
         it "can get a single product image" do
-          api_get :show, id: product_image.id, product_id: product.id
+          get spree.api_product_image_path(product.id, product_image)
           expect(response.status).to eq(200)
           expect(json_response).to have_attributes(attributes)
         end
 
         it "can get a single variant image" do
-          api_get :show, id: product_image.id, variant_id: product.master.id
+          get spree.api_variant_image_path(product.master.id, product_image)
           expect(response.status).to eq(200)
           expect(json_response).to have_attributes(attributes)
         end
 
         it "can get a list of product images" do
-          api_get :index, product_id: product.id
+          get spree.api_product_images_path(product.id)
           expect(response.status).to eq(200)
           expect(json_response).to have_key("images")
           expect(json_response["images"].first).to have_attributes(attributes)
         end
 
         it "can get a list of variant images" do
-          api_get :index, variant_id: product.master.id
+          get spree.api_variant_images_path(product.master.id)
           expect(response.status).to eq(200)
           expect(json_response).to have_key("images")
           expect(json_response["images"].first).to have_attributes(attributes)
@@ -61,14 +62,14 @@ module Spree
 
         it "can update image data" do
           expect(product_image.position).to eq(1)
-          api_post :update, image: { position: 2 }, id: product_image.id, product_id: product.id
+          put spree.api_variant_image_path(product.id, product_image), params: { image: { position: 2 } }
           expect(response.status).to eq(200)
           expect(json_response).to have_attributes(attributes)
           expect(product_image.reload.position).to eq(2)
         end
 
         it "can delete an image" do
-          api_delete :destroy, id: product_image.id, product_id: product.id
+          delete spree.api_variant_image_path(product.id, product_image)
           expect(response.status).to eq(204)
           expect { product_image.reload }.to raise_error(ActiveRecord::RecordNotFound)
         end
@@ -76,18 +77,20 @@ module Spree
     end
 
     context "as a non-admin" do
+      let(:product_image) { product.master.images.create!(attachment: image('thinking-cat.jpg')) }
+
       it "cannot create an image" do
-        api_post :create, product_id: product.id
+        post spree.api_product_images_path(product.id)
         assert_unauthorized!
       end
 
       it "cannot update an image" do
-        api_put :update, id: 1, product_id: product.id
+        put spree.api_product_image_path(product.id, product_image)
         assert_not_found!
       end
 
       it "cannot delete an image" do
-        api_delete :destroy, id: 1, product_id: product.id
+        delete spree.api_product_image_path(product.id, product_image)
         assert_not_found!
       end
     end

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

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::InventoryUnitsController, type: :controller do
-    render_views
+  describe Api::InventoryUnitsController, type: :request do
+    let!(:inventory_unit) { create(:inventory_unit) }
 
     before do
       stub_authentication!
-      @inventory_unit = create(:inventory_unit)
     end
 
     context "as an admin" do
@@ -14,34 +13,38 @@ module Spree
       let(:variant) { create(:variant) }
 
       it "gets an inventory unit" do
-        api_get :show, id: @inventory_unit.id
-        expect(json_response['state']).to eq @inventory_unit.state
+        get spree.api_inventory_unit_path(inventory_unit)
+        expect(json_response['state']).to eq inventory_unit.state
       end
 
       it "updates an inventory unit" do
-        api_put :update, id: @inventory_unit.id,
-                         inventory_unit: { variant_id: variant.id }
+        put spree.api_inventory_unit_path(inventory_unit), params: {
+          inventory_unit: { variant_id: variant.id }
+        }
         expect(json_response['variant_id']).to eq variant.id
       end
 
       context 'fires state event' do
         it 'if supplied with :fire param' do
-          api_put :update, id: @inventory_unit.id,
-                           fire: 'ship',
-                           inventory_unit: { variant_id: variant.id }
+          put spree.api_inventory_unit_path(inventory_unit), params: {
+            fire: 'ship',
+            inventory_unit: { variant_id: variant.id }
+          }
 
           expect(json_response['state']).to eq 'shipped'
         end
 
         it 'and returns exception if cannot fire' do
-          api_put :update, id: @inventory_unit.id,
-                           fire: 'return'
+          put spree.api_inventory_unit_path(inventory_unit), params: {
+            fire: 'return'
+          }
           expect(json_response['exception']).to match /cannot transition to return/
         end
 
         it 'and returns exception bad state' do
-          api_put :update, id: @inventory_unit.id,
-                           fire: 'bad'
+          put spree.api_inventory_unit_path(inventory_unit), params: {
+            fire: 'bad'
+          }
           expect(json_response['exception']).to match /cannot transition to bad/
         end
       end

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

@@ -5,15 +5,11 @@ module Spree
     mattr_writer :line_item_attributes
   end
 
-  unless PermittedAttributes.line_item_attributes.include? :some_option
-    PermittedAttributes.line_item_attributes += [:some_option]
+  unless PermittedAttributes.line_item_attributes.include? :options
+    PermittedAttributes.line_item_attributes << { options: [:some_option] }
   end
 
-  # This should go in an initializer
-  Spree::Api::LineItemsController.line_item_options += [:some_option]
-
-  describe Api::LineItemsController, type: :controller do
-    render_views
+  describe Api::LineItemsController, type: :request do
 
     let!(:order) { create(:order_with_line_items, line_items_count: 1) }
 
@@ -26,7 +22,7 @@ module Spree
     end
 
     it "can learn how to create a new line item" do
-      api_get :new
+      get spree.new_api_order_line_item_path(order)
       expect(json_response["attributes"]).to eq(["quantity", "price", "variant_id"])
       required_attributes = json_response["required_attributes"]
       expect(required_attributes).to include("quantity", "variant_id")
@@ -34,15 +30,16 @@ module Spree
 
     context "authenticating with a token" do
       it "can add a new line item to an existing order" do
-        api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }, order_token: order.guest_token
+        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 }, order_token: order.guest_token }
         expect(response.status).to eq(201)
         expect(json_response).to have_attributes(attributes)
         expect(json_response["variant"]["name"]).not_to be_blank
       end
 
       it "can add a new line item to an existing order with token in header" do
-        request.headers["X-Spree-Order-Token"] = order.guest_token
-        api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
+        post spree.api_order_line_items_path(order),
+          params: { line_item: { variant_id: product.master.to_param, quantity: 1 } },
+          headers: { 'X-Spree-Order-Token' => order.guest_token }
         expect(response.status).to eq(201)
         expect(json_response).to have_attributes(attributes)
         expect(json_response["variant"]["name"]).not_to be_blank
@@ -55,7 +52,7 @@ module Spree
       end
 
       it "can add a new line item to an existing order" do
-        api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
+        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
         expect(response.status).to eq(201)
         expect(json_response).to have_attributes(attributes)
         expect(json_response["variant"]["name"]).not_to be_blank
@@ -63,17 +60,19 @@ module Spree
 
       it "can add a new line item to an existing order with options" do
         expect_any_instance_of(LineItem).to receive(:some_option=).with("foobar")
-        api_post :create,
-                 line_item: {
-                   variant_id: product.master.to_param,
-                   quantity: 1,
-                   options: { some_option: "foobar" }
-                 }
+        post spree.api_order_line_items_path(order),
+                 params: {
+                                    line_item: {
+                              variant_id: product.master.to_param,
+                              quantity: 1,
+                              options: { some_option: "foobar" }
+                            }
+        }
         expect(response.status).to eq(201)
       end
 
       it "default quantity to 1 if none is given" do
-        api_post :create, line_item: { variant_id: product.master.to_param }
+        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param } }
         expect(response.status).to eq(201)
         expect(json_response).to have_attributes(attributes)
         expect(json_response[:quantity]).to eq 1
@@ -81,7 +80,7 @@ module Spree
 
       it "increases a line item's quantity if it exists already" do
         order.line_items.create(variant_id: product.master.id, quantity: 10)
-        api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
+        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
         expect(response.status).to eq(201)
         order.reload
         expect(order.line_items.count).to eq(2) # 1 original due to factory, + 1 in this test
@@ -91,7 +90,7 @@ module Spree
 
       it "can update a line item on the order" do
         line_item = order.line_items.first
-        api_put :update, id: line_item.id, line_item: { quantity: 101 }
+        put spree.api_order_line_item_path(order, line_item), params: { line_item: { quantity: 101 } }
         expect(response.status).to eq(200)
         order.reload
         expect(order.total).to eq(1010) # 10 original due to factory, + 1000 in this test
@@ -102,15 +101,16 @@ module Spree
       it "can update a line item's options on the order" do
         expect_any_instance_of(LineItem).to receive(:some_option=).with("foobar")
         line_item = order.line_items.first
-        api_put :update,
-                id: line_item.id,
-                line_item: { quantity: 1, options: { some_option: "foobar" } }
+        put spree.api_order_line_item_path(order, line_item),
+                params: {
+                  line_item: { quantity: 1, options: { some_option: "foobar" } }
+                }
         expect(response.status).to eq(200)
       end
 
       it "can delete a line item on the order" do
         line_item = order.line_items.first
-        api_delete :destroy, id: line_item.id
+        delete spree.api_order_line_item_path(order, line_item)
         expect(response.status).to eq(204)
         order.reload
         expect(order.line_items.count).to eq(0) # 1 original due to factory, - 1 in this test
@@ -126,19 +126,19 @@ module Spree
 
         it "clear out shipments on create" do
           expect(order.reload.shipments).not_to be_empty
-          api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
+          post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
           expect(order.reload.shipments).to be_empty
         end
 
         it "clear out shipments on update" do
           expect(order.reload.shipments).not_to be_empty
-          api_put :update, id: line_item.id, line_item: { quantity: 1000 }
+          put spree.api_order_line_item_path(order, line_item), params: { line_item: { quantity: 1000 } }
           expect(order.reload.shipments).to be_empty
         end
 
         it "clear out shipments on delete" do
           expect(order.reload.shipments).not_to be_empty
-          api_delete :destroy, id: line_item.id
+          delete spree.api_order_line_item_path(order, line_item)
           expect(order.reload.shipments).to be_empty
         end
 
@@ -150,7 +150,7 @@ module Spree
 
           it "doesn't destroy shipments or restart checkout flow" do
             expect(order.reload.shipments).not_to be_empty
-            api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
+            post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
             expect(order.reload.shipments).not_to be_empty
           end
         end
@@ -165,20 +165,20 @@ module Spree
       end
 
       it "cannot add a new line item to the order" do
-        api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
+        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
         assert_unauthorized!
       end
 
       it "cannot update a line item on the order" do
         line_item = order.line_items.first
-        api_put :update, id: line_item.id, line_item: { quantity: 1000 }
+        put spree.api_order_line_item_path(order, line_item), params: { line_item: { quantity: 1000 } }
         assert_unauthorized!
         expect(line_item.reload.quantity).not_to eq(1000)
       end
 
       it "cannot delete a line item on the order" do
         line_item = order.line_items.first
-        api_delete :destroy, id: line_item.id
+        delete spree.api_order_line_item_path(order, line_item)
         assert_unauthorized!
         expect { line_item.reload }.not_to raise_error
       end