solidus_stripe 4.4.0 → 5.0.0.rc.1

data/spec/requests/solidus_stripe/webhooks_controller_spec.rb

@@ -0,0 +1,56 @@
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::WebhooksController, type: [:request, :webhook_request] do
+  describe "POST /create" do
+    let(:payment_method) { create(:solidus_stripe_payment_method) }
+    let(:stripe_payment_intent) {
+      payment_method.gateway.request {
+        Stripe::PaymentIntent.create(amount: 100, currency: 'usd')
+      }
+    }
+    let(:context) do
+      SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        object: stripe_payment_intent,
+        type: "payment_intent.created",
+        payment_method: payment_method
+      )
+    end
+
+    context "when the request is valid" do
+      around do |example|
+        if Spree::Bus.registry.registered?(:"stripe.payment_intent.created")
+          example.run
+        else
+          Spree::Bus.register(:"stripe.payment_intent.created")
+          example.run
+          Spree::Bus.registry.unregister(:"stripe.payment_intent.created")
+        end
+      end
+
+      it "triggers a matching event on Spree::Bus" do
+        event_type = nil
+        subscription = Spree::Bus.subscribe(:"stripe.payment_intent.created") { |event| event_type = event.type }
+
+        webhook_request(context)
+
+        expect(event_type).to eq("payment_intent.created")
+      ensure
+        Spree::Bus.unsubscribe(subscription)
+      end
+
+      it "returns a 200 status code" do
+        webhook_request(context)
+
+        expect(response).to have_http_status(:ok)
+      end
+    end
+
+    context "when the event can't be generated" do
+      it "returns a 400 status code" do
+        webhook_request(context, timestamp: Time.zone.yesterday.to_time)
+
+        expect(response).to have_http_status(:bad_request)
+      end
+    end
+  end
+end

data/spec/solidus_stripe_spec_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'stripe'
+require 'solidus_starter_frontend_spec_helper'
+
+Dir["#{__dir__}/support/solidus_stripe/**/*.rb"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.include SolidusStripe::Webhook::RequestHelper, type: :webhook_request
+end

data/spec/subscribers/solidus_stripe/webhook/charge_subscriber_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::Webhook::ChargeSubscriber do
+  describe "#sync_refunds" do
+    it "synchronizes refunds" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+      payment = create(:payment,
+        amount: 10,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "completed")
+      stripe_charge = Stripe::Charge.construct_from(id: "ch_123", payment_intent: "pi_123")
+      allow(Stripe::Refund).to receive(:list).with(payment_intent: stripe_payment_intent.id).and_return(
+        Stripe::ListObject.construct_from(
+          data: [{ id: "re_123", amount: 1000, currency: "usd", metadata: {} }]
+        )
+      )
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_charge,
+        type: "charge.refunded"
+      ).solidus_stripe_object
+
+      described_class.new.sync_refunds(event)
+
+      expect(payment.refunds.count).to be(1)
+    end
+  end
+end

