1692 lines
47 KiB
Elixir
1692 lines
47 KiB
Elixir
defmodule Mobilizon.Web.Resolvers.EventTest do
|
|
use Mobilizon.Web.ConnCase
|
|
use Bamboo.Test, shared: true
|
|
use Oban.Testing, repo: Mobilizon.Storage.Repo
|
|
|
|
import Mobilizon.Factory
|
|
|
|
alias Mobilizon.Actors.Actor
|
|
alias Mobilizon.{Events, Users}
|
|
alias Mobilizon.Events.Event
|
|
alias Mobilizon.Service.Workers
|
|
alias Mobilizon.Users.User
|
|
|
|
alias Mobilizon.GraphQL.AbsintheHelpers
|
|
|
|
alias Mobilizon.Web.Email
|
|
|
|
@event %{
|
|
description: "some body",
|
|
title: "some title",
|
|
begins_on: DateTime.utc_now() |> DateTime.truncate(:second),
|
|
uuid: "b5126423-f1af-43e4-a923-002a03003ba4",
|
|
url: "some url",
|
|
category: "MEETING"
|
|
}
|
|
|
|
@find_event_query """
|
|
query Event($uuid: UUID!) {
|
|
event(uuid: $uuid) {
|
|
uuid,
|
|
draft
|
|
}
|
|
}
|
|
"""
|
|
|
|
setup %{conn: conn} do
|
|
user = insert(:user)
|
|
actor = insert(:actor, user: user, preferred_username: "test")
|
|
|
|
{:ok, conn: conn, actor: actor, user: user}
|
|
end
|
|
|
|
describe "Find an event" do
|
|
test "find_event/3 returns an event", context do
|
|
event =
|
|
@event
|
|
|> Map.put(:organizer_actor_id, context.actor.id)
|
|
|
|
{:ok, event} = Events.create_event(event)
|
|
|
|
res =
|
|
context.conn
|
|
|> AbsintheHelpers.graphql_query(query: @find_event_query, variables: %{uuid: event.uuid})
|
|
|
|
assert res["data"]["event"]["uuid"] == to_string(event.uuid)
|
|
|
|
res =
|
|
context.conn
|
|
|> AbsintheHelpers.graphql_query(query: @find_event_query, variables: %{uuid: "bad uuid"})
|
|
|
|
assert [%{"message" => "Argument \"uuid\" has invalid value $uuid."}] = res["errors"]
|
|
|
|
res =
|
|
context.conn
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @find_event_query,
|
|
variables: %{uuid: "b5126423-f1af-43e4-a923-002a03003ba5"}
|
|
)
|
|
|
|
assert [%{"message" => "Event not found"}] = res["errors"]
|
|
end
|
|
end
|
|
|
|
describe "create_event/3 for a regular profile" do
|
|
@create_event_mutation """
|
|
mutation CreateEvent(
|
|
$title: String!,
|
|
$description: String!,
|
|
$begins_on: DateTime!,
|
|
$ends_on: DateTime,
|
|
$status: EventStatus,
|
|
$visibility: EventVisibility,
|
|
$organizer_actor_id: ID!,
|
|
$attributed_to_id: ID,
|
|
$online_address: String,
|
|
$options: EventOptionsInput,
|
|
$draft: Boolean,
|
|
$language: String
|
|
$picture: MediaInput
|
|
$tags: [String]
|
|
$physicalAddress: AddressInput
|
|
$category: EventCategory
|
|
) {
|
|
createEvent(
|
|
title: $title,
|
|
description: $description,
|
|
begins_on: $begins_on,
|
|
ends_on: $ends_on,
|
|
status: $status,
|
|
visibility: $visibility,
|
|
organizer_actor_id: $organizer_actor_id,
|
|
attributed_to_id: $attributed_to_id,
|
|
online_address: $online_address,
|
|
options: $options,
|
|
draft: $draft,
|
|
picture: $picture
|
|
language: $language
|
|
physicalAddress: $physicalAddress
|
|
category: $category
|
|
tags: $tags
|
|
) {
|
|
id,
|
|
uuid,
|
|
title,
|
|
description,
|
|
begins_on,
|
|
ends_on,
|
|
status,
|
|
visibility,
|
|
organizer_actor {
|
|
id
|
|
},
|
|
attributed_to {
|
|
id
|
|
},
|
|
physicalAddress {
|
|
id,
|
|
url,
|
|
geom,
|
|
street
|
|
}
|
|
online_address,
|
|
phone_address,
|
|
category,
|
|
draft
|
|
language
|
|
options {
|
|
maximumAttendeeCapacity,
|
|
showRemainingAttendeeCapacity,
|
|
showEndTime
|
|
}
|
|
picture {
|
|
url
|
|
name
|
|
}
|
|
tags {
|
|
slug
|
|
title
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
test "create_event/3 should check the organizer_actor_id is owned by the user", %{
|
|
conn: conn,
|
|
user: user
|
|
} do
|
|
another_actor = insert(:actor)
|
|
|
|
begins_on = DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "#{begins_on}",
|
|
organizer_actor_id: "#{another_actor.id}"
|
|
}
|
|
)
|
|
|
|
assert res["data"]["createEvent"] == nil
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"Organizer profile is not owned by the user"
|
|
end
|
|
|
|
test "create_event/3 should check that end time is after start time", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
begins_on = DateTime.utc_now() |> DateTime.truncate(:second)
|
|
ends_on = DateTime.add(begins_on, -2 * 3600)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "#{begins_on}",
|
|
ends_on: "#{ends_on}",
|
|
organizer_actor_id: "#{actor.id}"
|
|
}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
["ends_on cannot be set before begins_on"]
|
|
end
|
|
|
|
test "create_event/3 creates an event", %{conn: conn, actor: actor, user: user} do
|
|
begins_on = DateTime.utc_now()
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "#{DateTime.add(begins_on, 3600 * 24)}",
|
|
organizer_actor_id: "#{actor.id}"
|
|
}
|
|
)
|
|
|
|
assert res["data"]["createEvent"]["title"] == "come to my event"
|
|
id = String.to_integer(res["data"]["createEvent"]["id"])
|
|
uuid = res["data"]["createEvent"]["uuid"]
|
|
|
|
assert_enqueued(
|
|
worker: Workers.BuildSearch,
|
|
args: %{event_id: id, op: :insert_search_event}
|
|
)
|
|
|
|
assert_enqueued(
|
|
worker: Workers.EventDelayedNotificationWorker,
|
|
args: %{event_uuid: uuid, action: :notify_of_new_event},
|
|
scheduled_at: {DateTime.add(begins_on, 1800), delta: 5}
|
|
)
|
|
end
|
|
|
|
test "create_event/3 creates an event and escapes title", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title:
|
|
"My Event title <img src=\"http://placekitten.com/g/200/300\" onclick=\"alert('aaa')\" >",
|
|
description:
|
|
"<b>My description</b> <img src=\"http://placekitten.com/g/200/300\" onclick=\"alert('aaa')\" >",
|
|
begins_on: DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601(),
|
|
organizer_actor_id: "#{actor.id}"
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
|
|
assert res["data"]["createEvent"]["title"] ==
|
|
"My Event title <img src=\"http://placekitten.com/g/200/300\" onclick=\"alert('aaa')\" >"
|
|
|
|
assert res["data"]["createEvent"]["description"] ==
|
|
"<b>My description</b> <img src=\"http://placekitten.com/g/200/300\"/>"
|
|
|
|
{id, ""} = res["data"]["createEvent"]["id"] |> Integer.parse()
|
|
|
|
assert_enqueued(
|
|
worker: Workers.BuildSearch,
|
|
args: %{event_id: id, op: :insert_search_event}
|
|
)
|
|
end
|
|
|
|
test "create_event/3 creates an event as a draft", %{conn: conn, actor: actor, user: user} do
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "#{DateTime.utc_now()}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
draft: true
|
|
}
|
|
)
|
|
|
|
assert res["data"]["createEvent"]["title"] == "come to my event"
|
|
assert res["data"]["createEvent"]["draft"] == true
|
|
|
|
event_uuid = res["data"]["createEvent"]["uuid"]
|
|
event_id = res["data"]["createEvent"]["id"]
|
|
{event_id_int, ""} = Integer.parse(event_id)
|
|
|
|
refute_enqueued(
|
|
worker: Workers.BuildSearch,
|
|
args: %{event_id: event_id_int, op: :insert_search_event}
|
|
)
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(query: @find_event_query, variables: %{uuid: event_uuid})
|
|
|
|
assert hd(res["errors"])["message"] =~ "not found"
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(query: @find_event_query, variables: %{uuid: event_uuid})
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["event"]["draft"] == true
|
|
|
|
query = """
|
|
query Person($actor_id: ID!, $event_id: ID) {
|
|
person(id: $actor_id) {
|
|
id,
|
|
participations(eventId: $event_id) {
|
|
elements {
|
|
id,
|
|
role,
|
|
actor {
|
|
id
|
|
},
|
|
event {
|
|
id
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: query,
|
|
variables: %{actor_id: actor.id, event_id: event_id}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["person"]["participations"]["elements"] == []
|
|
end
|
|
|
|
test "create_event/3 creates an event as a draft for a group", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
%Actor{id: group_id} = group = insert(:group)
|
|
insert(:member, parent: group, actor: actor, role: :moderator)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "#{DateTime.utc_now()}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
attributed_to_id: group_id,
|
|
draft: true
|
|
}
|
|
)
|
|
|
|
assert res["data"]["createEvent"]["title"] == "come to my event"
|
|
assert res["data"]["createEvent"]["draft"] == true
|
|
assert res["data"]["createEvent"]["attributed_to"]["id"] == to_string(group_id)
|
|
|
|
event_uuid = res["data"]["createEvent"]["uuid"]
|
|
event_id = res["data"]["createEvent"]["id"]
|
|
|
|
refute_enqueued(
|
|
worker: Workers.BuildSearch,
|
|
args: %{event_id: String.to_integer(event_id), op: :insert_search_event}
|
|
)
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(query: @find_event_query, variables: %{uuid: event_uuid})
|
|
|
|
assert hd(res["errors"])["message"] =~ "not found"
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(query: @find_event_query, variables: %{uuid: event_uuid})
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["event"]["draft"] == true
|
|
end
|
|
|
|
test "create_event/3 creates an event with options", %{conn: conn, actor: actor, user: user} do
|
|
begins_on = DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
|
|
ends_on = DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "#{begins_on}",
|
|
ends_on: "#{ends_on}",
|
|
status: "TENTATIVE",
|
|
visibility: "UNLISTED",
|
|
organizer_actor_id: "#{actor.id}",
|
|
online_address: "toto@example.com",
|
|
options: %{
|
|
maximumAttendeeCapacity: 30,
|
|
showRemainingAttendeeCapacity: true,
|
|
showEndTime: false
|
|
}
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
|
|
event = res["data"]["createEvent"]
|
|
|
|
assert event["title"] == "come to my event"
|
|
assert event["description"] == "it will be fine"
|
|
assert event["begins_on"] == begins_on
|
|
assert event["ends_on"] == ends_on
|
|
assert event["status"] == "TENTATIVE"
|
|
assert event["visibility"] == "UNLISTED"
|
|
assert event["organizer_actor"]["id"] == "#{actor.id}"
|
|
assert event["online_address"] == "toto@example.com"
|
|
assert event["options"]["maximumAttendeeCapacity"] == 30
|
|
assert event["options"]["showRemainingAttendeeCapacity"] == true
|
|
assert event["options"]["showEndTime"] == false
|
|
{event_id_int, ""} = Integer.parse(event["id"])
|
|
|
|
assert_enqueued(
|
|
worker: Workers.BuildSearch,
|
|
args: %{event_id: event_id_int, op: :insert_search_event}
|
|
)
|
|
end
|
|
|
|
test "create_event/3 creates an event an invalid options", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
begins_on = DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "#{begins_on}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
options: %{
|
|
maximumAttendeeCapacity: -5
|
|
}
|
|
}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] == %{
|
|
"maximum_attendee_capacity" => ["must be greater than or equal to 0"]
|
|
}
|
|
end
|
|
|
|
test "create_event/3 creates an event with tags", %{conn: conn, actor: actor, user: user} do
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "my event is referenced",
|
|
description: "with tags!",
|
|
begins_on:
|
|
"#{DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
category: "PARTY",
|
|
tags: ["nicolas", "birthday", "bad tag"]
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["createEvent"]["title"] == "my event is referenced"
|
|
|
|
assert res["data"]["createEvent"]["tags"] == [
|
|
%{"slug" => "nicolas", "title" => "nicolas"},
|
|
%{"slug" => "birthday", "title" => "birthday"},
|
|
%{"slug" => "bad-tag", "title" => "bad tag"}
|
|
]
|
|
|
|
assert res["data"]["createEvent"]["category"] == "PARTY"
|
|
end
|
|
|
|
test "create_event/3 creates an event with an address", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
address = %{street: "I am a street, please believe me", locality: "Where ever"}
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "my event is referenced",
|
|
description: "with tags!",
|
|
begins_on:
|
|
"#{DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
category: "PARTY",
|
|
physicalAddress: %{
|
|
street: "#{address.street}",
|
|
locality: "#{address.locality}"
|
|
}
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
|
|
assert res["data"]["createEvent"]["title"] == "my event is referenced"
|
|
|
|
assert res["data"]["createEvent"]["physicalAddress"]["street"] ==
|
|
address.street
|
|
|
|
address_url = res["data"]["createEvent"]["physicalAddress"]["url"]
|
|
address_id = res["data"]["createEvent"]["physicalAddress"]["id"]
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "my event is referenced",
|
|
description: "with tags!",
|
|
begins_on:
|
|
"#{DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
category: "PARTY",
|
|
physicalAddress: %{
|
|
id: "#{address_id}"
|
|
}
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
|
|
assert res["data"]["createEvent"]["title"] == "my event is referenced"
|
|
|
|
assert res["data"]["createEvent"]["physicalAddress"]["street"] ==
|
|
address.street
|
|
|
|
assert res["data"]["createEvent"]["physicalAddress"]["id"] ==
|
|
address_id
|
|
|
|
assert res["data"]["createEvent"]["physicalAddress"]["url"] ==
|
|
address_url
|
|
end
|
|
|
|
test "create_event/3 creates an event with an attached picture", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
map = %{
|
|
"query" => @create_event_mutation,
|
|
"variables" => %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on:
|
|
"#{DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
category: "PARTY",
|
|
picture: %{
|
|
media: %{
|
|
name: "picture for my event",
|
|
alt: "A very sunny landscape",
|
|
file: "event.jpg",
|
|
actor_id: actor.id
|
|
}
|
|
}
|
|
},
|
|
"event.jpg" => %Plug.Upload{
|
|
path: "test/fixtures/picture.png",
|
|
filename: "event.jpg"
|
|
}
|
|
}
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> put_req_header("content-type", "multipart/form-data")
|
|
|> post(
|
|
"/api",
|
|
map
|
|
)
|
|
|> json_response(200)
|
|
|
|
assert res["data"]["createEvent"]["title"] == "come to my event"
|
|
|
|
assert res["data"]["createEvent"]["picture"]["name"] ==
|
|
"picture for my event"
|
|
end
|
|
|
|
@upload_media_mutation """
|
|
mutation UploadMedia($name: String!, $alt: String, $file: Upload!) {
|
|
uploadMedia(
|
|
name: $name
|
|
alt: $alt
|
|
file: $file
|
|
) {
|
|
id
|
|
url
|
|
name
|
|
content_type
|
|
size
|
|
}
|
|
}
|
|
"""
|
|
|
|
test "create_event/3 creates an event with an picture ID", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
media = %{name: "my pic", alt: "represents something", file: "picture.png"}
|
|
|
|
map = %{
|
|
"query" => @upload_media_mutation,
|
|
"variables" => media,
|
|
media.file => %Plug.Upload{
|
|
path: "test/fixtures/picture.png",
|
|
filename: media.file
|
|
}
|
|
}
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> put_req_header("content-type", "multipart/form-data")
|
|
|> post(
|
|
"/api",
|
|
map
|
|
)
|
|
|> json_response(200)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["uploadMedia"]["name"] == media.name
|
|
media_id = res["data"]["uploadMedia"]["id"]
|
|
assert media_id !== "" and not is_nil(media_id)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on:
|
|
"#{DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()}",
|
|
organizer_actor_id: "#{actor.id}",
|
|
category: "PARTY",
|
|
picture: %{
|
|
media_id: "#{media_id}"
|
|
}
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["createEvent"]["title"] == "come to my event"
|
|
|
|
assert res["data"]["createEvent"]["picture"]["name"] == media.name
|
|
|
|
assert res["data"]["createEvent"]["picture"]["url"]
|
|
end
|
|
|
|
test "create_event/3 creates an event with detected language", %{
|
|
conn: conn,
|
|
actor: %Actor{id: actor_id},
|
|
user: user
|
|
} do
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "Come to my event",
|
|
description: "This should be long enough to get detected",
|
|
organizer_actor_id: actor_id,
|
|
begins_on: "2021-07-26T09:00:00Z"
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["createEvent"]["language"] == "en"
|
|
end
|
|
|
|
test "create_event/3 creates an event with manually set language", %{
|
|
conn: conn,
|
|
actor: %Actor{id: actor_id},
|
|
user: user
|
|
} do
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: %{
|
|
title: "Come to my event",
|
|
description: "This should be long enough to get detected",
|
|
organizer_actor_id: actor_id,
|
|
begins_on: "2021-07-26T09:00:00Z",
|
|
language: "it"
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["createEvent"]["language"] == "it"
|
|
end
|
|
end
|
|
|
|
describe "create_event/3 on behalf of a group" do
|
|
@variables %{
|
|
title: "come to my event",
|
|
description: "it will be fine",
|
|
begins_on: "2021-07-26T09:00:00Z"
|
|
}
|
|
|
|
test "create_event/3 should check the member has permission to create a group event", %{
|
|
conn: conn
|
|
} do
|
|
%User{} = user = insert(:user)
|
|
%Actor{id: group_id} = group = insert(:group)
|
|
|
|
%Actor{id: member_not_approved_actor_id} =
|
|
member_not_approved_actor = insert(:actor, user: user)
|
|
|
|
insert(:member, parent: group, actor: member_not_approved_actor)
|
|
%Actor{id: member_actor_id} = member_actor = insert(:actor, user: user)
|
|
insert(:member, parent: group, actor: member_actor, role: :member)
|
|
%Actor{id: moderator_actor_id} = moderator_actor = insert(:actor, user: user)
|
|
insert(:member, parent: group, actor: moderator_actor, role: :moderator)
|
|
%Actor{id: not_member_actor_id} = insert(:actor, user: user)
|
|
|
|
variables = Map.put(@variables, :attributed_to_id, "#{group_id}")
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{member_not_approved_actor_id}")
|
|
)
|
|
|
|
assert res["data"]["createEvent"] == nil
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"Organizer profile doesn't have permission to create an event on behalf of this group"
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{not_member_actor_id}")
|
|
)
|
|
|
|
assert res["data"]["createEvent"] == nil
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"Organizer profile doesn't have permission to create an event on behalf of this group"
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{member_actor_id}")
|
|
)
|
|
|
|
assert res["data"]["createEvent"] == nil
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"Organizer profile doesn't have permission to create an event on behalf of this group"
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @create_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{moderator_actor_id}")
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["createEvent"] != nil
|
|
end
|
|
end
|
|
|
|
@update_event_mutation """
|
|
mutation updateEvent(
|
|
$eventId: ID!
|
|
$title: String
|
|
$description: String
|
|
$beginsOn: DateTime
|
|
$endsOn: DateTime
|
|
$status: EventStatus
|
|
$visibility: EventVisibility
|
|
$joinOptions: EventJoinOptions
|
|
$draft: Boolean
|
|
$tags: [String]
|
|
$picture: MediaInput
|
|
$onlineAddress: String
|
|
$phoneAddress: String
|
|
$organizerActorId: ID
|
|
$attributedToId: ID
|
|
$category: EventCategory
|
|
$physicalAddress: AddressInput
|
|
$options: EventOptionsInput
|
|
$contacts: [Contact]
|
|
) {
|
|
updateEvent(
|
|
eventId: $eventId
|
|
title: $title
|
|
description: $description
|
|
beginsOn: $beginsOn
|
|
endsOn: $endsOn
|
|
status: $status
|
|
visibility: $visibility
|
|
joinOptions: $joinOptions
|
|
draft: $draft
|
|
tags: $tags
|
|
picture: $picture
|
|
onlineAddress: $onlineAddress
|
|
phoneAddress: $phoneAddress
|
|
organizerActorId: $organizerActorId
|
|
attributedToId: $attributedToId
|
|
category: $category
|
|
physicalAddress: $physicalAddress
|
|
options: $options
|
|
contacts: $contacts
|
|
) {
|
|
id,
|
|
uuid,
|
|
url,
|
|
title
|
|
draft
|
|
description
|
|
beginsOn
|
|
endsOn
|
|
status
|
|
tags {
|
|
title,
|
|
slug
|
|
},
|
|
online_address,
|
|
phone_address,
|
|
category,
|
|
options {
|
|
maximumAttendeeCapacity,
|
|
showRemainingAttendeeCapacity
|
|
},
|
|
physicalAddress {
|
|
url,
|
|
geom,
|
|
street
|
|
}
|
|
picture {
|
|
name
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
describe "update_event/3" do
|
|
test "update_event/3 should check the event exists", %{conn: conn, actor: _actor, user: user} do
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{eventId: 45, title: "my event updated"}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] == "Event not found"
|
|
end
|
|
|
|
test "update_event/3 should check the user can change the organizer", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
event = insert(:event, organizer_actor: actor)
|
|
actor2 = insert(:actor)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{eventId: event.id, title: "my event updated", organizerActorId: actor2.id}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"You can't attribute this event to this profile."
|
|
end
|
|
|
|
test "update_event/3 should check the user is the organizer", %{
|
|
conn: conn,
|
|
actor: _actor,
|
|
user: user
|
|
} do
|
|
event = insert(:event)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{eventId: event.id, title: "my event updated"}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] == "You can't edit this event."
|
|
end
|
|
|
|
test "update_event/3 should check the user is the organizer also when it's changed", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
event = insert(:event)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{eventId: event.id, title: "my event updated", organizerActorId: actor.id}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] == "You can't edit this event."
|
|
end
|
|
|
|
test "update_event/3 should check end time is after the beginning time", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
event = insert(:event, organizer_actor: actor)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{
|
|
eventId: event.id,
|
|
title: "my event updated",
|
|
endsOn: event.begins_on |> DateTime.add(3600 * -2) |> DateTime.to_iso8601()
|
|
}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
["ends_on cannot be set before begins_on"]
|
|
end
|
|
|
|
test "updates an event", %{conn: conn, actor: actor, user: user} do
|
|
%Event{uuid: event_uuid, title: event_title} =
|
|
event = insert(:event, organizer_actor: actor)
|
|
|
|
creator = insert(:participant, event: event, actor: actor, role: :creator)
|
|
participant_user = insert(:user)
|
|
participant_actor = insert(:actor, user: participant_user)
|
|
|
|
participant =
|
|
insert(:participant, event: event, actor: participant_actor, role: :participant)
|
|
|
|
address = insert(:address)
|
|
|
|
begins_on = DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
|
|
ends_on = DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{
|
|
eventId: event.id,
|
|
title: "my event updated",
|
|
description: "description updated",
|
|
beginsOn: "#{begins_on}",
|
|
endsOn: "#{ends_on}",
|
|
status: "TENTATIVE",
|
|
tags: ["tag1_updated", "tag2_updated"],
|
|
onlineAddress: "toto@example.com",
|
|
phoneAddress: "0000000000",
|
|
category: "PARTY",
|
|
options: %{
|
|
maximumAttendeeCapacity: 30,
|
|
showRemainingAttendeeCapacity: true
|
|
},
|
|
physicalAddress: %{
|
|
street: "#{address.street}",
|
|
locality: "#{address.locality}"
|
|
}
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
|
|
event_res = res["data"]["updateEvent"]
|
|
|
|
assert event_res["title"] == "my event updated"
|
|
assert event_res["description"] == "description updated"
|
|
assert event_res["beginsOn"] == "#{begins_on}"
|
|
assert event_res["endsOn"] == "#{ends_on}"
|
|
assert event_res["status"] == "TENTATIVE"
|
|
assert event_res["online_address"] == "toto@example.com"
|
|
assert event_res["phone_address"] == "0000000000"
|
|
assert event_res["category"] == "PARTY"
|
|
|
|
assert event_res["options"]["maximumAttendeeCapacity"] == 30
|
|
assert event_res["options"]["showRemainingAttendeeCapacity"] == true
|
|
|
|
assert event_res["uuid"] == event.uuid
|
|
assert event_res["url"] == event.url
|
|
|
|
assert event_res["physicalAddress"]["street"] == address.street
|
|
refute event_res["physicalAddress"]["url"] == address.url
|
|
|
|
assert event_res["tags"] == [
|
|
%{"slug" => "tag1-updated", "title" => "tag1_updated"},
|
|
%{"slug" => "tag2-updated", "title" => "tag2_updated"}
|
|
]
|
|
|
|
{event_id_int, ""} = Integer.parse(event_res["id"])
|
|
|
|
assert_enqueued(
|
|
worker: Workers.BuildSearch,
|
|
args: %{event_id: event_id_int, op: :update_search_event}
|
|
)
|
|
|
|
assert [
|
|
%{
|
|
args: %{
|
|
"event_uuid" => ^event_uuid,
|
|
"action" => "notify_of_event_update",
|
|
"old_event" => %{
|
|
"title" => ^event_title
|
|
},
|
|
"changes" => %{
|
|
"description" => "description updated",
|
|
"status" => "tentative",
|
|
"title" => "my event updated"
|
|
}
|
|
}
|
|
}
|
|
] = all_enqueued(worker: Workers.EventDelayedNotificationWorker)
|
|
|
|
Oban.drain_queue(queue: :default, with_scheduled: true)
|
|
|
|
{:ok, new_event} = Mobilizon.Events.get_event_with_preload(event.id)
|
|
|
|
assert_delivered_email(
|
|
Email.Event.event_updated(
|
|
user.email,
|
|
creator,
|
|
actor,
|
|
event,
|
|
new_event,
|
|
MapSet.new([:title, :begins_on, :ends_on, :status, :physical_address]),
|
|
"Etc/UTC",
|
|
"en"
|
|
)
|
|
)
|
|
|
|
assert_delivered_email(
|
|
Email.Event.event_updated(
|
|
participant_user.email,
|
|
participant,
|
|
participant_actor,
|
|
event,
|
|
new_event,
|
|
MapSet.new([:title, :begins_on, :ends_on, :status, :physical_address]),
|
|
"Etc/UTC",
|
|
"en"
|
|
)
|
|
)
|
|
end
|
|
|
|
test "update_event/3 updates an event with a new picture", %{
|
|
conn: conn,
|
|
actor: actor,
|
|
user: user
|
|
} do
|
|
event = insert(:event, organizer_actor: actor)
|
|
|
|
begins_on =
|
|
event.begins_on
|
|
|> DateTime.add(3 * 3600)
|
|
|> DateTime.truncate(:second)
|
|
|> DateTime.to_iso8601()
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> put_req_header("content-type", "multipart/form-data")
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{
|
|
eventId: event.id,
|
|
title: "my event updated",
|
|
description: "description updated",
|
|
beginsOn: "#{begins_on}",
|
|
category: "PARTY",
|
|
picture: %{
|
|
media: %{
|
|
name: "picture for my event",
|
|
alt: "A very sunny landscape",
|
|
file: "event.jpg",
|
|
actorId: "#{actor.id}"
|
|
}
|
|
}
|
|
},
|
|
uploads: %{
|
|
"event.jpg" => %Plug.Upload{
|
|
path: "test/fixtures/picture.png",
|
|
filename: "event.jpg"
|
|
}
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["updateEvent"]["title"] == "my event updated"
|
|
assert res["data"]["updateEvent"]["uuid"] == event.uuid
|
|
assert res["data"]["updateEvent"]["url"] == event.url
|
|
|
|
assert res["data"]["updateEvent"]["beginsOn"] ==
|
|
event.begins_on |> DateTime.add(3 * 3600) |> DateTime.to_iso8601()
|
|
|
|
assert res["data"]["updateEvent"]["picture"]["name"] ==
|
|
"picture for my event"
|
|
end
|
|
|
|
@person_participations_query """
|
|
query EventPersonParticipation($actorId: ID!, $eventId: ID!) {
|
|
person(id: $actorId) {
|
|
id
|
|
participations(eventId: $eventId) {
|
|
total
|
|
elements {
|
|
role
|
|
actor {
|
|
id
|
|
}
|
|
event {
|
|
id
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
test "respects the draft status", %{conn: conn, actor: actor, user: user} do
|
|
event = insert(:event, organizer_actor: actor, draft: true)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{
|
|
eventId: event.id,
|
|
title: "my event updated but still draft",
|
|
draft: true
|
|
}
|
|
)
|
|
|
|
assert res["data"]["updateEvent"]["draft"] == true
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @find_event_query,
|
|
variables: %{
|
|
uuid: event.uuid
|
|
}
|
|
)
|
|
|
|
assert hd(res["errors"])["message"] =~ "not found"
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @find_event_query,
|
|
variables: %{
|
|
uuid: event.uuid
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["event"]["draft"] == true
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @person_participations_query,
|
|
variables: %{
|
|
eventId: event.id,
|
|
actorId: actor.id
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["person"]["participations"]["elements"] == []
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: %{
|
|
eventId: event.id,
|
|
title: "my event updated and no longer draft",
|
|
draft: false
|
|
}
|
|
)
|
|
|
|
assert res["data"]["updateEvent"]["draft"] == false
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @find_event_query,
|
|
variables: %{
|
|
uuid: event.uuid
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["event"]["draft"] == false
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @person_participations_query,
|
|
variables: %{
|
|
eventId: event.id,
|
|
actorId: actor.id
|
|
}
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
|
|
assert res["data"]["person"]["participations"]["elements"] == [
|
|
%{
|
|
"actor" => %{"id" => to_string(actor.id)},
|
|
"event" => %{"id" => to_string(event.id)},
|
|
"role" => "CREATOR"
|
|
}
|
|
]
|
|
end
|
|
end
|
|
|
|
describe "update_event/3 on behalf of a group" do
|
|
test "should check the member has permission to update a group event", %{
|
|
conn: conn
|
|
} do
|
|
%User{} = user = insert(:user)
|
|
%Actor{id: group_id} = group = insert(:group)
|
|
|
|
%Actor{id: member_not_approved_actor_id} =
|
|
member_not_approved_actor = insert(:actor, user: user)
|
|
|
|
insert(:member, parent: group, actor: member_not_approved_actor)
|
|
%Actor{id: member_actor_id} = member_actor = insert(:actor, user: user)
|
|
insert(:member, parent: group, actor: member_actor, role: :member)
|
|
%Actor{id: moderator_actor_id} = moderator_actor = insert(:actor, user: user)
|
|
insert(:member, parent: group, actor: moderator_actor, role: :moderator)
|
|
|
|
%Actor{} = administrator_actor = insert(:actor, user: user)
|
|
insert(:member, parent: group, actor: administrator_actor, role: :administrator)
|
|
|
|
%Actor{id: not_member_actor_id} = not_member_actor = insert(:actor, user: user)
|
|
|
|
%Event{} =
|
|
event = insert(:event, attributed_to: group, organizer_actor: administrator_actor)
|
|
|
|
variables =
|
|
@variables
|
|
|> Map.put(:attributed_to_id, "#{group_id}")
|
|
|> Map.put(:eventId, to_string(event.id))
|
|
|
|
Users.update_user_default_actor(user, member_not_approved_actor)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{member_not_approved_actor_id}")
|
|
)
|
|
|
|
assert res["data"]["updateEvent"] == nil
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"This profile doesn't have permission to update an event on behalf of this group"
|
|
|
|
Users.update_user_default_actor(user, not_member_actor)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{not_member_actor_id}")
|
|
)
|
|
|
|
assert res["data"]["updateEvent"] == nil
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"This profile doesn't have permission to update an event on behalf of this group"
|
|
|
|
Users.update_user_default_actor(user, member_actor)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{member_actor_id}")
|
|
)
|
|
|
|
assert res["data"]["updateEvent"] == nil
|
|
|
|
assert hd(res["errors"])["message"] ==
|
|
"This profile doesn't have permission to update an event on behalf of this group"
|
|
|
|
Users.update_user_default_actor(user, moderator_actor)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @update_event_mutation,
|
|
variables: Map.put(variables, :organizer_actor_id, "#{moderator_actor_id}")
|
|
)
|
|
|
|
assert res["errors"] == nil
|
|
assert res["data"]["updateEvent"] != nil
|
|
end
|
|
end
|
|
|
|
describe "list_events/3" do
|
|
@fetch_events_query """
|
|
query Events($page: Int, $limit: Int) {
|
|
events(page: $page, limit: $limit) {
|
|
total
|
|
elements {
|
|
uuid
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
test "list_events/3 returns events", %{conn: conn} do
|
|
event = insert(:event)
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(query: @fetch_events_query)
|
|
|
|
assert res["data"]["events"]["elements"] |> Enum.map(& &1["uuid"]) == [
|
|
event.uuid
|
|
]
|
|
|
|
insert(:event)
|
|
insert(:event)
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @fetch_events_query,
|
|
variables: %{page: 1, limit: 2}
|
|
)
|
|
|
|
assert res["data"]["events"]["total"] == 3
|
|
assert res["data"]["events"]["elements"] |> length == 2
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @fetch_events_query,
|
|
variables: %{page: 2, limit: 2}
|
|
)
|
|
|
|
assert res["data"]["events"]["total"] == 3
|
|
assert res["data"]["events"]["elements"] |> length == 1
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(
|
|
query: @fetch_events_query,
|
|
variables: %{page: 3, limit: 2}
|
|
)
|
|
|
|
assert res["data"]["events"]["total"] == 3
|
|
assert res["data"]["events"]["elements"] |> length == 0
|
|
end
|
|
|
|
test "list_events/3 doesn't list private events", %{conn: conn} do
|
|
insert(:event, visibility: :private)
|
|
insert(:event, visibility: :unlisted)
|
|
insert(:event, visibility: :restricted)
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(query: @fetch_events_query)
|
|
|
|
assert res["data"]["events"]["total"] == 0
|
|
assert res["data"]["events"]["elements"] |> Enum.map(& &1["uuid"]) == []
|
|
end
|
|
|
|
test "list_events/3 doesn't list draft events", %{conn: conn} do
|
|
insert(:event, visibility: :public, draft: true)
|
|
|
|
res =
|
|
conn
|
|
|> AbsintheHelpers.graphql_query(query: @fetch_events_query)
|
|
|
|
assert res["data"]["events"]["total"] == 0
|
|
assert res["data"]["events"]["elements"] |> Enum.map(& &1["uuid"]) == []
|
|
end
|
|
|
|
test "find_event/3 returns an unlisted event", context do
|
|
event = insert(:event, visibility: :unlisted)
|
|
|
|
query = """
|
|
{
|
|
event(uuid: "#{event.uuid}") {
|
|
uuid,
|
|
}
|
|
}
|
|
"""
|
|
|
|
res =
|
|
context.conn
|
|
|> get("/api", AbsintheHelpers.query_skeleton(query, "event"))
|
|
|
|
assert json_response(res, 200)["data"]["event"]["uuid"] == to_string(event.uuid)
|
|
end
|
|
|
|
# test "find_event/3 doesn't return a private event", context do
|
|
# event = insert(:event, visibility: :private)
|
|
#
|
|
# query = """
|
|
# {
|
|
# event(uuid: "#{event.uuid}") {
|
|
# uuid,
|
|
# }
|
|
# }
|
|
# """
|
|
#
|
|
# res =
|
|
# context.conn
|
|
# |> get("/api", AbsintheHelpers.query_skeleton(query, "event"))
|
|
#
|
|
# assert json_response(res, 200)["errors"] |> hd |> Map.get("message") ==
|
|
# "Event with UUID #{event.uuid} not found"
|
|
# end
|
|
end
|
|
|
|
describe "delete_event/3" do
|
|
test "delete_event/3 deletes an event", %{conn: conn, user: user, actor: actor} do
|
|
event = insert(:event, organizer_actor: actor)
|
|
|
|
mutation = """
|
|
mutation {
|
|
deleteEvent(
|
|
event_id: #{event.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"]["deleteEvent"]["id"] == to_string(event.id)
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
|
|
|
|
assert hd(json_response(res, 200)["errors"])["message"] =~ "not found"
|
|
end
|
|
|
|
test "delete_event/3 should check the user is authenticated", %{conn: conn, actor: actor} do
|
|
event = insert(:event, organizer_actor: actor)
|
|
|
|
mutation = """
|
|
mutation {
|
|
deleteEvent(
|
|
event_id: #{event.id}
|
|
) {
|
|
id
|
|
}
|
|
}
|
|
"""
|
|
|
|
res =
|
|
conn
|
|
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
|
|
|
|
assert hd(json_response(res, 200)["errors"])["message"] =~ "logged-in"
|
|
end
|
|
|
|
test "delete_event/3 should check the event can be deleted by the user", %{
|
|
conn: conn,
|
|
user: user,
|
|
actor: _actor
|
|
} do
|
|
actor2 = insert(:actor)
|
|
event = insert(:event, organizer_actor: actor2)
|
|
|
|
mutation = """
|
|
mutation {
|
|
deleteEvent(
|
|
event_id: #{event.id}
|
|
) {
|
|
id
|
|
}
|
|
}
|
|
"""
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user)
|
|
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
|
|
|
|
assert hd(json_response(res, 200)["errors"])["message"] =~ "cannot delete"
|
|
end
|
|
|
|
test "delete_event/3 allows a event being deleted by a moderator and creates a entry in actionLogs",
|
|
%{
|
|
conn: conn,
|
|
user: _user,
|
|
actor: _actor
|
|
} do
|
|
user_moderator = insert(:user, role: :moderator)
|
|
actor_moderator = insert(:actor, user: user_moderator)
|
|
|
|
actor2 = insert(:actor)
|
|
event = insert(:event, organizer_actor: actor2)
|
|
|
|
mutation = """
|
|
mutation {
|
|
deleteEvent(
|
|
event_id: #{event.id}
|
|
) {
|
|
id
|
|
}
|
|
}
|
|
"""
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user_moderator)
|
|
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
|
|
|
|
assert json_response(res, 200)["data"]["deleteEvent"]["id"] == to_string(event.id)
|
|
|
|
query = """
|
|
{
|
|
actionLogs {
|
|
total
|
|
elements {
|
|
action,
|
|
actor {
|
|
preferredUsername
|
|
},
|
|
object {
|
|
... on Report {
|
|
id,
|
|
status
|
|
},
|
|
... on ReportNote {
|
|
content
|
|
}
|
|
... on Event {
|
|
id,
|
|
title
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
res =
|
|
conn
|
|
|> auth_conn(user_moderator)
|
|
|> get("/api", AbsintheHelpers.query_skeleton(query, "actionLogs"))
|
|
|
|
assert hd(json_response(res, 200)["data"]["actionLogs"]["elements"]) == %{
|
|
"action" => "EVENT_DELETION",
|
|
"actor" => %{"preferredUsername" => actor_moderator.preferred_username},
|
|
"object" => %{"title" => event.title, "id" => to_string(event.id)}
|
|
}
|
|
end
|
|
end
|
|
|
|
describe "list_related_events/3" do
|
|
test "list_related_events/3 should give related events", %{
|
|
conn: conn,
|
|
actor: actor
|
|
} do
|
|
tag1 = insert(:tag, title: "Elixir", slug: "elixir")
|
|
tag2 = insert(:tag, title: "PostgreSQL", slug: "postgresql")
|
|
|
|
event = insert(:event, title: "Initial event", organizer_actor: actor, tags: [tag1, tag2])
|
|
|
|
event2 =
|
|
insert(:event,
|
|
title: "Event from same actor",
|
|
organizer_actor: actor,
|
|
visibility: :public,
|
|
begins_on: Timex.shift(DateTime.utc_now(), days: 3)
|
|
)
|
|
|
|
event3 =
|
|
insert(:event,
|
|
title: "Event with same tags",
|
|
tags: [tag1, tag2],
|
|
visibility: :public,
|
|
begins_on: Timex.shift(DateTime.utc_now(), days: 3)
|
|
)
|
|
|
|
query = """
|
|
{
|
|
event(uuid: "#{event.uuid}") {
|
|
uuid,
|
|
title,
|
|
tags {
|
|
id
|
|
},
|
|
related_events {
|
|
uuid,
|
|
title,
|
|
tags {
|
|
id
|
|
}
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
res =
|
|
conn
|
|
|> get("/api", AbsintheHelpers.query_skeleton(query, "event"))
|
|
|
|
assert hd(json_response(res, 200)["data"]["event"]["related_events"])["uuid"] == event2.uuid
|
|
|
|
assert hd(tl(json_response(res, 200)["data"]["event"]["related_events"]))["uuid"] ==
|
|
event3.uuid
|
|
end
|
|
end
|
|
end
|