solidus_backend 1.2.3 → 1.3.0.beta1

data/spec/controllers/spree/admin/general_settings_controller_spec.rb

@@ -4,7 +4,7 @@ describe Spree::Admin::GeneralSettingsController, type: :controller do
   let(:user) { create(:user) }
 
   before do
-    allow(controller).to receive_messages :spree_current_user => user
+    allow(controller).to receive_messages spree_current_user: user
     user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
   end
 

data/spec/controllers/spree/admin/missing_products_controller_spec.rb

@@ -4,15 +4,13 @@ require 'spec_helper'
 # the load_resource filter in Spree::Admin::ResourceController is prepended to the filter chain
 # this means this call is triggered before the authorize_admin call and in this case
 # the load_resource filter halts the request meaning authorize_admin is not called at all.
-describe Spree::Admin::ProductsController, :type => :controller do
+describe Spree::Admin::ProductsController, type: :controller do
   stub_authorization!
 
   # Regression test for GH https://github.com/spree/spree/issues/538
   it "cannot find a non-existent product" do
-    spree_get :edit, :id => "non-existent-product"
+    spree_get :edit, id: "non-existent-product"
     expect(response).to redirect_to(spree.admin_products_path)
     expect(flash[:error]).to eql("Product is not found")
   end
 end
-
-

data/spec/controllers/spree/admin/orders/customer_details_controller_spec.rb

@@ -3,7 +3,6 @@ require "cancan"
 require "spree/testing_support/bar_ability"
 
 describe Spree::Admin::Orders::CustomerDetailsController, type: :controller do
-
   context "with authorization" do
     stub_authorization!
 

data/spec/controllers/spree/admin/orders_controller_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 require 'cancan'
 require 'spree/testing_support/bar_ability'
 
-describe Spree::Admin::OrdersController, :type => :controller do
-
+describe Spree::Admin::OrdersController, type: :controller do
+  let!(:store) { create(:store) }
   context "with authorization" do
     stub_authorization!
 
@@ -23,7 +23,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
         total:           100,
         number:          'R123456789',
         all_adjustments: adjustments,
-        ship_address: mock_model(Spree::Address),
+        ship_address: mock_model(Spree::Address)
       )
     end
 
@@ -60,7 +60,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
 
     context "pagination" do
       it "can page through the orders" do
-        spree_get :index, :page => 2, :per_page => 10
+        spree_get :index, page: 2, per_page: 10
         expect(assigns[:orders].offset_value).to eq(10)
         expect(assigns[:orders].limit_value).to eq(10)
       end
@@ -70,7 +70,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
     context "#new" do
       let(:user) { create(:user) }
       before do
-        allow(controller).to receive_messages :spree_current_user => user
+        allow(controller).to receive_messages spree_current_user: user
       end
 
       it "imports a new order and sets the current user as a creator" do
@@ -96,7 +96,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
 
       context "when a user_id is passed as a parameter" do
         let(:user)  { mock_model(Spree.user_class) }
-        before { allow(Spree.user_class).to receive_messages :find_by_id => user }
+        before { allow(Spree.user_class).to receive_messages find_by_id: user }
 
         it "imports a new order and assigns the user to the order" do
           expect(Spree::Core::Importer::Order).to receive(:import)
@@ -115,27 +115,27 @@ describe Spree::Admin::OrdersController, :type => :controller do
     # Regression test for https://github.com/spree/spree/issues/3684
     context "#edit" do
       it "does not refresh rates if the order is completed" do
-        allow(order).to receive_messages :completed? => true
+        allow(order).to receive_messages completed?: true
         expect(order).not_to receive :refresh_shipment_rates
-        spree_get :edit, :id => order.number
+        spree_get :edit, id: order.number
       end
 
       it "does refresh the rates if the order is incomplete" do
-        allow(order).to receive_messages :completed? => false
+        allow(order).to receive_messages completed?: false
         expect(order).to receive :refresh_shipment_rates
-        spree_get :edit, :id => order.number
+        spree_get :edit, id: order.number
       end
 
       context "when order does not have a ship address" do
         before do
-          allow(order).to receive_messages :ship_address => nil
+          allow(order).to receive_messages ship_address: nil
         end
 
         context 'when order_bill_address_used is true' do
           before { Spree::Config[:order_bill_address_used] = true }
 
           it "should redirect to the customer details page" do
