solidus_paypal_commerce_platform 0.3.0 → 0.4.0

data/spec/models/solidus_paypal_commerce_platform/payment_method_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::PaymentMethod, type: :model do
-  let(:paypal_payment_method) { create(:paypal_payment_method) }
-  let(:payment) { create(:payment) }
-  let(:completed_payment) { create(:payment, :completed) }
-  let(:response) { Struct(status_code: status_code, result: result, headers: headers) }
-  let(:status_code) { 201 }
-  let(:result) { nil }
-  let(:headers) { {} }
-
-  def Struct(data) # rubocop:disable Naming/MethodName
-    Struct.new(*data.keys, keyword_init: true).new(data)
-  end
-
-  before { allow_any_instance_of(PayPal::PayPalHttpClient).to receive(:execute) { response } }
-
-  describe "#purchase" do
-    let(:result) { Struct(purchase_units: [Struct(payments: payments)]) }
-    let(:payments) { Struct(captures: [Struct(id: SecureRandom.hex(4))]) }
-
-    it "sends a purchase request to paypal" do
-      paypal_order_id = SecureRandom.hex(8)
-      source = paypal_payment_method.payment_source_class.create(paypal_order_id: paypal_order_id)
-      expect_request(:OrdersCaptureRequest).to receive(:new).with(paypal_order_id).and_call_original
-      paypal_payment_method.purchase(1000, source, {})
-    end
-  end
-
-  describe "#authorize" do
-    let(:result) { Struct(purchase_units: [Struct(payments: payments)]) }
-    let(:payments) { Struct(authorizations: [Struct(id: SecureRandom.hex(4))]) }
-
-    it "sends an authorize request to paypal" do
-      paypal_order_id = SecureRandom.hex(8)
-      source = paypal_payment_method.payment_source_class.create(paypal_order_id: paypal_order_id)
-      expect_request(:OrdersAuthorizeRequest).to receive(:new).with(paypal_order_id)
-      paypal_payment_method.authorize(1000, source, {})
-    end
-  end
-
-  describe "#capture" do
-    let(:result) { Struct(id: SecureRandom.hex(4)) }
-
-    it "sends a capture request to paypal" do
-      authorization_id = SecureRandom.hex(8)
-      source = paypal_payment_method.payment_source_class.create(authorization_id: authorization_id)
-      payment.source = source
-      expect_request(:AuthorizationsCaptureRequest).to receive(:new).with(authorization_id).and_call_original
-      paypal_payment_method.capture(1000, {}, originator: payment)
-    end
-  end
-
-  describe "#void" do
-    it "sends a void request to paypal" do
-      authorization_id = SecureRandom.hex(8)
-      source = paypal_payment_method.payment_source_class.create(authorization_id: authorization_id)
-      payment.source = source
-      expect_request(:AuthorizationsVoidRequest).to receive(:new).with(authorization_id)
-      paypal_payment_method.void(nil, originator: payment)
-    end
-  end
-
-  describe "#credit" do
-    let(:result) { Struct(id: SecureRandom.hex(4)) }
-
-    it "sends a refund request to paypal" do
-      capture_id = SecureRandom.hex(4)
-      source = paypal_payment_method.payment_source_class.create(capture_id: capture_id)
-      completed_payment.source = source
-      expect_request(:CapturesRefundRequest).to receive(:new).with(capture_id).and_call_original
-      paypal_payment_method.credit(1000, {}, originator: completed_payment.refunds.new(amount: 12))
-      expect(source.refund_id).not_to be_blank
-    end
-  end
-
-  describe '.javascript_sdk_url' do
-    subject(:url) { URI(paypal_payment_method.javascript_sdk_url(order: order)) }
-
-    context 'when checkout_steps include "confirm"' do
-      let(:order) { instance_double(Spree::Order, checkout_steps: { "confirm" => "bar" }) }
-
-      it 'sets autocommit' do
-        expect(url.query.split("&")).to include("commit=false")
-      end
-    end
-
-    context 'when checkout_steps does not include "confirm"' do
-      let(:order) { instance_double(Spree::Order, checkout_steps: { "foo" => "bar" }) }
-
-      it 'disables autocommit' do
-        expect(url.query.split("&")).to include("commit=true")
-      end
-    end
-
-    context 'when messaging is turned on' do
-      let(:order) { instance_double(Spree::Order, checkout_steps: { "foo" => "bar" }) }
-
-      it 'includes messaging component' do
-        paypal_payment_method.preferences.update(display_credit_messaging: true)
-        expect(url.query.split("&")).to include("components=buttons%2Cmessages")
-      end
-    end
-
-    context 'when messaging is turned off' do
-      let(:order) { instance_double(Spree::Order, checkout_steps: { "foo" => "bar" }) }
-
-      it 'only includes buttons components' do
-        paypal_payment_method.preferences.update(display_credit_messaging: false)
-        expect(url.query.split("&")).not_to include("messages")
-        expect(url.query.split("&")).to include("components=buttons")
-      end
-    end
-  end
-
-  private
-
-  def expect_request(name)
-    expect(SolidusPaypalCommercePlatform::Gateway.const_get(name))
-  end
-end

