solidus_core 2.10.5 → 2.11.0

data/spec/models/spree/payment/cancellation_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Payment::Cancellation do
-  describe '#initialize' do
-    it 'has default refund reason' do
-      expect(subject.reason).to eq Spree::Payment::Cancellation::DEFAULT_REASON
-    end
-
-    context 'with reason given' do
-      subject { described_class.new(reason: 'My custom reason') }
-
-      it 'has this as refund reason' do
-        expect(subject.reason).to eq 'My custom reason'
-      end
-    end
-  end
-
-  describe '#cancel' do
-    subject { described_class.new.cancel(payment) }
-
-    let(:payment_method) { create(:payment_method) }
-    let(:payment) { create(:payment, payment_method: payment_method, amount: 10) }
-
-    context 'if the payment_method responds to `try_void`' do
-      context 'if payment method returns void response' do
-        before do
-          expect(payment_method).to receive(:try_void).with(payment) { double }
-        end
-
-        it 'handles the void' do
-          expect(payment).to receive(:handle_void_response)
-          subject
-        end
-      end
-
-      context 'if payment method rejects the void' do
-        before do
-          expect(payment_method).to receive(:try_void).with(payment) { false }
-        end
-
-        it 'refunds the payment' do
-          expect { subject }.to change { payment.refunds.count }.from(0).to(1)
-        end
-
-        context 'if payment has partial refunds' do
-          let(:credit_amount) { payment.amount / 2 }
-
-          before do
-            payment.refunds.create!(
-              amount: credit_amount,
-              reason: Spree::RefundReason.where(name: 'test').first_or_create
-            )
-          end
-
-          it 'only refunds the allowed credit amount' do
-            subject
-            refund = payment.refunds.last
-            expect(refund.amount).to eq(credit_amount)
-          end
-        end
-      end
-    end
-
-    context 'if the payment_method does not respond to `try_void`', partial_double_verification: false do
-      before do
-        allow(payment_method).to receive(:respond_to?) { false }
-        allow(payment_method).to receive(:cancel) { double }
-        allow(payment).to receive(:handle_void_response)
-      end
-
-      it 'calls cancel instead' do
-        expect(payment_method).to receive(:cancel)
-        Spree::Deprecation.silence { subject }
-      end
-
-      it 'prints depcrecation warning' do
-        expect(Spree::Deprecation).to receive(:warn)
-        subject
-      end
-    end
-  end
-end

