solidus_paypal_braintree 0.4.0 → 1.0.0

data/spec/models/solidus_paypal_braintree/response_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+RSpec.describe SolidusPaypalBraintree::Response do
+  let(:failed_transaction) { nil }
+  let(:error) do
+    instance_double(
+      'Braintree::ValidationError',
+      code: '12345',
+      message: "Cannot refund a transaction unless it is settled."
+    )
+  end
+
+  let(:error_result) do
+    instance_double(
+      'Braintree::ErrorResult',
+      success?: false,
+      errors: [error],
+      transaction: failed_transaction,
+      params: { some: 'error' }
+    )
+  end
+
+  let(:error_response) do
+    described_class.build(error_result)
+  end
+
+  let(:successful_result) do
+    transaction = instance_double(
+      'Braintree::Transaction',
+      status: 'ok',
+      id: 'abcdef',
+      avs_error_response_code: nil,
+      avs_street_address_response_code: 'M',
+      avs_postal_code_response_code: 'M',
+      cvv_response_code: 'I'
+    )
+
+    instance_double(
+      'Braintree::SuccessfulResult',
+      success?: true,
+      transaction: transaction
+    )
+  end
+
+  let(:successful_response) do
+    described_class.build(successful_result)
+  end
+
+  describe '.new' do
+    it 'is private' do
+      expect { described_class.new }.to raise_error(/private method/)
+    end
+  end
+
+  describe '.build' do
+    it { expect(error_response).to be_a ActiveMerchant::Billing::Response }
+    it { expect(successful_response).to be_a ActiveMerchant::Billing::Response }
+  end
+
+  describe '#success?' do
+    it { expect(error_response.success?).to be false }
+    it { expect(successful_response.success?).to be true }
+  end
+
+  describe "#message" do
+    context "with a success response" do
+      subject { successful_response.message }
+
+      it { is_expected.to eq "ok" }
+    end
+
+    context "with an error response" do
+      subject { error_response.message }
+
+      context "with a Braintree error" do
+        it { is_expected.to eq "Cannot refund a transaction unless it is settled. (12345)" }
+      end
+
+      context "with a settlement_declined status" do
+        let(:error) { nil }
+        let(:failed_transaction) do
+          instance_double(
+            'Braintree::Transaction',
+            id: 'abcdef',
+            status: "settlement_declined",
+            processor_settlement_response_code: "4001",
+            processor_settlement_response_text: "Settlement Declined",
+            avs_error_response_code: nil,
+            avs_street_address_response_code: nil,
+            avs_postal_code_response_code: nil,
+            cvv_response_code: nil
+          )
+        end
+
+        it { is_expected.to eq "Settlement Declined (4001)" }
+      end
+
+      context "with a gateway_rejected status" do
+        let(:error) { nil }
+        let(:failed_transaction) do
+          instance_double(
+            'Braintree::Transaction',
+            id: 'abcdef',
+            status: "gateway_rejected",
+            gateway_rejection_reason: "cvv",
+            avs_error_response_code: nil,
+            avs_street_address_response_code: nil,
+            avs_postal_code_response_code: nil,
+            cvv_response_code: nil
+          )
+        end
+
+        it { is_expected.to eq "CVV check failed." }
+      end
+
+      context "with a processor_declined status" do
+        let(:error) { nil }
+        let(:failed_transaction) do
+          instance_double(
+            'Braintree::Transaction',
+            id: 'abcdef',
+            status: "processor_declined",
+            processor_response_code: '2001',
+            processor_response_text: 'Insufficient Funds',
+            avs_error_response_code: nil,
+            avs_street_address_response_code: nil,
+            avs_postal_code_response_code: nil,
+            cvv_response_code: nil
+          )
+        end
+
+        it { is_expected.to eq "Insufficient Funds (2001)" }
+      end
+
+      context 'with other transaction status' do
+        let(:error) { nil }
+        let(:failed_transaction) do
+          instance_double(
+            'Braintree::Transaction',
+            id: 'abcdef',
+            status: "authorization_expired",
+            avs_error_response_code: nil,
+            avs_street_address_response_code: nil,
+            avs_postal_code_response_code: nil,
+            cvv_response_code: nil
+          )
+        end
+
+        it { is_expected.to eq 'Payment authorization has expired.' }
+      end
+
+      context 'with other transaction status that is not translated' do
+        let(:error) { nil }
+        let(:failed_transaction) do
+          instance_double(
+            'Braintree::Transaction',
+            id: 'abcdef',
+            status: "something_bad_happened",
+            avs_error_response_code: nil,
+            avs_street_address_response_code: nil,
+            avs_postal_code_response_code: nil,
+            cvv_response_code: nil
+          )
+        end
+
+        it { is_expected.to eq 'Something bad happened' }
+      end
+    end
+  end
+
+  describe '#avs_result' do
+    context 'with a successful result' do
+      subject { described_class.build(successful_result).avs_result }
+
+      it 'includes AVS response code' do
+        expect(subject['code']).to eq 'M'
+      end
+
+      it 'includes AVS response message' do
+        expect(subject['message']).to eq 'Street address and postal code match.'
+      end
+    end
+
+    context 'with an error result' do
+      subject { described_class.build(error_result).avs_result }
+
+      let(:failed_transaction) do
+        instance_double(
+          'Braintree::Transaction',
+          id: 'abcdef',
+          avs_error_response_code: 'E',
+          avs_street_address_response_code: nil,
+          avs_postal_code_response_code: nil,
+          cvv_response_code: nil
+        )
+      end
+
+      it 'includes AVS response code' do
+        expect(subject['code']).to eq 'E'
+      end
+
+      it 'includes AVS response message' do
+        expect(subject['message']).to eq 'AVS data is invalid or AVS is not allowed for this card type.'
+      end
+
+      context 'without transaction' do
+        let(:failed_transaction) { nil }
+
+        it 'includes no AVS response' do
+          expect(subject['message']).to be_nil
+          expect(subject['code']).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#cvv_result' do
+    context 'with a successful result' do
+      subject { described_class.build(successful_result).cvv_result }
+
+      it 'does not include CVV response code' do
+        expect(subject['code']).to be_nil
+      end
+
+      it 'does not include CVV response message' do
+        expect(subject['message']).to be_nil
+      end
+    end
+
+    context 'with an error result' do
+      subject { described_class.build(error_result).cvv_result }
+
+      let(:failed_transaction) do
+        instance_double(
+          'Braintree::Transaction',
+          id: 'abcdef',
+          avs_error_response_code: nil,
+          avs_street_address_response_code: nil,
+          avs_postal_code_response_code: nil,
+          cvv_response_code: 'N'
+        )
+      end
+
+      it 'includes CVV response code' do
+        expect(subject['code']).to eq 'N'
+      end
+
+      it 'includes CVV response message' do
+        expect(subject['message']).to eq 'CVV does not match'
+      end
+
+      context 'without transaction' do
+        let(:failed_transaction) { nil }
+
+        it 'includes no CVV response' do
+          expect(subject['message']).to be_nil
+          expect(subject['code']).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#params' do
+    context "with an error response" do
+      subject { error_response.params }
+
+      it 'includes request params' do
+        expect(subject).to eq({ 'some' => 'error' })
+      end
+    end
+  end
+
+  describe '#authorization' do
+    it 'is whatever the b.t. transaction id was' do
+      expect(successful_response.authorization).to eq 'abcdef'
+    end
+
+    it { expect(error_response.authorization).to be_nil }
+  end
+end