data/spec/models/solidus_paypal_commerce_platform/payment_source_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::PaymentSource, type: :model do
-  let(:order) { Spree::TestingSupport::OrderWalkthrough.up_to(:payment) }
-  let(:paypal_payment_method) { create(:paypal_payment_method) }
-  let(:paypal_order_id) { "foo-123" }
-  let(:payment_source) {
-    described_class.new(
-      paypal_order_id: paypal_order_id,
-      payment_method: paypal_payment_method,
-    )
-  }
-  let(:payment) {
-    order.payments.create!(
-      payment_method: paypal_payment_method,
-      source: payment_source
-    )
-  }
-  let(:paypal_order_status) { "COMPLETED" }
-
-  before do
-    allow_any_instance_of(SolidusPaypalCommercePlatform::Client).to receive(:execute) do |_client, request|
-      expect(request).to be_a(SolidusPaypalCommercePlatform::Gateway::OrdersGetRequest) # rubocop:disable RSpec/ExpectInHook
-      OpenStruct.new(result: OpenStruct.new(status: paypal_order_status))
-    end
-  end
-
-  describe '#actions' do
-    context 'when the payment is not yet completed' do
-      it 'shows "capture" and "void"' do
-        expect(payment.actions).to contain_exactly("capture", "void")
-      end
-    end
-
-    context 'when the payment is completed and captured' do
-      before do
-        payment.update!(state: :completed, amount: 123)
-        payment_source.update!(capture_id: 1234)
-      end
-
-      it 'shows "credit"' do
-        expect(payment.actions).to contain_exactly("credit")
-      end
-
-      context 'when the PayPal order status is not COMPLETED' do
-        let(:paypal_order_status) { "FOOBAR" }
-
-        it 'hides the "credit" action' do
-          expect(payment.actions).not_to include("credit")
-        end
-      end
-    end
-
-    context 'when it cannot capture' do
-      it 'also cannot void' do
-        # One for "capture", and one for "void"
-        expect(payment_source).to receive(:can_capture?).and_return(false).twice
-        expect(payment.actions).not_to include("void")
-      end
-    end
-  end
-end

data/spec/models/solidus_paypal_commerce_platform/paypal_address_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::PaypalAddress, type: :model do
-  let(:order) { create(:order) }
-  let(:original_address) { create(:address) }
-  let(:address) { create(:address, name_attributes) }
-  let(:params) {
-    {
-      updated_address: {
-        admin_area_1: address.state.abbr,
-        admin_area_2: address.city,
-        address_line_1: address.address1,
-        address_line_2: address.address2,
-        postal_code: address.zipcode,
-        country_code: address.country.iso
-      },
-      recipient: {
-        name: {
-          given_name: "Alexander",
-          surname: "Hamilton"
-        }
-      }
-    }
-  }
-
-  describe "#update_address" do
-    subject{ order.ship_address }
-
-    it "formats PayPal addresses correctly" do
-      order.ship_address = original_address
-
-      described_class.new(order).update(params)
-
-      expect(subject.state).to eq address.state
-      expect(subject.city).to eq address.city
-      expect(subject.address1).to eq address.address1
-      expect(subject.address2).to eq address.address2
-      expect(subject.zipcode).to eq address.zipcode
-      expect(subject.country).to eq address.country
-      if SolidusSupport.combined_first_and_last_name_in_address?
-        expect(subject.name).to eq address.name
-      else
-        expect(subject.firstname).to eq address.firstname
-        expect(subject.lastname).to eq address.lastname
-      end
-      expect(subject.phone).to eq original_address.phone
-    end
-
-    context "when no address exists" do
-      it "produce a valid address" do
-        order.ship_address = nil
-
-        described_class.new(order).update(params)
-
-        expect(subject).to be_present
-      end
-    end
-  end
-
-  def name_attributes
-    if SolidusSupport.combined_first_and_last_name_in_address?
-      { name: "Alexander Hamilton" }
-    else
-      { firstname: "Alexander", lastname: "Hamilton" }
-    end
-  end
-end

