Introduce group basic federation, event new page and notifications

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

test/graphql/api/report_test.exs

@@ -4,7 +4,8 @@ defmodule Mobilizon.GraphQL.API.ReportTest do
   import Mobilizon.Factory
 
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Events.{Comment, Event}
+  alias Mobilizon.Conversations.Comment
+  alias Mobilizon.Events.Event
   alias Mobilizon.Reports.{Note, Report}
   alias Mobilizon.Users
   alias Mobilizon.Users.User

test/graphql/resolvers/event_test.exs

@@ -207,7 +207,7 @@ defmodule Mobilizon.Web.Resolvers.EventTest do
       assert res["data"]["createEvent"]["title"] == "My Event title"
 
       assert res["data"]["createEvent"]["description"] ==
-               "<b>My description</b> <img src=\"http://placekitten.com/g/200/300\" />"
+               "<b>My description</b> <img src=\"http://placekitten.com/g/200/300\"/>"
 
       {id, ""} = res["data"]["createEvent"]["id"] |> Integer.parse()
 

test/graphql/resolvers/group_test.exs

@@ -15,7 +15,7 @@ defmodule Mobilizon.Web.Resolvers.GroupTest do
     {:ok, conn: conn, actor: actor, user: user}
   end
 
-  describe "Group Resolver" do
+  describe "create a group" do
     test "create_group/3 should check the user owns the identity", %{conn: conn, user: user} do
       another_actor = insert(:actor)
 
@@ -84,65 +84,130 @@ defmodule Mobilizon.Web.Resolvers.GroupTest do
       assert hd(json_response(res, 200)["errors"])["message"] ==
                "A group with this name already exists"
     end
+  end
 
-    test "list_groups/3 returns all public or unlisted groups", context do
+  describe "list groups" do
+    test "list_groups/3 returns all public or unlisted groups", %{conn: conn} do
       group = insert(:group, visibility: :unlisted)
       insert(:group, visibility: :private)
 
       query = """
       {
         groups {
-            preferredUsername,
+            elements {
+              preferredUsername,
+            },
+            total
         }
       }
       """
 
-      res =
-        context.conn
-        |> get("/api", AbsintheHelpers.query_skeleton(query, "groups"))
+      res = AbsintheHelpers.graphql_query(conn, query: query)
 
-      assert length(json_response(res, 200)["data"]["groups"]) == 1
+      assert res["data"]["groups"]["total"] == 1
 
-      assert hd(json_response(res, 200)["data"]["groups"])["preferredUsername"] ==
+      assert hd(res["data"]["groups"]["elements"])["preferredUsername"] ==
                group.preferred_username
     end
+  end
 
-    test "find_group/3 returns a group by its username", context do
-      group = insert(:group)
-
-      query = """
-      {
-        group(preferredUsername: "#{group.preferred_username}") {
+  describe "find a group" do
+    @group_query """
+      query Group($preferredUsername: String!) {
+        group(preferredUsername: $preferredUsername) {
             preferredUsername,
+            members {
+              total,
+              elements {
+                role,
+                actor {
+                  preferredUsername
+                }
+              }
+            }
         }
       }
-      """
+    """
+
+    test "find_group/3 returns a group by its username", %{conn: conn, actor: actor, user: user} do
+      group = insert(:group)
+      insert(:member, parent: group, actor: actor, role: :administrator)
+      insert(:member, parent: group, role: :member)
 
       res =
-        context.conn
-        |> get("/api", AbsintheHelpers.query_skeleton(query, "group"))
+        conn
+        |> AbsintheHelpers.graphql_query(
+          query: @group_query,
+          variables: %{
+            preferredUsername: group.preferred_username
+          }
+        )
 
-      assert json_response(res, 200)["data"]["group"]["preferredUsername"] ==
+      assert res["errors"] == nil
+
+      assert res["data"]["group"]["preferredUsername"] ==
                group.preferred_username
 
-      query = """
-      {
-        group(preferredUsername: "#{@non_existent_username}") {
-            preferredUsername,
-        }
-      }
-      """
+      assert res["data"]["group"]["members"]["total"] == 2
 
       res =
-        context.conn
-        |> get("/api", AbsintheHelpers.query_skeleton(query, "group"))
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @group_query,
+          variables: %{
+            preferredUsername: group.preferred_username,
+            actorId: actor.id
+          }
+        )
 
-      assert json_response(res, 200)["data"]["group"] == nil
+      assert res["errors"] == nil
 
