solidus_paypal_commerce_platform 0.7.1 → 1.0.0.beta1

data/spec/models/solidus_paypal_commerce_platform/payment_method_spec.rb

@@ -0,0 +1,200 @@
+require 'solidus_paypal_commerce_platform_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 'preferences' do
+    context 'with paypal_button_color' do
+      before do
+        paypal_payment_method.preferences.update(paypal_button_color: 'gold')
+        paypal_payment_method.save
+      end
+
+      it 'cannot be gold when Venmo standalone is enabled' do
+        expect(paypal_payment_method).to be_valid
+        paypal_payment_method.preferences.update(venmo_standalone: 'enabled')
+        expect(paypal_payment_method).to be_invalid
+        paypal_payment_method.preferences.update(venmo_standalone: 'only render standalone')
+        expect(paypal_payment_method).to be_invalid
+      end
+    end
+  end
+
+  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), status: status) }
+
+    context "when payment COMPLETED" do
+      let(:status) { "COMPLETED" }
+
+      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
+        billing_response = paypal_payment_method.capture(1000, {}, originator: payment)
+        expect(billing_response.message).to eq("Authorization captured")
+      end
+    end
+
+    context "when payment PENDING" do
+      let(:status) { "PENDING" }
+
+      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
+        billing_response = paypal_payment_method.capture(1000, {}, originator: payment)
+        expect(billing_response.message).to eq("Payment is awaiting processing on PayPal's side")
+      end
+    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)) }
+
+    let(:order) { build_stubbed(:order) }
+
+    context 'when checkout_steps include "confirm"' do
+      it 'sets autocommit' do
+        expect(url.query.split("&")).to include("commit=false")
+      end
+    end
+
+    context 'when checkout_steps does not include "confirm"' do
+      it 'disables autocommit' do
+        allow(order).to receive(:checkout_steps).and_return([:address, :delivery, :payment])
+        expect(url.query.split("&")).to include("commit=true")
+      end
+    end
+
+    context 'when messaging is turned on' do
+      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
+      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
+
+    context 'when venmo_standalone is "only render standalone"' do
+      before { paypal_payment_method.preferences.update(venmo_standalone: 'only render standalone') }
+
+      it 'includes "enable-funding=venmo" as a parameter' do
+        expect(url.query.split('&')).to include('enable-funding=venmo')
+      end
+    end
+
+    context 'when venmo_standalone is "enabled"' do
+      before { paypal_payment_method.preferences.update(venmo_standalone: 'enabled') }
+
+      it 'includes "enable-funding=venmo" as a parameter' do
+        expect(url.query.split('&')).to include('enable-funding=venmo')
+      end
+    end
+
+    context 'when venmo_standalone is "disabled"' do
+      before { paypal_payment_method.preferences.update(venmo_standalone: 'disabled') }
+
+      it 'does not include the "enable-funding" parameter' do
+        expect(url.query.split('&')).not_to include(match 'enable-funding')
+      end
+    end
+
+    context 'when force_buyer_country is an empty string' do
+      it 'does not include the "buyer-country" parameter' do
+        expect(url.query.split('&')).not_to include(match 'buyer-country')
+      end
+    end
+
+    context 'when force_buyer_country is "US"' do
+      before { paypal_payment_method.preferences.update(force_buyer_country: 'US') }
+
+      it 'includes "buyer-country=US" as a parameter' do
+        expect(url.query.split('&')).to include('buyer-country=US')
+      end
+    end
+
+    context 'when force_buyer_country is "US" but the environment is production' do
+      before {
+        allow(Rails.env).to receive(:production?).and_return(true)
+        paypal_payment_method.preferences.update(force_buyer_country: 'US')
+      }
+
+      it 'includes "buyer-country=US" as a parameter' do
+        expect(url.query.split('&')).not_to include(match 'buyer-country')
+      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

@@ -0,0 +1,119 @@
+require 'solidus_paypal_commerce_platform_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
+
+      # rubocop:disable RSpec/VerifiedDoubles
+      double(
+        'response',
+        result: double('result', status: paypal_order_status)
+      )
+      # rubocop:enable RSpec/VerifiedDoubles
+    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
+
+    context 'with #display_paypal_funding_source' do
+      context 'when the EN locale exists' do
+        it 'translates the funding source' do
+          payment_source.paypal_funding_source = 'card'
+
+          result = payment_source.display_paypal_funding_source
+
+          expect(result).to eq('Credit or debit card')
+        end
+      end
+
+      context "when the locale doesn't exist" do
+        it 'returns the paypal_funding_source as the default' do
+          allow(payment_source).to receive(:paypal_funding_source).and_return('non-existent')
+
+          result = payment_source.display_paypal_funding_source
+
+          expect(result).to eq('non-existent')
+        end
+      end
+    end
+  end
+
+  describe 'attributes' do
+    context 'with paypal_funding_source' do
+      it 'can be nil' do
+        payment_source.paypal_funding_source = nil
+
+        expect(payment_source).to be_valid
+      end
+
+      it 'makes empty strings nil' do
+        payment_source.paypal_funding_source = ''
+
+        result = payment_source.save
+
+        expect(result).to be(true)
+        expect(payment_source.paypal_funding_source).to be_nil
+      end
+
+      it 'gets correctly mapped as an enum' do
+        payment_source.paypal_funding_source = 'applepay'
+
+        result = payment_source.save
+
+        expect(result).to be(true)
+        expect(payment_source.paypal_funding_source).to eq('applepay')
+        expect(payment_source.applepay_funding?).to be(true)
+      end
+    end
+  end
+end

