solidus_paypal_braintree 1.1.0 → 1.1.1

data/spec/models/solidus_paypal_braintree/transaction_address_spec.rb

@@ -1,235 +0,0 @@
-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
-
-    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_paypal_braintree/transaction_import_spec.rb

@@ -1,300 +0,0 @@
-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
-
-    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(: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 'when transaction has paypal funding source' do
-          it 'saves it to the payment source' do
-            transaction.paypal_funding_source = 'paypal'
-
-            subject
-
-            source = SolidusPaypalBraintree::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
-        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

data/spec/models/solidus_paypal_braintree/transaction_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe SolidusPaypalBraintree::Transaction do
-  describe "#valid?" do
-    subject { transaction.valid? }
-
-    let(:valid_attributes) do
-      {
-        nonce: 'abcde-fghjkl-lmnop',
-        payment_method: SolidusPaypalBraintree::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")
-    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

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

@@ -1,36 +0,0 @@
-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
-      SolidusPaypalBraintree::Source.new(
-        nonce: 'fake-valid-nonce',
-        user: order.user,
-        payment_type: SolidusPaypalBraintree::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.status).to eq 200
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# Configure Rails Environment
-ENV['RAILS_ENV'] ||= 'test'
-
-# Run Coverage report
-require 'solidus_dev_support/rspec/coverage'
-
-require File.expand_path('dummy/config/environment.rb', __dir__)
-
-require 'rails-controller-testing'
-Rails::Controller::Testing.install
-
-# 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[File.join(File.dirname(__FILE__), 'support/**/*.rb')].sort.each { |f| require f }
-
-# Requires factories defined in lib/solidus_paypal_braintree/factories.rb
-require 'solidus_paypal_braintree/factories'
-
-RSpec.configure do |config|
-  config.infer_spec_type_from_file_location!
-  config.use_transactional_fixtures = false
-  config.raise_errors_for_deprecations!
-  config.example_status_persistence_file_path = "./spec/examples.txt"
-end

data/spec/support/capybara.rb

@@ -1,7 +0,0 @@
-RSpec.configure do |config|
-  config.before(:each, type: :feature, js: true) do
-    page.driver.browser.manage.window.resize_to(1600, 1024)
-  end
-end
-
-Capybara.javascript_driver = (ENV['CAPYBARA_DRIVER'] || :selenium_chrome).to_sym