spree_affirm 0.2.3 → 0.2.19

data/spec/models/affirm_address_validator_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Affirm::AddressValidator do
-  it 'detects when region1_code is missing' do
-    input_addr = {
-      state: 'California for example'
-    }
-    output = Affirm::AddressValidator.normalize_affirm_address(
-      input_addr)
-    expect(output['region1_code']).to eq(input_addr['state'])
-  end
-end
-

data/spec/models/spree_affirm_checkout_spec.rb

@@ -1,328 +0,0 @@
-require 'spec_helper'
-
-
-describe Spree::AffirmCheckout do
-  let(:valid_checkout) { FactoryGirl.create(:affirm_checkout) }
-  let(:affirm_payment) { FactoryGirl.create(:affirm_payment) }
-
-
-  describe "scopes" do
-    describe "with_payment_profile" do
-      it "returns all" do
-        expect(Spree::AffirmCheckout.all).to eq(Spree::AffirmCheckout.with_payment_profile)
-      end
-    end
-
-
-  end
-
-
-  describe '#details' do
-    it "calls get_checkout from the payment provider exactly once" do
-      _checkout = FactoryGirl.build(:affirm_checkout, stub_details: false)
-      _checkout.payment_method.provider.stub(:get_checkout) do
-         {"hello" => "there"}
-      end
-      expect(_checkout.payment_method.provider).to receive(:get_checkout).exactly(1).times
-      _checkout.details
-      _checkout.details
-      _checkout.details
-    end
-  end
-
-
-  describe "#valid?" do
-    context "with all valid checkout details" do
-      it "should return true" do
-        expect(valid_checkout.valid?).to be(true)
-      end
-    end
-  end
-
-  describe "#check_valid_products" do
-    context "with all matching fields" do
-      it "does not set an error" do
-        valid_checkout.check_valid_products
-        expect(valid_checkout.errors.size).to be(0)
-      end
-
-      it "does not throw an error for case senstive name mismatches" do
-        _checkout = FactoryGirl.build(:affirm_checkout, full_name_case_mismatch: true)
-        _checkout.check_matching_billing_address
-        expect(_checkout.errors.size).to be(0)
-
-      end
-    end
-
-    context "with an extra product is in the checkout details" do
-      it "sets an error on line_items" do
-        _checkout = FactoryGirl.build(:affirm_checkout, extra_line_item: true )
-        _checkout.check_valid_products
-        expect(_checkout.errors[:line_items]).to_not be_empty
-      end
-    end
-
-
-    context "with the checkout details are missing a product" do
-      it "sets an error on line_items" do
-        _checkout = FactoryGirl.build(:affirm_checkout, missing_line_item: true )
-        _checkout.check_valid_products
-        expect(_checkout.errors[:line_items]).to_not be_empty
-      end
-    end
-
-    context "with a line item has mismatched quantity" do
-      it "sets an error for the item" do
-        _checkout = FactoryGirl.build(:affirm_checkout, quantity_mismatch: true )
-        _checkout.check_valid_products
-        expect(_checkout.errors.size).to be(1)
-      end
-    end
-
-    context "with a line item has mismatched price" do
-      it "sets an error for the item" do
-        _checkout = FactoryGirl.build(:affirm_checkout, price_mismatch: true )
-        _checkout.check_valid_products
-        expect(_checkout.errors.size).to be(1)
-      end
-    end
-
-  end
-
-  describe "#check_matching_billing_address" do
-    context "with a matching billing address" do
-      it "does not set any errors for the billing_address" do
-        valid_checkout.check_matching_billing_address
-        expect(valid_checkout.errors.size).to be(0)
-        expect(valid_checkout.errors[:billing_address]).to be_empty
-      end
-
-      context "with alternate address format" do
-        it "does not set any errors for the billing_address" do
-          _checkout = FactoryGirl.build(:affirm_checkout, alternate_billing_address_format: true)
-          valid_checkout.check_matching_billing_address
-          expect(valid_checkout.errors.size).to be(0)
-          expect(valid_checkout.errors[:billing_address]).to be_empty
-        end
-      end
-
-      context "with a name.full instead of first/last" do
-        it "does not set any error for the billing_address" do
-          _checkout = FactoryGirl.build(:affirm_checkout, billing_address_full_name: true)
-          _checkout.check_matching_billing_address
-          expect(_checkout.errors[:billing_address]).to be_empty
-        end
-      end
-    end
-
-    context "with a mismtached billing address" do
-      it "sets an error for the billing_address" do
-        _checkout = FactoryGirl.build(:affirm_checkout, billing_address_mismatch: true)
-        _checkout.check_matching_billing_address
-        expect(_checkout.errors[:billing_address]).not_to be_empty
-      end
-
-      context "with alternate address format" do
-        it "sets an error for the billing_address" do
-          _checkout = FactoryGirl.build(:affirm_checkout, billing_address_mismatch: true, alternate_billing_address_format: true)
-          _checkout.check_matching_billing_address
-          expect(_checkout.errors[:billing_address]).not_to be_empty
-        end
-      end
-
-
-      context "with a name.full instead of first/last" do
-        it "sets an error for the billing_address" do
-          _checkout = FactoryGirl.build(:affirm_checkout, billing_address_mismatch: true, billing_address_full_name: true)
-          _checkout.check_matching_billing_address
-          expect(_checkout.errors[:billing_address]).not_to be_empty
-        end
-      end
-    end
-  end
-
-
-
-  describe "#check_matching_shipping_address" do
-    context "with a matching shipping address" do
-      it "does not set an error for the shipping_address" do
-        valid_checkout.check_matching_shipping_address
-        expect(valid_checkout.errors[:shipping_address]).to be_empty
-      end
-    end
-
-
-    context "with a mismatched shipping address" do
-      it "adds an error for the shipping_address" do
-        _checkout = FactoryGirl.build(:affirm_checkout, shipping_address_mismatch: true)
-        _checkout.check_matching_shipping_address
-        expect(_checkout.errors[:shipping_address]).not_to be_empty
-      end
-    end
-  end
-
-
-  describe "#check_matching_billing_email" do
-    context "with a matching billing email" do
-      it "does not set an error for the billing_email" do
-        valid_checkout.check_matching_billing_email
-        expect(valid_checkout.errors[:billing_email]).to be_empty
-      end
-    end
-
-
-    context "with a mismatched billing email" do
-      it "adds an error for billing_email" do
-        _checkout = FactoryGirl.build(:affirm_checkout, billing_email_mismatch: true)
-        _checkout.check_matching_billing_email
-        expect(_checkout.errors[:billing_email]).not_to be_empty
-      end
-    end
-  end
-
-  describe "actions" do
-
-    describe "#actions" do
-      it "returns capture, void, and credit" do
-        expect(valid_checkout.actions).to eq(['capture', 'void', 'credit'])
-      end
-    end
-
-
-    describe "can_capture?" do
-      context "with a payment response code set" do
-        before(:each) { affirm_payment.response_code = "1234-1234" }
-
-        context "with a payment in pending state" do
-          before(:each) { affirm_payment.state = 'pending' }
-
-          it "returns true" do
-            expect(valid_checkout.can_capture?(affirm_payment)).to be(true)
-          end
-        end
-
-
-        context "with a payment in checkout state" do
-          before(:each) { affirm_payment.state = 'checkout' }
-
-          it "returns true" do
-            expect(valid_checkout.can_capture?(affirm_payment)).to be(true)
-          end
-        end
-
-
-        context "with a payment in complete state" do
-          before(:each) { affirm_payment.state = 'complete' }
-
-          it "returns false" do
-            expect(valid_checkout.can_capture?(affirm_payment)).to be(false)
-          end
-        end
-
-      end
-
-
-      context "with no response code set on the payment" do
-        before(:each) { affirm_payment.response_code = nil }
-
-        it "returns false" do
-          expect(valid_checkout.can_capture?(affirm_payment)).to be(false)
-        end
-      end
-    end
-
-
-    describe "can_void?" do
-      context "with a payment response code set" do
-        before(:each) { affirm_payment.response_code = "1234-1234" }
-
-        context "with a payment in pending state" do
-          before(:each) { affirm_payment.state = 'pending' }
-
-          it "returns true" do
-            expect(valid_checkout.can_void?(affirm_payment)).to be(true)
-          end
-        end
-
-        context "with a payment in checkout state" do
-          before(:each) { affirm_payment.state = 'checkout' }
-
-          it "returns false" do
-            expect(valid_checkout.can_void?(affirm_payment)).to be(false)
-          end
-        end
-
-
-        context "with a payment in complete state" do
-          before(:each) { affirm_payment.state = 'complete' }
-
-          it "returns false" do
-            expect(valid_checkout.can_void?(affirm_payment)).to be(false)
-          end
-        end
-      end
-
-
-      context "with no response code set on the payment" do
-        before(:each) { affirm_payment.response_code = nil }
-
-        it "returns false" do
-          expect(valid_checkout.can_void?(affirm_payment)).to be(false)
-        end
-      end
-    end
-
-
-
-    describe "can_credit?" do
-      context "when the payment has not been completed" do
-        before(:each) { affirm_payment.state = 'pending' }
-
-        it "returns false" do
-          expect(valid_checkout.can_credit?(affirm_payment)).to be(false)
-        end
-      end
-
-      context "when the payment's order state is not 'credit_owed'" do
-        before(:each) do
-          affirm_payment.state = 'completed'
-          affirm_payment.order.payment_state = 'completed'
-        end
-
-        it "returns false" do
-          expect(valid_checkout.can_credit?(affirm_payment)).to be(false)
-        end
-      end
-
-      context "when the payement's order state is 'credit_owed'" do
-        before(:each) { affirm_payment.order.payment_state = 'credit_owed' }
-
-        context "when the payment has been completed" do
-          before(:each) { affirm_payment.state = 'completed'}
-
-          context "when the payment credit_allowed is greater than 0" do
-            before(:each) do
-              affirm_payment.stub(:credit_allowed).and_return 100
-            end
-
-            it "returns true" do
-              expect(valid_checkout.can_credit?(affirm_payment)).to be(true)
-            end
-          end
-
-
-          context "when the payment credit_allowed is equal to 0" do
-            before(:each) do
-              affirm_payment.stub(:credit_allowed).and_return 0
-            end
-
-            it "returns false" do
-              expect(valid_checkout.can_credit?(affirm_payment)).to be(false)
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/models/spree_gateway_affirm_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Gateway::Affirm do
-  let(:affirm_payment) { FactoryGirl.create(:affirm_payment) }
-  let(:affirm_checkout) { FactoryGirl.create(:affirm_checkout) }
-
-  describe '#provider_class' do
-    it "returns the Affirm ActiveMerchant class" do
-      expect(affirm_payment.payment_method.provider_class).to be(ActiveMerchant::Billing::Affirm)
-    end
-  end
-
-  describe '#payment_source_class' do
-    it "returns the affirm_checkout class" do
-      expect(affirm_payment.payment_method.payment_source_class).to be(Spree::AffirmCheckout)
-    end
-  end
-
-  describe '#source_required?' do
-    it "returns true" do
-      expect(affirm_payment.payment_method.source_required?).to be(true)
-    end
-  end
-
-  describe '#method_type?' do
-    it 'returns "affirm"' do
-      expect(affirm_payment.payment_method.method_type).to eq("affirm")
-    end
-  end
-
-  describe '#actions?' do
-    it "retuns capture, void and credit" do
-      expect(affirm_payment.payment_method.actions).to eq(['capture', 'void', 'credit'])
-    end
-  end
-
-  describe '#supports?' do
-    it "returns true if the source is an AffirmCheckout" do
-      expect(affirm_payment.payment_method.supports?(affirm_checkout)).to be(true)
-    end
-
-    it "returns false when the source is not an affirm" do
-      expect(affirm_payment.payment_method.supports?(6)).to be(false)
-      expect(affirm_payment.payment_method.supports?(affirm_payment)).to be(false)
-      expect(affirm_payment.payment_method.supports?(Spree::Order.new)).to be(false)
-    end
-  end
-
-
-  describe "#cancel" do
-    context "when there is no payment with the given charge_ari" do
-      it "returns nil" do
-        expect(affirm_payment.payment_method.cancel("xxxx-xxxx")).to be(nil)
-      end
-    end
-
-    context "when the payment is in a completed state" do
-      before(:each) do
-        affirm_payment.stub(:completed?).and_return true
-        affirm_payment.state = "completed"
-        affirm_payment.save
-      end
-
-      context "when credit_allowed amount is > 0" do
-        it "calls credit! on the payment with the credit_allowed amount" do
-          Spree::Payment.stub_chain(:valid, :where, :first).and_return(affirm_payment)
-          affirm_payment.stub(:can_credit?).and_return(true)
-          expect(affirm_payment).to receive(:credit!).and_return false
-          affirm_payment.payment_method.cancel affirm_payment.response_code
-        end
-
-        it "creates an adjustment for the -credit_allowed amount" do
-          Spree::Payment.stub_chain(:valid, :where, :first).and_return(affirm_payment)
-          affirm_payment.stub(:can_credit?).and_return(true)
-          expect(affirm_payment).to receive(:credit!).and_return false
-          _payment_amount = affirm_payment.credit_allowed
-          affirm_payment.payment_method.cancel affirm_payment.response_code
-        end
-      end
-
-      context "when credit_allowed amount is 0" do
-        it "does not credit the payment" do
-          Spree::Payment.stub_chain(:valid, :where, :first).and_return(affirm_payment)
-          affirm_payment.stub(:can_credit?).and_return(false)
-          expect(affirm_payment).not_to receive(:credit!)
-          affirm_payment.payment_method.cancel affirm_payment.response_code
-        end
-      end
-    end
-
-    context "when the payment is in a failed state" do
-      before do
-        affirm_payment.state = "failed"
-        affirm_payment.save
-      end
-
-      it "does nothing" do
-        expect(affirm_payment).not_to receive(:credit!)
-        expect(affirm_payment).not_to receive(:void_transaction!)
-        affirm_payment.payment_method.cancel affirm_payment.response_code
-      end
-    end
-
-    context "when the payment is in an invalid state" do
-      before do
-        affirm_payment.state = "invalid"
-        affirm_payment.save
-      end
-
-      it "does nothing" do
-        expect(affirm_payment).not_to receive(:credit!)
-        expect(affirm_payment).not_to receive(:void_transaction!)
-        affirm_payment.payment_method.cancel affirm_payment.response_code
-      end
-    end
-
-
-    context "when the payment is in a pending state" do
-      before do
-        affirm_payment.stub(:pending?).and_return true
-        affirm_payment.state = "pending"
-        affirm_payment.save
-      end
-
-      it "voids the transaction" do
-        Spree::Payment.stub_chain(:valid, :where, :first).and_return(affirm_payment)
-        expect(affirm_payment).not_to receive(:credit!)
-        expect(affirm_payment).to receive(:void_transaction!).and_return false
-        affirm_payment.payment_method.cancel affirm_payment.response_code
-      end
-    end
-
-  end
-end