-            spree_get :edit, :id => order.number
+            spree_get :edit, id: order.number
             expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
           end
         end
@@ -144,7 +144,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
           before { Spree::Config[:order_bill_address_used] = false }
 
           it "should redirect to the customer details page" do
-            spree_get :edit, :id => order.number
+            spree_get :edit, id: order.number
             expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
           end
         end
@@ -180,14 +180,14 @@ describe Spree::Admin::OrdersController, :type => :controller do
 
           it 'messages and redirects' do
             subject
-            expect(flash[:error]) == order.errors.full_messages
+            expect(flash[:error]).to eq order.errors.full_messages
             expect(response).to redirect_to(spree.confirm_admin_order_path(order))
           end
         end
       end
 
       context 'when already completed' do
-        before { allow(order).to receive_messages :completed? => true }
+        before { allow(order).to receive_messages completed?: true }
 
         it 'messages and redirects' do
           subject
@@ -280,7 +280,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
       let(:user) { create(:user) }
 
       before do
-        allow(controller).to receive_messages :spree_current_user => user
+        allow(controller).to receive_messages spree_current_user: user
         user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
 
         create(:completed_order_with_totals)
@@ -291,7 +291,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
         spree_get :index, q: {
           line_items_variant_id_in: Spree::Order.first.variants.map(&:id)
         }
-        expect(assigns[:orders].map { |o| o.number }.count).to eq 1
+        expect(assigns[:orders].map(&:number).count).to eq 1
       end
     end
 
@@ -337,49 +337,36 @@ describe Spree::Admin::OrdersController, :type => :controller do
   end
 
   context '#authorize_admin' do
-    let(:user) { create(:user) }
-    let(:order) { create(:completed_order_with_totals, :number => 'R987654321') }
+    let!(:user) { create(:user) }
+    let!(:order) { create(:completed_order_with_totals, number: 'R987654321') }
 
     before do
-      allow(Spree::Order).to receive_messages :find_by_number! => order
-      allow(controller).to receive_messages :spree_current_user => user
+      allow(controller).to receive_messages spree_current_user: user
     end
 
     it 'should grant access to users with an admin role' do
       user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-      spree_post :index
+      spree_get :index
       expect(response).to render_template :index
     end
 
     it 'should grant access to users with an bar role' do
       user.spree_roles << Spree::Role.find_or_create_by(name: 'bar')
       Spree::Ability.register_ability(BarAbility)
-      spree_post :index
+      spree_get :index
       expect(response).to render_template :index
       Spree::Ability.remove_ability(BarAbility)
     end
 
-    it 'should deny access to users with an bar role' do
-      allow(order).to receive(:update_attributes).and_return true
-      allow(order).to receive(:user).and_return Spree.user_class.new
-      allow(order).to receive(:token).and_return nil
-      user.spree_roles.clear
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'bar')
-      Spree::Ability.register_ability(BarAbility)
-      spree_put :update, { :id => 'R123' }
-      expect(response).to redirect_to('/unauthorized')
-      Spree::Ability.remove_ability(BarAbility)
-    end
-
     it 'should deny access to users without an admin role' do
-      allow(user).to receive_messages :has_spree_role? => false
-      spree_post :index
+      allow(user).to receive_messages has_spree_role?: false
+      spree_get :index
       expect(response).to redirect_to('/unauthorized')
     end
 
     context 'with only permissions on Order' do
-      stub_authorization! do |ability|
-        can [:admin, :manage], Spree::Order, :number => 'R987654321'
+      stub_authorization! do |_ability|
+        can [:admin, :manage], Spree::Order, number: 'R987654321'
       end
 
       it 'should restrict returned order(s) on index when using OrderSpecificAbility' do
@@ -388,7 +375,7 @@ describe Spree::Admin::OrdersController, :type => :controller do
         3.times { create(:completed_order_with_totals) }
         expect(Spree::Order.complete.count).to eq 4
 
-        allow(user).to receive_messages :has_spree_role? => false
+        allow(user).to receive_messages has_spree_role?: false
         spree_get :index
         expect(response).to render_template :index
         expect(assigns['orders'].size).to eq 1
@@ -406,55 +393,4 @@ describe Spree::Admin::OrdersController, :type => :controller do
       }.to raise_error ActiveRecord::RecordNotFound
     end
   end
