solidus_api 2.2.2 → 2.3.0.beta1

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

@@ -2,8 +2,7 @@ require 'shared_examples/protect_product_actions'
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ProductsController, type: :controller do
-    render_views
+  describe Spree::Api::ProductsController, type: :request do
 
     let!(:product) { create(:product) }
     let(:attributes) { [:id, :name, :description, :price, :available_on, :slug, :meta_description, :meta_keywords, :taxon_ids] }
@@ -12,7 +11,7 @@ module Spree
       before { Spree::Api::Config[:requires_authentication] = false }
 
       it "retrieves a list of products" do
-        api_get :index
+        get spree.api_products_path
         expect(json_response["products"].first).to have_attributes(attributes)
         expect(json_response["count"]).to eq(1)
         expect(json_response["current_page"]).to eq(1)

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

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::UsersController, type: :controller do
-    render_views
+  describe Api::UsersController, type: :request do
 
     let(:user) { create(:user, spree_api_key: SecureRandom.hex) }
     let(:stranger) { create(:user, email: 'stranger@example.com') }
@@ -10,19 +9,19 @@ module Spree
 
     context "as a normal user" do
       it "can get own details" do
-        api_get :show, id: user.id, token: user.spree_api_key
+        get spree.api_user_path(user.id), params: { token: user.spree_api_key }
 
         expect(json_response['email']).to eq user.email
       end
 
       it "cannot get other users details" do
-        api_get :show, id: stranger.id, token: user.spree_api_key
+        get spree.api_user_path(stranger.id), params: { token: user.spree_api_key }
 
         assert_not_found!
       end
 
       it "can learn how to create a new user" do
-        api_get :new, token: user.spree_api_key
+        get spree.new_api_user_path, params: { token: user.spree_api_key }
         expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
       end
 
@@ -31,20 +30,20 @@ module Spree
           email: 'new@example.com', password: 'spree123', password_confirmation: 'spree123'
         }
 
-        api_post :create, user: user_params, token: user.spree_api_key
+        post spree.api_users_path, params: { user: user_params, token: user.spree_api_key }
         expect(json_response['email']).to eq 'new@example.com'
       end
 
       # there's no validations on LegacyUser?
       xit "cannot create a new user with invalid attributes" do
-        api_post :create, user: {}, token: user.spree_api_key
+        post spree.api_users_path, params: { user: {}, token: user.spree_api_key }
         expect(response.status).to eq(422)
         expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
       end
 
       it "can update own details" do
         country = create(:country)
-        api_put :update, id: user.id, token: user.spree_api_key, user: {
+        put spree.api_user_path(user.id), params: { token: user.spree_api_key, user: {
           email: "mine@example.com",
           bill_address_attributes: {
             first_name: 'First',
@@ -66,30 +65,30 @@ module Spree
             zipcode: '55555',
             phone: '5555555555'
           }
-        }
+        } }
         expect(json_response['email']).to eq 'mine@example.com'
         expect(json_response['bill_address']).to_not be_nil
         expect(json_response['ship_address']).to_not be_nil
       end
 
       it "cannot update other users details" do
-        api_put :update, id: stranger.id, token: user.spree_api_key, user: { email: "mine@example.com" }
+        put spree.api_user_path(stranger.id), params: { token: user.spree_api_key, user: { email: "mine@example.com" } }
         assert_not_found!
       end
 
       it "cannot delete itself" do
-        api_delete :destroy, id: user.id, token: user.spree_api_key
+        delete spree.api_user_path(user.id), params: { token: user.spree_api_key }
         expect(response.status).to eq(401)
       end
 
       it "cannot delete other user" do
-        api_delete :destroy, id: stranger.id, token: user.spree_api_key
+        delete spree.api_user_path(stranger.id), params: { token: user.spree_api_key }
         assert_not_found!
       end
 
       it "should only get own details on index" do
         2.times { create(:user) }
-        api_get :index, token: user.spree_api_key
+        get spree.api_users_path, params: { token: user.spree_api_key }
 
         expect(Spree.user_class.count).to eq 3
         expect(json_response['count']).to eq 1
