Add actor parameter to all tests requiring authorization

This commit adds actor: system_actor to all Ash operations in tests that
require authorization.

test/accounts/user_member_deletion_test.exs

@@ -18,71 +18,86 @@ defmodule Mv.Accounts.UserMemberDeletionTest do
       email: "john@example.com"
     }
 
-    test "deleting a member sets the user's member_id to NULL" do
+    setup do
+      system_actor = Mv.Helpers.SystemActor.get_system_actor()
+      %{actor: system_actor}
+    end
+
+    test "deleting a member sets the user's member_id to NULL", %{actor: actor} do
       # Create a member
-      {:ok, member} = Membership.create_member(@valid_member_attrs)
+      {:ok, member} = Membership.create_member(@valid_member_attrs, actor: actor)
 
       # Create a user linked to the member
       {:ok, user} =
-        Accounts.create_user(Map.put(@valid_user_attrs, :member, %{id: member.id}))
+        Accounts.create_user(Map.put(@valid_user_attrs, :member, %{id: member.id}), actor: actor)
 
       # Verify the relationship is established
-      {:ok, user_before_delete} = Ash.get(Mv.Accounts.User, user.id, load: [:member])
+      {:ok, user_before_delete} =
+        Ash.get(Mv.Accounts.User, user.id, actor: actor, load: [:member], actor: actor)
+
       assert user_before_delete.member_id == member.id
       assert user_before_delete.member.id == member.id
 
       # Delete the member
-      :ok = Membership.destroy_member(member)
+      :ok = Membership.destroy_member(member, actor: actor)
 
       # Verify the user still exists but member_id is NULL
-      {:ok, user_after_delete} = Ash.get(Mv.Accounts.User, user.id, load: [:member])
+      {:ok, user_after_delete} =
+        Ash.get(Mv.Accounts.User, user.id, actor: actor, load: [:member], actor: actor)
+
       assert user_after_delete.id == user.id
       assert user_after_delete.member_id == nil
       assert user_after_delete.member == nil
     end
 
-    test "user can be linked to a new member after old member is deleted" do
+    test "user can be linked to a new member after old member is deleted", %{actor: actor} do
       # Create first member
-      {:ok, member1} = Membership.create_member(@valid_member_attrs)
+      {:ok, member1} = Membership.create_member(@valid_member_attrs, actor: actor)
 
       # Create user linked to first member
       {:ok, user} =
-        Accounts.create_user(Map.put(@valid_user_attrs, :member, %{id: member1.id}))
+        Accounts.create_user(Map.put(@valid_user_attrs, :member, %{id: member1.id}), actor: actor)
 
       assert user.member_id == member1.id
 
       # Delete first member
-      :ok = Membership.destroy_member(member1)
+      :ok = Membership.destroy_member(member1, actor: actor)
 
       # Reload user from database to get updated member_id (should be NULL)
-      {:ok, user_after_delete} = Ash.get(Mv.Accounts.User, user.id)
+      {:ok, user_after_delete} = Ash.get(Mv.Accounts.User, user.id, actor: actor)
       assert user_after_delete.member_id == nil
 
       # Create second member
       {:ok, member2} =
-        Membership.create_member(%{
-          first_name: "Jane",
-          last_name: "Smith",
-          email: "jane@example.com"
-        })
+        Membership.create_member(
+          %{
+            first_name: "Jane",
+            last_name: "Smith",
+            email: "jane@example.com"
+          },
+          actor: actor
+        )
 
       # Link user to second member (use reloaded user)
-      {:ok, updated_user} = Accounts.update_user(user_after_delete, %{member: %{id: member2.id}})
+      {:ok, updated_user} =
+        Accounts.update_user(user_after_delete, %{member: %{id: member2.id}}, actor: actor)
 
       # Verify new relationship
-      {:ok, final_user} = Ash.get(Mv.Accounts.User, updated_user.id, load: [:member])
+      {:ok, final_user} =
+        Ash.get(Mv.Accounts.User, updated_user.id, actor: actor, load: [:member])
+
       assert final_user.member_id == member2.id
       assert final_user.member.id == member2.id
     end
 
-    test "member without linked user can be deleted normally" do
-      {:ok, member} = Membership.create_member(@valid_member_attrs)
+    test "member without linked user can be deleted normally", %{actor: actor} do
+      {:ok, member} = Membership.create_member(@valid_member_attrs, actor: actor)
 
       # Delete member (no users linked)
-      assert :ok = Membership.destroy_member(member)
+      assert :ok = Membership.destroy_member(member, actor: actor)
 
       # Verify member is deleted
-      assert {:error, _} = Ash.get(Mv.Membership.Member, member.id)
+      assert {:error, _} = Ash.get(Mv.Membership.Member, member.id, actor: actor)
     end
   end
 end