-
-  describe "#update" do
-    stub_authorization!
-
-    let(:order) { create(:order) }
-    let(:payload) do
-      {
-        id: order.number,
-        order: { email: "foo@bar.com" }
-      }
-    end
-
-    before do
-      allow(order.contents).to receive(:update_cart)
-      expect(Spree::Order).to receive(:find_by_number!) { order }
-    end
-    subject { spree_put :update, payload }
-
-    it "attempts to update the order" do
-      expect(order.contents).to receive(:update_cart).with(payload[:order])
-      subject
-    end
-
-    context "the order is already completed" do
-      before { allow(order).to receive(:completed?) { true } }
-
-      it "renders the edit route" do
-        subject
-        expect(response).to render_template(:edit)
-      end
-    end
-
-    context "the order is not completed" do
-      before { allow(order).to receive(:completed?) { false } }
-
-      it "redirects to the customer path" do
-        subject
-        expect(response).to redirect_to(spree.admin_order_customer_path(order))
-      end
-    end
-
-    context "the order has no line items" do
-      let(:order) { Spree::Order.new(:number => "1234") }
-
-      it "includes an error on the order" do
-        subject
-        expect(order.errors[:line_items]).to include Spree.t('errors.messages.blank')
-      end
-    end
-
-  end
 end

data/spec/controllers/spree/admin/payment_methods_controller_spec.rb

@@ -2,33 +2,39 @@ require 'spec_helper'
 
 module Spree
   class GatewayWithPassword < PaymentMethod
-    preference :password, :string, :default => "password"
+    preference :password, :string, default: "password"
   end
 
-  describe Admin::PaymentMethodsController, :type => :controller do
+  describe Admin::PaymentMethodsController, type: :controller do
     stub_authorization!
 
-    let(:payment_method) { GatewayWithPassword.create!(:name => "Bogus", :preferred_password => "haxme") }
+    context "GatewayWithPassword" do
+      let(:payment_method) { GatewayWithPassword.create!(name: "Bogus", preferred_password: "haxme") }
 
-    # regression test for https://github.com/spree/spree/issues/2094
-    it "does not clear password on update" do
-      expect(payment_method.preferred_password).to eq("haxme")
-      spree_put :update, :id => payment_method.id, :payment_method => { :type => payment_method.class.to_s, :preferred_password => "" }
-      expect(response).to redirect_to(spree.edit_admin_payment_method_path(payment_method))
+      before do
+        allow(Rails.application.config.spree).to receive(:payment_methods).and_return([GatewayWithPassword])
+      end
+
+      # regression test for https://github.com/spree/spree/issues/2094
+      it "does not clear password on update" do
+        expect(payment_method.preferred_password).to eq("haxme")
+        spree_put :update, id: payment_method.id, payment_method: { type: payment_method.class.to_s, preferred_password: "" }
+        expect(response).to redirect_to(spree.edit_admin_payment_method_path(payment_method))
 
-      payment_method.reload
-      expect(payment_method.preferred_password).to eq("haxme")
+        payment_method.reload
+        expect(payment_method.preferred_password).to eq("haxme")
+      end
     end
 
     context "tries to save invalid payment" do
       it "doesn't break, responds nicely" do
-        spree_post :create, :payment_method => { :name => "", :type => "Spree::Gateway::Bogus" }
+        spree_post :create, payment_method: { name: "", type: "Spree::Gateway::Bogus" }
       end
     end
 
     it "can create a payment method of a valid type" do
       expect {
-        spree_post :create, :payment_method => { :name => "Test Method", :type => "Spree::Gateway::Bogus" }
+        spree_post :create, payment_method: { name: "Test Method", type: "Spree::Gateway::Bogus" }
       }.to change(Spree::PaymentMethod, :count).by(1)
 
       expect(response).to be_redirect
@@ -37,11 +43,30 @@ module Spree
 
     it "can not create a payment method of an invalid type" do
       expect {
-        spree_post :create, :payment_method => { :name => "Invalid Payment Method", :type => "Spree::InvalidType" }
+        spree_post :create, payment_method: { name: "Invalid Payment Method", type: "Spree::InvalidType" }
       }.to change(Spree::PaymentMethod, :count).by(0)
 
       expect(response).to be_redirect
       expect(response).to redirect_to spree.new_admin_payment_method_path
     end
