make tests pass

Author: zcesur

lib/algora/integrations/stripe/stripe.ex

@@ -32,4 +32,16 @@ defmodule Algora.Stripe do
 
     def create(params), do: Algora.Stripe.client(__MODULE__).create(params)
   end
+
+  defmodule PaymentMethod do
+    @moduledoc false
+
+    def attach(params), do: Algora.Stripe.client(__MODULE__).attach(params)
+  end
+
+  defmodule SetupIntent do
+    @moduledoc false
+
+    def retrieve(id, params), do: Algora.Stripe.client(__MODULE__).retrieve(id, params)
+  end
 end

lib/algora_web/controllers/webhooks/stripe_controller.ex

@@ -98,9 +98,9 @@ defmodule AlgoraWeb.Webhooks.StripeController do
         type: "checkout.session.completed",
         data: %{object: %Stripe.Session{customer: customer_id, mode: "setup", setup_intent: setup_intent_id}}
       }) do
-    with {:ok, setup_intent} <- Stripe.SetupIntent.retrieve(setup_intent_id, %{}),
+    with {:ok, setup_intent} <- Algora.Stripe.SetupIntent.retrieve(setup_intent_id, %{}),
          pm_id = setup_intent.payment_method,
-         {:ok, payment_method} <- Stripe.PaymentMethod.attach(%{payment_method: pm_id, customer: customer_id}),
+         {:ok, payment_method} <- Algora.Stripe.PaymentMethod.attach(%{payment_method: pm_id, customer: customer_id}),
          {:ok, customer} <- Repo.fetch_by(Customer, provider: "stripe", provider_id: customer_id),
          {:ok, _} <- Payments.create_payment_method(customer, payment_method) do
       Payments.broadcast()

test/algora_web/controllers/webhooks/stripe_controller_test.exs

@@ -5,43 +5,86 @@ defmodule AlgoraWeb.Webhooks.StripeControllerTest do
   import Algora.Factory
   import Ecto.Query
 
+  alias Algora.Bounties
   alias Algora.Payments
   alias Algora.Payments.PaymentMethod
   alias Algora.Payments.Transaction
   alias Algora.Repo
   alias AlgoraWeb.Webhooks.StripeController
 
   setup do
-    # Insert a test customer
-    user = insert(:user)
-    customer = insert(:customer, user: user)
-
-    # Common metadata for stripe events
+    sender = insert(:user)
+    recipient = insert(:user)
+    customer = insert(:customer, user: sender)
     metadata = %{"version" => Payments.metadata_version()}
-
-    {:ok, customer: customer, metadata: metadata}
+    {:ok, customer: customer, metadata: metadata, sender: sender, recipient: recipient}
   end
 
   describe "handle_event/1 for charge.succeeded" do
-    test "updates transaction status and creates jobs for credits", %{metadata: metadata} do
-      group_id = Ecto.UUID.generate()
+    test "updates transaction status and enqueues PromptPayoutConnect job", %{
+      metadata: metadata,
+      sender: sender,
+      recipient: recipient
+    } do
+      group_id = "#{Algora.Util.random_int()}"
+
+      debit_tx =
+        insert(:transaction, %{
+          type: :debit,
+          status: :initialized,
+          group_id: group_id,
+          user_id: sender.id
+        })
 
-      # Create test transactions in the group
       credit_tx =
         insert(:transaction, %{
           type: :credit,
-          status: :pending,
-          group_id: group_id
+          status: :initialized,
+          group_id: group_id,
+          user_id: recipient.id
         })
 
