solidus_stripe 4.3.0 → 5.0.0.alpha.1

data/lib/solidus_stripe/refunds_synchronizer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "solidus_stripe/money_to_stripe_amount_converter"
+
+module SolidusStripe
+  # Synchronizes refunds from Stripe to Solidus.
+  #
+  # For our use case, Stripe has two ways to inform us about refunds initiated
+  # on their side:
+  #
+  # 1. The `charge.refunded` webhook event, which is triggered when a refund is
+  # explicitly created.
+  # 2. The `payment_intent.succeeded` webhook event, which is triggered when a
+  # payment intent is captured. If the payment intent is captured for less than
+  # the full amount, a refund is automatically created for the remaining amount.
+  #
+  # In both cases, Stripe doesn't tell us which refund was recently created, so
+  # we need to fetch all the refunds for the payment intent and check if any of
+  # them is missing on Solidus. We're using the `transaction_id` field on
+  # `Spree::Refund` to match refunds against Stripe refunds ids. We could think
+  # about only syncing the single refund not present on Solidus, but we need to
+  # acknowledge concurrent partial refunds.
+  #
+  # The `Spree::RefundReason` with `SolidusStripe::Config.refund_reason_name`
+  # as name is used as created refunds' reason.
+  #
+  # Besides, we need to account for refunds created from Solidus admin panel,
+  # which calls the Stripe API. In this case, we need to avoid syncing the
+  # refund back to Solidus on the subsequent webhook, otherwise we would end up
+  # with duplicate records. We're marking those refunds with a metadata field on
+  # Stripe, so we can filter them out (see {Gateway#credit}).
+  class RefundsSynchronizer
+    include MoneyToStripeAmountConverter
+
+    # Metadata key used to mark refunds that shouldn't be synced back to Solidus.
+    # @return [Symbol]
+    SKIP_SYNC_METADATA_KEY = :solidus_skip_sync
+
+    # Metadata value used to mark refunds that shouldn't be synced back to Solidus.
+    # @return [String]
+    SKIP_SYNC_METADATA_VALUE = 'true'
+
+    # @param payment_method [SolidusStripe::PaymentMethod]
+    def initialize(payment_method)
+      @payment_method = payment_method
+    end
+
+    # @param payment_intent_id [String]
+    def call(payment_intent_id)
+      payment = Spree::Payment.find_by!(response_code: payment_intent_id)
+
+      stripe_refunds(payment_intent_id)
+        .select(&method(:stripe_refund_needs_sync?))
+        .map(
+          &method(:create_refund).curry[payment]
+        )
+    end
+
+    private
+
+    def stripe_refunds(payment_intent_id)
+      @payment_method.gateway.request do
+        Stripe::Refund.list(payment_intent: payment_intent_id).data
+      end
+    end
+
+    def stripe_refund_needs_sync?(refund)
+      originated_outside_solidus = refund.metadata[SKIP_SYNC_METADATA_KEY] != SKIP_SYNC_METADATA_VALUE
+      not_already_synced = Spree::Refund.find_by(transaction_id: refund.id).nil?
+
+      originated_outside_solidus && not_already_synced
+    end
+
+    def create_refund(payment, refund)
+      Spree::Refund.create!(
+        payment: payment,
+        amount: refund_decimal_amount(refund),
+        transaction_id: refund.id,
+        reason: SolidusStripe::PaymentMethod.refund_reason
+      ).tap(&method(:log_refund).curry[payment])
+    end
+
+    def log_refund(payment, refund)
+      SolidusStripe::LogEntries.payment_log(
+        payment,
+        success: true,
+        message: "Payment was refunded after Stripe event (#{refund.money})"
+      )
+    end
+
+    def refund_decimal_amount(refund)
+      to_solidus_amount(refund.amount, refund.currency)
+        .then { |amount| solidus_subunit_to_decimal(amount, refund.currency) }
+    end
+  end
+end

data/lib/solidus_stripe/seeds.rb

