solidus_paypal_commerce_platform 0.5.0 → 1.0.0.beta1

data/spec/jobs/solidus_paypal_commerce_platform/fixtures/PAYMENT.CAPTURE.REFUNDED.v1.json

@@ -0,0 +1,51 @@
+{
+  "id": "WH-2JG62852X9350413N-40V56408FN023574K",
+  "create_time": "2014-10-22T23:49:03Z",
+  "resource_type": "capture",
+  "event_type": "PAYMENT.CAPTURE.REFUNDED",
+  "summary": "A $ 0.15 USD capture payment was refunded",
+  "resource": {
+    "parent_payment": "PAY-7PD36489JY0066936KREEERQ",
+    "update_time": "2014-10-22T23:48:57Z",
+    "amount": {
+      "total": "-0.15",
+      "currency": "USD"
+    },
+    "create_time": "2014-10-22T23:48:57Z",
+    "links": [
+      {
+        "href": "https://api.paypal.com/v1/payments/refund/8VC964970N548345V",
+        "rel": "self",
+        "method": "GET"
+      },
+      {
+        "href": "https://api.paypal.com/v1/payments/payment/PAY-7PD36489JY0066936KREEERQ",
+        "rel": "parent_payment",
+        "method": "GET"
+      },
+      {
+        "href": "https://api.paypal.com/v1/payments/capture/5LK72275CG489890D",
+        "rel": "capture",
+        "method": "GET"
+      }
+    ],
+    "id": "8VC964970N548345V",
+    "state": "completed",
+    "capture_id": "5LK72275CG489890D"
+  },
+  "links": [
+    {
+      "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-2JG62852X9350413N-40V56408FN023574K",
+      "rel": "self",
+      "method": "GET",
+      "encType": "application/json"
+    },
+    {
+      "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-2JG62852X9350413N-40V56408FN023574K/resend",
+      "rel": "resend",
+      "method": "POST",
+      "encType": "application/json"
+    }
+  ],
+  "event_version": "1.0"
+}

data/spec/jobs/solidus_paypal_commerce_platform/fixtures/PAYMENT.CAPTURE.REFUNDED.v2.json

@@ -0,0 +1,63 @@
+{
+  "id": "WH-1GE84257G0350133W-6RW800890C634293G",
+  "create_time": "2018-08-15T19:14:04.543Z",
+  "resource_type": "refund",
+  "event_type": "PAYMENT.CAPTURE.REFUNDED",
+  "summary": "A $ 0.99 USD capture payment was refunded",
+  "resource": {
+    "seller_payable_breakdown": {
+      "gross_amount": {
+        "currency_code": "USD",
+        "value": "0.99"
+      },
+      "paypal_fee": {
+        "currency_code": "USD",
+        "value": "0.02"
+      },
+      "net_amount": {
+        "currency_code": "USD",
+        "value": "0.97"
+      },
+      "total_refunded_amount": {
+        "currency_code": "USD",
+        "value": "1.98"
+      }
+    },
+    "amount": {
+      "currency_code": "USD",
+      "value": "0.99"
+    },
+    "update_time": "2018-08-15T12:13:29-07:00",
+    "create_time": "2018-08-15T12:13:29-07:00",
+    "links": [
+      {
+        "href": "https://api.paypal.com/v2/payments/refunds/1Y107995YT783435V",
+        "rel": "self",
+        "method": "GET"
+      },
+      {
+        "href": "https://api.paypal.com/v2/payments/captures/0JF852973C016714D",
+        "rel": "up",
+        "method": "GET"
+      }
+    ],
+    "id": "1Y107995YT783435V",
+    "status": "COMPLETED"
+  },
+  "links": [
+    {
+      "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-1GE84257G0350133W-6RW800890C634293G",
+      "rel": "self",
+      "method": "GET",
+      "encType": "application/json"
+    },
+    {
+      "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-1GE84257G0350133W-6RW800890C634293G/resend",
+      "rel": "resend",
+      "method": "POST",
+      "encType": "application/json"
+    }
+  ],
+  "event_version": "1.0",
+  "resource_version": "2.0"
+}

data/spec/jobs/solidus_paypal_commerce_platform/webhook_job_spec.rb

@@ -0,0 +1,44 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::WebhookJob do
+  let(:paypal_order_id) { SecureRandom.uuid }
+  let(:capture_id) { SecureRandom.uuid }
+  let(:refund_id) { SecureRandom.uuid }
+
+  let(:payment_source) {
+    SolidusPaypalCommercePlatform::PaymentSource.new(
+      paypal_order_id: paypal_order_id,
+      capture_id: capture_id,
+      refund_id: refund_id,
+      payment_method: create(:paypal_payment_method),
+    )
+  }
+
+  let(:payment) {
+    create(:order).payments.create!(
+      payment_method: payment_source.payment_method,
+      source: payment_source,
+    )
+  }
+
+  [
+    ["CHECKOUT.ORDER.COMPLETED.v2", "paypal_order_id"],
+    ["CHECKOUT.ORDER.PROCESSED.v2", "paypal_order_id"],
+    ["PAYMENT.CAPTURE.COMPLETED.v1", "capture_id"],
+    ["PAYMENT.CAPTURE.COMPLETED.v2", "capture_id"],
+    ["PAYMENT.CAPTURE.DENIED.v1", "capture_id"],
+    ["PAYMENT.CAPTURE.DENIED.v2", "capture_id"],
+    ["PAYMENT.CAPTURE.REFUNDED.v1", "capture_id"],
+    ["PAYMENT.CAPTURE.REFUNDED.v2", "refund_id"],
+  ].each do |(event, source_attr)|
+    describe event do
+      let(:payload) { JSON.parse(File.read("#{__dir__}/fixtures/#{event}.json")) }
+      let(source_attr) { payload.dig("resource", "id") }
+
+      it 'inserts a log entry for the corresponding payment source' do
+        expect { described_class.perform_now(payload) }.to change(payment.log_entries, :count).by(1)
+        expect(YAML.load(payment.log_entries.last.details)).to eq(payload)
+      end
+    end
+  end
+end