-      assert hd(json_response(res, 200)["errors"])["message"] ==
+      assert res["data"]["group"]["members"]["total"] == 2
+      assert hd(res["data"]["group"]["members"]["elements"])["role"] == "ADMINISTRATOR"
+
+      assert hd(res["data"]["group"]["members"]["elements"])["actor"]["preferredUsername"] ==
+               actor.preferred_username
+
+      res =
+        conn
+        |> AbsintheHelpers.graphql_query(
+          query: @group_query,
+          variables: %{preferredUsername: @non_existent_username}
+        )
+
+      assert res["data"]["group"] == nil
+
+      assert hd(res["errors"])["message"] ==
                "Group with name #{@non_existent_username} not found"
     end
 
+    test "find_group doesn't list group members access if group is private", %{
+      conn: conn,
+      actor: actor
+    } do
+      group = insert(:group, visibility: :private)
+      insert(:member, parent: group, actor: actor, role: :administrator)
+
+      res =
+        conn
+        |> AbsintheHelpers.graphql_query(
+          query: @group_query,
+          variables: %{
+            preferredUsername: group.preferred_username
+          }
+        )
+
+      assert res["errors"] == nil
+
+      assert res["data"]["group"]["preferredUsername"] ==
+               group.preferred_username
+
+      assert res["data"]["group"]["members"] == %{"elements" => [], "total" => 1}
+    end
+  end
+
+  describe "delete a group" do
     test "delete_group/3 deletes a group", %{conn: conn, user: user, actor: actor} do
       group = insert(:group)
       insert(:member, parent: group, actor: actor, role: :administrator)

test/graphql/resolvers/member_test.exs

@@ -12,7 +12,7 @@ defmodule Mobilizon.GraphQL.Resolvers.MemberTest do
     {:ok, conn: conn, actor: actor, user: user}
   end
 
-  describe "Member Resolver" do
+  describe "Member Resolver to join a group" do
     test "join_group/3 should create a member", %{conn: conn, user: user, actor: actor} do
       group = insert(:group)
 
@@ -39,7 +39,7 @@ defmodule Mobilizon.GraphQL.Resolvers.MemberTest do
         |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
 
       assert json_response(res, 200)["errors"] == nil
-      assert json_response(res, 200)["data"]["joinGroup"]["role"] == "not_approved"
+      assert json_response(res, 200)["data"]["joinGroup"]["role"] == "NOT_APPROVED"
       assert json_response(res, 200)["data"]["joinGroup"]["parent"]["id"] == to_string(group.id)
       assert json_response(res, 200)["data"]["joinGroup"]["actor"]["id"] == to_string(actor.id)
 
@@ -136,7 +136,9 @@ defmodule Mobilizon.GraphQL.Resolvers.MemberTest do
 
       assert hd(json_response(res, 200)["errors"])["message"] =~ "Group id not found"
     end
+  end
 