@@ -0,0 +1,19 @@
+# frozen-string-literal: true
+
+module SolidusStripe
+  # Seed data to seamlessly integrate Solidus with Stripe.
+  module Seeds
+    # Default name for the `Spree::RefundReason` used for Stripe refunds.
+    #
+    # Changed via {SolidusStripe::Configuration#refund_reason_name}.
+    #
+    # @return [String]
+    DEFAULT_STRIPE_REFUND_REASON_NAME = "Refund generated from Stripe"
+
+    def self.refund_reasons
+      Spree::RefundReason.find_or_create_by(
+        name: DEFAULT_STRIPE_REFUND_REASON_NAME
+      ) { _1.mutable = false }
+    end
+  end
+end

data/lib/solidus_stripe/testing_support/factories.rb

@@ -1,4 +1,157 @@
 # frozen_string_literal: true
 
 FactoryBot.define do
+  factory :stripe_payment_method, class: 'SolidusStripe::PaymentMethod' do
+    type { "SolidusStripe::PaymentMethod" }
+    name { "Stripe Payment Method" }
+    preferences {
+      {
+        api_key: ENV['SOLIDUS_STRIPE_API_KEY'] ||
+          "sk_dummy_#{SecureRandom.hex(24)}",
+        publishable_key: ENV['SOLIDUS_STRIPE_PUBLISHABLE_KEY'] ||
+          "pk_dummy_#{SecureRandom.hex(24)}",
+        webhook_endpoint_signing_secret: ENV['SOLIDUS_STRIPE_WEBHOOK_SIGNING_SECRET'] ||
+          "whsec_dummy_#{SecureRandom.hex(32)}"
+      }
+    }
+  end
+
+  factory :stripe_payment_source, class: 'SolidusStripe::PaymentSource' do
+    association :payment_method, factory: :stripe_payment_method
+    stripe_payment_method_id { "pm_#{SecureRandom.uuid.delete('-')}" }
+  end
+
+  factory :stripe_payment, parent: :payment do
+    association :payment_method, factory: :stripe_payment_method
+    amount { order.outstanding_balance }
+    response_code { "pi_#{SecureRandom.uuid.delete('-')}" }
+    state { 'checkout' }
+
+    transient do
+      stripe_payment_method_id { "pm_#{SecureRandom.uuid.delete('-')}" }
+    end
+
+    source {
+      create(
+        :stripe_payment_source,
+        payment_method: payment_method,
+        stripe_payment_method_id: stripe_payment_method_id
+      )
+    }
+
+    trait :authorized do
+      state { 'pending' }
+
+      after(:create) do |payment, _evaluator|
+        create(
+          :stripe_payment_log_entry,
+          :authorize,
+          source: payment
+        )
+      end
+    end
+
+    trait :captured do
+      state { 'completed' }
+
+      after(:create) do |payment, _evaluator|
+        create(
+          :stripe_payment_log_entry,
+          :autocapture,
+          source: payment
+        )
+      end
+    end
+  end
+
+  factory :stripe_payment_intent, class: 'SolidusStripe::PaymentIntent' do
+    association :order
+    association :payment_method, factory: :stripe_payment_method
+    stripe_intent_id { "pm_#{SecureRandom.uuid.delete('-')}" }
+  end
+
+  factory :stripe_slug_entry, class: 'SolidusStripe::SlugEntry' do
+    association :payment_method, factory: :stripe_payment_method
+    slug { SecureRandom.hex(16) }
+  end
+
+  factory :stripe_customer, class: 'SolidusStripe::Customer' do
+    association :payment_method, factory: :stripe_payment_method
+    association :source, factory: :user
+    stripe_id { "cus_#{SecureRandom.uuid.delete('-')}" }
+
+    trait :guest do
+      association :source, factory: :order, email: 'guest@example.com', user: nil
+    end
+  end
+
+  factory :stripe_payment_log_entry, class: 'Spree::LogEntry' do
+    transient do
+      success { true }
+      message { nil }
+      response_code { source.response_code }
+      data { nil }
+    end
+
+    source { create(:payment) }
+
+    trait :authorize do
+      message { 'PaymentIntent was confirmed successfully' }
+    end
+
+    trait :capture do
+      message { 'Payment captured successfully' }
+    end
+
+    trait :autocapture do
+      message { 'PaymentIntent was confirmed and captured successfully' }
+    end
+
+    trait :void do
+      message { 'PaymentIntent was canceled successfully' }
+    end
+
+    trait :refund do
+      message { 'PaymentIntent was refunded successfully' }
+    end
+
+    trait :fail do
+      success { false }
+      message { 'PaymentIntent operation failed with a generic error' }
+    end
+
+    details {
+      YAML.safe_dump(
+        SolidusStripe::LogEntries.build_payment_log(
+          success: success,
+          message: message,
+          response_code: response_code,
+          data: data
+        ),
+        permitted_classes: Spree::LogEntry.permitted_classes,
+        aliases: Spree::Config.log_entry_allow_aliases
+      )
+    }
+  end
+
+  factory :order_with_stripe_payment, parent: :order do
+    transient do
+      amount { 10 }
+      payment_method { build(:stripe_payment_method) }
+      stripe_payment_method_id { "pm_#{SecureRandom.uuid.delete('-')}" }
+    end
+
+    line_items { [build(:line_item, price: amount)] }
+
+    after(:create) do |order, evaluator|
+      build(
+        :stripe_payment,
+        amount: evaluator.amount,
+        order: order,
+        payment_method: evaluator.payment_method,
+        stripe_payment_method_id: evaluator.stripe_payment_method_id
+      )
+      order.recalculate
+    end
+  end
 end

