solidus_frontend 1.2.3 → 1.3.0.beta1

data/spec/controllers/spree/content_controller_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-describe Spree::ContentController, :type => :controller do
+describe Spree::ContentController, type: :controller do
   it "should display CVV page" do
     spree_get :cvv
     expect(response.response_code).to eq(200)

data/spec/controllers/spree/current_order_tracking_spec.rb

@@ -1,25 +1,26 @@
 require 'spec_helper'
 
-describe 'current order tracking', :type => :controller do
+describe 'current order tracking', type: :controller do
+  let!(:store) { create(:store) }
   let(:user) { create(:user) }
 
   controller(Spree::StoreController) do
     def index
-      render :nothing => true
+      render nothing: true
     end
   end
 
   let(:order) { FactoryGirl.create(:order) }
 
   it 'automatically tracks who the order was created by & IP address' do
-    allow(controller).to receive_messages(:try_spree_current_user => user)
+    allow(controller).to receive_messages(try_spree_current_user: user)
     get :index
     expect(controller.current_order(create_order_if_necessary: true).created_by).to eq controller.try_spree_current_user
     expect(controller.current_order.last_ip_address).to eq "0.0.0.0"
   end
 
   context "current order creation" do
-    before { allow(controller).to receive_messages(:try_spree_current_user => user) }
+    before { allow(controller).to receive_messages(try_spree_current_user: user) }
 
     it "doesn't create a new order out of the blue" do
       expect {
@@ -29,10 +30,10 @@ describe 'current order tracking', :type => :controller do
   end
 end
 
-describe Spree::OrdersController, :type => :controller do
+describe Spree::OrdersController, type: :controller do
   let(:user) { create(:user) }
 
-  before { allow(controller).to receive_messages(:try_spree_current_user => user) }
+  before { allow(controller).to receive_messages(try_spree_current_user: user) }
 
   describe Spree::OrdersController do
     it "doesn't create a new order out of the blue" do

data/spec/controllers/spree/home_controller_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe Spree::HomeController, :type => :controller do
+describe Spree::HomeController, type: :controller do
   it "provides current user to the searcher class" do
-    user = mock_model(Spree.user_class, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    allow(controller).to receive_messages :try_spree_current_user => user
+    user = mock_model(Spree.user_class, last_incomplete_spree_order: nil, spree_api_key: 'fake')
+    allow(controller).to receive_messages try_spree_current_user: user
     expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
     spree_get :index
     expect(response.status).to eq(200)

data/spec/controllers/spree/orders_controller_ability_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 module Spree
-  describe OrdersController, :type => :controller do
+  describe OrdersController, type: :controller do
     ORDER_TOKEN = 'ORDER_TOKEN'
 
+    let!(:store) { create(:store) }
     let(:user) { create(:user) }
     let(:guest_user) { create(:user) }
     let(:order) { Spree::Order.create }
@@ -17,29 +18,29 @@ module Spree
       let(:specified_order) { create(:order) }
 
       before do
-        allow(controller).to receive_messages :current_order => order
-        allow(controller).to receive_messages :spree_current_user => user
+        allow(controller).to receive_messages current_order: order
+        allow(controller).to receive_messages spree_current_user: user
       end
 
       context '#populate' do
         it 'should check if user is authorized for :edit' do
           expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_post :populate, :token => token
+          spree_post :populate, token: token
         end
         it "should check against the specified order" do
           expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_post :populate, :id => specified_order.number, :token => token
+          spree_post :populate, id: specified_order.number, token: token
         end
       end
 
       context '#edit' do
         it 'should check if user is authorized for :edit' do
           expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_get :edit, :token => token
+          spree_get :edit, token: token
         end
         it "should check against the specified order" do
           expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_get :edit, :id => specified_order.number, :token => token
+          spree_get :edit, id: specified_order.number, token: token
         end
       end
 
@@ -47,54 +48,54 @@ module Spree
         it 'should check if user is authorized for :edit' do
           allow(order).to receive :update_attributes
           expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_post :update, :order => { :email => "foo@bar.com" }, :token => token
+          spree_post :update, order: { email: "foo@bar.com" }, token: token
         end
         it "should check against the specified order" do
           allow(order).to receive :update_attributes
           expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_post :update, :order => { :email => "foo@bar.com" }, :id => specified_order.number, :token => token
+          spree_post :update, order: { email: "foo@bar.com" }, id: specified_order.number, token: token
         end
       end
 
       context '#empty' do
         it 'should check if user is authorized for :edit' do
           expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_post :empty, :token => token
+          spree_post :empty, token: token
         end
         it "should check against the specified order" do
           expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_post :empty, :id => specified_order.number, :token => token
+          spree_post :empty, id: specified_order.number, token: token
         end
       end
 
       context "#show" do
         it "should check against the specified order" do
           expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_get :show, :id => specified_order.number, :token => token
+          spree_get :show, id: specified_order.number, token: token
         end
       end
     end
 
     context 'when no authenticated user' do
-      let(:order) { create(:order, :number => 'R123') }
+      let(:order) { create(:order, number: 'R123') }
 
       context '#show' do
         context 'when token parameter present' do
           it 'always ooverride existing token when passing a new one' do
             cookies.signed[:guest_token] = "soo wrong"
-            spree_get :show, { :id => 'R123', :token => order.guest_token }
+            spree_get :show, { id: 'R123', token: order.guest_token }
             expect(cookies.signed[:guest_token]).to eq(order.guest_token)
           end
 
           it 'should store as guest_token in session' do
-            spree_get :show, {:id => 'R123', :token => order.guest_token }
+            spree_get :show, { id: 'R123', token: order.guest_token }
             expect(cookies.signed[:guest_token]).to eq(order.guest_token)
           end
         end
 
         context 'when no token present' do
           it 'should respond with 404' do
-            spree_get :show, {:id => 'R123'}
+            spree_get :show, { id: 'R123' }
             expect(response.code).to eq('404')
           end
         end

data/spec/controllers/spree/orders_controller_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
-describe Spree::OrdersController, :type => :controller do
+describe Spree::OrdersController, type: :controller do
+  let!(:store) { create(:store) }
   let(:user) { create(:user) }
 
   context "Order model mock" do
@@ -10,7 +11,7 @@ describe Spree::OrdersController, :type => :controller do
     let(:variant) { create(:variant) }
 
     before do
-      allow(controller).to receive_messages(:try_spree_current_user => user)
+      allow(controller).to receive_messages(try_spree_current_user: user)
     end
 
     context "#populate" do
@@ -75,13 +76,13 @@ describe Spree::OrdersController, :type => :controller do
         it "should render the edit view (on failure)" do
           # email validation is only after address state
           order.update_column(:state, "delivery")
-          spree_put :update, { :order => { :email => "" } }, { :order_id => order.id }
+          spree_put :update, { order: { email: "" } }, { order_id: order.id }
           expect(response).to render_template :edit
         end
 
         it "should redirect to cart path (on success)" do
           allow(order).to receive(:update_attributes).and_return true
-          spree_put :update, {}, {:order_id => 1}
+          spree_put :update, {}, { order_id: 1 }
           expect(response).to redirect_to(spree.cart_path)
         end
       end
@@ -108,7 +109,7 @@ describe Spree::OrdersController, :type => :controller do
       end
 
       it "cannot update a blank order" do
-        spree_put :update, :order => { :email => "foo" }
+        spree_put :update, order: { email: "foo" }
         expect(flash[:error]).to eq(Spree.t(:order_not_found))
         expect(response).to redirect_to(spree.root_path)
       end
@@ -116,18 +117,18 @@ describe Spree::OrdersController, :type => :controller do
   end
 
   context "line items quantity is 0" do
-    let(:order) { Spree::Order.create }
+    let(:order) { Spree::Order.create(store: store) }
     let(:variant) { create(:variant) }
     let!(:line_item) { order.contents.add(variant, 1) }
 
     before do
       allow(controller).to receive(:check_authorization)
-      allow(controller).to receive_messages(:current_order => order)
+      allow(controller).to receive_messages(current_order: order)
     end
 
     it "removes line items on update" do
       expect(order.line_items.count).to eq 1
-      spree_put :update, :order => { line_items_attributes: { "0" => { id: line_item.id, quantity: 0 } } }
+      spree_put :update, order: { line_items_attributes: { "0" => { id: line_item.id, quantity: 0 } } }
       expect(order.reload.line_items.count).to eq 0
     end
   end

data/spec/controllers/spree/orders_controller_transitions_spec.rb

@@ -5,17 +5,17 @@ Spree::Order.class_eval do
 end
 
 module Spree
-  describe OrdersController, :type => :controller do
+  describe OrdersController, type: :controller do
     # Regression test for https://github.com/spree/spree/issues/2004
     context "with a transition callback on first state" do
       let(:order) { Spree::Order.new }
 
       before do
-        allow(controller).to receive_messages :current_order => order
+        allow(controller).to receive_messages current_order: order
         expect(controller).to receive(:authorize!).at_least(:once).and_return(true)
 
-        first_state, _ = Spree::Order.checkout_steps.first
-        Spree::Order.state_machine.after_transition :to => first_state do |order|
+        first_state, = Spree::Order.checkout_steps.first
+        Spree::Order.state_machine.after_transition to: first_state do |order|
           order.did_transition = true
         end
       end
@@ -23,7 +23,7 @@ module Spree
       it "correctly calls the transition callback" do
         expect(order.did_transition).to be_nil
         order.line_items << FactoryGirl.create(:line_item)
-        spree_put :update, { :checkout => "checkout" }, { :order_id => 1}
+        spree_put :update, { checkout: "checkout" }, { order_id: 1 }
         expect(order.did_transition).to be true
       end
     end

data/spec/controllers/spree/products_controller_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
-describe Spree::ProductsController, :type => :controller do
-  let!(:product) { create(:product, :available_on => 1.year.from_now) }
+describe Spree::ProductsController, type: :controller do
+  let!(:product) { create(:product, available_on: 1.year.from_now) }
 
   # Regression test for https://github.com/spree/spree/issues/1390
   it "allows admins to view non-active products" do
-    allow(controller).to receive_messages :spree_current_user => mock_model(Spree.user_class, :has_spree_role? => true, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    spree_get :show, :id => product.to_param
+    allow(controller).to receive_messages spree_current_user: mock_model(Spree.user_class, has_spree_role?: true, last_incomplete_spree_order: nil, spree_api_key: 'fake')
+    spree_get :show, id: product.to_param
     expect(response.status).to eq(200)
   end
 
   it "cannot view non-active products" do
-    spree_get :show, :id => product.to_param
+    spree_get :show, id: product.to_param
     expect(response.status).to eq(404)
   end
 
   it "should provide the current user to the searcher class" do
-    user = mock_model(Spree.user_class, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    allow(controller).to receive_messages :spree_current_user => user
+    user = mock_model(Spree.user_class, last_incomplete_spree_order: nil, spree_api_key: 'fake')
+    allow(controller).to receive_messages spree_current_user: user
     expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
     spree_get :index
     expect(response.status).to eq(200)
@@ -25,12 +25,11 @@ describe Spree::ProductsController, :type => :controller do
 
   # Regression test for https://github.com/spree/spree/issues/2249
   it "doesn't error when given an invalid referer" do
-    current_user = mock_model(Spree.user_class, :has_spree_role? => true, :last_incomplete_spree_order => nil, :generate_spree_api_key! => nil)
-    allow(controller).to receive_messages :spree_current_user => current_user
+    current_user = mock_model(Spree.user_class, has_spree_role?: true, last_incomplete_spree_order: nil, generate_spree_api_key!: nil)
+    allow(controller).to receive_messages spree_current_user: current_user
     request.env['HTTP_REFERER'] = "not|a$url"
 
     # Previously a URI::InvalidURIError exception was being thrown
-    spree_get :show, :id => product.to_param
+    spree_get :show, id: product.to_param
   end
-
 end

data/spec/controllers/spree/taxons_controller_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe Spree::TaxonsController, :type => :controller do
+describe Spree::TaxonsController, type: :controller do
   it "should provide the current user to the searcher class" do
-    taxon = create(:taxon, :permalink => "test")
-    user = mock_model(Spree.user_class, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    allow(controller).to receive_messages :spree_current_user => user
+    taxon = create(:taxon, permalink: "test")
+    user = mock_model(Spree.user_class, last_incomplete_spree_order: nil, spree_api_key: 'fake')
+    allow(controller).to receive_messages spree_current_user: user
     expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
-    spree_get :show, :id => taxon.permalink
+    spree_get :show, id: taxon.permalink
     expect(response.status).to eq(200)
   end
 end

data/spec/features/address_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe "Address", type: :feature, inaccessible: true do
-  let!(:product) { create(:product, :name => "RoR Mug") }
-  let!(:order) { create(:order_with_totals, :state => 'cart') }
+  let!(:product) { create(:product, name: "RoR Mug") }
+  let!(:order) { create(:order_with_totals, state: 'cart') }
 
   stub_authorization!
 
@@ -18,43 +18,43 @@ describe "Address", type: :feature, inaccessible: true do
     @state_name_css = "##{address}_state_name"
   end
 
-  context "country requires state", :js => true, :focus => true do
-    let!(:canada) { create(:country, :name => "Canada", :states_required => true, :iso => "CA") }
-    let!(:uk) { create(:country, :name => "United Kingdom", :states_required => true, :iso => "GB") }
+  context "country requires state", js: true, focus: true do
+    let!(:canada) { create(:country, name: "Canada", states_required: true, iso: "CA") }
+    let!(:uk) { create(:country, name: "United Kingdom", states_required: true, iso: "GB") }
 
-    before { Spree::Config[:default_country_id] = uk.id }
+    before { Spree::Config[:default_country_iso] = uk.iso }
 
     context "but has no state" do
       it "shows the state input field" do
         click_button "Checkout"
 
-        select canada.name, :from => @country_css
+        select canada.name, from: @country_css
         expect(page).to have_no_css(@state_select_css)
         expect(page).to have_css("#{@state_name_css}.required")
       end
     end
 
     context "and has state" do
-      before { create(:state, :name => "Ontario", :country => canada) }
+      before { create(:state, name: "Ontario", country: canada) }
 
       it "shows the state collection selection" do
         click_button "Checkout"
 
-        select canada.name, :from => @country_css
+        select canada.name, from: @country_css
         expect(page).to have_no_css(@state_name_css)
         expect(page).to have_css("#{@state_select_css}.required")
       end
     end
 
     context "user changes to country without states required" do
-      let!(:france) { create(:country, :name => "France", :states_required => false, :iso => "FRA") }
+      let!(:france) { create(:country, name: "France", states_required: false, iso: "FR") }
 
       it "clears the state name" do
         click_button "Checkout"
-        select canada.name, :from => @country_css
+        select canada.name, from: @country_css
         page.find(@state_name_css).set("Toscana")
 
-        select france.name, :from => @country_css
+        select france.name, from: @country_css
 
         expect(page).to have_no_css(@state_name_css)
         expect(page).to have_no_css(@state_select_css)
@@ -62,13 +62,13 @@ describe "Address", type: :feature, inaccessible: true do
     end
   end
 
-  context "country does not require state", :js => true do
-    let!(:france) { create(:country, :name => "France", :states_required => false, :iso => "FRA") }
+  context "country does not require state", js: true do
+    let!(:france) { create(:country, name: "France", states_required: false, iso: "FR") }
 
     it "shows a disabled state input field" do
        click_button "Checkout"
 
-       select france.name, :from => @country_css
+       select france.name, from: @country_css
        expect(page).to have_no_css(@state_name_css)
        expect(page).to have_css("#{@state_select_css}[disabled]", visible: false)
     end

data/spec/features/automatic_promotion_adjustments_spec.rb

@@ -1,34 +1,34 @@
 require 'spec_helper'
 
-describe "Automatic promotions", :type => :feature, :js => true do
-  let!(:country) { create(:country, :name => "United States of America", :states_required => true) }
-  let!(:state) { create(:state, :name => "Alabama", :country => country) }
+describe "Automatic promotions", type: :feature, js: true do
+  let!(:store) { create(:store) }
+  let!(:country) { create(:country, name: "United States of America", states_required: true) }
+  let!(:state) { create(:state, name: "Alabama", country: country) }
   let!(:zone) { create(:zone) }
   let!(:shipping_method) { create(:shipping_method) }
   let!(:payment_method) { create(:check_payment_method) }
-  let!(:product) { create(:product, :name => "RoR Mug", :price => 20) }
+  let!(:product) { create(:product, name: "RoR Mug", price: 20) }
 
   let!(:promotion) do
     promotion = Spree::Promotion.create!(name: "$10 off when you spend more than $100", apply_automatically: true)
 
-   calculator = Spree::Calculator::FlatRate.new
-   calculator.preferred_amount = 10
+    calculator = Spree::Calculator::FlatRate.new
+    calculator.preferred_amount = 10
 
-   rule = Spree::Promotion::Rules::ItemTotal.create
-   rule.preferred_amount = 100
-   rule.save
+    rule = Spree::Promotion::Rules::ItemTotal.create
+    rule.preferred_amount = 100
+    rule.save
 
-   promotion.rules << rule
+    promotion.rules << rule
 
-   action = Spree::Promotion::Actions::CreateAdjustment.create
-   action.calculator = calculator
-   action.save
+    action = Spree::Promotion::Actions::CreateAdjustment.create
+    action.calculator = calculator
+    action.save
 
-   promotion.actions << action
+    promotion.actions << action
   end
 
   context "on the cart page" do
-
     before do
       visit spree.root_path
       click_link product.name
@@ -36,12 +36,12 @@ describe "Automatic promotions", :type => :feature, :js => true do
     end
 
     it "automatically applies the promotion once the order crosses the threshold" do
-      fill_in "order_line_items_attributes_0_quantity", :with => 10
+      fill_in "order_line_items_attributes_0_quantity", with: 10
       click_button "Update"
       expect(page).to have_content("Promotion ($10 off when you spend more than $100) -$10.00")
-      fill_in "order_line_items_attributes_0_quantity", :with => 1
+      fill_in "order_line_items_attributes_0_quantity", with: 1
       click_button "Update"
       expect(page).not_to have_content("Promotion ($10 off when you spend more than $100) -$10.00")
     end
   end
-end
+end