Add OpenAPI spec for StatusController

This commit is contained in:
Egor Kislitsyn 2020-05-12 23:59:26 +04:00
parent c74018e6a7
commit 7803a85d2c
No known key found for this signature in database
GPG Key ID: 1B49CB15B71E7805
71 changed files with 1856 additions and 1082 deletions

View File

@ -66,7 +66,7 @@ defmodule Pleroma.BBS.Handler do
with %Activity{} <- Activity.get_by_id(activity_id), with %Activity{} <- Activity.get_by_id(activity_id),
{:ok, _activity} <- {:ok, _activity} <-
CommonAPI.post(user, %{"status" => rest, "in_reply_to_status_id" => activity_id}) do CommonAPI.post(user, %{status: rest, in_reply_to_status_id: activity_id}) do
IO.puts("Replied!") IO.puts("Replied!")
else else
_e -> IO.puts("Could not reply...") _e -> IO.puts("Could not reply...")
@ -78,7 +78,7 @@ defmodule Pleroma.BBS.Handler do
def handle_command(%{user: user} = state, "p " <> text) do def handle_command(%{user: user} = state, "p " <> text) do
text = String.trim(text) text = String.trim(text)
with {:ok, _activity} <- CommonAPI.post(user, %{"status" => text}) do with {:ok, _activity} <- CommonAPI.post(user, %{status: text}) do
IO.puts("Posted!") IO.puts("Posted!")
else else
_e -> IO.puts("Could not post...") _e -> IO.puts("Could not post...")

View File

@ -40,7 +40,7 @@ defmodule Pleroma.ScheduledActivity do
%{changes: %{params: %{"media_ids" => media_ids} = params}} = changeset %{changes: %{params: %{"media_ids" => media_ids} = params}} = changeset
) )
when is_list(media_ids) do when is_list(media_ids) do
media_attachments = Utils.attachments_from_ids(%{"media_ids" => media_ids}) media_attachments = Utils.attachments_from_ids(%{media_ids: media_ids})
params = params =
params params

View File

@ -10,8 +10,8 @@ defmodule Pleroma.User.WelcomeMessage do
with %User{} = sender_user <- welcome_user(), with %User{} = sender_user <- welcome_user(),
message when is_binary(message) <- welcome_message() do message when is_binary(message) <- welcome_message() do
CommonAPI.post(sender_user, %{ CommonAPI.post(sender_user, %{
"visibility" => "direct", visibility: "direct",
"status" => "@#{user.nickname}\n#{message}" status: "@#{user.nickname}\n#{message}"
}) })
else else
_ -> {:ok, nil} _ -> {:ok, nil}

View File

@ -844,15 +844,20 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do
end end
def status_update(%{assigns: %{user: admin}} = conn, %{"id" => id} = params) do def status_update(%{assigns: %{user: admin}} = conn, %{"id" => id} = params) do
params =
params
|> Map.take(["sensitive", "visibility"])
|> Map.new(fn {key, value} -> {String.to_existing_atom(key), value} end)
with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
{:ok, sensitive} = Ecto.Type.cast(:boolean, params["sensitive"]) {:ok, sensitive} = Ecto.Type.cast(:boolean, params[:sensitive])
ModerationLog.insert_log(%{ ModerationLog.insert_log(%{
action: "status_update", action: "status_update",
actor: admin, actor: admin,
subject: activity, subject: activity,
sensitive: sensitive, sensitive: sensitive,
visibility: params["visibility"] visibility: params[:visibility]
}) })
conn conn

View File

