solidus_stripe 4.4.1 → 5.0.0.alpha.1

data/spec/models/solidus_stripe/gateway_spec.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require 'solidus_stripe_spec_helper'
+
+RSpec.describe SolidusStripe::Gateway do
+  describe '#authorize' do
+    it 'confirms the Stripe payment' do
+      stripe_payment_method = Stripe::PaymentMethod.construct_from(id: "pm_123")
+      stripe_customer = Stripe::Customer.construct_from(id: 'cus_123')
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment,
+        amount: 123.45,
+        payment_method: payment_method,
+        stripe_payment_method_id: stripe_payment_method.id)
+      payment = order.payments.last
+
+      allow(Stripe::Customer).to receive(:create).and_return(stripe_customer)
+      [:create, :update, :retrieve].each do |method|
+        allow(Stripe::PaymentIntent).to receive(method).and_return(stripe_payment_intent)
+      end
+      allow(Stripe::PaymentIntent).to receive(:confirm).with(stripe_payment_intent.id).and_return(stripe_payment_intent)
+
+      result = gateway.authorize(123_45, payment.source, currency: 'USD', originator: order.payments.first)
+
+      expect(Stripe::PaymentIntent).to have_received(:update).with(
+        stripe_payment_intent.id,
+        { payment_method: stripe_payment_method.id }
+      )
+
+      expect(Stripe::PaymentIntent).to have_received(:create).with(
+        amount: 123_45,
+        currency: 'USD',
+        capture_method: 'manual',
+        confirm: false,
+        metadata: { solidus_order_number: order.number },
+        customer: "cus_123",
+        setup_future_usage: nil
+      )
+      expect(Stripe::PaymentIntent).to have_received(:confirm).with("pi_123")
+      expect(result.params).to eq("data" => '{"id":"pi_123"}')
+      expect(payment.reload.response_code).to eq("pi_123")
+    end
+
+    it 'generates error response on failure' do
+      stripe_payment_method = Stripe::PaymentMethod.construct_from(id: "pm_123")
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment,
+        amount: 123.45,
+        payment_method: payment_method,
+        stripe_payment_method_id: stripe_payment_method.id)
+      payment = order.payments.last
+
+      [:create, :update, :retrieve].each do |method|
+        allow(Stripe::PaymentIntent).to receive(method).and_return(stripe_payment_intent)
+      end
+      allow(Stripe::PaymentIntent).to receive(:confirm).with(
+        stripe_payment_intent.id
+      ).and_raise(Stripe::StripeError.new("auth error"))
+
+      result = gateway.authorize(123_45, payment.source, currency: 'USD', originator: order.payments.first)
+
+      expect(Stripe::PaymentIntent).to have_received(:confirm).with("pi_123")
+      expect(result.success?).to be(false)
+      expect(result.message).to eq("auth error")
+    end
+
+    it "raises if the given amount doesn't match the order total" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment, amount: 123.45, payment_method: payment_method)
+
+      expect { gateway.authorize(10, :source, originator: order.payments.first ) }.to raise_error(
+        /custom amount is not supported/
+      )
+    end
+  end
+
+  describe '#capture' do
+    it 'captures a pre-authorized Stripe payment' do
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+
+      gateway = build(:stripe_payment_method).gateway
+      payment = build(:payment, response_code: "pi_123", amount: 123.45)
+
+      allow(Stripe::PaymentIntent).to receive(:capture).and_return(stripe_payment_intent)
+
+      result = gateway.capture(123_45, "pi_123", originator: payment)
+
+      expect(Stripe::PaymentIntent).to have_received(:capture).with('pi_123')
+      expect(result.params).to eq("data" => '{"id":"pi_123"}')
+    end
+
+    it "raises if the given amount doesn't match the order total" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment, amount: 123.45, payment_method: payment_method)
+
+      expect { gateway.capture(10, :payment_intent_id, originator: order.payments.first ) }.to raise_error(
+        /custom amount is not supported/
+      )
+    end
+
+    it "raises if no payment_intent_id is given" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment, amount: 123.45, payment_method: payment_method)
+
+      expect { gateway.capture(123_45, nil, originator: order.payments.first ) }.to raise_error(
+        ArgumentError,
+        /missing payment_intent_id/
+      )
+    end
+
+    it "raises if payment_intent_id is not valid" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment, amount: 123.45, payment_method: payment_method)
+
+      expect { gateway.capture(123_45, "invalid", originator: order.payments.first ) }.to raise_error(
+        ArgumentError,
+        /payment intent id has the wrong format/
+      )
+    end
+  end
+
+  describe '#void' do
+    it 'voids a payment that hasn not been captured yet' do
+      gateway = build(:stripe_payment_method).gateway
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+      allow(Stripe::PaymentIntent).to receive(:cancel).and_return(stripe_payment_intent)
+
+      result = gateway.void('pi_123')
+
+      expect(Stripe::PaymentIntent).to have_received(:cancel).with('pi_123')
+      expect(result.params).to eq("data" => '{"id":"pi_123"}')
+    end
+
+    it "raises if no payment_intent_id is given" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+
+      expect { gateway.void(nil) }.to raise_error(
+        ArgumentError,
+        /missing payment_intent_id/
+      )
+    end
+
+    it "raises if payment_intent_id is not valid" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+
+      expect { gateway.void("invalid") }.to raise_error(
+        ArgumentError,
+        /payment intent id has the wrong format/
+      )
+    end
+  end
+
+  describe '#purchase' do
+    it 'authorizes and captures in a single operation' do
+      stripe_payment_method = Stripe::PaymentMethod.construct_from(id: "pm_123")
+      stripe_customer = Stripe::Customer.construct_from(id: 'cus_123')
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment,
+        amount: 123.45,
+        payment_method: payment_method,
+        stripe_payment_method_id: stripe_payment_method.id)
+      payment = order.payments.last
+
+      allow(Stripe::Customer).to receive(:create).and_return(stripe_customer)
+      [:create, :update, :retrieve].each do |method|
+        allow(Stripe::PaymentIntent).to receive(method).and_return(stripe_payment_intent)
+      end
+      allow(Stripe::PaymentIntent).to receive(:confirm).with(stripe_payment_intent.id).and_return(stripe_payment_intent)
+
+      result = gateway.purchase(123_45, payment.source, currency: 'USD', originator: order.payments.first)
+
+      expect(Stripe::PaymentIntent).to have_received(:update).with(
+        stripe_payment_intent.id,
+        { payment_method: stripe_payment_method.id }
+      )
+
+      expect(Stripe::PaymentIntent).to have_received(:create).with(
+        amount: 123_45,
+        currency: 'USD',
+        capture_method: 'automatic',
+        confirm: false,
+        metadata: { solidus_order_number: order.number },
+        customer: "cus_123",
+        setup_future_usage: nil
+      )
+      expect(Stripe::PaymentIntent).to have_received(:confirm).with("pi_123")
+      expect(result.params).to eq("data" => '{"id":"pi_123"}')
+      expect(payment.reload.response_code).to eq("pi_123")
+    end
+
+    it 'generates error response on failure' do
+      stripe_payment_method = Stripe::PaymentMethod.construct_from(id: "pm_123")
+      stripe_payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123")
+
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment,
+        amount: 123.45,
+        payment_method: payment_method,
+        stripe_payment_method_id: stripe_payment_method.id)
+      payment = order.payments.last
+
+      [:create, :update, :retrieve].each do |method|
+        allow(Stripe::PaymentIntent).to receive(method).and_return(stripe_payment_intent)
+      end
+      allow(Stripe::PaymentIntent).to receive(:confirm).with(
+        stripe_payment_intent.id
+      ).and_raise(Stripe::StripeError.new("auth error"))
+
+      result = gateway.purchase(123_45, payment.source, currency: 'USD', originator: order.payments.first)
+
+      expect(Stripe::PaymentIntent).to have_received(:confirm).with("pi_123")
+      expect(result.success?).to be(false)
+      expect(result.message).to eq("auth error")
+    end
+
+    it "raises if the given amount doesn't match the order total" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+      order = create(:order_with_stripe_payment, amount: 123.45, payment_method: payment_method)
+
+      expect { gateway.purchase(10, :source, originator: order.payments.first ) }.to raise_error(
+        /custom amount is not supported/
+      )
+    end
+  end
+
+  describe '#credit' do
+    it 'refunds when provided an originator payment' do
+      gateway = build(:stripe_payment_method).gateway
+      payment = instance_double(Spree::Payment, response_code: 'pi_123', currency: "USD")
+      refund = Stripe::Refund.construct_from(id: "re_123")
+      allow(Stripe::Refund).to receive(:create).and_return(refund)
+
+      result = gateway.credit(123_45, 'pi_123', currency: 'USD', originator: instance_double(
+        Spree::Refund,
+        payment: payment
+      ))
+
+      expect(Stripe::Refund).to have_received(:create).with(
+        payment_intent: 'pi_123',
+        amount: 123_45,
+        metadata: { solidus_skip_sync: 'true' }
+      )
+      expect(result.params).to eq("data" => '{"id":"re_123"}')
+    end
+
+    it "raises if no payment_intent_id is given" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+
+      expect { gateway.credit(:amount, nil) }.to raise_error(
+        ArgumentError,
+        /missing payment_intent_id/
+      )
+    end
+
+    it "raises if payment_intent_id is not valid" do
+      payment_method = build(:stripe_payment_method)
+      gateway = payment_method.gateway
+
+      expect { gateway.credit(:amount, "invalid") }.to raise_error(
+        ArgumentError,
+        /payment intent id has the wrong format/
+      )
+    end
+  end
+end

