From 5b3831b4bf8a9ad9c06e045784e08b327609a01a Mon Sep 17 00:00:00 2001
From: Thomas Citharel <tcit@tcit.fr>
Date: Fri, 31 May 2019 17:58:03 +0200
Subject: [PATCH] Attach actor to pictures entity

---
 js/src/components/Editor.vue                  |   14 +-
 js/src/components/Editor/Image.ts             |    3 +
 js/src/graphql/upload.ts                      |    4 +-
 lib/mobilizon/media/picture.ex                |    4 +-
 lib/mobilizon/users/user.ex                   |   12 +
 lib/mobilizon_web/resolvers/picture.ex        |   14 +-
 lib/mobilizon_web/router.ex                   |    2 +-
 lib/mobilizon_web/schema/picture.ex           |    2 +
 lib/service/activity_pub/utils.ex             |   13 +-
 ...190531131458_attach-pictures-to-actors.exs |    9 +
 schema.graphql                                | 1320 +++++++----------
 test/mobilizon/media/media_test.exs           |   11 +-
 .../resolvers/event_resolver_test.exs         |    6 +-
 .../resolvers/picture_resolver_test.exs       |   13 +-
 test/support/factory.ex                       |    3 +-
 15 files changed, 645 insertions(+), 785 deletions(-)
 create mode 100644 priv/repo/migrations/20190531131458_attach-pictures-to-actors.exs

diff --git a/js/src/components/Editor.vue b/js/src/components/Editor.vue
index a40f5640e..afb05a604 100644
--- a/js/src/components/Editor.vue
+++ b/js/src/components/Editor.vue
@@ -1,6 +1,6 @@
 <template>
     <div>
-    <div class="editor">
+    <div class="editor" id="tiptab-editor" :data-actor-id="loggedPerson && loggedPerson.id">
         <editor-menu-bar :editor="editor" v-slot="{ commands, isActive, focused }">
             <div class="menubar bar-is-hidden" :class="{ 'is-focused': focused }">
 
@@ -172,16 +172,25 @@ import {
 } from 'tiptap-extensions';
 import tippy, { Instance } from 'tippy.js';
 import { SEARCH_PERSONS } from '@/graphql/search';
-import { IActor } from '@/types/actor';
+import { IActor, IPerson } from '@/types/actor';
 import Image from '@/components/Editor/Image';
 import { UPLOAD_PICTURE } from '@/graphql/upload';
 import { listenFileUpload } from '@/utils/upload';