+  describe "Member Resolver to leave from a group" do
     test "leave_group/3 should delete a member from a group", %{
       conn: conn,
       user: user,
@@ -286,4 +288,211 @@ defmodule Mobilizon.GraphQL.Resolvers.MemberTest do
       assert hd(json_response(res, 200)["errors"])["message"] =~ "Member not found"
     end
   end
+
+  describe "Member Resolver to invite to a group" do
+    @invite_member_mutation """
+      mutation InviteMember($groupId: ID!, $targetActorUsername: String!) {
+        inviteMember(groupId: $groupId, targetActorUsername: $targetActorUsername) {
+          parent {
+            id
+          },
+          actor {
+            id
+          },
+          role
+        }
+      }
+    """
+
+    setup %{conn: conn, actor: actor, user: user} do
+      group = insert(:group)
+      target_actor = insert(:actor, user: user)
+
+      {:ok, conn: conn, actor: actor, user: user, group: group, target_actor: target_actor}
+    end
+
+    test "invite_member/3 invites a local actor to a group", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      group: group,
+      target_actor: target_actor
+    } do
+      _admin_member = insert(:member, %{actor: actor, parent: group, role: :creator})
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: group.id,
+            targetActorUsername: target_actor.preferred_username
+          }
+        )
+
+      assert is_nil(res["errors"])
+      assert res["data"]["inviteMember"]["role"] == "INVITED"
+      assert res["data"]["inviteMember"]["parent"]["id"] == to_string(group.id)
+      assert res["data"]["inviteMember"]["actor"]["id"] == to_string(target_actor.id)
+    end
+
+    test "invite_member/3 invites a remote actor to a group", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      group: group
+    } do
+      _admin_member = insert(:member, %{actor: actor, parent: group, role: :creator})
+      target_actor = insert(:actor, domain: "remote.tld")
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: group.id,
+            targetActorUsername: "#{target_actor.preferred_username}@#{target_actor.domain}"
+          }
+        )
+
+      assert is_nil(res["errors"])
+      assert res["data"]["inviteMember"]["role"] == "INVITED"
+      assert res["data"]["inviteMember"]["parent"]["id"] == to_string(group.id)
+      assert res["data"]["inviteMember"]["actor"]["id"] == to_string(target_actor.id)
+    end
+
+    test "invite_member/3 fails to invite a local actor to a group that invitor isn't in", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      group: group,
+      target_actor: target_actor
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: group.id,
+            targetActorUsername: target_actor.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "You are not a member of this group"
+    end
+
+    test "invite_member/3 fails to invite a non existing local actor", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      group: group
+    } do
+      insert(:member, %{actor: actor, parent: group, role: :administrator})
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: group.id,
+            targetActorUsername: "not_existing"
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "Actor invited doesn't exist"
+    end
+
+    test "invite_member/3 fails to invite a non existing remote actor", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      group: group
+    } do
+      insert(:member, %{actor: actor, parent: group, role: :administrator})
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: group.id,
+            targetActorUsername: "not_existing@nowhere.absolute"
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "Actor invited doesn't exist"
+    end
+
+    test "invite_member/3 fails to invite a actor for a non-existing group", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      target_actor: target_actor
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: "780907988778",
+            targetActorUsername: target_actor.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "Group id not found"
+    end
+
+    test "invite_member/3 fails to invite a actor if we are not an admin for the group", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      group: group,
+      target_actor: target_actor
+    } do
+      _admin_member = insert(:member, %{actor: actor, parent: group, role: :member})
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: group.id,
+            targetActorUsername: target_actor.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "You cannot invite to this group"
+    end
+
+    test "invite_member/3 fails to invite a actor if it's already a member of the group", %{
+      conn: conn,
+      user: user,
+      actor: actor,
+      group: group,
+      target_actor: target_actor
+    } do
+      insert(:member, %{actor: actor, parent: group, role: :member})
+      insert(:member, %{actor: target_actor, parent: group, role: :member})
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @invite_member_mutation,
+          variables: %{
+            groupId: group.id,
+            targetActorUsername: target_actor.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "You cannot invite to this group"
+    end
+  end
 end

test/graphql/resolvers/participant_test.exs

@@ -483,11 +483,10 @@ defmodule Mobilizon.GraphQL.Resolvers.ParticipantTest do
       participant2 = insert(:participant, event: event, actor: actor3, role: :participant)
 
       query = """
-      {
-        event(uuid: "#{event.uuid}") {
-          participants(page: 1, limit: 1, roles: "participant,moderator,administrator,creator", actorId: "#{
-        actor.id
-      }") {
+      query EventParticipants($uuid: UUID!, $actorId: ID, $roles: String, $page: Int, $limit: Int) {
+        event(uuid: $uuid) {
+          participants(page: $page, limit: $limit, roles: $roles, actorId: $actorId) {
+            total,
             elements {
               role,
               actor {
@@ -502,45 +501,21 @@ defmodule Mobilizon.GraphQL.Resolvers.ParticipantTest do
       res =
         conn
         |> auth_conn(user)
-        |> get("/api", AbsintheHelpers.query_skeleton(query, "participants"))
-
-      sorted_participants =
-        json_response(res, 200)["data"]["event"]["participants"]["elements"]
-        |> Enum.filter(&(&1["role"] == "PARTICIPANT"))
-
-      assert sorted_participants == [
-               %{
-                 "actor" => %{
-                   "preferredUsername" => participant2.actor.preferred_username
-                 },
-                 "role" => "PARTICIPANT"
-               }
-             ]
-
-      query = """
-      {
-        event(uuid: "#{event.uuid}") {
-          participants(page: 2, limit: 1, roles: "participant,moderator,administrator,creator", actorId: "#{
-        actor.id
-      }") {
-            elements {
-              role,
-              actor {
-                  preferredUsername
-              }
-            }
+        |> AbsintheHelpers.graphql_query(
+          query: query,
+          variables: %{
+            uuid: event.uuid,
+            actorId: actor.id,
+            roles: "participant,moderator,administrator,creator",
+            page: 1,
+            limit: 1
           }
-        }
-      }
-      """
+        )
 
-      res =
-        conn
-        |> auth_conn(user)
-        |> get("/api", AbsintheHelpers.query_skeleton(query, "participants"))
+      assert is_nil(res["errors"])
 
       sorted_participants =
-        json_response(res, 200)["data"]["event"]["participants"]["elements"]
+        res["data"]["event"]["participants"]["elements"]
         |> Enum.sort_by(
           &(&1
             |> Map.get("actor")
@@ -555,6 +530,35 @@ defmodule Mobilizon.GraphQL.Resolvers.ParticipantTest do
                  "role" => "CREATOR"
                }
              ]
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: query,
+          variables: %{
+            uuid: event.uuid,
+            actorId: actor.id,
+            roles: "participant,moderator,administrator,creator",
+            page: 2,
+            limit: 1
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      sorted_participants =
+        res["data"]["event"]["participants"]["elements"]
+        |> Enum.filter(&(&1["role"] == "PARTICIPANT"))
+
+      assert sorted_participants == [
+               %{
+                 "actor" => %{
+                   "preferredUsername" => participant2.actor.preferred_username
+                 },
+                 "role" => "PARTICIPANT"
+               }
+             ]
     end
 
     test "stats_participants_for_event/3 give the number of (un)approved participants", %{
@@ -1288,7 +1292,11 @@ defmodule Mobilizon.GraphQL.Resolvers.ParticipantTest do
       assert %Participant{
                role: :not_confirmed,
                metadata: %{confirmation_token: confirmation_token, email: @email}
-             } = event.id |> Events.list_participants_for_event([]) |> Map.get(:elements) |> hd
+             } =
+               event.id
+               |> Events.list_participants_for_event([:not_confirmed])
+               |> Map.get(:elements)
+               |> hd
 
       conn
       |> AbsintheHelpers.graphql_query(
@@ -1307,7 +1315,10 @@ defmodule Mobilizon.GraphQL.Resolvers.ParticipantTest do
               }} = Events.get_event(event.id)
 
       assert %Participant{role: :not_approved, id: participant_id} =
-               event.id |> Events.list_participants_for_event([]) |> Map.get(:elements) |> hd
+               event.id
+               |> Events.list_participants_for_event([:not_approved])
+               |> Map.get(:elements)
+               |> hd
 
       update_participation_mutation = """
           mutation UpdateParticipation($participantId: ID!, $role: String!, $moderatorActorId: ID!) {
@@ -1339,7 +1350,10 @@ defmodule Mobilizon.GraphQL.Resolvers.ParticipantTest do
       assert res["errors"] == nil
 
       assert %Participant{role: :participant} =
-               event.id |> Events.list_participants_for_event([]) |> Map.get(:elements) |> hd
+               event.id
+               |> Events.list_participants_for_event([:participant])
+               |> Map.get(:elements)
+               |> hd
 
       assert {:ok,
               %Event{

test/graphql/resolvers/resource_test.exs

@@ -0,0 +1,864 @@
+defmodule Mobilizon.GraphQL.Resolvers.ResourceTest do
+  use Mobilizon.Web.ConnCase
+
+  import Mobilizon.Factory
+
+  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Resources.Resource
+  alias Mobilizon.Users.User
+
+  alias Mobilizon.GraphQL.AbsintheHelpers
+
+  @metadata_fragment """
+  fragment ResourceMetadataBasicFields on ResourceMetadata {
+    imageRemoteUrl,
+    height,
+    width,
+    type,
+    faviconUrl
+  }
+  """
+
+  @get_group_resources """
+  query($name: String!) {
+    group(preferredUsername: $name) {
+        id,
+        url,
+        name,
+        domain,
+        summary,
+        preferredUsername,
+        resources(page: 1, limit: 3) {
+            elements {
+                id,
+                title,
+                resourceUrl,
+                summary,
+                updatedAt,
+                type,
+                path,
+                metadata {
+                    ...ResourceMetadataBasicFields
+                }
+            },
+            total
+        },
+    }
+  }
+  #{@metadata_fragment}
+  """
+
+  @get_resource """
+  query GetResource($path: String, $username: String) {
+    resource(path: $path, username: $username) {
+        id,
+        title,
+        summary,
+        url,
+        path,
+        type,
+        metadata {
+            ...ResourceMetadataBasicFields
+            authorName,
+            authorUrl,
+            providerName,
+            providerUrl,
+            html
+        },
+        parent {
+            id
+        },
+        actor {
+            id,
+            preferredUsername
+        },
+        children {
+            total,
+            elements {
+                id,
+                title,
+                summary,
+                url,
+                type,
+                path,
+                resourceUrl,
+                metadata {
+                    ...ResourceMetadataBasicFields
+                }
+            }
+        }
+    }
+  }
+  #{@metadata_fragment}
+  """
+
+  @create_resource """
+  mutation CreateResource($title: String!, $parentId: ID, $summary: String, $actorId: ID!, $resourceUrl: String, $type: String) {
+    createResource(title: $title, parentId: $parentId, summary: $summary, actorId: $actorId, resourceUrl: $resourceUrl, type: $type) {
+        id,
+        title,
+        summary,
+        url,
+        resourceUrl,
+        updatedAt,
+        path,
+        type,
+        metadata {
+            ...ResourceMetadataBasicFields
+            authorName,
+            authorUrl,
+            providerName,
+            providerUrl,
+            html
+        }
+    }
+  }
+  #{@metadata_fragment}
+  """
+
+  @update_resource """
+  mutation UpdateResource($id: ID!, $title: String, $summary: String, $parentId: ID, $resourceUrl: String) {
+    updateResource(id: $id, title: $title, parentId: $parentId, summary: $summary, resourceUrl: $resourceUrl) {
+        id,
+        title,
+        summary,
+        url,
+        path,
+        resourceUrl,
+        type,
+        children {
+          total,
+          elements {
+              id,
+              title,
+              summary,
+              url,
+              type,
+              path,
+              resourceUrl,
+              metadata {
+                  ...ResourceMetadataBasicFields
+              }
+          }
+      }
+    }
+  }
+  #{@metadata_fragment}
+  """
+
+  @delete_resource """
+  mutation DeleteResource($id: ID!) {
+    deleteResource(id: $id) {
+        id
+    }
+  }
+  """
+
+  @resource_url "https://framasoft.org/fr/full"
+  @resource_title "my resource"
+  @updated_resource_title "my updated resource"
+  @folder_title "my folder"
+
+  setup do
+    %User{} = user = insert(:user)
+    %Actor{} = actor = insert(:actor, user: user)
+    %Actor{} = group = insert(:group)
+    %Member{} = insert(:member, parent: group, actor: actor, role: :member)
+    resource_in_root = %Resource{} = insert(:resource, actor: group)
+
+    folder_in_root =
+      %Resource{id: parent_id, path: parent_path} =
+      insert(:resource,
+        type: :folder,
+        resource_url: nil,
+        actor: group,
+        title: "root folder",
+        path: "/root folder"
+      )
+
+    resource_in_folder =
+      %Resource{} =
+      insert(:resource,
+        resource_url: nil,
+        actor: group,
+        parent_id: parent_id,
+        path: "#{parent_path}/titre",
+        title: "titre"
+      )
+
+    {:ok,
+     user: user,
+     group: group,
+     root_resources: [folder_in_root, resource_in_root],
+     resource_in_folder: resource_in_folder}
+  end
+
+  describe "Resolver: Get group's resources" do
+    test "find_resources_for_group/3", %{
+      conn: conn,
+      user: user,
+      group: group,
+      root_resources: root_resources,
+      resource_in_folder: resource_in_folder
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_group_resources,
+          variables: %{
+            name: group.preferred_username
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["group"]["resources"]["total"] == 3
+
+      assert res["data"]["group"]["resources"]["elements"]
+             |> Enum.map(&{&1["path"], &1["type"]})
+             |> MapSet.new() ==
+               (root_resources ++ [resource_in_folder])
+               |> Enum.map(&{&1.path, Atom.to_string(&1.type)})
+               |> MapSet.new()
+    end
+
+    test "find_resources_for_group/3 when not member of group", %{
+      conn: conn,
+      group: group
+    } do
+      %User{} = user = insert(:user)
+      %Actor{} = insert(:actor, user: user)
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_group_resources,
+          variables: %{
+            name: group.preferred_username
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["group"]["resources"]["total"] == 0
+      assert res["data"]["group"]["resources"]["elements"] == []
+    end
+
+    test "find_resources_for_group/3 when not connected", %{
+      conn: conn,
+      group: group
+    } do
+      res =
+        conn
+        |> AbsintheHelpers.graphql_query(
+          query: @get_group_resources,
+          variables: %{
+            name: group.preferred_username
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["group"]["resources"]["total"] == 0
+      assert res["data"]["group"]["resources"]["elements"] == []
+    end
+  end
+
+  describe "Resolver: Get a specific resource" do
+    test "get_resource/3 for the root path", %{
+      conn: conn,
+      user: user,
+      group: group,
+      root_resources: root_resources
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: "/",
+            username: group.preferred_username
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["resource"]["path"] == "/"
+      assert String.starts_with?(res["data"]["resource"]["id"], "root_")
+
+      assert res["data"]["resource"]["children"]["elements"]
+             |> Enum.map(& &1["id"])
+             |> MapSet.new() == root_resources |> Enum.map(& &1.id) |> MapSet.new()
+    end
+
+    test "get_resource/3 for a folder path", %{
+      conn: conn,
+      user: user,
+      group: group,
+      root_resources: [root_folder, _],
+      resource_in_folder: resource_in_folder
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: root_folder.path,
+            username: group.preferred_username
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["resource"]["type"] == "folder"
+      assert res["data"]["resource"]["path"] == root_folder.path
+      assert is_nil(res["data"]["resource"]["parent"]["id"])
+
+      assert res["data"]["resource"]["children"]["total"] == 1
+
+      assert res["data"]["resource"]["children"]["elements"]
+             |> Enum.map(& &1["id"])
+             |> MapSet.new() == [resource_in_folder] |> Enum.map(& &1.id) |> MapSet.new()
+    end
+
+    test "get_resource/3 for a non-existing path", %{
+      conn: conn,
+      user: user,
+      group: group
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: "/non existing",
+            username: group.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "No such resource"
+    end
+
+    test "get_resource/3 for a non-existing group", %{
+      conn: conn,
+      user: user
+    } do
+      %Actor{preferred_username: group_name} = insert(:group)
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: "/non existing",
+            username: group_name
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "Actor is not member of group"
+    end
+
+    test "get_resource/3 when not connected", %{
+      conn: conn,
+      group: group,
+      resource_in_folder: resource_in_folder
+    } do
+      res =
+        conn
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: resource_in_folder.path,
+            username: group.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "You need to be logged-in to access resources"
+    end
+  end
+
+  describe "Resolver: Create a resource" do
+    test "create_resource/3 creates a resource for a group", %{
+      conn: conn,
+      user: user,
+      group: group
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @create_resource,
+          variables: %{
+            title: @resource_title,
+            parentId: nil,
+            actorId: group.id,
+            resourceUrl: @resource_url
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["createResource"]["metadata"]["faviconUrl"] ==
+               "https://framasoft.org/icons/favicon.png"
+
+      assert res["data"]["createResource"]["metadata"]["imageRemoteUrl"] ==
+               "https://framasoft.org/img/opengraph/full.jpg"
+
+      assert res["data"]["createResource"]["path"] == "/#{@resource_title}"
+      assert res["data"]["createResource"]["resourceUrl"] == @resource_url
+      assert res["data"]["createResource"]["title"] == @resource_title
+      assert res["data"]["createResource"]["type"] == "link"
+    end
+
+    test "create_resource/3 creates a folder", %{conn: conn, user: user, group: group} do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @create_resource,
+          variables: %{
+            title: @folder_title,
+            parentId: nil,
+            actorId: group.id,
+            type: "folder"
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["createResource"]["path"] == "/#{@folder_title}"
+      assert res["data"]["createResource"]["title"] == @folder_title
+      assert res["data"]["createResource"]["type"] == "folder"
+    end
+
+    test "create_resource/3 creates a resource in a folder", %{
+      conn: conn,
+      user: user,
+      group: group
+    } do
+      %Resource{id: parent_id, path: parent_path} =
+        insert(:resource, type: :folder, resource_url: nil, actor: group)
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @create_resource,
+          variables: %{
+            title: @resource_title,
+            parentId: parent_id,
+            actorId: group.id,
+            resourceUrl: @resource_url
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["createResource"]["metadata"]["faviconUrl"] ==
+               "https://framasoft.org/icons/favicon.png"
+
+      assert res["data"]["createResource"]["metadata"]["imageRemoteUrl"] ==
+               "https://framasoft.org/img/opengraph/full.jpg"
+
+      assert res["data"]["createResource"]["path"] == "#{parent_path}/#{@resource_title}"
+      assert res["data"]["createResource"]["resourceUrl"] == @resource_url
+      assert res["data"]["createResource"]["title"] == @resource_title
+      assert res["data"]["createResource"]["type"] == "link"
+    end
+
+    test "create_resource/3 doesn't create a resource in a folder if no group is defined", %{
+      conn: conn,
+      user: user
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @create_resource,
+          variables: %{
+            title: @resource_title,
+            parentId: nil,
+            resourceUrl: @resource_url
+          }
+        )
+
+      assert Enum.map(res["errors"], & &1["message"]) == [
+               "In argument \"actorId\": Expected type \"ID!\", found null.",
+               "Variable \"actorId\": Expected non-null, found null."
+             ]
+    end
+
+    test "create_resource/3 doesn't create a resource if the actor is not a member of the group",
+         %{
+           conn: conn,
+           group: group
+         } do
+      %User{} = user = insert(:user)
+      %Actor{} = insert(:actor, user: user)
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @create_resource,
+          variables: %{
+            title: @resource_title,
+            parentId: nil,
+            actorId: group.id,
+            resourceUrl: @resource_url
+          }
+        )
+
+      assert Enum.map(res["errors"], & &1["message"]) == [
+               "Actor id is not member of group"
+             ]
+    end
+
+    test "create_resource/3 doesn't create a resource if the referenced parent folder is not owned by the group",
+         %{
+           conn: conn,
+           user: user,
+           group: group
+         } do
+      %Actor{} = group2 = insert(:group)
+
+      %Resource{id: parent_id} =
+        insert(:resource, type: :folder, resource_url: nil, actor: group2)
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @create_resource,
+          variables: %{
+            title: @resource_title,
+            parentId: parent_id,
+            actorId: group.id,
+            resourceUrl: @resource_url
+          }
+        )
+
+      assert Enum.map(res["errors"], & &1["message"]) == [
+               "Parent resource doesn't match this group"
+             ]
+    end
+  end
+
+  describe "Resolver: Update a resource" do
+    test "update_resource/3 renames a resource for a group", %{
+      conn: conn,
+      user: user,
+      group: group
+    } do
+      %Resource{id: resource_id} = insert(:resource, resource_url: @resource_url, actor: group)
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @update_resource,
+          variables: %{
+            id: resource_id,
+            title: @updated_resource_title
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["updateResource"]["path"] == "/#{@updated_resource_title}"
+      assert res["data"]["updateResource"]["resourceUrl"] == @resource_url
+      assert res["data"]["updateResource"]["title"] == @updated_resource_title
+      assert res["data"]["updateResource"]["type"] == "link"
+    end
+
+    test "update_resource/3 moves and renames a resource for a group", %{
+      conn: conn,
+      user: user,
+      group: group,
+      root_resources: [root_folder, _]
+    } do
+      %Resource{id: resource_id} = insert(:resource, resource_url: @resource_url, actor: group)
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @update_resource,
+          variables: %{
+            id: resource_id,
+            title: @updated_resource_title,
+            parentId: root_folder.id
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["updateResource"]["path"] ==
+               "#{root_folder.path}/#{@updated_resource_title}"
+
+      assert res["data"]["updateResource"]["resourceUrl"] == @resource_url
+      assert res["data"]["updateResource"]["title"] == @updated_resource_title
+      assert res["data"]["updateResource"]["type"] == "link"
+    end
+
+    test "update_resource/3 moves a resource in a subfolder for a group", %{
+      conn: conn,
+      user: user,
+      group: group,
+      root_resources: [root_folder, _]
+    } do
+      %Resource{id: resource_id} =
+        resource = insert(:resource, resource_url: @resource_url, actor: group)
+
+      folder =
+        insert(:resource,
+          parent_id: root_folder.id,
+          actor: group,
+          path: "#{root_folder.path}/subfolder",
+          title: "subfolder"
+        )
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @update_resource,
+          variables: %{
+            id: resource_id,
+            parentId: folder.id
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["updateResource"]["path"] ==
+               "#{folder.path}/#{resource.title}"
+
+      assert res["data"]["updateResource"]["resourceUrl"] == @resource_url
+      assert res["data"]["updateResource"]["title"] == resource.title
+      assert res["data"]["updateResource"]["type"] == "link"
+    end
+
+    test "update_resource/3 renames a folder and all the paths for it's children", %{
+      conn: conn,
+      user: user,
+      group: group,
+      root_resources: [root_folder, _]
+    } do
+      folder =
+        insert(:resource,
+          parent_id: root_folder.id,
+          actor: group,
+          path: "#{root_folder.path}/subfolder",
+          title: "subfolder",
+          type: :folder
+        )
+
+      %Resource{} =
+        insert(:resource,
+          resource_url: @resource_url,
+          actor: group,
+          parent_id: folder.id,
+          path: "#{folder.path}/titre",
+          title: "titre"
+        )
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @update_resource,
+          variables: %{
+            id: folder.id,
+            title: "updated subfolder"
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["updateResource"]["path"] ==
+               "#{root_folder.path}/updated subfolder"
+
+      assert res["data"]["updateResource"]["title"] == "updated subfolder"
+      assert res["data"]["updateResource"]["type"] == "folder"
+
+      assert hd(res["data"]["updateResource"]["children"]["elements"])["path"] ==
+               "#{root_folder.path}/updated subfolder/titre"
+    end
+
+    test "update_resource/3 moves a folder and updates all the paths for it's children", %{
+      conn: conn,
+      user: user,
+      group: group,
+      root_resources: [root_folder, _]
+    } do
+      folder =
+        insert(:resource,
+          parent_id: nil,
+          actor: group,
+          path: "/subfolder",
+          title: "subfolder",
+          type: :folder
+        )
+
+      %Resource{} =
+        insert(:resource,
+          resource_url: @resource_url,
+          actor: group,
+          parent_id: folder.id,
+          path: "#{folder.path}/titre",
+          title: "titre"
+        )
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @update_resource,
+          variables: %{
+            id: folder.id,
+            parentId: root_folder.id,
+            title: "updated subfolder"
+          }
+        )
+
+      assert is_nil(res["errors"])
+
+      assert res["data"]["updateResource"]["path"] ==
+               "#{root_folder.path}/updated subfolder"
+
+      assert res["data"]["updateResource"]["title"] == "updated subfolder"
+      assert res["data"]["updateResource"]["type"] == "folder"
+
+      assert hd(res["data"]["updateResource"]["children"]["elements"])["path"] ==
+               "#{root_folder.path}/updated subfolder/titre"
+    end
+  end
+
+  describe "Resolver: Delete a resource" do
+    test "delete_resource/3 deletes a resource", %{
+      conn: conn,
+      user: user,
+      group: group
+    } do
+      %Resource{id: resource_id, path: resource_path} =
+        insert(:resource,
+          resource_url: @resource_url,
+          actor: group,
+          parent_id: nil
+        )
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @delete_resource,
+          variables: %{
+            id: resource_id
+          }
+        )
+
+      assert is_nil(res["errors"])
+      assert res["data"]["deleteResource"]["id"] == resource_id
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: resource_path,
+            username: group.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "No such resource"
+    end
+
+    test "delete_resource/3 deletes a folder and children", %{
+      conn: conn,
+      user: user,
+      group: group
+    } do
+      %Resource{id: folder_id, path: folder_path} =
+        insert(:resource,
+          parent_id: nil,
+          actor: group,
+          path: "/subfolder",
+          title: "subfolder",
+          type: :folder
+        )
+
+      %Resource{path: resource_path} =
+        insert(:resource,
+          resource_url: @resource_url,
+          actor: group,
+          parent_id: folder_id,
+          path: "#{folder_path}/titre",
+          title: "titre"
+        )
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @delete_resource,
+          variables: %{
+            id: folder_id
+          }
+        )
+
+      assert is_nil(res["errors"])
+      assert res["data"]["deleteResource"]["id"] == folder_id
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: folder_path,
+            username: group.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "No such resource"
+
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @get_resource,
+          variables: %{
+            path: resource_path,
+            username: group.preferred_username
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "No such resource"
+    end
+
+    test "delete_resource/3 deletes a resource not found", %{
+      conn: conn,
+      user: user
+    } do
+      res =
+        conn
+        |> auth_conn(user)
+        |> AbsintheHelpers.graphql_query(
+          query: @delete_resource,
+          variables: %{
+            id: "58869b5b-2beb-423a-b483-1585d847e2cc"
+          }
+        )
+
+      assert hd(res["errors"])["message"] == "Resource doesn't exist"
+    end
+  end
+end

test/graphql/resolvers/user_test.exs

@@ -5,9 +5,10 @@ defmodule Mobilizon.GraphQL.Resolvers.UserTest do
 
   import Mobilizon.Factory
 
-  alias Mobilizon.{Actors, Config, Events, Users}
+  alias Mobilizon.{Actors, Config, Conversations, Events, Users}
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Events.{Comment, Event, Participant}
+  alias Mobilizon.Conversations.Comment
+  alias Mobilizon.Events.{Event, Participant}
   alias Mobilizon.Users.User
 
   alias Mobilizon.GraphQL.AbsintheHelpers
@@ -1424,7 +1425,7 @@ defmodule Mobilizon.GraphQL.Resolvers.UserTest do
       end
 
       assert_raise Ecto.NoResultsError, fn ->
-        Events.get_comment!(comment_id)
+        Conversations.get_comment!(comment_id)
       end
 
       # Actors are not deleted but emptied (to keep the  username reserved)