@@ -107,7 +106,7 @@ module Spree
 
         2.times { create(:user) }
 
-        api_get :index
+        get spree.api_users_path
         expect(Spree.user_class.count).to eq 2
         expect(json_response['count']).to eq 2
         expect(json_response['users'].size).to eq 2
@@ -115,7 +114,7 @@ module Spree
 
       it 'can control the page size through a parameter' do
         2.times { create(:user) }
-        api_get :index, per_page: 1
+        get spree.api_users_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)
@@ -123,26 +122,26 @@ module Spree
 
       it 'can query the results through a paramter' do
         expected_result = create(:user, email: 'brian@spreecommerce.com')
-        api_get :index, q: { email_cont: 'brian' }
+        get spree.api_users_path, params: { q: { email_cont: 'brian' } }
         expect(json_response['count']).to eq(1)
         expect(json_response['users'].first['email']).to eq expected_result.email
       end
 
       it "can create" do
-        api_post :create, user: { email: "new@example.com", password: 'spree123', password_confirmation: 'spree123' }
+        post spree.api_users_path, params: { user: { email: "new@example.com", password: 'spree123', password_confirmation: 'spree123' } }
         expect(json_response).to have_attributes(attributes)
         expect(response.status).to eq(201)
       end
 
       it "can destroy user without orders" do
         user.orders.destroy_all
-        api_delete :destroy, id: user.id
+        delete spree.api_user_path(user)
         expect(response.status).to eq(204)
       end
 
       it "cannot destroy user with orders" do
         create(:completed_order_with_totals, user: user)
-        api_delete :destroy, id: user.id
+        delete spree.api_user_path(user)
         expect(json_response["exception"]).to eq "Spree::Core::DestroyWithOrdersError"
         expect(response.status).to eq(422)
       end

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

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::VariantsController, type: :controller do
-    render_views
+  describe Api::VariantsController, type: :request do
 
     let!(:product) { create(:product) }
     let!(:variant) do
@@ -21,7 +20,7 @@ module Spree
 
     describe "#index" do
       it "can see a paginated list of variants" do
-        api_get :index
+        get spree.api_variants_path
         first_variant = json_response["variants"].first
         expect(first_variant).to have_attributes(show_attributes)
         expect(first_variant["stock_items"]).to be_present
@@ -32,7 +31,7 @@ module Spree
 
       it 'can control the page size through a parameter' do
         create(:variant)
-        api_get :index, per_page: 1
+        get spree.api_variants_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(3)
@@ -40,13 +39,13 @@ module Spree
 
       it 'can query the results through a paramter' do
         expected_result = create(:variant, sku: 'FOOBAR')
-        api_get :index, q: { sku_cont: 'FOO' }
+        get spree.api_variants_path, params: { q: { sku_cont: 'FOO' } }
         expect(json_response['count']).to eq(1)
         expect(json_response['variants'].first['sku']).to eq expected_result.sku
       end
 
       it "variants returned contain option values data" do
