solidus_paypal_commerce_platform 0.0.1

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 '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 '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
+      expect_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,67 @@
+require 'spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::Configuration do
+  let(: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(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)
+
+      expect(Rails).to receive(:env).and_return("development".inquiry)
+      expect(subject.default_env).to eq("sandbox")
+
+      expect(Rails).to receive(:env).and_return("test".inquiry)
+      expect(subject.default_env).to eq("sandbox")
+
+      expect(Rails).to receive(:env).and_return("production".inquiry)
+      expect(subject.default_env).to eq("live")
+
+      expect(Rails).to receive(:env).and_return("staging".inquiry)
+      expect{ subject.default_env }.to raise_error(described_class::InvalidEnvironment)
+    end
+  end
+
+  describe '#env' do
+    it 'returns a string inquirer' do
+      expect(subject.env).to eq("sandbox")
+      expect(subject.env).to be_sandbox
+
+      subject.env = "live"
+      expect(subject.env).to eq("live")
+      expect(subject.env).to be_live
+
+      subject.env = "sandbox"
+      expect(subject.env).to eq("sandbox")
+      expect(subject.env).to be_sandbox
+    end
+
+    it 'raises an error when assigned an unsupported value' do
+      expect{ subject.env = "foo" }.to raise_error(described_class::InvalidEnvironment)
+    end
+  end
+
+  describe '#env_class' do
+    it 'changes based on the current env' do
+      subject.env = "live"
+      expect(subject.env_class).to eq(PayPal::LiveEnvironment)
+
+      subject.env = "sandbox"
+      expect(subject.env_class).to eq(PayPal::SandboxEnvironment)
+    end
+  end
+
+  describe '#env_domain' do
+    it 'changes based on the current env' do
+      subject.env = "live"
+      expect(subject.env_domain).to eq("www.paypal.com")
+
+      subject.env = "sandbox"
+      expect(subject.env_domain).to eq("www.sandbox.paypal.com")
+    end
+  end
+end

data/spec/models/solidus_paypal_commerce_platform/payment_method_spec.rb

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::PaypalAddress, type: :model do
+  let(:order) { create(:order) }
+  let(:original_address) { create(:address) }
+  let(:address) { create(:address) }
+  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: address.firstname,
+          surname: address.lastname
+        }
+      }
+    }
+  }
+
+  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
+      expect(subject.firstname).to eq address.firstname
+      expect(subject.lastname).to eq address.lastname
+      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
+end