+import { LOGGED_PERSON } from '@/graphql/actor';
 
 @Component({
   components: { EditorContent, EditorMenuBar, EditorMenuBubble },
+  apollo: {
+    loggedPerson: {
+      query: LOGGED_PERSON,
+    },
+  },
 })
 export default class CreateEvent extends Vue {
   @Prop({ required: true }) value!: String;
+
+  loggedPerson!: IPerson;
+
   editor: Editor = null;
 
     /**
@@ -429,6 +438,7 @@ export default class CreateEvent extends Vue {
       variables: {
         file: image,
         name: image.name,
+        actorId: this.loggedPerson.id,
       },
     });
     if (data.uploadPicture && data.uploadPicture.url) {
diff --git a/js/src/components/Editor/Image.ts b/js/src/components/Editor/Image.ts
index 26304776c..b17d64edb 100644
--- a/js/src/components/Editor/Image.ts
+++ b/js/src/components/Editor/Image.ts
@@ -71,11 +71,14 @@ export default class Image extends Node {
               const { schema } = view.state;
               const coordinates = view.posAtCoords({ left: event.clientX, top: event.clientY });
               const client = apolloProvider.defaultClient as ApolloClient<InMemoryCache>;
+              const editorElem = document.getElementById('tiptab-editor');
+              const actorId = editorElem && editorElem.dataset.actorId;
 
               for (const image of images) {
                 const { data } = await client.mutate({
                   mutation: UPLOAD_PICTURE,
                   variables: {
+                    actorId,
                     file: image,
                     name: image.name,
                   },
diff --git a/js/src/graphql/upload.ts b/js/src/graphql/upload.ts
index 490e08389..05fda76f8 100644
--- a/js/src/graphql/upload.ts
+++ b/js/src/graphql/upload.ts
@@ -1,8 +1,8 @@
 import gql from 'graphql-tag';
 
 export const UPLOAD_PICTURE = gql`
-    mutation UploadPicture($file: Upload!, $alt: String, $name: String!){
-        uploadPicture(file: $file, alt: $alt, name: $name) {
+    mutation UploadPicture($file: Upload!, $alt: String, $name: String!, $actorId: ID!){
+        uploadPicture(file: $file, alt: $alt, name: $name, actorId: $actorId) {
             url,
             id
         }
diff --git a/lib/mobilizon/media/picture.ex b/lib/mobilizon/media/picture.ex
index de1c24287..62b811894 100644
--- a/lib/mobilizon/media/picture.ex
+++ b/lib/mobilizon/media/picture.ex
@@ -5,9 +5,11 @@ defmodule Mobilizon.Media.Picture do
   use Ecto.Schema
   import Ecto.Changeset
   alias Mobilizon.Media.File
+  alias Mobilizon.Actors.Actor
 
   schema "pictures" do
     embeds_one(:file, File, on_replace: :update)
+    belongs_to(:actor, Actor)
 
     timestamps()
   end
@@ -15,7 +17,7 @@ defmodule Mobilizon.Media.Picture do
   @doc false
   def changeset(picture, attrs) do
     picture
-    |> cast(attrs, [])
+    |> cast(attrs, [:actor_id])
     |> cast_embed(:file)
   end
 end
diff --git a/lib/mobilizon/users/user.ex b/lib/mobilizon/users/user.ex
index cd31a29f4..449f4b1cb 100644
--- a/lib/mobilizon/users/user.ex
+++ b/lib/mobilizon/users/user.ex
@@ -149,6 +149,18 @@ defmodule Mobilizon.Users.User do
   def is_confirmed(%User{confirmed_at: nil} = _user), do: {:error, :unconfirmed}
   def is_confirmed(%User{} = user), do: {:ok, user}
 
+  @doc """
+  Returns whether an user owns an actor
+  """
+  @spec owns_actor(struct(), String.t()) :: {:is_owned, false} | {:is_owned, true, Actor.t()}
+  def owns_actor(%User{} = user, actor_id) when is_binary(actor_id) do
+    case Integer.parse(actor_id) do
+      {actor_id, ""} -> owns_actor(user, actor_id)
+      _ -> {:is_owned, false}
+    end
+  end
+
+  @spec owns_actor(struct(), integer()) :: {:is_owned, false} | {:is_owned, true, Actor.t()}
   def owns_actor(%User{actors: actors}, actor_id) do
     case Enum.find(actors, fn a -> a.id == actor_id end) do
       nil -> {:is_owned, false}
diff --git a/lib/mobilizon_web/resolvers/picture.ex b/lib/mobilizon_web/resolvers/picture.ex
index 37cd91285..18c0caa59 100644
--- a/lib/mobilizon_web/resolvers/picture.ex
+++ b/lib/mobilizon_web/resolvers/picture.ex
@@ -4,6 +4,7 @@ defmodule MobilizonWeb.Resolvers.Picture do
   """
   alias Mobilizon.Media
   alias Mobilizon.Media.Picture
+  alias Mobilizon.Users.User
 
   @doc """
   Get picture for an event's pic
@@ -43,16 +44,21 @@ defmodule MobilizonWeb.Resolvers.Picture do
   end
 
   @spec upload_picture(map(), map(), map()) :: {:ok, Picture.t()} | {:error, any()}
-  def upload_picture(_parent, %{file: %Plug.Upload{} = file} = args, %{
+  def upload_picture(_parent, %{file: %Plug.Upload{} = file, actor_id: actor_id} = args, %{
         context: %{
-          current_user: _user
+          current_user: user
         }
       }) do
-    with {:ok, %{"url" => [%{"href" => url}]}} <- MobilizonWeb.Upload.store(file),
+    with {:is_owned, true, _actor} <- User.owns_actor(user, actor_id),
+         {:ok, %{"url" => [%{"href" => url}]}} <- MobilizonWeb.Upload.store(file),
          args <- Map.put(args, :url, url),
-         {:ok, picture = %Picture{}} <- Media.create_picture(%{"file" => args}) do
+         {:ok, picture = %Picture{}} <-
+           Media.create_picture(%{"file" => args, "actor_id" => actor_id}) do
       {:ok, %{name: picture.file.name, url: picture.file.url, id: picture.id}}
     else
+      {:is_owned, false} ->
+        {:error, "Actor id is not owned by authenticated user"}
+
       err ->
         {:error, err}
     end
diff --git a/lib/mobilizon_web/router.ex b/lib/mobilizon_web/router.ex
index e70a0ccbb..3d57a7ff8 100644
--- a/lib/mobilizon_web/router.ex
+++ b/lib/mobilizon_web/router.ex
@@ -31,7 +31,7 @@ defmodule MobilizonWeb.Router do
   end
 
   pipeline :browser do
-    plug(Plug.Static, at: "/", from: "priv/static")
+    plug(Plug.Static, at: "/", from: "priv/static/js")
     plug(:accepts, ["html"])
     plug(:fetch_session)
     plug(:fetch_flash)
diff --git a/lib/mobilizon_web/schema/picture.ex b/lib/mobilizon_web/schema/picture.ex
index 980149d4b..d14b3ebf3 100644
--- a/lib/mobilizon_web/schema/picture.ex
+++ b/lib/mobilizon_web/schema/picture.ex
@@ -26,6 +26,7 @@ defmodule MobilizonWeb.Schema.PictureType do
     field(:name, non_null(:string))
     field(:alt, :string)
     field(:file, non_null(:upload))
+    field(:actor_id, :id)
   end
 
   object :picture_queries do
@@ -42,6 +43,7 @@ defmodule MobilizonWeb.Schema.PictureType do
       arg(:name, non_null(:string))
       arg(:alt, :string)
       arg(:file, non_null(:upload))
+      arg(:actor_id, non_null(:id))
       resolve(&Picture.upload_picture/3)
     end
   end
diff --git a/lib/service/activity_pub/utils.ex b/lib/service/activity_pub/utils.ex
index 163fe8eb4..1e81d1291 100644
--- a/lib/service/activity_pub/utils.ex
+++ b/lib/service/activity_pub/utils.ex
@@ -176,6 +176,9 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
   #    Repo.one(query)
   #  end
 
+  @doc """
+  Save picture data from %Plug.Upload{} and return AS Link data.
+  """
   def make_picture_data(%Plug.Upload{} = picture) do
     with {:ok, picture} <- MobilizonWeb.Upload.store(picture) do
       picture
@@ -184,6 +187,10 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
     end
   end
 
+  @doc """
+  Convert a picture model into an AS Link representation
+  """
+  # TODO: Move me to Mobilizon.Service.ActivityPub.Converters
   def make_picture_data(%Picture{file: file} = _picture) do
     %{
       "type" => "Document",
@@ -198,6 +205,9 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
     }
   end
 
+  @doc """
+  Save picture data from raw data and return AS Link data.
+  """
   def make_picture_data(%{picture: picture}) do
     with {:ok, %{"url" => [%{"href" => url}]}} <- MobilizonWeb.Upload.store(picture.file),
          {:ok, %Picture{file: _file} = pic} <-
@@ -205,7 +215,8 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
              "file" => %{
                "url" => url,
                "name" => picture.name
-             }
+             },
+             "actor_id" => picture.actor_id
            }) do
       make_picture_data(pic)
     end
diff --git a/priv/repo/migrations/20190531131458_attach-pictures-to-actors.exs b/priv/repo/migrations/20190531131458_attach-pictures-to-actors.exs
new file mode 100644
index 000000000..08b430ba5
--- /dev/null
+++ b/priv/repo/migrations/20190531131458_attach-pictures-to-actors.exs
@@ -0,0 +1,9 @@
+defmodule :"Elixir.Mobilizon.Repo.Migrations.Attach-pictures-to-actors" do
+  use Ecto.Migration
+
+  def change do
+    alter table(:pictures) do
+      add(:actor_id, references(:actors, on_delete: :delete_all), null: false)
+    end
+  end
+end
diff --git a/schema.graphql b/schema.graphql
index adcb5231f..bf8c681c8 100644
--- a/schema.graphql
+++ b/schema.graphql
@@ -1,869 +1,663 @@
-# source: http://localhost:4000/api
-# timestamp: Thu May 02 2019 16:24:47 GMT+0200 (GMT+02:00)
+# This file was generated based on ".graphqlconfig.yaml". Do not edit manually.
 
 schema {
-  query: RootQueryType
-  mutation: RootMutationType
+    query: RootQueryType
+    mutation: RootMutationType
 }
 
-"""An ActivityPub actor"""
+"An ActivityPub actor"
 interface Actor {
-  """The actor's avatar picture"""
-  avatar: Picture
-
-  """The actor's banner picture"""
-  banner: Picture
-
-  """The actor's domain if (null if it's this instance)"""
-  domain: String
-
-  """List of followers"""
-  followers: [Follower]
-
-  """Number of followers for this actor"""
-  followersCount: Int
-
-  """List of followings"""
-  following: [Follower]
-
-  """Number of actors following this actor"""
-  followingCount: Int
-
-  """Internal ID for this actor"""
-  id: Int
-
-  """The actors RSA Keys"""
-  keys: String
-
-  """If the actor is from this instance"""
-  local: Boolean
-
-  """Whether the actors manually approves followers"""
-  manuallyApprovesFollowers: Boolean
-
-  """The actor's displayed name"""
-  name: String
-
-  """A list of the events this actor has organized"""
-  organizedEvents: [Event]
-
-  """The actor's preferred username"""
-  preferredUsername: String
-
-  """The actor's summary"""
-  summary: String
-
-  """If the actor is suspended"""
-  suspended: Boolean
-
-  """The type of Actor (Person, Group,…)"""
-  type: ActorType
-
-  """The ActivityPub actor's URL"""
-  url: String
-}
-
-"""The list of types an actor can be"""
-enum ActorType {
-  """An ActivityPub Application"""
-  APPLICATION
-
-  """An ActivityPub Group"""
-  GROUP
-
-  """An ActivityPub Organization"""
-  ORGANIZATION
-
-  """An ActivityPub Person"""
-  PERSON
-
-  """An ActivityPub Service"""
-  SERVICE
+    "The actor's avatar picture"
+    avatar: Picture
+    "The actor's banner picture"
+    banner: Picture
+    "The actor's domain if (null if it's this instance)"
+    domain: String
+    "List of followers"
+    followers: [Follower]
+    "Number of followers for this actor"
+    followersCount: Int
+    "List of followings"
+    following: [Follower]
+    "Number of actors following this actor"
+    followingCount: Int
+    "Internal ID for this actor"
+    id: Int
+    "The actors RSA Keys"
+    keys: String
+    "If the actor is from this instance"
+    local: Boolean
+    "Whether the actors manually approves followers"
+    manuallyApprovesFollowers: Boolean
+    "The actor's displayed name"
+    name: String
+    "A list of the events this actor has organized"
+    organizedEvents: [Event]
+    "The actor's preferred username"
+    preferredUsername: String
+    "The actor's summary"
+    summary: String
+    "If the actor is suspended"
+    suspended: Boolean
+    "The type of Actor (Person, Group,…)"
+    type: ActorType
+    "The ActivityPub actor's URL"
+    url: String
 }
 
 type Address {
-  country: String
-  description: String
-
-  """The floor this event is at"""
-  floor: String
-
-  """The geocoordinates for the point where this address is"""
-  geom: Point
-
-  """The address's locality"""
-  locality: String
-  postalCode: String
-  region: String
-
-  """The address's street name (with number)"""
-  street: String
+    country: String
+    description: String
+    "The floor this event is at"
+    floor: String
+    "The geocoordinates for the point where this address is"
+    geom: Point
+    "The address's locality"
+    locality: String
+    postalCode: String
+    region: String
+    "The address's street name (with number)"
+    street: String
 }
 
-"""A comment"""
+"A comment"
 type Comment {
-  """Internal ID for this comment"""
-  id: ID
-  local: Boolean
-  primaryLanguage: String
-  replies: [Comment]
-  text: String
-  threadLanguages: [String]!
-  url: String
-  uuid: UUID
-  visibility: CommentVisibility
+    "Internal ID for this comment"
+    id: ID
+    local: Boolean
+    primaryLanguage: String
+    replies: [Comment]
+    text: String
+    threadLanguages: [String]!
+    url: String
+    uuid: UUID
+    visibility: CommentVisibility
 }
 
-"""The list of visibility options for a comment"""
-enum CommentVisibility {
-  """visible only to people invited"""
-  INVITE
-
-  """Visible only after a moderator accepted"""
-  MODERATED
-
-  """Visible only to people members of the group or followers of the person"""
-  PRIVATE
-
-  """Publically listed and federated. Can be shared."""
-  PUBLIC
-
-  """Visible only to people with the link - or invited"""
-  UNLISTED
-}
-
-"""A config object"""
+"A config object"
 type Config {
-  description: String
-  name: String
-  registrationsOpen: Boolean
+    description: String
+    name: String
+    registrationsOpen: Boolean
 }
 
-"""
-The `DateTime` scalar type represents a date and time in the UTC
-timezone. The DateTime appears in a JSON response as an ISO8601 formatted
-string, including UTC timezone ("Z"). The parsed date and time string will
-be converted to UTC and any UTC offset other than 0 will be rejected.
-"""
-scalar DateTime
-
-"""Represents a deleted feed_token"""
+"Represents a deleted feed_token"
 type DeletedFeedToken {
-  actor: DeletedObject
-  user: DeletedObject
+    actor: DeletedObject
+    user: DeletedObject
 }
 
-"""Represents a deleted member"""
+"Represents a deleted member"
 type DeletedMember {
-  actor: DeletedObject
-  parent: DeletedObject
+    actor: DeletedObject
+    parent: DeletedObject
 }
 
-"""A struct containing the id of the deleted object"""
+"A struct containing the id of the deleted object"
 type DeletedObject {
-  id: Int
+    id: Int
 }
 
-"""Represents a deleted participant"""
+"Represents a deleted participant"
 type DeletedParticipant {
-  actor: DeletedObject
-  event: DeletedObject
+    actor: DeletedObject
+    event: DeletedObject
 }
 
-"""An event"""
+"An event"
 type Event {
-  """Who the event is attributed to (often a group)"""
-  attributedTo: Actor
-
-  """Datetime for when the event begins"""
-  beginsOn: DateTime
-
-  """The event's category"""
-  category: String
-
-  """When the event was created"""
-  createdAt: DateTime
-
-  """The event's description"""
-  description: String
-
-  """Datetime for when the event ends"""
-  endsOn: DateTime
-
-  """Internal ID for this event"""
-  id: Int
-
-  """Whether the event is local or not"""
-  local: Boolean
-
-  """Online address of the event"""
-  onlineAddress: OnlineAddress
-
-  """The event's organizer (as a person)"""
-  organizerActor: Actor
-
-  """The event's participants"""
-  participants: [Participant]
-
-  """Phone address for the event"""
-  phoneAddress: PhoneAddress
-
-  """The type of the event's address"""
-  physicalAddress: Address
-
-  """The event's picture"""
-  picture: Picture
-
-  """When the event was published"""
-  publishAt: DateTime
-
-  """Events related to this one"""
-  relatedEvents: [Event]
-
-  """The event's description's slug"""
-  slug: String
-
-  """Status of the event"""
-  status: EventStatus
-
-  """The event's tags"""
-  tags: [Tag]
-
-  """The event's title"""
-  title: String
-
-  """When the event was last updated"""
-  updatedAt: DateTime
-
-  """The ActivityPub Event URL"""
-  url: String
-
-  """The Event UUID"""
-  uuid: UUID
-
-  """The event's visibility"""
-  visibility: EventVisibility
+    "Who the event is attributed to (often a group)"
+    attributedTo: Actor
+    "Datetime for when the event begins"
+    beginsOn: DateTime
+    "The event's category"
+    category: String
+    "When the event was created"
+    createdAt: DateTime
+    "The event's description"
+    description: String
+    "Datetime for when the event ends"
+    endsOn: DateTime
+    "Internal ID for this event"
+    id: Int
+    "Whether the event is local or not"
+    local: Boolean
+    "Online address of the event"
+    onlineAddress: OnlineAddress
+    "The event's organizer (as a person)"
+    organizerActor: Actor
+    "The event's participants"
+    participants: [Participant]
+    "Phone address for the event"
+    phoneAddress: PhoneAddress
+    "The type of the event's address"
+    physicalAddress: Address
+    "The event's picture"
+    picture: Picture
+    "When the event was published"
+    publishAt: DateTime
+    "Events related to this one"
+    relatedEvents: [Event]
+    "The event's description's slug"
+    slug: String
+    "Status of the event"
+    status: EventStatus
+    "The event's tags"
+    tags: [Tag]
+    "The event's title"
+    title: String
+    "When the event was last updated"
+    updatedAt: DateTime
+    "The ActivityPub Event URL"
+    url: String
+    "The Event UUID"
+    uuid: UUID
+    "The event's visibility"
+    visibility: EventVisibility
 }
 
-"""Search events result"""
+"Search events result"
 type Events {
-  """Event elements"""
-  elements: [Event]!
-
-  """Total elements"""
-  total: Int!
+    "Event elements"
+    elements: [Event]!
+    "Total elements"
+    total: Int!
 }
 
-"""The list of possible options for the event's status"""
-enum EventStatus {
-  """The event is cancelled"""
-  CANCELLED
-
-  """The event is confirmed"""
-  CONFIRMED
-
-  """The event is tentative"""
-  TENTATIVE
-}
-
-"""The list of visibility options for an event"""
-enum EventVisibility {
-  """visible only to people invited"""
-  INVITE
-
-  """Visible only after a moderator accepted"""
-  MODERATED
-
-  """Visible only to people members of the group or followers of the person"""
-  PRIVATE
-
-  """Publically listed and federated. Can be shared."""
-  PUBLIC
-
-  """Visible only to people with the link - or invited"""
-  UNLISTED
-}
-
-"""Represents a participant to an event"""
+"Represents a participant to an event"
 type FeedToken {
-  """The event which the actor participates in"""
-  actor: Actor
-
-  """The role of this actor at this event"""
-  token: String
-
-  """The actor that participates to the event"""
-  user: User
+    "The event which the actor participates in"
+    actor: Actor
+    "The role of this actor at this event"
+    token: String
+    "The actor that participates to the event"
+    user: User
 }
 
 """
 Represents an actor's follower
-
 """
 type Follower {
-  """Which profile follows"""
-  actor: Actor
-
-  """Whether the follow has been approved by the target actor"""
-  approved: Boolean
-
-  """What or who the profile follows"""
-  targetActor: Actor
+    "Which profile follows"
+    actor: Actor
+    "Whether the follow has been approved by the target actor"
+    approved: Boolean
+    "What or who the profile follows"
+    targetActor: Actor
 }
 
 """
 Represents a group of actors
-
 """
 type Group implements Actor {
-  """The actor's avatar picture"""
-  avatar: Picture
-
-  """The actor's banner picture"""
-  banner: Picture
-
-  """The actor's domain if (null if it's this instance)"""
-  domain: String
-
-  """List of followers"""
-  followers: [Follower]
-
-  """Number of followers for this actor"""
-  followersCount: Int
-
-  """List of followings"""
-  following: [Follower]
-
-  """Number of actors following this actor"""
-  followingCount: Int
-
-  """Internal ID for this group"""
-  id: Int
-
-  """The actors RSA Keys"""
-  keys: String
-
-  """If the actor is from this instance"""
-  local: Boolean
-
-  """Whether the actors manually approves followers"""
-  manuallyApprovesFollowers: Boolean
-
-  """List of group members"""
-  members: [Member]!
-
-  """The actor's displayed name"""
-  name: String
-
-  """Whether the group is opened to all or has restricted access"""
-  openness: Openness
-
-  """A list of the events this actor has organized"""
-  organizedEvents: [Event]
-
-  """The actor's preferred username"""
-  preferredUsername: String
-
-  """The actor's summary"""
-  summary: String
-
-  """If the actor is suspended"""
-  suspended: Boolean
-
-  """The type of Actor (Person, Group,…)"""
-  type: ActorType
-
-  """The type of group : Group, Community,…"""
-  types: GroupType
-
-  """The ActivityPub actor's URL"""
-  url: String
+    "The actor's avatar picture"
+    avatar: Picture
+    "The actor's banner picture"
+    banner: Picture
+    "The actor's domain if (null if it's this instance)"
+    domain: String
+    "List of followers"
+    followers: [Follower]
+    "Number of followers for this actor"
+    followersCount: Int
+    "List of followings"
+    following: [Follower]
+    "Number of actors following this actor"
+    followingCount: Int
+    "Internal ID for this group"
+    id: Int
+    "The actors RSA Keys"
+    keys: String
+    "If the actor is from this instance"
+    local: Boolean
+    "Whether the actors manually approves followers"
+    manuallyApprovesFollowers: Boolean
+    "List of group members"
+    members: [Member]!
+    "The actor's displayed name"
+    name: String
+    "Whether the group is opened to all or has restricted access"
+    openness: Openness
+    "A list of the events this actor has organized"
+    organizedEvents: [Event]
+    "The actor's preferred username"
+    preferredUsername: String
+    "The actor's summary"
+    summary: String
+    "If the actor is suspended"
+    suspended: Boolean
+    "The type of Actor (Person, Group,…)"
+    type: ActorType
+    "The type of group : Group, Community,…"
+    types: GroupType
+    "The ActivityPub actor's URL"
+    url: String
 }
 
-"""Search groups result"""
+"Search groups result"
 type Groups {
-  """Group elements"""
-  elements: [Group]!
-
-  """Total elements"""
-  total: Int!
+    "Group elements"
+    elements: [Group]!
+    "Total elements"
+    total: Int!
 }
 
-"""
-The types of Group that exist
-
-"""
-enum GroupType {
-  """A public group of many actors"""
-  COMMUNITY
-
-  """A private group of persons"""
-  GROUP
-}
-
-"""A JWT and the associated user ID"""
+"A JWT and the associated user ID"
 type Login {
-  """A JWT Token for this session"""
-  token: String!
-
-  """The user associated to this session"""
-  user: User!
+    "A JWT Token for this session"
+    token: String!
+    "The user associated to this session"
+    user: User!
 }
 
 """
 Represents a member of a group
-
 """
 type Member {
-  """Which profile is member of"""
-  actor: Person
-
-  """Of which the profile is member"""
-  parent: Group
-
-  """The role of this membership"""
-  role: Int
+    "Which profile is member of"
+    actor: Person
+    "Of which the profile is member"
+    parent: Group
+    "The role of this membership"
+    role: Int
 }
 
 type OnlineAddress {
-  info: String
-  url: String
+    info: String
+    url: String
 }
 
-"""
-Describes how an actor is opened to follows
-
-"""
-enum Openness {
-  """The actor can only be followed by invitation"""
-  INVITE_ONLY
-
-  """The actor needs to accept the following before it's effective"""
-  MODERATED
-
-  """The actor is open to followings"""
-  OPEN
-}
-
-"""Represents a participant to an event"""
+"Represents a participant to an event"
 type Participant {
-  """The actor that participates to the event"""
-  actor: Actor
-
-  """The event which the actor participates in"""
-  event: Event
-
-  """The role of this actor at this event"""
-  role: Int
+    "The actor that participates to the event"
+    actor: Actor
+    "The event which the actor participates in"
+    event: Event
+    "The role of this actor at this event"
+    role: Int
 }
 
 """
 Represents a person identity
-
 """
 type Person implements Actor {
-  """The actor's avatar picture"""
-  avatar: Picture
-
-  """The actor's banner picture"""
-  banner: Picture
-
-  """The actor's domain if (null if it's this instance)"""
-  domain: String
-
-  """A list of the feed tokens for this person"""
-  feedTokens: [FeedToken]
-
-  """List of followers"""
-  followers: [Follower]
-
-  """Number of followers for this actor"""
-  followersCount: Int
-
-  """List of followings"""
-  following: [Follower]
-
-  """Number of actors following this actor"""
-  followingCount: Int
-
-  """The list of events this person goes to"""
-  goingToEvents: [Event]
-
-  """Internal ID for this person"""
-  id: Int
-
-  """The actors RSA Keys"""
-  keys: String
-
-  """If the actor is from this instance"""
-  local: Boolean
-
-  """Whether the actors manually approves followers"""
-  manuallyApprovesFollowers: Boolean
-
-  """The list of groups this person is member of"""
-  memberOf: [Member]
-
-  """The actor's displayed name"""
-  name: String
-
-  """A list of the events this actor has organized"""
-  organizedEvents: [Event]
-
-  """The actor's preferred username"""
-  preferredUsername: String
-
-  """The actor's summary"""
-  summary: String
-
-  """If the actor is suspended"""
-  suspended: Boolean
-
-  """The type of Actor (Person, Group,…)"""
-  type: ActorType
-
-  """The ActivityPub actor's URL"""
-  url: String
-
-  """The user this actor is associated to"""
-  user: User
+    "The actor's avatar picture"
+    avatar: Picture
+    "The actor's banner picture"
+    banner: Picture
+    "The actor's domain if (null if it's this instance)"
+    domain: String
+    "A list of the feed tokens for this person"
+    feedTokens: [FeedToken]
+    "List of followers"
+    followers: [Follower]
+    "Number of followers for this actor"
+    followersCount: Int
+    "List of followings"
+    following: [Follower]
+    "Number of actors following this actor"
+    followingCount: Int
+    "The list of events this person goes to"
+    goingToEvents: [Event]
+    "Internal ID for this person"
+    id: Int
+    "The actors RSA Keys"
+    keys: String
+    "If the actor is from this instance"
+    local: Boolean
+    "Whether the actors manually approves followers"
+    manuallyApprovesFollowers: Boolean
+    "The list of groups this person is member of"
+    memberOf: [Member]
+    "The actor's displayed name"
+    name: String
+    "A list of the events this actor has organized"
+    organizedEvents: [Event]
+    "The actor's preferred username"
+    preferredUsername: String
+    "The actor's summary"
+    summary: String
+    "If the actor is suspended"
+    suspended: Boolean
+    "The type of Actor (Person, Group,…)"
+    type: ActorType
+    "The ActivityPub actor's URL"
+    url: String
+    "The user this actor is associated to"
+    user: User
 }
 
-"""Search persons result"""
+"Search persons result"
 type Persons {
-  """Person elements"""
-  elements: [Person]!
-
-  """Total elements"""
-  total: Int!
+    "Person elements"
+    elements: [Person]!
+    "Total elements"
+    total: Int!
 }
 
 type PhoneAddress {
-  info: String
-  phone: String
+    info: String
+    phone: String
 }
 
-"""A picture"""
+"A picture"
 type Picture {
-  """The picture's alternative text"""
-  alt: String
-
-  """The picture's UUID"""
-  id: UUID
-
-  """The picture's name"""
-  name: String
-
-  """The picture's full thumbnail URL"""
-  thumbnailUrl: String
-
-  """The picture's full URL"""
-  url: String
+    "The picture's alternative text"
+    alt: String
+    "The picture's ID"
+    id: ID
+    "The picture's name"
+    name: String
+    "The picture's full URL"
+    url: String
 }
 
-"""An attached picture or a link to a picture"""
-input PictureInput {
-  picture: PictureInputObject
-  pictureId: String
-}
-
-"""An attached picture"""
-input PictureInputObject {
-  alt: String
-  file: Upload!
-  name: String!
-}
-
-"""
-The `Point` scalar type represents Point geographic information compliant string data, 
-represented as floats separated by a semi-colon. The geodetic system is WGS 84
-"""
-scalar Point
-
 type RootMutationType {
-  """Change default actor for user"""
-  changeDefaultActor(preferredUsername: String!): User
-
-  """Create a comment"""
-  createComment(actorUsername: String!, text: String!): Comment
-
-  """Create an event"""
-  createEvent(
-    beginsOn: DateTime!
-    category: String!
-    description: String!
-    endsOn: DateTime
-    onlineAddress: String
-    organizerActorId: ID!
-    phoneAddress: String
-
-    """
-    The picture for the event, either as an object or directly the ID of an existing Picture
-    """
-    picture: PictureInput
-    public: Boolean
-    publishAt: DateTime
-    state: Int
-    status: Int
-    title: String!
-  ): Event
-
-  """Create a Feed Token"""
-  createFeedToken(actorId: Int): FeedToken
-
-  """Create a group"""
-  createGroup(
-    """
-    The actor's username which will be the admin (otherwise user's default one)
-    """
-    adminActorUsername: String
-
-    """
-    The avatar for the group, either as an object or directly the ID of an existing Picture
-    """
-    avatar: PictureInput
-
-    """
-    The banner for the group, either as an object or directly the ID of an existing Picture
-    """
-    banner: PictureInput
-
-    """The summary for the group"""
-    description: String = ""
-
-    """The displayed name for the group"""
-    name: String
-
-    """The name for the group"""
-    preferredUsername: String!
-  ): Group
-
-  """Create a new person for user"""
-  createPerson(
-    """
-    The avatar for the profile, either as an object or directly the ID of an existing Picture
-    """
-    avatar: PictureInput
-
-    """
-    The banner for the profile, either as an object or directly the ID of an existing Picture
-    """
-    banner: PictureInput
-
-    """The displayed name for the new profile"""
-    name: String = ""
-    preferredUsername: String!
-
-    """The summary for the new profile"""
-    summary: String = ""
-  ): Person
-
-  """Create an user"""
-  createUser(email: String!, password: String!): User
-
-  """Delete an event"""
-  deleteEvent(actorId: Int!, eventId: Int!): DeletedObject
-
-  """Delete a feed token"""
-  deleteFeedToken(token: String!): DeletedFeedToken
-
-  """Delete a group"""
-  deleteGroup(actorId: Int!, groupId: Int!): DeletedObject
-
-  """Join an event"""
-  joinEvent(actorId: Int!, eventId: Int!): Participant
-
-  """Join a group"""
-  joinGroup(actorId: Int!, groupId: Int!): Member
-
-  """Leave an event"""
-  leaveEvent(actorId: Int!, eventId: Int!): DeletedParticipant
-
-  """Leave an event"""
-  leaveGroup(actorId: Int!, groupId: Int!): DeletedMember
-
-  """Login an user"""
-  login(email: String!, password: String!): Login
-
-  """Register a first profile on registration"""
-  registerPerson(
-    """
-    The avatar for the profile, either as an object or directly the ID of an existing Picture
-    """
-    avatar: PictureInput
-
-    """
-    The banner for the profile, either as an object or directly the ID of an existing Picture
-    """
-    banner: PictureInput
-
-    """The email from the user previously created"""
-    email: String!
-
-    """The displayed name for the new profile"""
-    name: String = ""
-    preferredUsername: String!
-
-    """The summary for the new profile"""
-    summary: String = ""
-  ): Person
-
-  """Resend registration confirmation token"""
-  resendConfirmationEmail(email: String!, locale: String = "en"): String
-
-  """Reset user password"""
-  resetPassword(locale: String = "en", password: String!, token: String!): Login
-
-  """Send a link through email to reset user password"""
-  sendResetPassword(email: String!, locale: String = "en"): String
-
-  """Upload a picture"""
-  uploadPicture(alt: String, file: Upload!, name: String!): Picture
-
-  """Validate an user after registration"""
-  validateUser(token: String!): Login
+    "Change default actor for user"
+    changeDefaultActor(preferredUsername: String!): User
+    "Create a comment"
+    createComment(actorUsername: String!, text: String!): Comment
+    "Create an event"
+    createEvent(
+        beginsOn: DateTime!,
+        category: String!,
+        description: String!,
+        endsOn: DateTime,
+        onlineAddress: String,
+        organizerActorId: ID!,
+        phoneAddress: String,
+        #The picture for the event, either as an object or directly the ID of an existing Picture
+        picture: PictureInput,
+        public: Boolean,
+        publishAt: DateTime,
+        state: Int,
+        status: Int,
+        title: String!,
+        visibility: EventVisibility = PRIVATE
+    ): Event
+    "Create a Feed Token"
+    createFeedToken(actorId: Int): FeedToken
+    "Create a group"
+    createGroup(
+        #The actor's username which will be the admin (otherwise user's default one)
+        adminActorUsername: String,
+        #The avatar for the group, either as an object or directly the ID of an existing Picture
+        avatar: PictureInput,
+        #The banner for the group, either as an object or directly the ID of an existing Picture
+        banner: PictureInput,
+        #The summary for the group
+        description: String = "",
+        #The displayed name for the group
+        name: String,
+        #The name for the group
+        preferredUsername: String!
+    ): Group
+    "Create a new person for user"
+    createPerson(
+        #The avatar for the profile, either as an object or directly the ID of an existing Picture
+        avatar: PictureInput,
+        #The banner for the profile, either as an object or directly the ID of an existing Picture
+        banner: PictureInput,
+        #The displayed name for the new profile
+        name: String = "",
+        preferredUsername: String!,
+        #The summary for the new profile
+        summary: String = ""
+    ): Person
+    "Create an user"
+    createUser(email: String!, password: String!): User
+    "Delete an event"
+    deleteEvent(actorId: Int!, eventId: Int!): DeletedObject
+    "Delete a feed token"
+    deleteFeedToken(token: String!): DeletedFeedToken
+    "Delete a group"
+    deleteGroup(actorId: Int!, groupId: Int!): DeletedObject
+    "Join an event"
+    joinEvent(actorId: Int!, eventId: Int!): Participant
+    "Join a group"
+    joinGroup(actorId: Int!, groupId: Int!): Member
+    "Leave an event"
+    leaveEvent(actorId: Int!, eventId: Int!): DeletedParticipant
+    "Leave an event"
+    leaveGroup(actorId: Int!, groupId: Int!): DeletedMember
+    "Login an user"
+    login(email: String!, password: String!): Login
+    "Register a first profile on registration"
+    registerPerson(
+        #The avatar for the profile, either as an object or directly the ID of an existing Picture
+        avatar: PictureInput,
+        #The banner for the profile, either as an object or directly the ID of an existing Picture
+        banner: PictureInput,
+        #The email from the user previously created
+        email: String!,
+        #The displayed name for the new profile
+        name: String = "",
+        preferredUsername: String!,
+        #The summary for the new profile
+        summary: String = ""
+    ): Person
+    "Resend registration confirmation token"
+    resendConfirmationEmail(email: String!, locale: String = "en"): String
+    "Reset user password"
+    resetPassword(locale: String = "en", password: String!, token: String!): Login
+    "Send a link through email to reset user password"
+    sendResetPassword(email: String!, locale: String = "en"): String
+    "Upload a picture"
+    uploadPicture(actorId: ID!, alt: String, file: Upload!, name: String!): Picture
+    "Validate an user after registration"
+    validateUser(token: String!): Login
 }
 
 """
 Root Query
-
 """
 type RootQueryType {
-  """Get the instance config"""
-  config: Config
-
-  """Get an event by uuid"""
-  event(uuid: UUID!): Event
-
-  """Get all events"""
-  events(limit: Int = 10, page: Int = 1): [Event]
-
-  """Get a group by it's preferred username"""
-  group(preferredUsername: String!): Group
-
-  """Get all groups"""
-  groups(limit: Int = 10, page: Int = 1): [Group]
-
-  """Get the persons for an user"""
-  identities: [Person]
-
-  """Get the current actor for the logged-in user"""
-  loggedPerson: Person
-
-  """Get the current user"""
-  loggedUser: User
-
-  """Get all participants for an event uuid"""
-  participants(limit: Int = 10, page: Int = 1, uuid: UUID!): [Participant]
-
-  """Get a person by it's preferred username"""
-  person(preferredUsername: String!): Person
-
-  """Get a picture"""
-  picture(id: String!): Picture
-
-  """Reverse geocode coordinates"""
-  reverseGeocode(latitude: Float!, longitude: Float!): [Address]
-
-  """Search for an address"""
-  searchAddress(query: String!): [Address]
-
-  """Search events"""
-  searchEvents(limit: Int = 10, page: Int = 1, search: String!): Events
-
-  """Search groups"""
-  searchGroups(limit: Int = 10, page: Int = 1, search: String!): Groups
-
-  """Search persons"""
-  searchPersons(limit: Int = 10, page: Int = 1, search: String!): Persons
-
-  """Get the list of tags"""
-  tags(limit: Int = 10, page: Int = 1): [Tag]!
-
-  """Get an user"""
-  user(id: ID!): User
-
-  """List instance users"""
-  users(direction: SortDirection = DESC, limit: Int = 10, page: Int = 1, sort: SortableUserField = ID): Users
+    "Get the instance config"
+    config: Config
+    "Get an event by uuid"
+    event(uuid: UUID!): Event
+    "Get all events"
+    events(limit: Int = 10, page: Int = 1): [Event]
+    "Get a group by it's preferred username"
+    group(preferredUsername: String!): Group
+    "Get all groups"
+    groups(limit: Int = 10, page: Int = 1): [Group]
+    "Get the persons for an user"
+    identities: [Person]
+    "Get the current actor for the logged-in user"
+    loggedPerson: Person
+    "Get the current user"
+    loggedUser: User
+    "Get all participants for an event uuid"
+    participants(limit: Int = 10, page: Int = 1, uuid: UUID!): [Participant]
+    "Get a person by it's preferred username"
+    person(preferredUsername: String!): Person
+    "Get a picture"
+    picture(id: String!): Picture
+    "Reverse geocode coordinates"
+    reverseGeocode(latitude: Float!, longitude: Float!): [Address]
+    "Search for an address"
+    searchAddress(query: String!): [Address]
+    "Search events"
+    searchEvents(limit: Int = 10, page: Int = 1, search: String!): Events
+    "Search groups"
+    searchGroups(limit: Int = 10, page: Int = 1, search: String!): Groups
+    "Search persons"
+    searchPersons(limit: Int = 10, page: Int = 1, search: String!): Persons
+    "Get the list of tags"
+    tags(limit: Int = 10, page: Int = 1): [Tag]!
+    "Get an user"
+    user(id: ID!): User
+    "List instance users"
+    users(direction: SortDirection = DESC, limit: Int = 10, page: Int = 1, sort: SortableUserField = ID): Users
 }
 
-"""The list of possible options for the event's status"""
-enum SortableUserField {
-  ID
-}
-
-"""Available sort directions"""
-enum SortDirection {
-  ASC
-  DESC
-}
-
-"""A tag"""
+"A tag"
 type Tag {
-  """The tag's ID"""
-  id: ID
-
-  """Related tags to this tag"""
-  related: [Tag]
-
-  """The tags's slug"""
-  slug: String
-
-  """The tag's title"""
-  title: String
+    "The tag's ID"
+    id: ID
+    "Related tags to this tag"
+    related: [Tag]
+    "The tags's slug"
+    slug: String
+    "The tag's title"
+    title: String
 }
 
-"""
-Represents an uploaded file.
-
-"""
-scalar Upload
-
-"""A local user of Mobilizon"""
+"A local user of Mobilizon"
 type User {
-  """The datetime the last activation/confirmation token was sent"""
-  confirmationSentAt: DateTime
-
-  """The account activation/confirmation token"""
-  confirmationToken: String
-
-  """The datetime when the user was confirmed/activated"""
-  confirmedAt: DateTime
-
-  """The user's default actor"""
-  defaultActor: Person
-
-  """The user's email"""
-  email: String!
-
-  """A list of the feed tokens for this user"""
-  feedTokens: [FeedToken]
-
-  """The user's ID"""
-  id: ID!
-
-  """The user's list of profiles (identities)"""
-  profiles: [Person]!
-
-  """The datetime last reset password email was sent"""
-  resetPasswordSentAt: DateTime
-
-  """The token sent when requesting password token"""
-  resetPasswordToken: String
+    "The datetime the last activation/confirmation token was sent"
+    confirmationSentAt: DateTime
+    "The account activation/confirmation token"
+    confirmationToken: String
+    "The datetime when the user was confirmed/activated"
+    confirmedAt: DateTime
+    "The user's default actor"
+    defaultActor: Person
+    "The user's email"
+    email: String!
+    "A list of the feed tokens for this user"
+    feedTokens: [FeedToken]
+    "The user's ID"
+    id: ID!
+    "The user's list of profiles (identities)"
+    profiles: [Person]!
+    "The datetime last reset password email was sent"
+    resetPasswordSentAt: DateTime
+    "The token sent when requesting password token"
+    resetPasswordToken: String
 }
 
-"""Users list"""
+"Users list"
 type Users {
-  """User elements"""
-  elements: [User]!
-
-  """Total elements"""
-  total: Int!
+    "User elements"
+    elements: [User]!
+    "Total elements"
+    total: Int!
 }
 
+"The list of types an actor can be"
+enum ActorType {
+    #An ActivityPub Application
+    APPLICATION
+    #An ActivityPub Group
+    GROUP
+    #An ActivityPub Organization
+    ORGANIZATION
+    #An ActivityPub Person
+    PERSON
+    #An ActivityPub Service
+    SERVICE
+}
+
+"The list of visibility options for a comment"
+enum CommentVisibility {
+    #visible only to people invited
+    INVITE
+    #Visible only after a moderator accepted
+    MODERATED
+    #Visible only to people members of the group or followers of the person
+    PRIVATE
+    #Publically listed and federated. Can be shared.
+    PUBLIC
+    #Visible only to people with the link - or invited
+    UNLISTED
+}
+
+"The list of possible options for the event's status"
+enum EventStatus {
+    #The event is cancelled
+    CANCELLED
+    #The event is confirmed
+    CONFIRMED
+    #The event is tentative
+    TENTATIVE
+}
+
+"The list of visibility options for an event"
+enum EventVisibility {
+    #visible only to people invited
+    INVITE
+    #Visible only after a moderator accepted
+    MODERATED
+    #Visible only to people members of the group or followers of the person
+    PRIVATE
+    #Publically listed and federated. Can be shared.
+    PUBLIC
+    #Visible only to people with the link - or invited
+    UNLISTED
+}
+
+"""
+The types of Group that exist
+"""
+enum GroupType {
+    #A public group of many actors
+    COMMUNITY
+    #A private group of persons
+    GROUP
+}
+
+"""
+Describes how an actor is opened to follows
+"""
+enum Openness {
+    #The actor can only be followed by invitation
+    INVITE_ONLY
+    #The actor needs to accept the following before it's effective
+    MODERATED
+    #The actor is open to followings
+    OPEN
+}
+
+"Available sort directions"
+enum SortDirection {
+    ASC
+    DESC
+}
+
+"The list of possible options for the event's status"
+enum SortableUserField {
+    ID
+}
+
+"An attached picture or a link to a picture"
+input PictureInput {
+    picture: PictureInputObject
+    pictureId: String
+}
+
+"An attached picture"
+input PictureInputObject {
+    actorId: ID
+    alt: String
+    file: Upload!
+    name: String!
+}
+
+
+"""
+The `Point` scalar type represents Point geographic information compliant string data,
+represented as floats separated by a semi-colon. The geodetic system is WGS 84
+"""
+scalar Point
+
+"""
+The `DateTime` scalar type represents a date and time in the UTC
+timezone. The DateTime appears in a JSON response as an ISO8601 formatted
+string, including UTC timezone (\"Z\"). The parsed date and time string will
+be converted to UTC and any UTC offset other than 0 will be rejected.
+"""
+scalar DateTime
+
 """
 The `UUID` scalar type represents UUID4 compliant string data, represented as UTF-8
 character sequences. The UUID4 type is most often used to represent unique
 human-readable ID strings.
 """
 scalar UUID
+
+"""
+Represents an uploaded file.
+"""
+scalar Upload
diff --git a/test/mobilizon/media/media_test.exs b/test/mobilizon/media/media_test.exs
index 58aa6e19d..04dce976e 100644
--- a/test/mobilizon/media/media_test.exs
+++ b/test/mobilizon/media/media_test.exs
@@ -22,17 +22,22 @@ defmodule Mobilizon.MediaTest do
 
     test "get_picture!/1 returns the picture with given id" do
       picture = insert(:picture)
-      assert Media.get_picture!(picture.id) == picture
+      assert Media.get_picture!(picture.id).id == picture.id
     end
 
     test "create_picture/1 with valid data creates a picture" do
-      assert {:ok, %Picture{} = picture} = Media.create_picture(@valid_attrs)
+      assert {:ok, %Picture{} = picture} =
+               Media.create_picture(Map.put(@valid_attrs, :actor_id, insert(:actor).id))
+
       assert picture.file.name == "something old"
     end
 
     test "update_picture/2 with valid data updates the picture" do
       picture = insert(:picture)
-      assert {:ok, %Picture{} = picture} = Media.update_picture(picture, @update_attrs)
+
+      assert {:ok, %Picture{} = picture} =
+               Media.update_picture(picture, Map.put(@update_attrs, :actor_id, insert(:actor).id))
+
       assert picture.file.name == "something new"
     end
 
diff --git a/test/mobilizon_web/resolvers/event_resolver_test.exs b/test/mobilizon_web/resolvers/event_resolver_test.exs
index 473a5449b..013a54260 100644
--- a/test/mobilizon_web/resolvers/event_resolver_test.exs
+++ b/test/mobilizon_web/resolvers/event_resolver_test.exs
@@ -103,7 +103,8 @@ defmodule MobilizonWeb.Resolvers.EventResolverTest do
                     picture: {
                       name: "picture for my event",
                       alt: "A very sunny landscape",
-                      file: "event.jpg"
+                      file: "event.jpg",
+                      actor_id: #{actor.id}
                     }
                   }
               ) {
@@ -148,7 +149,8 @@ defmodule MobilizonWeb.Resolvers.EventResolverTest do
       mutation { uploadPicture(
               name: "#{picture.name}",
               alt: "#{picture.alt}",
-              file: "#{picture.file}"
+              file: "#{picture.file}",
+              actor_id: #{actor.id}
             ) {
                 id,
                 url,
diff --git a/test/mobilizon_web/resolvers/picture_resolver_test.exs b/test/mobilizon_web/resolvers/picture_resolver_test.exs
index 35ca00486..63e71dea0 100644
--- a/test/mobilizon_web/resolvers/picture_resolver_test.exs
+++ b/test/mobilizon_web/resolvers/picture_resolver_test.exs
@@ -7,8 +7,9 @@ defmodule MobilizonWeb.Resolvers.PictureResolverTest do
 
   setup %{conn: conn} do
     user = insert(:user)
+    actor = insert(:actor, user: user)
 
-    {:ok, conn: conn, user: user}
+    {:ok, conn: conn, user: user, actor: actor}
   end
 
   describe "Resolver: Get picture" do
@@ -56,14 +57,15 @@ defmodule MobilizonWeb.Resolvers.PictureResolverTest do
   end
 
   describe "Resolver: Upload picture" do
-    test "upload_picture/3 uploads a new picture", %{conn: conn, user: user} do
+    test "upload_picture/3 uploads a new picture", %{conn: conn, user: user, actor: actor} do
       picture = %{name: "my pic", alt: "represents something", file: "picture.png"}
 
       mutation = """
       mutation { uploadPicture(
               name: "#{picture.name}",
               alt: "#{picture.alt}",
-              file: "#{picture.file}"
+              file: "#{picture.file}",
+              actor_id: #{actor.id}
             ) {
                 url,
                 name
@@ -92,14 +94,15 @@ defmodule MobilizonWeb.Resolvers.PictureResolverTest do
       assert json_response(res, 200)["data"]["uploadPicture"]["url"]
     end
 
-    test "upload_picture/3 forbids uploading if no auth", %{conn: conn} do
+    test "upload_picture/3 forbids uploading if no auth", %{conn: conn, actor: actor} do
       picture = %{name: "my pic", alt: "represents something", file: "picture.png"}
 
       mutation = """
       mutation { uploadPicture(
               name: "#{picture.name}",
               alt: "#{picture.alt}",
-              file: "#{picture.file}"
+              file: "#{picture.file}",
+              actor_id: #{actor.id}
             ) {
                 url,
                 name
diff --git a/test/support/factory.ex b/test/support/factory.ex
index 3c5999282..65804f631 100644
--- a/test/support/factory.ex
+++ b/test/support/factory.ex
@@ -180,7 +180,8 @@ defmodule Mobilizon.Factory do
 
   def picture_factory do
     %Mobilizon.Media.Picture{
-      file: build(:file)
+      file: build(:file),
+      actor: build(:actor)
     }
   end
 end