data/spec/models/solidus_paypal_commerce_platform/paypal_address_spec.rb

@@ -0,0 +1,67 @@
+require 'solidus_paypal_commerce_platform_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/paypal_order_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::PaypalOrder, type: :model do
+  describe '#to_json' do
+    subject(:to_json) { described_class.new(order).to_json('intent') }
+
+    let(:order) { create(:order_ready_to_complete, ship_address: ship_address, bill_address: bill_address) }
+    let(:ship_address) { create_address('John', 'Von Doe') }
+    let(:bill_address) { create_address('Johnny', 'Vonny Doey') }
+
+    it { expect { to_json }.not_to raise_error }
+
+    it 'represents amounts as strings with double decimals' do
+      purchase_unit = to_json.dig(:purchase_units, 0)
+      expect(purchase_unit.dig(:amount, :breakdown)).to eq(
+        item_total: { currency_code: "USD", value: "10.00" },
+        shipping: { currency_code: "USD", value: "100.00" },
+        tax_total: { currency_code: "USD", value: "0.00" },
+        discount: { currency_code: "USD", value: "0.00" }
+      )
+      expect(purchase_unit.dig(:items, 0, :unit_amount)).to eq(currency_code: "USD", value: "10.00")
+    end
+
+    it 'maps the bill and ship address names correctly' do
+      expect(to_json).to match hash_including(
+        purchase_units: array_including(
+          hash_including(shipping: hash_including(name: { full_name: 'John Von Doe' }))
+        ),
+        payer: hash_including(name: { given_name: 'Johnny', surname: 'Vonny Doey' })
+      )
+    end
+
+    context 'when the item name is greater than 127 characters' do
+      let(:variant) { create(:variant, product: create(:product, name: 'a' * 128)) }
+      let(:order) do
+        create(:order_ready_to_complete, line_items_attributes: [{ variant: variant, quantity: 1, price: 10 }])
+      end
+
+      it 'returns the truncated name' do
+        expect(to_json).to match hash_including(
+          purchase_units: array_including(
+            hash_including(
+              items: array_including(hash_including(name: "#{'a' * 124}..."))
+            )
+          )
+        )
+      end
+    end
+
+    context 'when checkout_steps does not include "delivery"' do
+      let(:old_checkout_flow) { Spree::Order.checkout_flow }
+
+      before do
+        old_checkout_flow
+
+        Spree::Order.class_eval do
+          remove_checkout_step :delivery
+        end
+      end
+
+      after do
+        Spree::Order.checkout_flow(&old_checkout_flow)
+      end
+
+      it 'disable shipping requirements' do
+        expect(to_json).to match hash_including(
+          application_context: hash_including(shipping_preference: 'NO_SHIPPING')
+        )
+      end
+    end
+  end
+
+  private
+
+  def create_address(firstname, lastname)
+    create(:address, name: "#{firstname} #{lastname}")
+  end
+end

data/spec/models/solidus_paypal_commerce_platform/state_guesser_spec.rb

@@ -0,0 +1,38 @@
+require 'solidus_paypal_commerce_platform_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 be_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

@@ -0,0 +1,9 @@
+require 'solidus_paypal_commerce_platform_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

@@ -0,0 +1,36 @@
+require 'solidus_paypal_commerce_platform_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

@@ -0,0 +1,44 @@
+require 'solidus_paypal_commerce_platform_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).to have_http_status(:unprocessable_entity) # 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

@@ -0,0 +1,59 @@
+require 'solidus_paypal_commerce_platform_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
+          # rubocop:disable RSpec/VerifiedDoubles
+          double(
+            'response',
+            result: double(
+              'result',
+              access_token: "ACCESS-TOKEN"
+            )
+          )
+          # rubocop:enable RSpec/VerifiedDoubles
+        when SolidusPaypalCommercePlatform::FetchMerchantCredentialsRequest
+          expect(request.headers.fetch("Authorization")).to eq("Bearer ACCESS-TOKEN")
+
+          # rubocop:disable RSpec/VerifiedDoubles
+          double(
+            'response',
+            result: double(
+              'result',
+              client_id: "CLIENT-ID",
+              client_secret: "CLIENT-SECRET",
+            )
+          )
+          # rubocop:enable RSpec/VerifiedDoubles
+        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/solidus_paypal_commerce_platform_spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'solidus_starter_frontend_helper'
+
+Dir["#{__dir__}/support/solidus_paypal_commerce_platform/**/*.rb"].sort.each { |f| require f }

data/spec/support/solidus_paypal_commerce_platform/factories.rb

@@ -0,0 +1,5 @@
+FactoryBot.definition_file_paths << SolidusPaypalCommercePlatform::Engine.root.join(
+  'lib/solidus_paypal_commerce_platform/testing_support/factories'
+).to_s
+
+FactoryBot.reload

data/spec/support/solidus_paypal_commerce_platform/paypal_sdk_script_tag_helper.rb

@@ -0,0 +1,13 @@
+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: :system
+end