data/spec/subscribers/solidus_stripe/webhook/payment_intent_subscriber_spec.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::Webhook::PaymentIntentSubscriber do
+  describe "#capture_payment" do
+    context "when a full capture is performed" do
+      it "completes a pending payment" do
+        payment_method = create(:solidus_stripe_payment_method)
+        stripe_payment_intent = Stripe::PaymentIntent.construct_from(
+          id: "pi_123",
+          amount: 1000,
+          amount_received: 1000,
+          currency: "usd"
+        )
+        payment = create(:payment,
+          amount: 10,
+          payment_method: payment_method,
+          response_code: stripe_payment_intent.id,
+          state: "pending")
+        event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+          payment_method: payment_method,
+          object: stripe_payment_intent,
+          type: "payment_intent.succeeded"
+        ).solidus_stripe_object
+
+        described_class.new.capture_payment(event)
+
+        expect(payment.reload.state).to eq "completed"
+      end
+
+      it "adds a log entry to the payment" do
+        payment_method = create(:solidus_stripe_payment_method)
+        stripe_payment_intent = Stripe::PaymentIntent.construct_from(
+          id: "pi_123",
+          amount: 1000,
+          amount_received: 1000,
+          currency: "usd"
+        )
+        payment = create(:payment,
+          amount: 10,
+          payment_method: payment_method,
+          response_code: stripe_payment_intent.id,
+          state: "pending")
+        event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+          payment_method: payment_method,
+          object: stripe_payment_intent,
+          type: "payment_intent.succeeded"
+        ).solidus_stripe_object
+
+        described_class.new.capture_payment(event)
+
+        details = payment.log_entries.last.parsed_details
+        expect(details.success?).to be(true)
+        expect(
+          details.message
+        ).to eq "Capture was successful after payment_intent.succeeded webhook"
+      end
+    end
+
+    context "when a partial capture is performed" do
+      it "completes a pending payment" do
+        SolidusStripe::Seeds.refund_reasons
+        payment_method = create(:solidus_stripe_payment_method)
+        stripe_payment_intent = Stripe::PaymentIntent.construct_from(
+          id: "pi_123",
+          amount: 1000,
+          amount_received: 700,
+          currency: "usd"
+        )
+        payment = create(:payment,
+          amount: 10,
+          payment_method: payment_method,
+          response_code: stripe_payment_intent.id,
+          state: "pending")
+        allow(Stripe::Refund).to receive(:list).with(payment_intent: stripe_payment_intent.id).and_return(
+          Stripe::ListObject.construct_from(
+            data: [{ id: "re_123", amount: 700, currency: "usd", metadata: {} }]
+          )
+        )
+        event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+          payment_method: payment_method,
+          object: stripe_payment_intent,
+          type: "payment_intent.succeeded"
+        ).solidus_stripe_object
+
+        described_class.new.capture_payment(event)
+
+        expect(payment.reload.state).to eq "completed"
+      end
+
+      it "synchronizes refunds" do
+        SolidusStripe::Seeds.refund_reasons
+        payment_method = create(:solidus_stripe_payment_method)
+        stripe_payment_intent = Stripe::PaymentIntent.construct_from(
+          id: "pi_123",
+          amount: 1000,
+          amount_received: 700,
+          currency: "usd"
+        )
+        payment = create(:payment,
+          amount: 7,
+          payment_method: payment_method,
+          response_code: stripe_payment_intent.id,
+          state: "pending")
+        allow(Stripe::Refund).to receive(:list).with(payment_intent: stripe_payment_intent.id).and_return(
+          Stripe::ListObject.construct_from(
+            data: [{ id: "re_123", amount: 200, currency: "usd", metadata: {} }]
+          )
+        )
+        event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+          payment_method: payment_method,
+          object: stripe_payment_intent,
+          type: "payment_intent.succeeded"
+        ).solidus_stripe_object
+
+        described_class.new.capture_payment(event)
+
+        expect(payment.refunds.count).to be(1)
+      end
+
+      it "adds a log entry for the captured payment" do
+        SolidusStripe::Seeds.refund_reasons
+        payment_method = create(:solidus_stripe_payment_method)
+        stripe_payment_intent = Stripe::PaymentIntent.construct_from(
+          id: "pi_123",
+          amount: 1000,
+          amount_received: 700,
+          currency: "usd"
+        )
+        payment = create(:payment,
+          amount: 10,
+          payment_method: payment_method,
+          response_code: stripe_payment_intent.id,
+          state: "pending")
+        allow(Stripe::Refund).to receive(:list).with(payment_intent: stripe_payment_intent.id).and_return(
+          Stripe::ListObject.construct_from(
+            data: [{ id: "re_123", amount: 700, currency: "usd", metadata: {} }]
+          )
+        )
+        event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+          payment_method: payment_method,
+          object: stripe_payment_intent,
+          type: "payment_intent.succeeded"
+        ).solidus_stripe_object
+
+        described_class.new.capture_payment(event)
+
+        log_entries = payment.log_entries.map { [_1.parsed_details.success?, _1.parsed_details.message] }
+        expect(
+          log_entries
+        ).to include([true, "Capture was successful after payment_intent.succeeded webhook"])
+      end
+    end
+
+    it "does nothing if the payment is already completed" do
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+      payment = create(:payment,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "completed")
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.succeeded",
+      ).solidus_stripe_object
+
+      described_class.new.capture_payment(event)
+
+      expect(payment.reload.state).to eq "completed"
+      expect(payment.log_entries.count).to be(0)
+    end
+  end
+
+  describe "#fail_payment" do
+    it "fails a pending payment" do
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+      payment = create(:payment,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "pending")
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.payment_failed"
+      ).solidus_stripe_object
+
+      described_class.new.fail_payment(event)
+
+      expect(payment.reload.state).to eq "failed"
+    end
+
+    it "adds a log entry to the payment" do
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+      payment = create(:payment,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "pending")
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.payment_failed"
+      ).solidus_stripe_object
+
+      described_class.new.fail_payment(event)
+
+      details = payment.log_entries.last.parsed_details
+      expect(details.success?).to be(false)
+      expect(
+        details.message
+      ).to eq "Payment was marked as failed after payment_intent.failed webhook"
+    end
+
+    it "does nothing if the payment is already failed" do
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+      payment = create(:payment,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "failed")
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.payment_failed",
+      ).solidus_stripe_object
+
+      described_class.new.fail_payment(event)
+
+      expect(payment.reload.state).to eq "failed"
+      expect(payment.log_entries.count).to be(0)
+    end
+  end
+
+  describe "#void_payment" do
+    it "voids a pending payment" do
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123", cancellation_reason: "duplicate")
+      payment = create(:payment,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "pending")
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.canceled"
+      ).solidus_stripe_object
+
+      described_class.new.void_payment(event)
+
+      expect(payment.reload.state).to eq "void"
+    end
+
+    it "adds a log entry to the payment" do
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123", cancellation_reason: "duplicate")
+      payment = create(:payment,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "pending")
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.canceled"
+      ).solidus_stripe_object
+
+      described_class.new.void_payment(event)
+
+      details = payment.log_entries.last.parsed_details
+      expect(details.success?).to be(true)
+      expect(
+        details.message
+      ).to eq "Payment was voided after payment_intent.voided webhook (duplicate)"
+    end
+
+    it "does nothing if the payment is already voided" do
+      payment_method = create(:solidus_stripe_payment_method)
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123", cancellation_reason: "duplicate")
+      payment = create(:payment,
+        payment_method: payment_method,
+        response_code: stripe_payment_intent.id,
+        state: "void")
+      event = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.payment_void",
+      ).solidus_stripe_object
+
+      described_class.new.void_payment(event)
+
+      expect(payment.reload.state).to eq "void"
+      expect(payment.log_entries.count).to be(0)
+    end
+  end
+end