data/spec/models/solidus_stripe/payment_intent_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'solidus_stripe_spec_helper'
+
+RSpec.describe SolidusStripe::PaymentIntent do
+  describe "#reload" do
+    it "reloads the stripe intent" do
+      intent = create(:stripe_payment_intent)
+      allow(Stripe::PaymentIntent).to receive(:retrieve) do
+        Stripe::PaymentIntent.construct_from(id: intent.stripe_intent_id)
+      end
+
+      expect(intent.stripe_intent.object_id).to eq(intent.stripe_intent.object_id)
+      expect(intent.stripe_intent.object_id).not_to eq(intent.reload.stripe_intent.object_id)
+    end
+  end
+end

data/spec/models/solidus_stripe/payment_method_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'solidus_stripe_spec_helper'
+
+RSpec.describe SolidusStripe::PaymentMethod do
+  it 'has a working factory' do
+    expect(create(:stripe_payment_method)).to be_valid
+  end
+
+  describe 'Callbacks' do
+    describe 'after_create' do
+      it 'creates a webhook endpoint' do
+        payment_method = create(:stripe_payment_method)
+
+        expect(payment_method.slug_entry).to be_present
+      end
+    end
+  end
+
+  describe '#intent_id_for_payment' do
+    context 'when the payment has a transaction_id' do
+      it 'fetches the payment intent id from the response code' do
+        payment = build(:payment, response_code: 'pi_123')
+
+        expect(described_class.intent_id_for_payment(payment)).to eq("pi_123")
+      end
+    end
+
+    context 'when the order has a payment intent' do
+      it 'fetches the payment intent id' do
+        intent = create(:stripe_payment_intent, stripe_intent_id: 'pi_123')
+        payment = build(:payment, response_code: nil, payment_method: intent.payment_method, order: intent.order)
+
+        expect(described_class.intent_id_for_payment(payment)).to eq("pi_123")
+      end
+    end
+
+    it 'returns nil without a payment' do
+      expect(described_class.intent_id_for_payment(nil)).to eq(nil)
+    end
+  end
+
+  describe '#stripe_dashboard_url' do
+    context 'with a payment intent id' do
+      it 'generates a dashboard link' do
+        payment_method = build(:stripe_payment_method, preferred_test_mode: false)
+
+        expect(payment_method.stripe_dashboard_url('pi_123')).to eq("https://dashboard.stripe.com/payments/pi_123")
+      end
+
+      it 'supports test mode' do
+        payment_method = build(:stripe_payment_method, preferred_test_mode: true)
+
+        expect(payment_method.stripe_dashboard_url('pi_123')).to eq("https://dashboard.stripe.com/test/payments/pi_123")
+      end
+    end
+
+    it 'returns nil with anything else' do
+      payment_method = build(:stripe_payment_method)
+
+      expect(payment_method.stripe_dashboard_url(Object.new)).to eq(nil)
+      expect(payment_method.stripe_dashboard_url('')).to eq(nil)
+      expect(payment_method.stripe_dashboard_url(123)).to eq(nil)
+    end
+  end
+
+  describe '.with_slug' do
+    it 'selects by slug' do
+      payment_method = create(:stripe_payment_method)
+
+      expect(described_class.with_slug(payment_method.slug)).to eq([payment_method])
+      expect(described_class.with_slug('bad-slug')).to eq([])
+    end
+  end
+
+  describe '.previous_sources' do
+    it 'finds no sources associated with the order' do
+      payment_method = create(:stripe_payment_method)
+      order = create(:order, user: nil)
+
+      expect(payment_method.previous_sources(order)).to be_empty
+    end
+
+    it 'finds no sources associated with the user' do
+      payment_method = create(:stripe_payment_method)
+      user = create(:user)
+      order = create(:order, user: user)
+
+      expect(payment_method.previous_sources(order)).to be_empty
+    end
+
+    it 'finds sources associated with the user' do
+      payment_source = create(:stripe_payment_source)
+      payment_method = payment_source.payment_method
+      user = create(:user)
+      order = create(:order, user: user.reload)
+
+      user.wallet.add(payment_source)
+
+      expect(payment_method.previous_sources(order)).to eq [payment_source]
+    end
+  end
+
+  describe '.assign_slug' do
+    it 'generates a "test" slug for the first payment method in test mode' do
+      payment_method = build(:stripe_payment_method)
+
+      payment_method.save!
+
+      expect(payment_method.slug).to eq('test')
+    end
+
+    it 'generates a "live" slug for the first payment method in live mode' do
+      payment_method = build(:stripe_payment_method, preferred_test_mode: false)
+
+      payment_method.save!
+
+      expect(payment_method.slug).to eq('live')
+    end
+
+    it 'generates a random hex string' do
+      _existing_payment_method = create(:stripe_payment_method)
+      payment_method = create(:stripe_payment_method)
+
+      expect(payment_method.slug).to match(/^[0-9a-f]{32}$/)
+    end
+
+    it 'generates a unique slug' do
+      slug = SecureRandom.hex(16)
+
+      create(:stripe_slug_entry, slug: slug)
+      allow(SecureRandom).to receive(:hex).and_return(slug).and_call_original
+
+      expect(create(:stripe_payment_method).slug).not_to eq(slug)
+    end
+  end
+end

