solidus_stripe 4.4.1 → 5.0.0.alpha.1

data/spec/lib/solidus_stripe/refunds_synchronizer_spec.rb

@@ -0,0 +1,238 @@
+# frozen-string-literal: true
+
+require "solidus_stripe_spec_helper"
+require "solidus_stripe/refunds_synchronizer"
+require "solidus_stripe/seeds"
+
+RSpec.describe SolidusStripe::RefundsSynchronizer do
+  def mock_refund_list(payment_intent_id, refunds)
+    allow(Stripe::Refund).to receive(:list).with(payment_intent: payment_intent_id).and_return(
+      Stripe::ListObject.construct_from(
+        data: refunds
+      )
+    )
+  end
+
+  describe "#call" do
+    let(:payment_method) { create(:stripe_payment_method) }
+
+    it "creates missing refunds on Solidus" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(payment.refunds.count).to eq(1)
+    end
+
+    it "uses the stripe refund id as created Solidus refund transaction_id field" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      refund = payment.refunds.first
+      expect(refund.transaction_id).to eq("re_123")
+    end
+
+    it "uses the stripe amount as created Solidus refund amount" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      refund = payment.refunds.first
+      expect(refund.amount).to eq(10)
+    end
+
+    it "uses the configured reason for created Solidus refunds" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      refund = payment.refunds.first
+      expect(refund.reason).to eq(SolidusStripe::PaymentMethod.refund_reason)
+    end
+
+    it "skips the creation of Solidus refunds with transaction_id matching some stripe refund id" do
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+      create(:refund, amount: 10, payment: payment, transaction_id: "re_123")
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(payment.refunds.count).to be(1)
+    end
+
+    it "skips the creation of Solidus refunds when specified in their metadata" do
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {
+            solidus_skip_sync: 'true'
+          }
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(payment.refunds.count).to be(0)
+    end
+
+    it "creates multiple Solidus refunds if needed" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 500,
+          currency: "usd",
+          metadata: {}
+        },
+        {
+          id: "re_456",
+          amount: 500,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(payment.refunds.count).to be(2)
+    end
+
+    it "creates only the missing Solidus refunds when there're multiple Stripe refunds" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 500,
+          currency: "usd",
+          metadata: {}
+        },
+        {
+          id: "re_456",
+          amount: 500,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+      create(:refund, amount: 5, payment: payment, transaction_id: "re_123")
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(payment.refunds.pluck(:transaction_id)).to contain_exactly("re_123", "re_456")
+    end
+
+    it "adds a log entry for created Solidus refund" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(payment.log_entries.count).to eq(1)
+    end
+
+    it "sets created log entry as successful" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 1000,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(
+        payment.log_entries.first.parsed_details.success?
+      ).to be(true)
+    end
+
+    it "uses a meaningful message with the refunded amount in created log entry" do
+      SolidusStripe::Seeds.refund_reasons
+      payment_intent_id = "pi_123"
+      payment = create(:payment, response_code: payment_intent_id, amount: 10, payment_method: payment_method)
+      mock_refund_list(payment_intent_id, [
+        {
+          id: "re_123",
+          amount: 500,
+          currency: "usd",
+          metadata: {}
+        }
+      ])
+
+      described_class.new(payment_method).call(payment_intent_id)
+
+      expect(
+        payment.log_entries.first.parsed_details.message
+      ).to include("after Stripe event ($5.00)")
+    end
+  end
+end

data/spec/lib/solidus_stripe/seeds_spec.rb

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+
+require "solidus_stripe_spec_helper"
+
+RSpec.describe SolidusStripe::Seeds do
+  describe ".refund_reasons" do
+    it "creates a refund reason" do
+      expect do
+        described_class.refund_reasons
+      end.to change(Spree::RefundReason, :count).from(0).to(1)
+    end
+
+    it "uses default name for the refund reason name" do
+      described_class.refund_reasons
+
+      expect(Spree::RefundReason.last.name).to eq(described_class::DEFAULT_STRIPE_REFUND_REASON_NAME)
+    end
+
+    it "makes the refund reason immutable" do
+      described_class.refund_reasons
+
+      expect(Spree::RefundReason.last.mutable).to be(false)
+    end
+
+    it "does not duplicate refund reasons" do
+      described_class.refund_reasons
+
+      expect do
+        described_class.refund_reasons
+      end.not_to change(Spree::RefundReason, :count)
+    end
+
+    it "does not change the mutable attribute of existing refund reasons" do
+      described_class.refund_reasons
+      refund_reason = Spree::RefundReason.last
+      refund_reason.update_column(:mutable, true)
+
+      described_class.refund_reasons
+
+      expect(refund_reason.reload.mutable).to be(true)
+    end
+  end
+end

data/spec/lib/solidus_stripe/webhook/event_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "solidus_stripe_spec_helper"
+require "solidus_stripe/webhook/event"
+require "omnes/bus"
+
+RSpec.describe SolidusStripe::Webhook::Event do
+  describe ".register" do
+    it "registers core events prepending with 'stripe'" do
+      bus = Omnes::Bus.new
+
+      described_class.register(bus: bus, core_events: %i[foo], user_events: [])
+
+      expect(bus.registry.registered?(:"stripe.foo")).to be(true)
+    end
+
+    it "registers user events prepending with 'stripe'" do
+      bus = Omnes::Bus.new
+
+      described_class.register(bus: bus, user_events: %i[foo])
+
+      expect(bus.registry.registered?(:"stripe.foo")).to be(true)
+    end
+  end
+
+  describe ".from_request" do
+    let(:context) do
+      SolidusStripe::Webhook::EventWithContextFactory.from_data(
+        data: SolidusStripe::Webhook::DataFixtures.charge_succeeded,
+        payment_method: create(:stripe_payment_method)
+      )
+    end
+
+    context "with a valid event" do
+      it "returns an event" do
+        event = described_class.from_request(
+          payload: context.json, signature_header: context.signature_header, slug: context.slug
+        )
+
+        expect(event).to be_a(described_class)
+      end
+    end
+
+    context "when the signature is invalid" do
+      it "returns nil" do
+        signature_header = "t=1,v1=1"
+
+        event = described_class.from_request(
+          payload: context.json, signature_header: signature_header, slug: context.slug
+        )
+
+        expect(event).to be(nil)
+      end
+    end
+
+    context "when the tolerance has expired" do
+      it "returns nil" do
+        event = described_class.from_request(
+          payload: context.json, signature_header: context.signature_header, tolerance: 0, slug: context.slug
+        )
+
+        expect(event).to be(nil)
+      end
+    end
+
+    context "when the payload is malformed" do
+      it "returns nil" do
+        event = described_class.from_request(
+          payload: "invalid", signature_header: context.signature_header, slug: context.slug
+        )
+
+        expect(event).to be(nil)
+      end
+    end
+
+    context "when the slug is not known" do
+      it "returns nil" do
+        event = described_class.from_request(
+          payload: context.json, signature_header: context.signature_header, slug: "foo"
+        )
+
+        expect(event).to be(nil)
+      end
+    end
+  end
+
+  describe "#initialize" do
+    let(:context) do
+      SolidusStripe::Webhook::EventWithContextFactory.new(
+        data: SolidusStripe::Webhook::DataFixtures.charge_succeeded,
+        payment_method: create(:stripe_payment_method)
+      )
+    end
+
+    it "sets the payment method" do
+      event = described_class.new(stripe_event: context.stripe_object, spree_payment_method: context.payment_method)
+
+      expect(event.spree_payment_method).to be(context.payment_method)
+    end
+
+    it "sets the omnes_event_name from the event type field" do
+      event = described_class.new(stripe_event: context.stripe_object, spree_payment_method: context.payment_method)
+
+      expect(event.omnes_event_name).to be(:"stripe.charge.succeeded")
+    end
+
+    it "delegates all other methods to the stripe event" do
+      event = described_class.new(stripe_event: context.stripe_object, spree_payment_method: context.payment_method)
+
+      expect(event.type).to eq("charge.succeeded")
+    end
+  end
+
+  describe "#payload" do
+    let(:context) do
+      SolidusStripe::Webhook::EventWithContextFactory.new(
+        data: SolidusStripe::Webhook::DataFixtures.charge_succeeded,
+        payment_method: create(:stripe_payment_method)
+      )
+    end
+
+    it "includes stripe event Hash representation" do
+      event = described_class.new(stripe_event: context.stripe_object, spree_payment_method: context.payment_method)
+
+      expect(event.payload["stripe_event"]).to eq(context.stripe_object.as_json)
+    end
+
+    it "includes spree payment method id" do
+      event = described_class.new(stripe_event: context.stripe_object, spree_payment_method: context.payment_method)
+
+      expect(event.payload["spree_payment_method_id"]).to be(context.payment_method.id)
+    end
+  end
+end

data/spec/models/concerns/solidus_stripe/log_entries_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'solidus_stripe_spec_helper'
+
+RSpec.describe SolidusStripe::LogEntries do
+  describe '#payment_log' do
+    it 'creates a new Spree::LogEntry associated to the payment' do
+      payment = create(:payment)
+
+      expect {
+        described_class.payment_log(
+          payment,
+          message: "Hi there!",
+          success: true,
+        )
+      }.to change(Spree::LogEntry, :count).by(1)
+
+      details = payment.log_entries.last.parsed_details
+
+      expect(details).to respond_to(:success?)
+      expect(details).to respond_to(:message)
+      expect(details.message).to eq("Hi there!")
+      expect(details.success?).to eq(true)
+    end
+  end
+
+  describe '#build_payment_log' do
+    it 'creates an object suitable for serialization in a Spree::LogEntry' do
+      details = described_class.build_payment_log(
+        message: "Hi there!",
+        success: true,
+      )
+
+      expect(details).to respond_to(:success?)
+      expect(details).to respond_to(:message)
+      expect(details.message).to eq("Hi there!")
+      expect(details.success?).to eq(true)
+    end
+
+    it 'accepts data and a response_code' do
+      details = described_class.build_payment_log(
+        message: "Hi there!",
+        success: true,
+        response_code: 'foo_123',
+        data: { foo: :Bar },
+      )
+
+      expect(details.message).to eq("Hi there!")
+      expect(details.success?).to eq(true)
+      expect(details.authorization).to eq('foo_123')
+      expect(details.params).to eq("data" => '{"foo":"Bar"}')
+    end
+  end
+end

data/spec/models/solidus_stripe/customer_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'solidus_stripe_spec_helper'
+
+RSpec.describe SolidusStripe::Customer, type: :model do
+  describe ".retrieve_or_create_stripe_customer_id" do
+    context 'with an existing customer' do
+      it 'returns the customer_id' do
+        user = create(:user)
+        order = create(:order, user: user)
+        customer = create(:stripe_customer, stripe_id: 'cus_123', source: user)
+
+        expect(customer.source).to be_a(Spree::User)
+        expect(
+          described_class.retrieve_or_create_stripe_customer_id(order: order, payment_method: customer.payment_method)
+        ).to eq('cus_123')
+      end
+    end
+
+    context 'without an existing customer' do
+      it 'creates the customer from a user' do
+        user = create(:user, email: 'registered@example.com')
+        order = create(:order, user: user)
+        payment_method = create(:stripe_payment_method)
+
+        stripe_customer = Stripe::Customer.construct_from(id: 'cus_123')
+        allow(Stripe::Customer).to receive(:create).with(email: 'registered@example.com').and_return(stripe_customer)
+
+        expect(
+          described_class.retrieve_or_create_stripe_customer_id(order: order, payment_method: payment_method)
+        ).to eq('cus_123')
+      end
+
+      it 'creates the customer from a guest order' do
+        payment_method = create(:stripe_payment_method)
+        order = create(:order, user: nil, email: 'guest@example.com')
+
+        stripe_customer = Stripe::Customer.construct_from(id: 'cus_123')
+        allow(Stripe::Customer).to receive(:create).with(email: 'guest@example.com').and_return(stripe_customer)
+
+        expect(
+          described_class.retrieve_or_create_stripe_customer_id(order: order, payment_method: payment_method)
+        ).to eq('cus_123')
+      end
+    end
+  end
+end