data/spec/models/solidus_paypal_commerce_platform/state_guesser_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::StateGuesser, type: :model do
-  let(:country) { create(:country, iso: "IT") }
-  let!(:state) { create(:state, country: country, name: "Abruzzo") }
-
-  describe "#guess" do
-    context "with a guessable state error" do
-      it "correctly guesses the state" do
-        expect(
-          described_class.new("Pescara", country).guess
-        ).to eq state
-      end
-
-      it "guesses the state using an abbreviation" do
-        expect(
-          described_class.new("PE", country).guess
-        ).to eq state
-      end
-    end
-
-    context "with an unsolvable state error" do
-      it "returns nil" do
-        expect(
-          described_class.new("Gondor", country).guess
-        ).to eq nil
-      end
-    end
-
-    context "with an already correct state" do
-      it "returns the correct state" do
-        expect(
-          described_class.new("Abruzzo", country).guess
-        ).to eq state
-      end
-    end
-  end
-end

data/spec/models/solidus_paypal_commerce_platform/wizard_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::Wizard do
-  describe "#nonce" do
-    it 'is between 45 and 128 chars long' do
-      expect(subject.nonce.size).to be_between(45, 128)
-    end
-  end
-end

data/spec/requests/solidus_paypal_commerce_platform/orders_controller_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::OrdersController, type: :request do
-  stub_authorization!
-  let(:order) { create(:order_with_line_items) }
-
-  describe "GET /solidus_paypal_commerce_platform/verify_total" do
-    context "when the amount is correct" do
-      it "passes" do
-        params = {
-          order_id: order.number,
-          paypal_total: order.total,
-          format: :json
-        }
-
-        get solidus_paypal_commerce_platform.verify_total_path, params: params
-
-        expect(response).to have_http_status(:ok)
-      end
-    end
-
-    context "when the amount is incorrect" do
-      it "fails" do
-        params = {
-          order_id: order.number,
-          paypal_total: order.total - 1,
-          format: :json
-        }
-
-        get solidus_paypal_commerce_platform.verify_total_path, params: params
-
-        expect(response).to have_http_status(:bad_request)
-      end
-    end
-  end
-end

data/spec/requests/solidus_paypal_commerce_platform/shipping_rates_controller_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::ShippingRatesController, type: :request do
-  stub_authorization!
-  let(:new_country) { create(:country, iso: "IT", states_required: true) }
-  let(:new_state) { create(:state, country: new_country) }
-  let(:new_address) { build(:address, country: new_country, state: new_state) }
-  let(:order) { Spree::TestingSupport::OrderWalkthrough.up_to(:payment) }
-  let(:paypal_address) {
-    {
-      country_code: new_country.iso,
-      city: new_address.city,
-      state: new_state&.abbr,
-      postal_code: new_address.zipcode
-    }
-  }
-
-  describe "GET /simulate_shipping_rates" do
-    before do
-      get solidus_paypal_commerce_platform.shipping_rates_path, params: {
-        order_id: order.number,
-        address: paypal_address
-      }
-    end
-
-    it "returns a paypal_order without the simulated address" do
-      expect(response.body).not_to include "admin_area_1\":\"#{new_address.state.abbr}\""
-      expect(response.body).not_to include "admin_area_1\":\"#{order.ship_address.state.abbr}\""
-    end
-
-    it "does not modify original address" do
-      expect(order.ship_address).not_to eq new_address
-    end
-
-    context "with an invalid address" do
-      let(:new_state) { nil }
-
-      it "returns a list of errors" do
-        expect(response.status).to be(422) # unprocessable_entity
-        expect(response.body).to include "State can't be blank"
-      end
-    end
-  end
-end

