solidus_api 1.2.3 → 1.3.0.beta1

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

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::TaxonsController, :type => :controller do
+  describe Api::TaxonsController, type: :controller do
     render_views
 
     let(:taxonomy) { create(:taxonomy) }
-    let(:taxon) { create(:taxon, :name => "Ruby", :taxonomy => taxonomy) }
-    let(:taxon2) { create(:taxon, :name => "Rails", :taxonomy => taxonomy) }
+    let(:taxon) { create(:taxon, name: "Ruby", taxonomy: taxonomy) }
+    let(:taxon2) { create(:taxon, name: "Rails", taxonomy: taxonomy) }
     let(:attributes) { ["id", "name", "pretty_name", "permalink", "parent_id", "taxonomy_id"] }
 
     before do
       stub_authentication!
-      taxon2.children << create(:taxon, :name => "3.2.2", :taxonomy => taxonomy)
+      taxon2.children << create(:taxon, name: "3.2.2", taxonomy: taxonomy)
       taxon.children << taxon2
       taxonomy.root.children << taxon
     end
 
     context "as a normal user" do
       it "gets all taxons for a taxonomy" do
-        api_get :index, :taxonomy_id => taxonomy.id
+        api_get :index, taxonomy_id: taxonomy.id
 
         expect(json_response['taxons'].first['name']).to eq taxon.name
         children = json_response['taxons'].first['taxons']
@@ -29,17 +29,17 @@ module Spree
 
       # Regression test for https://github.com/spree/spree/issues/4112
       it "does not include children when asked not to" do
-        api_get :index, :taxonomy_id => taxonomy.id, :without_children => 1
+        api_get :index, taxonomy_id: taxonomy.id, without_children: 1
 
         expect(json_response['taxons'].first['name']).to eq(taxon.name)
         expect(json_response['taxons'].first['taxons']).to be_nil
       end
 
       it "paginates through taxons" do
-        new_taxon = create(:taxon, :name => "Go", :taxonomy => taxonomy)
+        new_taxon = create(:taxon, name: "Go", taxonomy: taxonomy)
         taxonomy.root.children << new_taxon
         expect(taxonomy.root.children.count).to eql(2)
-        api_get :index, :taxonomy_id => taxonomy.id, :page => 1, :per_page => 1
+        api_get :index, taxonomy_id: taxonomy.id, page: 1, per_page: 1
         expect(json_response["count"]).to eql(1)
         expect(json_response["total_count"]).to eql(2)
         expect(json_response["current_page"]).to eql(1)
@@ -50,7 +50,7 @@ module Spree
       describe 'searching' do
         context 'with a name' do
           before do
-            api_get :index, :q => { :name_cont => name }
+            api_get :index, q: { name_cont: name }
           end
 
           context 'with one result' do
@@ -86,39 +86,39 @@ module Spree
       end
 
       it "gets a single taxon" do
-        api_get :show, :id => taxon.id, :taxonomy_id => taxonomy.id
+        api_get :show, id: taxon.id, taxonomy_id: taxonomy.id
 
         expect(json_response['name']).to eq taxon.name
         expect(json_response['taxons'].count).to eq 1
       end
 
       it "gets all taxons in JSTree form" do
-        api_get :jstree, :taxonomy_id => taxonomy.id, :id => taxon.id
+        api_get :jstree, taxonomy_id: taxonomy.id, id: taxon.id
         response = json_response.first
         expect(response["data"]).to eq(taxon2.name)
-        expect(response["attr"]).to eq({ "name" => taxon2.name, "id" => taxon2.id})
+        expect(response["attr"]).to eq({ "name" => taxon2.name, "id" => taxon2.id })
         expect(response["state"]).to eq("closed")
       end
 
       it "can learn how to create a new taxon" do
-        api_get :new, :taxonomy_id => taxonomy.id
+        api_get :new, taxonomy_id: taxonomy.id
         expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
         required_attributes = json_response["required_attributes"]
         expect(required_attributes).to include("name")
       end
 
       it "cannot create a new taxon if not an admin" do
-        api_post :create, :taxonomy_id => taxonomy.id, :taxon => { :name => "Location" }
+        api_post :create, taxonomy_id: taxonomy.id, taxon: { name: "Location" }
         assert_unauthorized!
       end
 
       it "cannot update a taxon" do
-        api_put :update, :taxonomy_id => taxonomy.id, :id => taxon.id, :taxon => { :name => "I hacked your store!" }
+        api_put :update, taxonomy_id: taxonomy.id, id: taxon.id, taxon: { name: "I hacked your store!" }
         assert_unauthorized!
       end
 
       it "cannot delete a taxon" do