@ -0,0 +1,502 @@
# Pleroma: A lightweight social networking server
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.ApiSpec.StatusOperation do
alias OpenApiSpex.Operation
alias OpenApiSpex.Schema
alias Pleroma.Web.ApiSpec.AccountOperation
alias Pleroma.Web.ApiSpec.Schemas.ApiError
alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
alias Pleroma.Web.ApiSpec.Schemas.FlakeID
alias Pleroma.Web.ApiSpec.Schemas.ScheduledStatus
alias Pleroma.Web.ApiSpec.Schemas.Status
alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope
import Pleroma.Web.ApiSpec.Helpers
def open_api_operation(action) do
operation = String.to_existing_atom("#{action}_operation")
apply(__MODULE__, operation, [])
end
def index_operation do
%Operation{
tags: ["Statuses"],
summary: "Get multiple statuses by IDs",
security: [%{"oAuth" => ["read:statuses"]}],
parameters: [
Operation.parameter(
:ids,
:query,
%Schema{type: :array, items: FlakeID},
"Array of account IDs"
)
],
operationId: "StatusController.index",
responses: %{
200 => Operation.response("Array of Status", "application/json", array_of_statuses())
}
}
end
def create_operation do
%Operation{
tags: ["Statuses"],
summary: "Publish new status",
security: [%{"oAuth" => ["write:statuses"]}],
description: "Post a new status",
operationId: "StatusController.create",
requestBody: request_body("Parameters", create_request(), required: true),
responses: %{
200 =>
Operation.response(
"Status. When `scheduled_at` is present, ScheduledStatus is returned instead",
"application/json",
%Schema{oneOf: [Status, ScheduledStatus]}
),
422 => Operation.response("Bad Request", "application/json", ApiError)
}
}
end
def show_operation do
%Operation{
tags: ["Statuses"],
summary: "View specific status",
description: "View information about a status",
operationId: "StatusController.show",
security: [%{"oAuth" => ["read:statuses"]}],
parameters: [id_param()],
responses: %{
200 => status_response(),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def delete_operation do
%Operation{
tags: ["Statuses"],
summary: "Delete status",
security: [%{"oAuth" => ["write:statuses"]}],
description: "Delete one of your own statuses",
operationId: "StatusController.delete",
parameters: [id_param()],
responses: %{
200 => empty_object_response(),
403 => Operation.response("Forbidden", "application/json", ApiError),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def reblog_operation do
%Operation{
tags: ["Statuses"],
summary: "Boost",
security: [%{"oAuth" => ["write:statuses"]}],
description: "Reshare a status",
operationId: "StatusController.reblog",
parameters: [id_param()],
requestBody:
request_body("Parameters", %Schema{
type: :object,
properties: %{
visibility: %Schema{allOf: [VisibilityScope], default: "public"}
}
}),
responses: %{
200 => status_response(),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def unreblog_operation do
%Operation{
tags: ["Statuses"],
summary: "Undo boost",
security: [%{"oAuth" => ["write:statuses"]}],
description: "Undo a reshare of a status",
operationId: "StatusController.unreblog",
parameters: [id_param()],
responses: %{
200 => status_response(),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def favourite_operation do
%Operation{
tags: ["Statuses"],
summary: "Favourite",
security: [%{"oAuth" => ["write:favourites"]}],
description: "Add a status to your favourites list",
operationId: "StatusController.favourite",
parameters: [id_param()],
responses: %{
200 => status_response(),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def unfavourite_operation do
%Operation{
tags: ["Statuses"],
summary: "Undo favourite",
security: [%{"oAuth" => ["write:favourites"]}],
description: "Remove a status from your favourites list",
operationId: "StatusController.unfavourite",
parameters: [id_param()],
responses: %{
200 => status_response(),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def pin_operation do
%Operation{
tags: ["Statuses"],
summary: "Pin to profile",
security: [%{"oAuth" => ["write:accounts"]}],
description: "Feature one of your own public statuses at the top of your profile",
operationId: "StatusController.pin",
parameters: [id_param()],
responses: %{
200 => status_response(),
400 => Operation.response("Error", "application/json", ApiError)
}
}
end
def unpin_operation do
%Operation{
tags: ["Statuses"],
summary: "Unpin to profile",
security: [%{"oAuth" => ["write:accounts"]}],
description: "Unfeature a status from the top of your profile",
operationId: "StatusController.unpin",
parameters: [id_param()],
responses: %{
200 => status_response(),
400 => Operation.response("Error", "application/json", ApiError)
}
}
end
def bookmark_operation do
%Operation{
tags: ["Statuses"],
summary: "Bookmark",
security: [%{"oAuth" => ["write:bookmarks"]}],
description: "Privately bookmark a status",
operationId: "StatusController.bookmark",
parameters: [id_param()],
responses: %{
200 => status_response()
}
}
end
def unbookmark_operation do
%Operation{
tags: ["Statuses"],
summary: "Undo bookmark",
security: [%{"oAuth" => ["write:bookmarks"]}],
description: "Remove a status from your private bookmarks",
operationId: "StatusController.unbookmark",
parameters: [id_param()],
responses: %{
200 => status_response()
}
}
end
def mute_conversation_operation do
%Operation{
tags: ["Statuses"],
summary: "Mute conversation",
security: [%{"oAuth" => ["write:mutes"]}],
description:
"Do not receive notifications for the thread that this status is part of. Must be a thread in which you are a participant.",
operationId: "StatusController.mute_conversation",
parameters: [id_param()],
responses: %{
200 => status_response(),
400 => Operation.response("Error", "application/json", ApiError)
}
}
end
def unmute_conversation_operation do
%Operation{
tags: ["Statuses"],
summary: "Unmute conversation",
security: [%{"oAuth" => ["write:mutes"]}],
description:
"Start receiving notifications again for the thread that this status is part of",
operationId: "StatusController.unmute_conversation",
parameters: [id_param()],
responses: %{
200 => status_response(),
400 => Operation.response("Error", "application/json", ApiError)
}
}
end
def card_operation do
%Operation{
tags: ["Statuses"],
deprecated: true,
summary: "Preview card",
description: "Deprecated in favor of card property inlined on Status entity",
operationId: "StatusController.card",
parameters: [id_param()],
security: [%{"oAuth" => ["read:statuses"]}],
responses: %{
200 =>
Operation.response("Card", "application/json", %Schema{
type: :object,
nullable: true,
properties: %{
type: %Schema{type: :string, enum: ["link", "photo", "video", "rich"]},
provider_name: %Schema{type: :string, nullable: true},
provider_url: %Schema{type: :string, format: :uri},
url: %Schema{type: :string, format: :uri},
image: %Schema{type: :string, nullable: true, format: :uri},
title: %Schema{type: :string},
description: %Schema{type: :string}
}
})
}
}
end
def favourited_by_operation do
%Operation{
tags: ["Statuses"],
summary: "Favourited by",
description: "View who favourited a given status",
operationId: "StatusController.favourited_by",
security: [%{"oAuth" => ["read:accounts"]}],
parameters: [id_param()],
responses: %{
200 =>
Operation.response(
"Array of Accounts",
"application/json",
AccountOperation.array_of_accounts()
),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def reblogged_by_operation do
%Operation{
tags: ["Statuses"],
summary: "Boosted by",
description: "View who boosted a given status",
operationId: "StatusController.reblogged_by",
security: [%{"oAuth" => ["read:accounts"]}],
parameters: [id_param()],
responses: %{
200 =>
Operation.response(
"Array of Accounts",
"application/json",
AccountOperation.array_of_accounts()
),
404 => Operation.response("Not Found", "application/json", ApiError)
}
}
end
def context_operation do
%Operation{
tags: ["Statuses"],
summary: "Parent and child statuses",
description: "View statuses above and below this status in the thread",
operationId: "StatusController.context",
security: [%{"oAuth" => ["read:statuses"]}],
parameters: [id_param()],
responses: %{
200 => Operation.response("Context", "application/json", context())
}
}
end
def favourites_operation do
%Operation{
tags: ["Statuses"],
summary: "Favourited statuses",
description: "Statuses the user has favourited",
operationId: "StatusController.favourites",
parameters: pagination_params(),
security: [%{"oAuth" => ["read:favourites"]}],
responses: %{
200 => Operation.response("Array of Statuses", "application/json", array_of_statuses())
}
}
end
def bookmarks_operation do
%Operation{
tags: ["Statuses"],
summary: "Bookmarked statuses",
description: "Statuses the user has bookmarked",
operationId: "StatusController.bookmarks",
parameters: [
Operation.parameter(:with_relationships, :query, BooleanLike, "Include relationships")
| pagination_params()
],
security: [%{"oAuth" => ["read:bookmarks"]}],
responses: %{
200 => Operation.response("Array of Statuses", "application/json", array_of_statuses())
}
}
end
defp array_of_statuses do
%Schema{type: :array, items: Status, example: [Status.schema().example]}
end
defp create_request do
%Schema{
title: "StatusCreateRequest",
type: :object,
properties: %{
status: %Schema{
type: :string,
description:
"Text content of the status. If `media_ids` is provided, this becomes optional. Attaching a `poll` is optional while `status` is provided."
},
media_ids: %Schema{
type: :array,
items: %Schema{type: :string},
description:
"Array of Attachment ids to be attached as media. If provided, `status` becomes optional, and `poll` cannot be used."
},
poll: %Schema{
type: :object,
required: [:options],
properties: %{
options: %Schema{
type: :array,
items: %Schema{type: :string},
description:
"Array of possible answers. If provided, `media_ids` cannot be used, and `poll[expires_in]` must be provided."
},
expires_in: %Schema{
type: :integer,
description:
"Duration the poll should be open, in seconds. If provided, `media_ids` cannot be used, and `poll[options]` must be provided."
},
multiple: %Schema{type: :boolean, description: "Allow multiple choices?"},
hide_totals: %Schema{
type: :boolean,
description: "Hide vote counts until the poll ends?"
}
}
},
in_reply_to_id: %Schema{
allOf: [FlakeID],
description: "ID of the status being replied to, if status is a reply"
},
sensitive: %Schema{
type: :boolean,
description: "Mark status and attached media as sensitive?"
},
spoiler_text: %Schema{
type: :string,
description:
"Text to be shown as a warning or subject before the actual content. Statuses are generally collapsed behind this field."
},
scheduled_at: %Schema{
type: :string,
format: :"date-time",
nullable: true,
description:
"ISO 8601 Datetime at which to schedule a status. Providing this paramter will cause ScheduledStatus to be returned instead of Status. Must be at least 5 minutes in the future."
},
language: %Schema{type: :string, description: "ISO 639 language code for this status."},
# Pleroma-specific properties:
preview: %Schema{
type: :boolean,
description:
"If set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example"
},
content_type: %Schema{
type: :string,
description:
"The MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint."
},
to: %Schema{
type: :array,
items: %Schema{type: :string},
description:
"A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for for post visibility are not affected by this and will still apply"
},
visibility: %Schema{
anyOf: [
VisibilityScope,
%Schema{type: :string, description: "`list:LIST_ID`", example: "LIST:123"}
],
description:
"Visibility of the posted status. Besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`"
},
expires_in: %Schema{
type: :integer,
description:
"The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour."
},
in_reply_to_conversation_id: %Schema{
type: :string,
description:
"Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`."
}
},
example: %{
"status" => "What time is it?",
"sensitive" => "false",
"poll" => %{
"options" => ["Cofe", "Adventure"],
"expires_in" => 420
}
}
}
end
defp id_param do
Operation.parameter(:id, :path, FlakeID, "Status ID",
example: "9umDrYheeY451cQnEe",
required: true
)
end
defp status_response do
Operation.response("Status", "application/json", Status)
end
defp context do
%Schema{
title: "StatusContext",
description:
"Represents the tree around a given status. Used for reconstructing threads of statuses.",
type: :object,
required: [:ancestors, :descendants],
properties: %{
ancestors: array_of_statuses(),
descendants: array_of_statuses()
},
example: %{
"ancestors" => [Status.schema().example],
"descendants" => [Status.schema().example]
}
}
end
end

View File

@ -19,60 +19,127 @@ defmodule Pleroma.Web.ApiSpec.Schemas.Status do
description: "Response schema for a status", description: "Response schema for a status",
type: :object, type: :object,
properties: %{ properties: %{
account: Account, account: %Schema{allOf: [Account], description: "The account that authored this status"},
application: %Schema{ application: %Schema{
description: "The application used to post this status",
type: :object, type: :object,
properties: %{ properties: %{
name: %Schema{type: :string}, name: %Schema{type: :string},
website: %Schema{type: :string, nullable: true, format: :uri} website: %Schema{type: :string, nullable: true, format: :uri}
} }
}, },
bookmarked: %Schema{type: :boolean}, bookmarked: %Schema{type: :boolean, description: "Have you bookmarked this status?"},
card: %Schema{ card: %Schema{
type: :object, type: :object,
nullable: true, nullable: true,
description: "Preview card for links included within status content",
required: [:url, :title, :description, :type],
properties: %{ properties: %{
type: %Schema{type: :string, enum: ["link", "photo", "video", "rich"]}, type: %Schema{
provider_name: %Schema{type: :string, nullable: true}, type: :string,
provider_url: %Schema{type: :string, format: :uri}, enum: ["link", "photo", "video", "rich"],
url: %Schema{type: :string, format: :uri}, description: "The type of the preview card"
image: %Schema{type: :string, nullable: true, format: :uri}, },
title: %Schema{type: :string}, provider_name: %Schema{
description: %Schema{type: :string} type: :string,
nullable: true,
description: "The provider of the original resource"
},
provider_url: %Schema{
type: :string,
format: :uri,
description: "A link to the provider of the original resource"
},
url: %Schema{type: :string, format: :uri, description: "Location of linked resource"},
image: %Schema{
type: :string,
nullable: true,
format: :uri,
description: "Preview thumbnail"
},
title: %Schema{type: :string, description: "Title of linked resource"},
description: %Schema{type: :string, description: "Description of preview"}
} }
}, },
content: %Schema{type: :string, format: :html}, content: %Schema{type: :string, format: :html, description: "HTML-encoded status content"},
created_at: %Schema{type: :string, format: "date-time"}, created_at: %Schema{
emojis: %Schema{type: :array, items: Emoji}, type: :string,
favourited: %Schema{type: :boolean}, format: "date-time",
favourites_count: %Schema{type: :integer}, description: "The date when this status was created"
},
emojis: %Schema{
type: :array,
items: Emoji,
description: "Custom emoji to be used when rendering status content"
},
favourited: %Schema{type: :boolean, description: "Have you favourited this status?"},
favourites_count: %Schema{
type: :integer,
description: "How many favourites this status has received"
},
id: FlakeID, id: FlakeID,
in_reply_to_account_id: %Schema{type: :string, nullable: true}, in_reply_to_account_id: %Schema{
in_reply_to_id: %Schema{type: :string, nullable: true}, allOf: [FlakeID],
language: %Schema{type: :string, nullable: true}, nullable: true,
description: "ID of the account being replied to"
},
in_reply_to_id: %Schema{
allOf: [FlakeID],
nullable: true,
description: "ID of the status being replied"
},
language: %Schema{
type: :string,
nullable: true,
description: "Primary language of this status"
},
media_attachments: %Schema{ media_attachments: %Schema{
type: :array, type: :array,
items: Attachment items: Attachment,
description: "Media that is attached to this status"
}, },
mentions: %Schema{ mentions: %Schema{
type: :array, type: :array,
description: "Mentions of users within the status content",
items: %Schema{ items: %Schema{
type: :object, type: :object,
properties: %{ properties: %{
id: %Schema{type: :string}, id: %Schema{allOf: [FlakeID], description: "The account id of the mentioned user"},
acct: %Schema{type: :string}, acct: %Schema{
username: %Schema{type: :string}, type: :string,
url: %Schema{type: :string, format: :uri} description:
"The webfinger acct: URI of the mentioned user. Equivalent to `username` for local users, or `username@domain` for remote users."
},
username: %Schema{type: :string, description: "The username of the mentioned user"},
url: %Schema{
type: :string,
format: :uri,
description: "The location of the mentioned user's profile"
}
} }
} }
}, },
muted: %Schema{type: :boolean}, muted: %Schema{
pinned: %Schema{type: :boolean}, type: :boolean,
description: "Have you muted notifications for this status's conversation?"
},
pinned: %Schema{
type: :boolean,
description: "Have you pinned this status? Only appears if the status is pinnable."
},
pleroma: %Schema{ pleroma: %Schema{
type: :object, type: :object,
properties: %{ properties: %{
content: %Schema{type: :object, additionalProperties: %Schema{type: :string}}, content: %Schema{
conversation_id: %Schema{type: :integer}, type: :object,
additionalProperties: %Schema{type: :string},
description:
"A map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`"
},
conversation_id: %Schema{
type: :integer,
description: "The ID of the AP context the status is associated with (if any)"
},
direct_conversation_id: %Schema{ direct_conversation_id: %Schema{
type: :integer, type: :integer,
nullable: true, nullable: true,
@ -81,6 +148,8 @@ defmodule Pleroma.Web.ApiSpec.Schemas.Status do
}, },
emoji_reactions: %Schema{ emoji_reactions: %Schema{
type: :array, type: :array,
description:
"A list with emoji / reaction maps. Contains no information about the reacting users, for that use the /statuses/:id/reactions endpoint.",
items: %Schema{ items: %Schema{
type: :object, type: :object,
properties: %{ properties: %{
@ -90,27 +159,74 @@ defmodule Pleroma.Web.ApiSpec.Schemas.Status do
} }
} }
}, },
expires_at: %Schema{type: :string, format: "date-time", nullable: true}, expires_at: %Schema{
in_reply_to_account_acct: %Schema{type: :string, nullable: true}, type: :string,
local: %Schema{type: :boolean}, format: "date-time",
spoiler_text: %Schema{type: :object, additionalProperties: %Schema{type: :string}}, nullable: true,
thread_muted: %Schema{type: :boolean} description:
"A datetime (ISO 8601) that states when the post will expire (be deleted automatically), or empty if the post won't expire"
},
in_reply_to_account_acct: %Schema{
type: :string,
nullable: true,
description: "The `acct` property of User entity for replied user (if any)"
},
local: %Schema{
type: :boolean,
description: "`true` if the post was made on the local instance"
},
spoiler_text: %Schema{
type: :object,
additionalProperties: %Schema{type: :string},
description:
"A map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`."
},
thread_muted: %Schema{
type: :boolean,
description: "`true` if the thread the post belongs to is muted"
}
} }
}, },
poll: %Schema{type: Poll, nullable: true}, poll: %Schema{allOf: [Poll], nullable: true, description: "The poll attached to the status"},
reblog: %Schema{ reblog: %Schema{
allOf: [%OpenApiSpex.Reference{"$ref": "#/components/schemas/Status"}], allOf: [%OpenApiSpex.Reference{"$ref": "#/components/schemas/Status"}],
nullable: true nullable: true,
description: "The status being reblogged"
},
reblogged: %Schema{type: :boolean, description: "Have you boosted this status?"},
reblogs_count: %Schema{
type: :integer,
description: "How many boosts this status has received"
},
replies_count: %Schema{
type: :integer,
description: "How many replies this status has received"
},
sensitive: %Schema{
type: :boolean,
description: "Is this status marked as sensitive content?"
},
spoiler_text: %Schema{
type: :string,
description:
"Subject or summary line, below which status content is collapsed until expanded"
}, },
reblogged: %Schema{type: :boolean},
reblogs_count: %Schema{type: :integer},
replies_count: %Schema{type: :integer},
sensitive: %Schema{type: :boolean},
spoiler_text: %Schema{type: :string},
tags: %Schema{type: :array, items: Tag}, tags: %Schema{type: :array, items: Tag},
uri: %Schema{type: :string, format: :uri}, uri: %Schema{
url: %Schema{type: :string, nullable: true, format: :uri}, type: :string,
visibility: VisibilityScope format: :uri,
description: "URI of the status used for federation"
},
url: %Schema{
type: :string,
nullable: true,
format: :uri,
description: "A link to the status's HTML representation"
},
visibility: %Schema{
allOf: [VisibilityScope],
description: "Visibility of this status"
}
}, },
example: %{ example: %{
"account" => %{ "account" => %{

View File

@ -9,6 +9,6 @@ defmodule Pleroma.Web.ApiSpec.Schemas.VisibilityScope do
title: "VisibilityScope", title: "VisibilityScope",
description: "Status visibility", description: "Status visibility",
type: :string, type: :string,
enum: ["public", "unlisted", "private", "direct"] enum: ["public", "unlisted", "private", "direct", "list"]
}) })
end end

View File

@ -58,16 +58,16 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
end end
defp put_params(draft, params) do defp put_params(draft, params) do
params = Map.put_new(params, "in_reply_to_status_id", params["in_reply_to_id"]) params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id])
%__MODULE__{draft | params: params} %__MODULE__{draft | params: params}
end end
defp status(%{params: %{"status" => status}} = draft) do defp status(%{params: %{status: status}} = draft) do
%__MODULE__{draft | status: String.trim(status)} %__MODULE__{draft | status: String.trim(status)}
end end
defp summary(%{params: params} = draft) do defp summary(%{params: params} = draft) do
%__MODULE__{draft | summary: Map.get(params, "spoiler_text", "")} %__MODULE__{draft | summary: Map.get(params, :spoiler_text, "")}
end end
defp full_payload(%{status: status, summary: summary} = draft) do defp full_payload(%{status: status, summary: summary} = draft) do
@ -84,20 +84,20 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
%__MODULE__{draft | attachments: attachments} %__MODULE__{draft | attachments: attachments}
end end
defp in_reply_to(%{params: %{"in_reply_to_status_id" => ""}} = draft), do: draft defp in_reply_to(%{params: %{in_reply_to_status_id: ""}} = draft), do: draft
defp in_reply_to(%{params: %{"in_reply_to_status_id" => id}} = draft) when is_binary(id) do defp in_reply_to(%{params: %{in_reply_to_status_id: id}} = draft) when is_binary(id) do
%__MODULE__{draft | in_reply_to: Activity.get_by_id(id)} %__MODULE__{draft | in_reply_to: Activity.get_by_id(id)}
end end
defp in_reply_to(%{params: %{"in_reply_to_status_id" => %Activity{} = in_reply_to}} = draft) do defp in_reply_to(%{params: %{in_reply_to_status_id: %Activity{} = in_reply_to}} = draft) do
%__MODULE__{draft | in_reply_to: in_reply_to} %__MODULE__{draft | in_reply_to: in_reply_to}
end end
defp in_reply_to(draft), do: draft defp in_reply_to(draft), do: draft
defp in_reply_to_conversation(draft) do defp in_reply_to_conversation(draft) do
in_reply_to_conversation = Participation.get(draft.params["in_reply_to_conversation_id"]) in_reply_to_conversation = Participation.get(draft.params[:in_reply_to_conversation_id])
%__MODULE__{draft | in_reply_to_conversation: in_reply_to_conversation} %__MODULE__{draft | in_reply_to_conversation: in_reply_to_conversation}
end end
@ -112,7 +112,7 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
end end
defp expires_at(draft) do defp expires_at(draft) do
case CommonAPI.check_expiry_date(draft.params["expires_in"]) do case CommonAPI.check_expiry_date(draft.params[:expires_in]) do
{:ok, expires_at} -> %__MODULE__{draft | expires_at: expires_at} {:ok, expires_at} -> %__MODULE__{draft | expires_at: expires_at}
{:error, message} -> add_error(draft, message) {:error, message} -> add_error(draft, message)
end end
@ -144,7 +144,7 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
addressed_users = addressed_users =
draft.mentions draft.mentions
|> Enum.map(fn {_, mentioned_user} -> mentioned_user.ap_id end) |> Enum.map(fn {_, mentioned_user} -> mentioned_user.ap_id end)
|> Utils.get_addressed_users(draft.params["to"]) |> Utils.get_addressed_users(draft.params[:to])
{to, cc} = {to, cc} =
Utils.get_to_and_cc( Utils.get_to_and_cc(
@ -164,7 +164,7 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
end end
defp sensitive(draft) do defp sensitive(draft) do
sensitive = draft.params["sensitive"] || Enum.member?(draft.tags, {"#nsfw", "nsfw"}) sensitive = draft.params[:sensitive] || Enum.member?(draft.tags, {"#nsfw", "nsfw"})
%__MODULE__{draft | sensitive: sensitive} %__MODULE__{draft | sensitive: sensitive}
end end
@ -191,7 +191,7 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
end end
defp preview?(draft) do defp preview?(draft) do
preview? = Pleroma.Web.ControllerHelper.truthy_param?(draft.params["preview"]) preview? = Pleroma.Web.ControllerHelper.truthy_param?(draft.params[:preview])
%__MODULE__{draft | preview?: preview?} %__MODULE__{draft | preview?: preview?}
end end

View File

@ -116,19 +116,18 @@ defmodule Pleroma.Web.CommonAPI do
end end
def repeat(id, user, params \\ %{}) do def repeat(id, user, params \\ %{}) do
with {_, %Activity{data: %{"type" => "Create"}} = activity} <- with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id(id) do
{:find_activity, Activity.get_by_id(id)}, object = Object.normalize(activity)
object <- Object.normalize(activity), announce_activity = Utils.get_existing_announce(user.ap_id, object)
announce_activity <- Utils.get_existing_announce(user.ap_id, object), public = public_announce?(object, params)
public <- public_announce?(object, params) do
if announce_activity do if announce_activity do
{:ok, announce_activity, object} {:ok, announce_activity, object}
else else
ActivityPub.announce(user, object, nil, true, public) ActivityPub.announce(user, object, nil, true, public)
end end
else else
{:find_activity, _} -> {:error, :not_found} _ -> {:error, :not_found}
_ -> {:error, dgettext("errors", "Could not repeat")}
end end
end end
@ -286,7 +285,7 @@ defmodule Pleroma.Web.CommonAPI do
end end
end end
def public_announce?(_, %{"visibility" => visibility}) def public_announce?(_, %{visibility: visibility})
when visibility in ~w{public unlisted private direct}, when visibility in ~w{public unlisted private direct},
do: visibility in ~w(public unlisted) do: visibility in ~w(public unlisted)
@ -296,11 +295,11 @@ defmodule Pleroma.Web.CommonAPI do
def get_visibility(_, _, %Participation{}), do: {"direct", "direct"} def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}
def get_visibility(%{"visibility" => visibility}, in_reply_to, _) def get_visibility(%{visibility: visibility}, in_reply_to, _)
when visibility in ~w{public unlisted private direct}, when visibility in ~w{public unlisted private direct},
do: {visibility, get_replied_to_visibility(in_reply_to)} do: {visibility, get_replied_to_visibility(in_reply_to)}
def get_visibility(%{"visibility" => "list:" <> list_id}, in_reply_to, _) do def get_visibility(%{visibility: "list:" <> list_id}, in_reply_to, _) do
visibility = {:list, String.to_integer(list_id)} visibility = {:list, String.to_integer(list_id)}
{visibility, get_replied_to_visibility(in_reply_to)} {visibility, get_replied_to_visibility(in_reply_to)}
end end
@ -358,7 +357,7 @@ defmodule Pleroma.Web.CommonAPI do
end end
end end
def post(user, %{"status" => _} = data) do def post(user, %{status: _} = data) do
with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, data) do with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, data) do
draft.changes draft.changes
|> ActivityPub.create(draft.preview?) |> ActivityPub.create(draft.preview?)
@ -467,11 +466,11 @@ defmodule Pleroma.Web.CommonAPI do
end end
end end
defp toggle_sensitive(activity, %{"sensitive" => sensitive}) when sensitive in ~w(true false) do defp toggle_sensitive(activity, %{sensitive: sensitive}) when sensitive in ~w(true false) do
toggle_sensitive(activity, %{"sensitive" => String.to_existing_atom(sensitive)}) toggle_sensitive(activity, %{sensitive: String.to_existing_atom(sensitive)})
end end
defp toggle_sensitive(%Activity{object: object} = activity, %{"sensitive" => sensitive}) defp toggle_sensitive(%Activity{object: object} = activity, %{sensitive: sensitive})
when is_boolean(sensitive) do when is_boolean(sensitive) do
new_data = Map.put(object.data, "sensitive", sensitive) new_data = Map.put(object.data, "sensitive", sensitive)
@ -485,7 +484,7 @@ defmodule Pleroma.Web.CommonAPI do
defp toggle_sensitive(activity, _), do: {:ok, activity} defp toggle_sensitive(activity, _), do: {:ok, activity}
defp set_visibility(activity, %{"visibility" => visibility}) do defp set_visibility(activity, %{visibility: visibility}) do
Utils.update_activity_visibility(activity, visibility) Utils.update_activity_visibility(activity, visibility)
end end

View File

@ -22,11 +22,11 @@ defmodule Pleroma.Web.CommonAPI.Utils do
require Logger require Logger
require Pleroma.Constants require Pleroma.Constants
def attachments_from_ids(%{"media_ids" => ids, "descriptions" => desc} = _) do def attachments_from_ids(%{media_ids: ids, descriptions: desc}) do
attachments_from_ids_descs(ids, desc) attachments_from_ids_descs(ids, desc)
end end
def attachments_from_ids(%{"media_ids" => ids} = _) do def attachments_from_ids(%{media_ids: ids}) do
attachments_from_ids_no_descs(ids) attachments_from_ids_no_descs(ids)
end end
@ -37,11 +37,11 @@ defmodule Pleroma.Web.CommonAPI.Utils do
def attachments_from_ids_no_descs(ids) do def attachments_from_ids_no_descs(ids) do
Enum.map(ids, fn media_id -> Enum.map(ids, fn media_id ->
case Repo.get(Object, media_id) do case Repo.get(Object, media_id) do
%Object{data: data} = _ -> data %Object{data: data} -> data
_ -> nil _ -> nil
end end
end) end)
|> Enum.filter(& &1) |> Enum.reject(&is_nil/1)
end end
def attachments_from_ids_descs([], _), do: [] def attachments_from_ids_descs([], _), do: []
@ -51,14 +51,14 @@ defmodule Pleroma.Web.CommonAPI.Utils do
Enum.map(ids, fn media_id -> Enum.map(ids, fn media_id ->
case Repo.get(Object, media_id) do case Repo.get(Object, media_id) do
%Object{data: data} = _ -> %Object{data: data} ->
Map.put(data, "name", descs[media_id]) Map.put(data, "name", descs[media_id])
_ -> _ ->
nil nil
end end
end) end)
|> Enum.filter(& &1) |> Enum.reject(&is_nil/1)
end end
@spec get_to_and_cc( @spec get_to_and_cc(
@ -140,7 +140,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do
|> make_poll_data() |> make_poll_data()
end end
def make_poll_data(%{"poll" => %{"options" => options, "expires_in" => expires_in}} = data) def make_poll_data(%{poll: %{options: options, expires_in: expires_in}} = data)
when is_list(options) do when is_list(options) do
limits = Pleroma.Config.get([:instance, :poll_limits]) limits = Pleroma.Config.get([:instance, :poll_limits])
@ -163,7 +163,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do
|> DateTime.add(expires_in) |> DateTime.add(expires_in)
|> DateTime.to_iso8601() |> DateTime.to_iso8601()
key = if truthy_param?(data["poll"]["multiple"]), do: "anyOf", else: "oneOf" key = if truthy_param?(data.poll[:multiple]), do: "anyOf", else: "oneOf"
poll = %{"type" => "Question", key => option_notes, "closed" => end_time} poll = %{"type" => "Question", key => option_notes, "closed" => end_time}
{:ok, {poll, emoji}} {:ok, {poll, emoji}}
@ -213,7 +213,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do
|> Map.get("attachment_links", Config.get([:instance, :attachment_links])) |> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
|> truthy_param?() |> truthy_param?()
content_type = get_content_type(data["content_type"]) content_type = get_content_type(data[:content_type])
options = options =
if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do

View File

@ -24,6 +24,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
alias Pleroma.Web.MastodonAPI.AccountView alias Pleroma.Web.MastodonAPI.AccountView
alias Pleroma.Web.MastodonAPI.ScheduledActivityView alias Pleroma.Web.MastodonAPI.ScheduledActivityView
plug(Pleroma.Web.ApiSpec.CastAndValidate)
plug(:skip_plug, Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug when action in [:index, :show]) plug(:skip_plug, Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug when action in [:index, :show])
@unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []} @unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []}
@ -97,12 +98,14 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
action_fallback(Pleroma.Web.MastodonAPI.FallbackController) action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.StatusOperation
@doc """ @doc """
GET `/api/v1/statuses?ids[]=1&ids[]=2` GET `/api/v1/statuses?ids[]=1&ids[]=2`
`ids` query param is required `ids` query param is required
""" """
def index(%{assigns: %{user: user}} = conn, %{"ids" => ids} = params) do def index(%{assigns: %{user: user}} = conn, %{ids: ids} = params) do
limit = 100 limit = 100
activities = activities =
@ -125,21 +128,29 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
Creates a scheduled status when `scheduled_at` param is present and it's far enough Creates a scheduled status when `scheduled_at` param is present and it's far enough
""" """
def create( def create(
%{assigns: %{user: user}} = conn, %{
%{"status" => _, "scheduled_at" => scheduled_at} = params assigns: %{user: user},
body_params: %{status: _, scheduled_at: scheduled_at} = params
} = conn,
_
) )
when not is_nil(scheduled_at) do when not is_nil(scheduled_at) do
params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"]) params = Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
attrs = %{
params: Map.new(params, fn {key, value} -> {to_string(key), value} end),
scheduled_at: scheduled_at
}
with {:far_enough, true} <- {:far_enough, ScheduledActivity.far_enough?(scheduled_at)}, with {:far_enough, true} <- {:far_enough, ScheduledActivity.far_enough?(scheduled_at)},
attrs <- %{"params" => params, "scheduled_at" => scheduled_at},
{:ok, scheduled_activity} <- ScheduledActivity.create(user, attrs) do {:ok, scheduled_activity} <- ScheduledActivity.create(user, attrs) do
conn conn
|> put_view(ScheduledActivityView) |> put_view(ScheduledActivityView)
|> render("show.json", scheduled_activity: scheduled_activity) |> render("show.json", scheduled_activity: scheduled_activity)
else else
{:far_enough, _} -> {:far_enough, _} ->
create(conn, Map.drop(params, ["scheduled_at"])) params = Map.drop(params, [:scheduled_at])
create(%Plug.Conn{conn | body_params: params}, %{})
error -> error ->
error error
@ -151,8 +162,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
Creates a regular status Creates a regular status
""" """
def create(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do def create(%{assigns: %{user: user}, body_params: %{status: _} = params} = conn, _) do
params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"]) params = Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
with {:ok, activity} <- CommonAPI.post(user, params) do with {:ok, activity} <- CommonAPI.post(user, params) do
try_render(conn, "show.json", try_render(conn, "show.json",
@ -169,12 +180,13 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
end end
def create(%{assigns: %{user: _user}} = conn, %{"media_ids" => _} = params) do def create(%{assigns: %{user: _user}, body_params: %{media_ids: _} = params} = conn, _) do
create(conn, Map.put(params, "status", "")) params = Map.put(params, :status, "")
create(%Plug.Conn{conn | body_params: params}, %{})
end end
@doc "GET /api/v1/statuses/:id" @doc "GET /api/v1/statuses/:id"
def show(%{assigns: %{user: user}} = conn, %{"id" => id}) do def show(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id_with_object(id), with %Activity{} = activity <- Activity.get_by_id_with_object(id),
true <- Visibility.visible_for_user?(activity, user) do true <- Visibility.visible_for_user?(activity, user) do
try_render(conn, "show.json", try_render(conn, "show.json",
@ -188,7 +200,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "DELETE /api/v1/statuses/:id" @doc "DELETE /api/v1/statuses/:id"
def delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do def delete(%{assigns: %{user: user}} = conn, %{id: id}) do
with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
json(conn, %{}) json(conn, %{})
else else
@ -198,7 +210,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/reblog" @doc "POST /api/v1/statuses/:id/reblog"
def reblog(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id} = params) do def reblog(%{assigns: %{user: user}, body_params: params} = conn, %{id: ap_id_or_id}) do
with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user, params), with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user, params),
%Activity{} = announce <- Activity.normalize(announce.data) do %Activity{} = announce <- Activity.normalize(announce.data) do
try_render(conn, "show.json", %{activity: announce, for: user, as: :activity}) try_render(conn, "show.json", %{activity: announce, for: user, as: :activity})
@ -206,7 +218,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/unreblog" @doc "POST /api/v1/statuses/:id/unreblog"
def unreblog(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do def unreblog(%{assigns: %{user: user}} = conn, %{id: activity_id}) do
with {:ok, _unannounce} <- CommonAPI.unrepeat(activity_id, user), with {:ok, _unannounce} <- CommonAPI.unrepeat(activity_id, user),
%Activity{} = activity <- Activity.get_by_id(activity_id) do %Activity{} = activity <- Activity.get_by_id(activity_id) do
try_render(conn, "show.json", %{activity: activity, for: user, as: :activity}) try_render(conn, "show.json", %{activity: activity, for: user, as: :activity})
@ -214,7 +226,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/favourite" @doc "POST /api/v1/statuses/:id/favourite"
def favourite(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do def favourite(%{assigns: %{user: user}} = conn, %{id: activity_id}) do
with {:ok, _fav} <- CommonAPI.favorite(user, activity_id), with {:ok, _fav} <- CommonAPI.favorite(user, activity_id),
%Activity{} = activity <- Activity.get_by_id(activity_id) do %Activity{} = activity <- Activity.get_by_id(activity_id) do
try_render(conn, "show.json", activity: activity, for: user, as: :activity) try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@ -222,7 +234,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/unfavourite" @doc "POST /api/v1/statuses/:id/unfavourite"
def unfavourite(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do def unfavourite(%{assigns: %{user: user}} = conn, %{id: activity_id}) do
with {:ok, _unfav} <- CommonAPI.unfavorite(activity_id, user), with {:ok, _unfav} <- CommonAPI.unfavorite(activity_id, user),
%Activity{} = activity <- Activity.get_by_id(activity_id) do %Activity{} = activity <- Activity.get_by_id(activity_id) do
try_render(conn, "show.json", activity: activity, for: user, as: :activity) try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@ -230,21 +242,21 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/pin" @doc "POST /api/v1/statuses/:id/pin"
def pin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do def pin(%{assigns: %{user: user}} = conn, %{id: ap_id_or_id}) do
with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
try_render(conn, "show.json", activity: activity, for: user, as: :activity) try_render(conn, "show.json", activity: activity, for: user, as: :activity)
end end
end end
@doc "POST /api/v1/statuses/:id/unpin" @doc "POST /api/v1/statuses/:id/unpin"
def unpin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do def unpin(%{assigns: %{user: user}} = conn, %{id: ap_id_or_id}) do
with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
try_render(conn, "show.json", activity: activity, for: user, as: :activity) try_render(conn, "show.json", activity: activity, for: user, as: :activity)
end end
end end
@doc "POST /api/v1/statuses/:id/bookmark" @doc "POST /api/v1/statuses/:id/bookmark"
def bookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do def bookmark(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id_with_object(id), with %Activity{} = activity <- Activity.get_by_id_with_object(id),
%User{} = user <- User.get_cached_by_nickname(user.nickname), %User{} = user <- User.get_cached_by_nickname(user.nickname),
true <- Visibility.visible_for_user?(activity, user), true <- Visibility.visible_for_user?(activity, user),
@ -254,7 +266,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/unbookmark" @doc "POST /api/v1/statuses/:id/unbookmark"
def unbookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do def unbookmark(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id_with_object(id), with %Activity{} = activity <- Activity.get_by_id_with_object(id),
%User{} = user <- User.get_cached_by_nickname(user.nickname), %User{} = user <- User.get_cached_by_nickname(user.nickname),
true <- Visibility.visible_for_user?(activity, user), true <- Visibility.visible_for_user?(activity, user),
@ -264,7 +276,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/mute" @doc "POST /api/v1/statuses/:id/mute"
def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do def mute_conversation(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id(id), with %Activity{} = activity <- Activity.get_by_id(id),
{:ok, activity} <- CommonAPI.add_mute(user, activity) do {:ok, activity} <- CommonAPI.add_mute(user, activity) do
try_render(conn, "show.json", activity: activity, for: user, as: :activity) try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@ -272,7 +284,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "POST /api/v1/statuses/:id/unmute" @doc "POST /api/v1/statuses/:id/unmute"
def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do def unmute_conversation(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id(id), with %Activity{} = activity <- Activity.get_by_id(id),
{:ok, activity} <- CommonAPI.remove_mute(user, activity) do {:ok, activity} <- CommonAPI.remove_mute(user, activity) do
try_render(conn, "show.json", activity: activity, for: user, as: :activity) try_render(conn, "show.json", activity: activity, for: user, as: :activity)
@ -281,7 +293,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
@doc "GET /api/v1/statuses/:id/card" @doc "GET /api/v1/statuses/:id/card"
@deprecated "https://github.com/tootsuite/mastodon/pull/11213" @deprecated "https://github.com/tootsuite/mastodon/pull/11213"
def card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do def card(%{assigns: %{user: user}} = conn, %{id: status_id}) do
with %Activity{} = activity <- Activity.get_by_id(status_id), with %Activity{} = activity <- Activity.get_by_id(status_id),
true <- Visibility.visible_for_user?(activity, user) do true <- Visibility.visible_for_user?(activity, user) do
data = Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity) data = Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
@ -292,7 +304,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "GET /api/v1/statuses/:id/favourited_by" @doc "GET /api/v1/statuses/:id/favourited_by"
def favourited_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do def favourited_by(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id_with_object(id), with %Activity{} = activity <- Activity.get_by_id_with_object(id),
{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)}, {:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
%Object{data: %{"likes" => likes}} <- Object.normalize(activity) do %Object{data: %{"likes" => likes}} <- Object.normalize(activity) do
@ -312,7 +324,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "GET /api/v1/statuses/:id/reblogged_by" @doc "GET /api/v1/statuses/:id/reblogged_by"
def reblogged_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do def reblogged_by(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id_with_object(id), with %Activity{} = activity <- Activity.get_by_id_with_object(id),
{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)}, {:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
%Object{data: %{"announcements" => announces, "id" => ap_id}} <- %Object{data: %{"announcements" => announces, "id" => ap_id}} <-
@ -344,7 +356,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
end end
@doc "GET /api/v1/statuses/:id/context" @doc "GET /api/v1/statuses/:id/context"
def context(%{assigns: %{user: user}} = conn, %{"id" => id}) do def context(%{assigns: %{user: user}} = conn, %{id: id}) do
with %Activity{} = activity <- Activity.get_by_id(id) do with %Activity{} = activity <- Activity.get_by_id(id) do
activities = activities =
ActivityPub.fetch_activities_for_context(activity.data["context"], %{ ActivityPub.fetch_activities_for_context(activity.data["context"], %{
@ -359,11 +371,12 @@ defmodule Pleroma.Web.MastodonAPI.StatusController do
@doc "GET /api/v1/favourites" @doc "GET /api/v1/favourites"
def favourites(%{assigns: %{user: %User{} = user}} = conn, params) do def favourites(%{assigns: %{user: %User{} = user}} = conn, params) do
activities = params =
ActivityPub.fetch_favourites( params
user, |> Map.new(fn {key, value} -> {to_string(key), value} end)
Map.take(params, Pleroma.Pagination.page_keys()) |> Map.take(Pleroma.Pagination.page_keys())
)
activities = ActivityPub.fetch_favourites(user, params)
conn conn
|> add_link_headers(activities) |> add_link_headers(activities)

View File

@ -337,7 +337,11 @@ defmodule Pleroma.Web.MastodonAPI.AccountView do
defp maybe_put_role(data, _, _), do: data defp maybe_put_role(data, _, _), do: data
defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
Kernel.put_in(data, [:pleroma, :notification_settings], user.notification_settings) Kernel.put_in(
data,
[:pleroma, :notification_settings],
Map.from_struct(user.notification_settings)
)
end end
defp maybe_put_notification_settings(data, _, _), do: data defp maybe_put_notification_settings(data, _, _), do: data

View File

@ -30,6 +30,8 @@ defmodule Pleroma.Workers.ScheduledActivityWorker do
end end
defp post_activity(%ScheduledActivity{user_id: user_id, params: params} = scheduled_activity) do defp post_activity(%ScheduledActivity{user_id: user_id, params: params} = scheduled_activity) do
params = Map.new(params, fn {key, value} -> {String.to_existing_atom(key), value} end)
with {:delete, {:ok, _}} <- {:delete, ScheduledActivity.delete(scheduled_activity)}, with {:delete, {:ok, _}} <- {:delete, ScheduledActivity.delete(scheduled_activity)},
{:user, %User{} = user} <- {:user, User.get_cached_by_id(user_id)}, {:user, %User{} = user} <- {:user, User.get_cached_by_id(user_id)},
{:post, {:ok, _}} <- {:post, CommonAPI.post(user, params)} do {:post, {:ok, _}} <- {:post, CommonAPI.post(user, params)} do

View File

@ -125,8 +125,8 @@ defmodule Pleroma.ActivityTest do
"to" => ["https://www.w3.org/ns/activitystreams#Public"] "to" => ["https://www.w3.org/ns/activitystreams#Public"]
} }
{:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{"status" => "find me!"}) {:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "find me!"})
{:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{"status" => "更新情報"}) {:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "更新情報"})
{:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params) {:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
{:ok, remote_activity} = ObanHelpers.perform(job) {:ok, remote_activity} = ObanHelpers.perform(job)
@ -225,8 +225,8 @@ defmodule Pleroma.ActivityTest do
test "all_by_actor_and_id/2" do test "all_by_actor_and_id/2" do
user = insert(:user) user = insert(:user)
{:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{"status" => "cofe"}) {:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
{:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{"status" => "cofefe"}) {:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofefe"})
assert [] == Activity.all_by_actor_and_id(user, []) assert [] == Activity.all_by_actor_and_id(user, [])

View File

@ -21,8 +21,8 @@ defmodule Pleroma.BBS.HandlerTest do
{:ok, user} = User.follow(user, followed) {:ok, user} = User.follow(user, followed)
{:ok, _first} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, _first} = CommonAPI.post(user, %{status: "hey"})
{:ok, _second} = CommonAPI.post(followed, %{"status" => "hello"}) {:ok, _second} = CommonAPI.post(followed, %{status: "hello"})
output = output =
capture_io(fn -> capture_io(fn ->
@ -62,7 +62,7 @@ defmodule Pleroma.BBS.HandlerTest do
user = insert(:user) user = insert(:user)
another_user = insert(:user) another_user = insert(:user)
{:ok, activity} = CommonAPI.post(another_user, %{"status" => "this is a test post"}) {:ok, activity} = CommonAPI.post(another_user, %{status: "this is a test post"})
activity_object = Object.normalize(activity) activity_object = Object.normalize(activity)
output = output =

View File

@ -11,7 +11,7 @@ defmodule Pleroma.BookmarkTest do
describe "create/2" do describe "create/2" do
test "with valid params" do test "with valid params" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Some cool information"}) {:ok, activity} = CommonAPI.post(user, %{status: "Some cool information"})
{:ok, bookmark} = Bookmark.create(user.id, activity.id) {:ok, bookmark} = Bookmark.create(user.id, activity.id)
assert bookmark.user_id == user.id assert bookmark.user_id == user.id
assert bookmark.activity_id == activity.id assert bookmark.activity_id == activity.id
@ -32,7 +32,7 @@ defmodule Pleroma.BookmarkTest do
test "with valid params" do test "with valid params" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Some cool information"}) {:ok, activity} = CommonAPI.post(user, %{status: "Some cool information"})
{:ok, _bookmark} = Bookmark.create(user.id, activity.id) {:ok, _bookmark} = Bookmark.create(user.id, activity.id)
{:ok, _deleted_bookmark} = Bookmark.destroy(user.id, activity.id) {:ok, _deleted_bookmark} = Bookmark.destroy(user.id, activity.id)
@ -45,7 +45,7 @@ defmodule Pleroma.BookmarkTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"Scientists Discover The Secret Behind Tenshi Eating A Corndog Being So Cute Science Daily" "Scientists Discover The Secret Behind Tenshi Eating A Corndog Being So Cute Science Daily"
}) })

View File

@ -16,7 +16,7 @@ defmodule Pleroma.Conversation.ParticipationTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hey @#{other_user.nickname}.", visibility: "direct"})
[participation] = Participation.for_user(user) [participation] = Participation.for_user(user)
@ -30,7 +30,7 @@ defmodule Pleroma.Conversation.ParticipationTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, _} = {:ok, _} =
CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hey @#{other_user.nickname}.", visibility: "direct"})
user = User.get_cached_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_cached_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
@ -43,9 +43,9 @@ defmodule Pleroma.Conversation.ParticipationTest do
{:ok, _} = {:ok, _} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Hey @#{user.nickname}.", status: "Hey @#{user.nickname}.",
"visibility" => "direct", visibility: "direct",
"in_reply_to_conversation_id" => participation.id in_reply_to_conversation_id: participation.id
}) })
user = User.get_cached_by_id(user.id) user = User.get_cached_by_id(user.id)
@ -64,7 +64,7 @@ defmodule Pleroma.Conversation.ParticipationTest do
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hey @#{other_user.nickname}.", visibility: "direct"})
user = User.get_cached_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_cached_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
@ -79,9 +79,9 @@ defmodule Pleroma.Conversation.ParticipationTest do
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"in_reply_to_status_id" => activity.id, in_reply_to_status_id: activity.id,
"status" => "Hey @#{third_user.nickname}.", status: "Hey @#{third_user.nickname}.",
"visibility" => "direct" visibility: "direct"
}) })
[participation] = Participation.for_user(user) [participation] = Participation.for_user(user)
@ -154,14 +154,14 @@ defmodule Pleroma.Conversation.ParticipationTest do
test "gets all the participations for a user, ordered by updated at descending" do test "gets all the participations for a user, ordered by updated at descending" do
user = insert(:user) user = insert(:user)
{:ok, activity_one} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"}) {:ok, activity_one} = CommonAPI.post(user, %{status: "x", visibility: "direct"})
{:ok, activity_two} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"}) {:ok, activity_two} = CommonAPI.post(user, %{status: "x", visibility: "direct"})
{:ok, activity_three} = {:ok, activity_three} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "x", status: "x",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => activity_one.id in_reply_to_status_id: activity_one.id
}) })
# Offset participations because the accuracy of updated_at is down to a second # Offset participations because the accuracy of updated_at is down to a second
@ -201,7 +201,7 @@ defmodule Pleroma.Conversation.ParticipationTest do
test "Doesn't die when the conversation gets empty" do test "Doesn't die when the conversation gets empty" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
[participation] = Participation.for_user_with_last_activity_id(user) [participation] = Participation.for_user_with_last_activity_id(user)
assert participation.last_activity_id == activity.id assert participation.last_activity_id == activity.id
@ -215,7 +215,7 @@ defmodule Pleroma.Conversation.ParticipationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, _activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, _activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
[participation] = Participation.for_user_with_last_activity_id(user) [participation] = Participation.for_user_with_last_activity_id(user)
participation = Repo.preload(participation, :recipients) participation = Repo.preload(participation, :recipients)
@ -239,26 +239,26 @@ defmodule Pleroma.Conversation.ParticipationTest do
{:ok, _direct1} = {:ok, _direct1} =
CommonAPI.post(third_user, %{ CommonAPI.post(third_user, %{
"status" => "Hi @#{blocker.nickname}", status: "Hi @#{blocker.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, _direct2} = {:ok, _direct2} =
CommonAPI.post(third_user, %{ CommonAPI.post(third_user, %{
"status" => "Hi @#{blocker.nickname}, @#{blocked.nickname}", status: "Hi @#{blocker.nickname}, @#{blocked.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, _direct3} = {:ok, _direct3} =
CommonAPI.post(blocked, %{ CommonAPI.post(blocked, %{
"status" => "Hi @#{blocker.nickname}", status: "Hi @#{blocker.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, _direct4} = {:ok, _direct4} =
CommonAPI.post(blocked, %{ CommonAPI.post(blocked, %{
"status" => "Hi @#{blocker.nickname}, @#{third_user.nickname}", status: "Hi @#{blocker.nickname}, @#{third_user.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
assert [%{read: false}, %{read: false}, %{read: false}, %{read: false}] = assert [%{read: false}, %{read: false}, %{read: false}, %{read: false}] =
@ -293,8 +293,8 @@ defmodule Pleroma.Conversation.ParticipationTest do
# When the blocked user is the author # When the blocked user is the author
{:ok, _direct1} = {:ok, _direct1} =
CommonAPI.post(blocked, %{ CommonAPI.post(blocked, %{
"status" => "Hi @#{blocker.nickname}", status: "Hi @#{blocker.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
assert [%{read: true}] = Participation.for_user(blocker) assert [%{read: true}] = Participation.for_user(blocker)
@ -303,8 +303,8 @@ defmodule Pleroma.Conversation.ParticipationTest do
# When the blocked user is a recipient # When the blocked user is a recipient
{:ok, _direct2} = {:ok, _direct2} =
CommonAPI.post(third_user, %{ CommonAPI.post(third_user, %{
"status" => "Hi @#{blocker.nickname}, @#{blocked.nickname}", status: "Hi @#{blocker.nickname}, @#{blocked.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
assert [%{read: true}, %{read: true}] = Participation.for_user(blocker) assert [%{read: true}, %{read: true}] = Participation.for_user(blocker)
@ -321,8 +321,8 @@ defmodule Pleroma.Conversation.ParticipationTest do
{:ok, _direct1} = {:ok, _direct1} =
CommonAPI.post(blocker, %{ CommonAPI.post(blocker, %{
"status" => "Hi @#{third_user.nickname}, @#{blocked.nickname}", status: "Hi @#{third_user.nickname}, @#{blocked.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, _user_relationship} = User.block(blocker, blocked) {:ok, _user_relationship} = User.block(blocker, blocked)
@ -334,9 +334,9 @@ defmodule Pleroma.Conversation.ParticipationTest do
# When it's a reply from the blocked user # When it's a reply from the blocked user
{:ok, _direct2} = {:ok, _direct2} =
CommonAPI.post(blocked, %{ CommonAPI.post(blocked, %{
"status" => "reply", status: "reply",
"visibility" => "direct", visibility: "direct",
"in_reply_to_conversation_id" => blocked_participation.id in_reply_to_conversation_id: blocked_participation.id
}) })
assert [%{read: true}] = Participation.for_user(blocker) assert [%{read: true}] = Participation.for_user(blocker)
@ -347,9 +347,9 @@ defmodule Pleroma.Conversation.ParticipationTest do
# When it's a reply from the third user # When it's a reply from the third user
{:ok, _direct3} = {:ok, _direct3} =
CommonAPI.post(third_user, %{ CommonAPI.post(third_user, %{
"status" => "reply", status: "reply",
"visibility" => "direct", visibility: "direct",
"in_reply_to_conversation_id" => third_user_participation.id in_reply_to_conversation_id: third_user_participation.id
}) })
assert [%{read: true}] = Participation.for_user(blocker) assert [%{read: true}] = Participation.for_user(blocker)

View File

@ -18,7 +18,7 @@ defmodule Pleroma.ConversationTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"visibility" => "direct", "status" => "hey @#{other_user.nickname}"}) CommonAPI.post(user, %{visibility: "direct", status: "hey @#{other_user.nickname}"})
Pleroma.Tests.ObanHelpers.perform_all() Pleroma.Tests.ObanHelpers.perform_all()
@ -46,7 +46,7 @@ defmodule Pleroma.ConversationTest do
test "public posts don't create conversations" do test "public posts don't create conversations" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "Hey"})
object = Pleroma.Object.normalize(activity) object = Pleroma.Object.normalize(activity)
context = object.data["context"] context = object.data["context"]
@ -62,7 +62,7 @@ defmodule Pleroma.ConversationTest do
tridi = insert(:user) tridi = insert(:user)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"}) CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct"})
object = Pleroma.Object.normalize(activity) object = Pleroma.Object.normalize(activity)
context = object.data["context"] context = object.data["context"]
@ -81,9 +81,9 @@ defmodule Pleroma.ConversationTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(jafnhar, %{ CommonAPI.post(jafnhar, %{
"status" => "Hey @#{har.nickname}", status: "Hey @#{har.nickname}",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
object = Pleroma.Object.normalize(activity) object = Pleroma.Object.normalize(activity)
@ -105,9 +105,9 @@ defmodule Pleroma.ConversationTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(tridi, %{ CommonAPI.post(tridi, %{
"status" => "Hey @#{har.nickname}", status: "Hey @#{har.nickname}",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
object = Pleroma.Object.normalize(activity) object = Pleroma.Object.normalize(activity)
@ -149,14 +149,14 @@ defmodule Pleroma.ConversationTest do
jafnhar = insert(:user, local: false) jafnhar = insert(:user, local: false)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"}) CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "direct"})
{:ok, conversation} = Conversation.create_or_bump_for(activity) {:ok, conversation} = Conversation.create_or_bump_for(activity)
assert length(conversation.participations) == 2 assert length(conversation.participations) == 2
{:ok, activity} = {:ok, activity} =
CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "public"}) CommonAPI.post(har, %{status: "Hey @#{jafnhar.nickname}", visibility: "public"})
assert {:error, _} = Conversation.create_or_bump_for(activity) assert {:error, _} = Conversation.create_or_bump_for(activity)
end end

View File

@ -171,7 +171,7 @@ defmodule Pleroma.HTMLTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"I think I just found the best github repo https://github.com/komeiji-satori/Dress" "I think I just found the best github repo https://github.com/komeiji-satori/Dress"
}) })
@ -186,7 +186,7 @@ defmodule Pleroma.HTMLTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"@#{other_user.nickname} install misskey! https://github.com/syuilo/misskey/blob/develop/docs/setup.en.md" "@#{other_user.nickname} install misskey! https://github.com/syuilo/misskey/blob/develop/docs/setup.en.md"
}) })
@ -203,8 +203,7 @@ defmodule Pleroma.HTMLTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status: "#cofe https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140"
"#cofe https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140"
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -218,9 +217,9 @@ defmodule Pleroma.HTMLTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"<a href=\"https://pleroma.gov/tags/cofe\" rel=\"tag\">#cofe</a> https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140", "<a href=\"https://pleroma.gov/tags/cofe\" rel=\"tag\">#cofe</a> https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140",
"content_type" => "text/html" content_type: "text/html"
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -232,8 +231,7 @@ defmodule Pleroma.HTMLTest do
test "does not crash when there is an HTML entity in a link" do test "does not crash when there is an HTML entity in a link" do
user = insert(:user) user = insert(:user)
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "\"http://cofe.com/?boomer=ok&foo=bar\""})
CommonAPI.post(user, %{"status" => "\"http://cofe.com/?boomer=ok&foo=bar\""})
object = Object.normalize(activity) object = Object.normalize(activity)

View File

@ -55,7 +55,7 @@ defmodule Pleroma.Integration.MastodonWebsocketTest do
test "receives well formatted events" do test "receives well formatted events" do
user = insert(:user) user = insert(:user)
{:ok, _} = start_socket("?stream=public") {:ok, _} = start_socket("?stream=public")
{:ok, activity} = CommonAPI.post(user, %{"status" => "nice echo chamber"}) {:ok, activity} = CommonAPI.post(user, %{status: "nice echo chamber"})
assert_receive {:text, raw_json}, 1_000 assert_receive {:text, raw_json}, 1_000
assert {:ok, json} = Jason.decode(raw_json) assert {:ok, json} = Jason.decode(raw_json)

View File

@ -25,7 +25,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"}) {:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "") {:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "")
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
@ -40,7 +40,7 @@ defmodule Pleroma.NotificationTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname} and @#{third_user.nickname}" status: "hey @#{other_user.nickname} and @#{third_user.nickname}"
}) })
{:ok, [notification, other_notification]} = Notification.create_notifications(activity) {:ok, [notification, other_notification]} = Notification.create_notifications(activity)
@ -60,7 +60,7 @@ defmodule Pleroma.NotificationTest do
User.subscribe(subscriber, user) User.subscribe(subscriber, user)
{:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"}) {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
{:ok, [notification]} = Notification.create_notifications(status) {:ok, [notification]} = Notification.create_notifications(status)
assert notification.user_id == subscriber.id assert notification.user_id == subscriber.id
@ -73,12 +73,12 @@ defmodule Pleroma.NotificationTest do
User.subscribe(subscriber, other_user) User.subscribe(subscriber, other_user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
{:ok, _reply_activity} = {:ok, _reply_activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "test reply", status: "test reply",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
user_notifications = Notification.for_user(user) user_notifications = Notification.for_user(user)
@ -98,7 +98,7 @@ defmodule Pleroma.NotificationTest do
blocker = insert(:user) blocker = insert(:user)
{:ok, _user_relationship} = User.block(blocker, user) {:ok, _user_relationship} = User.block(blocker, user)
{:ok, _activity} = CommonAPI.post(user, %{"status" => "hey @#{blocker.nickname}!"}) {:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{blocker.nickname}!"})
blocker_id = blocker.id blocker_id = blocker.id
assert [%Notification{user_id: ^blocker_id}] = Repo.all(Notification) assert [%Notification{user_id: ^blocker_id}] = Repo.all(Notification)
@ -113,7 +113,7 @@ defmodule Pleroma.NotificationTest do
muter = insert(:user) muter = insert(:user)
{:ok, _user_relationships} = User.mute(muter, user) {:ok, _user_relationships} = User.mute(muter, user)
{:ok, _activity} = CommonAPI.post(user, %{"status" => "hey @#{muter.nickname}!"}) {:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{muter.nickname}!"})
muter_id = muter.id muter_id = muter.id
assert [%Notification{user_id: ^muter_id}] = Repo.all(Notification) assert [%Notification{user_id: ^muter_id}] = Repo.all(Notification)
@ -127,14 +127,14 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
thread_muter = insert(:user) thread_muter = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{thread_muter.nickname}!"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{thread_muter.nickname}!"})
{:ok, _} = CommonAPI.add_mute(thread_muter, activity) {:ok, _} = CommonAPI.add_mute(thread_muter, activity)
{:ok, _same_context_activity} = {:ok, _same_context_activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey-hey-hey @#{thread_muter.nickname}!", status: "hey-hey-hey @#{thread_muter.nickname}!",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
[pre_mute_notification, post_mute_notification] = [pre_mute_notification, post_mute_notification] =
@ -202,7 +202,7 @@ defmodule Pleroma.NotificationTest do
muted = insert(:user) muted = insert(:user)
{:ok, _} = User.mute(muter, muted) {:ok, _} = User.mute(muter, muted)
muter = Repo.get(User, muter.id) muter = Repo.get(User, muter.id)
{:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"}) {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})
assert Notification.create_notification(activity, muter) assert Notification.create_notification(activity, muter)
end end
@ -213,7 +213,7 @@ defmodule Pleroma.NotificationTest do
{:ok, _user_relationships} = User.mute(muter, muted, false) {:ok, _user_relationships} = User.mute(muter, muted, false)
{:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"}) {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})
assert Notification.create_notification(activity, muter) assert Notification.create_notification(activity, muter)
end end
@ -221,13 +221,13 @@ defmodule Pleroma.NotificationTest do
test "it creates a notification for an activity from a muted thread" do test "it creates a notification for an activity from a muted thread" do
muter = insert(:user) muter = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(muter, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(muter, %{status: "hey"})
CommonAPI.add_mute(muter, activity) CommonAPI.add_mute(muter, activity)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Hi @#{muter.nickname}", status: "Hi @#{muter.nickname}",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
assert Notification.create_notification(activity, muter) assert Notification.create_notification(activity, muter)
@ -240,7 +240,7 @@ defmodule Pleroma.NotificationTest do
insert(:user, notification_settings: %Pleroma.User.NotificationSetting{followers: false}) insert(:user, notification_settings: %Pleroma.User.NotificationSetting{followers: false})
User.follow(follower, followed) User.follow(follower, followed)
{:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"}) {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
refute Notification.create_notification(activity, followed) refute Notification.create_notification(activity, followed)
end end
@ -252,7 +252,7 @@ defmodule Pleroma.NotificationTest do
notification_settings: %Pleroma.User.NotificationSetting{non_followers: false} notification_settings: %Pleroma.User.NotificationSetting{non_followers: false}
) )
{:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"}) {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
refute Notification.create_notification(activity, followed) refute Notification.create_notification(activity, followed)
end end
@ -263,7 +263,7 @@ defmodule Pleroma.NotificationTest do
followed = insert(:user) followed = insert(:user)
User.follow(follower, followed) User.follow(follower, followed)
follower = Repo.get(User, follower.id) follower = Repo.get(User, follower.id)
{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"}) {:ok, activity} = CommonAPI.post(followed, %{status: "hey @#{follower.nickname}"})
refute Notification.create_notification(activity, follower) refute Notification.create_notification(activity, follower)
end end
@ -272,7 +272,7 @@ defmodule Pleroma.NotificationTest do
insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false}) insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false})
followed = insert(:user) followed = insert(:user)
{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"}) {:ok, activity} = CommonAPI.post(followed, %{status: "hey @#{follower.nickname}"})
refute Notification.create_notification(activity, follower) refute Notification.create_notification(activity, follower)
end end
@ -289,7 +289,7 @@ defmodule Pleroma.NotificationTest do
{:ok, _, _, _} = CommonAPI.follow(subscriber, user) {:ok, _, _, _} = CommonAPI.follow(subscriber, user)
User.subscribe(subscriber, user) User.subscribe(subscriber, user)
{:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"}) {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
{:ok, [_notif]} = Notification.create_notifications(status) {:ok, [_notif]} = Notification.create_notifications(status)
end end
@ -299,7 +299,7 @@ defmodule Pleroma.NotificationTest do
User.subscribe(subscriber, user) User.subscribe(subscriber, user)
{:ok, status} = CommonAPI.post(user, %{"status" => "inwisible", "visibility" => "direct"}) {:ok, status} = CommonAPI.post(user, %{status: "inwisible", visibility: "direct"})
assert {:ok, []} == Notification.create_notifications(status) assert {:ok, []} == Notification.create_notifications(status)
end end
@ -370,7 +370,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
{:ok, notification} = Notification.get(other_user, notification.id) {:ok, notification} = Notification.get(other_user, notification.id)
@ -382,7 +382,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
{:error, _notification} = Notification.get(user, notification.id) {:error, _notification} = Notification.get(user, notification.id)
@ -394,7 +394,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
{:ok, notification} = Notification.dismiss(other_user, notification.id) {:ok, notification} = Notification.dismiss(other_user, notification.id)
@ -406,7 +406,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
{:error, _notification} = Notification.dismiss(user, notification.id) {:error, _notification} = Notification.dismiss(user, notification.id)
@ -421,14 +421,14 @@ defmodule Pleroma.NotificationTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !" status: "hey @#{other_user.nickname} and @#{third_user.nickname} !"
}) })
{:ok, _notifs} = Notification.create_notifications(activity) {:ok, _notifs} = Notification.create_notifications(activity)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !" status: "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
}) })
{:ok, _notifs} = Notification.create_notifications(activity) {:ok, _notifs} = Notification.create_notifications(activity)
@ -446,12 +446,12 @@ defmodule Pleroma.NotificationTest do
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname}!" status: "hey @#{other_user.nickname}!"
}) })
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey again @#{other_user.nickname}!" status: "hey again @#{other_user.nickname}!"
}) })
[n2, n1] = notifs = Notification.for_user(other_user) [n2, n1] = notifs = Notification.for_user(other_user)
@ -461,7 +461,7 @@ defmodule Pleroma.NotificationTest do
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey yet again @#{other_user.nickname}!" status: "hey yet again @#{other_user.nickname}!"
}) })
Notification.set_read_up_to(other_user, n2.id) Notification.set_read_up_to(other_user, n2.id)
@ -500,7 +500,7 @@ defmodule Pleroma.NotificationTest do
Enum.each(0..10, fn i -> Enum.each(0..10, fn i ->
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user1, %{ CommonAPI.post(user1, %{
"status" => "hey ##{i} @#{user2.nickname}!" status: "hey ##{i} @#{user2.nickname}!"
}) })
end) end)
@ -536,7 +536,7 @@ defmodule Pleroma.NotificationTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname}!" status: "hey @#{other_user.nickname}!"
}) })
{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity) {enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)
@ -605,7 +605,7 @@ defmodule Pleroma.NotificationTest do
{:ok, activity_one} = {:ok, activity_one} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname}!" status: "hey @#{other_user.nickname}!"
}) })
{:ok, activity_two} = CommonAPI.favorite(third_user, activity_one.id) {:ok, activity_two} = CommonAPI.favorite(third_user, activity_one.id)
@ -623,7 +623,7 @@ defmodule Pleroma.NotificationTest do
{:ok, activity_one} = {:ok, activity_one} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname}!" status: "hey @#{other_user.nickname}!"
}) })
{:ok, like_data, _} = Builder.like(third_user, activity_one.object) {:ok, like_data, _} = Builder.like(third_user, activity_one.object)
@ -645,7 +645,7 @@ defmodule Pleroma.NotificationTest do
{:ok, activity_one} = {:ok, activity_one} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname}!" status: "hey @#{other_user.nickname}!"
}) })
{:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user) {:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)
@ -661,7 +661,7 @@ defmodule Pleroma.NotificationTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, _user_relationship} = User.block(other_user, user) {:ok, _user_relationship} = User.block(other_user, user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity) {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
@ -674,7 +674,7 @@ defmodule Pleroma.NotificationTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, _user_relationships} = User.mute(other_user, user) {:ok, _user_relationships} = User.mute(other_user, user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity) {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
@ -686,14 +686,14 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
{:ok, _} = CommonAPI.add_mute(other_user, activity) {:ok, _} = CommonAPI.add_mute(other_user, activity)
{:ok, same_context_activity} = {:ok, same_context_activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey-hey-hey @#{other_user.nickname}!", status: "hey-hey-hey @#{other_user.nickname}!",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
{enabled_receivers, disabled_receivers} = {enabled_receivers, disabled_receivers} =
@ -710,7 +710,7 @@ defmodule Pleroma.NotificationTest do
{:ok, other_user} = User.block_domain(other_user, blocked_domain) {:ok, other_user} = User.block_domain(other_user, blocked_domain)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity) {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
@ -726,7 +726,7 @@ defmodule Pleroma.NotificationTest do
{:ok, other_user} = User.block_domain(other_user, blocked_domain) {:ok, other_user} = User.block_domain(other_user, blocked_domain)
{:ok, other_user} = User.follow(other_user, user) {:ok, other_user} = User.follow(other_user, user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}!"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity) {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
@ -740,7 +740,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
assert Enum.empty?(Notification.for_user(user)) assert Enum.empty?(Notification.for_user(user))
@ -757,7 +757,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
assert Enum.empty?(Notification.for_user(user)) assert Enum.empty?(Notification.for_user(user))
@ -774,7 +774,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
assert Enum.empty?(Notification.for_user(user)) assert Enum.empty?(Notification.for_user(user))
@ -791,7 +791,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
assert Enum.empty?(Notification.for_user(user)) assert Enum.empty?(Notification.for_user(user))
@ -808,7 +808,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
assert Enum.empty?(Notification.for_user(user)) assert Enum.empty?(Notification.for_user(user))
@ -825,7 +825,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
assert Enum.empty?(Notification.for_user(user)) assert Enum.empty?(Notification.for_user(user))
@ -842,13 +842,13 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user) {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
{:ok, _reply_activity} = {:ok, _reply_activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "test reply", status: "test reply",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
assert Enum.empty?(Notification.for_user(user)) assert Enum.empty?(Notification.for_user(user))
@ -859,7 +859,7 @@ defmodule Pleroma.NotificationTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}", "visibility" => "direct"}) CommonAPI.post(user, %{status: "hi @#{other_user.nickname}", visibility: "direct"})
refute Enum.empty?(Notification.for_user(other_user)) refute Enum.empty?(Notification.for_user(other_user))
@ -970,7 +970,7 @@ defmodule Pleroma.NotificationTest do
muted = insert(:user) muted = insert(:user)
{:ok, _user_relationships} = User.mute(user, muted, false) {:ok, _user_relationships} = User.mute(user, muted, false)
{:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
assert length(Notification.for_user(user)) == 1 assert length(Notification.for_user(user)) == 1
end end
@ -980,7 +980,7 @@ defmodule Pleroma.NotificationTest do
muted = insert(:user) muted = insert(:user)
{:ok, _user_relationships} = User.mute(user, muted) {:ok, _user_relationships} = User.mute(user, muted)
{:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
assert Notification.for_user(user) == [] assert Notification.for_user(user) == []
end end
@ -990,7 +990,7 @@ defmodule Pleroma.NotificationTest do
blocked = insert(:user) blocked = insert(:user)
{:ok, _user_relationship} = User.block(user, blocked) {:ok, _user_relationship} = User.block(user, blocked)
{:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
assert Notification.for_user(user) == [] assert Notification.for_user(user) == []
end end
@ -1000,7 +1000,7 @@ defmodule Pleroma.NotificationTest do
blocked = insert(:user, ap_id: "http://some-domain.com") blocked = insert(:user, ap_id: "http://some-domain.com")
{:ok, user} = User.block_domain(user, "some-domain.com") {:ok, user} = User.block_domain(user, "some-domain.com")
{:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
assert Notification.for_user(user) == [] assert Notification.for_user(user) == []
end end
@ -1012,7 +1012,7 @@ defmodule Pleroma.NotificationTest do
{:ok, user} = User.block_domain(user, "some-domain.com") {:ok, user} = User.block_domain(user, "some-domain.com")
{:ok, _} = User.follow(user, blocked) {:ok, _} = User.follow(user, blocked)
{:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
assert length(Notification.for_user(user)) == 1 assert length(Notification.for_user(user)) == 1
end end
@ -1021,7 +1021,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
another_user = insert(:user) another_user = insert(:user)
{:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})
{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"]) {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
assert Notification.for_user(user) == [] assert Notification.for_user(user) == []
@ -1032,7 +1032,7 @@ defmodule Pleroma.NotificationTest do
muted = insert(:user) muted = insert(:user)
{:ok, _user_relationships} = User.mute(user, muted) {:ok, _user_relationships} = User.mute(user, muted)
{:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
assert length(Notification.for_user(user, %{with_muted: true})) == 1 assert length(Notification.for_user(user, %{with_muted: true})) == 1
end end
@ -1042,7 +1042,7 @@ defmodule Pleroma.NotificationTest do
blocked = insert(:user) blocked = insert(:user)
{:ok, _user_relationship} = User.block(user, blocked) {:ok, _user_relationship} = User.block(user, blocked)
{:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
assert Enum.empty?(Notification.for_user(user, %{with_muted: true})) assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
end end
@ -1053,7 +1053,7 @@ defmodule Pleroma.NotificationTest do
blocked = insert(:user, ap_id: "http://some-domain.com") blocked = insert(:user, ap_id: "http://some-domain.com")
{:ok, user} = User.block_domain(user, "some-domain.com") {:ok, user} = User.block_domain(user, "some-domain.com")
{:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
assert Enum.empty?(Notification.for_user(user, %{with_muted: true})) assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
end end
@ -1062,7 +1062,7 @@ defmodule Pleroma.NotificationTest do
user = insert(:user) user = insert(:user)
another_user = insert(:user) another_user = insert(:user)
{:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})
{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"]) {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
assert length(Notification.for_user(user, %{with_muted: true})) == 1 assert length(Notification.for_user(user, %{with_muted: true})) == 1

View File

@ -22,26 +22,26 @@ defmodule Pleroma.StatsTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"}) CommonAPI.post(user, %{visibility: "public", status: "hey"})
Enum.each(0..1, fn _ -> Enum.each(0..1, fn _ ->
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "unlisted", visibility: "unlisted",
"status" => "hey" status: "hey"
}) })
end) end)
Enum.each(0..2, fn _ -> Enum.each(0..2, fn _ ->
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "direct", visibility: "direct",
"status" => "hey @#{other_user.nickname}" status: "hey @#{other_user.nickname}"
}) })
end) end)
Enum.each(0..3, fn _ -> Enum.each(0..3, fn _ ->
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "private", visibility: "private",
"status" => "hey" status: "hey"
}) })
end) end)
@ -51,7 +51,7 @@ defmodule Pleroma.StatsTest do
test "on status delete" do test "on status delete" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
assert %{public: 1} = Pleroma.Stats.get_status_visibility_count() assert %{public: 1} = Pleroma.Stats.get_status_visibility_count()
CommonAPI.delete(activity.id, user) CommonAPI.delete(activity.id, user)
assert %{public: 0} = Pleroma.Stats.get_status_visibility_count() assert %{public: 0} = Pleroma.Stats.get_status_visibility_count()
@ -59,16 +59,16 @@ defmodule Pleroma.StatsTest do
test "on status visibility update" do test "on status visibility update" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
assert %{public: 1, private: 0} = Pleroma.Stats.get_status_visibility_count() assert %{public: 1, private: 0} = Pleroma.Stats.get_status_visibility_count()
{:ok, _} = CommonAPI.update_activity_scope(activity.id, %{"visibility" => "private"}) {:ok, _} = CommonAPI.update_activity_scope(activity.id, %{visibility: "private"})
assert %{public: 0, private: 1} = Pleroma.Stats.get_status_visibility_count() assert %{public: 0, private: 1} = Pleroma.Stats.get_status_visibility_count()
end end
test "doesn't count unrelated activities" do test "doesn't count unrelated activities" do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
_ = CommonAPI.follow(user, other_user) _ = CommonAPI.follow(user, other_user)
CommonAPI.favorite(other_user, activity.id) CommonAPI.favorite(other_user, activity.id)
CommonAPI.repeat(activity.id, other_user) CommonAPI.repeat(activity.id, other_user)

