solidus_braintree 1.4.0 → 2.0.0

data/spec/models/solidus_braintree/transaction_address_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe SolidusBraintree::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
+
+    unless SolidusSupport.combined_first_and_last_name_in_address?
+      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
+  end
+end

data/spec/models/solidus_braintree/transaction_import_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+
+describe SolidusBraintree::TransactionImport do
+  let(:order) { Spree::Order.new }
+  let!(:country) { create :country, iso: "US" }
+  let(:braintree_gateway) { SolidusBraintree::Gateway.new }
+  let(:transaction_address) { nil }
+  let(:transaction) do
+    SolidusBraintree::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) { SolidusBraintree::Transaction.new }
+
+      it { is_expected.to be false }
+    end
+
+    context "with invalid address" do
+      let(:transaction_address) do
+        SolidusBraintree::TransactionAddress.new(
+          name: "Bruce Wayne",
+          address_line_1: "42 Spruce Lane",
+          city: "Gotham",
+          state_code: "WA",
+          country_code: "US"
+        )
+      end
+
+      before do
+        create(:state, state_code: "WA")
+      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 SolidusBraintree::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
+
+    it 'takes the paypal funding source from the transaction' do
+      transaction.paypal_funding_source = 'paypal'
+
+      expect(subject.paypal_funding_source).to eq('paypal')
+    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(:transaction_address) { nil }
+    let(:end_state) { 'confirm' }
+
+    let(:transaction) do
+      SolidusBraintree::Transaction.new(
+        nonce: 'fake-valid-nonce',
+        payment_method: payment_method,
+        address: transaction_address,
+        payment_type: SolidusBraintree::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
+      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
+          SolidusBraintree::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 'when transaction has paypal funding source' do
+          it 'saves it to the payment source' do
+            transaction.paypal_funding_source = 'paypal'
+
+            subject
+
+            source = SolidusBraintree::Source.last
+            expect(source.paypal_funding_source).to eq('paypal')
+          end
+        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
+        SolidusBraintree::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(
+          SolidusBraintree::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

data/spec/models/solidus_braintree/transaction_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe SolidusBraintree::Transaction do
+  describe "#valid?" do
+    subject { transaction.valid? }
+
+    let(:valid_attributes) do
+      {
+        nonce: 'abcde-fghjkl-lmnop',
+        payment_method: SolidusBraintree::Gateway.new,
+        payment_type: 'ApplePayCard',
+        email: "test@example.com"
+      }
+    end
+    let(:valid_address_attributes) do
+      {
+        address_attributes: {
+          name: "Bruce Wayne",
+          address_line_1: "42 Spruce Lane",
+          city: "Gotham",
+          zip: "98201",
+          state_code: "WA",
+          country_code: "US"
+        }
+      }
+    end
+    let(:transaction) { described_class.new(valid_attributes) }
+
+    before do
+      create(:country, iso: "US")
+      create(:state, state_code: "WA")
+    end
+
+    it { is_expected.to be true }
+
+    context 'without nonce' do
+      let(:valid_attributes) { super().except(:nonce) }
+
+      it { is_expected.to be false }
+    end
+
+    context 'without gateway' do
+      let(:valid_attributes) { super().except(:payment_method) }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with bad gateway' do
+      let(:valid_attributes) { super().merge(payment_method: Spree::PaymentMethod.new) }
+
+      it { is_expected.to be false }
+    end
+
+    context 'without payment_type' do
+      let(:valid_attributes) { super().except(:payment_type) }
+
+      it { is_expected.to be false }
+    end
+
+    context 'without email' do
+      let(:valid_attributes) { super().except(:email) }
+
+      it { is_expected.to be false }
+    end
+
+    context "with valid address" do
+      let(:valid_attributes) { super().merge(valid_address_attributes) }
+
+      it { is_expected.to be true }
+    end
+
+    context "with invalid address" do
+      let(:valid_attributes) { super().merge(valid_address_attributes) }
+
+      before { valid_address_attributes[:address_attributes][:zip] = nil }
+
+      it { is_expected.to be false }
+
+      it "sets useful error messages" do
+        transaction.valid?
+        expect(transaction.errors.full_messages).
+          to eq ["Address Zip can't be blank"]
+      end
+    end
+  end
+end

data/spec/models/spree/store_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Spree::Store do
+  describe 'before_create :build_default_configuration' do
+    context 'when a braintree_configuration record already exists' do
+      it 'does not overwrite it' do
+        store = build(:store)
+        custom_braintree_configuration = store.build_braintree_configuration
+        store.save!
+        expect(store.braintree_configuration).to be custom_braintree_configuration
+      end
+    end
+  end
+end

data/spec/requests/spree/api/orders_controller_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Spree::Api::OrdersController, type: :request do
+  stub_authorization!
+
+  describe 'get show' do
+    let(:gateway) { create_gateway }
+    let(:order) { create(:order_with_line_items) }
+    let(:source) do
+      SolidusBraintree::Source.new(
+        nonce: 'fake-valid-nonce',
+        user: order.user,
+        payment_type: SolidusBraintree::Source::PAYPAL,
+        payment_method: gateway
+      )
+    end
+
+    context 'when using braintree as the payment' do
+      before do
+        allow_any_instance_of(Spree::Payment).to receive(:create_payment_profile).and_return(true)
+
+        order.payments.create!(
+          payment_method: gateway,
+          source: source,
+          amount: 55
+        )
+      end
+
+      it "can be rendered correctly" do
+        get "/api/orders/#{order.number}"
+
+        expect(response).to have_http_status :ok
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+# Run Coverage report
+require 'solidus_dev_support/rspec/coverage'
+require 'rails-controller-testing'
+
+# Create the dummy app if it's still missing.
+dummy_env = "#{__dir__}/dummy/config/environment.rb"
+system 'bin/rake extension:test_app' unless File.exist? dummy_env
+require dummy_env
+
+# Requires factories and other useful helpers defined in spree_core.
+require 'solidus_dev_support/rspec/feature_helper'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{__dir__}/support/**/*.rb"].sort.each { |f| require f }
+
+# Requires factories defined in lib/solidus_braintree/testing_support/factories.rb
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusBraintree::Engine)
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+  config.use_transactional_fixtures = false
+
+  if Spree.solidus_gem_version < Gem::Version.new('2.11')
+    config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :system
+  end
+end