data/lib/solidus_stripe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidusStripe
-  VERSION = '4.3.0'
+  VERSION = '5.0.0.alpha.1'
 end

data/lib/solidus_stripe/webhook/event.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module SolidusStripe
+  module Webhook
+    # Omnes event wrapping a Stripe event for a given payment method.
+    #
+    # All unknown methods are delegated to the wrapped Stripe event.
+    #
+    # @see https://www.rubydoc.info/gems/stripe/Stripe/Event
+    class Event
+      include Omnes::Event
+
+      PREFIX = "stripe."
+      private_constant :PREFIX
+
+      CORE_EVENTS = Set[*%i[
+        payment_intent.succeeded
+        payment_intent.payment_failed
+        payment_intent.canceled
+        charge.refunded
+      ]].freeze
+      private_constant :CORE_EVENTS
+
+      # @api private
+      class << self
+        def from_request(payload:, signature_header:, slug:, tolerance: default_tolerance)
+          payment_method = SolidusStripe::PaymentMethod.with_slug(slug).first!
+          stripe_event = Stripe::Webhook.construct_event(
+            payload,
+            signature_header,
+            payment_method.preferred_webhook_endpoint_signing_secret,
+            tolerance: tolerance
+          )
+          new(stripe_event: stripe_event, spree_payment_method: payment_method)
+        rescue ActiveRecord::RecordNotFound, Stripe::SignatureVerificationError, JSON::ParserError
+          nil
+        end
+
+        def register(user_events:, bus:, core_events: CORE_EVENTS)
+          (core_events + user_events).each do |event|
+            bus.register(:"stripe.#{event}")
+          end
+        end
+
+        private
+
+        def default_tolerance
+          SolidusStripe.configuration.webhook_signature_tolerance
+        end
+      end
+
+      # @api private
+      attr_reader :omnes_event_name
+
+      # @attr_reader [SolidusStripe::PaymentMethod]
+      attr_reader :spree_payment_method
+
+      # @api private
+      def initialize(stripe_event:, spree_payment_method:)
+        @stripe_event = stripe_event
+        @spree_payment_method = spree_payment_method
+        @omnes_event_name = :"#{PREFIX}#{stripe_event.type}"
+      end
+
+      # Serializable representation of the event.
+      #
+      # Ready to be consumed by async Omnes adapters, like
+      # `Omnes::Subscriber::Adapter::ActiveJob` or
+      # `Omnes::Subscriber::Adapter::Sidekiq`.
+      #
+      # @return [Hash<String, Object>]
+      def payload
+        {
+          "stripe_event" => @stripe_event.as_json,
+          "spree_payment_method_id" => @spree_payment_method.id
+        }
+      end
+
+      private
+
+      def method_missing(method_name, ...)
+        @stripe_event.send(method_name, ...)
+      end
+
+      def respond_to_missing?(...)
+        @stripe_event.respond_to?(...)
+      end
+    end
+  end
+end