View File

@ -13,11 +13,11 @@ defmodule Mix.Tasks.Pleroma.CountStatusesTest do
test "counts statuses" do test "counts statuses" do
user = insert(:user) user = insert(:user)
{:ok, _} = CommonAPI.post(user, %{"status" => "test"}) {:ok, _} = CommonAPI.post(user, %{status: "test"})
{:ok, _} = CommonAPI.post(user, %{"status" => "test2"}) {:ok, _} = CommonAPI.post(user, %{status: "test2"})
user2 = insert(:user) user2 = insert(:user)
{:ok, _} = CommonAPI.post(user2, %{"status" => "test3"}) {:ok, _} = CommonAPI.post(user2, %{status: "test3"})
user = refresh_record(user) user = refresh_record(user)
user2 = refresh_record(user2) user2 = refresh_record(user2)

View File

@ -26,7 +26,7 @@ defmodule Mix.Tasks.Pleroma.DatabaseTest do
describe "running remove_embedded_objects" do describe "running remove_embedded_objects" do
test "it replaces objects with references" do test "it replaces objects with references" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test"}) {:ok, activity} = CommonAPI.post(user, %{status: "test"})
new_data = Map.put(activity.data, "object", activity.object.data) new_data = Map.put(activity.data, "object", activity.object.data)
{:ok, activity} = {:ok, activity} =
@ -99,8 +99,8 @@ defmodule Mix.Tasks.Pleroma.DatabaseTest do
test "it turns OrderedCollection likes into empty arrays" do test "it turns OrderedCollection likes into empty arrays" do
[user, user2] = insert_pair(:user) [user, user2] = insert_pair(:user)
{:ok, %{id: id, object: object}} = CommonAPI.post(user, %{"status" => "test"}) {:ok, %{id: id, object: object}} = CommonAPI.post(user, %{status: "test"})
{:ok, %{object: object2}} = CommonAPI.post(user, %{"status" => "test test"}) {:ok, %{object: object2}} = CommonAPI.post(user, %{status: "test test"})
CommonAPI.favorite(user2, id) CommonAPI.favorite(user2, id)