-        api_delete :destroy, :taxonomy_id => taxonomy.id, :id => taxon.id
+        api_delete :destroy, taxonomy_id: taxonomy.id, id: taxon.id
         assert_unauthorized!
       end
     end
@@ -127,12 +127,12 @@ module Spree
       sign_in_as_admin!
 
       it "can create" do
-        api_post :create, :taxonomy_id => taxonomy.id, :taxon => { :name => "Colors" }
+        api_post :create, taxonomy_id: taxonomy.id, taxon: { name: "Colors" }
         expect(json_response).to have_attributes(attributes)
         expect(response.status).to eq(201)
 
         expect(taxonomy.reload.root.children.count).to eq 2
-        taxon = Spree::Taxon.where(:name => 'Colors').first
+        taxon = Spree::Taxon.where(name: 'Colors').first
 
         expect(taxon.parent_id).to eq taxonomy.root.id
         expect(taxon.taxonomy_id).to eq taxonomy.id
@@ -140,23 +140,22 @@ module Spree
 
       it "can update the position in the list" do
         taxonomy.root.children << taxon2
-        api_put :update, :taxonomy_id => taxonomy.id, :id => taxon.id, :taxon => {:parent_id => taxon.parent_id, :child_index => 2 }
+        api_put :update, taxonomy_id: taxonomy.id, id: taxon.id, taxon: { parent_id: taxon.parent_id, child_index: 2 }
         expect(response.status).to eq(200)
         expect(taxonomy.reload.root.children[0]).to eql taxon2
         expect(taxonomy.reload.root.children[1]).to eql taxon
       end
 
       it "cannot create a new taxon with invalid attributes" do
-        api_post :create, :taxonomy_id => taxonomy.id, :taxon => {}
+        api_post :create, taxonomy_id: taxonomy.id, taxon: {}
         expect(response.status).to eq(422)
         expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
-        errors = json_response["errors"]
 
         expect(taxonomy.reload.root.children.count).to eq 1
       end
 
       it "cannot create a new taxon with invalid taxonomy_id" do
-        api_post :create, :taxonomy_id => 1000, :taxon => { :name => "Colors" }
+        api_post :create, taxonomy_id: 1000, taxon: { name: "Colors" }
         expect(response.status).to eq(422)
         expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
 
@@ -168,10 +167,9 @@ module Spree
       end
 
       it "can destroy" do
-        api_delete :destroy, :taxonomy_id => taxonomy.id, :id => taxon.id
+        api_delete :destroy, taxonomy_id: taxonomy.id, id: taxon.id
         expect(response.status).to eq(204)
       end
     end
-
   end
 end

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

@@ -2,7 +2,7 @@ require 'shared_examples/protect_product_actions'
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ProductsController, :type => :controller do
+  describe Spree::Api::ProductsController, type: :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -23,4 +23,3 @@ module Spree
     end
   end
 end
-

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

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::UsersController, :type => :controller do
+  describe Api::UsersController, type: :controller do
     render_views
 
     let(:user) { create(:user, spree_api_key: SecureRandom.hex) }
-    let(:stranger) { create(:user, :email => 'stranger@example.com') }
+    let(:stranger) { create(:user, email: 'stranger@example.com') }
     let(:attributes) { [:id, :email, :created_at, :updated_at] }
 
     context "as a normal user" do
@@ -28,19 +28,18 @@ module Spree
 
       it "can create a new user" do
         user_params = {
-          :email => 'new@example.com', :password => 'spree123', :password_confirmation => 'spree123'
+          email: 'new@example.com', password: 'spree123', password_confirmation: 'spree123'
         }
 
-        api_post :create, :user => user_params, token: user.spree_api_key
+        api_post :create, 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
+        api_post :create, 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.")
-        errors = json_response["errors"]
       end
 
       it "can update own details" do
@@ -74,7 +73,7 @@ module Spree
       end
 
       it "cannot update other users details" do
-        api_put :update, id: stranger.id, token: user.spree_api_key, user: { :email => "mine@example.com" }
+        api_put :update, id: stranger.id, token: user.spree_api_key, user: { email: "mine@example.com" }
         assert_not_found!
       end
 
@@ -116,38 +115,37 @@ module Spree
 
       it 'can control the page size through a parameter' do
         2.times { create(:user) }
-        api_get :index, :per_page => 1
+        api_get :index, 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)
       end
 
       it 'can query the results through a paramter' do
-        expected_result = create(:user, :email => 'brian@spreecommerce.com')
-        api_get :index, :q => { :email_cont => 'brian' }
+        expected_result = create(:user, email: 'brian@spreecommerce.com')
+        api_get :index, 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' }
+        api_post :create, 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
+        api_delete :destroy, id: user.id
         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
+        create(:completed_order_with_totals, user: user)
+        api_delete :destroy, id: user.id
         expect(json_response["exception"]).to eq "Spree::Core::DestroyWithOrdersError"
         expect(response.status).to eq(422)
       end
