Introduce group basic federation, event new page and notifications

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

test/mobilizon/actors/actors_test.exs

@@ -5,9 +5,10 @@ defmodule Mobilizon.ActorsTest do
 
   import Mobilizon.Factory
 
-  alias Mobilizon.{Actors, Config, Events, Tombstone, Users}
+  alias Mobilizon.{Actors, Config, Conversations, Events, Tombstone, Users}
   alias Mobilizon.Actors.{Actor, Bot, Follower, Member}
-  alias Mobilizon.Events.{Comment, Event}
+  alias Mobilizon.Conversations.Comment
+  alias Mobilizon.Events.Event
   alias Mobilizon.Media.File, as: FileModel
   alias Mobilizon.Service.Workers
   alias Mobilizon.Storage.Page
@@ -331,7 +332,7 @@ defmodule Mobilizon.ActorsTest do
 
       assert {:error, :event_not_found} = Events.get_event(event1.id)
       assert %Tombstone{} = Tombstone.find_tombstone(event1_url)
-      assert %Comment{deleted_at: deleted_at} = Events.get_comment(comment1.id)
+      assert %Comment{deleted_at: deleted_at} = Conversations.get_comment(comment1.id)
       refute is_nil(deleted_at)
       assert %Tombstone{} = Tombstone.find_tombstone(comment1_url)
 
@@ -363,7 +364,11 @@ defmodule Mobilizon.ActorsTest do
     @invalid_attrs %{summary: nil, suspended: nil, preferred_username: nil, name: nil}
 
     test "create_group/1 with valid data creates a group" do
-      assert {:ok, %Actor{} = group} = Actors.create_group(@valid_attrs)
+      %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"
@@ -372,21 +377,23 @@ 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,
-              %Ecto.Changeset{errors: [preferred_username: {"Username is already taken", []}]}} =
-               Actors.create_group(@valid_attrs)
+      assert {:error, :insert_group,
+              %Ecto.Changeset{errors: [preferred_username: {"Username is already taken", []}]},
+              %{}} = Actors.create_group(@valid_attrs)
     end
 
     test "create_group/1 with an existing group username fails" do