data/spec/models/spree/payment_create_spec.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe PaymentCreate do
-    let(:user) { nil }
-    let(:order) { create :order, user: user }
-    let(:request_env) { {} }
-    let(:payment_create) { described_class.new(order, attributes, request_env: request_env) }
-    let(:payment_method) { create(:payment_method) }
-    let(:new_payment) { payment_create.build }
-
-    context 'empty attributes' do
-      let(:attributes){ {} }
-      it "builds a new empty payment" do
-        expect(new_payment).to be_a Spree::Payment
-        expect(new_payment.order).to eq order
-        expect(new_payment.source).to be_nil
-      end
-
-      it "builds the payment in order.payments" do
-        expect(order.payments).to eq [new_payment]
-      end
-    end
-
-    context 'with a new source' do
-      let(:attributes) do
-        {
-          amount: 100,
-          payment_method: payment_method,
-          source_attributes: {
-            expiry: "01 / 99",
-            number: '1234567890123',
-            verification_value: '123',
-            name: 'Foo Bar'
-          }
-        }
-      end
-
-      it "should build the payment's source" do
-        expect(new_payment).to be_valid
-        expect(new_payment.source).not_to be_nil
-        expect(new_payment.source.user_id).to eq order.user_id
-        expect(new_payment.source.payment_method_id).to eq payment_method.id
-      end
-
-      it "doesn't modify passed-in hash" do
-        original = attributes.dup
-        new_payment
-        expect(original).to eq(attributes)
-      end
-
-      context "when payment source not valid" do
-        let(:attributes) do
-          {
-            amount: 100,
-            payment_method: payment_method,
-            source_attributes: { expiry: "1 / 12" }
-          }
-        end
-        it "errors when payment source not valid" do
-          expect(new_payment).not_to be_valid
-          expect(new_payment).not_to be_persisted
-          expect(new_payment.source).not_to be_persisted
-          expect(new_payment.source).not_to be_valid
-          expect(new_payment.source.errors[:number]).to be_present
-          expect(new_payment.source.errors[:verification_value].size).to be_present
-        end
-      end
-    end
-
-    context 'with the deprecated existing_card_id attribute' do
-      let(:user) { create(:user) }
-      let!(:credit_card) { create(:credit_card, user: order.user) }
-
-      let(:attributes) do
-        {
-          source_attributes: {
-            existing_card_id: credit_card.id,
-            verification_value: '321'
-          }
-        }
-      end
-
-      around do |example|
-        Spree::Deprecation.silence { example.run }
-      end
-
-      it 'sets the existing card as the source for the new payment' do
-        expect(new_payment.source).to eq(credit_card)
-      end
-
-      it 'sets the payment payment_method to that of the credit card' do
-        expect(new_payment.payment_method_id).to eq(credit_card.payment_method_id)
-      end
-
-      it 'sets the verification_value on the credit card' do
-        expect(new_payment.source.verification_value).to eq('321')
-      end
-
-      context 'with request_env' do
-        let(:request_env){ { 'USER_AGENT' => 'Firefox' } }
-        it 'sets the request_env on the payment' do
-          expect(new_payment.request_env).to eq({ 'USER_AGENT' => 'Firefox' })
-        end
-      end
-
-      context 'the credit card belongs to a different user' do
-        let(:other_user) { create(:user) }
-        before { credit_card.update!(user: other_user) }
-        it 'errors' do
-          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-
-      context 'the credit card has no user' do
-        before { credit_card.update!(user_id: nil) }
-        it 'errors' do
-          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-
-      context 'the order has no user' do
-        before { order.update!(user_id: nil) }
-        it 'errors' do
-          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-
-      context 'the order and the credit card have no user' do
-        before do
-          order.update!(user_id: nil)
-          credit_card.update!(user_id: nil)
-        end
-        it 'errors' do
-          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-    end
-
-    context "with strong params" do
-      let(:valid_attributes) do
-        {
-          amount: 100,
-          payment_method: payment_method,
-          source_attributes: {
-            expiry: "01 / 99",
-            number: '1234567890123',
-            verification_value: '123',
-            name: 'Foo Bar'
-          }
-        }
-      end
-
-      context "unpermitted" do
-        let(:attributes) { ActionController::Parameters.new(valid_attributes) }
-
-        it "raises an exception" do
-          expect {
-            new_payment
-          }.to raise_exception(ActionController::UnfilteredParameters)
-        end
-      end
-
-      context "partially permitted" do
-        let(:attributes) do
-          ActionController::Parameters.new(valid_attributes).permit(:amount)
-        end
-
-        it "only uses permitted attributes" do
-          expect(new_payment).to have_attributes(
-            amount: 100, # permitted
-            payment_method: nil, # unpermitted
-            source: nil # unpermitted
-          )
-        end
-      end
-
-      context "all permitted" do
-        let(:attributes) do
-          ActionController::Parameters.new(valid_attributes).permit!
-        end
-
-        it "creates a payment with all attributes" do
-          expect(new_payment).to have_attributes(
-            amount: 100,
-            payment_method: payment_method,
-            source: kind_of(CreditCard)
-          )
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/payment_method/bogus_credit_card_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe PaymentMethod::BogusCreditCard, type: :model do
-    let(:bogus) { create(:credit_card_payment_method) }
-    let!(:cc) { create(:credit_card, payment_method: bogus, gateway_customer_profile_id: "BGS-RERTERT") }
-  end
-end

