solidus_core 2.10.5 → 3.0.8

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

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

@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PaymentMethod::StoreCredit do
-  let(:order)           { create(:order) }
-  let(:payment)         { create(:payment, order: order) }
-  let(:gateway_options) { payment.gateway_options }
-
-  context "#authorize" do
-    subject do
-      Spree::PaymentMethod::StoreCredit.new.authorize(auth_amount, store_credit, gateway_options)
-    end
-
-    let(:auth_amount) { store_credit.amount_remaining * 100 }
-    let(:store_credit) { create(:store_credit) }
-    let(:gateway_options) { super().merge(originator: originator) }
-    let(:originator) { nil }
-
-    context 'without an invalid store credit' do
-      let(:store_credit) { nil }
-      let(:auth_amount) { 10 }
-
-      it "declines an unknown store credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.unable_to_find')
-      end
-    end
-
-    context 'with insuffient funds' do
-      let(:auth_amount) { (store_credit.amount_remaining * 100) + 1 }
-
-      it "declines a store credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.insufficient_funds')
-      end
-    end
-
-    context 'when the currency does not match the order currency' do
-      let(:store_credit) { create(:store_credit, currency: 'AUD') }
-
-      it "declines the credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.currency_mismatch')
-      end
-    end
-
-    context 'with a valid request' do
-      it "authorizes a valid store credit" do
-        expect(subject.success?).to be true
-        expect(subject.authorization).not_to be_nil
-      end
-
-      context 'with an originator' do
-        let(:originator) { double('originator') }
-
-        it 'passes the originator' do
-          expect_any_instance_of(Spree::StoreCredit).to receive(:authorize)
-            .with(anything, anything, action_originator: originator)
-          subject
-        end
-      end
-    end
-  end
-
-  context "#capture" do
-    subject do
-      Spree::PaymentMethod::StoreCredit.new.capture(capture_amount, auth_code, gateway_options)
-    end
-
-    let(:capture_amount) { 10_00 }
-    let(:auth_code) { auth_event.authorization_code }
-    let(:gateway_options) { super().merge(originator: originator) }
-
-    let(:authorized_amount) { capture_amount / 100.0 }
-    let(:auth_event) { create(:store_credit_auth_event, store_credit: store_credit, amount: authorized_amount) }
-    let(:store_credit) { create(:store_credit, amount_authorized: authorized_amount) }
-    let(:originator) { nil }
-
-    context 'with an invalid auth code' do
-      let(:auth_code) { -1 }
-
-      it "declines an unknown store credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.unable_to_find')
-      end
-    end
-
-    context 'when unable to authorize the amount' do
-      let(:authorized_amount) { (capture_amount - 1) / 100 }
-
-      before do
-        allow_any_instance_of(Spree::StoreCredit).to receive_messages(authorize: true)
-      end
-
-      it "declines a store credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.insufficient_authorized_amount')
-      end
-    end
-
-    context 'when the currency does not match the order currency' do
-      let(:store_credit) { create(:store_credit, currency: 'AUD', amount_authorized: authorized_amount) }
-
-      it "declines the credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.currency_mismatch')
-      end
-    end
-
-    context 'with a valid request' do
-      it "captures the store credit" do
-        expect(subject.message).to include I18n.t('spree.store_credit.successful_action', action: Spree::StoreCredit::CAPTURE_ACTION)
-        expect(subject.success?).to be true
-      end
-
-      context 'with an originator' do
-        let(:originator) { double('originator') }
-
-        it 'passes the originator' do
-          expect_any_instance_of(Spree::StoreCredit).to receive(:capture)
-            .with(anything, anything, anything, action_originator: originator)
-          subject
-        end
-      end
-    end
-  end
-
-  context "#void" do
-    subject do
-      Spree::PaymentMethod::StoreCredit.new.void(auth_code, gateway_options)
-    end
-
-    let(:auth_code) { auth_event.authorization_code }
-    let(:gateway_options) { super().merge(originator: originator) }
-    let(:auth_event) { create(:store_credit_auth_event) }
-    let(:originator) { nil }
-
-    context 'with an invalid auth code' do
-      let(:auth_code) { 1 }
-
-      it "declines an unknown store credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.unable_to_find')
-      end
-    end
-
-    context 'when the store credit is not voided successfully' do
-      before { allow_any_instance_of(Spree::StoreCredit).to receive_messages(void: false) }
-
-      it "returns an error response" do
-        expect(subject.success?).to be false
-      end
-    end
-
-    it "voids a valid store credit void request" do
-      expect(subject.success?).to be true
-      expect(subject.message).to include I18n.t('spree.store_credit.successful_action', action: Spree::StoreCredit::VOID_ACTION)
-    end
-
-    context 'with an originator' do
-      let(:originator) { double('originator') }
-
-      it 'passes the originator' do
-        expect_any_instance_of(Spree::StoreCredit).to receive(:void)
-          .with(anything, action_originator: originator)
-        subject
-      end
-    end
-  end
-
-  context "#purchase" do
-    it "declines a purchase if it can't find a pending credit for the correct amount" do
-      amount = 100.0
-      store_credit = create(:store_credit)
-      auth_code = store_credit.generate_authorization_code
-      store_credit.store_credit_events.create!(action: Spree::StoreCredit::ELIGIBLE_ACTION,
-                                               amount: amount,
-                                               authorization_code: auth_code)
-      store_credit.store_credit_events.create!(action: Spree::StoreCredit::CAPTURE_ACTION,
-                                               amount: amount,
-                                               authorization_code: auth_code)
-
-      resp = subject.purchase(amount * 100.0, store_credit, gateway_options)
-      expect(resp.success?).to be false
-      expect(resp.message).to include I18n.t('spree.store_credit.unable_to_find')
-    end
-
-    it "captures a purchase if it can find a pending credit for the correct amount" do
-      amount = 100.0
-      store_credit = create(:store_credit)
-      auth_code = store_credit.generate_authorization_code
-      store_credit.store_credit_events.create!(action: Spree::StoreCredit::ELIGIBLE_ACTION,
-                                               amount: amount,
-                                               authorization_code: auth_code)
-
-      resp = subject.purchase(amount * 100.0, store_credit, gateway_options)
-      expect(resp.success?).to be true
-      expect(resp.message).to include I18n.t('spree.store_credit.successful_action', action: Spree::StoreCredit::CAPTURE_ACTION)
-    end
-  end
-
-  context "#credit" do
-    subject do
-      Spree::PaymentMethod::StoreCredit.new.credit(credit_amount, auth_code, gateway_options)
-    end
-
-    let(:credit_amount) { 100.0 }
-    let(:auth_code) { auth_event.authorization_code }
-    let(:gateway_options) { super().merge(originator: originator) }
-    let(:auth_event) { create(:store_credit_auth_event) }
-    let(:originator) { nil }
-
-    context 'with an invalid auth code' do
-      let(:auth_code) { 1 }
-
-      it "declines an unknown store credit" do
-        expect(subject.success?).to be false
-        expect(subject.message).to include I18n.t('spree.store_credit.unable_to_find')
-      end
-    end
-
-    context "when the store credit isn't credited successfully" do
-      before { allow_any_instance_of(Spree::StoreCredit).to receive_messages(credit: false) }
-
-      it "returns an error response" do
-        expect(subject.success?).to be false
-      end
-    end
-
-    context 'with a valid credit request' do
-      before { allow_any_instance_of(Spree::StoreCredit).to receive_messages(credit: true) }
-
-      it "credits a valid store credit credit request" do
-        expect(subject.success?).to be true
-        expect(subject.message).to include I18n.t('spree.store_credit.successful_action', action: Spree::StoreCredit::CREDIT_ACTION)
-      end
-    end
-
-    context 'with an originator' do
-      let(:originator) { double('originator') }
-
-      it 'passes the originator' do
-        expect_any_instance_of(Spree::StoreCredit).to receive(:credit)
-          .with(anything, anything, anything, action_originator: originator)
-        subject
-      end
-    end
-  end
-
-  context "#try_void" do
-    subject do
-      payment_method.try_void(double(response_code: auth_code))
-    end
-
-    let(:payment_method)  { described_class.create!(name: 'Store Credit') }
-    let(:store_credit)    { create(:store_credit, amount: original_amount, amount_used: captured_amount) }
-    let(:auth_code)       { "1-SC-20141111111111" }
-    let(:original_amount) { 100.0 }
-    let(:captured_amount) { 10.0 }
-
-    shared_examples "a spree payment method" do
-      it "returns an ActiveMerchant::Billing::Response" do
-        expect(subject).to be_instance_of(ActiveMerchant::Billing::Response)
-      end
-    end
-
-    context "capture event found" do
-      let!(:store_credit_event) do
-        create(:store_credit_capture_event,
-          authorization_code: auth_code,
-          amount: captured_amount,
-          store_credit: store_credit)
-      end
-
-      it { is_expected.to be(false) }
-
-      describe "called from payment#cancel!" do
-        subject { payment.cancel! }
-
-        let!(:payment) do
-          create(:payment,
-            order: order,
-            payment_method: payment_method,
-            source: store_credit,
-            amount: captured_amount,
-            response_code: auth_code)
-        end
-
-        it "refunds the capture amount" do
-          expect { subject }.to change { store_credit.reload.amount_remaining }.
-                                from(original_amount - captured_amount).
-                                to(original_amount)
-        end
-      end
-    end
-
-    context "capture event not found" do
-      context "auth event found" do
-        let!(:store_credit_event) do
-          create(:store_credit_auth_event,
-            authorization_code: auth_code,
-            amount: captured_amount,
-            store_credit: store_credit)
-        end
-
-        it_behaves_like "a spree payment method"
-
-        it "voids the capture amount" do
-          expect { subject }.to change { store_credit.reload.amount_remaining }.
-                                from(original_amount - captured_amount).
-                                to(original_amount)
-        end
-      end
-
-      context "store credit event not found" do
-        let(:auth_code) { 'INVALID' }
-
-        it_behaves_like "a spree payment method"
-
-        it { is_expected.to_not be_success }
-      end
-    end
-  end
-end