mobilizon.chapril.org-mobil.../test/graphql/resolvers/group_test.exs

345 lines
8.9 KiB
Elixir
Raw Normal View History

2020-01-26 21:36:50 +01:00
defmodule Mobilizon.Web.Resolvers.GroupTest do
use Mobilizon.Web.ConnCase
2020-01-26 20:34:25 +01:00
import Mobilizon.Factory
2020-01-26 20:34:25 +01:00
alias Mobilizon.GraphQL.AbsintheHelpers
@non_existent_username "nonexistent"
@new_group_params %{groupname: "new group"}
setup %{conn: conn} do
user = insert(:user)
actor = insert(:actor, user: user)
{:ok, conn: conn, actor: actor, user: user}
end
describe "create a group" do
2019-09-02 10:50:00 +02:00
test "create_group/3 should check the user owns the identity", %{conn: conn, user: user} do
another_actor = insert(:actor)
mutation = """
mutation {
createGroup(
preferred_username: "#{@new_group_params.groupname}",
creator_actor_id: #{another_actor.id}
) {
preferred_username,
type
}
}
"""
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] ==
"Creator actor id is not owned by the current user"
2019-09-02 10:50:00 +02:00
end
test "create_group/3 creates a group and check a group with this name does not already exist",
%{conn: conn, user: user, actor: actor} do
mutation = """
mutation {
createGroup(
preferred_username: "#{@new_group_params.groupname}",
2019-09-02 10:50:00 +02:00
creator_actor_id: #{actor.id}
) {
preferred_username,
type
}
}
"""
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert json_response(res, 200)["data"]["createGroup"]["preferred_username"] ==
@new_group_params.groupname
assert json_response(res, 200)["data"]["createGroup"]["type"] == "GROUP"
mutation = """
mutation {
createGroup(
preferred_username: "#{@new_group_params.groupname}",
2019-09-02 10:50:00 +02:00
creator_actor_id: #{actor.id},
) {
preferred_username,
type
}
}
"""
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
2019-09-02 10:50:00 +02:00
assert hd(json_response(res, 200)["errors"])["message"] ==
"A group with this name already exists"
end
end
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 {
elements {
preferredUsername,
},
total
}
}
"""
res = AbsintheHelpers.graphql_query(conn, query: query)
assert res["data"]["groups"]["total"] == 1
assert hd(res["data"]["groups"]["elements"])["preferredUsername"] ==
group.preferred_username
end
end
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 =
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"]["total"] == 2
res =
conn
|> auth_conn(user)
|> AbsintheHelpers.graphql_query(
query: @group_query,
variables: %{
preferredUsername: group.preferred_username,
actorId: actor.id
}
)
assert res["errors"] == nil
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
2019-01-25 09:23:44 +01:00
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
2019-01-25 09:23:44 +01:00
test "delete_group/3 deletes a group", %{conn: conn, user: user, actor: actor} do
group = insert(:group)
2019-03-01 17:11:28 +01:00
insert(:member, parent: group, actor: actor, role: :administrator)
2019-01-25 09:23:44 +01:00
mutation = """
mutation {
deleteGroup(
actor_id: #{actor.id},
group_id: #{group.id}
) {
id
}
}
"""
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert json_response(res, 200)["errors"] == nil
assert json_response(res, 200)["data"]["deleteGroup"]["id"] == to_string(group.id)
2019-01-25 09:23:44 +01:00
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] =~ "not found"
end
2019-02-01 09:42:31 +01:00
test "delete_group/3 should check user authentication", %{conn: conn, actor: actor} do
group = insert(:group)
2019-03-01 17:11:28 +01:00
insert(:member, parent: group, actor: actor, role: :member)
2019-02-01 09:42:31 +01:00
mutation = """
mutation {
deleteGroup(
actor_id: #{actor.id},
group_id: #{group.id}
) {
id
}
}
"""
res =
conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] =~ "logged-in"
end
2019-02-01 09:52:36 +01:00
test "delete_group/3 should check the actor is owned by the user", %{
conn: conn,
user: user,
actor: actor
} do
2019-02-01 09:42:31 +01:00
group = insert(:group)
2019-03-01 17:11:28 +01:00
insert(:member, parent: group, actor: actor, role: :member)
2019-02-01 09:42:31 +01:00
mutation = """
mutation {
deleteGroup(
actor_id: 159,
group_id: #{group.id}
) {
id
}
}
"""
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] =~ "not owned"
end
2019-02-01 09:52:36 +01:00
test "delete_group/3 should check the actor is a member of this group", %{
conn: conn,
user: user,
actor: actor
} do
2019-02-01 09:42:31 +01:00
group = insert(:group)
mutation = """
mutation {
deleteGroup(
actor_id: #{actor.id},
group_id: #{group.id}
) {
id
}
}
"""
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] =~ "not a member"
end
2019-02-01 09:52:36 +01:00
test "delete_group/3 should check the actor is an administrator of this group", %{
conn: conn,
user: user,
actor: actor
} do
2019-02-01 09:42:31 +01:00
group = insert(:group)
2019-03-01 17:11:28 +01:00
insert(:member, parent: group, actor: actor, role: :member)
2019-02-01 09:42:31 +01:00
mutation = """
mutation {
deleteGroup(
actor_id: #{actor.id},
group_id: #{group.id}
) {
id
}
}
"""
res =
conn
|> auth_conn(user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] =~ "not an administrator"
end
end
end