Various refactoring and typespec improvements

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

test/mobilizon/actors/actors_test.exs

@@ -298,10 +298,10 @@ defmodule Mobilizon.ActorsTest do
     test "delete_actor/1 deletes the actor", %{
       actor: %Actor{avatar: %{url: avatar_url}, banner: %{url: banner_url}, id: actor_id} = actor
     } do
-      %Event{url: event1_url} = event1 = insert(:event, organizer_actor: actor)
+      %Event{} = event1 = insert(:event, organizer_actor: actor)
       insert(:event, organizer_actor: actor)
 
-      %Comment{url: comment1_url} = comment1 = insert(:comment, actor: actor)
+      %Comment{} = comment1 = insert(:comment, actor: actor)
       insert(:comment, actor: actor)
 
       %URI{path: "/media/" <> avatar_path} = URI.parse(avatar_url)
@@ -386,25 +386,25 @@ defmodule Mobilizon.ActorsTest do
     test "create_group/1 with an existing profile username fails" do
       _actor = insert(:actor, preferred_username: @valid_attrs.preferred_username)
 
-      assert {:error, :insert_group,
+      assert {:error,
               %Ecto.Changeset{
                 errors: [preferred_username: {"This username is already taken.", []}]
-              }, %{}} = Actors.create_group(@valid_attrs)
+              }} = 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{} = group} = Actors.create_group(attrs)
+      assert {:ok, %Actor{}} = Actors.create_group(attrs)
 
-      assert {:error, :insert_group,
+      assert {:error,
               %Ecto.Changeset{
                 errors: [preferred_username: {"This username is already taken.", []}]
-              }, %{}} = Actors.create_group(attrs)
+              }} = Actors.create_group(attrs)
     end
 
     test "create_group/1 with invalid data returns error changeset" do
-      assert {:error, :insert_group, %Ecto.Changeset{}, %{}} = Actors.create_group(@invalid_attrs)
+      assert {:error, %Ecto.Changeset{}} = Actors.create_group(@invalid_attrs)
     end
   end
 
@@ -456,7 +456,7 @@ defmodule Mobilizon.ActorsTest do
     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 = Actors.get_bot!(bot.id)
+      assert bot.id == Actors.get_bot!(bot.id).id
     end
 
     test "delete_bot/1 deletes the bot" do
@@ -483,7 +483,7 @@ defmodule Mobilizon.ActorsTest do
 
     test "get_follower!/1 returns the follower with given id", context do
       follower = create_test_follower(context)