data/spec/models/solidus_stripe/payment_source_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'solidus_stripe_spec_helper'
+
+RSpec.describe SolidusStripe::PaymentSource, type: :model do
+  it 'has a working factory' do
+    expect(create(:stripe_payment_source)).to be_valid
+  end
+
+  describe '#stripe_payment_method' do
+    it 'retrieves the Stripe::PaymentMethod object if the stripe_payment_method id is present' do
+      stripe_payment_method = Stripe::PaymentMethod.construct_from(id: 'pm_123')
+      source = create(:stripe_payment_source, stripe_payment_method_id: 'pm_123')
+      allow(Stripe::PaymentMethod).to receive(:retrieve).with('pm_123').and_return(stripe_payment_method)
+
+      expect(source.stripe_payment_method).to eq(stripe_payment_method)
+    end
+
+    it 'returns nil if the stripe_payment_method id is missing' do
+      source = create(:stripe_payment_source, stripe_payment_method_id: nil)
+
+      expect(source.stripe_payment_method).to be_nil
+    end
+  end
+end

data/spec/requests/solidus_stripe/intents_controller_spec.rb

@@ -0,0 +1,29 @@
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::IntentsController, type: :request do
+  describe "GET /after_confirmation" do
+    context 'when not provided a payment intent' do
+      it 'responds with unprocessable entity' do
+        payment_method = create(:stripe_payment_method)
+        order = create(:order_ready_to_complete)
+        sign_in order.user
+
+        get "/solidus_stripe/#{payment_method.slug}/after_confirmation"
+
+        expect(response.status).to eq(422)
+      end
+    end
+
+    context 'when the order is not at "confirm"' do
+      it 'redirects to the current order step' do
+        payment_method = create(:stripe_payment_method)
+        order = create(:order)
+        sign_in order.user
+
+        get "/solidus_stripe/#{payment_method.slug}/after_confirmation?payment_intent=pi_123"
+
+        expect(response).to redirect_to('/checkout/cart')
+      end
+    end
+  end
+end