data/lib/solidus_stripe.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_merchant'
-
 require 'solidus_stripe/configuration'
 require 'solidus_stripe/version'
 require 'solidus_stripe/engine'

data/solidus_stripe.gemspec

@@ -15,9 +15,9 @@ Gem::Specification.new do |spec|
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = 'https://github.com/solidusio/solidus_stripe'
-  spec.metadata['changelog_uri'] = 'https://github.com/solidusio/solidus_stripe/blob/master/CHANGELOG.md'
+  spec.metadata['changelog_uri'] = 'https://github.com/solidusio/solidus_stripe/releases'
 
-  spec.required_ruby_version = '>= 2.4.0'
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.0')
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -29,9 +29,33 @@ Gem::Specification.new do |spec|
   spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'solidus_core', ['>= 2.3', '< 4']
+  spec.add_dependency 'solidus_core', ['>= 3.2', '< 4']
   spec.add_dependency 'solidus_support', '~> 0.8'
-  spec.add_dependency 'activemerchant', '>= 1.105'
 
-  spec.add_development_dependency 'solidus_dev_support', '~> 2.3'
+  spec.add_dependency 'stripe', '~> 8.0'
+
+  spec.add_development_dependency 'redcarpet' # used by yard
+  spec.add_development_dependency 'rubocop', '~> 1.0'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.5'
+  spec.add_development_dependency 'rubocop-rails', '~> 2.3'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.0'
+  spec.add_development_dependency 'yard'
+
+  spec.post_install_message = <<~TXT
+    ------------------------------------------------------------------------
+            ⚠️ **WARNING: `solidus_stripe` & `solidus_frontend** ⚠️
+    ------------------------------------------------------------------------
+
+    If you need support for `solidus_frontend` please add `< 5`
+    as a version requirement in your gemfile:
+
+    `gem 'solidus_stripe', '< 5'`
+
+    or if your tracking the github version please switch to
+    the `v4` branch:
+
+    `gem 'solidus_stripe', github: 'solidusio/solidus_stripe', branch: 'v4'`
+
+    ------------------------------------------------------------------------
+  TXT
 end

data/spec/lib/solidus_stripe/configuration_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::Configuration do
+  describe "#initialize" do
+    it "defaults webhook events to empty" do
+      expect(described_class.new.webhook_events).to eq([])
+    end
+
+    it "defaults webhook signature tolerance to stripe's default" do
+      expect(described_class.new.webhook_signature_tolerance).to eq(Stripe::Webhook::DEFAULT_TOLERANCE)
+    end
+
+    it "defaults refund reason name to the one in seeds" do
+      expect(
+        described_class.new.refund_reason_name
+      ).to eq(SolidusStripe::Seeds::DEFAULT_STRIPE_REFUND_REASON_NAME)
+    end
+  end
+end

data/spec/lib/solidus_stripe/money_to_stripe_amount_converter_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'solidus_stripe_spec_helper'
+
+# rubocop:disable Style/NumericLiterals
+RSpec.describe SolidusStripe::MoneyToStripeAmountConverter do
+  describe '.to_stripe_amount' do
+    let(:custom_message) do
+      ->(actual, expected, currency) { "Expected #{currency} to be #{expected} but got #{actual}" }
+    end
+
+    context 'with zero decimal currencies' do
+      it 'returns the same unit amount' do
+        (described_class::ZERO_DECIMAL_CURRENCIES - %w[MGA]).each do |currency|
+          actual = described_class.to_stripe_amount(12345, currency).to_i
+
+          expected = 12345
+          expect(actual).to eq(expected), custom_message.call(actual, expected, currency)
+        end
+      end
+    end
+
+    context 'with three decimal currencies' do
+      it 'returns the same subunit amount' do
+        described_class::THREE_DECIMAL_CURRENCIES.each do |currency|
+          actual = described_class.to_stripe_amount(12_345, currency).to_i
+
+          expected = 12_345
+          expect(actual).to eq(expected), custom_message.call(actual, expected, currency)
+        end
+      end
+    end
+
+    context 'with special cases' do
+      it 'returns the amount divided by 5 (iraimbilanja to ariary) when currency is MGA' do
+        expect(described_class.to_stripe_amount(255, 'MGA').to_i).to eq(51)
+      end
+
+      it 'returns the amount as a two decimal currency when currency is HUF' do
+        expect(described_class.to_stripe_amount(1_2345, 'HUF').to_i).to eq(12_345_00)
+      end
+
+      it 'returns the same amount as a zero decimal currency when currency is UGX' do
+        expect(described_class.to_stripe_amount(12_3450_00, 'UGX').to_i).to eq(123_450_00)
+      end
+
+      it 'returns the same amount as a zero decimal currency when currency is TWD' do
+        expect(described_class.to_stripe_amount(1_2345_00, 'TWD').to_i).to eq(12_345_00)
+      end
+    end
+
+    context 'with default as two decimal currencies' do
+      it 'returns the same subunit amount' do
+        %w[USD EUR ILS MXN TWD].each do |currency|
+          actual = described_class.to_stripe_amount(123_45, currency).to_i
+
+          expected = 123_45
+          expect(actual).to eq(expected), custom_message.call(actual, expected, currency)
+        end
+      end
+    end
+  end
+
+  describe '.to_solidus_amount' do
+    let(:custom_message) do
+      ->(actual, expected, currency) { "Expected #{currency} to be #{expected} but got #{actual}" }
+    end
+
+    context 'with zero decimal currencies' do
+      it 'returns the same unit amount' do
+        (described_class::ZERO_DECIMAL_CURRENCIES - %w[MGA]).each do |currency|
+          actual = described_class.to_stripe_amount(12345, currency).to_i
+
+          expected = 12345
+          expect(actual).to eq(expected), custom_message.call(actual, expected, currency)
+        end
+      end
+    end
+
+    context 'with three decimal currencies' do
+      it 'returns the same subunit amount' do
+        described_class::THREE_DECIMAL_CURRENCIES.each do |currency|
+          actual = described_class.to_solidus_amount(12_345, currency).to_i
+
+          expected = 12_345
+          expect(actual).to eq(expected), custom_message.call(actual, expected, currency)
+        end
+      end
+    end
+
+    context 'with special cases' do
+      it 'returns the amount multiplied by 5 (ariary to iraimbilanja) when currency is MGA' do
+        expect(described_class.to_solidus_amount(51, 'MGA').to_i).to eq(255)
+      end
+
+      it 'returns the amount without the last two digits when currency is HUF' do
+        expect(described_class.to_solidus_amount(12_345_00, 'HUF').to_i).to eq(1_2345)
+      end
+
+      it 'returns the amount as a zero decimal currency when currency is UGX' do
+        expect(described_class.to_solidus_amount(123_450_00, 'UGX').to_i).to eq(12_3450_00)
+      end
+
+      it 'returns the amount as a zero decimal currency when currency is TWD' do
+        expect(described_class.to_solidus_amount(12_345_00, 'TWD').to_i).to eq(1_2345_00)
+      end
+    end
+
+    context 'with default as two decimal currencies' do
+      it 'returns the same subunit amount' do
+        %w[USD EUR ILS MXN TWD].each do |currency|
+          actual = described_class.to_solidus_amount(123_45, currency).to_i
+
+          expected = 123_45
+          expect(actual).to eq(expected), custom_message.call(actual, expected, currency)
+        end
+      end
+    end
+  end
+
+  describe '.solidus_decimal_to_subunit' do
+    it 'returns the subunit amount as an integer' do
+      expect(described_class.solidus_decimal_to_subunit(100, 'USD')).to be(100_00)
+    end
+  end
+
+  describe '.solidus_subunit_to_decimal' do
+    it 'returns to the unit amount as a decimal' do
+      expect(described_class.solidus_subunit_to_decimal(100_00, 'USD')).to eq(BigDecimal("100"))
+    end
+  end
+end
+# rubocop:enable Style/NumericLiterals