-
     end
   end
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::VariantsController, :type => :controller do
+  describe Api::VariantsController, type: :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -20,7 +20,6 @@ module Spree
     end
 
     describe "#index" do
-
       it "can see a paginated list of variants" do
         api_get :index
         first_variant = json_response["variants"].first
@@ -33,15 +32,15 @@ module Spree
 
       it 'can control the page size through a parameter' do
         create(:variant)
-        api_get :index, :per_page => 1
+        api_get :index, 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)
       end
 
       it 'can query the results through a paramter' do
-        expected_result = create(:variant, :sku => 'FOOBAR')
-        api_get :index, :q => { :sku_cont => 'FOO' }
+        expected_result = create(:variant, sku: 'FOOBAR')
+        api_get :index, q: { sku_cont: 'FOO' }
         expect(json_response['count']).to eq(1)
         expect(json_response['variants'].first['sku']).to eq expected_result.sku
       end
@@ -50,26 +49,25 @@ module Spree
         api_get :index
         option_values = json_response["variants"].last["option_values"]
         expect(option_values.first).to have_attributes([:name,
-                                                   :presentation,
-                                                   :option_type_name,
-                                                   :option_type_id])
+                                                        :presentation,
+                                                        :option_type_name,
+                                                        :option_type_id])
       end
 
       it "variants returned contain images data" do
-        variant.images.create!(:attachment => image("thinking-cat.jpg"))
+        variant.images.create!(attachment: image("thinking-cat.jpg"))
 
         api_get :index
 
         expect(json_response["variants"].last).to have_attributes([:images])
         expect(json_response['variants'].first['images'].first).to have_attributes([:attachment_file_name,
-                                                                                 :attachment_width,
-                                                                                 :attachment_height,
-                                                                                 :attachment_content_type,
-                                                                                 :mini_url,
-                                                                                 :small_url,
-                                                                                 :product_url,
-                                                                                 :large_url])
-
+                                                                                    :attachment_width,
+                                                                                    :attachment_height,
+                                                                                    :attachment_content_type,
+                                                                                    :mini_url,
+                                                                                    :small_url,
+                                                                                    :product_url,
+                                                                                    :large_url])
       end
 
       # Regression test for https://github.com/spree/spree/issues/2141
@@ -84,7 +82,7 @@ module Spree
         end
 
         it "is not returned even when show_deleted is passed" do
-          api_get :index, :show_deleted => true
+          api_get :index, show_deleted: true
           expect(json_response["variants"].count).to eq(0)
         end
       end
@@ -117,8 +115,8 @@ module Spree
 
       context "pagination" do
         it "can select the next page of variants" do
-          second_variant = create(:variant)
-          api_get :index, :page => 2, :per_page => 1
+          create(:variant)
+          api_get :index, 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)
@@ -142,7 +140,6 @@ module Spree
     end
 
     describe "#show" do
-
       subject { api_get :show, id: variant.to_param }
 
       it "can see a single variant" do
@@ -151,22 +148,22 @@ module Spree
         expect(json_response["stock_items"]).to be_present
         option_values = json_response["option_values"]
         expect(option_values.first).to have_attributes([:name,
-                                                   :presentation,
-                                                   :option_type_name,
-                                                   :option_type_id])
+                                                        :presentation,
+                                                        :option_type_name,
+                                                        :option_type_id])
       end
 
       it "can see a single variant with images" do
-        variant.images.create!(:attachment => image("thinking-cat.jpg"))
+        variant.images.create!(attachment: image("thinking-cat.jpg"))
 
         subject
 
         expect(json_response).to have_attributes(show_attributes + [:images])
         option_values = json_response["option_values"]
         expect(option_values.first).to have_attributes([:name,
-                                                   :presentation,
-                                                   :option_type_name,
-                                                   :option_type_id])
+                                                        :presentation,
+                                                        :option_type_name,
+                                                        :option_type_id])
       end
 
       context "variant doesn't have variant properties" do
@@ -204,24 +201,24 @@ module Spree
     end
 
     it "cannot create a new variant if not an admin" do
-      api_post :create, :variant => { :sku => "12345" }
+      api_post :create, variant: { sku: "12345" }
       assert_unauthorized!
     end
 
     it "cannot update a variant" do
-      api_put :update, :id => variant.to_param, :variant => { :sku => "12345" }
+      api_put :update, id: variant.to_param, variant: { sku: "12345" }
       assert_not_found!
     end
 
     it "cannot delete a variant" do
-      api_delete :destroy, :id => variant.to_param
+      api_delete :destroy, id: variant.to_param
       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 } }