data/spec/requests/solidus_stripe/webhooks_controller/charge/refunded_spec.rb

@@ -0,0 +1,31 @@
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::WebhooksController, type: %i[request webhook_request] do
+  describe "POST /create charge.refunded" do
+    it "synchronizes refunds" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_method = create(: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: {} }]
+        )
+      )
+      context = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_charge,
+        type: "charge.refunded"
+      )
+
+      webhook_request(context)
+
+      expect(payment.reload.refunds.count).to be(1)
+    end
+  end
+end

data/spec/requests/solidus_stripe/webhooks_controller/payment_intent/canceled_spec.rb

@@ -0,0 +1,23 @@
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::WebhooksController, type: %i[request webhook_request] do
+  describe "POST /create payment_intent.canceled" do
+    it "transitions the associated payment to failed" do
+      payment_method = create(: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")
+      context = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.canceled"
+      )
+
+      expect do
+        webhook_request(context)
+      end.to change { payment.reload.state }.from("pending").to("void")
+    end
+  end
+end

data/spec/requests/solidus_stripe/webhooks_controller/payment_intent/payment_failed_spec.rb

@@ -0,0 +1,23 @@
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::WebhooksController, type: %i[request webhook_request] do
+  describe "POST /create payment_intent.payment_failed" do
+    it "transitions the associated payment to failed" do
+      payment_method = create(: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")
+      context = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.payment_failed"
+      )
+
+      expect do
+        webhook_request(context)
+      end.to change { payment.reload.state }.from("pending").to("failed")
+    end
+  end
+end

data/spec/requests/solidus_stripe/webhooks_controller/payment_intent/succeeded_spec.rb

@@ -0,0 +1,29 @@
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::WebhooksController, type: %i[request webhook_request] do
+  describe "POST /create payment_intent.succeeded" do
+    it "captures the associated payment" do
+      payment_method = create(: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")
+      context = SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        payment_method: payment_method,
+        object: stripe_payment_intent,
+        type: "payment_intent.succeeded"
+      )
+
+      expect do
+        webhook_request(context)
+      end.to change { payment.reload.state }.from("pending").to("completed")
+    end
+  end
+end

data/spec/requests/solidus_stripe/webhooks_controller_spec.rb

@@ -0,0 +1,52 @@
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::WebhooksController, type: [:request, :webhook_request] do
+  describe "POST /create" do
+    let(:stripe) { create(:stripe_payment_method) }
+    let(:payment_intent) { stripe.gateway.request { Stripe::PaymentIntent.create(amount: 100, currency: 'usd') } }
+    let(:context) do
+      SolidusStripe::Webhook::EventWithContextFactory.from_object(
+        object: payment_intent,
+        type: "payment_intent.created",
+        payment_method: stripe
+      )
+    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