-        api_get :index
+        get spree.api_variants_path
         option_values = json_response["variants"].last["option_values"]
         expect(option_values.first).to have_attributes([:name,
                                                         :presentation,
@@ -57,7 +56,7 @@ module Spree
       it "variants returned contain images data" do
         variant.images.create!(attachment: image("thinking-cat.jpg"))
 
-        api_get :index
+        get spree.api_variants_path
 
         expect(json_response["variants"].last).to have_attributes([:images])
         expect(json_response['variants'].first['images'].first).to have_attributes([:attachment_file_name,
@@ -77,38 +76,67 @@ module Spree
         end
 
         it "is not returned in the results" do
-          api_get :index
+          get spree.api_variants_path
           expect(json_response["variants"].count).to eq(0)
         end
 
         it "is not returned even when show_deleted is passed" do
-          api_get :index, show_deleted: true
+          get spree.api_variants_path, params: { show_deleted: true }
           expect(json_response["variants"].count).to eq(0)
         end
       end
 
       context "stock filtering" do
-        subject { api_get :index, in_stock_only: true }
 
-        context "variant is out of stock" do
-          before do
-            variant.stock_items.update_all(count_on_hand: 0)
+        context "only variants in stock" do
+          subject { get spree.api_variants_path, params: { in_stock_only: "true" } }
+
+          context "variant is out of stock" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 0)
+            end
+
+            it "is not returned in the results" do
+              subject
+              expect(json_response["variants"].count).to eq 0
+            end
           end
 
-          it "is not returned in the results" do
-            subject
-            expect(json_response["variants"].count).to eq 0
+          context "variant is in stock" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 10)
+            end
+
+            it "is returned in the results" do
+              subject
+              expect(json_response["variants"].count).to eq 1
+            end
           end
         end
 
-        context "variant is in stock" do
-          before do
-            variant.stock_items.update_all(count_on_hand: 10)
+        context "all variants" do
+          subject { get spree.api_variants_path, params: { in_stock_only: "false" } }
+
+          context "variant is out of stock" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 0)
+            end
+
+            it "is returned in the results" do
+              subject
+              expect(json_response["variants"].count).to eq 1
+            end
           end
 
-          it "is returned in the results" do
-            subject
-            expect(json_response["variants"].count).to eq 1
+          context "variant is in stock" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 10)
+            end
+
+            it "is returned in the results" do
+              subject
+              expect(json_response["variants"].count).to eq 1
+            end
           end
         end
       end
@@ -116,7 +144,7 @@ module Spree
       context "pagination" do
         it "can select the next page of variants" do
           create(:variant)
-          api_get :index, page: 2, per_page: 1
+          get spree.api_variants_path, params: { page: 2, per_page: 1 }
           expect(json_response["variants"].first).to have_attributes(show_attributes)
           expect(json_response["total_count"]).to eq(3)
           expect(json_response["current_page"]).to eq(2)
@@ -129,7 +157,7 @@ module Spree
         let!(:inactive_stock_location) { create(:stock_location, propagate_all_variants: true, name: "My special stock location", active: false) }
 
         it "only returns stock items for active stock locations" do
-          api_get :index
+          get spree.api_variants_path
           variant = json_response['variants'].first
           stock_items = variant['stock_items'].map { |si| si['stock_location_name'] }
 
@@ -140,7 +168,9 @@ module Spree
     end
 
     describe "#show" do
-      subject { api_get :show, id: variant.to_param }
+      subject do
+        get spree.api_variant_path(variant)
+      end
 
       it "can see a single variant" do
         subject
@@ -195,30 +225,29 @@ module Spree
     end
 
     it "can learn how to create a new variant" do
-      api_get :new
+      get spree.new_api_variant_path(variant)
       expect(json_response["attributes"]).to eq(new_attributes.map(&:to_s))
       expect(json_response["required_attributes"]).to be_empty
     end
 
     it "cannot create a new variant if not an admin" do
-      api_post :create, variant: { sku: "12345" }
+      post spree.api_variants_path, params: { variant: { sku: "12345" } }
       assert_unauthorized!
     end
 
     it "cannot update a variant" do
-      api_put :update, id: variant.to_param, variant: { sku: "12345" }
+      put spree.api_variant_path(variant), params: { variant: { sku: "12345" } }
       assert_not_found!
     end
 
     it "cannot delete a variant" do
-      api_delete :destroy, id: variant.to_param
+      delete spree.api_variant_path(variant)
       assert_not_found!
       expect { variant.reload }.not_to raise_error
     end
 
     context "as an admin" do
       sign_in_as_admin!
-      let(:resource_scoping) { { product_id: variant.product.to_param } }
 
       # Test for https://github.com/spree/spree/issues/2141
       context "deleted variants" do
@@ -227,13 +256,13 @@ module Spree
         end
 
         it "are visible by admin" do
-          api_get :index, show_deleted: 1
+          get spree.api_variants_path, params: { show_deleted: 1 }
           expect(json_response["variants"].count).to eq(1)
         end
       end
 
       it "can create a new variant" do