View File

@ -25,7 +25,7 @@ defmodule Mix.Tasks.Pleroma.DigestTest do
Enum.each(0..10, fn i -> Enum.each(0..10, fn i ->
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user1, %{ CommonAPI.post(user1, %{
"status" => "hey ##{i} @#{user2.nickname}!" status: "hey ##{i} @#{user2.nickname}!"
}) })
end) end)

View File

@ -12,26 +12,26 @@ defmodule Mix.Tasks.Pleroma.RefreshCounterCacheTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"}) CommonAPI.post(user, %{visibility: "public", status: "hey"})
Enum.each(0..1, fn _ -> Enum.each(0..1, fn _ ->
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "unlisted", visibility: "unlisted",
"status" => "hey" status: "hey"
}) })
end) end)
Enum.each(0..2, fn _ -> Enum.each(0..2, fn _ ->
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "direct", visibility: "direct",
"status" => "hey @#{other_user.nickname}" status: "hey @#{other_user.nickname}"
}) })
end) end)
Enum.each(0..3, fn _ -> Enum.each(0..3, fn _ ->
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "private", visibility: "private",
"status" => "hey" status: "hey"
}) })
end) end)

View File

@ -109,7 +109,7 @@ defmodule Mix.Tasks.Pleroma.UserTest do
test "a remote user's create activity is deleted when the object has been pruned" do test "a remote user's create activity is deleted when the object has been pruned" do
user = insert(:user) user = insert(:user)
{:ok, post} = CommonAPI.post(user, %{"status" => "uguu"}) {:ok, post} = CommonAPI.post(user, %{status: "uguu"})
object = Object.normalize(post) object = Object.normalize(post)
Object.prune(object) Object.prune(object)

View File

@ -990,7 +990,7 @@ defmodule Pleroma.UserTest do
actor = insert(:user) actor = insert(:user)
user = insert(:user, local: true) user = insert(:user, local: true)
{:ok, activity} = CommonAPI.post(actor, %{"status" => "hello"}) {:ok, activity} = CommonAPI.post(actor, %{status: "hello"})
{:ok, announce, _} = CommonAPI.repeat(activity.id, user) {:ok, announce, _} = CommonAPI.repeat(activity.id, user)
recipients = User.get_recipients_from_activity(announce) recipients = User.get_recipients_from_activity(announce)
@ -1007,7 +1007,7 @@ defmodule Pleroma.UserTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(actor, %{ CommonAPI.post(actor, %{
"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}" status: "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
}) })
assert Enum.map([actor, addressed], & &1.ap_id) -- assert Enum.map([actor, addressed], & &1.ap_id) --
@ -1029,7 +1029,7 @@ defmodule Pleroma.UserTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(actor, %{ CommonAPI.post(actor, %{
"status" => "hey @#{addressed.nickname}" status: "hey @#{addressed.nickname}"
}) })
assert Enum.map([actor, addressed], & &1.ap_id) -- assert Enum.map([actor, addressed], & &1.ap_id) --
@ -1090,7 +1090,7 @@ defmodule Pleroma.UserTest do
{:ok, user2} = User.follow(user2, user) {:ok, user2} = User.follow(user2, user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{user2.nickname}"})
activity = Repo.preload(activity, :bookmark) activity = Repo.preload(activity, :bookmark)
@ -1126,7 +1126,7 @@ defmodule Pleroma.UserTest do
setup do: clear_config([:instance, :federating]) setup do: clear_config([:instance, :federating])
test ".delete_user_activities deletes all create activities", %{user: user} do test ".delete_user_activities deletes all create activities", %{user: user} do
{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"}) {:ok, activity} = CommonAPI.post(user, %{status: "2hu"})
User.delete_user_activities(user) User.delete_user_activities(user)
@ -1411,7 +1411,7 @@ defmodule Pleroma.UserTest do
{:ok, _} = {:ok, _} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "hey @#{to.nickname}" status: "hey @#{to.nickname}"
}) })
end) end)
@ -1443,12 +1443,12 @@ defmodule Pleroma.UserTest do
Enum.each(recipients, fn to -> Enum.each(recipients, fn to ->
{:ok, _} = {:ok, _} =
CommonAPI.post(sender, %{ CommonAPI.post(sender, %{
"status" => "hey @#{to.nickname}" status: "hey @#{to.nickname}"
}) })
{:ok, _} = {:ok, _} =
CommonAPI.post(sender, %{ CommonAPI.post(sender, %{
"status" => "hey again @#{to.nickname}" status: "hey again @#{to.nickname}"
}) })
end) end)

View File

@ -341,7 +341,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
test "cached purged after activity deletion", %{conn: conn} do test "cached purged after activity deletion", %{conn: conn} do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(user, %{status: "cofe"})
uuid = String.split(activity.data["id"], "/") |> List.last() uuid = String.split(activity.data["id"], "/") |> List.last()

View File