+      let(:resource_scoping) { { product_id: variant.product.to_param } }
 
       # Test for https://github.com/spree/spree/issues/2141
       context "deleted variants" do
@@ -230,13 +227,13 @@ module Spree
         end
 
         it "are visible by admin" do
-          api_get :index, :show_deleted => 1
+          api_get :index, 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" }
+        api_post :create, 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,20 +241,28 @@ module Spree
         expect(variant.product.variants.count).to eq(1)
       end
 
+      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) }
+        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" }
+        api_put :update, id: variant.to_param, variant: { sku: "12345" }
         expect(response.status).to eq(200)
       end
 
       it "can delete a variant" do
-        api_delete :destroy, :id => variant.to_param
+        api_delete :destroy, id: variant.to_param
         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
-        expect(json_response["variants"].first.has_key?(:cost_price)).to eq true
+        expect(json_response["variants"].first.key?(:cost_price)).to eq true
       end
     end
   end

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ZonesController, :type => :controller do
+  describe Api::ZonesController, type: :controller do
     render_views
 
     let!(:attributes) { [:id, :name, :zone_members] }
 
     before do
       stub_authentication!
-      @zone = create(:zone, :name => 'Europe')
+      @zone = create(:zone, name: 'Europe')
     end
 
     it "gets list of zones" do
@@ -18,21 +18,21 @@ module Spree
 
     it 'can control the page size through a parameter' do
       create(:zone)
-      api_get :index, :per_page => 1
+      api_get :index, 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)
     end
 
     it 'can query the results through a paramter' do
-      expected_result = create(:zone, :name => 'South America')
-      api_get :index, :q => { :name_cont => 'south' }
+      expected_result = create(:zone, name: 'South America')
+      api_get :index, 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
+      api_get :show, id: @zone.id
       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
@@ -43,12 +43,12 @@ module Spree
 
       it "can create a new zone" do
         params = {
-          :zone => {
-            :name => "North Pole",
-            :zone_members => [
+          zone: {
+            name: "North Pole",
+            zone_members: [
               {
-                :zoneable_type => "Spree::Country",
-                :zoneable_id => 1
+                zoneable_type: "Spree::Country",
+                zoneable_id: 1
               }
             ]
           }
@@ -61,13 +61,13 @@ module Spree
       end
 
       it "updates a zone" do
-        params = { :id => @zone.id,
-          :zone => {
-            :name => "North Pole",
-            :zone_members => [
+        params = { id: @zone.id,
+          zone: {
+            name: "North Pole",
+            zone_members: [
               {
-                :zoneable_type => "Spree::Country",
-                :zoneable_id => 1
+                zoneable_type: "Spree::Country",
+                zoneable_id: 1
               }
             ]
           }
@@ -80,7 +80,7 @@ module Spree
       end
 
       it "can delete a zone" do
-        api_delete :destroy, :id => @zone.id
+        api_delete :destroy, id: @zone.id
         expect(response.status).to eq(204)
         expect { @zone.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end

data/spec/features/checkout_spec.rb

@@ -52,7 +52,7 @@ module Spree
       expect(response).to have_http_status(:created)
     end
 
-    def add_promotion(promotion)
+    def add_promotion(_promotion)
       expect {
         put "/api/orders/#{@order.number}/apply_coupon_code", coupon_code: promotion_code.value
       }.to change { @order.promotions.count }.by 1
@@ -92,7 +92,7 @@ module Spree
       expect(@order.completed_at).to be_a ActiveSupport::TimeWithZone
       expect(@order.item_total).to eq 600.00
       expect(@order.total).to eq 600.00
-      expect(@order.adjustment_total).to eq -10.00
+      expect(@order.adjustment_total).to eq(-10.00)
       expect(@order.shipment_total).to eq 10.00
       expect(@order.user).to eq @user
       expect(@order.bill_address).to eq bill_address

data/spec/models/spree/legacy_user_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe LegacyUser, :type => :model do
+  describe LegacyUser, type: :model do
     let(:user) { LegacyUser.new }
 
     it "can generate an API key" do
@@ -47,7 +47,7 @@ module Spree
         end
 
         context "roles_for_auto_api_key is defined" do
-          let (:role) { create(:role, name: 'hobbit') }
+          let(:role) { create(:role, name: 'hobbit') }
           let(:undesired_role) { create(:role, name: "foo") }
 
           before {
@@ -60,9 +60,9 @@ module Spree
         end
 
         context "for all roles" do
-          let (:role) { create(:role, name: 'hobbit') }
-          let (:other_role) { create(:role, name: 'wizard') }
-          let (:other_user) { create(:user) }
+          let(:role) { create(:role, name: 'hobbit') }
+          let(:other_role) { create(:role, name: 'wizard') }
+          let(:other_user) { create(:user) }
 
           before {
             user.clear_spree_api_key!