solidus_paypal_braintree 0.4.0 → 1.0.0

data/spec/models/solidus_paypal_braintree/transaction_address_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+
+describe SolidusPaypalBraintree::TransactionAddress do
+  describe "#valid?" do
+    subject { address.valid? }
+
+    let(:address) { described_class.new(valid_attributes) }
+
+    let(:valid_attributes) do
+      {
+        name: "Bruce Wayne",
+        address_line_1: "42 Spruce Lane",
+        city: "Gotham",
+        zip: "98201",
+        state_code: "WA",
+        country_code: "US"
+      }
+    end
+
+    let(:country) { create :country, iso: 'US', states_required: true }
+
+    before do
+      create :state, abbr: "WA", country: country
+    end
+
+    it { is_expected.to be true }
+
+    context 'without country matches' do
+      let(:valid_attributes) { super().merge({ country_code: 'CA' }) }
+
+      it { is_expected.to be false }
+    end
+
+    context "without name" do
+      let(:valid_attributes) { super().except(:name) }
+
+      it { is_expected.to be false }
+    end
+
+    context "without address_line_1" do
+      let(:valid_attributes) { super().except(:address_line_1) }
+
+      it { is_expected.to be false }
+    end
+
+    context "without city" do
+      let(:valid_attributes) { super().except(:city) }
+
+      it { is_expected.to be false }
+    end
+
+    context "without zip" do
+      let(:valid_attributes) { super().except(:zip) }
+
+      it { is_expected.to be false }
+    end
+
+    context "without state_code" do
+      let(:valid_attributes) { super().except(:state_code) }
+
+      it { is_expected.to be false }
+
+      context "when country does not requires states" do
+        let(:country) { create :country, iso: 'US', states_required: false }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "without country_code" do
+      let(:valid_attributes) { super().except(:country_code) }
+
+      it { is_expected.to be true }
+
+      it "defaults to the US" do
+        subject
+        expect(address.country_code).to eq "us"
+      end
+    end
+
+    context "with a one word name" do
+      let(:valid_attributes) { super().merge({ name: "Bruce" }) }
+
+      it { is_expected.to be true }
+    end
+  end
+
+  describe "#attributes=" do
+    subject { described_class.new(attrs) }
+
+    context "when an ISO code is provided" do
+      let(:attrs) { { country_code: "US" } }
+
+      it "uses the ISO code provided" do
+        expect(subject.country_code).to eq "US"
+      end
+    end
+
+    context "when the ISO code is blank" do
+      context "with a valid country name provided" do
+        before do
+          create :country, name: "canada", iso: "CA"
+        end
+
+        let(:attrs) { { country_name: "Canada" } }
+
+        it "looks up the ISO code by the country name" do
+          expect(subject.country_code).to eq "CA"
+        end
+      end
+
+      context "without valid country name" do
+        let(:attrs) { { country_name: "Neverland" } }
+
+        it "leaves the country code blank" do
+          expect(subject.country_code).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#spree_country' do
+    subject { described_class.new(country_code: country_code).spree_country }
+
+    before do
+      create :country, name: 'United States', iso: 'US'
+    end
+
+    ['us', 'US'].each do |code|
+      let(:country_code) { code }
+
+      it 'looks up by iso' do
+        expect(subject.name).to eq 'United States'
+      end
+    end
+
+    context 'when country does not exist' do
+      let(:country_code) { 'NA' }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#spree_state' do
+    subject { described_class.new(country_code: 'US', state_code: state_code).spree_state }
+
+    let(:state_code) { 'newy' }
+
+    it { is_expected.to be_nil }
+
+    context 'when state exists' do
+      before do
+        us = create :country, iso: 'US'
+        create :state, abbr: 'NY', name: 'New York', country: us
+      end
+
+      ['ny', ' ny', 'ny ', 'New York', 'new york', 'NY'].each do |code|
+        let(:state_code) { code }
+
+        it 'looks up the right state' do
+          expect(subject.abbr).to eq "NY"
+        end
+      end
+
+      context 'with no matching state' do
+        let(:state_code) { 'AL' }
+
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+
+  describe '#should_match_state_model' do
+    subject { described_class.new(country_code: 'US').should_match_state_model? }
+
+    it { is_expected.to be_falsey }
+
+    context 'when country does not require states' do
+      before { create :country, iso: 'US', states_required: false }
+
+      it { is_expected.to be false }
+    end
+
+    context 'when country requires states' do
+      before { create :country, iso: 'US', states_required: true }
+
+      it { is_expected.to be true }
+    end
+  end
+
+  describe '#to_spree_address' do
+    subject { described_class.new(address_params).to_spree_address }
+
+    let(:address_params) do
+      {
+        country_code: 'US',
+        state_code: 'NY',
+        name: "Alfred"
+      }
+    end
+    let!(:us) { create :country, iso: 'US' }
+
+    it { is_expected.to be_a Spree::Address }
+
+    context 'when country exists with states' do
+      before do
+        create :state, country: us, abbr: 'NY', name: 'New York'
+      end
+
+      it 'uses state model' do
+        expect(subject.state.name).to eq 'New York'
+      end
+    end
+
+    context 'when country exist with no states' do
+      it 'uses state_name' do
+        expect(subject.state).to be_nil
+        expect(subject.state_text).to eq 'NY'
+      end
+    end
+
+    context 'when using first_name and last_name' do
+      let(:address_params) { super().merge({ first_name: "Bruce", last_name: "Wayne" }) }
+
+      it 'displays a deprecation warning' do
+        expect(Spree::Deprecation).to receive(:warn).
+          with("first_name and last_name are deprecated. Use name instead.", any_args)
+
+        subject
+      end
+    end
+  end
+
+  describe "#split" do
+    subject { described_class.new.split_name(name) }
+
+    context "with a one word name" do
+      let(:name) { "Bruce" }
+
+      it "correctly splits" do
+        expect(subject).to eq ["Bruce"]
+      end
+    end
+
+    context "with a multi word name" do
+      let(:name) { "Bruce Wayne The Batman" }
+
+      it "correctly splits" do
+        expect(subject).to eq ["Bruce", "Wayne The Batman"]
+      end
+    end
+  end
+end