data/spec/models/spree/payment_method/check_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PaymentMethod::Check do
-  let(:order) { create(:order) }
-  subject { described_class.new }
-
-  context "#can_capture?" do
-    let(:payment) { create(:payment, order: order, state: state) }
-
-    context "with payment in state checkout" do
-      let(:state) { "checkout" }
-
-      it "returns true" do
-        expect(subject.can_capture?(payment)).to be_truthy
-      end
-    end
-
-    context "with payment in state pending" do
-      let(:state) { "pending" }
-
-      it "returns true" do
-        expect(subject.can_capture?(payment)).to be_truthy
-      end
-    end
-
-    context "with payment in state failed" do
-      let(:state) { "failed" }
-
-      it "returns false" do
-        expect(subject.can_capture?(payment)).to be_falsy
-      end
-    end
-  end
-
-  context "#can_void?" do
-    let(:payment) { create(:payment, order: order, state: state) }
-
-    context "with payment in state checkout" do
-      let(:state) { "checkout" }
-
-      it "returns true" do
-        expect(subject.can_void?(payment)).to be_truthy
-      end
-    end
-
-    context "with payment in state void" do
-      let(:state) { "void" }
-
-      it "returns false" do
-        expect(subject.can_void?(payment)).to be_falsy
-      end
-    end
-  end
-
-  context "#capture" do
-    it "succeeds" do
-      expect(subject.capture).to be_success
-    end
-  end
-
-  context "#try_void" do
-    it "succeeds" do
-      expect(subject.try_void).to be_success
-    end
-  end
-
-  context "#void" do
-    it "succeeds" do
-      expect(subject.void).to be_success
-    end
-  end
-
-  context "#credit" do
-    it "succeeds" do
-      expect(subject.credit).to be_success
-    end
-  end
-end

data/spec/models/spree/payment_method/credit_card_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PaymentMethod::CreditCard, type: :model do
-  context "fetching payment sources" do
-    let(:store) { create :store }
-    let(:user) { create :user }
-    let(:order) { Spree::Order.create(user: user, completed_at: completed_at, store: store) }
-
-    let(:payment_method) { create(:credit_card_payment_method) }
-
-    let(:cc) do
-      create(:credit_card,
-             payment_method: payment_method,
-             gateway_customer_profile_id: "EFWE",
-             user: cc_user)
-    end
-
-    let(:payment) do
-      create(:payment, order: order, source: cc, payment_method: payment_method)
-    end
-
-    context 'order is not complete and credit card user is nil' do
-      let(:cc_user) { nil }
-      let(:completed_at) { nil }
-
-      it "finds no credit cards associated to the order" do
-        expect(payment_method.reusable_sources(payment.order)).to be_empty
-      end
-    end
-
-    context 'order is complete but credit card user is nil' do
-      let(:cc_user) { nil }
-      let(:completed_at) { Date.yesterday }
-
-      it "finds credit cards associated on a order completed" do
-        expect(payment_method.reusable_sources(payment.order)).to eq [cc]
-      end
-    end
-
-    context 'order is not complete but credit card has user' do
-      let(:cc_user) { user }
-      let(:completed_at) { nil }
-      before do
-        cc_user.wallet.add(cc)
-      end
-      it "finds credit cards associated to the user" do
-        expect(payment_method.reusable_sources(payment.order)).to eq [cc]
-      end
-    end
-  end
-
-  context 'using preference_source' do
-    let(:klass){ Spree::PaymentMethod::BogusCreditCard }
-    before do
-      Spree::Config.static_model_preferences.add(klass, 'test_preference_source', server: 'bar')
-    end
-    after do
-      Spree::Config.static_model_preferences.for_class(klass).clear
-    end
-    let(:payment_method){ create(:credit_card_payment_method, preference_source: 'test_preference_source') }
-
-    it "reads static preferences" do
-      expect(payment_method.options).to eq({ server: "bar" })
-    end
-  end
-end

data/spec/models/spree/payment_method/simple_bogus_credit_card_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PaymentMethod::SimpleBogusCreditCard, type: :model do
-  subject { Spree::PaymentMethod::SimpleBogusCreditCard.new }
-
-  # regression test for https://github.com/spree/spree/issues/3824
-  describe "#capture" do
-    it "returns success with the right response code" do
-      response = subject.capture(123, '12345', {})
-      expect(response.message).to include("success")
-    end
-
-    it "returns failure with the wrong response code" do
-      response = subject.capture(123, 'wrong', {})
-      expect(response.message).to include("failure")
-    end
-  end
-end