update tests

Author: zcesur

lib/algora/payments/payments.ex

@@ -320,26 +320,24 @@ defmodule Algora.Payments do
     # TODO: provide idempotency key
     case Algora.Stripe.create_transfer(%{
            amount: MoneyUtils.to_minor_units(transaction.net_amount),
-           currency: to_string(transaction.net_amount.currency),
+           currency: MoneyUtils.to_stripe_currency(transaction.net_amount),
            destination: account.provider_id
          }) do
       {:ok, transfer} ->
         # it's fine if this fails since we'll receive a webhook
-        _result = try_update_transaction(transaction, transfer)
+        transaction
+        |> change(%{status: :succeeded, provider_id: transfer.id, provider_meta: Util.normalize_struct(transfer)})
+        |> Repo.update()
+
         {:ok, transfer}
 
       {:error, error} ->
+        # TODO: inconsistent state if this fails
+        transaction
+        |> change(%{status: :failed})
+        |> Repo.update()
+
         {:error, error}
     end
   end
-
-  defp try_update_transaction(transaction, transfer) do
-    transaction
-    |> change(%{
-      status: if(transfer.status == :succeeded, do: :succeeded, else: :failed),
-      provider_id: transfer.id,
-      provider_meta: Util.normalize_struct(transfer)
-    })
-    |> Repo.update()
-  end
 end

lib/algora/shared/money_utils.ex

@@ -17,6 +17,11 @@ defmodule Algora.MoneyUtils do
     amount_int
   end
 
+  @spec to_stripe_currency(Money.t()) :: String.t()
+  def to_stripe_currency(money) do
+    money.currency |> to_string() |> String.downcase()
+  end
+
   # TODO: Find a way to make this obsolete
   # Why does ecto return {currency, amount} instead of Money.t()?
   def ensure_money_field(struct, field) do

test/algora/payments_test.exs

@@ -10,44 +10,55 @@ defmodule Algora.PaymentsTest do
 
   setup :verify_on_exit!
 
-  describe "perform/1" do
+  describe "execute_pending_transfers/1" do
     setup do
       user = insert(:user)
       account = insert(:account, user: user)
 
       {:ok, user: user, account: account}
     end
 
-    test "executes transfer when there are pending credits", %{user: user} do
-      # Create a successful credit transaction
+    test "executes transfer when there are pending credits", %{user: user, account: account} do
       insert(:transaction,
         user: user,
         type: :credit,
         status: :succeeded,
         net_amount: Money.new(1, :USD)
       )
 
-      # Mock Stripe transfer creation
-      expect(Algora.StripeMock, :create_transfer, fn params ->
-        assert params.amount == 100
-        assert params.currency == "USD"
+      insert(:transaction,
+        user: user,
+        type: :credit,
+        status: :succeeded,
+        net_amount: Money.new(2, :USD)
+      )
 
+      stripe_transfer_id = "tr_#{Nanoid.generate()}"
+
+      expect(Algora.StripeMock, :create_transfer, fn params ->
         {:ok,
          %{
-           id: "tr_123",
-           status: :succeeded,
-           amount: 100,
-           currency: "USD"
+           id: stripe_transfer_id,
+           amount: params.amount,
+           currency: params.currency,
+           destination: params.destination
          }}
       end)
 
-      assert {:ok, _transfer} = Payments.execute_pending_transfers(user.id)
+      assert {:ok, transfer} = Payments.execute_pending_transfers(user.id)
+      assert transfer.id == stripe_transfer_id
+      assert transfer.amount == 100 + 200
+      assert transfer.currency == "usd"
+      assert transfer.destination == account.provider_id
 
-      # Verify transfer transaction was created
-      transfer_tx = Repo.get_by(Transaction, provider_id: "tr_123")
+      transfer_tx = Repo.get_by(Transaction, provider_id: stripe_transfer_id)
       assert transfer_tx.status == :succeeded
       assert transfer_tx.type == :transfer
-      assert Money.equal?(transfer_tx.net_amount, Money.new(1, :USD))
+      assert transfer_tx.provider == "stripe"
+      assert transfer_tx.provider_meta["id"] == stripe_transfer_id
+      assert Money.equal?(transfer_tx.net_amount, Money.new(1 + 2, :USD))
+      assert Money.equal?(transfer_tx.gross_amount, Money.new(1 + 2, :USD))
+      assert Money.equal?(transfer_tx.total_fee, Money.new(0, :USD))
     end
 
     test "does nothing when user has no pending credits", %{user: user} do
@@ -56,34 +67,40 @@ defmodule Algora.PaymentsTest do
       assert Repo.aggregate(Transaction, :count) == 0
     end
 
-    test "does nothing when user has no stripe account", %{user: user} do
-      # Delete the account created in setup
-      Repo.delete_all(Account)
+    test "does nothing when user has payouts disabled", %{user: user, account: account} do
+      account |> change(payouts_enabled: false) |> Repo.update()
 
       insert(:transaction,
         user: user,
         type: :credit,
         status: :succeeded,
-        net_amount: Money.new(1000, :USD)
+        net_amount: Money.new(1, :USD)
       )
 
       assert {:ok, nil} = Payments.execute_pending_transfers(user.id)
+      assert Transaction |> where([t], t.type == :transfer) |> Repo.aggregate(:count) == 0
+    end
 
-      # Verify no transfer was created
-      transfer_count =
-        Transaction
-        |> where([t], t.type == :transfer)
-        |> Repo.aggregate(:count)
+    test "does nothing when user has no stripe account", %{user: user} do
+      Repo.delete_all(Account)
 
-      assert transfer_count == 0
+      insert(:transaction,
+        user: user,
+        type: :credit,
+        status: :succeeded,
+        net_amount: Money.new(1, :USD)
+      )
+
+      assert {:ok, nil} = Payments.execute_pending_transfers(user.id)
+      assert Transaction |> where([t], t.type == :transfer) |> Repo.aggregate(:count) == 0
     end
 
     test "handles failed stripe transfers", %{user: user} do
       insert(:transaction,
         user: user,
         type: :credit,
         status: :succeeded,
-        net_amount: Money.new(1000, :USD)
+        net_amount: Money.new(1, :USD)
       )
 
       expect(Algora.StripeMock, :create_transfer, fn _params ->
@@ -92,9 +109,8 @@ defmodule Algora.PaymentsTest do
 
       assert {:error, _} = Payments.execute_pending_transfers(user.id)
 
-      # Verify transfer transaction status
       transfer_tx = Repo.one(from t in Transaction, where: t.type == :transfer)
-      assert transfer_tx.status == :initialized
+      assert transfer_tx.status == :failed
     end
   end
 end