@ -32,7 +32,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
describe "streaming out participations" do describe "streaming out participations" do
test "it streams them out" do test "it streams them out" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity) {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
@ -56,8 +56,8 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
stream: fn _, _ -> nil end do stream: fn _, _ -> nil end do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "@#{user_two.nickname}", status: "@#{user_two.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
conversation = conversation =
@ -74,15 +74,13 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "it restricts by the appropriate visibility" do test "it restricts by the appropriate visibility" do
user = insert(:user) user = insert(:user)
{:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"}) {:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
{:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
{:ok, unlisted_activity} = {:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
{:ok, private_activity} = {:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
activities = activities =
ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id}) ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
@ -118,15 +116,13 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "it excludes by the appropriate visibility" do test "it excludes by the appropriate visibility" do
user = insert(:user) user = insert(:user)
{:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"}) {:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
{:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
{:ok, unlisted_activity} = {:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
{:ok, private_activity} = {:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
activities = activities =
ActivityPub.fetch_activities([], %{ ActivityPub.fetch_activities([], %{
@ -193,9 +189,9 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "it fetches the appropriate tag-restricted posts" do test "it fetches the appropriate tag-restricted posts" do
user = insert(:user) user = insert(:user)
{:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"}) {:ok, status_one} = CommonAPI.post(user, %{status: ". #test"})
{:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"}) {:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
{:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"}) {:ok, status_three} = CommonAPI.post(user, %{status: ". #test #reject"})
fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"}) fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})
@ -432,26 +428,26 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_cached_by_id(user.id), %{ CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "1", status: "1",
"visibility" => "public" visibility: "public"
}) })
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_cached_by_id(user.id), %{ CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "2", status: "2",
"visibility" => "unlisted" visibility: "unlisted"
}) })
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_cached_by_id(user.id), %{ CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "2", status: "2",
"visibility" => "private" visibility: "private"
}) })
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_cached_by_id(user.id), %{ CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "3", status: "3",
"visibility" => "direct" visibility: "direct"
}) })
user = User.get_cached_by_id(user.id) user = User.get_cached_by_id(user.id)
@ -462,27 +458,27 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
user = insert(:user) user = insert(:user)
user2 = insert(:user) user2 = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"}) {:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
ap_id = activity.data["id"] ap_id = activity.data["id"]
reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id} reply_data = %{status: "1", in_reply_to_status_id: activity.id}
# public # public
{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public")) {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id) assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
assert object.data["repliesCount"] == 1 assert object.data["repliesCount"] == 1
# unlisted # unlisted
{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted")) {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id) assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
assert object.data["repliesCount"] == 2 assert object.data["repliesCount"] == 2
# private # private
{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private")) {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id) assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
assert object.data["repliesCount"] == 2 assert object.data["repliesCount"] == 2
# direct # direct
{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct")) {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id) assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
assert object.data["repliesCount"] == 2 assert object.data["repliesCount"] == 2
end end
@ -569,13 +565,13 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, _user_relationship} = User.block(blocker, blockee) {:ok, _user_relationship} = User.block(blocker, blockee)
{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"}) {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})
{:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"}) {:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})
{:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"}) {:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
{:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"}) {:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})
activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker}) activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
@ -592,9 +588,9 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, _user_relationship} = User.block(blocker, blockee) {:ok, _user_relationship} = User.block(blocker, blockee)
{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"}) {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})
{:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"}) {:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
{:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend) {:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)
@ -774,10 +770,9 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "doesn't retrieve unlisted activities" do test "doesn't retrieve unlisted activities" do
user = insert(:user) user = insert(:user)
{:ok, _unlisted_activity} = {:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})
CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"}) {:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})
[activity] = ActivityPub.fetch_public_activities() [activity] = ActivityPub.fetch_public_activities()
@ -912,7 +907,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
describe "announcing a private object" do describe "announcing a private object" do
test "adds an announce activity to the db if the audience is not widened" do test "adds an announce activity to the db if the audience is not widened" do
user = insert(:user) user = insert(:user)
{:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"}) {:ok, note_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
object = Object.normalize(note_activity) object = Object.normalize(note_activity)
{:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false) {:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)
@ -926,7 +921,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "does not add an announce activity to the db if the audience is widened" do test "does not add an announce activity to the db if the audience is widened" do
user = insert(:user) user = insert(:user)
{:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"}) {:ok, note_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
object = Object.normalize(note_activity) object = Object.normalize(note_activity)
assert {:error, _} = ActivityPub.announce(user, object, nil, true, true) assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
@ -935,7 +930,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "does not add an announce activity to the db if the announcer is not the author" do test "does not add an announce activity to the db if the announcer is not the author" do
user = insert(:user) user = insert(:user)
announcer = insert(:user) announcer = insert(:user)
{:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"}) {:ok, note_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
object = Object.normalize(note_activity) object = Object.normalize(note_activity)
assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false) assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
@ -1111,23 +1106,22 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, user3} = User.follow(user3, user2) {:ok, user3} = User.follow(user3, user2)
assert User.following?(user3, user2) assert User.following?(user3, user2)
{:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"}) {:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})
{:ok, private_activity_1} = {:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})
CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
{:ok, private_activity_2} = {:ok, private_activity_2} =
CommonAPI.post(user2, %{ CommonAPI.post(user2, %{
"status" => "hi 3", status: "hi 3",
"visibility" => "private", visibility: "private",
"in_reply_to_status_id" => private_activity_1.id in_reply_to_status_id: private_activity_1.id
}) })
{:ok, private_activity_3} = {:ok, private_activity_3} =
CommonAPI.post(user3, %{ CommonAPI.post(user3, %{
"status" => "hi 4", status: "hi 4",
"visibility" => "private", visibility: "private",
"in_reply_to_status_id" => private_activity_2.id in_reply_to_status_id: private_activity_2.id
}) })
activities = activities =
@ -1177,9 +1171,9 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
Config.put([:instance, :max_pinned_statuses], 3) Config.put([:instance, :max_pinned_statuses], 3)
user = insert(:user) user = insert(:user)
{:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"}) {:ok, activity_one} = CommonAPI.post(user, %{status: "HI!!!"})
{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"}) {:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})
{:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"}) {:ok, activity_three} = CommonAPI.post(user, %{status: "HI!!!"})
CommonAPI.pin(activity_one.id, user) CommonAPI.pin(activity_one.id, user)
user = refresh_record(user) user = refresh_record(user)
@ -1200,7 +1194,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
reporter = insert(:user) reporter = insert(:user)
target_account = insert(:user) target_account = insert(:user)
content = "foobar" content = "foobar"
{:ok, activity} = CommonAPI.post(target_account, %{"status" => content}) {:ok, activity} = CommonAPI.post(target_account, %{status: content})
context = Utils.generate_context_id() context = Utils.generate_context_id()
reporter_ap_id = reporter.ap_id reporter_ap_id = reporter.ap_id
@ -1296,8 +1290,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, list} = Pleroma.List.create("foo", user) {:ok, list} = Pleroma.List.create("foo", user)
{:ok, list} = Pleroma.List.follow(list, member) {:ok, list} = Pleroma.List.follow(list, member)
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
activity = Repo.preload(activity, :bookmark) activity = Repo.preload(activity, :bookmark)
activity = %Activity{activity | thread_muted?: !!activity.thread_muted?} activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
@ -1315,8 +1308,8 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "thought I looked cute might delete later :3", status: "thought I looked cute might delete later :3",
"visibility" => "private" visibility: "private"
}) })
[result] = ActivityPub.fetch_activities_bounded([user.follower_address], []) [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
@ -1325,12 +1318,12 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "fetches only public posts for other users" do test "fetches only public posts for other users" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"}) {:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})
{:ok, _private_activity} = {:ok, _private_activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "why is tenshi eating a corndog so cute?", status: "why is tenshi eating a corndog so cute?",
"visibility" => "private" visibility: "private"
}) })
[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address]) [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
@ -1458,11 +1451,11 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
other_user = insert(:user) other_user = insert(:user)
user1 = insert(:user) user1 = insert(:user)
user2 = insert(:user) user2 = insert(:user)
{:ok, a1} = CommonAPI.post(user1, %{"status" => "bla"}) {:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
{:ok, _a2} = CommonAPI.post(user2, %{"status" => "traps are happy"}) {:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
{:ok, a3} = CommonAPI.post(user2, %{"status" => "Trees Are "}) {:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
{:ok, a4} = CommonAPI.post(user2, %{"status" => "Agent Smith "}) {:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
{:ok, a5} = CommonAPI.post(user1, %{"status" => "Red or Blue "}) {:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})
{:ok, _} = CommonAPI.favorite(user, a4.id) {:ok, _} = CommonAPI.favorite(user, a4.id)
{:ok, _} = CommonAPI.favorite(other_user, a3.id) {:ok, _} = CommonAPI.favorite(other_user, a3.id)
@ -1542,10 +1535,9 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
test "doesn't retrieve replies activities with exclude_replies" do test "doesn't retrieve replies activities with exclude_replies" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"}) {:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
{:ok, _reply} = {:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})
CommonAPI.post(user, %{"status" => "yeah", "in_reply_to_status_id" => activity.id})
[result] = ActivityPub.fetch_public_activities(%{"exclude_replies" => "true"}) [result] = ActivityPub.fetch_public_activities(%{"exclude_replies" => "true"})
@ -1858,84 +1850,84 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, u2} = User.follow(u2, u3) {:ok, u2} = User.follow(u2, u3)
{:ok, u3} = User.follow(u3, u2) {:ok, u3} = User.follow(u3, u2)
{:ok, a1} = CommonAPI.post(u1, %{"status" => "Status"}) {:ok, a1} = CommonAPI.post(u1, %{status: "Status"})
{:ok, r1_1} = {:ok, r1_1} =
CommonAPI.post(u2, %{ CommonAPI.post(u2, %{
"status" => "@#{u1.nickname} reply from u2 to u1", status: "@#{u1.nickname} reply from u2 to u1",
"in_reply_to_status_id" => a1.id in_reply_to_status_id: a1.id
}) })
{:ok, r1_2} = {:ok, r1_2} =
CommonAPI.post(u3, %{ CommonAPI.post(u3, %{
"status" => "@#{u1.nickname} reply from u3 to u1", status: "@#{u1.nickname} reply from u3 to u1",
"in_reply_to_status_id" => a1.id in_reply_to_status_id: a1.id
}) })
{:ok, r1_3} = {:ok, r1_3} =
CommonAPI.post(u4, %{ CommonAPI.post(u4, %{
"status" => "@#{u1.nickname} reply from u4 to u1", status: "@#{u1.nickname} reply from u4 to u1",
"in_reply_to_status_id" => a1.id in_reply_to_status_id: a1.id
}) })
{:ok, a2} = CommonAPI.post(u2, %{"status" => "Status"}) {:ok, a2} = CommonAPI.post(u2, %{status: "Status"})
{:ok, r2_1} = {:ok, r2_1} =
CommonAPI.post(u1, %{ CommonAPI.post(u1, %{
"status" => "@#{u2.nickname} reply from u1 to u2", status: "@#{u2.nickname} reply from u1 to u2",
"in_reply_to_status_id" => a2.id in_reply_to_status_id: a2.id
}) })
{:ok, r2_2} = {:ok, r2_2} =
CommonAPI.post(u3, %{ CommonAPI.post(u3, %{
"status" => "@#{u2.nickname} reply from u3 to u2", status: "@#{u2.nickname} reply from u3 to u2",
"in_reply_to_status_id" => a2.id in_reply_to_status_id: a2.id
}) })
{:ok, r2_3} = {:ok, r2_3} =
CommonAPI.post(u4, %{ CommonAPI.post(u4, %{
"status" => "@#{u2.nickname} reply from u4 to u2", status: "@#{u2.nickname} reply from u4 to u2",
"in_reply_to_status_id" => a2.id in_reply_to_status_id: a2.id
}) })
{:ok, a3} = CommonAPI.post(u3, %{"status" => "Status"}) {:ok, a3} = CommonAPI.post(u3, %{status: "Status"})
{:ok, r3_1} = {:ok, r3_1} =
CommonAPI.post(u1, %{ CommonAPI.post(u1, %{
"status" => "@#{u3.nickname} reply from u1 to u3", status: "@#{u3.nickname} reply from u1 to u3",
"in_reply_to_status_id" => a3.id in_reply_to_status_id: a3.id
}) })
{:ok, r3_2} = {:ok, r3_2} =
CommonAPI.post(u2, %{ CommonAPI.post(u2, %{
"status" => "@#{u3.nickname} reply from u2 to u3", status: "@#{u3.nickname} reply from u2 to u3",
"in_reply_to_status_id" => a3.id in_reply_to_status_id: a3.id
}) })
{:ok, r3_3} = {:ok, r3_3} =
CommonAPI.post(u4, %{ CommonAPI.post(u4, %{
"status" => "@#{u3.nickname} reply from u4 to u3", status: "@#{u3.nickname} reply from u4 to u3",
"in_reply_to_status_id" => a3.id in_reply_to_status_id: a3.id
}) })
{:ok, a4} = CommonAPI.post(u4, %{"status" => "Status"}) {:ok, a4} = CommonAPI.post(u4, %{status: "Status"})
{:ok, r4_1} = {:ok, r4_1} =
CommonAPI.post(u1, %{ CommonAPI.post(u1, %{
"status" => "@#{u4.nickname} reply from u1 to u4", status: "@#{u4.nickname} reply from u1 to u4",
"in_reply_to_status_id" => a4.id in_reply_to_status_id: a4.id
}) })
{:ok, r4_2} = {:ok, r4_2} =
CommonAPI.post(u2, %{ CommonAPI.post(u2, %{
"status" => "@#{u4.nickname} reply from u2 to u4", status: "@#{u4.nickname} reply from u2 to u4",
"in_reply_to_status_id" => a4.id in_reply_to_status_id: a4.id
}) })
{:ok, r4_3} = {:ok, r4_3} =
CommonAPI.post(u3, %{ CommonAPI.post(u3, %{
"status" => "@#{u4.nickname} reply from u3 to u4", status: "@#{u4.nickname} reply from u3 to u4",
"in_reply_to_status_id" => a4.id in_reply_to_status_id: a4.id
}) })
{:ok, {:ok,
@ -1959,68 +1951,68 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
{:ok, u2} = User.follow(u2, u3) {:ok, u2} = User.follow(u2, u3)
{:ok, u3} = User.follow(u3, u2) {:ok, u3} = User.follow(u3, u2)
{:ok, a1} = CommonAPI.post(u1, %{"status" => "Status", "visibility" => "private"}) {:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})
{:ok, r1_1} = {:ok, r1_1} =
CommonAPI.post(u2, %{ CommonAPI.post(u2, %{
"status" => "@#{u1.nickname} reply from u2 to u1", status: "@#{u1.nickname} reply from u2 to u1",
"in_reply_to_status_id" => a1.id, in_reply_to_status_id: a1.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, r1_2} = {:ok, r1_2} =
CommonAPI.post(u3, %{ CommonAPI.post(u3, %{
"status" => "@#{u1.nickname} reply from u3 to u1", status: "@#{u1.nickname} reply from u3 to u1",
"in_reply_to_status_id" => a1.id, in_reply_to_status_id: a1.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, r1_3} = {:ok, r1_3} =
CommonAPI.post(u4, %{ CommonAPI.post(u4, %{
"status" => "@#{u1.nickname} reply from u4 to u1", status: "@#{u1.nickname} reply from u4 to u1",
"in_reply_to_status_id" => a1.id, in_reply_to_status_id: a1.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, a2} = CommonAPI.post(u2, %{"status" => "Status", "visibility" => "private"}) {:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})
{:ok, r2_1} = {:ok, r2_1} =
CommonAPI.post(u1, %{ CommonAPI.post(u1, %{
"status" => "@#{u2.nickname} reply from u1 to u2", status: "@#{u2.nickname} reply from u1 to u2",
"in_reply_to_status_id" => a2.id, in_reply_to_status_id: a2.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, r2_2} = {:ok, r2_2} =
CommonAPI.post(u3, %{ CommonAPI.post(u3, %{
"status" => "@#{u2.nickname} reply from u3 to u2", status: "@#{u2.nickname} reply from u3 to u2",
"in_reply_to_status_id" => a2.id, in_reply_to_status_id: a2.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, a3} = CommonAPI.post(u3, %{"status" => "Status", "visibility" => "private"}) {:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})
{:ok, r3_1} = {:ok, r3_1} =
CommonAPI.post(u1, %{ CommonAPI.post(u1, %{
"status" => "@#{u3.nickname} reply from u1 to u3", status: "@#{u3.nickname} reply from u1 to u3",
"in_reply_to_status_id" => a3.id, in_reply_to_status_id: a3.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, r3_2} = {:ok, r3_2} =
CommonAPI.post(u2, %{ CommonAPI.post(u2, %{
"status" => "@#{u3.nickname} reply from u2 to u3", status: "@#{u3.nickname} reply from u2 to u3",
"in_reply_to_status_id" => a3.id, in_reply_to_status_id: a3.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, a4} = CommonAPI.post(u4, %{"status" => "Status", "visibility" => "private"}) {:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})
{:ok, r4_1} = {:ok, r4_1} =
CommonAPI.post(u1, %{ CommonAPI.post(u1, %{
"status" => "@#{u4.nickname} reply from u1 to u4", status: "@#{u4.nickname} reply from u1 to u4",
"in_reply_to_status_id" => a4.id, in_reply_to_status_id: a4.id,
"visibility" => "private" visibility: "private"
}) })
{:ok, {:ok,

View File

@ -13,7 +13,7 @@ defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
describe "EmojiReacts" do describe "EmojiReacts" do
setup do setup do
user = insert(:user) user = insert(:user)
{:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"}) {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
object = Pleroma.Object.get_by_ap_id(post_activity.data["object"]) object = Pleroma.Object.get_by_ap_id(post_activity.data["object"])
@ -53,7 +53,7 @@ defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
describe "Undos" do describe "Undos" do
setup do setup do
user = insert(:user) user = insert(:user)
{:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"}) {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
{:ok, like} = CommonAPI.favorite(user, post_activity.id) {:ok, like} = CommonAPI.favorite(user, post_activity.id)
{:ok, valid_like_undo, []} = Builder.undo(user, like) {:ok, valid_like_undo, []} = Builder.undo(user, like)
@ -93,7 +93,7 @@ defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
describe "deletes" do describe "deletes" do
setup do setup do
user = insert(:user) user = insert(:user)
{:ok, post_activity} = CommonAPI.post(user, %{"status" => "cancel me daddy"}) {:ok, post_activity} = CommonAPI.post(user, %{status: "cancel me daddy"})
{:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"]) {:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"])
{:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id) {:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id)
@ -185,7 +185,7 @@ defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
describe "likes" do describe "likes" do
setup do setup do
user = insert(:user) user = insert(:user)
{:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"}) {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
valid_like = %{ valid_like = %{
"to" => [user.ap_id], "to" => [user.ap_id],

View File

@ -25,8 +25,8 @@ defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, op} = CommonAPI.post(other_user, %{"status" => "big oof"}) {:ok, op} = CommonAPI.post(other_user, %{status: "big oof"})
{:ok, post} = CommonAPI.post(user, %{"status" => "hey", "in_reply_to_id" => op}) {:ok, post} = CommonAPI.post(user, %{status: "hey", in_reply_to_id: op})
{:ok, favorite} = CommonAPI.favorite(user, post.id) {:ok, favorite} = CommonAPI.favorite(user, post.id)
object = Object.normalize(post) object = Object.normalize(post)
{:ok, delete_data, _meta} = Builder.delete(user, object.data["id"]) {:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
@ -118,7 +118,7 @@ defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
poster = insert(:user) poster = insert(:user)
user = insert(:user) user = insert(:user)
{:ok, post} = CommonAPI.post(poster, %{"status" => "hey"}) {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
{:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌") {:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
{:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true) {:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)
@ -144,7 +144,7 @@ defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
setup do setup do
poster = insert(:user) poster = insert(:user)
user = insert(:user) user = insert(:user)
{:ok, post} = CommonAPI.post(poster, %{"status" => "hey"}) {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
{:ok, like} = CommonAPI.favorite(user, post.id) {:ok, like} = CommonAPI.favorite(user, post.id)
{:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍") {:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
{:ok, announce, _} = CommonAPI.repeat(post.id, user) {:ok, announce, _} = CommonAPI.repeat(post.id, user)
@ -244,7 +244,7 @@ defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
setup do setup do
poster = insert(:user) poster = insert(:user)
user = insert(:user) user = insert(:user)
{:ok, post} = CommonAPI.post(poster, %{"status" => "hey"}) {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
{:ok, like_data, _meta} = Builder.like(user, post.object) {:ok, like_data, _meta} = Builder.like(user, post.object)
{:ok, like, _meta} = ActivityPub.persist(like_data, local: true) {:ok, like, _meta} = ActivityPub.persist(like_data, local: true)

View File

@ -15,7 +15,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.EmojiReactHandlingTest do
test "it works for incoming emoji reactions" do test "it works for incoming emoji reactions" do
user = insert(:user) user = insert(:user)
other_user = insert(:user, local: false) other_user = insert(:user, local: false)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"}) {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
data = data =
File.read!("test/fixtures/emoji-reaction.json") File.read!("test/fixtures/emoji-reaction.json")
@ -40,7 +40,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.EmojiReactHandlingTest do
test "it reject invalid emoji reactions" do test "it reject invalid emoji reactions" do
user = insert(:user) user = insert(:user)
other_user = insert(:user, local: false) other_user = insert(:user, local: false)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"}) {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
data = data =
File.read!("test/fixtures/emoji-reaction-too-long.json") File.read!("test/fixtures/emoji-reaction-too-long.json")

View File

@ -14,7 +14,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.LikeHandlingTest do
test "it works for incoming likes" do test "it works for incoming likes" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"}) {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
data = data =
File.read!("test/fixtures/mastodon-like.json") File.read!("test/fixtures/mastodon-like.json")
@ -36,7 +36,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.LikeHandlingTest do
test "it works for incoming misskey likes, turning them into EmojiReacts" do test "it works for incoming misskey likes, turning them into EmojiReacts" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"}) {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
data = data =
File.read!("test/fixtures/misskey-like.json") File.read!("test/fixtures/misskey-like.json")
@ -57,7 +57,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.LikeHandlingTest do
test "it works for incoming misskey likes that contain unicode emojis, turning them into EmojiReacts" do test "it works for incoming misskey likes that contain unicode emojis, turning them into EmojiReacts" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"}) {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
data = data =
File.read!("test/fixtures/misskey-like.json") File.read!("test/fixtures/misskey-like.json")

View File

@ -16,7 +16,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.UndoHandlingTest do
test "it works for incoming emoji reaction undos" do test "it works for incoming emoji reaction undos" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"}) {:ok, activity} = CommonAPI.post(user, %{status: "hello"})
{:ok, reaction_activity} = CommonAPI.react_with_emoji(activity.id, user, "👌") {:ok, reaction_activity} = CommonAPI.react_with_emoji(activity.id, user, "👌")
data = data =
@ -34,7 +34,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.UndoHandlingTest do
test "it returns an error for incoming unlikes wihout a like activity" do test "it returns an error for incoming unlikes wihout a like activity" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"}) {:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})
data = data =
File.read!("test/fixtures/mastodon-undo-like.json") File.read!("test/fixtures/mastodon-undo-like.json")
@ -46,7 +46,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.UndoHandlingTest do
test "it works for incoming unlikes with an existing like activity" do test "it works for incoming unlikes with an existing like activity" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"}) {:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})
like_data = like_data =
File.read!("test/fixtures/mastodon-like.json") File.read!("test/fixtures/mastodon-like.json")
@ -77,7 +77,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.UndoHandlingTest do
test "it works for incoming unlikes with an existing like activity and a compact object" do test "it works for incoming unlikes with an existing like activity and a compact object" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"}) {:ok, activity} = CommonAPI.post(user, %{status: "leave a like pls"})
like_data = like_data =
File.read!("test/fixtures/mastodon-like.json") File.read!("test/fixtures/mastodon-like.json")
@ -104,7 +104,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.UndoHandlingTest do
test "it works for incoming unannounces with an existing notice" do test "it works for incoming unannounces with an existing notice" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
announce_data = announce_data =
File.read!("test/fixtures/mastodon-announce.json") File.read!("test/fixtures/mastodon-announce.json")

View File

@ -212,8 +212,8 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "suya...", status: "suya...",
"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10} poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -263,7 +263,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it works for incoming honk announces" do test "it works for incoming honk announces" do
_user = insert(:user, ap_id: "https://honktest/u/test", local: false) _user = insert(:user, ap_id: "https://honktest/u/test", local: false)
other_user = insert(:user) other_user = insert(:user)
{:ok, post} = CommonAPI.post(other_user, %{"status" => "bonkeronk"}) {:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})
announce = %{ announce = %{
"@context" => "https://www.w3.org/ns/activitystreams", "@context" => "https://www.w3.org/ns/activitystreams",
@ -362,7 +362,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it works for incoming announces with an existing activity" do test "it works for incoming announces with an existing activity" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
data = data =
File.read!("test/fixtures/mastodon-announce.json") File.read!("test/fixtures/mastodon-announce.json")
@ -412,7 +412,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it does not clobber the addressing on announce activities" do test "it does not clobber the addressing on announce activities" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
data = data =
File.read!("test/fixtures/mastodon-announce.json") File.read!("test/fixtures/mastodon-announce.json")
@ -498,7 +498,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it strips internal reactions" do test "it strips internal reactions" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"}) {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "📢") {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "📢")
%{object: object} = Activity.get_by_id_with_object(activity.id) %{object: object} = Activity.get_by_id_with_object(activity.id)
@ -996,7 +996,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"}) {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
object = Object.normalize(activity) object = Object.normalize(activity)
note_obj = %{ note_obj = %{
@ -1140,13 +1140,13 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
setup do setup do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "post1"}) {:ok, activity} = CommonAPI.post(user, %{status: "post1"})
{:ok, reply1} = {:ok, reply1} =
CommonAPI.post(user, %{"status" => "reply1", "in_reply_to_status_id" => activity.id}) CommonAPI.post(user, %{status: "reply1", in_reply_to_status_id: activity.id})
{:ok, reply2} = {:ok, reply2} =
CommonAPI.post(user, %{"status" => "reply2", "in_reply_to_status_id" => activity.id}) CommonAPI.post(user, %{status: "reply2", in_reply_to_status_id: activity.id})
replies_uris = Enum.map([reply1, reply2], fn a -> a.object.data["id"] end) replies_uris = Enum.map([reply1, reply2], fn a -> a.object.data["id"] end)
@ -1186,7 +1186,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it inlines private announced objects" do test "it inlines private announced objects" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey", "visibility" => "private"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey", visibility: "private"})
{:ok, announce_activity, _} = CommonAPI.repeat(activity.id, user) {:ok, announce_activity, _} = CommonAPI.repeat(activity.id, user)
@ -1201,7 +1201,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"}) CommonAPI.post(user, %{status: "hey, @#{other_user.nickname}, how are ya? #2hu"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
object = modified["object"] object = modified["object"]
@ -1225,7 +1225,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it adds the sensitive property" do test "it adds the sensitive property" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "#nsfw hey"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
assert modified["object"]["sensitive"] assert modified["object"]["sensitive"]
@ -1234,7 +1234,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it adds the json-ld context and the conversation property" do test "it adds the json-ld context and the conversation property" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
assert modified["@context"] == assert modified["@context"] ==
@ -1246,7 +1246,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
assert modified["object"]["actor"] == modified["object"]["attributedTo"] assert modified["object"]["actor"] == modified["object"]["attributedTo"]
@ -1255,7 +1255,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it strips internal hashtag data" do test "it strips internal hashtag data" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu"}) {:ok, activity} = CommonAPI.post(user, %{status: "#2hu"})
expected_tag = %{ expected_tag = %{
"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu", "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
@ -1271,7 +1271,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "it strips internal fields" do test "it strips internal fields" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :firefox:"}) {:ok, activity} = CommonAPI.post(user, %{status: "#2hu :firefox:"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
@ -1303,14 +1303,13 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"}) {:ok, activity} = CommonAPI.post(user, %{status: "2hu :moominmamma:"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
assert modified["directMessage"] == false assert modified["directMessage"] == false
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "@#{other_user.nickname} :moominmamma:"})
CommonAPI.post(user, %{"status" => "@#{other_user.nickname} :moominmamma:"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
@ -1318,8 +1317,8 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "@#{other_user.nickname} :moominmamma:", status: "@#{other_user.nickname} :moominmamma:",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
@ -1331,8 +1330,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
user = insert(:user) user = insert(:user)
{:ok, list} = Pleroma.List.create("foo", user) {:ok, list} = Pleroma.List.create("foo", user)
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data) {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
@ -1367,8 +1365,8 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
user_two = insert(:user) user_two = insert(:user)
Pleroma.FollowingRelationship.follow(user_two, user, :follow_accept) Pleroma.FollowingRelationship.follow(user_two, user, :follow_accept)
{:ok, activity} = CommonAPI.post(user, %{"status" => "test"}) {:ok, activity} = CommonAPI.post(user, %{status: "test"})
{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"}) {:ok, unrelated_activity} = CommonAPI.post(user_two, %{status: "test"})
assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
user = User.get_cached_by_id(user.id) user = User.get_cached_by_id(user.id)
@ -1534,8 +1532,8 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
{:ok, poll_activity} = {:ok, poll_activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "suya...", status: "suya...",
"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10} poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
}) })
poll_object = Object.normalize(poll_activity) poll_object = Object.normalize(poll_activity)
@ -1878,28 +1876,27 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
test "sets `replies` collection with a limited number of self-replies" do test "sets `replies` collection with a limited number of self-replies" do
[user, another_user] = insert_list(2, :user) [user, another_user] = insert_list(2, :user)
{:ok, %{id: id1} = activity} = CommonAPI.post(user, %{"status" => "1"}) {:ok, %{id: id1} = activity} = CommonAPI.post(user, %{status: "1"})
{:ok, %{id: id2} = self_reply1} = {:ok, %{id: id2} = self_reply1} =
CommonAPI.post(user, %{"status" => "self-reply 1", "in_reply_to_status_id" => id1}) CommonAPI.post(user, %{status: "self-reply 1", in_reply_to_status_id: id1})
{:ok, self_reply2} = {:ok, self_reply2} =
CommonAPI.post(user, %{"status" => "self-reply 2", "in_reply_to_status_id" => id1}) CommonAPI.post(user, %{status: "self-reply 2", in_reply_to_status_id: id1})
# Assuming to _not_ be present in `replies` due to :note_replies_output_limit is set to 2 # Assuming to _not_ be present in `replies` due to :note_replies_output_limit is set to 2
{:ok, _} = {:ok, _} = CommonAPI.post(user, %{status: "self-reply 3", in_reply_to_status_id: id1})
CommonAPI.post(user, %{"status" => "self-reply 3", "in_reply_to_status_id" => id1})
{:ok, _} = {:ok, _} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "self-reply to self-reply", status: "self-reply to self-reply",
"in_reply_to_status_id" => id2 in_reply_to_status_id: id2
}) })
{:ok, _} = {:ok, _} =
CommonAPI.post(another_user, %{ CommonAPI.post(another_user, %{
"status" => "another user's reply", status: "another user's reply",
"in_reply_to_status_id" => id1 in_reply_to_status_id: id1
}) })
object = Object.normalize(activity) object = Object.normalize(activity)

View File

@ -120,7 +120,7 @@ defmodule Pleroma.Web.ActivityPub.UtilsTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?" "hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
}) })
@ -139,8 +139,8 @@ defmodule Pleroma.Web.ActivityPub.UtilsTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!", status: "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
"visibility" => "private" visibility: "private"
}) })
%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil) %{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
@ -168,11 +168,11 @@ defmodule Pleroma.Web.ActivityPub.UtilsTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "How do I pronounce LaTeX?", status: "How do I pronounce LaTeX?",
"poll" => %{ poll: %{
"options" => ["laytekh", "lahtekh", "latex"], options: ["laytekh", "lahtekh", "latex"],
"expires_in" => 20, expires_in: 20,
"multiple" => true multiple: true
} }
}) })
@ -187,10 +187,10 @@ defmodule Pleroma.Web.ActivityPub.UtilsTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "Are we living in a society?", status: "Are we living in a society?",
"poll" => %{ poll: %{
"options" => ["yes", "no"], options: ["yes", "no"],
"expires_in" => 20 expires_in: 20
} }
}) })
@ -469,7 +469,7 @@ defmodule Pleroma.Web.ActivityPub.UtilsTest do
test "returns map with Flag object" do test "returns map with Flag object" do
reporter = insert(:user) reporter = insert(:user)
target_account = insert(:user) target_account = insert(:user)
{:ok, activity} = CommonAPI.post(target_account, %{"status" => "foobar"}) {:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
context = Utils.generate_context_id() context = Utils.generate_context_id()
content = "foobar" content = "foobar"

View File

@ -44,7 +44,7 @@ defmodule Pleroma.Web.ActivityPub.ObjectViewTest do
activity = insert(:note_activity, user: user) activity = insert(:note_activity, user: user)
{:ok, self_reply1} = {:ok, self_reply1} =
CommonAPI.post(user, %{"status" => "self-reply 1", "in_reply_to_status_id" => activity.id}) CommonAPI.post(user, %{status: "self-reply 1", in_reply_to_status_id: activity.id})
replies_uris = [self_reply1.object.data["id"]] replies_uris = [self_reply1.object.data["id"]]
result = ObjectView.render("object.json", %{object: refresh_record(activity)}) result = ObjectView.render("object.json", %{object: refresh_record(activity)})

View File

@ -164,7 +164,7 @@ defmodule Pleroma.Web.ActivityPub.UserViewTest do
posts = posts =
for i <- 0..25 do for i <- 0..25 do
{:ok, activity} = CommonAPI.post(user, %{"status" => "post #{i}"}) {:ok, activity} = CommonAPI.post(user, %{status: "post #{i}"})
activity activity
end end

View File

@ -21,21 +21,21 @@ defmodule Pleroma.Web.ActivityPub.VisibilityTest do
Pleroma.List.follow(list, unrelated) Pleroma.List.follow(list, unrelated)
{:ok, public} = {:ok, public} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "public"}) CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "public"})
{:ok, private} = {:ok, private} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "private"}) CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "private"})
{:ok, direct} = {:ok, direct} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "direct"}) CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "direct"})
{:ok, unlisted} = {:ok, unlisted} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "unlisted"}) CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "unlisted"})
{:ok, list} = {:ok, list} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "@#{mentioned.nickname}", status: "@#{mentioned.nickname}",
"visibility" => "list:#{list.id}" visibility: "list:#{list.id}"
}) })
%{ %{

View File

@ -1747,7 +1747,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
test "change visibility flag", %{conn: conn, id: id, admin: admin} do test "change visibility flag", %{conn: conn, id: id, admin: admin} do
response = response =
conn conn
|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"}) |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
|> json_response(:ok) |> json_response(:ok)
assert response["visibility"] == "public" assert response["visibility"] == "public"
@ -1759,21 +1759,21 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
response = response =
conn conn
|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"}) |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "private"})
|> json_response(:ok) |> json_response(:ok)
assert response["visibility"] == "private" assert response["visibility"] == "private"
response = response =
conn conn
|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"}) |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
|> json_response(:ok) |> json_response(:ok)
assert response["visibility"] == "unlisted" assert response["visibility"] == "unlisted"
end end
test "returns 400 when visibility is unknown", %{conn: conn, id: id} do test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
conn = put(conn, "/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"}) conn = put(conn, "/api/pleroma/admin/statuses/#{id}", %{visibility: "test"})
assert json_response(conn, :bad_request) == "Unsupported visibility" assert json_response(conn, :bad_request) == "Unsupported visibility"
end end
@ -2977,13 +2977,12 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
user = insert(:user) user = insert(:user)
User.block(admin, blocked) User.block(admin, blocked)
{:ok, _} = {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
CommonAPI.post(user, %{"status" => "@#{admin.nickname}", "visibility" => "direct"})
{:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"}) {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
{:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"}) {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
{:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"}) {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
{:ok, _} = CommonAPI.post(blocked, %{"status" => ".", "visibility" => "public"}) {:ok, _} = CommonAPI.post(blocked, %{status: ".", visibility: "public"})
response = response =
conn conn
@ -3011,11 +3010,10 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do
user = insert(:user) user = insert(:user)
{:ok, _} = {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
CommonAPI.post(user, %{"status" => "@#{admin.nickname}", "visibility" => "direct"})
{:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"}) {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
{:ok, _} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"}) {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
conn = get(conn, "/api/pleroma/admin/statuses?godmode=true") conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
assert json_response(conn, 200) |> length() == 3 assert json_response(conn, 200) |> length() == 3
end end
@ -3049,11 +3047,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
end end
test "doesn't return private statuses by default", %{conn: conn, user: user} do test "doesn't return private statuses by default", %{conn: conn, user: user} do
{:ok, _private_status} = {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
{:ok, _public_status} = {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses") conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
@ -3061,11 +3057,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
end end
test "returns private statuses with godmode on", %{conn: conn, user: user} do test "returns private statuses with godmode on", %{conn: conn, user: user} do
{:ok, _private_status} = {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
{:ok, _public_status} = {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true") conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
@ -3074,7 +3068,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
test "excludes reblogs by default", %{conn: conn, user: user} do test "excludes reblogs by default", %{conn: conn, user: user} do
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "."}) {:ok, activity} = CommonAPI.post(user, %{status: "."})
{:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, other_user) {:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, other_user)
conn_res = get(conn, "/api/pleroma/admin/users/#{other_user.nickname}/statuses") conn_res = get(conn, "/api/pleroma/admin/users/#{other_user.nickname}/statuses")
@ -3599,9 +3593,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
test "status visibility count", %{conn: conn} do test "status visibility count", %{conn: conn} do
admin = insert(:user, is_admin: true) admin = insert(:user, is_admin: true)
user = insert(:user) user = insert(:user)
CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"}) CommonAPI.post(user, %{visibility: "public", status: "hey"})
CommonAPI.post(user, %{"visibility" => "unlisted", "status" => "hey"}) CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
CommonAPI.post(user, %{"visibility" => "unlisted", "status" => "hey"}) CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
response = response =
conn conn

View File

@ -45,7 +45,7 @@ defmodule Pleroma.Web.AdminAPI.ReportViewTest do
test "includes reported statuses" do test "includes reported statuses" do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "toot"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "toot"})
{:ok, report_activity} = {:ok, report_activity} =
CommonAPI.report(user, %{account_id: other_user.id, status_ids: [activity.id]}) CommonAPI.report(user, %{account_id: other_user.id, status_ids: [activity.id]})

View File

@ -27,7 +27,7 @@ defmodule Pleroma.Web.CommonAPITest do
test "it works with pruned objects" do test "it works with pruned objects" do
user = insert(:user) user = insert(:user)
{:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"}) {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
Object.normalize(post, false) Object.normalize(post, false)
|> Object.prune() |> Object.prune()
@ -45,7 +45,7 @@ defmodule Pleroma.Web.CommonAPITest do
test "it allows users to delete their posts" do test "it allows users to delete their posts" do
user = insert(:user) user = insert(:user)
{:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"}) {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
with_mock Pleroma.Web.Federator, with_mock Pleroma.Web.Federator,
publish: fn _ -> nil end do publish: fn _ -> nil end do
@ -61,7 +61,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"}) {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user) assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user)
assert Activity.get_by_id(post.id) assert Activity.get_by_id(post.id)
@ -71,7 +71,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
moderator = insert(:user, is_moderator: true) moderator = insert(:user, is_moderator: true)
{:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"}) {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
assert {:ok, delete} = CommonAPI.delete(post.id, moderator) assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
assert delete.local assert delete.local
@ -83,7 +83,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
moderator = insert(:user, is_admin: true) moderator = insert(:user, is_admin: true)
{:ok, post} = CommonAPI.post(user, %{"status" => "namu amida butsu"}) {:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})
assert {:ok, delete} = CommonAPI.delete(post.id, moderator) assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
assert delete.local assert delete.local
@ -124,7 +124,7 @@ defmodule Pleroma.Web.CommonAPITest do
users_serial = insert_list(10, :user) users_serial = insert_list(10, :user)
users = insert_list(10, :user) users = insert_list(10, :user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "."}) {:ok, activity} = CommonAPI.post(user, %{status: "."})
users_serial users_serial
|> Enum.map(fn user -> |> Enum.map(fn user ->
@ -151,7 +151,7 @@ defmodule Pleroma.Web.CommonAPITest do
users_serial = insert_list(10, :user) users_serial = insert_list(10, :user)
users = insert_list(10, :user) users = insert_list(10, :user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "."}) {:ok, activity} = CommonAPI.post(user, %{status: "."})
users_serial users_serial
|> Enum.map(fn user -> |> Enum.map(fn user ->
@ -175,12 +175,12 @@ defmodule Pleroma.Web.CommonAPITest do
test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
[participation] = Participation.for_user(user) [participation] = Participation.for_user(user)
{:ok, convo_reply} = {:ok, convo_reply} =
CommonAPI.post(user, %{"status" => ".", "in_reply_to_conversation_id" => participation.id}) CommonAPI.post(user, %{status: ".", in_reply_to_conversation_id: participation.id})
assert Visibility.is_direct?(convo_reply) assert Visibility.is_direct?(convo_reply)
@ -194,8 +194,8 @@ defmodule Pleroma.Web.CommonAPITest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(har, %{ CommonAPI.post(har, %{
"status" => "@#{jafnhar.nickname} hey", status: "@#{jafnhar.nickname} hey",
"visibility" => "direct" visibility: "direct"
}) })
assert har.ap_id in activity.recipients assert har.ap_id in activity.recipients
@ -205,10 +205,10 @@ defmodule Pleroma.Web.CommonAPITest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(har, %{ CommonAPI.post(har, %{
"status" => "I don't really like @#{tridi.nickname}", status: "I don't really like @#{tridi.nickname}",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => activity.id, in_reply_to_status_id: activity.id,
"in_reply_to_conversation_id" => participation.id in_reply_to_conversation_id: participation.id
}) })
assert har.ap_id in activity.recipients assert har.ap_id in activity.recipients
@ -225,8 +225,8 @@ defmodule Pleroma.Web.CommonAPITest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(har, %{ CommonAPI.post(har, %{
"status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again", status: "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
"visibility" => "direct" visibility: "direct"
}) })
refute tridi.ap_id in activity.recipients refute tridi.ap_id in activity.recipients
@ -235,7 +235,7 @@ defmodule Pleroma.Web.CommonAPITest do
test "it de-duplicates tags" do test "it de-duplicates tags" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"}) {:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU"})
object = Object.normalize(activity) object = Object.normalize(activity)
@ -244,7 +244,7 @@ defmodule Pleroma.Web.CommonAPITest do
test "it adds emoji in the object" do test "it adds emoji in the object" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"}) {:ok, activity} = CommonAPI.post(user, %{status: ":firefox:"})
assert Object.normalize(activity).data["emoji"]["firefox"] assert Object.normalize(activity).data["emoji"]["firefox"]
end end
@ -258,9 +258,9 @@ defmodule Pleroma.Web.CommonAPITest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.", "Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
"to" => [user_two.nickname, user_four.nickname, "nonexistent"] to: [user_two.nickname, user_four.nickname, "nonexistent"]
}) })
assert user.ap_id in activity.recipients assert user.ap_id in activity.recipients
@ -276,8 +276,8 @@ defmodule Pleroma.Web.CommonAPITest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => post, status: post,
"content_type" => "text/html" content_type: "text/html"
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -292,8 +292,8 @@ defmodule Pleroma.Web.CommonAPITest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => post, status: post,
"content_type" => "text/markdown" content_type: "text/markdown"
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -304,21 +304,21 @@ defmodule Pleroma.Web.CommonAPITest do
test "it does not allow replies to direct messages that are not direct messages themselves" do test "it does not allow replies to direct messages that are not direct messages themselves" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: "suya..", visibility: "direct"})
assert {:ok, _} = assert {:ok, _} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "suya..", status: "suya..",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
Enum.each(["public", "private", "unlisted"], fn visibility -> Enum.each(["public", "private", "unlisted"], fn visibility ->
assert {:error, "The message visibility must be direct"} = assert {:error, "The message visibility must be direct"} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "suya..", status: "suya..",
"visibility" => visibility, visibility: visibility,
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
end) end)
end end
@ -327,8 +327,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
{:ok, list} = Pleroma.List.create("foo", user) {:ok, list} = Pleroma.List.create("foo", user)
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
assert activity.data["bcc"] == [list.ap_id] assert activity.data["bcc"] == [list.ap_id]
assert activity.recipients == [list.ap_id, user.ap_id] assert activity.recipients == [list.ap_id, user.ap_id]
@ -339,7 +338,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
assert {:error, "Cannot post an empty status without attachments"} = assert {:error, "Cannot post an empty status without attachments"} =
CommonAPI.post(user, %{"status" => ""}) CommonAPI.post(user, %{status: ""})
end end
test "it validates character limits are correctly enforced" do test "it validates character limits are correctly enforced" do
@ -348,9 +347,9 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
assert {:error, "The status is over the character limit"} = assert {:error, "The status is over the character limit"} =
CommonAPI.post(user, %{"status" => "foobar"}) CommonAPI.post(user, %{status: "foobar"})
assert {:ok, activity} = CommonAPI.post(user, %{"status" => "12345"}) assert {:ok, activity} = CommonAPI.post(user, %{status: "12345"})
end end
test "it can handle activities that expire" do test "it can handle activities that expire" do
@ -361,8 +360,7 @@ defmodule Pleroma.Web.CommonAPITest do
|> NaiveDateTime.truncate(:second) |> NaiveDateTime.truncate(:second)
|> NaiveDateTime.add(1_000_000, :second) |> NaiveDateTime.add(1_000_000, :second)
assert {:ok, activity} = assert {:ok, activity} = CommonAPI.post(user, %{status: "chai", expires_in: 1_000_000})
CommonAPI.post(user, %{"status" => "chai", "expires_in" => 1_000_000})
assert expiration = Pleroma.ActivityExpiration.get_by_activity_id(activity.id) assert expiration = Pleroma.ActivityExpiration.get_by_activity_id(activity.id)
assert expiration.scheduled_at == expires_at assert expiration.scheduled_at == expires_at
@ -374,14 +372,14 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍") {:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")
assert reaction.data["actor"] == user.ap_id assert reaction.data["actor"] == user.ap_id
assert reaction.data["content"] == "👍" assert reaction.data["content"] == "👍"
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".") {:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
end end
@ -390,7 +388,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍") {:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")
{:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍") {:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")
@ -404,7 +402,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user) {:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
end end
@ -412,7 +410,7 @@ defmodule Pleroma.Web.CommonAPITest do
test "can't repeat a repeat" do test "can't repeat a repeat" do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, %Activity{} = announce, _} = CommonAPI.repeat(activity.id, other_user) {:ok, %Activity{} = announce, _} = CommonAPI.repeat(activity.id, other_user)
@ -423,10 +421,10 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, %Activity{} = announce_activity, _} = {:ok, %Activity{} = announce_activity, _} =
CommonAPI.repeat(activity.id, user, %{"visibility" => "private"}) CommonAPI.repeat(activity.id, user, %{visibility: "private"})
assert Visibility.is_private?(announce_activity) assert Visibility.is_private?(announce_activity)
end end
@ -435,7 +433,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, post_activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, post_activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id) {:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
assert data["type"] == "Like" assert data["type"] == "Like"
@ -447,7 +445,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, %Activity{} = announce, object} = CommonAPI.repeat(activity.id, user) {:ok, %Activity{} = announce, object} = CommonAPI.repeat(activity.id, user)
{:ok, ^announce, ^object} = CommonAPI.repeat(activity.id, user) {:ok, ^announce, ^object} = CommonAPI.repeat(activity.id, user)
end end
@ -456,7 +454,7 @@ defmodule Pleroma.Web.CommonAPITest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id) {:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id) assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id)
end end
@ -467,7 +465,7 @@ defmodule Pleroma.Web.CommonAPITest do
Pleroma.Config.put([:instance, :max_pinned_statuses], 1) Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
[user: user, activity: activity] [user: user, activity: activity]
end end
@ -484,8 +482,8 @@ defmodule Pleroma.Web.CommonAPITest do
test "pin poll", %{user: user} do test "pin poll", %{user: user} do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "How is fediverse today?", status: "How is fediverse today?",
"poll" => %{"options" => ["Absolutely outstanding", "Not good"], "expires_in" => 20} poll: %{options: ["Absolutely outstanding", "Not good"], expires_in: 20}
}) })
assert {:ok, ^activity} = CommonAPI.pin(activity.id, user) assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
@ -497,7 +495,7 @@ defmodule Pleroma.Web.CommonAPITest do
end end
test "unlisted statuses can be pinned", %{user: user} do test "unlisted statuses can be pinned", %{user: user} do
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!", "visibility" => "unlisted"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!", visibility: "unlisted"})
assert {:ok, ^activity} = CommonAPI.pin(activity.id, user) assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
end end
@ -508,7 +506,7 @@ defmodule Pleroma.Web.CommonAPITest do
end end
test "max pinned statuses", %{user: user, activity: activity_one} do test "max pinned statuses", %{user: user, activity: activity_one} do
{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"}) {:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})
assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user) assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)
@ -576,7 +574,7 @@ defmodule Pleroma.Web.CommonAPITest do
reporter = insert(:user) reporter = insert(:user)
target_user = insert(:user) target_user = insert(:user)
{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"}) {:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})
reporter_ap_id = reporter.ap_id reporter_ap_id = reporter.ap_id
target_ap_id = target_user.ap_id target_ap_id = target_user.ap_id
@ -813,8 +811,8 @@ defmodule Pleroma.Web.CommonAPITest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "Am I cute?", status: "Am I cute?",
"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20} poll: %{options: ["Yes", "No"], expires_in: 20}
}) })
object = Object.normalize(activity) object = Object.normalize(activity)