+
+    describe "GET index" do
+      subject { spree_get :index }
+
+      let!(:first_method) { GatewayWithPassword.create! name: "First", preferred_password: "1235" }
+      let!(:second_method) { GatewayWithPassword.create! name: "Second", preferred_password: "1235" }
+
+      before do
+        second_method.move_to_top
+      end
+
+      it { is_expected.to be_success }
+      it { is_expected.to render_template "index"  }
+
+      it "respects the order of payment methods by position" do
+        subject
+        expect(assigns(:payment_methods).to_a).to eql([second_method, first_method])
+      end
+    end
   end
 end

data/spec/controllers/spree/admin/payments_controller_spec.rb

@@ -2,127 +2,132 @@ require 'spec_helper'
 
 module Spree
   module Admin
-    describe PaymentsController, :type => :controller do
+    describe PaymentsController, type: :controller do
       before do
-        allow(controller).to receive_messages :spree_current_user => user
+        allow(controller).to receive_messages spree_current_user: user
       end
 
       let(:user) { create(:admin_user) }
       let(:order) { create(:order) }
 
-      context "with a valid credit card" do
-        let(:order) { create(:order_with_line_items, :state => "payment") }
-        let(:payment_method) { create(:credit_card_payment_method, :display_on => "back_end") }
-        let(:attributes) do
-          {
-            :order_id => order.number,
-            :card => "new",
-            :payment => {
-              :amount => order.total,
-              :payment_method_id => payment_method.id.to_s,
-              :source_attributes => {
-                :name => "Test User",
-                :number => "4111 1111 1111 1111",
-                :expiry => "09 / #{Time.current.year + 1}",
-                :verification_value => "123"
+      describe '#create' do
+        context "with a valid credit card" do
+          let(:order) { create(:order_with_line_items, state: "payment") }
+          let(:payment_method) { create(:credit_card_payment_method, display_on: "back_end") }
+          let(:attributes) do
+            {
+              order_id: order.number,
+              card: "new",
+              payment: {
+                amount: order.total,
+                payment_method_id: payment_method.id.to_s,
+                source_attributes: {
+                  name: "Test User",
+                  number: "4111 1111 1111 1111",
+                  expiry: "09 / #{Time.current.year + 1}",
+                verification_value: "123"
+                }
               }
             }
-          }
-        end
-
-        before do
-          spree_post :create, attributes
-        end
-
-        it "should process payment correctly" do
-          expect(order.payments.count).to eq(1)
-          expect(order.payments.last.state).to eq 'checkout'
-          expect(response).to redirect_to(spree.admin_order_payments_path(order))
-          expect(order.reload.state).to eq('confirm')
-        end
-
-        context 'with credit card address fields' do
-          let(:address) { build(:address) }
-
-          let(:attributes) do
-            attrs = super()
-            attrs[:payment][:source_attributes][:address_attributes] = address_attributes
-            attrs
           end
 
-          let(:address_attributes) do
-            {
-              'firstname' => address.firstname,
-              'lastname' => address.lastname,
-              'address1' => address.address1,
-              'city' => address.city,
-              'country_id' => address.country_id,
-              'state_id' => address.state_id,
-              'zipcode' => address.zipcode,
-              'phone' => address.phone,
-            }
+          before do
+            spree_post :create, attributes
           end
 
-          it 'associates the address' do
+          it "should process payment correctly" do
             expect(order.payments.count).to eq(1)
-            credit_card = order.payments.last.source
-            expect(credit_card.address.attributes).to include(address_attributes)
+            expect(order.payments.last.state).to eq 'checkout'
+            expect(response).to redirect_to(spree.admin_order_payments_path(order))
+            expect(order.reload.state).to eq('confirm')
           end
-        end
-      end
 
-      # Regression test for https://github.com/spree/spree/issues/3233
-      context "with a backend payment method" do
-        before do
-          @payment_method = create(:check_payment_method, :display_on => "back_end")
-        end
+          context 'with credit card address fields' do
+            let(:address) { build(:address) }
 
-        it "loads backend payment methods" do
-          spree_get :new, :order_id => order.number
-          expect(response.status).to eq(200)
-          expect(assigns[:payment_methods]).to include(@payment_method)
+            let(:attributes) do
+              attrs = super()
+              attrs[:payment][:source_attributes][:address_attributes] = address_attributes
+              attrs
+            end
+
+            let(:address_attributes) do
+              {
+                'firstname' => address.firstname,
+                'lastname' => address.lastname,
+                'address1' => address.address1,
+                'city' => address.city,
+                'country_id' => address.country_id,
+                'state_id' => address.state_id,
+                'zipcode' => address.zipcode,
+                'phone' => address.phone
+              }
+            end
+
+            it 'associates the address' do
+              expect(order.payments.count).to eq(1)
+              credit_card = order.payments.last.source
+              expect(credit_card.address.attributes).to include(address_attributes)
+            end
+          end
         end
       end
 
-      context "order has billing address" do
-        before do
-          order.bill_address = create(:address)
-          order.save!
-        end
+      describe '#new' do
+        # Regression test for https://github.com/spree/spree/issues/3233
+        context "with a backend payment method" do
+          before do
+            @payment_method = create(:check_payment_method, display_on: "back_end")
+          end
 
-        context "order does not have payments" do
-          it "redirect to new payments page" do
-            spree_get :index, { amount: 100, order_id: order.number }
-            expect(response).to redirect_to(spree.new_admin_order_payment_path(order))
+          it "loads backend payment methods" do
+            spree_get :new, order_id: order.number
+            expect(response.status).to eq(200)
+            expect(assigns[:payment_methods]).to include(@payment_method)
           end
         end
+      end
 
-        context "order has payments" do
+      describe '#index' do
+        context "order has billing address" do
           before do
-            order.payments << create(:payment, amount: order.total, order: order, state: 'completed')
+            order.bill_address = create(:address)
+            order.save!
           end
 
-          it "shows the payments page" do
-            spree_get :index, { amount: 100, order_id: order.number }
-            expect(response.code).to eq "200"
+          context "order does not have payments" do
+            it "redirect to new payments page" do
+              spree_get :index, { amount: 100, order_id: order.number }
+              expect(response).to redirect_to(spree.new_admin_order_payment_path(order))
+            end
           end
-        end
 
-      end
+          context "order has payments" do
+            before do
+              order.payments << create(:payment, amount: order.total, order: order, state: 'completed')
+            end
 
-      context "order does not have a billing address" do
-        before do
-          order.bill_address = nil
-          order.save
+            it "shows the payments page" do
+              spree_get :index, { amount: 100, order_id: order.number }
+              expect(response.code).to eq "200"
+            end
+          end
         end
 
-        it "should redirect to the customer details page" do
-          spree_get :index, { amount: 100, order_id: order.number }
-          expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
+        context "order does not have a billing address" do
+          before do
+            order.bill_address = nil
+            order.save
+          end
+
+          it "should redirect to the customer details page" do
+            spree_get :index, { amount: 100, order_id: order.number }
+            expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
+          end
         end
       end
 
-      describe 'fire' do
+      describe '#fire' do
         describe 'authorization' do
           let(:payment) { create(:payment, state: 'checkout') }
           let(:order) { payment.order }
@@ -131,7 +136,7 @@ module Spree
             class CaptureAllowedAbility
               include CanCan::Ability
 
-              def initialize(user)
+              def initialize(_user)
                 can :capture, Spree::Payment
               end
             end
@@ -145,31 +150,30 @@ module Spree
                 spree_post(:fire, id: payment.to_param, e: 'capture', order_id: order.to_param)
               }.to change { payment.reload.state }.from('checkout').to('completed')
             end
-          end
 
-          context 'the user is not authorized' do
-            class CaptureNotAllowedAbility
-              include CanCan::Ability
+            context 'the user is not authorized' do
+              class CaptureNotAllowedAbility
+                include CanCan::Ability
 
-              def initialize(user)
-                cannot :capture, Spree::Payment
+                def initialize(_user)
+                  cannot :capture, Spree::Payment
+                end
               end
-            end
 
-            before do
-              Spree::Ability.register_ability(CaptureNotAllowedAbility)
-            end
+              before do
+                Spree::Ability.register_ability(CaptureNotAllowedAbility)
+              end
 
-            it 'does not allow the action' do
-              expect {
-                spree_post(:fire, id: payment.to_param, e: 'capture', order_id: order.to_param)
-              }.to_not change { payment.reload.state }
-              expect(flash[:error]).to eq('Authorization Failure')
+              it 'does not allow the action' do
+                expect {
+                  spree_post(:fire, id: payment.to_param, e: 'capture', order_id: order.to_param)
+                }.to_not change { payment.reload.state }
+                expect(flash[:error]).to eq('Authorization Failure')
+              end
             end
           end
         end
       end
-
     end
   end
 end