solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/payment_create_spec.rb

@@ -0,0 +1,205 @@
+# 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_attributes!(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_attributes!(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) }
+
+        if Rails.gem_version < Gem::Version.new('5.1')
+          it "ignores all attributes" do
+            expect(new_payment).to have_attributes(
+              amount: 0,
+              payment_method: nil,
+              source: nil
+            )
+          end
+        else
+          it "raises an exception" do
+            expect {
+              new_payment
+            }.to raise_exception(ActionController::UnfilteredParameters)
+          end
+        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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,80 @@
+# 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

@@ -0,0 +1,68 @@
+# 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

@@ -0,0 +1,20 @@
+# 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