View File

@ -228,7 +228,7 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id] mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "public", nil) {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "public", nil)
@ -261,7 +261,7 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id] mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "unlisted", nil) {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "unlisted", nil)
@ -292,7 +292,7 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id] mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "private", nil) {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "private", nil)
@ -322,7 +322,7 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{"status" => "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id] mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "direct", nil) {to, cc} = Utils.get_to_and_cc(user, mentions, activity, "direct", nil)
@ -463,8 +463,8 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
desc = Jason.encode!(%{object.id => "test-desc"}) desc = Jason.encode!(%{object.id => "test-desc"})
assert Utils.attachments_from_ids(%{ assert Utils.attachments_from_ids(%{
"media_ids" => ["#{object.id}"], media_ids: ["#{object.id}"],
"descriptions" => desc descriptions: desc
}) == [ }) == [
Map.merge(object.data, %{"name" => "test-desc"}) Map.merge(object.data, %{"name" => "test-desc"})
] ]
@ -472,7 +472,7 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
test "returns attachments without descs" do test "returns attachments without descs" do
object = insert(:note) object = insert(:note)
assert Utils.attachments_from_ids(%{"media_ids" => ["#{object.id}"]}) == [object.data] assert Utils.attachments_from_ids(%{media_ids: ["#{object.id}"]}) == [object.data]
end end
test "returns [] when not pass media_ids" do test "returns [] when not pass media_ids" do

View File

@ -29,7 +29,7 @@ defmodule Pleroma.Web.FederatorTest do
describe "Publish an activity" do describe "Publish an activity" do
setup do setup do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
relay_mock = { relay_mock = {
Pleroma.Web.ActivityPub.Relay, Pleroma.Web.ActivityPub.Relay,
@ -96,7 +96,7 @@ defmodule Pleroma.Web.FederatorTest do
Instances.set_consistently_unreachable(URI.parse(inbox2).host) Instances.set_consistently_unreachable(URI.parse(inbox2).host)
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"}) CommonAPI.post(user, %{status: "HI @nick1@domain.com, @nick2@domain2.com!"})
expected_dt = NaiveDateTime.to_iso8601(dt) expected_dt = NaiveDateTime.to_iso8601(dt)

View File

@ -21,7 +21,7 @@ defmodule Pleroma.Web.Feed.TagControllerTest do
) )
user = insert(:user) user = insert(:user)
{:ok, activity1} = CommonAPI.post(user, %{"status" => "yeah #PleromaArt"}) {:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})
object = Object.normalize(activity1) object = Object.normalize(activity1)
@ -43,9 +43,9 @@ defmodule Pleroma.Web.Feed.TagControllerTest do
|> Ecto.Changeset.change(data: object_data) |> Ecto.Changeset.change(data: object_data)
|> Pleroma.Repo.update() |> Pleroma.Repo.update()
{:ok, activity2} = CommonAPI.post(user, %{"status" => "42 This is :moominmamma #PleromaArt"}) {:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})
{:ok, _activity3} = CommonAPI.post(user, %{"status" => "This is :moominmamma"}) {:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})
response = response =
conn conn
@ -88,7 +88,7 @@ defmodule Pleroma.Web.Feed.TagControllerTest do
) )
user = insert(:user) user = insert(:user)
{:ok, activity1} = CommonAPI.post(user, %{"status" => "yeah #PleromaArt"}) {:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})
object = Object.normalize(activity1) object = Object.normalize(activity1)
@ -110,9 +110,9 @@ defmodule Pleroma.Web.Feed.TagControllerTest do
|> Ecto.Changeset.change(data: object_data) |> Ecto.Changeset.change(data: object_data)
|> Pleroma.Repo.update() |> Pleroma.Repo.update()
{:ok, activity2} = CommonAPI.post(user, %{"status" => "42 This is :moominmamma #PleromaArt"}) {:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})
{:ok, _activity3} = CommonAPI.post(user, %{"status" => "This is :moominmamma"}) {:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})
response = response =
conn conn

View File

@ -226,7 +226,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
user = insert(:user, ap_id: "https://honktest/u/test", local: false) user = insert(:user, ap_id: "https://honktest/u/test", local: false)
other_user = insert(:user) other_user = insert(:user)
{:ok, post} = CommonAPI.post(other_user, %{"status" => "bonkeronk"}) {:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})
{:ok, announce, _} = {:ok, announce, _} =
%{ %{
@ -255,7 +255,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
User.block(user_one, user_two) User.block(user_one, user_two)
{:ok, activity} = CommonAPI.post(user_two, %{"status" => "User one sux0rz"}) {:ok, activity} = CommonAPI.post(user_two, %{status: "User one sux0rz"})
{:ok, repeat, _} = CommonAPI.repeat(activity.id, user_three) {:ok, repeat, _} = CommonAPI.repeat(activity.id, user_three)
assert resp = assert resp =
@ -298,16 +298,16 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
{:ok, _user_three} = User.follow(user_three, user_one) {:ok, _user_three} = User.follow(user_three, user_one)
{:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"}) {:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!"})
{:ok, direct_activity} = {:ok, direct_activity} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi, @#{user_two.nickname}.", status: "Hi, @#{user_two.nickname}.",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, private_activity} = {:ok, private_activity} =
CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"}) CommonAPI.post(user_one, %{status: "private", visibility: "private"})
# TODO!!! # TODO!!!
resp = resp =
@ -362,8 +362,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id) {:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)
{:ok, %{id: image_post_id}} = {:ok, %{id: image_post_id}} = CommonAPI.post(user, %{status: "cofe", media_ids: [media_id]})
CommonAPI.post(user, %{"status" => "cofe", "media_ids" => [media_id]})
conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_media=true") conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_media=true")
@ -375,7 +374,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
end end
test "gets a user's statuses without reblogs", %{user: user, conn: conn} do test "gets a user's statuses without reblogs", %{user: user, conn: conn} do
{:ok, %{id: post_id}} = CommonAPI.post(user, %{"status" => "HI!!!"}) {:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
{:ok, _, _} = CommonAPI.repeat(post_id, user) {:ok, _, _} = CommonAPI.repeat(post_id, user)
conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=true") conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=true")
@ -386,8 +385,8 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
end end
test "filters user's statuses by a hashtag", %{user: user, conn: conn} do test "filters user's statuses by a hashtag", %{user: user, conn: conn} do
{:ok, %{id: post_id}} = CommonAPI.post(user, %{"status" => "#hashtag"}) {:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "#hashtag"})
{:ok, _post} = CommonAPI.post(user, %{"status" => "hashtag"}) {:ok, _post} = CommonAPI.post(user, %{status: "hashtag"})
conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?tagged=hashtag") conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?tagged=hashtag")
assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200) assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
@ -398,9 +397,9 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
conn: conn conn: conn
} do } do
{:ok, %{id: public_activity_id}} = {:ok, %{id: public_activity_id}} =
CommonAPI.post(user, %{"status" => ".", "visibility" => "public"}) CommonAPI.post(user, %{status: ".", visibility: "public"})
{:ok, _direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, _direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_visibilities[]=direct") conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_visibilities[]=direct")
assert [%{"id" => ^public_activity_id}] = json_response_and_validate_schema(conn, 200) assert [%{"id" => ^public_activity_id}] = json_response_and_validate_schema(conn, 200)
@ -678,7 +677,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
assert %{"showing_reblogs" => false} = json_response_and_validate_schema(ret_conn, 200) assert %{"showing_reblogs" => false} = json_response_and_validate_schema(ret_conn, 200)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
{:ok, %{id: reblog_id}, _} = CommonAPI.repeat(activity.id, followed) {:ok, %{id: reblog_id}, _} = CommonAPI.repeat(activity.id, followed)
assert [] == assert [] ==
@ -777,7 +776,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
describe "pinned statuses" do describe "pinned statuses" do
setup do setup do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
%{conn: conn} = oauth_access(["read:statuses"], user: user) %{conn: conn} = oauth_access(["read:statuses"], user: user)
[conn: conn, user: user, activity: activity] [conn: conn, user: user, activity: activity]

View File

@ -22,16 +22,16 @@ defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
{:ok, direct} = {:ok, direct} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}, @#{user_three.nickname}!", status: "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
assert User.get_cached_by_id(user_two.id).unread_conversation_count == 1 assert User.get_cached_by_id(user_two.id).unread_conversation_count == 1
{:ok, _follower_only} = {:ok, _follower_only} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}!", status: "Hi @#{user_two.nickname}!",
"visibility" => "private" visibility: "private"
}) })
res_conn = get(conn, "/api/v1/conversations") res_conn = get(conn, "/api/v1/conversations")
@ -63,32 +63,32 @@ defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
{:ok, direct1} = {:ok, direct1} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}!", status: "Hi @#{user_two.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, _direct2} = {:ok, _direct2} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_three.nickname}!", status: "Hi @#{user_three.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, direct3} = {:ok, direct3} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}, @#{user_three.nickname}!", status: "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, _direct4} = {:ok, _direct4} =
CommonAPI.post(user_two, %{ CommonAPI.post(user_two, %{
"status" => "Hi @#{user_three.nickname}!", status: "Hi @#{user_three.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, direct5} = {:ok, direct5} =
CommonAPI.post(user_two, %{ CommonAPI.post(user_two, %{
"status" => "Hi @#{user_one.nickname}!", status: "Hi @#{user_one.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
assert [conversation1, conversation2] = assert [conversation1, conversation2] =
@ -112,15 +112,15 @@ defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
{:ok, direct} = {:ok, direct} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}", status: "Hi @#{user_two.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, direct_reply} = {:ok, direct_reply} =
CommonAPI.post(user_two, %{ CommonAPI.post(user_two, %{
"status" => "reply", status: "reply",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => direct.id in_reply_to_status_id: direct.id
}) })
[%{"last_status" => res_last_status}] = [%{"last_status" => res_last_status}] =
@ -136,8 +136,8 @@ defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
{:ok, direct} = {:ok, direct} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}", status: "Hi @#{user_two.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
assert User.get_cached_by_id(user_one.id).unread_conversation_count == 0 assert User.get_cached_by_id(user_one.id).unread_conversation_count == 0
@ -167,9 +167,9 @@ defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
# The conversation is marked as unread on reply # The conversation is marked as unread on reply
{:ok, _} = {:ok, _} =
CommonAPI.post(user_two, %{ CommonAPI.post(user_two, %{
"status" => "reply", status: "reply",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => direct.id in_reply_to_status_id: direct.id
}) })
[%{"unread" => true}] = [%{"unread" => true}] =
@ -183,9 +183,9 @@ defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
# A reply doesn't increment the user's unread_conversation_count if the conversation is unread # A reply doesn't increment the user's unread_conversation_count if the conversation is unread
{:ok, _} = {:ok, _} =
CommonAPI.post(user_two, %{ CommonAPI.post(user_two, %{
"status" => "reply", status: "reply",
"visibility" => "direct", visibility: "direct",
"in_reply_to_status_id" => direct.id in_reply_to_status_id: direct.id
}) })
assert User.get_cached_by_id(user_one.id).unread_conversation_count == 1 assert User.get_cached_by_id(user_one.id).unread_conversation_count == 1
@ -197,8 +197,8 @@ defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
{:ok, direct} = {:ok, direct} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}!", status: "Hi @#{user_two.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
res_conn = get(conn, "/api/v1/statuses/#{direct.id}/context") res_conn = get(conn, "/api/v1/statuses/#{direct.id}/context")

View File

@ -50,7 +50,7 @@ defmodule Pleroma.Web.MastodonAPI.InstanceControllerTest do
insert(:user, %{local: false, nickname: "u@peer1.com"}) insert(:user, %{local: false, nickname: "u@peer1.com"})
insert(:user, %{local: false, nickname: "u@peer2.com"}) insert(:user, %{local: false, nickname: "u@peer2.com"})
{:ok, _} = Pleroma.Web.CommonAPI.post(user, %{"status" => "cofe"}) {:ok, _} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
Pleroma.Stats.force_update() Pleroma.Stats.force_update()

View File

@ -18,7 +18,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["read:notifications"]) %{user: user, conn: conn} = oauth_access(["read:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, [_notification]} = Notification.create_notifications(activity) {:ok, [_notification]} = Notification.create_notifications(activity)
response = response =
@ -36,7 +36,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["read:notifications"]) %{user: user, conn: conn} = oauth_access(["read:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, [_notification]} = Notification.create_notifications(activity) {:ok, [_notification]} = Notification.create_notifications(activity)
@ -60,7 +60,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["read:notifications"]) %{user: user, conn: conn} = oauth_access(["read:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
@ -79,7 +79,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["write:notifications"]) %{user: user, conn: conn} = oauth_access(["write:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
@ -96,7 +96,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["write:notifications"]) %{user: user, conn: conn} = oauth_access(["write:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
@ -112,7 +112,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"]) %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, [_notification]} = Notification.create_notifications(activity) {:ok, [_notification]} = Notification.create_notifications(activity)
@ -130,10 +130,10 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["read:notifications"]) %{user: user, conn: conn} = oauth_access(["read:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity3} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity4} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
notification1_id = get_notification_id_by_activity(activity1) notification1_id = get_notification_id_by_activity(activity1)
notification2_id = get_notification_id_by_activity(activity2) notification2_id = get_notification_id_by_activity(activity2)
@ -173,16 +173,16 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, public_activity} = {:ok, public_activity} =
CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "public"}) CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "public"})
{:ok, direct_activity} = {:ok, direct_activity} =
CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"}) CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
{:ok, unlisted_activity} = {:ok, unlisted_activity} =
CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "unlisted"}) CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "unlisted"})
{:ok, private_activity} = {:ok, private_activity} =
CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "private"}) CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "private"})
query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]}) query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
conn_res = get(conn, "/api/v1/notifications?" <> query) conn_res = get(conn, "/api/v1/notifications?" <> query)
@ -213,17 +213,15 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
user = insert(:user) user = insert(:user)
%{user: other_user, conn: conn} = oauth_access(["read:notifications"]) %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
{:ok, public_activity} = {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
{:ok, direct_activity} = {:ok, direct_activity} =
CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"}) CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
{:ok, unlisted_activity} = {:ok, unlisted_activity} =
CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"}) CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
{:ok, private_activity} = {:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})
CommonAPI.post(other_user, %{"status" => ".", "visibility" => "private"})
{:ok, _} = CommonAPI.favorite(user, public_activity.id) {:ok, _} = CommonAPI.favorite(user, public_activity.id)
{:ok, _} = CommonAPI.favorite(user, direct_activity.id) {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
@ -279,11 +277,10 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
user = insert(:user) user = insert(:user)
%{user: other_user, conn: conn} = oauth_access(["read:notifications"]) %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
{:ok, public_activity} = {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
{:ok, unlisted_activity} = {:ok, unlisted_activity} =
CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"}) CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
{:ok, _, _} = CommonAPI.repeat(public_activity.id, user) {:ok, _, _} = CommonAPI.repeat(public_activity.id, user)
{:ok, _, _} = CommonAPI.repeat(unlisted_activity.id, user) {:ok, _, _} = CommonAPI.repeat(unlisted_activity.id, user)
@ -303,8 +300,8 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["read:notifications"]) %{user: user, conn: conn} = oauth_access(["read:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"}) {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
{:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id) {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
{:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user) {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user) {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
@ -341,8 +338,8 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["read:notifications"]) %{user: user, conn: conn} = oauth_access(["read:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"}) {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
{:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id) {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
{:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user) {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user) {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
@ -388,10 +385,10 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"]) %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
other_user = insert(:user) other_user = insert(:user)
{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
{:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"}) {:ok, activity3} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
{:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"}) {:ok, activity4} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
notification1_id = get_notification_id_by_activity(activity1) notification1_id = get_notification_id_by_activity(activity1)
notification2_id = get_notification_id_by_activity(activity2) notification2_id = get_notification_id_by_activity(activity2)
@ -435,7 +432,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
user2 = insert(:user) user2 = insert(:user)
{:ok, _, _, _} = CommonAPI.follow(user, user2) {:ok, _, _, _} = CommonAPI.follow(user, user2)
{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"}) {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
ret_conn = get(conn, "/api/v1/notifications") ret_conn = get(conn, "/api/v1/notifications")
@ -453,7 +450,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
user2 = insert(:user) user2 = insert(:user)
{:ok, _, _, _} = CommonAPI.follow(user, user2) {:ok, _, _, _} = CommonAPI.follow(user, user2)
{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"}) {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
ret_conn = get(conn, "/api/v1/notifications") ret_conn = get(conn, "/api/v1/notifications")
@ -471,7 +468,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
user2 = insert(:user) user2 = insert(:user)
{:ok, _, _, _} = CommonAPI.follow(user, user2) {:ok, _, _, _} = CommonAPI.follow(user, user2)
{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"}) {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
ret_conn = get(conn, "/api/v1/notifications") ret_conn = get(conn, "/api/v1/notifications")
@ -518,14 +515,14 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
{:ok, activity1} = {:ok, activity1} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "hi @#{user.nickname}", status: "hi @#{user.nickname}",
"visibility" => "public" visibility: "public"
}) })
{:ok, activity2} = {:ok, activity2} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "hi @#{user.nickname}", status: "hi @#{user.nickname}",
"visibility" => "public" visibility: "public"
}) })
notification1 = Repo.get_by(Notification, activity_id: activity1.id) notification1 = Repo.get_by(Notification, activity_id: activity1.id)
@ -550,8 +547,8 @@ defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
%{id: account_id} = other_user1 = insert(:user) %{id: account_id} = other_user1 = insert(:user)
other_user2 = insert(:user) other_user2 = insert(:user)
{:ok, _activity} = CommonAPI.post(other_user1, %{"status" => "hi @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
{:ok, _activity} = CommonAPI.post(other_user2, %{"status" => "bye @#{user.nickname}"}) {:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})
assert [%{"account" => %{"id" => ^account_id}}] = assert [%{"account" => %{"id" => ^account_id}}] =
conn conn

View File

@ -16,8 +16,8 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
test "returns poll entity for object id", %{user: user, conn: conn} do test "returns poll entity for object id", %{user: user, conn: conn} do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "Pleroma does", status: "Pleroma does",
"poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20} poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20}
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -34,9 +34,9 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Pleroma does", status: "Pleroma does",
"poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20}, poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20},
"visibility" => "private" visibility: "private"
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -55,11 +55,11 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "A very delicious sandwich", status: "A very delicious sandwich",
"poll" => %{ poll: %{
"options" => ["Lettuce", "Grilled Bacon", "Tomato"], options: ["Lettuce", "Grilled Bacon", "Tomato"],
"expires_in" => 20, expires_in: 20,
"multiple" => true multiple: true
} }
}) })
@ -81,8 +81,8 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
test "author can't vote", %{user: user, conn: conn} do test "author can't vote", %{user: user, conn: conn} do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "Am I cute?", status: "Am I cute?",
"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20} poll: %{options: ["Yes", "No"], expires_in: 20}
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -102,8 +102,8 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "The glass is", status: "The glass is",
"poll" => %{"options" => ["half empty", "half full"], "expires_in" => 20} poll: %{options: ["half empty", "half full"], expires_in: 20}
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -125,8 +125,8 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Am I cute?", status: "Am I cute?",
"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20} poll: %{options: ["Yes", "No"], expires_in: 20}
}) })
object = Object.normalize(activity) object = Object.normalize(activity)
@ -153,9 +153,9 @@ defmodule Pleroma.Web.MastodonAPI.PollControllerTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Am I cute?", status: "Am I cute?",
"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}, poll: %{options: ["Yes", "No"], expires_in: 20},
"visibility" => "private" visibility: "private"
}) })
object = Object.normalize(activity) object = Object.normalize(activity)