data/spec/models/solidus_paypal_braintree/source_spec.rb

@@ -0,0 +1,360 @@
+require 'spec_helper'
+
+RSpec.describe SolidusPaypalBraintree::Source, type: :model do
+  include_context 'when order is ready for payment'
+
+  it 'is invalid without a payment_type set' do
+    expect(described_class.new).to be_invalid
+  end
+
+  it 'is invalid with payment_type set to unknown type' do
+    expect(described_class.new(payment_type: 'AndroidPay')).to be_invalid
+  end
+
+  describe '#payment_method' do
+    it 'uses spree_payment_method' do
+      expect(described_class.new.build_payment_method).to be_a Spree::PaymentMethod
+    end
+  end
+
+  describe '#imported' do
+    it 'is always false' do
+      expect(described_class.new.imported).not_to be_truthy
+    end
+  end
+
+  describe "#actions" do
+    it "supports capture, void, and credit" do
+      expect(described_class.new.actions).to eq %w[capture void credit]
+    end
+  end
+
+  describe "#can_capture?" do
+    subject { described_class.new.can_capture?(payment) }
+
+    context "when the payment state is pending" do
+      let(:payment) { build(:payment, state: "pending") }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when the payment state is checkout" do
+      let(:payment) { build(:payment, state: "checkout") }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when the payment is completed" do
+      let(:payment) { build(:payment, state: "completed") }
+
+      it { is_expected.not_to be_truthy }
+    end
+  end
+
+  describe '#can_void?' do
+    subject { payment_source.can_void?(payment) }
+
+    let(:payment_source) { described_class.new }
+    let(:payment) { build(:payment) }
+
+    let(:transaction_response) do
+      double(:response, status: Braintree::Transaction::Status::SubmittedForSettlement)
+    end
+
+    let(:transaction_request) do
+      double(:request, find: transaction_response)
+    end
+
+    before do
+      allow(payment_source).to receive(:braintree_client) do
+        double(:transaction, transaction: transaction_request)
+      end
+    end
+
+    context 'when transaction id is not present' do
+      let(:payment) { build(:payment, response_code: nil) }
+
+      it { is_expected.to be(false) }
+    end
+
+    context 'when transaction has voidable status' do
+      it { is_expected.to be(true) }
+    end
+
+    context 'when transaction has non voidable status' do
+      let(:transaction_response) do
+        double(:response, status: Braintree::Transaction::Status::Settled)
+      end
+
+      it { is_expected.to be(false) }
+    end
+
+    context 'when transaction is not found at Braintreee' do
+      before do
+        allow(transaction_request).to \
+          receive(:find).and_raise(Braintree::NotFoundError)
+      end
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe "#can_credit?" do
+    subject { described_class.new.can_credit?(payment) }
+
+    context "when the payment is completed" do
+      context "when the credit allowed is 100" do
+        let(:payment) { build(:payment, state: "completed", amount: 100) }
+
+        it { is_expected.to be_truthy }
+      end
+
+      context "when the credit allowed is 0" do
+        let(:payment) { build(:payment, state: "completed", amount: 0) }
+
+        it { is_expected.not_to be_truthy }
+      end
+    end
+
+    context "when the payment has not been completed" do
+      let(:payment) { build(:payment, state: "checkout") }
+
+      it { is_expected.not_to be_truthy }
+    end
+  end
+
+  describe "#friendly_payment_type" do
+    subject { described_class.new(payment_type: type).friendly_payment_type }
+
+    context "when then payment type is PayPal" do
+      let(:type) { "PayPalAccount" }
+
+      it "returns the translated payment type" do
+        expect(subject).to eq "PayPal"
+      end
+    end
+
+    context "when the payment type is Apple Pay" do
+      let(:type) { "ApplePayCard" }
+
+      it "returns the translated payment type" do
+        expect(subject).to eq "Apple Pay"
+      end
+    end
+
+    context "when the payment type is Credit Card" do
+      let(:type) { "CreditCard" }
+
+      it "returns the translated payment type" do
+        expect(subject).to eq "Credit Card"
+      end
+    end
+  end
+
+  describe "#apple_pay?" do
+    subject { described_class.new(payment_type: type).apple_pay? }
+
+    context "when the payment type is Apple Pay" do
+      let(:type) { "ApplePayCard" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when the payment type is not Apple Pay" do
+      let(:type) { "DogeCoin" }
+
+      it { is_expected.to be false }
+    end
+  end
+
+  describe "#paypal?" do
+    subject { described_class.new(payment_type: type).paypal? }
+
+    context "when the payment type is PayPal" do
+      let(:type) { "PayPalAccount" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when the payment type is not PayPal" do
+      let(:type) { "MonopolyMoney" }
+
+      it { is_expected.to be false }
+    end
+  end
+
+  describe "#credit_card?" do
+    subject { described_class.new(payment_type: type).credit_card? }
+
+    context "when the payment type is CreditCard" do
+      let(:type) { "CreditCard" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when the payment type is not CreditCard" do
+      let(:type) { "MonopolyMoney" }
+
+      it { is_expected.to be false }
+    end
+  end
+
+  shared_context 'with unknown source token' do
+    let(:braintree_payment_method) { double }
+
+    before do
+      allow(braintree_payment_method).to receive(:find) do
+        raise Braintree::NotFoundError
+      end
+      allow(payment_source).to receive(:braintree_client) do
+        instance_double(payment_method: braintree_payment_method)
+      end
+    end
+  end
+
+  shared_context 'with nil source token' do
+    let(:braintree_payment_method) { double }
+
+    before do
+      allow(braintree_payment_method).to receive(:find) do
+        raise ArgumentError
+      end
+      allow(payment_source).to receive(:braintree_client) do
+        instance_double(payment_method: braintree_payment_method)
+      end
+    end
+  end
+
+  describe "#last_4" do
+    subject { payment_source.last_4 }
+
+    let(:method) { new_gateway.tap(&:save!) }
+    let(:payment_source) { described_class.create!(payment_type: "CreditCard", payment_method: method) }
+    let(:braintree_client) { method.braintree }
+
+    context 'when token is known at braintree', vcr: {
+      cassette_name: "source/last4",
+      match_requests_on: [:braintree_uri]
+    } do
+      before do
+        customer = braintree_client.customer.create
+
+        method = braintree_client.payment_method.create({
+          payment_method_nonce: "fake-valid-country-of-issuance-usa-nonce",
+          customer_id: customer.customer.id
+        })
+
+        payment_source.update!(token: method.payment_method.token)
+      end
+
+      it "delegates to the braintree payment method" do
+        method = braintree_client.payment_method.find(payment_source.token)
+        expect(subject).to eql(method.last_4)
+      end
+    end
+
+    context 'when the source token is not known at Braintree' do
+      include_context 'with unknown source token'
+
+      it { is_expected.to be(nil) }
+    end
+
+    context 'when the source token is nil' do
+      include_context 'with nil source token'
+
+      it { is_expected.to be(nil) }
+    end
+  end
+
+  describe "#display_number" do
+    subject { payment_source.display_number }
+
+    let(:type) { nil }
+    let(:payment_source) { described_class.new(payment_type: type) }
+
+    context "when last_digits is a number" do
+      before do
+        allow(payment_source).to receive(:last_digits).and_return('1234')
+      end
+
+      it { is_expected.to eq 'XXXX-XXXX-XXXX-1234' }
+    end
+
+    context "when last_digits is nil" do
+      before do
+        allow(payment_source).to receive(:last_digits).and_return(nil)
+      end
+
+      it { is_expected.to eq 'XXXX-XXXX-XXXX-XXXX' }
+    end
+
+    context "when is a PayPal source" do
+      let(:type) { "PayPalAccount" }
+
+      before do
+        allow(payment_source).to receive(:email).and_return('user@example.com')
+      end
+
+      it { is_expected.to eq 'user@example.com' }
+    end
+  end
+
+  describe "#card_type" do
+    subject { payment_source.card_type }
+
+    let(:method) { new_gateway.tap(&:save!) }
+    let(:payment_source) { described_class.create!(payment_type: "CreditCard", payment_method: method) }
+    let(:braintree_client) { method.braintree }
+
+    context "when the token is known at braintree", vcr: {
+      cassette_name: "source/card_type",
+      match_requests_on: [:braintree_uri]
+    } do
+      before do
+        customer = braintree_client.customer.create
+
+        method = braintree_client.payment_method.create({
+          payment_method_nonce: "fake-valid-country-of-issuance-usa-nonce", customer_id: customer.customer.id
+        })
+
+        payment_source.update!(token: method.payment_method.token)
+      end
+
+      it "delegates to the braintree payment method" do
+        method = braintree_client.payment_method.find(payment_source.token)
+        expect(subject).to eql(method.card_type)
+      end
+    end
+
+    context 'when the source token is not known at Braintree' do
+      include_context 'with unknown source token'
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when the source token is nil' do
+      include_context 'with nil source token'
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#reusable?' do
+    subject { payment_source.reusable? }
+
+    let(:payment_source) { described_class.new(token: token, nonce: nonce) }
+    let(:nonce) { 'nonce67890' }
+
+    context 'when source token is present' do
+      let(:token) { 'token12345' }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when source token is nil' do
+      let(:token) { nil }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end