-      assert follower = Actors.get_follower!(follower.id)
+      assert follower.id == Actors.get_follower!(follower.id).id
     end
 
     test "create_follower/1 with valid data creates a follower", %{
@@ -498,8 +498,12 @@ defmodule Mobilizon.ActorsTest do
       assert {:ok, %Follower{} = follower} = Actors.create_follower(valid_attrs)
       assert follower.approved == true
 
-      assert %{total: 1, elements: [target_actor]} = Actors.build_followings_for_actor(actor)
-      assert %{total: 1, elements: [actor]} = Actors.build_followers_for_actor(target_actor)
+      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", %{
@@ -538,7 +542,7 @@ defmodule Mobilizon.ActorsTest do
     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 = Actors.get_follower!(follower.id)
+      assert follower.id == Actors.get_follower!(follower.id).id
     end
 
     test "delete_follower/1 deletes the follower", context do
@@ -563,13 +567,11 @@ defmodule Mobilizon.ActorsTest do
       assert actor.followings |> Enum.map(& &1.target_actor_id) == [target_actor.id]
 
       # Test if actor is already following target actor
-      assert {:error, :already_following, msg} = Actors.follow(target_actor, actor)
-      assert msg =~ "already following"
+      assert {:error, :already_following} = Actors.follow(target_actor, actor)
 
       # Test if target actor is suspended
       target_actor = %{target_actor | suspended: true}
-      assert {:error, :suspended, msg} = Actors.follow(target_actor, actor)
-      assert msg =~ "suspended"
+      assert {:error, :followed_suspended} = Actors.follow(target_actor, actor)
     end
   end
 
@@ -590,7 +592,7 @@ defmodule Mobilizon.ActorsTest do
 
     test "get_member!/1 returns the member with given id", context do
       member = create_test_member(context)
-      assert member = Actors.get_member!(member.id)
+      assert member.id == Actors.get_member!(member.id).id
     end
 
     test "create_member/1 with valid data creates a member", %{
@@ -606,7 +608,9 @@ defmodule Mobilizon.ActorsTest do
       assert member.role == :member
 
       assert [group] = Actors.list_groups_member_of(actor)
-      assert %Page{elements: [actor], total: 1} = Actors.list_members_for_group(group)
+      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", %{

test/mobilizon/admin/action_log_test.exs

@@ -19,28 +19,32 @@ defmodule Mobilizon.Service.Admin.ActionLogTest do
 
   describe "action_log_creation" do
     test "log a report update", %{moderator: moderator} do
-      %Report{id: _report_id} = report = insert(:report)
+      %Report{id: report_id} = report = insert(:report)
 
       assert {:ok,
               %ActionLog{
                 target_type: "Elixir.Mobilizon.Reports.Report",
-                target_id: report_id,
+                target_id: found_report_id,
                 action: :update,
-                actor: moderator
+                actor: _moderator
               }} = Admin.log_action(moderator, "update", report)
+
+      assert found_report_id == report_id
     end
 
     test "log the creation of a report note", %{moderator: moderator} do
       %Report{} = report = insert(:report)
-      %Note{id: _note_id} = report = insert(:report_note, report: report)
+      %Note{id: note_id} = report = insert(:report_note, report: report)
 
       assert {:ok,
               %ActionLog{
                 target_type: "Elixir.Mobilizon.Reports.Note",
-                target_id: note_id,
+                target_id: found_note_id,
                 action: :create,
-                actor: moderator
+                actor: _moderator
               }} = Admin.log_action(moderator, "create", report)
+
+      assert found_note_id == note_id
     end
   end
 end

test/mobilizon/events/events_test.exs

@@ -424,7 +424,7 @@ defmodule Mobilizon.EventsTest do
     end
 
     test "delete_participant/1 deletes the participant", %{participant: participant} do
-      assert {:ok, %Participant{}} = Events.delete_participant(participant)
+      assert {:ok, %{participant: %Participant{}}} = Events.delete_participant(participant)
     end
   end
 

test/mobilizon/users/users_test.exs

@@ -19,13 +19,13 @@ defmodule Mobilizon.UsersTest do
     end
 
     test "get_user!/1 returns the user with given id" do
-      user = insert(:user)
-      assert user = Users.get_user!(user.id)
+      %User{id: user_id} = user = insert(:user)
+      assert user == Users.get_user!(user_id)
     end
 
     # There's no create_user/1, just register/1
     test "register/1 with valid data creates a user" do
-      assert {:ok, %User{email: email} = user} = Users.register(@valid_attrs)
+      assert {:ok, %User{email: email}} = Users.register(@valid_attrs)
 
       assert email == @valid_attrs.email
     end
@@ -48,9 +48,9 @@ defmodule Mobilizon.UsersTest do
     end
 
     test "update_user/2 with invalid data returns error changeset" do
-      user = insert(:user)
+      %User{id: user_id} = user = insert(:user)
       assert {:error, %Ecto.Changeset{}} = Users.update_user(user, @invalid_attrs)
-      assert user = Users.get_user!(user.id)
+      assert user == Users.get_user!(user_id)
     end
 
     test "delete_user/1 empties the user" do
@@ -65,11 +65,6 @@ defmodule Mobilizon.UsersTest do
       assert_raise Ecto.NoResultsError, fn -> Users.get_user!(user.id) end
     end
 
-    # test "change_user/1 returns a user changeset" do
-    #   user = insert(:user)
-    #   assert %Ecto.Changeset{} = Users.change_user(user)
-    # end
-
     @email "email@domain.tld"
     @password "password"