View File

@ -14,7 +14,7 @@ defmodule Pleroma.Web.MastodonAPI.ReportControllerTest do
setup do setup do
target_user = insert(:user) target_user = insert(:user)
{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"}) {:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})
[target_user: target_user, activity: activity] [target_user: target_user, activity: activity]
end end

View File

@ -42,15 +42,15 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
user_two = insert(:user, %{nickname: "shp@shitposter.club"}) user_two = insert(:user, %{nickname: "shp@shitposter.club"})
user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"}) user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu private 天子"}) {:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "This is about 2hu, but private", status: "This is about 2hu, but private",
"visibility" => "private" visibility: "private"
}) })
{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"}) {:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})
results = results =
conn conn
@ -80,9 +80,9 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"}) user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"}) user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})
{:ok, act1} = CommonAPI.post(user, %{"status" => "This is about 2hu private 天子"}) {:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
{:ok, act2} = CommonAPI.post(user_smith, %{"status" => "Agent Smith"}) {:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
{:ok, act3} = CommonAPI.post(user_neo, %{"status" => "Agent Smith"}) {:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
Pleroma.User.block(user, user_smith) Pleroma.User.block(user, user_smith)
results = results =
@ -161,15 +161,15 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
user_two = insert(:user, %{nickname: "shp@shitposter.club"}) user_two = insert(:user, %{nickname: "shp@shitposter.club"})
user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"}) user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"}) {:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "This is about 2hu, but private", status: "This is about 2hu, but private",
"visibility" => "private" visibility: "private"
}) })
{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"}) {:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})
results = results =
conn conn
@ -189,7 +189,7 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
capture_log(fn -> capture_log(fn ->
{:ok, %{id: activity_id}} = {:ok, %{id: activity_id}} =
CommonAPI.post(insert(:user), %{ CommonAPI.post(insert(:user), %{
"status" => "check out https://shitposter.club/notice/2827873" status: "check out https://shitposter.club/notice/2827873"
}) })
results = results =
@ -207,8 +207,8 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
test "search doesn't show statuses that it shouldn't", %{conn: conn} do test "search doesn't show statuses that it shouldn't", %{conn: conn} do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(insert(:user), %{ CommonAPI.post(insert(:user), %{
"status" => "This is about 2hu, but private", status: "This is about 2hu, but private",
"visibility" => "private" visibility: "private"
}) })
capture_log(fn -> capture_log(fn ->
@ -251,8 +251,8 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
_user_two = insert(:user, %{nickname: "shp@shitposter.club"}) _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
_user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"}) _user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
{:ok, _activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"}) {:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
{:ok, _activity2} = CommonAPI.post(user, %{"status" => "This is also about 2hu"}) {:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})
result = result =
conn conn
@ -277,7 +277,7 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
user = insert(:user) user = insert(:user)
_user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"}) _user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
{:ok, _activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"}) {:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})
assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} = assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
conn conn
@ -294,8 +294,8 @@ defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
user = insert(:user, %{nickname: "shp@shitposter.club"}) user = insert(:user, %{nickname: "shp@shitposter.club"})
user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"}) user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
{:ok, activity1} = CommonAPI.post(user, %{"status" => "This is about 2hu"}) {:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
{:ok, activity2} = CommonAPI.post(user_two, %{"status" => "This is also about 2hu"}) {:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})
results = results =
conn conn

File diff suppressed because it is too large Load Diff

View File

@ -28,7 +28,7 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, _} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"}) {:ok, _} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
response = response =
conn conn
@ -47,8 +47,8 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
following = insert(:user, nickname: "followed") following = insert(:user, nickname: "followed")
third_user = insert(:user, nickname: "repeated") third_user = insert(:user, nickname: "repeated")
{:ok, _activity} = CommonAPI.post(following, %{"status" => "post"}) {:ok, _activity} = CommonAPI.post(following, %{status: "post"})
{:ok, activity} = CommonAPI.post(third_user, %{"status" => "repeated post"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "repeated post"})
{:ok, _, _} = CommonAPI.repeat(activity.id, following) {:ok, _, _} = CommonAPI.repeat(activity.id, following)
ret_conn = get(conn, uri) ret_conn = get(conn, uri)
@ -108,14 +108,12 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
end end
test "the home timeline when the direct messages are excluded", %{user: user, conn: conn} do test "the home timeline when the direct messages are excluded", %{user: user, conn: conn} do
{:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"}) {:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
{:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"}) {:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
{:ok, unlisted_activity} = {:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
{:ok, private_activity} = {:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})
CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
conn = get(conn, "/api/v1/timelines/home", %{"exclude_visibilities" => ["direct"]}) conn = get(conn, "/api/v1/timelines/home", %{"exclude_visibilities" => ["direct"]})
@ -132,7 +130,7 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
test "the public timeline", %{conn: conn} do test "the public timeline", %{conn: conn} do
following = insert(:user) following = insert(:user)
{:ok, _activity} = CommonAPI.post(following, %{"status" => "test"}) {:ok, _activity} = CommonAPI.post(following, %{status: "test"})
_activity = insert(:note_activity, local: false) _activity = insert(:note_activity, local: false)
@ -152,10 +150,10 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
test "the public timeline includes only public statuses for an authenticated user" do test "the public timeline includes only public statuses for an authenticated user" do
%{user: user, conn: conn} = oauth_access(["read:statuses"]) %{user: user, conn: conn} = oauth_access(["read:statuses"])
{:ok, _activity} = CommonAPI.post(user, %{"status" => "test"}) {:ok, _activity} = CommonAPI.post(user, %{status: "test"})
{:ok, _activity} = CommonAPI.post(user, %{"status" => "test", "visibility" => "private"}) {:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "private"})
{:ok, _activity} = CommonAPI.post(user, %{"status" => "test", "visibility" => "unlisted"}) {:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "unlisted"})
{:ok, _activity} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"}) {:ok, _activity} = CommonAPI.post(user, %{status: "test", visibility: "direct"})
res_conn = get(conn, "/api/v1/timelines/public") res_conn = get(conn, "/api/v1/timelines/public")
assert length(json_response(res_conn, 200)) == 1 assert length(json_response(res_conn, 200)) == 1
@ -263,14 +261,14 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
{:ok, direct} = {:ok, direct} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}!", status: "Hi @#{user_two.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, _follower_only} = {:ok, _follower_only} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}!", status: "Hi @#{user_two.nickname}!",
"visibility" => "private" visibility: "private"
}) })
conn_user_two = conn_user_two =
@ -306,8 +304,8 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
Enum.each(1..20, fn _ -> Enum.each(1..20, fn _ ->
{:ok, _} = {:ok, _} =
CommonAPI.post(user_one, %{ CommonAPI.post(user_one, %{
"status" => "Hi @#{user_two.nickname}!", status: "Hi @#{user_two.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
end) end)
@ -332,14 +330,14 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
{:ok, _blocked_direct} = {:ok, _blocked_direct} =
CommonAPI.post(blocked, %{ CommonAPI.post(blocked, %{
"status" => "Hi @#{blocker.nickname}!", status: "Hi @#{blocker.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, direct} = {:ok, direct} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Hi @#{blocker.nickname}!", status: "Hi @#{blocker.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
res_conn = get(conn, "api/v1/timelines/direct") res_conn = get(conn, "api/v1/timelines/direct")
@ -354,8 +352,8 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
test "list timeline", %{user: user, conn: conn} do test "list timeline", %{user: user, conn: conn} do
other_user = insert(:user) other_user = insert(:user)
{:ok, _activity_one} = CommonAPI.post(user, %{"status" => "Marisa is cute."}) {:ok, _activity_one} = CommonAPI.post(user, %{status: "Marisa is cute."})
{:ok, activity_two} = CommonAPI.post(other_user, %{"status" => "Marisa is cute."}) {:ok, activity_two} = CommonAPI.post(other_user, %{status: "Marisa is cute."})
{:ok, list} = Pleroma.List.create("name", user) {:ok, list} = Pleroma.List.create("name", user)
{:ok, list} = Pleroma.List.follow(list, other_user) {:ok, list} = Pleroma.List.follow(list, other_user)
@ -371,12 +369,12 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
conn: conn conn: conn
} do } do
other_user = insert(:user) other_user = insert(:user)
{:ok, activity_one} = CommonAPI.post(other_user, %{"status" => "Marisa is cute."}) {:ok, activity_one} = CommonAPI.post(other_user, %{status: "Marisa is cute."})
{:ok, _activity_two} = {:ok, _activity_two} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Marisa is cute.", status: "Marisa is cute.",
"visibility" => "private" visibility: "private"
}) })
{:ok, list} = Pleroma.List.create("name", user) {:ok, list} = Pleroma.List.create("name", user)
@ -397,7 +395,7 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
test "hashtag timeline", %{conn: conn} do test "hashtag timeline", %{conn: conn} do
following = insert(:user) following = insert(:user)
{:ok, activity} = CommonAPI.post(following, %{"status" => "test #2hu"}) {:ok, activity} = CommonAPI.post(following, %{status: "test #2hu"})
nconn = get(conn, "/api/v1/timelines/tag/2hu") nconn = get(conn, "/api/v1/timelines/tag/2hu")
@ -416,9 +414,9 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
test "multi-hashtag timeline", %{conn: conn} do test "multi-hashtag timeline", %{conn: conn} do
user = insert(:user) user = insert(:user)
{:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"}) {:ok, activity_test} = CommonAPI.post(user, %{status: "#test"})
{:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"}) {:ok, activity_test1} = CommonAPI.post(user, %{status: "#test #test1"})
{:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"}) {:ok, activity_none} = CommonAPI.post(user, %{status: "#test #none"})
any_test = get(conn, "/api/v1/timelines/tag/test", %{"any" => ["test1"]}) any_test = get(conn, "/api/v1/timelines/tag/test", %{"any" => ["test1"]})

View File

@ -75,9 +75,9 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPITest do
User.subscribe(subscriber, user) User.subscribe(subscriber, user)
{:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"}) {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
{:ok, status1} = CommonAPI.post(user, %{"status" => "Magi"}) {:ok, status1} = CommonAPI.post(user, %{status: "Magi"})
{:ok, [notification]} = Notification.create_notifications(status) {:ok, [notification]} = Notification.create_notifications(status)
{:ok, [notification1]} = Notification.create_notifications(status1) {:ok, [notification1]} = Notification.create_notifications(status1)
res = MastodonAPI.get_notifications(subscriber) res = MastodonAPI.get_notifications(subscriber)

View File

@ -93,7 +93,14 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
test "Represent the user account for the account owner" do test "Represent the user account for the account owner" do
user = insert(:user) user = insert(:user)
notification_settings = %Pleroma.User.NotificationSetting{} notification_settings = %{
followers: true,
follows: true,
non_followers: true,
non_follows: true,
privacy_option: false
}
privacy = user.default_scope privacy = user.default_scope
assert %{ assert %{
@ -452,8 +459,8 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Hey @#{user.nickname}.", status: "Hey @#{user.nickname}.",
"visibility" => "direct" visibility: "direct"
}) })
user = User.get_cached_by_ap_id(user.ap_id) user = User.get_cached_by_ap_id(user.ap_id)

View File

@ -16,7 +16,7 @@ defmodule Pleroma.Web.MastodonAPI.ConversationViewTest do
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}", "visibility" => "direct"}) CommonAPI.post(user, %{status: "hey @#{other_user.nickname}", visibility: "direct"})
[participation] = Participation.for_user_with_last_activity_id(user) [participation] = Participation.for_user_with_last_activity_id(user)

View File

@ -34,7 +34,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
test "Mention notification" do test "Mention notification" do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{mentioned_user.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
user = User.get_cached_by_id(user.id) user = User.get_cached_by_id(user.id)
@ -53,7 +53,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
test "Favourite notification" do test "Favourite notification" do
user = insert(:user) user = insert(:user)
another_user = insert(:user) another_user = insert(:user)
{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
{:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id) {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
{:ok, [notification]} = Notification.create_notifications(favorite_activity) {:ok, [notification]} = Notification.create_notifications(favorite_activity)
create_activity = Activity.get_by_id(create_activity.id) create_activity = Activity.get_by_id(create_activity.id)
@ -73,7 +73,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
test "Reblog notification" do test "Reblog notification" do
user = insert(:user) user = insert(:user)
another_user = insert(:user) another_user = insert(:user)
{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
{:ok, reblog_activity, _object} = CommonAPI.repeat(create_activity.id, another_user) {:ok, reblog_activity, _object} = CommonAPI.repeat(create_activity.id, another_user)
{:ok, [notification]} = Notification.create_notifications(reblog_activity) {:ok, [notification]} = Notification.create_notifications(reblog_activity)
reblog_activity = Activity.get_by_id(create_activity.id) reblog_activity = Activity.get_by_id(create_activity.id)
@ -155,7 +155,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"}) {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
{:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "") {:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "")
activity = Repo.get(Activity, activity.id) activity = Repo.get(Activity, activity.id)

View File

@ -22,10 +22,10 @@ defmodule Pleroma.Web.MastodonAPI.PollViewTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "Is Tenshi eating a corndog cute?", status: "Is Tenshi eating a corndog cute?",
"poll" => %{ poll: %{
"options" => ["absolutely!", "sure", "yes", "why are you even asking?"], options: ["absolutely!", "sure", "yes", "why are you even asking?"],
"expires_in" => 20 expires_in: 20
} }
}) })
@ -62,11 +62,11 @@ defmodule Pleroma.Web.MastodonAPI.PollViewTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "Which Mastodon developer is your favourite?", status: "Which Mastodon developer is your favourite?",
"poll" => %{ poll: %{
"options" => ["Gargron", "Eugen"], options: ["Gargron", "Eugen"],
"expires_in" => 20, expires_in: 20,
"multiple" => true multiple: true
} }
}) })
@ -91,10 +91,10 @@ defmodule Pleroma.Web.MastodonAPI.PollViewTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "What's with the smug face?", status: "What's with the smug face?",
"poll" => %{ poll: %{
"options" => [":blank: sip", ":blank::blank: sip", ":blank::blank::blank: sip"], options: [":blank: sip", ":blank::blank: sip", ":blank::blank::blank: sip"],
"expires_in" => 20 expires_in: 20
} }
}) })
@ -109,11 +109,11 @@ defmodule Pleroma.Web.MastodonAPI.PollViewTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "Which input devices do you use?", status: "Which input devices do you use?",
"poll" => %{ poll: %{
"options" => ["mouse", "trackball", "trackpoint"], options: ["mouse", "trackball", "trackpoint"],
"multiple" => true, multiple: true,
"expires_in" => 20 expires_in: 20
} }
}) })

View File

@ -14,7 +14,7 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityViewTest do
test "A scheduled activity with a media attachment" do test "A scheduled activity with a media attachment" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hi"}) {:ok, activity} = CommonAPI.post(user, %{status: "hi"})
scheduled_at = scheduled_at =
NaiveDateTime.utc_now() NaiveDateTime.utc_now()
@ -47,7 +47,7 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityViewTest do
expected = %{ expected = %{
id: to_string(scheduled_activity.id), id: to_string(scheduled_activity.id),
media_attachments: media_attachments:
%{"media_ids" => [upload.id]} %{media_ids: [upload.id]}
|> Utils.attachments_from_ids() |> Utils.attachments_from_ids()
|> Enum.map(&StatusView.render("attachment.json", %{attachment: &1})), |> Enum.map(&StatusView.render("attachment.json", %{attachment: &1})),
params: %{ params: %{

View File

@ -20,6 +20,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
import Pleroma.Factory import Pleroma.Factory
import Tesla.Mock import Tesla.Mock
import OpenApiSpex.TestAssertions
setup do setup do
mock(fn env -> apply(HttpRequestMock, :request, [env]) end) mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
@ -30,7 +31,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "dae cofe??"}) {:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})
{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "") {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "")
{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵") {:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
@ -38,6 +39,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
activity = Repo.get(Activity, activity.id) activity = Repo.get(Activity, activity.id)
status = StatusView.render("show.json", activity: activity) status = StatusView.render("show.json", activity: activity)
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
assert status[:pleroma][:emoji_reactions] == [ assert status[:pleroma][:emoji_reactions] == [
%{name: "", count: 2, me: false}, %{name: "", count: 2, me: false},
%{name: "🍵", count: 1, me: false} %{name: "🍵", count: 1, me: false}
@ -45,6 +48,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
status = StatusView.render("show.json", activity: activity, for: user) status = StatusView.render("show.json", activity: activity, for: user)
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
assert status[:pleroma][:emoji_reactions] == [ assert status[:pleroma][:emoji_reactions] == [
%{name: "", count: 2, me: true}, %{name: "", count: 2, me: true},
%{name: "🍵", count: 1, me: false} %{name: "🍵", count: 1, me: false}
@ -54,7 +59,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
[participation] = Participation.for_user(user) [participation] = Participation.for_user(user)
status = status =
@ -68,12 +73,13 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
status = StatusView.render("show.json", activity: activity, for: user) status = StatusView.render("show.json", activity: activity, for: user)
assert status[:pleroma][:direct_conversation_id] == nil assert status[:pleroma][:direct_conversation_id] == nil
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "returns the direct conversation id when given the `direct_conversation_id` option" do test "returns the direct conversation id when given the `direct_conversation_id` option" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
[participation] = Participation.for_user(user) [participation] = Participation.for_user(user)
status = status =
@ -84,12 +90,13 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
) )
assert status[:pleroma][:direct_conversation_id] == participation.id assert status[:pleroma][:direct_conversation_id] == participation.id
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "returns a temporary ap_id based user for activities missing db users" do test "returns a temporary ap_id based user for activities missing db users" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
Repo.delete(user) Repo.delete(user)
Cachex.clear(:user_cache) Cachex.clear(:user_cache)
@ -119,7 +126,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
test "tries to get a user by nickname if fetching by ap_id doesn't work" do test "tries to get a user by nickname if fetching by ap_id doesn't work" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"}) {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
{:ok, user} = {:ok, user} =
user user
@ -131,6 +138,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
result = StatusView.render("show.json", activity: activity) result = StatusView.render("show.json", activity: activity)
assert result[:account][:id] == to_string(user.id) assert result[:account][:id] == to_string(user.id)
assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "a note with null content" do test "a note with null content" do
@ -149,6 +157,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
status = StatusView.render("show.json", %{activity: note}) status = StatusView.render("show.json", %{activity: note})
assert status.content == "" assert status.content == ""
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "a note activity" do test "a note activity" do
@ -222,6 +231,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
} }
assert status == expected assert status == expected
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "tells if the message is muted for some reason" do test "tells if the message is muted for some reason" do
@ -230,13 +240,14 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
{:ok, _user_relationships} = User.mute(user, other_user) {:ok, _user_relationships} = User.mute(user, other_user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
relationships_opt = UserRelationship.view_relationships_option(user, [other_user]) relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
opts = %{activity: activity} opts = %{activity: activity}
status = StatusView.render("show.json", opts) status = StatusView.render("show.json", opts)
assert status.muted == false assert status.muted == false
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt)) status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
assert status.muted == false assert status.muted == false
@ -247,6 +258,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt)) status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
assert status.muted == true assert status.muted == true
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "tells if the message is thread muted" do test "tells if the message is thread muted" do
@ -255,7 +267,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
{:ok, _user_relationships} = User.mute(user, other_user) {:ok, _user_relationships} = User.mute(user, other_user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
status = StatusView.render("show.json", %{activity: activity, for: user}) status = StatusView.render("show.json", %{activity: activity, for: user})
assert status.pleroma.thread_muted == false assert status.pleroma.thread_muted == false
@ -270,7 +282,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
test "tells if the status is bookmarked" do test "tells if the status is bookmarked" do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Cute girls doing cute things"}) {:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
status = StatusView.render("show.json", %{activity: activity}) status = StatusView.render("show.json", %{activity: activity})
assert status.bookmarked == false assert status.bookmarked == false
@ -292,8 +304,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
note = insert(:note_activity) note = insert(:note_activity)
user = insert(:user) user = insert(:user)
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "he", in_reply_to_status_id: note.id})
CommonAPI.post(user, %{"status" => "he", "in_reply_to_status_id" => note.id})
status = StatusView.render("show.json", %{activity: activity}) status = StatusView.render("show.json", %{activity: activity})
@ -308,12 +319,14 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
user = insert(:user) user = insert(:user)
mentioned = insert(:user) mentioned = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hi @#{mentioned.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{status: "hi @#{mentioned.nickname}"})
status = StatusView.render("show.json", %{activity: activity}) status = StatusView.render("show.json", %{activity: activity})
assert status.mentions == assert status.mentions ==
Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end) Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "create mentions from the 'to' field" do test "create mentions from the 'to' field" do
@ -405,14 +418,14 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
api_spec = Pleroma.Web.ApiSpec.spec() api_spec = Pleroma.Web.ApiSpec.spec()
assert expected == StatusView.render("attachment.json", %{attachment: object}) assert expected == StatusView.render("attachment.json", %{attachment: object})
OpenApiSpex.TestAssertions.assert_schema(expected, "Attachment", api_spec) assert_schema(expected, "Attachment", api_spec)
# If theres a "id", use that instead of the generated one # If theres a "id", use that instead of the generated one
object = Map.put(object, "id", 2) object = Map.put(object, "id", 2)
result = StatusView.render("attachment.json", %{attachment: object}) result = StatusView.render("attachment.json", %{attachment: object})
assert %{id: "2"} = result assert %{id: "2"} = result
OpenApiSpex.TestAssertions.assert_schema(result, "Attachment", api_spec) assert_schema(result, "Attachment", api_spec)
end end
test "put the url advertised in the Activity in to the url attribute" do test "put the url advertised in the Activity in to the url attribute" do
@ -436,6 +449,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
assert represented[:id] == to_string(reblog.id) assert represented[:id] == to_string(reblog.id)
assert represented[:reblog][:id] == to_string(activity.id) assert represented[:reblog][:id] == to_string(activity.id)
assert represented[:emojis] == [] assert represented[:emojis] == []
assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "a peertube video" do test "a peertube video" do
@ -452,6 +466,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
assert represented[:id] == to_string(activity.id) assert represented[:id] == to_string(activity.id)
assert length(represented[:media_attachments]) == 1 assert length(represented[:media_attachments]) == 1
assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "funkwhale audio" do test "funkwhale audio" do
@ -567,13 +582,15 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "drink more water" status: "drink more water"
}) })
result = StatusView.render("show.json", %{activity: activity, for: other_user}) result = StatusView.render("show.json", %{activity: activity, for: other_user})
assert result[:account][:pleroma][:relationship] == assert result[:account][:pleroma][:relationship] ==
AccountView.render("relationship.json", %{user: other_user, target: user}) AccountView.render("relationship.json", %{user: other_user, target: user})
assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "embeds a relationship in the account in reposts" do test "embeds a relationship in the account in reposts" do
@ -582,7 +599,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "˙˙ɐʎns" status: "˙˙ɐʎns"
}) })
{:ok, activity, _object} = CommonAPI.repeat(activity.id, other_user) {:ok, activity, _object} = CommonAPI.repeat(activity.id, other_user)
@ -594,6 +611,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
assert result[:reblog][:account][:pleroma][:relationship] == assert result[:reblog][:account][:pleroma][:relationship] ==
AccountView.render("relationship.json", %{user: user, target: user}) AccountView.render("relationship.json", %{user: user, target: user})
assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
end end
test "visibility/list" do test "visibility/list" do
@ -601,8 +620,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
{:ok, list} = Pleroma.List.create("foo", user) {:ok, list} = Pleroma.List.create("foo", user)
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
status = StatusView.render("show.json", activity: activity) status = StatusView.render("show.json", activity: activity)
@ -616,5 +634,6 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
assert status.length == listen_activity.data["object"]["length"] assert status.length == listen_activity.data["object"]["length"]
assert status.title == listen_activity.data["object"]["title"] assert status.title == listen_activity.data["object"]["title"]
assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
end end
end end

View File