-        api_post :create, variant: { sku: "12345" }
+        post spree.api_product_variants_path(product), params: { variant: { sku: "12345" } }
         expect(json_response).to have_attributes(new_attributes)
         expect(response.status).to eq(201)
         expect(json_response["sku"]).to eq("12345")
@@ -244,24 +273,28 @@ module Spree
       it "creates new variants with nested option values" do
         option_values = create_list(:option_value, 2)
         expect do
-          api_post :create, variant: { sku: "12345",
-                                       option_value_ids: option_values.map(&:id) }
+          post spree.api_product_variants_path(product), params: {
+            variant: {
+              sku: "12345",
+              option_value_ids: option_values.map(&:id)
+            }
+          }
         end.to change { Spree::OptionValuesVariant.count }.by(2)
       end
 
       it "can update a variant" do
-        api_put :update, id: variant.to_param, variant: { sku: "12345" }
+        put spree.api_variant_path(variant), params: { variant: { sku: "12345" } }
         expect(response.status).to eq(200)
       end
 
       it "can delete a variant" do
-        api_delete :destroy, id: variant.to_param
+        delete spree.api_variant_path(variant)
         expect(response.status).to eq(204)
         expect { Spree::Variant.find(variant.id) }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       it 'variants returned contain cost price data' do
-        api_get :index
+        get spree.api_variants_path
         expect(json_response["variants"].first.key?(:cost_price)).to eq true
       end
     end

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

@@ -1,24 +1,23 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ZonesController, type: :controller do
-    render_views
+  describe Api::ZonesController, type: :request do
 
     let!(:attributes) { [:id, :name, :zone_members] }
+    let!(:zone) { create(:zone, name: 'Europe') }
 
     before do
       stub_authentication!
-      @zone = create(:zone, name: 'Europe')
     end
 
     it "gets list of zones" do
-      api_get :index
+      get spree.api_zones_path
       expect(json_response['zones'].first).to have_attributes(attributes)
     end
 
     it 'can control the page size through a parameter' do
       create(:zone)
-      api_get :index, per_page: 1
+      get spree.api_zones_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)
@@ -26,16 +25,16 @@ module Spree
 
     it 'can query the results through a paramter' do
       expected_result = create(:zone, name: 'South America')
-      api_get :index, q: { name_cont: 'south' }
+      get spree.api_zones_path, params: { q: { name_cont: 'south' } }
       expect(json_response['count']).to eq(1)
       expect(json_response['zones'].first['name']).to eq expected_result.name
     end
 
     it "gets a zone" do
-      api_get :show, id: @zone.id
+      get spree.api_zone_path(zone)
       expect(json_response).to have_attributes(attributes)
-      expect(json_response['name']).to eq @zone.name
-      expect(json_response['zone_members'].size).to eq @zone.zone_members.count
+      expect(json_response['name']).to eq zone.name
+      expect(json_response['zone_members'].size).to eq zone.zone_members.count
     end
 
     context "as an admin" do
@@ -54,14 +53,14 @@ module Spree
           }
         }
 
-        api_post :create, params
+        post spree.api_zones_path, params: params
         expect(response.status).to eq(201)
         expect(json_response).to have_attributes(attributes)
         expect(json_response["zone_members"]).not_to be_empty
       end
 
       it "updates a zone" do
-        params = { id: @zone.id,
+        params = {
           zone: {
             name: "North Pole",
             zone_members: [
@@ -73,16 +72,16 @@ module Spree
           }
         }
 
-        api_put :update, params
+        put spree.api_zone_path(zone), params: params
         expect(response.status).to eq(200)
         expect(json_response['name']).to eq 'North Pole'
         expect(json_response['zone_members']).not_to be_blank
       end
 
       it "can delete a zone" do
-        api_delete :destroy, id: @zone.id
+        delete spree.api_zone_path(zone)
         expect(response.status).to eq(204)
-        expect { @zone.reload }.to raise_error(ActiveRecord::RecordNotFound)
+        expect { zone.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end