data/spec/requests/solidus_paypal_commerce_platform/wizard_controller_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusPaypalCommercePlatform::WizardController, type: :request do
-  stub_authorization!
-
-  let(:wizard) { SolidusPaypalCommercePlatform::Wizard.new }
-
-  describe "POST /solidus_paypal_commerce_platform/wizard" do
-    let(:params) {
-      {
-        authCode: "PFc4d2vp4DVfHqcnEHbGAA12C_H29U39NM_vmQrZBPzdLcxA12Br-GzjbliqXGu3AG6Gfwo5G9GTal6REkcKGMREc9fPsR_wv",
-        sharedId: "awj45zMAy1XonxWfgIhjjGHZGAPStkZFzXp4bfe1QmNWA-9DL6HkpklD0skHig4vVF7zVZD8Uwy5Qop4",
-        nonce: wizard.nonce,
-      }
-    }
-
-    it "creates a new payment method from data received from PayPal" do
-      expect_any_instance_of(SolidusPaypalCommercePlatform::Client).to receive(:execute) do |_client, request|
-        case request
-        when SolidusPaypalCommercePlatform::AccessTokenAuthorizationRequest
-          OpenStruct.new(result: OpenStruct.new(access_token: "ACCESS-TOKEN"))
-        when SolidusPaypalCommercePlatform::FetchMerchantCredentialsRequest
-          expect(request.headers.fetch("Authorization")).to eq("Bearer ACCESS-TOKEN")
-          OpenStruct.new(result: OpenStruct.new(
-            client_id: "CLIENT-ID",
-            client_secret: "CLIENT-SECRET",
-          ))
-        else
-          raise "unexpected request: #{request}"
-        end
-      end.twice
-
-      expect {
-        post solidus_paypal_commerce_platform.wizard_index_path, params: params
-      }.to change(SolidusPaypalCommercePlatform::PaymentMethod, :count).from(0).to(1)
-
-      payment_method = SolidusPaypalCommercePlatform::PaymentMethod.last
-
-      expect(payment_method.preferred_client_id).to eq("CLIENT-ID")
-      expect(payment_method.preferred_client_secret).to eq("CLIENT-SECRET")
-      expect(response).to have_http_status(:created)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-# Configure Rails Environment
-ENV['RAILS_ENV'] = 'test'
-
-# Run Coverage report
-require 'solidus_dev_support/rspec/coverage'
-
-# 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'
-require 'spree/testing_support/order_walkthrough'
-
-# 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_paypal_commerce_platform/testing_support/factories.rb
-SolidusDevSupport::TestingSupport::Factories.load_for(SolidusPaypalCommercePlatform::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

data/spec/support/capybara.rb

@@ -1,11 +0,0 @@
-require "capybara/cuprite"
-
-Capybara.javascript_driver = :cuprite
-
-Capybara.register_driver(:cuprite) do |app|
-  # Set `export INSPECTOR=true` and add `page.driver.debug(binding)` to open a Chrome tab
-  # to debug the browser status.
-  #
-  # See also: https://github.com/rubycdp/cuprite#debugging
-  Capybara::Cuprite::Driver.new(app, window_size: [1920, 1080], inspector: ENV["INSPECTOR"])
-end

data/spec/support/paypal_sdk_script_tag_helper.rb

@@ -1,13 +0,0 @@
-module PaypalSdkScriptTagHelper
-  def js_sdk_script_query
-    URI(page.find('script[src*="sdk/js?"]', visible: false)[:src]).query.split('&')
-  end
-
-  def js_sdk_script_partner_id
-    page.find('script[src*="sdk/js?"]', visible: false)['data-partner-attribution-id']
-  end
-end
-
-RSpec.configure do |config|
-  config.include PaypalSdkScriptTagHelper, type: :feature
-end