data/spec/lib/solidus_paypal_commerce_platform/client_spec.rb

@@ -0,0 +1,21 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::Client do
+  subject(:client) { described_class.new(client_id: "1234") }
+
+  describe '#execute_with_response' do
+    let(:request_class) { SolidusPaypalCommercePlatform::Gateway::OrdersCaptureRequest }
+    let(:paypal_request) { double(:request, class: request_class) }
+    let(:paypal_response) { double(:response, status_code: status_code, result: nil, headers: {}) }
+    let(:status_code) { 201 }
+
+    it 'forwards to the upstream client adding i18n response messages' do
+      allow_any_instance_of(PayPal::PayPalHttpClient)
+        .to receive(:execute).with(paypal_request).and_return(paypal_response)
+
+      response = subject.execute_with_response(paypal_request)
+
+      expect(response.message).to eq("Payment captured")
+    end
+  end
+end

data/spec/lib/solidus_paypal_commerce_platform/configuration_spec.rb

@@ -0,0 +1,91 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::Configuration do
+  subject(:test_subject) { described_class.new }
+
+  describe '#default_env' do
+    it "uses ENV['PAYPAL_ENV'] when present" do
+      expect(ENV).to receive(:[]).with("PAYPAL_ENV").and_return("foo").at_least(:once)
+      expect(test_subject.default_env).to eq("foo")
+    end
+
+    it "falls back to Rails.env if ENV['PAYPAL_ENV'] is not set" do
+      expect(ENV).to receive(:[]).with("PAYPAL_ENV").and_return(nil).at_least(:once)
+
+      allow(Rails).to receive(:env).and_return("development".inquiry)
+      expect(test_subject.default_env).to eq("sandbox")
+
+      allow(Rails).to receive(:env).and_return("test".inquiry)
+      expect(test_subject.default_env).to eq("sandbox")
+
+      allow(Rails).to receive(:env).and_return("production".inquiry)
+      expect(test_subject.default_env).to eq("live")
+
+      allow(Rails).to receive(:env).and_return("staging".inquiry)
+      expect{ test_subject.default_env }.to raise_error(described_class::InvalidEnvironment)
+    end
+  end
+
+  describe '#env' do
+    it 'returns a string inquirer' do
+      expect(test_subject.env).to eq("sandbox")
+      expect(test_subject.env).to be_sandbox
+
+      test_subject.env = "live"
+      expect(test_subject.env).to eq("live")
+      expect(test_subject.env).to be_live
+
+      test_subject.env = "sandbox"
+      expect(test_subject.env).to eq("sandbox")
+      expect(test_subject.env).to be_sandbox
+    end
+
+    it 'raises an error when assigned an unsupported value' do
+      expect{ test_subject.env = "foo" }.to raise_error(described_class::InvalidEnvironment)
+    end
+  end
+
+  describe '#env_class' do
+    it 'changes based on the current env' do
+      test_subject.env = "live"
+      expect(test_subject.env_class).to eq(PayPal::LiveEnvironment)
+
+      test_subject.env = "sandbox"
+      expect(test_subject.env_class).to eq(PayPal::SandboxEnvironment)
+    end
+  end
+
+  describe '#env_domain' do
+    it 'changes based on the current env' do
+      test_subject.env = "live"
+      expect(test_subject.env_domain).to eq("www.paypal.com")
+
+      test_subject.env = "sandbox"
+      expect(test_subject.env_domain).to eq("www.sandbox.paypal.com")
+    end
+  end
+
+  describe "#state_guesser_class" do
+    before do
+      stub_const('SolidusPaypalCommercePlatform::BetterStateGuesser', Class.new)
+    end
+
+    it "returns a class" do
+      expect(test_subject.state_guesser_class).to be_a(Class)
+    end
+
+    it "is settable" do
+      expect(test_subject.state_guesser_class).to eq(SolidusPaypalCommercePlatform::StateGuesser)
+
+      test_subject.state_guesser_class = "SolidusPaypalCommercePlatform::BetterStateGuesser"
+
+      expect(test_subject.state_guesser_class).to eq(SolidusPaypalCommercePlatform::BetterStateGuesser)
+    end
+  end
+
+  describe "#partner_code" do
+    it "returns the correct code" do
+      expect(test_subject.partner_code).to eq("Solidus_PCP_SP")
+    end
+  end
+end

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