data/spec/models/solidus_paypal_braintree/transaction_import_spec.rb

@@ -0,0 +1,283 @@
+require 'spec_helper'
+
+describe SolidusPaypalBraintree::TransactionImport do
+  let(:order) { Spree::Order.new }
+  let!(:country) { create :country, iso: "US" }
+  let(:braintree_gateway) { SolidusPaypalBraintree::Gateway.new }
+  let(:transaction_address) { nil }
+  let(:transaction) do
+    SolidusPaypalBraintree::Transaction.new(
+      nonce: 'abcd1234',
+      payment_type: "ApplePayCard",
+      address: transaction_address,
+      payment_method: braintree_gateway,
+      email: "test@example.com",
+      phone: "123-456-6789"
+    )
+  end
+  let(:transaction_import) { described_class.new(order, transaction) }
+
+  describe "#valid?" do
+    subject { transaction_import.valid? }
+
+    it { is_expected.to be true }
+
+    context "with invalid transaction" do
+      let(:transaction) { SolidusPaypalBraintree::Transaction.new }
+
+      it { is_expected.to be false }
+    end
+
+    context "with invalid address" do
+      let(:transaction_address) do
+        SolidusPaypalBraintree::TransactionAddress.new(
+          name: "Bruce Wayne",
+          address_line_1: "42 Spruce Lane",
+          city: "Gotham",
+          state_code: "WA",
+          country_code: "US"
+        )
+      end
+
+      it { is_expected.to be false }
+
+      it "sets useful error messages" do
+        transaction_import.valid?
+        expect(transaction_import.errors.full_messages).
+          to eq ["Address is invalid", "Address zip can't be blank"]
+      end
+    end
+  end
+
+  describe '#source' do
+    subject { described_class.new(order, transaction).source }
+
+    it { is_expected.to be_a SolidusPaypalBraintree::Source }
+
+    it 'takes the nonce from the transaction' do
+      expect(subject.nonce).to eq 'abcd1234'
+    end
+
+    it 'takes the payment type from the transaction' do
+      expect(subject.payment_type).to eq 'ApplePayCard'
+    end
+
+    it 'takes the payment method from the transaction' do
+      expect(subject.payment_method).to eq braintree_gateway
+    end
+
+    context 'when order has a user' do
+      let(:user) { Spree.user_class.new }
+      let(:order) { Spree::Order.new user: user }
+
+      it 'associates user to the source' do
+        expect(subject.user).to eq user
+      end
+    end
+  end
+
+  describe '#user' do
+    subject { described_class.new(order, transaction).user }
+
+    it { is_expected.to be_nil }
+
+    context 'when order has a user' do
+      let(:user) { Spree.user_class.new }
+      let(:order) { Spree::Order.new user: user }
+
+      it { is_expected.to eq user }
+    end
+  end
+
+  describe '#import!' do
+    subject { described_class.new(order, transaction).import!(end_state) }
+
+    let(:store) { create :store }
+    let(:variant) { create :variant }
+    let(:line_item) { Spree::LineItem.new(variant: variant, quantity: 1, price: 10) }
+    let(:address) { create :address, country: country }
+    let(:order) {
+      Spree::Order.create(
+        number: "R999999999",
+        store: store,
+        line_items: [line_item],
+        ship_address: address,
+        currency: 'USD',
+        total: 10,
+        email: 'test@example.com'
+      )
+    }
+    let(:payment_method) { create_gateway }
+
+    let(:country) { create :country, iso: 'US', states_required: true }
+    let(:transaction_address) { nil }
+    let(:end_state) { 'confirm' }
+
+    let(:transaction) do
+      SolidusPaypalBraintree::Transaction.new(
+        nonce: 'fake-valid-nonce',
+        payment_method: payment_method,
+        address: transaction_address,
+        payment_type: SolidusPaypalBraintree::Source::PAYPAL,
+        phone: '123-456-7890',
+        email: 'user@example.com'
+      )
+    end
+
+    before do
+      # create a shipping method so we can push through to the end
+      country
+      create :shipping_method, cost: 5
+
+      # ensure payments have the same number so VCR matches the request body
+      allow_any_instance_of(Spree::Payment).
+        to receive(:generate_identifier).
+        and_return("ABCD1234")
+    end
+
+    context "with passing validation", vcr: {
+      cassette_name: 'transaction/import/valid',
+      match_requests_on: [:braintree_uri]
+    } do
+      context "when order end state is confirm" do
+        it 'advances order to confirm state' do
+          subject
+          expect(order.state).to eq 'confirm'
+        end
+
+        it 'has a payment for the cost of line items + shipment' do
+          subject
+          expect(order.payments.first.amount).to eq 15
+        end
+
+        it 'is complete and capturable', aggregate_failures: true, vcr: {
+          cassette_name: 'transaction/import/valid/capture',
+          match_requests_on: [:braintree_uri]
+        } do
+          subject
+          order.complete
+
+          expect(order).to be_complete
+          expect(order.payments.first).to be_pending
+
+          order.payments.first.capture!
+          # need to reload, as capture will update the order
+          expect(order.reload).to be_paid
+        end
+      end
+
+      context "when order end state is delivery" do
+        let(:end_state) { 'delivery' }
+
+        it "advances the order to delivery" do
+          subject
+          expect(order.state).to eq 'delivery'
+        end
+
+        it "has a payment for the cost of line items" do
+          subject
+          expect(order.payments.first.amount).to eq 10
+        end
+      end
+
+      context 'when transaction has address' do
+        let!(:new_york) { create :state, country: country, abbr: 'NY' }
+
+        let(:transaction_address) do
+          SolidusPaypalBraintree::TransactionAddress.new(
+            country_code: 'US',
+            name: 'Thaddeus Venture',
+            city: 'New York',
+            state_code: 'NY',
+            address_line_1: '350 5th Ave',
+            zip: '10118'
+          )
+        end
+
+        it 'uses the new address', aggregate_failures: true do
+          subject
+          expect(order.shipping_address.address1).to eq '350 5th Ave'
+          expect(order.shipping_address.country).to eq country
+          expect(order.shipping_address.state).to eq new_york
+        end
+
+        context 'with a tax category' do
+          before do
+            zone = Spree::Zone.create name: 'nyc tax'
+            zone.members << Spree::ZoneMember.new(zoneable: new_york)
+            create :tax_rate, zone: zone
+          end
+
+          it 'includes the tax in the payment' do
+            subject
+            expect(order.payments.first.amount).to eq 16
+          end
+        end
+
+        context 'with a less expensive tax category' do
+          before do
+            original_zone = Spree::Zone.create name: 'first address tax'
+            original_zone.members << Spree::ZoneMember.new(zoneable: address.state)
+            original_tax_rate = create :tax_rate, zone: original_zone, amount: 0.2
+
+            # new address is NY
+            ny_zone = Spree::Zone.create name: 'nyc tax'
+            ny_zone.members << Spree::ZoneMember.new(zoneable: new_york)
+            create :tax_rate, tax_categories: [original_tax_rate.tax_categories.first], zone: ny_zone, amount: 0.1
+          end
+
+          it 'includes the lower tax in the payment' do
+            # so shipments and shipment cost is calculated before transaction import
+            order.next!; order.next!
+            # precondition
+            expect(order.additional_tax_total).to eq 2
+            expect(order.total).to eq 17
+
+            subject
+            expect(order.additional_tax_total).to eq 1
+            expect(order.payments.first.amount).to eq 16
+          end
+        end
+      end
+    end
+
+    context "when validation fails" do
+      let(:transaction_address) do
+        SolidusPaypalBraintree::TransactionAddress.new(
+          country_code: 'US',
+          name: 'Thaddeus Venture',
+          city: 'New York',
+          state_code: 'NY',
+          address_line_1: '350 5th Ave'
+        )
+      end
+
+      it "raises an error with the validation messages" do
+        expect { subject }.to raise_error(
+          SolidusPaypalBraintree::TransactionImport::InvalidImportError
+        )
+      end
+    end
+
+    context "with checkout flow", vcr: {
+      cassette_name: 'transaction/import/valid',
+      match_requests_on: [:braintree_uri]
+    } do
+      it "is not restarted by default" do
+        expect(order).not_to receive(:restart_checkout_flow)
+        subject
+      end
+
+      context "with restart_checkout: true" do
+        subject do
+          described_class.new(order, transaction).import!(end_state, restart_checkout: true)
+        end
+
+        it "is restarted" do
+          expect(order).to receive(:restart_checkout_flow)
+          subject
+        end
+      end
+    end
+  end
+end