data/spec/support/solidus_stripe/backend_test_helper.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module SolidusStripe::BackendTestHelper
+  def create_payment_method(setup_future_usage: 'off_session', auto_capture: false)
+    @payment_method = create(
+      :solidus_stripe_payment_method,
+      preferred_setup_future_usage: setup_future_usage,
+      auto_capture: auto_capture
+    )
+  end
+
+  def payment_method
+    # Memoize the payment method id to avoid fetching it multiple times
+    @payment_method ||= SolidusStripe::PaymentMethod.first || create_payment_method
+  end
+
+  def order
+    @order ||= create(:completed_order_with_totals, line_items_price: 50)
+  end
+
+  def last_valid_payment
+    order.payments.valid.last
+  end
+
+  # Stripe-related helper methods for creating and fetching Stripe objects
+
+  def create_stripe_payment_method(card_number)
+    payment_method.gateway.request do
+      Stripe::PaymentMethod.create({
+        type: 'card',
+        card: {
+          number: card_number,
+          exp_month: 12,
+          exp_year: (Time.zone.now.year + 1),
+          cvc: '123',
+        },
+      })
+    end
+  end
+
+  def create_stripe_payment_intent(stripe_payment_method_id)
+    payment_method.gateway.request do
+      Stripe::PaymentIntent.create(
+        amount: (order.outstanding_balance * 100).to_i,
+        capture_method: 'manual',
+        confirm: true,
+        currency: 'usd',
+        payment_method: stripe_payment_method_id
+      )
+    end
+  end
+
+  def fetch_stripe_refund(payment)
+    payment_method.gateway.request do
+      Stripe::Refund.list(payment_intent: payment.response_code).data.first
+    end
+  end
+
+  def fetch_stripe_payment_intent(payment)
+    payment_method.gateway.request do
+      Stripe::PaymentIntent.retrieve(payment.response_code)
+    end
+  end
+
+  # Navigation helper methods for interacting with the admin panel
+
+  def visit_payments_page
+    visit "/admin/orders/#{order.number}/payments"
+  end
+
+  def visit_payment_page(payment)
+    visit_payments_page
+    click_on payment.number
+  end
+
+  # Action helper methods for performing operations on payments
+
+  def create_authorized_payment(opts = {})
+    stripe_payment_method = create_stripe_payment_method(opts[:card_number] || '4242424242424242')
+    stripe_payment_intent = create_stripe_payment_intent(stripe_payment_method.id)
+
+    create(:solidus_stripe_payment,
+      :authorized,
+      order: order,
+      response_code: stripe_payment_intent.id,
+      stripe_payment_method_id: stripe_payment_method.id,
+      payment_method: payment_method)
+  end
+
+  def create_captured_payment(card_number: '4242424242424242')
+    payment = create_authorized_payment(card_number: card_number)
+    payment.capture!
+    payment
+  end
+
+  def create_valid_payment_source
+    stripe_payment_method = create_stripe_payment_method('4242424242424242')
+    SolidusStripe::PaymentSource.create!(
+      stripe_payment_method_id: stripe_payment_method.id,
+      payment_method_id: payment_method.id
+    )
+  end
+
+  def create_order_with_existing_payment_source
+    payment_source = create_valid_payment_source
+    @order = create(:order_with_line_items, line_items_price: 50)
+    order.user.wallet.add(payment_source)
+  end
+
+  def complete_order_with_existing_payment_source
+    visit_payments_page
+    click_on "Continue"
+    click_on "Confirm"
+    click_on "Complete Order"
+  end
+
+  def refund_payment
+    refund_reason = create :refund_reason
+    click_icon(:"mail-reply") # Refund icon style reference in solidus_backend
+    within '.new_refund' do
+      select refund_reason.name, from: 'Reason'
+      click_button 'Refund'
+    end
+  end
+
+  def partially_refund_payment(refund_reason, amount)
+    click_icon(:"mail-reply") # Refund icon style reference in solidus_backend
+    within '.new_refund' do
+      select refund_reason.name, from: 'Reason'
+      fill_in 'Amount', with: amount
+      click_button 'Refund'
+    end
+  end
+
+  def capture_partial_payment_amount(payment, amount)
+    within_row(1) do
+      click_icon(:edit)
+      fill_in('amount', with: amount)
+      click_icon(:ok)
+      expect(page).to have_selector('td.amount span', text: amount.to_money.format)
+      expect(payment.reload.amount).to eq(amount)
+    end
+
+    capture_payment
+  end
+
+  def void_payment
+    click_icon(:void)
+  end
+
+  def capture_payment
+    click_icon(:capture)
+  end
+
+  def cancel_order
+    visit "/admin/orders/#{order.number}/edit"
+    accept_alert do
+      click_on 'Cancel'
+    end
+  end
+
+  # Helper methods for checking expected outcomes and states
+
+  def expects_page_to_display_log_messages(log_messages = [])
+    expect(page).to have_content('Log Entries')
+    log_messages.each do |log_message|
+      expect(page).to have_content(log_message)
+    end
+  end
+
+  def expects_payment_to_be_refunded_on_stripe(payment, amount)
+    stripe_refund = fetch_stripe_refund(payment)
+    expect(stripe_refund.amount).to eq(amount * 100)
+  end
+
+  def expects_payment_to_be_voided_on_stripe(payment)
+    stripe_payment_intent = fetch_stripe_payment_intent(payment)
+    expect(stripe_payment_intent.status).to eq('canceled')
+  end
+
+  def expects_payment_to_have_correct_capture_amount_on_stripe(payment, amount)
+    stripe_payment_intent = fetch_stripe_payment_intent(payment)
+    expect(stripe_payment_intent.amount_received).to eq(amount.to_money.fractional)
+  end
+end