@ -30,7 +30,7 @@ defmodule Pleroma.Web.Metadata.Providers.TwitterCardTest do
test "it uses summary twittercard if post has no attachment" do test "it uses summary twittercard if post has no attachment" do
user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994") user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
note = note =
insert(:note, %{ insert(:note, %{
@ -56,7 +56,7 @@ defmodule Pleroma.Web.Metadata.Providers.TwitterCardTest do
test "it renders avatar not attachment if post is nsfw and unfurl_nsfw is disabled" do test "it renders avatar not attachment if post is nsfw and unfurl_nsfw is disabled" do
Pleroma.Config.put([Pleroma.Web.Metadata, :unfurl_nsfw], false) Pleroma.Config.put([Pleroma.Web.Metadata, :unfurl_nsfw], false)
user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994") user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
note = note =
insert(:note, %{ insert(:note, %{
@ -100,7 +100,7 @@ defmodule Pleroma.Web.Metadata.Providers.TwitterCardTest do
test "it renders supported types of attachments and skips unknown types" do test "it renders supported types of attachments and skips unknown types" do
user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994") user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
note = note =
insert(:note, %{ insert(:note, %{

View File

@ -171,8 +171,8 @@ defmodule Pleroma.Web.PleromaAPI.AccountControllerTest do
} do } do
{:ok, direct} = {:ok, direct} =
CommonAPI.post(current_user, %{ CommonAPI.post(current_user, %{
"status" => "Hi @#{user.nickname}!", status: "Hi @#{user.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
CommonAPI.favorite(user, direct.id) CommonAPI.favorite(user, direct.id)
@ -204,8 +204,8 @@ defmodule Pleroma.Web.PleromaAPI.AccountControllerTest do
{:ok, direct} = {:ok, direct} =
CommonAPI.post(user_two, %{ CommonAPI.post(user_two, %{
"status" => "Hi @#{user.nickname}!", status: "Hi @#{user.nickname}!",
"visibility" => "direct" visibility: "direct"
}) })
CommonAPI.favorite(user, direct.id) CommonAPI.favorite(user, direct.id)

View File

@ -20,7 +20,7 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"}) {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
result = result =
conn conn
@ -42,7 +42,7 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"}) {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
{:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, "") {:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, "")
ObanHelpers.perform_all() ObanHelpers.perform_all()
@ -68,7 +68,7 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
other_user = insert(:user) other_user = insert(:user)
doomed_user = insert(:user) doomed_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"}) {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
result = result =
conn conn
@ -106,7 +106,7 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"}) {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
result = result =
conn conn
@ -133,7 +133,7 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
%{user: other_user, conn: conn} = oauth_access(["read:statuses"]) %{user: other_user, conn: conn} = oauth_access(["read:statuses"])
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}!", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})
[participation] = Participation.for_user(other_user) [participation] = Participation.for_user(other_user)
@ -151,18 +151,18 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
third_user = insert(:user) third_user = insert(:user)
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"status" => "Hi @#{third_user.nickname}!", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hi @#{third_user.nickname}!", visibility: "direct"})
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}!", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})
[participation] = Participation.for_user(other_user) [participation] = Participation.for_user(other_user)
{:ok, activity_two} = {:ok, activity_two} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Hi!", status: "Hi!",
"in_reply_to_status_id" => activity.id, in_reply_to_status_id: activity.id,
"in_reply_to_conversation_id" => participation.id in_reply_to_conversation_id: participation.id
}) })
result = result =
@ -178,9 +178,9 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
{:ok, %{id: id_three}} = {:ok, %{id: id_three}} =
CommonAPI.post(other_user, %{ CommonAPI.post(other_user, %{
"status" => "Bye!", status: "Bye!",
"in_reply_to_status_id" => activity.id, in_reply_to_status_id: activity.id,
"in_reply_to_conversation_id" => participation.id in_reply_to_conversation_id: participation.id
}) })
assert [%{"id" => ^id_two}, %{"id" => ^id_three}] = assert [%{"id" => ^id_two}, %{"id" => ^id_three}] =
@ -198,7 +198,7 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
%{user: user, conn: conn} = oauth_access(["write:conversations"]) %{user: user, conn: conn} = oauth_access(["write:conversations"])
other_user = insert(:user) other_user = insert(:user)
{:ok, _activity} = CommonAPI.post(user, %{"status" => "Hi", "visibility" => "direct"}) {:ok, _activity} = CommonAPI.post(user, %{status: "Hi", visibility: "direct"})
[participation] = Participation.for_user(user) [participation] = Participation.for_user(user)
@ -229,10 +229,10 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
%{user: other_user, conn: conn} = oauth_access(["write:conversations"]) %{user: other_user, conn: conn} = oauth_access(["write:conversations"])
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user, %{"status" => "Hi @#{other_user.nickname}", "visibility" => "direct"}) CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
[participation2, participation1] = Participation.for_user(other_user) [participation2, participation1] = Participation.for_user(other_user)
assert Participation.get(participation2.id).read == false assert Participation.get(participation2.id).read == false
@ -255,8 +255,8 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
test "it marks a single notification as read", %{user: user1, conn: conn} do test "it marks a single notification as read", %{user: user1, conn: conn} do
user2 = insert(:user) user2 = insert(:user)
{:ok, activity1} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"}) {:ok, activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
{:ok, activity2} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"}) {:ok, activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
{:ok, [notification1]} = Notification.create_notifications(activity1) {:ok, [notification1]} = Notification.create_notifications(activity1)
{:ok, [notification2]} = Notification.create_notifications(activity2) {:ok, [notification2]} = Notification.create_notifications(activity2)
@ -272,9 +272,9 @@ defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
test "it marks multiple notifications as read", %{user: user1, conn: conn} do test "it marks multiple notifications as read", %{user: user1, conn: conn} do
user2 = insert(:user) user2 = insert(:user)
{:ok, _activity1} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"}) {:ok, _activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
{:ok, _activity2} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"}) {:ok, _activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
{:ok, _activity3} = CommonAPI.post(user2, %{"status" => "HIE @#{user1.nickname}"}) {:ok, _activity3} = CommonAPI.post(user2, %{status: "HIE @#{user1.nickname}"})
[notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3}) [notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})

View File

@ -55,7 +55,7 @@ defmodule Pleroma.Web.Push.ImplTest do
data: %{alerts: %{"follow" => true, "mention" => false}} data: %{alerts: %{"follow" => true, "mention" => false}}
) )
{:ok, activity} = CommonAPI.post(user, %{"status" => "<Lorem ipsum dolor sit amet."}) {:ok, activity} = CommonAPI.post(user, %{status: "<Lorem ipsum dolor sit amet."})
notif = notif =
insert(:notification, insert(:notification,
@ -111,7 +111,7 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis." "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
}) })
@ -147,7 +147,7 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis." "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
}) })
@ -166,7 +166,7 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => status:
"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis." "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
}) })
@ -184,8 +184,8 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "direct", visibility: "direct",
"status" => "This is just between you and me, pal" status: "This is just between you and me, pal"
}) })
assert Impl.format_title(%{activity: activity}) == assert Impl.format_title(%{activity: activity}) ==
@ -199,8 +199,8 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "direct", visibility: "direct",
"status" => "<Lorem ipsum dolor sit amet." status: "<Lorem ipsum dolor sit amet."
}) })
notif = insert(:notification, user: user2, activity: activity) notif = insert(:notification, user: user2, activity: activity)
@ -214,8 +214,8 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "public", visibility: "public",
"status" => "<Lorem ipsum dolor sit amet." status: "<Lorem ipsum dolor sit amet."
}) })
notif = insert(:notification, user: user2, activity: activity) notif = insert(:notification, user: user2, activity: activity)
@ -245,8 +245,8 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "direct", visibility: "direct",
"status" => status:
"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis." "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
}) })
@ -263,8 +263,8 @@ defmodule Pleroma.Web.Push.ImplTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"visibility" => "public", visibility: "public",
"status" => status:
"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis." "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
}) })

View File

@ -26,8 +26,8 @@ defmodule Pleroma.Web.RichMedia.HelpersTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "[test](example.com/ogp)", status: "[test](example.com/ogp)",
"content_type" => "text/markdown" content_type: "text/markdown"
}) })
Config.put([:rich_media, :enabled], true) Config.put([:rich_media, :enabled], true)
@ -40,8 +40,8 @@ defmodule Pleroma.Web.RichMedia.HelpersTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "[test](example.com[]/ogp)", status: "[test](example.com[]/ogp)",
"content_type" => "text/markdown" content_type: "text/markdown"
}) })
Config.put([:rich_media, :enabled], true) Config.put([:rich_media, :enabled], true)
@ -54,8 +54,8 @@ defmodule Pleroma.Web.RichMedia.HelpersTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "[test](https://example.com/ogp)", status: "[test](https://example.com/ogp)",
"content_type" => "text/markdown" content_type: "text/markdown"
}) })
Config.put([:rich_media, :enabled], true) Config.put([:rich_media, :enabled], true)
@ -69,8 +69,8 @@ defmodule Pleroma.Web.RichMedia.HelpersTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "http://example.com/ogp", status: "http://example.com/ogp",
"sensitive" => true sensitive: true
}) })
%Object{} = object = Object.normalize(activity) %Object{} = object = Object.normalize(activity)
@ -87,7 +87,7 @@ defmodule Pleroma.Web.RichMedia.HelpersTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "http://example.com/ogp #nsfw" status: "http://example.com/ogp #nsfw"
}) })
%Object{} = object = Object.normalize(activity) %Object{} = object = Object.normalize(activity)
@ -103,12 +103,12 @@ defmodule Pleroma.Web.RichMedia.HelpersTest do
user = insert(:user) user = insert(:user)
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user, %{"status" => "http://127.0.0.1:4000/notice/9kCP7VNyPJXFOXDrgO"}) CommonAPI.post(user, %{status: "http://127.0.0.1:4000/notice/9kCP7VNyPJXFOXDrgO"})
{:ok, activity2} = CommonAPI.post(user, %{"status" => "https://10.111.10.1/notice/9kCP7V"}) {:ok, activity2} = CommonAPI.post(user, %{status: "https://10.111.10.1/notice/9kCP7V"})
{:ok, activity3} = CommonAPI.post(user, %{"status" => "https://172.16.32.40/notice/9kCP7V"}) {:ok, activity3} = CommonAPI.post(user, %{status: "https://172.16.32.40/notice/9kCP7V"})
{:ok, activity4} = CommonAPI.post(user, %{"status" => "https://192.168.10.40/notice/9kCP7V"}) {:ok, activity4} = CommonAPI.post(user, %{status: "https://192.168.10.40/notice/9kCP7V"})
{:ok, activity5} = CommonAPI.post(user, %{"status" => "https://pleroma.local/notice/9kCP7V"}) {:ok, activity5} = CommonAPI.post(user, %{status: "https://pleroma.local/notice/9kCP7V"})
Config.put([:rich_media, :enabled], true) Config.put([:rich_media, :enabled], true)

View File

@ -32,8 +32,8 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
end end
test "profile does not include private messages", %{conn: conn, user: user} do test "profile does not include private messages", %{conn: conn, user: user} do
CommonAPI.post(user, %{"status" => "public"}) CommonAPI.post(user, %{status: "public"})
CommonAPI.post(user, %{"status" => "private", "visibility" => "private"}) CommonAPI.post(user, %{status: "private", visibility: "private"})
conn = get(conn, "/users/#{user.nickname}") conn = get(conn, "/users/#{user.nickname}")
@ -44,7 +44,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
end end
test "pagination", %{conn: conn, user: user} do test "pagination", %{conn: conn, user: user} do
Enum.map(1..30, fn i -> CommonAPI.post(user, %{"status" => "test#{i}"}) end) Enum.map(1..30, fn i -> CommonAPI.post(user, %{status: "test#{i}"}) end)
conn = get(conn, "/users/#{user.nickname}") conn = get(conn, "/users/#{user.nickname}")
@ -57,7 +57,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
end end
test "pagination, page 2", %{conn: conn, user: user} do test "pagination, page 2", %{conn: conn, user: user} do
activities = Enum.map(1..30, fn i -> CommonAPI.post(user, %{"status" => "test#{i}"}) end) activities = Enum.map(1..30, fn i -> CommonAPI.post(user, %{status: "test#{i}"}) end)
{:ok, a11} = Enum.at(activities, 11) {:ok, a11} = Enum.at(activities, 11)
conn = get(conn, "/users/#{user.nickname}?max_id=#{a11.id}") conn = get(conn, "/users/#{user.nickname}?max_id=#{a11.id}")
@ -77,7 +77,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
describe "notice html" do describe "notice html" do
test "single notice page", %{conn: conn, user: user} do test "single notice page", %{conn: conn, user: user} do
{:ok, activity} = CommonAPI.post(user, %{"status" => "testing a thing!"}) {:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})
conn = get(conn, "/notice/#{activity.id}") conn = get(conn, "/notice/#{activity.id}")
@ -89,7 +89,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
test "filters HTML tags", %{conn: conn} do test "filters HTML tags", %{conn: conn} do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "<script>alert('xss')</script>"}) {:ok, activity} = CommonAPI.post(user, %{status: "<script>alert('xss')</script>"})
conn = conn =
conn conn
@ -101,11 +101,11 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
end end
test "shows the whole thread", %{conn: conn, user: user} do test "shows the whole thread", %{conn: conn, user: user} do
{:ok, activity} = CommonAPI.post(user, %{"status" => "space: the final frontier"}) {:ok, activity} = CommonAPI.post(user, %{status: "space: the final frontier"})
CommonAPI.post(user, %{ CommonAPI.post(user, %{
"status" => "these are the voyages or something", status: "these are the voyages or something",
"in_reply_to_status_id" => activity.id in_reply_to_status_id: activity.id
}) })
conn = get(conn, "/notice/#{activity.id}") conn = get(conn, "/notice/#{activity.id}")
@ -117,7 +117,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
test "redirect by AP object ID", %{conn: conn, user: user} do test "redirect by AP object ID", %{conn: conn, user: user} do
{:ok, %Activity{data: %{"object" => object_url}}} = {:ok, %Activity{data: %{"object" => object_url}}} =
CommonAPI.post(user, %{"status" => "beam me up"}) CommonAPI.post(user, %{status: "beam me up"})
conn = get(conn, URI.parse(object_url).path) conn = get(conn, URI.parse(object_url).path)
@ -126,7 +126,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
test "redirect by activity ID", %{conn: conn, user: user} do test "redirect by activity ID", %{conn: conn, user: user} do
{:ok, %Activity{data: %{"id" => id}}} = {:ok, %Activity{data: %{"id" => id}}} =
CommonAPI.post(user, %{"status" => "I'm a doctor, not a devops!"}) CommonAPI.post(user, %{status: "I'm a doctor, not a devops!"})
conn = get(conn, URI.parse(id).path) conn = get(conn, URI.parse(id).path)
@ -140,8 +140,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
end end
test "404 for private status", %{conn: conn, user: user} do test "404 for private status", %{conn: conn, user: user} do
{:ok, activity} = {:ok, activity} = CommonAPI.post(user, %{status: "don't show me!", visibility: "private"})
CommonAPI.post(user, %{"status" => "don't show me!", "visibility" => "private"})
conn = get(conn, "/notice/#{activity.id}") conn = get(conn, "/notice/#{activity.id}")
@ -171,7 +170,7 @@ defmodule Pleroma.Web.StaticFE.StaticFEControllerTest do
end end
test "it requires authentication if instance is NOT federating", %{conn: conn, user: user} do test "it requires authentication if instance is NOT federating", %{conn: conn, user: user} do
{:ok, activity} = CommonAPI.post(user, %{"status" => "testing a thing!"}) {:ok, activity} = CommonAPI.post(user, %{status: "testing a thing!"})
ensure_federating_or_authenticated(conn, "/notice/#{activity.id}", user) ensure_federating_or_authenticated(conn, "/notice/#{activity.id}", user)
end end

View File

@ -96,7 +96,7 @@ defmodule Pleroma.Web.StreamerTest do
test "it streams the user's post in the 'user' stream", %{user: user} do test "it streams the user's post in the 'user' stream", %{user: user} do
Streamer.get_topic_and_add_socket("user", user) Streamer.get_topic_and_add_socket("user", user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
assert_receive {:render_with_user, _, _, ^activity} assert_receive {:render_with_user, _, _, ^activity}
refute Streamer.filtered_by_user?(user, activity) refute Streamer.filtered_by_user?(user, activity)
end end
@ -105,7 +105,7 @@ defmodule Pleroma.Web.StreamerTest do
Streamer.get_topic_and_add_socket("user", user) Streamer.get_topic_and_add_socket("user", user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
{:ok, announce, _} = CommonAPI.repeat(activity.id, user) {:ok, announce, _} = CommonAPI.repeat(activity.id, user)
assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce} assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce}
@ -134,7 +134,7 @@ defmodule Pleroma.Web.StreamerTest do
Streamer.get_topic_and_add_socket("user:notification", user) Streamer.get_topic_and_add_socket("user:notification", user)
{:ok, activity} = CommonAPI.post(user, %{"status" => ":("}) {:ok, activity} = CommonAPI.post(user, %{status: ":("})
{:ok, _} = CommonAPI.favorite(blocked, activity.id) {:ok, _} = CommonAPI.favorite(blocked, activity.id)
refute_receive _ refute_receive _
@ -145,7 +145,7 @@ defmodule Pleroma.Web.StreamerTest do
} do } do
user2 = insert(:user) user2 = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"}) {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
{:ok, _} = CommonAPI.add_mute(user, activity) {:ok, _} = CommonAPI.add_mute(user, activity)
Streamer.get_topic_and_add_socket("user:notification", user) Streamer.get_topic_and_add_socket("user:notification", user)
@ -161,7 +161,7 @@ defmodule Pleroma.Web.StreamerTest do
} do } do
user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"}) user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
{:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"}) {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
Streamer.get_topic_and_add_socket("user:notification", user) Streamer.get_topic_and_add_socket("user:notification", user)
{:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id) {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
@ -176,7 +176,7 @@ defmodule Pleroma.Web.StreamerTest do
user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"}) user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
{:ok, user} = User.block_domain(user, "hecking-lewd-place.com") {:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
{:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"}) {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
Streamer.get_topic_and_add_socket("user:notification", user) Streamer.get_topic_and_add_socket("user:notification", user)
{:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id) {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
@ -215,7 +215,7 @@ defmodule Pleroma.Web.StreamerTest do
Streamer.get_topic_and_add_socket("public", other_user) Streamer.get_topic_and_add_socket("public", other_user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Test"}) {:ok, activity} = CommonAPI.post(user, %{status: "Test"})
assert_receive {:render_with_user, _, _, ^activity} assert_receive {:render_with_user, _, _, ^activity}
refute Streamer.filtered_by_user?(user, activity) refute Streamer.filtered_by_user?(user, activity)
end end
@ -223,7 +223,7 @@ defmodule Pleroma.Web.StreamerTest do
test "works for deletions" do test "works for deletions" do
user = insert(:user) user = insert(:user)
other_user = insert(:user) other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{"status" => "Test"}) {:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
Streamer.get_topic_and_add_socket("public", user) Streamer.get_topic_and_add_socket("public", user)
@ -238,7 +238,7 @@ defmodule Pleroma.Web.StreamerTest do
Streamer.get_topic_and_add_socket("public", nil) Streamer.get_topic_and_add_socket("public", nil)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Test"}) {:ok, activity} = CommonAPI.post(user, %{status: "Test"})
activity_id = activity.id activity_id = activity.id
assert_receive {:text, event} assert_receive {:text, event}
assert %{"event" => "update", "payload" => payload} = Jason.decode!(event) assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
@ -323,7 +323,7 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, _user_relationship} = User.block(user, blocked_user) {:ok, _user_relationship} = User.block(user, blocked_user)
Streamer.get_topic_and_add_socket("public", user) Streamer.get_topic_and_add_socket("public", user)
{:ok, activity} = CommonAPI.post(blocked_user, %{"status" => "Test"}) {:ok, activity} = CommonAPI.post(blocked_user, %{status: "Test"})
assert_receive {:render_with_user, _, _, ^activity} assert_receive {:render_with_user, _, _, ^activity}
assert Streamer.filtered_by_user?(user, activity) assert Streamer.filtered_by_user?(user, activity)
end end
@ -337,17 +337,17 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, _user_relationship} = User.block(blocker, blockee) {:ok, _user_relationship} = User.block(blocker, blockee)
{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"}) {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})
assert_receive {:render_with_user, _, _, ^activity_one} assert_receive {:render_with_user, _, _, ^activity_one}
assert Streamer.filtered_by_user?(blocker, activity_one) assert Streamer.filtered_by_user?(blocker, activity_one)
{:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"}) {:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
assert_receive {:render_with_user, _, _, ^activity_two} assert_receive {:render_with_user, _, _, ^activity_two}
assert Streamer.filtered_by_user?(blocker, activity_two) assert Streamer.filtered_by_user?(blocker, activity_two)
{:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"}) {:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})
assert_receive {:render_with_user, _, _, ^activity_three} assert_receive {:render_with_user, _, _, ^activity_three}
assert Streamer.filtered_by_user?(blocker, activity_three) assert Streamer.filtered_by_user?(blocker, activity_three)
@ -369,8 +369,8 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user_b, %{ CommonAPI.post(user_b, %{
"status" => "@#{user_c.nickname} Test", status: "@#{user_c.nickname} Test",
"visibility" => "direct" visibility: "direct"
}) })
refute_receive _ refute_receive _
@ -387,8 +387,8 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, _activity} = {:ok, _activity} =
CommonAPI.post(user_b, %{ CommonAPI.post(user_b, %{
"status" => "Test", status: "Test",
"visibility" => "private" visibility: "private"
}) })
refute_receive _ refute_receive _
@ -407,8 +407,8 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, activity} = {:ok, activity} =
CommonAPI.post(user_b, %{ CommonAPI.post(user_b, %{
"status" => "Test", status: "Test",
"visibility" => "private" visibility: "private"
}) })
assert_receive {:render_with_user, _, _, ^activity} assert_receive {:render_with_user, _, _, ^activity}
@ -424,7 +424,7 @@ defmodule Pleroma.Web.StreamerTest do
CommonAPI.follow(user1, user2) CommonAPI.follow(user1, user2)
CommonAPI.hide_reblogs(user1, user2) CommonAPI.hide_reblogs(user1, user2)
{:ok, create_activity} = CommonAPI.post(user3, %{"status" => "I'm kawen"}) {:ok, create_activity} = CommonAPI.post(user3, %{status: "I'm kawen"})
Streamer.get_topic_and_add_socket("user", user1) Streamer.get_topic_and_add_socket("user", user1)
{:ok, announce_activity, _} = CommonAPI.repeat(create_activity.id, user2) {:ok, announce_activity, _} = CommonAPI.repeat(create_activity.id, user2)
@ -438,7 +438,7 @@ defmodule Pleroma.Web.StreamerTest do
CommonAPI.follow(user1, user2) CommonAPI.follow(user1, user2)
CommonAPI.hide_reblogs(user1, user2) CommonAPI.hide_reblogs(user1, user2)
{:ok, create_activity} = CommonAPI.post(user1, %{"status" => "I'm kawen"}) {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
Streamer.get_topic_and_add_socket("user", user1) Streamer.get_topic_and_add_socket("user", user1)
{:ok, _favorite_activity, _} = CommonAPI.repeat(create_activity.id, user2) {:ok, _favorite_activity, _} = CommonAPI.repeat(create_activity.id, user2)
@ -452,7 +452,7 @@ defmodule Pleroma.Web.StreamerTest do
CommonAPI.follow(user1, user2) CommonAPI.follow(user1, user2)
CommonAPI.hide_reblogs(user1, user2) CommonAPI.hide_reblogs(user1, user2)
{:ok, create_activity} = CommonAPI.post(user1, %{"status" => "I'm kawen"}) {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
Streamer.get_topic_and_add_socket("user", user1) Streamer.get_topic_and_add_socket("user", user1)
{:ok, _favorite_activity} = CommonAPI.favorite(user2, create_activity.id) {:ok, _favorite_activity} = CommonAPI.favorite(user2, create_activity.id)
@ -466,7 +466,7 @@ defmodule Pleroma.Web.StreamerTest do
user2 = insert(:user) user2 = insert(:user)
Streamer.get_topic_and_add_socket("user", user2) Streamer.get_topic_and_add_socket("user", user2)
{:ok, user2, user, _activity} = CommonAPI.follow(user2, user) {:ok, user2, user, _activity} = CommonAPI.follow(user2, user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"}) {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
{:ok, _} = CommonAPI.add_mute(user2, activity) {:ok, _} = CommonAPI.add_mute(user2, activity)
assert_receive {:render_with_user, _, _, ^activity} assert_receive {:render_with_user, _, _, ^activity}
assert Streamer.filtered_by_user?(user2, activity) assert Streamer.filtered_by_user?(user2, activity)
@ -485,8 +485,8 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, _create_activity} = {:ok, _create_activity} =
CommonAPI.post(another_user, %{ CommonAPI.post(another_user, %{
"status" => "hey @#{user.nickname}", status: "hey @#{user.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
assert_receive {:text, received_event} assert_receive {:text, received_event}
@ -507,8 +507,8 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, create_activity} = {:ok, create_activity} =
CommonAPI.post(another_user, %{ CommonAPI.post(another_user, %{
"status" => "hi @#{user.nickname}", status: "hi @#{user.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
create_activity_id = create_activity.id create_activity_id = create_activity.id
@ -533,15 +533,15 @@ defmodule Pleroma.Web.StreamerTest do
{:ok, create_activity} = {:ok, create_activity} =
CommonAPI.post(another_user, %{ CommonAPI.post(another_user, %{
"status" => "hi @#{user.nickname}", status: "hi @#{user.nickname}",
"visibility" => "direct" visibility: "direct"
}) })
{:ok, create_activity2} = {:ok, create_activity2} =
CommonAPI.post(another_user, %{ CommonAPI.post(another_user, %{
"status" => "hi @#{user.nickname} 2", status: "hi @#{user.nickname} 2",
"in_reply_to_status_id" => create_activity.id, in_reply_to_status_id: create_activity.id,
"visibility" => "direct" visibility: "direct"
}) })
assert_receive {:render_with_user, _, _, ^create_activity} assert_receive {:render_with_user, _, _, ^create_activity}

View File

@ -29,7 +29,7 @@ defmodule Pleroma.Workers.Cron.DigestEmailsWorkerTest do
user2 = insert(:user, last_digest_emailed_at: date) user2 = insert(:user, last_digest_emailed_at: date)
{:ok, _} = User.switch_email_notifications(user2, "digest", true) {:ok, _} = User.switch_email_notifications(user2, "digest", true)
CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}!"}) CommonAPI.post(user, %{status: "hey @#{user2.nickname}!"})
{:ok, user2: user2} {:ok, user2: user2}
end end

View File

@ -15,7 +15,7 @@ defmodule Pleroma.Workers.Cron.NewUsersDigestWorkerTest do
admin = insert(:user, %{is_admin: true}) admin = insert(:user, %{is_admin: true})
user = insert(:user, %{inserted_at: yesterday}) user = insert(:user, %{inserted_at: yesterday})
user2 = insert(:user, %{inserted_at: yesterday}) user2 = insert(:user, %{inserted_at: yesterday})
CommonAPI.post(user, %{"status" => "cofe"}) CommonAPI.post(user, %{status: "cofe"})
NewUsersDigestWorker.perform(nil, nil) NewUsersDigestWorker.perform(nil, nil)
ObanHelpers.perform_all() ObanHelpers.perform_all()
@ -36,7 +36,7 @@ defmodule Pleroma.Workers.Cron.NewUsersDigestWorkerTest do
insert(:user, %{inserted_at: yesterday}) insert(:user, %{inserted_at: yesterday})
user = insert(:user, %{inserted_at: yesterday}) user = insert(:user, %{inserted_at: yesterday})
CommonAPI.post(user, %{"status" => "cofe"}) CommonAPI.post(user, %{status: "cofe"})
NewUsersDigestWorker.perform(nil, nil) NewUsersDigestWorker.perform(nil, nil)
ObanHelpers.perform_all() ObanHelpers.perform_all()