solidus_paypal_commerce_platform 0.3.2 → 0.5.0

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

@@ -1,51 +0,0 @@
-{
-  "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

@@ -1,63 +0,0 @@
-{
-  "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

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

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

@@ -1,91 +0,0 @@
-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)
-
-      allow(Rails).to receive(:env).and_return("development".inquiry)
-      expect(subject.default_env).to eq("sandbox")
-
-      allow(Rails).to receive(:env).and_return("test".inquiry)
-      expect(subject.default_env).to eq("sandbox")
-
-      allow(Rails).to receive(:env).and_return("production".inquiry)
-      expect(subject.default_env).to eq("live")
-
-      allow(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
-
-  describe "#state_guesser_class" do
-    before do
-      stub_const('SolidusPaypalCommercePlatform::BetterStateGuesser', Class.new)
-    end
-
-    it "returns a class" do
-      expect(subject.state_guesser_class).to be_kind_of(Class)
-    end
-
-    it "is settable" do
-      expect(subject.state_guesser_class).to eq(SolidusPaypalCommercePlatform::StateGuesser)
-
-      subject.state_guesser_class = "SolidusPaypalCommercePlatform::BetterStateGuesser"
-
-      expect(subject.state_guesser_class).to eq(SolidusPaypalCommercePlatform::BetterStateGuesser)
-    end
-  end
-
-  describe "#partner_code" do
-    it "returns the correct code" do
-      expect(subject.partner_code).to eq("Solidus_PCP_SP")
-    end
-  end
-end

data/spec/models/solidus_paypal_commerce_platform/payment_method_spec.rb

@@ -1,129 +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 checkout_steps does not include "delivery"' do
-      let(:order) { instance_double(Spree::Order, checkout_steps: { "foo" => "bar" }) }
-
-      it 'disables autocommit' do
-        expect(url.query.split("&")).to include("shipping_preference=NO_SHIPPING")
-      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/paypal_order_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require '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) }
-
-    it { expect { to_json }.not_to raise_error }
-
-    if Spree.solidus_gem_version >= Gem::Version.new('2.11')
-      it 'returns the name of the user' 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: 'John', surname: 'Von Doe' })
-        )
-      end
-    else
-      it 'returns the name and surname of the user' do
-        expect(to_json).to match hash_including(
-          purchase_units: array_including(
-            hash_including(shipping: hash_including(name: { full_name: 'John' }))
-          ),
-          payer: hash_including(name: { given_name: 'John', surname: nil })
-        )
-      end
-    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