defmodule Mobilizon.ActorsTest do use Mobilizon.DataCase use Oban.Testing, repo: Mobilizon.Storage.Repo import Mox import Mobilizon.Factory alias Mobilizon.{Actors, Config, Discussions, Events, Users} alias Mobilizon.Actors.{Actor, Bot, Follower, Member} alias Mobilizon.Discussions.Comment alias Mobilizon.Events.Event alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor alias Mobilizon.Medias.File, as: FileModel alias Mobilizon.Service.HTTP.ActivityPub.Mock alias Mobilizon.Service.Workers alias Mobilizon.Storage.Page alias Mobilizon.Web.Upload.Uploader describe "actors" do @valid_attrs %{ summary: "some description", name: "Bobby Blank", domain: "some domain", keys: "some keypair", suspended: true, uri: "some uri", url: "some url", preferred_username: "some_username" } @update_attrs %{ summary: "some updated description", name: "some updated name", domain: "some updated domain", keys: "some updated keys", suspended: false, uri: "some updated uri", url: "some updated url", preferred_username: "some_updated_username" } @invalid_attrs %{ summary: nil, name: nil, domain: nil, keys: nil, suspended: nil, uri: nil, url: nil, preferred_username: "never" } @remote_account_url "https://social.tcit.fr/users/tcit" setup do user = insert(:user) actor = insert(:actor, user: user, preferred_username: "tcit") {:ok, actor: actor} end test "list_actors/0 returns all actors", %{actor: %Actor{id: actor_id}} do assert %Page{total: 1, elements: [%Actor{id: id}]} = Actors.list_actors() assert id == actor_id end test "get_actor!/1 returns the actor with given id", %{actor: %Actor{id: actor_id} = actor} do assert actor_id == Actors.get_actor!(actor.id).id end test "get_actor_for_user/1 returns the actor for an user", %{ actor: %{user: user, id: actor_id} = _actor } do assert actor_id == Users.get_actor_for_user(user).id end test "get_actor_for_user/1 returns the actor for an user with no default actor defined" do user = insert(:user) actor_id = insert(:actor, user: user).id assert actor_id == Users.get_actor_for_user(user).id end test "get_actor_with_preload/1 returns the actor with its organized events", %{ actor: actor } do assert Actors.get_actor_with_preload(actor.id).organized_events == [] event = insert(:event, organizer_actor: actor) event_found_id = Actors.get_actor_with_preload(actor.id).organized_events |> hd |> Map.get(:id) assert event_found_id == event.id end test "get_actor_by_name/1 returns a local actor", %{ actor: %Actor{id: actor_id, preferred_username: preferred_username} } do actor_found_id = Actors.get_actor_by_name(preferred_username).id assert actor_found_id == actor_id end test "get_actor_by_name/1 returns a remote actor" do tcit_social_tcit = "test/fixtures/mastodon-tcit-tcit.json" |> File.read!() |> Jason.decode!() Mock |> expect(:call, fn %{method: :get, url: @remote_account_url}, _opts -> {:ok, %Tesla.Env{status: 200, body: tcit_social_tcit}} end) {:ok, %Actor{ id: actor_id, preferred_username: preferred_username, domain: domain, avatar: %FileModel{name: picture_name} = _picture } = _actor} = ActivityPubActor.get_or_fetch_actor_by_url(@remote_account_url) assert picture_name == "a28c50ce5f2b13fd.jpg" %Actor{ id: actor_found_id, avatar: %FileModel{name: picture_name} = _picture } = Actors.get_actor_by_name("#{preferred_username}@#{domain}") assert actor_found_id == actor_id assert picture_name == "a28c50ce5f2b13fd.jpg" end test "get_local_actor_by_name_with_preload!/1 returns the local actor with its organized events", %{ actor: actor } do assert Actors.get_local_actor_by_name_with_preload(actor.preferred_username).organized_events == [] event = insert(:event, organizer_actor: actor) event_found_id = Actors.get_local_actor_by_name_with_preload(actor.preferred_username).organized_events |> hd |> Map.get(:id) assert event_found_id == event.id end test "get_actor_by_name_with_preload!/1 returns the local actor with its organized events", %{ actor: actor } do assert Actors.get_actor_by_name_with_preload(actor.preferred_username).organized_events == [] event = insert(:event, organizer_actor: actor) event_found_id = Actors.get_actor_by_name_with_preload(actor.preferred_username).organized_events |> hd |> Map.get(:id) assert event_found_id == event.id end test "get_actor_by_name_with_preload!/1 returns the remote actor with its organized events" do tcit_social_tcit = "test/fixtures/mastodon-tcit-tcit.json" |> File.read!() |> Jason.decode!() Mock |> expect(:call, fn %{method: :get, url: @remote_account_url}, _opts -> {:ok, %Tesla.Env{status: 200, body: tcit_social_tcit}} end) with {:ok, %Actor{} = actor} <- ActivityPubActor.get_or_fetch_actor_by_url(@remote_account_url) do assert Actors.get_actor_by_name_with_preload( "#{actor.preferred_username}@#{actor.domain}" ).organized_events == [] event = insert(:event, organizer_actor: actor) event_found_id = Actors.get_actor_by_name_with_preload("#{actor.preferred_username}@#{actor.domain}").organized_events |> hd |> Map.get(:id) assert event_found_id == event.id end end test "test list_local_actor_by_username/1 returns local actors with similar usernames", %{ actor: actor } do actor2 = insert(:actor, preferred_username: "tcit") [%Actor{id: actor_found_id} | tail] = Actors.list_local_actor_by_username("tcit") %Actor{id: actor2_found_id} = hd(tail) assert MapSet.new([actor_found_id, actor2_found_id]) == MapSet.new([actor.id, actor2.id]) end test "test search_actors/4 returns actors with similar usernames", %{actor: %Actor{id: actor_id}} do tcit_social_tcit = "test/fixtures/mastodon-tcit-tcit.json" |> File.read!() |> Jason.decode!() Mock |> expect(:call, fn %{method: :get, url: @remote_account_url}, _opts -> {:ok, %Tesla.Env{status: 200, body: tcit_social_tcit}} end) with {:ok, %Actor{id: actor2_id}} <- ActivityPubActor.get_or_fetch_actor_by_url(@remote_account_url) do %Page{total: 2, elements: actors} = Actors.search_actors("tcit", actor_type: :Person, minimum_visibility: :private ) actors_ids = actors |> Enum.map(& &1.id) assert MapSet.new(actors_ids) == MapSet.new([actor2_id, actor_id]) end end test "test search_actors/4 returns actors with similar names" do %{total: 0, elements: actors} = Actors.search_actors("ohno", actor_type: :Person) assert actors == [] end test "create_actor/1 with valid data creates a actor" do assert {:ok, %Actor{} = actor} = Actors.create_actor(@valid_attrs) assert actor.summary == "some description" assert actor.name == "Bobby Blank" assert actor.domain == "some domain" assert actor.keys == "some keypair" assert actor.suspended assert actor.preferred_username == "some_username" end test "create_actor/1 with empty data returns error changeset" do assert {:error, %Ecto.Changeset{}} = Actors.create_actor() end test "create_actor/1 with invalid data returns error changeset" do assert {:error, %Ecto.Changeset{}} = Actors.create_actor(@invalid_attrs) end test "update_actor/2 with valid data updates the actor", %{ actor: %Actor{} = actor } do assert {:ok, actor} = Actors.update_actor( actor, @update_attrs ) assert %Actor{} = actor assert actor.summary == "some updated description" assert actor.name == "some updated name" assert actor.keys == "some updated keys" refute actor.suspended end test "update_actor/2 with valid data updates the actor and its media files", %{ actor: %Actor{avatar: %{url: avatar_url}, banner: %{url: banner_url}} = actor } do %URI{path: "/media/" <> avatar_path} = URI.parse(avatar_url) %URI{path: "/media/" <> banner_path} = URI.parse(banner_url) assert File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> avatar_path ) assert File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> banner_path ) file = %Plug.Upload{ content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "image.jpg" } {:ok, data} = Mobilizon.Web.Upload.store(file) assert {:ok, actor} = Actors.update_actor( actor, Map.put(@update_attrs, :avatar, %{name: file.filename, url: data.url}) ) assert %Actor{} = actor assert actor.summary == "some updated description" assert actor.name == "some updated name" assert actor.keys == "some updated keys" refute actor.suspended refute File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> avatar_path ) assert File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> banner_path ) end test "update_actor/2 with invalid data returns error changeset", %{actor: actor} do assert {:error, %Ecto.Changeset{}} = Actors.update_actor(actor, @invalid_attrs) actor_fetched = Actors.get_actor!(actor.id) assert actor.id == actor_fetched.id end test "delete_actor/1 deletes the actor", %{ actor: %Actor{avatar: %{url: avatar_url}, banner: %{url: banner_url}, id: actor_id} = actor } do %Event{} = event1 = insert(:event, organizer_actor: actor) insert(:event, organizer_actor: actor) %Comment{} = comment1 = insert(:comment, actor: actor) insert(:comment, actor: actor) %URI{path: "/media/" <> avatar_path} = URI.parse(avatar_url) %URI{path: "/media/" <> banner_path} = URI.parse(banner_url) assert File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> avatar_path ) assert File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> banner_path ) assert {:ok, %Oban.Job{}} = Actors.delete_actor(actor) assert_enqueued( worker: Workers.Background, args: %{ "actor_id" => actor.id, "op" => "delete_actor", "author_id" => nil, "suspension" => false, "reserve_username" => true } ) assert %{success: 1, snoozed: 0, failure: 0, discard: 0} == Oban.drain_queue(queue: :background) assert %Actor{ name: nil, summary: nil, suspended: true, avatar: nil, banner: nil, user_id: nil } = Actors.get_actor(actor_id) assert {:error, :event_not_found} = Events.get_event(event1.id) assert %Comment{deleted_at: deleted_at} = Discussions.get_comment(comment1.id) refute is_nil(deleted_at) refute File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> avatar_path ) refute File.exists?( Config.get!([Uploader.Local, :uploads]) <> "/" <> banner_path ) end end describe "groups" do @valid_attrs %{ summary: "some description", suspended: true, preferred_username: "some_title", name: "Some Title" } @update_attrs %{ summary: "some updated description", suspended: false, preferred_username: "some_updated_title", name: "Some Updated Title" } @invalid_attrs %{summary: nil, suspended: nil, preferred_username: nil, name: nil} test "create_group/1 with valid data creates a group" do %Actor{id: actor_id} = insert(:actor) assert {:ok, %Actor{} = group} = Actors.create_group(Map.put(@valid_attrs, :creator_actor_id, actor_id)) assert group.summary == "some description" refute group.suspended assert group.preferred_username == "some_title" end test "create_group/1 with an existing profile username fails" do _actor = insert(:actor, preferred_username: @valid_attrs.preferred_username) assert {:error, %Ecto.Changeset{ errors: [preferred_username: {"This username is already taken.", []}] }} = Actors.create_group(@valid_attrs) end test "create_group/1 with an existing group username fails" do %Actor{id: actor_id} = insert(:actor) attrs = Map.put(@valid_attrs, :creator_actor_id, actor_id) assert {:ok, %Actor{}} = Actors.create_group(attrs) assert {:error, %Ecto.Changeset{ errors: [preferred_username: {"This username is already taken.", []}] }} = Actors.create_group(attrs) end test "create_group/1 with invalid data returns error changeset" do assert {:error, %Ecto.Changeset{}} = Actors.create_group(@invalid_attrs) end end describe "bots" do @valid_attrs %{source: "some source", type: "some type"} @update_attrs %{source: "some updated source", type: "some updated type"} @invalid_attrs %{source: nil, type: nil} test "get_bot!/1 returns the bot with given id" do %Bot{id: bot_id} = bot = insert(:bot) assert bot_id == Actors.get_bot!(bot.id).id end test "create_bot/1 with valid data creates a bot" do attrs = @valid_attrs |> Map.merge(%{actor_id: insert(:actor).id}) |> Map.merge(%{user_id: insert(:user).id}) assert {:ok, %Bot{} = bot} = Actors.create_bot(attrs) assert bot.source == "some source" assert bot.type == "some type" end test "create_bot/1 with invalid data returns error changeset" do case Actors.create_bot(@invalid_attrs) do {:error, %Ecto.Changeset{}} -> assert true _ -> assert false end end test "update_bot/2 with valid data updates the bot" do with bot <- insert(:bot), {:ok, %Bot{source: source, type: type}} <- Actors.update_bot(bot, @update_attrs) do assert source == "some updated source" assert type == "some updated type" end end test "update_bot/2 with invalid data returns error changeset" do bot = insert(:bot) assert {:error, %Ecto.Changeset{}} = Actors.update_bot(bot, @invalid_attrs) assert bot.id == Actors.get_bot!(bot.id).id end test "delete_bot/1 deletes the bot" do bot = insert(:bot) assert {:ok, %Bot{}} = Actors.delete_bot(bot) assert_raise Ecto.NoResultsError, fn -> Actors.get_bot!(bot.id) end end end describe "followers" do @valid_attrs %{approved: true} @update_attrs %{approved: false} @invalid_attrs %{approved: nil} setup do actor = insert(:actor) target_actor = insert(:actor) {:ok, actor: actor, target_actor: target_actor} end defp create_test_follower(%{actor: actor, target_actor: target_actor}) do insert(:follower, actor: actor, target_actor: target_actor) end test "get_follower!/1 returns the follower with given id", context do follower = create_test_follower(context) assert follower.id == Actors.get_follower!(follower.id).id end test "create_follower/1 with valid data creates a follower", %{ actor: actor, target_actor: target_actor } do valid_attrs = @valid_attrs |> Map.put(:actor_id, actor.id) |> Map.put(:target_actor_id, target_actor.id) assert {:ok, %Follower{} = follower} = Actors.create_follower(valid_attrs) assert follower.approved == true assert %{total: 1, elements: followings} = Actors.build_followings_for_actor(actor) followings_ids = Enum.map(followings, & &1.id) assert followings_ids == [target_actor.id] assert %{total: 1, elements: followers} = Actors.build_followers_for_actor(target_actor) followers_ids = Enum.map(followers, & &1.id) assert followers_ids == [actor.id] end test "create_follower/1 with valid data but same actors fails to create a follower", %{ actor: actor, target_actor: target_actor } do create_test_follower(%{actor: actor, target_actor: target_actor}) valid_attrs = @valid_attrs |> Map.put(:actor_id, actor.id) |> Map.put(:target_actor_id, target_actor.id) assert {:error, _follower} = Actors.create_follower(valid_attrs) end test "create_follower/1 with invalid data returns error changeset", %{ actor: actor, target_actor: target_actor } do invalid_attrs = @invalid_attrs |> Map.put(:actor_id, actor.id) |> Map.put(:target_actor_id, target_actor.id) assert {:error, %Ecto.Changeset{}} = Actors.create_follower(invalid_attrs) end test "update_follower/2 with valid data updates the follower", context do follower = create_test_follower(context) assert {:ok, follower} = Actors.update_follower(follower, @update_attrs) assert %Follower{} = follower assert follower.approved == false end test "update_follower/2 with invalid data returns error changeset", context do follower = create_test_follower(context) assert {:error, %Ecto.Changeset{}} = Actors.update_follower(follower, @invalid_attrs) assert follower.id == Actors.get_follower!(follower.id).id end test "delete_follower/1 deletes the follower", context do follower = create_test_follower(context) assert {:ok, %Follower{}} = Actors.delete_follower(follower) assert_raise Ecto.NoResultsError, fn -> Actors.get_follower!(follower.id) end end test "follow/3 makes an actor follow another", %{actor: actor, target_actor: target_actor} do # Preloading followers/followings actor = Actors.get_actor_with_preload(actor.id) target_actor = Actors.get_actor_with_preload(target_actor.id) {:ok, follower} = Actors.follow(target_actor, actor) assert follower.actor.id == actor.id # Referesh followers/followings actor = Actors.get_actor_with_preload(actor.id) target_actor = Actors.get_actor_with_preload(target_actor.id) assert target_actor.followers |> Enum.map(& &1.actor_id) == [actor.id] assert actor.followings |> Enum.map(& &1.target_actor_id) == [target_actor.id] # Test if actor is already following target actor assert {:error, :already_following} = Actors.follow(target_actor, actor) # Test if target actor is suspended target_actor = %{target_actor | suspended: true} assert {:error, :followed_suspended} = Actors.follow(target_actor, actor) end end describe "members" do @valid_attrs %{role: :member} @update_attrs %{role: :not_approved} @invalid_attrs %{role: nil} setup do actor = insert(:actor) group = insert(:group) {:ok, actor: actor, group: group} end defp create_test_member(%{actor: actor, group: group}) do insert(:member, actor: actor, parent: group) end test "get_member!/1 returns the member with given id", context do member = create_test_member(context) assert member.id == Actors.get_member!(member.id).id end test "create_member/1 with valid data creates a member", %{ actor: actor, group: group } do valid_attrs = @valid_attrs |> Map.put(:actor_id, actor.id) |> Map.put(:parent_id, group.id) assert {:ok, %Member{} = member} = Actors.create_member(valid_attrs) assert member.role == :member assert [group] = Actors.list_groups_member_of(actor) assert %Page{elements: members, total: 1} = Actors.list_members_for_group(group) members_ids = Enum.map(members, & &1.id) assert members_ids == [member.id] end test "create_member/1 with valid data but same actors just updates the member", %{ actor: actor, group: group } do %Member{id: member_id, url: member_url} = create_test_member(%{actor: actor, group: group}) attrs = %{} |> Map.put(:actor_id, actor.id) |> Map.put(:parent_id, group.id) |> Map.put(:role, :member) assert {:ok, %Member{ id: updated_member_id, role: updated_member_role, actor_id: actor_id, parent_id: parent_id, url: url }} = Actors.create_member(attrs) assert updated_member_role == :member assert actor_id == actor.id assert parent_id == group.id assert url == member_url assert updated_member_id == member_id end test "create_member/1 with invalid data returns error changeset" do invalid_attrs = @invalid_attrs |> Map.put(:actor_id, nil) |> Map.put(:parent_id, nil) assert {:error, %Ecto.Changeset{}} = Actors.create_member(invalid_attrs) end test "update_member/2 with valid data updates the member", context do member = create_test_member(context) assert {:ok, member} = Actors.update_member(member, @update_attrs) assert %Member{} = member assert member.role == :not_approved end # This can't happen, since attrs are optional # test "update_member/2 with invalid data returns error changeset", context do # member = create_member(context) # assert {:error, %Ecto.Changeset{}} = Actors.update_member(member, @invalid_attrs) # assert member = Actors.get_member!(member.id) # end test "delete_member/1 deletes the member", context do member = create_test_member(context) assert {:ok, %Member{}} = Actors.delete_member(member) assert_raise Ecto.NoResultsError, fn -> Actors.get_member!(member.id) end end end end