+      event = %Stripe.Event{
+        type: "charge.succeeded",
+        data: %{
+          object: %Stripe.Charge{
+            metadata: Map.put(metadata, "group_id", group_id)
+          }
+        }
+      }
+
+      assert {:ok, _} = StripeController.handle_event(event)
+
+      assert Repo.get(Transaction, credit_tx.id).status == :succeeded
+      assert Repo.get(Transaction, debit_tx.id).status == :succeeded
+
+      assert_enqueued(worker: Bounties.Jobs.PromptPayoutConnect)
+    end
+
+    test "updates transaction status and enqueues ExecutePendingTransfer for enabled accounts", %{
+      metadata: metadata,
+      sender: sender,
+      recipient: recipient
+    } do
+      _account = insert(:account, %{user_id: recipient.id, payouts_enabled: true})
+      group_id = "#{Algora.Util.random_int()}"
+
       debit_tx =
         insert(:transaction, %{
           type: :debit,
-          status: :pending,
-          group_id: group_id
+          status: :initialized,
+          group_id: group_id,
+          user_id: sender.id
+        })
+
+      credit_tx =
+        insert(:transaction, %{
+          type: :credit,
+          status: :initialized,
+          group_id: group_id,
+          user_id: recipient.id
         })
 
-      # Create stripe event
       event = %Stripe.Event{
         type: "charge.succeeded",
         data: %{
@@ -51,26 +94,25 @@ defmodule AlgoraWeb.Webhooks.StripeControllerTest do
         }
       }
 
-      assert {:ok, nil} = StripeController.handle_event(event)
+      assert {:ok, _} = StripeController.handle_event(event)
 
-      # Assert transactions were updated
       assert Repo.get(Transaction, credit_tx.id).status == :succeeded
       assert Repo.get(Transaction, debit_tx.id).status == :succeeded
 
-      # Assert jobs were created
       assert_enqueued(worker: Payments.Jobs.ExecutePendingTransfer, args: %{credit_id: credit_tx.id})
     end
   end
 
   describe "handle_event/1 for transfer.created" do
     test "updates associated transaction status", %{metadata: metadata} do
-      transfer_id = "tr_#{Ecto.UUID.generate()}"
+      transfer_id = "tr_#{Algora.Util.random_int()}"
 
       transaction =
         insert(:transaction, %{
           provider: "stripe",
           provider_id: transfer_id,
-          status: :pending
+          type: :transfer,
+          status: :initialized
         })
 
       event = %Stripe.Event{
@@ -93,8 +135,7 @@ defmodule AlgoraWeb.Webhooks.StripeControllerTest do
 
   describe "handle_event/1 for checkout.session.completed" do
     test "creates payment method for setup mode", %{customer: customer} do
-      setup_intent_id = "seti_#{Ecto.UUID.generate()}"
-      payment_method_id = "pm_#{Ecto.UUID.generate()}"
+      setup_intent_id = "seti_#{Algora.Util.random_int()}"
 
       event = %Stripe.Event{
         type: "checkout.session.completed",
@@ -109,8 +150,9 @@ defmodule AlgoraWeb.Webhooks.StripeControllerTest do
 
       assert :ok = StripeController.handle_event(event)
 
-      # Assert payment method was created
-      payment_method = Repo.one!(from p in PaymentMethod, where: p.provider_id == ^payment_method_id)
+      {:ok, setup_intent} = Algora.Stripe.SetupIntent.retrieve(setup_intent_id, %{})
+
+      payment_method = Repo.one!(from p in PaymentMethod, where: p.provider_id == ^setup_intent.payment_method)
       assert payment_method.customer_id == customer.id
     end
   end

test/support/stripe_mock.ex

@@ -57,4 +57,24 @@ defmodule Algora.Support.StripeMock do
       {:ok, %Stripe.Session{id: "cs_#{Algora.Util.random_int()}", url: "https://example.com/stripe"}}
     end
   end
+
+  defmodule PaymentMethod do
+    @moduledoc false
+    def attach(%{payment_method: payment_method_id}) do
+      {:ok, %Stripe.PaymentMethod{id: payment_method_id}}
+    end
+  end
+
+  defmodule SetupIntent do
+    @moduledoc false
+    def retrieve(id, _params) do
+      payment_method_id = "pm_#{:erlang.phash2(id)}"
+
+      {:ok,
+       %Stripe.SetupIntent{
+         id: "seti_#{:erlang.phash2(id)}",
+         payment_method: payment_method_id
+       }}
+    end
+  end
 end