-      assert {:ok, %Actor{} = group} = Actors.create_group(@valid_attrs)
+      %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 {:error,
-              %Ecto.Changeset{errors: [preferred_username: {"Username is already taken", []}]}} =
-               Actors.create_group(@valid_attrs)
+      assert {:error, :insert_group,
+              %Ecto.Changeset{errors: [preferred_username: {"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)
+      assert {:error, :insert_group, %Ecto.Changeset{}, %{}} = Actors.create_group(@invalid_attrs)
     end
   end
 
@@ -588,7 +595,7 @@ defmodule Mobilizon.ActorsTest do
       assert member.role == :member
 
       assert [group] = Actors.list_groups_member_of(actor)
-      assert [actor] = Actors.list_members_for_group(group)
+      assert %Page{elements: [actor], total: 1} = Actors.list_members_for_group(group)
     end
 
     test "create_member/1 with valid data but same actors fails to create a member", %{

test/mobilizon/conversations_test.exs

@@ -0,0 +1,72 @@
+defmodule Mobilizon.ConversationsTest do
+  use Mobilizon.DataCase
+
+  import Mobilizon.Factory
+
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Conversations
+  alias Mobilizon.Conversations.Comment
+  alias Mobilizon.Service.Workers
+  alias Mobilizon.Storage.Page
+
+  describe "comments" do
+    @valid_attrs %{text: "some text"}
+    @update_attrs %{text: "some updated text"}
+    @invalid_attrs %{text: nil, url: nil}
+
+    test "list_comments/0 returns all comments" do
+      %Comment{id: comment_id} = insert(:comment)
+      comment_ids = Conversations.list_comments() |> Enum.map(& &1.id)
+      assert comment_ids == [comment_id]
+    end
+
+    test "get_comment!/1 returns the comment with given id" do
+      %Comment{id: comment_id} = insert(:comment)
+      comment_fetched = Conversations.get_comment!(comment_id)
+      assert comment_fetched.id == comment_id
+    end
+
+    test "create_comment/1 with valid data creates a comment" do
+      %Actor{} = actor = insert(:actor)
+      comment_data = Map.merge(@valid_attrs, %{actor_id: actor.id})
+
+      case Conversations.create_comment(comment_data) do
+        {:ok, %Comment{} = comment} ->
+          assert comment.text == "some text"
+          assert comment.actor_id == actor.id
+
+        err ->
+          flunk("Failed to create a comment #{inspect(err)}")
+      end
+    end
+
+    test "create_comment/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Conversations.create_comment(@invalid_attrs)
+    end
+
+    test "update_comment/2 with valid data updates the comment" do
+      %Comment{} = comment = insert(:comment)
+
+      case Conversations.update_comment(comment, @update_attrs) do
+        {:ok, %Comment{} = comment} ->
+          assert comment.text == "some updated text"
+
+        err ->
+          flunk("Failed to update a comment #{inspect(err)}")
+      end
+    end
+
+    test "update_comment/2 with invalid data returns error changeset" do
+      %Comment{} = comment = insert(:comment)
+      assert {:error, %Ecto.Changeset{}} = Conversations.update_comment(comment, @invalid_attrs)
+      %Comment{} = comment_fetched = Conversations.get_comment!(comment.id)
+      assert comment = comment_fetched
+    end
+
+    test "delete_comment/1 deletes the comment" do
+      %Comment{} = comment = insert(:comment)
+      assert {:ok, %Comment{}} = Conversations.delete_comment(comment)
+      refute is_nil(Conversations.get_comment!(comment.id).deleted_at)
+    end
+  end
+end

test/mobilizon/events/events_test.exs

@@ -4,8 +4,9 @@ defmodule Mobilizon.EventsTest do
   import Mobilizon.Factory
 
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Events
-  alias Mobilizon.Events.{Comment, Event, Participant, Session, Tag, TagRelation, Track}
+  alias Mobilizon.{Conversations, Events}
+  alias Mobilizon.Conversations.Comment
+  alias Mobilizon.Events.{Event, Participant, Session, Tag, TagRelation, Track}
   alias Mobilizon.Service.Workers
   alias Mobilizon.Storage.Page
 
@@ -530,65 +531,4 @@ defmodule Mobilizon.EventsTest do
       assert_raise Ecto.NoResultsError, fn -> Events.get_track!(track.id) end
     end
   end
-
-  describe "comments" do
-    @valid_attrs %{text: "some text"}
-    @update_attrs %{text: "some updated text"}
-    @invalid_attrs %{text: nil, url: nil}
-
-    test "list_comments/0 returns all comments" do
-      %Comment{id: comment_id} = insert(:comment)
-      comment_ids = Events.list_comments() |> Enum.map(& &1.id)
-      assert comment_ids == [comment_id]
-    end
-
-    test "get_comment!/1 returns the comment with given id" do
-      %Comment{id: comment_id} = insert(:comment)
-      comment_fetched = Events.get_comment!(comment_id)
-      assert comment_fetched.id == comment_id
-    end
-
-    test "create_comment/1 with valid data creates a comment" do
-      actor = insert(:actor)
-      comment_data = Map.merge(@valid_attrs, %{actor_id: actor.id})
-
-      case Events.create_comment(comment_data) do
-        {:ok, %Comment{} = comment} ->
-          assert comment.text == "some text"
-          assert comment.actor_id == actor.id
-
-        err ->
-          flunk("Failed to create a comment #{inspect(err)}")
-      end
-    end
-
-    test "create_comment/1 with invalid data returns error changeset" do
-      assert {:error, %Ecto.Changeset{}} = Events.create_comment(@invalid_attrs)
-    end
-
-    test "update_comment/2 with valid data updates the comment" do
-      comment = insert(:comment)
-
-      case Events.update_comment(comment, @update_attrs) do
-        {:ok, %Comment{} = comment} ->
-          assert comment.text == "some updated text"
-
-        err ->
-          flunk("Failed to update a comment #{inspect(err)}")
-      end
-    end
-
-    test "update_comment/2 with invalid data returns error changeset" do
-      comment = insert(:comment)
-      assert {:error, %Ecto.Changeset{}} = Events.update_comment(comment, @invalid_attrs)
-      comment_fetched = Events.get_comment!(comment.id)
-      assert comment = comment_fetched
-    end
-
-    test "delete_comment/1 deletes the comment" do
-      comment = insert(:comment)
-      assert {:ok, %Comment{}} = Events.delete_comment(comment)
-      refute is_nil(Events.get_comment!(comment.id).deleted_at)
-    end
-  end
 end

test/mobilizon/users/users_test.exs

@@ -2,7 +2,7 @@ defmodule Mobilizon.UsersTest do
   use Mobilizon.DataCase
 
   alias Mobilizon.Users
-  alias Mobilizon.Users.User
+  alias Mobilizon.Users.{Setting, User}
   import Mobilizon.Factory
   use ExVCR.Mock, adapter: ExVCR.Adapter.Hackney
 
@@ -101,4 +101,60 @@ defmodule Mobilizon.UsersTest do
       assert id == user.id
     end
   end
+
+  describe "user_settings" do
+    @valid_attrs %{timezone: "Europe/Paris", notification_each_week: true}
+    @update_attrs %{timezone: "Atlantic/Cape_Verde", notification_each_week: false}
+    @invalid_attrs %{timezone: nil, notification_each_week: nil}
+
+    def setting_fixture(attrs \\ %{}) do
+      {:ok, setting} =
+        attrs
+        |> Enum.into(@valid_attrs)
+        |> Users.create_setting()
+
+      setting
+    end
+
+    test "get_setting!/1 returns the setting with given id" do
+      %User{id: user_id} = insert(:user)
+      setting = setting_fixture(user_id: user_id)
+      assert Users.get_setting!(setting.user_id) == setting
+    end
+
+    test "create_setting/1 with valid data creates a setting" do
+      %User{id: user_id} = insert(:user)
+
+      assert {:ok, %Setting{} = setting} =
+               Users.create_setting(Map.put(@valid_attrs, :user_id, user_id))
+
+      assert setting.timezone == "Europe/Paris"
+      assert setting.notification_each_week == true
+    end
+
+    test "create_setting/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Users.create_setting(@invalid_attrs)
+    end
+
+    test "update_setting/2 with valid data updates the setting" do
+      %User{id: user_id} = insert(:user)
+      setting = setting_fixture(user_id: user_id)
+      assert {:ok, %Setting{} = setting} = Users.update_setting(setting, @update_attrs)
+      assert setting.timezone == "Atlantic/Cape_Verde"
+      assert setting.notification_each_week == false
+    end
+
+    test "delete_setting/1 deletes the setting" do
+      %User{id: user_id} = insert(:user)
+      setting = setting_fixture(user_id: user_id)
+      assert {:ok, %Setting{}} = Users.delete_setting(setting)
+      assert_raise Ecto.NoResultsError, fn -> Users.get_setting!(setting.user_id) end
+    end
+
+    test "change_setting/1 returns a setting changeset" do
+      %User{id: user_id} = insert(:user)
+      setting = setting_fixture(user_id: user_id)
+      assert %Ecto.Changeset{} = Users.change_setting(setting)
+    end
+  end
 end