solidus_core 2.10.0 → 2.11.0

data/spec/models/spree/payment_method_spec.rb

@@ -1,408 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PaymentMethod, type: :model do
-  let!(:payment_method_nil_display) do
-    create(:payment_method, {
-      active: true,
-      available_to_users: true,
-      available_to_admin: true
-    })
-  end
-  let!(:payment_method_both_display) do
-    create(:payment_method, {
-      active: true,
-      available_to_users: true,
-      available_to_admin: true
-    })
-  end
-  let!(:payment_method_front_display) do
-    create(:payment_method, {
-      active: true,
-      available_to_users: true,
-      available_to_admin: false
-    })
-  end
-  let!(:payment_method_back_display) do
-    create(:payment_method, {
-      active: true,
-      available_to_users: false,
-      available_to_admin: true
-    })
-  end
-
-  describe "available_to_[<users>, <admin>, <store>]" do
-    context "when searching for payment methods available to users and admins" do
-      subject { Spree::PaymentMethod.available_to_users.available_to_admin }
-
-      it { is_expected.to contain_exactly(payment_method_both_display, payment_method_nil_display) }
-
-      context "with a store" do
-        let!(:extra_payment_method_both_display) do
-          create(:payment_method, {
-            active: true,
-            available_to_users: true,
-            available_to_admin: true
-          })
-        end
-        let!(:store_1) do
-          create(:store, payment_methods: [
-            payment_method_nil_display,
-            payment_method_both_display,
-            payment_method_front_display,
-            payment_method_back_display
-          ])
-        end
-
-        subject { Spree::PaymentMethod.available_to_store( store_1 ).available_to_users.available_to_admin }
-
-        it { is_expected.to contain_exactly(payment_method_both_display, payment_method_nil_display) }
-
-        context "when the store has no payment methods" do
-          subject { Spree::PaymentMethod.available_to_store(store_without_payment_methods) }
-          let!(:store_without_payment_methods) do
-            create(:store, payment_methods: [])
-          end
-
-          it "returns all payment methods" do
-            expect(subject.all.size).to eq(5)
-          end
-
-          it "is further scopeable for admin availability" do
-            expect(subject.available_to_admin).not_to include(payment_method_front_display)
-          end
-
-          it "is further scopeable for users availability" do
-            expect(subject.available_to_users).not_to include(payment_method_back_display)
-          end
-        end
-      end
-    end
-
-    context "when searching for payment methods available to users" do
-      subject { Spree::PaymentMethod.available_to_users }
-
-      it { is_expected.to contain_exactly(payment_method_front_display, payment_method_both_display, payment_method_nil_display) }
-    end
-
-    context "when searching for payment methods available to admin" do
-      subject { Spree::PaymentMethod.available_to_admin }
-
-      it { is_expected.to contain_exactly(payment_method_back_display, payment_method_both_display, payment_method_nil_display) }
-    end
-
-    context "when searching for payment methods available to a store" do
-      subject { Spree::PaymentMethod.available_to_store(store) }
-
-      context "when the store is nil" do
-        let(:store) { nil }
-        it "raises an argument error" do
-          expect { subject }.to raise_error(ArgumentError, "You must provide a store")
-        end
-      end
-
-      context "when the store exists" do
-        let(:store) { create(:store, payment_methods: [payment_method_back_display]) }
-        it { is_expected.to contain_exactly(payment_method_back_display) }
-      end
-    end
-  end
-
-  describe ".available" do
-    it "should have 4 total methods" do
-      expect(Spree::PaymentMethod.all.size).to eq(4)
-    end
-
-    it "should return all methods available to front-end/back-end when no parameter is passed" do
-      Spree::Deprecation.silence do
-        expect(Spree::PaymentMethod.available.size).to eq(2)
-      end
-    end
-
-    it "should return all methods available to front-end/back-end when passed :both" do
-      Spree::Deprecation.silence do
-        expect(Spree::PaymentMethod.available(:both).size).to eq(2)
-      end
-    end
-
-    it "should return all methods available to front-end when passed :front_end" do
-      Spree::Deprecation.silence do
-        expect(Spree::PaymentMethod.available(:front_end).size).to eq(3)
-      end
-    end
-
-    it "should return all methods available to back-end when passed :back_end" do
-      Spree::Deprecation.silence do
-        expect(Spree::PaymentMethod.available(:back_end).size).to eq(3)
-      end
-    end
-
-    context 'with stores' do
-      let!(:store_1) do
-        create(:store,
-          payment_methods: [
-            payment_method_nil_display,
-            payment_method_both_display,
-            payment_method_front_display,
-            payment_method_back_display
-          ])
-      end
-
-      let!(:store_2) do
-        create(:store, payment_methods: [store_2_payment_method])
-      end
-
-      let!(:store_3) { create(:store) }
-
-      let!(:store_2_payment_method) { create(:payment_method, active: true) }
-      let!(:no_store_payment_method) { create(:payment_method, active: true) }
-
-      context 'when the store is specified' do
-        context 'when the store has payment methods' do
-          it 'finds the payment methods for the store' do
-            Spree::Deprecation.silence do
-              expect(Spree::PaymentMethod.available(:both, store: store_1)).to match_array(
-                [payment_method_nil_display, payment_method_both_display]
-              )
-            end
-          end
-        end
-
-        context "when store does not have payment_methods" do
-          it "returns all matching payment methods regardless of store" do
-            Spree::Deprecation.silence do
-              expect(Spree::PaymentMethod.available(:both)).to match_array(
-                [
-                  payment_method_nil_display,
-                  payment_method_both_display,
-                  store_2_payment_method,
-                  no_store_payment_method
-                ]
-              )
-            end
-          end
-        end
-      end
-
-      context 'when the store is not specified' do
-        it "returns all matching payment methods regardless of store" do
-          Spree::Deprecation.silence do
-            expect(Spree::PaymentMethod.available(:both)).to match_array(
-              [
-                payment_method_nil_display,
-                payment_method_both_display,
-                store_2_payment_method,
-                no_store_payment_method
-              ]
-            )
-          end
-        end
-      end
-    end
-  end
-
-  describe '#auto_capture?' do
-    class TestGateway < Spree::PaymentMethod::CreditCard
-      def gateway_class
-        Provider
-      end
-    end
-
-    let(:gateway) { TestGateway.new }
-
-    subject { gateway.auto_capture? }
-
-    context 'when auto_capture is nil' do
-      before(:each) do
-        expect(Spree::Config).to receive('[]').with(:auto_capture).and_return(auto_capture)
-      end
-
-      context 'and when Spree::Config[:auto_capture] is false' do
-        let(:auto_capture) { false }
-
-        it 'should be false' do
-          expect(gateway.auto_capture).to be_nil
-          expect(subject).to be false
-        end
-      end
-
-      context 'and when Spree::Config[:auto_capture] is true' do
-        let(:auto_capture) { true }
-
-        it 'should be true' do
-          expect(gateway.auto_capture).to be_nil
-          expect(subject).to be true
-        end
-      end
-    end
-
-    context 'when auto_capture is not nil' do
-      before(:each) do
-        gateway.auto_capture = auto_capture
-      end
-
-      context 'and is true' do
-        let(:auto_capture) { true }
-
-        it 'should be true' do
-          expect(subject).to be true
-        end
-      end
-
-      context 'and is false' do
-        let(:auto_capture) { false }
-
-        it 'should be true' do
-          expect(subject).to be false
-        end
-      end
-    end
-  end
-
-  describe "display_on=" do
-    around do |example|
-      Spree::Deprecation.silence do
-        example.run
-      end
-    end
-    let(:payment) { described_class.new(display_on: display_on) }
-
-    context 'with empty string' do
-      let(:display_on) { "" }
-
-      it "should be available to admins" do
-        expect(payment.available_to_admin).to be true
-      end
-
-      it "should be available to users" do
-        expect(payment.available_to_users).to be true
-      end
-
-      it "should have the same value for display_on" do
-        expect(payment.display_on).to eq ""
-      end
-    end
-
-    context 'with "back_end"' do
-      let(:display_on) { "back_end" }
-
-      it "should be available to admins" do
-        expect(payment.available_to_admin).to be true
-      end
-
-      it "should not be available to users" do
-        expect(payment.available_to_users).to be false
-      end
-
-      it "should have the same value for display_on" do
-        expect(payment.display_on).to eq "back_end"
-      end
-    end
-
-    context 'with "front_end"' do
-      let(:display_on) { "front_end" }
-
-      it "should be available to admins" do
-        expect(payment.available_to_admin).to be false
-      end
-
-      it "should not be available to users" do
-        expect(payment.available_to_users).to be true
-      end
-
-      it "should have the same value for display_on" do
-        expect(payment.display_on).to eq "front_end"
-      end
-    end
-
-    context 'with any other string' do
-      let(:display_on) { "foobar" }
-
-      it "should be available to admins" do
-        expect(payment.available_to_admin).to be false
-      end
-
-      it "should not be available to users" do
-        expect(payment.available_to_users).to be false
-      end
-
-      it "should have none for display_on" do
-        expect(payment.display_on).to eq "none"
-      end
-    end
-  end
-
-  describe 'ActiveMerchant methods' do
-    class PaymentGateway
-      def initialize(options)
-      end
-
-      def authorize; 'authorize'; end
-
-      def purchase; 'purchase'; end
-
-      def capture; 'capture'; end
-
-      def void; 'void'; end
-
-      def credit; 'credit'; end
-    end
-
-    class TestPaymentMethod < Spree::PaymentMethod
-      def gateway_class
-        PaymentGateway
-      end
-    end
-
-    let(:payment_method) { TestPaymentMethod.new }
-
-    it "passes through authorize" do
-      expect(payment_method.authorize).to eq 'authorize'
-    end
-
-    it "passes through purchase" do
-      expect(payment_method.purchase).to eq 'purchase'
-    end
-
-    it "passes through capture" do
-      expect(payment_method.capture).to eq 'capture'
-    end
-
-    it "passes through void" do
-      expect(payment_method.void).to eq 'void'
-    end
-
-    it "passes through credit" do
-      expect(payment_method.credit).to eq 'credit'
-    end
-  end
-
-  describe 'model_name.human' do
-    context 'PaymentMethod itself' do
-      it "returns i18n value" do
-        expect(Spree::PaymentMethod.model_name.human).to eq('Payment Method')
-      end
-    end
-
-    context 'A subclass with no i18n key' do
-      let!(:klass) { stub_const("MyGem::SomeClass", Class.new(described_class)) }
-
-      it "returns default humanized value" do
-        expect(klass.model_name.human).to eq('Some class')
-      end
-    end
-  end
-
-  describe "::DISPLAY" do
-    it "returns [:both, :front_end, :back_end]" do
-      # Emits deprecation warning on first reference
-      Spree::Deprecation.silence do
-        expect(Spree::PaymentMethod::DISPLAY).to eq([:both, :front_end, :back_end])
-      end
-
-      # but not subsequent
-      expect(Spree::PaymentMethod::DISPLAY).to eq([:both, :front_end, :back_end])
-    end
-  end
-end