### Removed
- Non-finch HTTP adapters
-### Upgrade notes
-- Ensure `config :tesla, :adapter` is either unset, or set to `{Tesla.Adapter.Finch, name: MyFinch}` in your .exs config
+- Legacy redirect from /api/pleroma/admin to /api/v1/pleroma/admin
+
### Changed
- Return HTTP error 413 when uploading an avatar or banner that's above the configured upload limit instead of a 500.
+### Upgrade notes
+- Ensure `config :tesla, :adapter` is either unset, or set to `{Tesla.Adapter.Finch, name: MyFinch}` in your .exs config
+
## 2022.12
## Added
+# credo:disable-for-this-file
# Pleroma: A lightweight social networking server
# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
nil
|> Pleroma.Workers.Cron.PruneDatabaseWorker.perform()
- |> IO.inspect()
end
def run(["fix_likes_collections"]) do
+# credo:disable-for-this-file
defmodule Mix.Tasks.Pleroma.Diagnostics do
alias Pleroma.Repo
alias Pleroma.User
config_dir = Path.dirname(config_path)
psql_dir = Path.dirname(psql_path)
- [config_dir, psql_dir, static_dir, uploads_dir]
- |> Enum.reject(&File.exists?/1)
- |> Enum.map(&File.mkdir_p!/1)
+ to_create =
+ [config_dir, psql_dir, static_dir, uploads_dir]
+ |> Enum.reject(&File.exists?/1)
+
+ for dir <- to_create do
+ File.mkdir_p!(dir)
+ end
shell_info("Writing config to #{config_path}.")
enabled_filters
end
-
- defp upload_filters(_), do: []
end
def run(["import", "activities" | _rest]) do
start_pleroma()
- IO.inspect(Pleroma.Config.get([Pleroma.Search.Elasticsearch.Cluster, :indexes, :activities]))
- IO.inspect(
- Elasticsearch.Index.Bulk.upload(
- Pleroma.Search.Elasticsearch.Cluster,
- "activities",
- Pleroma.Config.get([Pleroma.Search.Elasticsearch.Cluster, :indexes, :activities])
- )
+ Elasticsearch.Index.Bulk.upload(
+ Pleroma.Search.Elasticsearch.Cluster,
+ "activities",
+ Pleroma.Config.get([Pleroma.Search.Elasticsearch.Cluster, :indexes, :activities])
)
end
end
def run(["show", nickname]) do
start_pleroma()
- nickname
- |> User.get_cached_by_nickname()
- |> IO.inspect()
+ user =
+ nickname
+ |> User.get_cached_by_nickname()
+
+ shell_info("#{inspect(user)}")
end
def run(["send_confirmation", nickname]) do
with %User{} = user <- User.get_cached_by_nickname(nickname) do
user
|> Pleroma.Emails.UserEmail.account_confirmation_email()
- |> IO.inspect()
|> Pleroma.Emails.Mailer.deliver!()
shell_info("#{nickname}'s email sent")
with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
blocks = User.following_ap_ids(user)
- IO.inspect(blocks, limit: :infinity)
+ IO.puts("#{inspect(blocks)}")
end
end
def invalidate_cache_for(activity_id) do
keys = get_cache_keys_for(activity_id)
- Enum.map(keys, &@cachex.del(:scrubber_cache, &1))
+
+ for key <- keys do
+ @cachex.del(:scrubber_cache, key)
+ end
+
@cachex.del(:scrubber_management_cache, activity_id)
end
end
def change(struct, params \\ %{}) do
+ params = validate_params(struct, params)
+
struct
- |> cast(validate_params(struct, params), [:data, :starts_at, :ends_at, :rendered])
+ |> cast(params, [:data, :starts_at, :ends_at, :rendered])
|> validate_required([:data])
end
]
end
+ @spec task_children(atom()) :: [map()]
+
defp task_children(:test) do
[
%{
]
end
+ @spec elasticsearch_children :: [Pleroma.Search.Elasticsearch.Cluster]
def elasticsearch_children do
config = Config.get([Pleroma.Search, :module])
end
end
- defp check_system_commands!(result), do: result
-
defp check_repo_pool_size!(:ok) do
if Pleroma.Config.get([Pleroma.Repo, :pool_size], 10) != 10 and
not Pleroma.Config.get([:dangerzone, :override_repo_pool_size], false) do
with :ok <- validate_shareable_packs_available(uri) do
uri
- |> URI.merge("/api/pleroma/emoji/packs?page=#{opts[:page]}&page_size=#{opts[:page_size]}")
+ |> URI.merge(
+ "/api/v1/pleroma/emoji/packs?page=#{opts[:page]}&page_size=#{opts[:page_size]}"
+ )
|> http_get()
end
end
with :ok <- validate_shareable_packs_available(uri),
{:ok, remote_pack} <-
- uri |> URI.merge("/api/pleroma/emoji/pack?name=#{name}") |> http_get(),
+ uri |> URI.merge("/api/v1/pleroma/emoji/pack?name=#{name}") |> http_get(),
{:ok, %{sha: sha, url: url} = pack_info} <- fetch_pack_info(remote_pack, uri, name),
{:ok, archive} <- download_archive(url, sha),
pack <- copy_as(remote_pack, as || name),
{:ok,
%{
sha: sha,
- url: URI.merge(uri, "/api/pleroma/emoji/packs/archive?name=#{name}") |> to_string()
+ url: URI.merge(uri, "/api/v1/pleroma/emoji/packs/archive?name=#{name}") |> to_string()
}}
%{"fallback-src" => src, "fallback-src-sha256" => sha} when is_binary(src) ->
alias Pleroma.Repo
alias Pleroma.User
+ @type follow_state :: :follow_pending | :follow_accept | :follow_reject | :unfollow
+
schema "following_relationships" do
field(:state, State, default: :follow_pending)
end
end
+ @spec follow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, any}
def follow(%User{} = follower, %User{} = following, state \\ :follow_accept) do
with {:ok, _following_relationship} <-
%__MODULE__{}
end
end
+ @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, any}
def unfollow(%User{} = follower, %User{} = following) do
case get(follower, following) do
%__MODULE__{} = following_relationship ->
end
_ ->
- {:ok, nil}
+ {:ok, follower, following}
end
end
+ @spec after_update(follow_state(), User.t(), User.t()) ::
+ {:ok, User.t(), User.t()} | {:error, any()}
defp after_update(state, %User{} = follower, %User{} = following) do
with {:ok, following} <- User.update_follower_count(following),
{:ok, follower} <- User.update_following_count(follower) do
})
{:ok, follower, following}
+ else
+ err -> {:error, err}
end
end
args: args
])
- fifo = Port.open(to_charlist(fifo_path), [:eof, :binary, :stream, :out])
+ fifo = File.open!(fifo_path, [:append, :binary])
fix = Pleroma.Helpers.QtFastStart.fix(env.body)
- true = Port.command(fifo, fix)
- :erlang.port_close(fifo)
+ IO.binwrite(fifo, fix)
+ File.close(fifo)
loop_recv(pid)
after
File.rm(fifo_path)
alias Pleroma.HTTP.AdapterHelper
require Logger
- @type proxy ::
- {Connection.host(), pos_integer()}
- | {Connection.proxy_type(), Connection.host(), pos_integer()}
+ @type proxy :: {Connection.proxy_type(), Connection.host(), pos_integer(), list()}
@callback options(keyword(), URI.t()) :: keyword()
def format_proxy(proxy_url) do
case parse_proxy(proxy_url) do
- {:ok, host, port} -> {:http, host, port, []}
{:ok, type, host, port} -> {type, host, port, []}
_ -> nil
end
defp proxy_type(_), do: {:error, :unknown}
@spec parse_proxy(String.t() | tuple() | nil) ::
- {:ok, host(), pos_integer()}
- | {:ok, proxy_type(), host(), pos_integer()}
+ {:ok, proxy_type(), host(), pos_integer()}
| {:error, atom()}
| nil
def parse_proxy(nil), do: nil
@callback fault_rate_allowance() :: integer() | float()
defmacro __using__(_opts) do
- quote do
+ quote generated: true do
use GenServer
require Logger
insert_log_entry_with_message(%ModerationLog{data: data})
end
- @spec insert_log_entry_with_message(ModerationLog) :: {:ok, ModerationLog} | {:error, any}
+ @spec insert_log_entry_with_message(ModerationLog.t()) ::
+ {:ok, ModerationLog.t()} | {:error, any}
defp insert_log_entry_with_message(entry) do
entry.data["message"]
|> put_in(get_log_entry_message(entry))
{:ok, _} <- invalid_object_cache(object) do
cleanup_attachments(
Config.get([:instance, :cleanup_attachments]),
- %{"object" => object}
+ %{object: object}
)
{:ok, object, deleted_activity}
@spec cleanup_attachments(boolean(), %{required(:object) => map()}) ::
{:ok, Oban.Job.t() | nil}
- def cleanup_attachments(true, %{"object" => _} = params) do
+ def cleanup_attachments(true, %{object: _} = params) do
AttachmentsCleanupWorker.enqueue("cleanup_attachments", params)
end
IO.puts("The database for #{inspect(@repo)} has already been created")
{:error, term} when is_binary(term) ->
- IO.puts(:stderr, "The database for #{inspect(@repo)} couldn't be created: #{term}")
-
- {:error, term} ->
IO.puts(
:stderr,
"The database for #{inspect(@repo)} couldn't be created: #{inspect(term)}"
@impl true
@spec close(map) :: :ok | no_return()
def close(%{pid: _pid}) do
+ :ok
end
defp check_adapter do
def es_query(:activity, query, offset, limit) do
must = Parsers.Activity.parse(query)
- if must == [] do
- :skip
- else
- %{
- size: limit,
- from: offset,
- terminate_after: 50,
- timeout: "5s",
- sort: [
- "_score",
- %{"_timestamp" => %{order: "desc", format: "basic_date_time"}}
- ],
- query: %{
- bool: %{
- must: must
- }
+ %{
+ size: limit,
+ from: offset,
+ terminate_after: 50,
+ timeout: "5s",
+ sort: [
+ "_score",
+ %{"_timestamp" => %{order: "desc", format: "basic_date_time"}}
+ ],
+ query: %{
+ bool: %{
+ must: must
}
}
- end
+ }
end
defp maybe_fetch(:activity, search_query) do
defimpl Elasticsearch.Document, for: Pleroma.Object do
def id(obj), do: obj.id
def routing(_), do: false
- def encode(_), do: nil
+ def encode(_), do: %{}
end
with {:ok, res} <- result,
true <- Map.has_key?(res, "taskUid") do
- # Do nothing
+ {:ok, res}
else
- _ ->
+ err ->
Logger.error("Failed to add activity #{activity.id} to index: #{inspect(result)}")
+ {:error, err}
end
end
end
The whole activity is passed, to allow filtering on things such as scope.
"""
- @callback add_to_index(activity :: Pleroma.Activity.t()) :: nil
+ @callback add_to_index(activity :: Pleroma.Activity.t()) :: {:ok, any()} | {:error, any()}
@doc """
Remove the object from the index.
is what contains the actual content and there is no need for fitlering when removing
from index.
"""
- @callback remove_from_index(object :: Pleroma.Object.t()) :: nil
+ @callback remove_from_index(object :: Pleroma.Object.t()) :: {:ok, any()} | {:error, any()}
end
_ ->
case Pleroma.Web.WebFinger.finger(maybe_ap_id) do
- %{"ap_id" => ap_id} -> {:ok, ap_id}
+ {:ok, %{"ap_id" => ap_id}} -> {:ok, ap_id}
_ -> {:error, maybe_ap_id}
end
end
defp prepare_upload(%{img: "data:image/" <> image_data}, opts) do
parsed = Regex.named_captures(~r/(?<filetype>jpeg|png|gif);base64,(?<data>.*)/, image_data)
data = Base.decode64!(parsed["data"], ignore: :whitespace)
- hash = Base.encode16(:crypto.hash(:sha256, data), lower: true)
+ hash = Base.encode16(:crypto.hash(:sha256, data), case: :lower)
with :ok <- check_binary_size(data, opts.size_limit),
tmp_path <- tempfile_for_image(data),
%{width: width, height: height}
else
nil -> {:error, {:ffprobe, :command_not_found}}
- {:error, _} = error -> error
end
end
end
"""
@behaviour Pleroma.Upload.Filter
- @spec filter(Pleroma.Upload.t()) :: {:ok, any()} | {:error, String.t()}
+ @spec filter(Pleroma.Upload.t()) :: {:ok, :noop} | {:ok, :filtered} | {:error, String.t()}
# Formats not compatible with exiftool at this time
def filter(%Pleroma.Upload{content_type: "image/heic"}), do: {:ok, :noop}
[{"fill", "yellow"}, {"tint", "40"}]
]
- @spec filter(Pleroma.Upload.t()) :: {:ok, atom()} | {:error, String.t()}
+ @spec filter(Pleroma.Upload.t()) :: {:ok, :filtered | :noop} | {:error, String.t()}
def filter(%Pleroma.Upload{tempfile: file, content_type: "image" <> _}) do
try do
Filter.Mogrify.do_filter(file, [Enum.random(@filters)])
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.User do
+ @moduledoc """
+ A user, local or remote
+ """
+
use Ecto.Schema
import Ecto.Changeset
end
defp put_fields(changeset) do
+ # These fields are inconsistent in tests when it comes to binary/atom keys
if raw_fields = get_change(changeset, :raw_fields) do
raw_fields =
raw_fields
+ |> Enum.map(fn
+ %{name: name, value: value} ->
+ %{"name" => name, "value" => value}
+
+ %{"name" => _} = field ->
+ field
+ end)
|> Enum.filter(fn %{"name" => n} -> n != "" end)
fields =
|> put_private_key()
end
- def register_changeset(struct, params \\ %{}, opts \\ []) do
+ @spec register_changeset(User.t(), map(), keyword()) :: Changeset.t()
+ def register_changeset(%User{} = struct, params \\ %{}, opts \\ []) do
bio_limit = Config.get([:instance, :user_bio_length], 5000)
name_limit = Config.get([:instance, :user_name_length], 100)
reason_limit = Config.get([:instance, :registration_reason_length], 500)
end
@doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
+ @spec register(Changeset.t()) :: {:ok, User.t()} | {:error, any} | nil
def register(%Ecto.Changeset{} = changeset) do
with {:ok, user} <- Repo.insert(changeset) do
post_register_action(user)
end
end
+ @spec post_register_action(User.t()) :: {:error, any} | {:ok, User.t()}
def post_register_action(%User{is_confirmed: false} = user) do
with {:ok, _} <- maybe_send_confirmation_email(user) do
{:ok, user}
def needs_update?(_), do: true
- @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
+ @spec maybe_direct_follow(User.t(), User.t()) ::
+ {:ok, User.t(), User.t()} | {:error, String.t()}
# "Locked" (self-locked) users demand explicit authorization of follow requests
def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
get_cached_by_nickname(nickname)
end
+ @spec set_cache(
+ {:error, any}
+ | {:ok, User.t()}
+ | User.t()
+ ) :: {:ok, User.t()} | {:error, any}
def set_cache({:ok, user}), do: set_cache(user)
def set_cache({:error, err}), do: {:error, err}
{:ok, user}
end
+ @spec update_and_set_cache(User.t(), map()) :: {:ok, User.t()} | {:error, any}
def update_and_set_cache(struct, params) do
struct
|> update_changeset(params)
|> update_and_set_cache()
end
+ @spec update_and_set_cache(Changeset.t()) :: {:ok, User.t()} | {:error, any}
def update_and_set_cache(%{data: %Pleroma.User{} = user} = changeset) do
was_superuser_before_update = User.superuser?(user)
end
end
+ @spec get_cached_by_id(String.t()) :: nil | Pleroma.User.t()
def get_cached_by_id(id) do
key = "id:#{id}"
end
end
+ @spec delete_alias(User.t(), User.t()) :: {:error, :no_such_alias}
def delete_alias(user, alias_user) do
current_aliases = user.also_known_as || []
alias_ap_id = alias_user.ap_id
cast(user, params, [:is_confirmed, :confirmation_token])
end
- @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
+ @spec approval_changeset(Changeset.t(), keyword()) :: Changeset.t()
def approval_changeset(user, set_approval: approved?) do
cast(user, %{is_approved: approved?}, [:is_approved])
end
with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
{:ok, relationship}
+ else
+ err -> err
end
end
- @spec add_to_block(User.t(), User.t()) ::
+ @spec remove_from_block(User.t(), User.t()) ::
{:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
defp remove_from_block(%User{} = user, %User{} = blocked) do
with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
{:ok, relationship}
+ else
+ err -> err
end
end
:ok <- statuses(dir, backup.user),
:ok <- likes(dir, backup.user),
:ok <- bookmarks(dir, backup.user),
- {:ok, zip_path} <- :zip.create(String.to_charlist(dir <> ".zip"), @files, cwd: dir),
+ {:ok, zip_path} <-
+ :zip.create(String.to_charlist(dir <> ".zip"), @files, cwd: String.to_charlist(dir)),
{:ok, _} <- File.rm_rf(dir) do
{:ok, to_string(zip_path)}
end
plug_module.skip_plug(conn)
rescue
UndefinedFunctionError ->
- raise "`#{plug_module}` is not skippable. Append `use Pleroma.Web, :plug` to its code."
+ reraise(
+ "`#{plug_module}` is not skippable. Append `use Pleroma.Web, :plug` to its code.",
+ __STACKTRACE__
+ )
end
end
)
defp normalize_image(urls) when is_list(urls), do: urls |> List.first() |> normalize_image()
defp normalize_image(_), do: nil
+ defp normalize_also_known_as(aka) when is_list(aka), do: aka
+ defp normalize_also_known_as(aka) when is_binary(aka), do: [aka]
+ defp normalize_also_known_as(nil), do: []
+
defp object_to_user_data(data, additional) do
fields =
data
also_known_as =
data
|> Map.get("alsoKnownAs", [])
+ |> normalize_also_known_as()
|> Enum.filter(fn url ->
case URI.parse(url) do
%URI{scheme: "http"} -> true
alias Pleroma.Web.Plugs.OAuthScopesPlug
+ require Logger
+
@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
@unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []}
conn
|> json(%{source: source_languages, target: dest_languages})
else
- {:enabled, false} -> json(conn, %{})
- e -> IO.inspect(e)
+ {:enabled, false} ->
+ json(conn, %{})
+
+ e ->
+ Logger.error("Translation language list error: #{inspect(e)}")
+ {:error, e}
end
end
"application/json",
%Schema{
type: :object,
- additionalProperties: emoji_pack(),
+ properties: %{
+ count: %Schema{type: :integer},
+ packs: %Schema{
+ type: :object,
+ additionalProperties: emoji_pack()
+ }
+ },
example: %{
- "emojos" => emoji_pack().example
+ "count" => 4,
+ "packs" => %{
+ "emojos" => emoji_pack().example
+ }
}
}
)
def get_registration(%Plug.Conn{} = _conn), do: {:error, :missing_credentials}
@doc "Creates Pleroma.User record basing on params and Pleroma.Registration record."
+ @spec create_from_registration(Plug.Conn.t(), Registration.t()) ::
+ {:ok, User.t()} | {:error, any()}
def create_from_registration(
%Plug.Conn{params: %{"authorization" => registration_attrs}},
%Registration{} = registration
{:ok, _} <-
Registration.changeset(registration, %{user_id: new_user.id}) |> Repo.update() do
{:ok, new_user}
+ else
+ err -> err
end
end
def assign_account_by_id(conn, _) do
case Pleroma.User.get_cached_by_id(conn.params.id) do
- %Pleroma.User{} = account -> assign(conn, :account, account)
- nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) |> halt()
+ %Pleroma.User{} = account ->
+ assign(conn, :account, account)
+
+ nil ->
+ Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found})
+ |> halt()
end
end
+ @spec try_render(Plug.Conn.t(), any, any) :: Plug.Conn.t()
def try_render(conn, target, params) when is_binary(target) do
- case render(conn, target, params) do
- nil -> render_error(conn, :not_implemented, "Can't display this activity")
- res -> res
- end
+ render(conn, target, params)
end
def try_render(conn, _, _) do
plug(Plug.Parsers,
parsers: [
:urlencoded,
- {:multipart, length: {Config, :get, [[:instance, :upload_limit]]}},
+ Pleroma.Web.Plugs.Parsers.Multipart,
:json
],
pass: ["*/*"],
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.Fallback.LegacyPleromaApiRerouterPlug do
- alias Pleroma.Web.Endpoint
- alias Pleroma.Web.Fallback.RedirectController
-
- def init(opts), do: opts
-
- def call(%{path_info: ["api", "pleroma" | path_info_rest]} = conn, _opts) do
- new_path_info = ["api", "v1", "pleroma" | path_info_rest]
- new_request_path = Enum.join(new_path_info, "/")
-
- conn
- |> Map.merge(%{
- path_info: new_path_info,
- request_path: new_request_path
- })
- |> Endpoint.call(conn.params)
- end
-
- def call(conn, _opts) do
- RedirectController.api_not_implemented(conn, %{})
- end
-end
|> scrub_html_and_truncate_object_field(object)
end
+ def scrub_html_and_truncate(%{data: _}) do
+ ""
+ end
+
def scrub_html_and_truncate(content, max_length \\ 200) when is_binary(content) do
content
|> scrub_html
else
{:error, changeset} ->
message =
- Enum.map(changeset.errors, fn {field, {error, _}} ->
+ Enum.map_join(changeset.errors, "; ", fn {field, {error, _}} ->
"#{field} #{error}"
end)
- |> Enum.join("; ")
message =
String.replace(
--- /dev/null
+defmodule Pleroma.Web.Plugs.Parsers.Multipart do
+ @multipart Plug.Parsers.MULTIPART
+
+ alias Pleroma.Config
+
+ def init(opts) do
+ opts
+ end
+
+ def parse(conn, "multipart", subtype, headers, opts) do
+ length = Config.get([:instance, :upload_limit])
+
+ opts = @multipart.init([length: length] ++ opts)
+
+ @multipart.parse(conn, "multipart", subtype, headers, opts)
+ end
+
+ def parse(conn, _type, _subtype, _headers, _opts) do
+ {:next, conn}
+ end
+end
"""
alias Pleroma.Config
- import Plug.Conn
@behaviour Plug
def call(%{remote_ip: original_remote_ip} = conn, _) do
if Config.get([__MODULE__, :enabled]) do
- %{remote_ip: new_remote_ip} = conn = RemoteIp.call(conn, remote_ip_opts())
- assign(conn, :remote_ip_found, original_remote_ip != new_remote_ip)
+ {headers, proxies} = remote_ip_opts()
+ new_remote_ip = RemoteIp.from(conn.req_headers, headers: headers, proxies: proxies)
+
+ if new_remote_ip != original_remote_ip do
+ Map.put(conn, :remote_ip, new_remote_ip)
+ else
+ conn
+ end
else
conn
end
end
defp remote_ip_opts do
- headers = Config.get([__MODULE__, :headers], []) |> MapSet.new()
+ headers = Config.get([__MODULE__, :headers], [])
reserved = Config.get([__MODULE__, :reserved], [])
proxies =
end
defp maybe_add_cidr(proxy) when is_binary(proxy) do
- proxy =
- cond do
- "/" in String.codepoints(proxy) -> proxy
- InetCidr.v4?(InetCidr.parse_address!(proxy)) -> proxy <> "/32"
- InetCidr.v6?(InetCidr.parse_address!(proxy)) -> proxy <> "/128"
- end
-
- InetCidr.parse(proxy, true)
+ cond do
+ "/" in String.codepoints(proxy) -> proxy
+ InetCidr.v4?(InetCidr.parse_address!(proxy)) -> proxy <> "/32"
+ InetCidr.v6?(InetCidr.parse_address!(proxy)) -> proxy <> "/128"
+ end
end
end
scope "/", Pleroma.Web.Fallback do
get("/registration/:token", RedirectController, :registration_page)
get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
- match(:*, "/api/pleroma*path", LegacyPleromaApiRerouterPlug, [])
- get("/api*path", RedirectController, :api_not_implemented)
get("/*path", RedirectController, :redirector_with_preload)
options("/*path", RedirectController, :empty)
end
end
- def remote_interaction(%{body_params: %{ap_id: ap_id, profile: profile}} = conn, _params) do
+ def remote_interaction(
+ %Plug.Conn{body_params: %{ap_id: ap_id, profile: profile}} = conn,
+ _params
+ ) do
with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile) do
conn
|> json(%{url: String.replace(template, "{uri}", ap_id)})
Pleroma.Config.get([__MODULE__, :domain]) || Pleroma.Web.Endpoint.host()
end
+ @spec webfinger_from_xml(binary()) :: {:ok, map()} | nil
defp webfinger_from_xml(body) do
with {:ok, doc} <- XML.parse_document(body) do
subject = XML.string_from_xpath("//Subject", doc)
else
_e ->
conn
- |> put_status(404)
+ |> put_status(:not_found)
|> json("Couldn't find user")
end
end
version: version("3.5.0"),
elixir: "~> 1.12",
elixirc_paths: elixirc_paths(Mix.env()),
- compilers: [:phoenix, :gettext] ++ Mix.compilers(),
+ compilers: [:phoenix] ++ Mix.compilers(),
elixirc_options: [warnings_as_errors: warnings_as_errors()],
xref: [exclude: [:eldap]],
start_permanent: Mix.env() == :prod,
# Specifies OAuth dependencies.
defp oauth_deps do
oauth_strategy_packages =
- System.get_env("OAUTH_CONSUMER_STRATEGIES")
+ "OAUTH_CONSUMER_STRATEGIES"
+ |> System.get_env()
|> to_string()
|> String.split()
|> Enum.map(fn strategy_entry ->
# Type `mix help deps` for examples and options.
defp deps do
[
- {:phoenix, "~> 1.6.11"},
+ {:phoenix, "~> 1.6.15"},
{:tzdata, "~> 1.1.1"},
- {:plug_cowboy, "~> 2.5"},
+ {:plug_cowboy, "~> 2.6"},
{:phoenix_pubsub, "~> 2.1"},
{:phoenix_ecto, "~> 4.4"},
+ {:inet_cidr, "~> 1.0.0"},
{:ecto_enum, "~> 1.4"},
{:ecto_sql, "~> 3.9.0"},
{:postgrex, ">= 0.16.3"},
{:oban, "~> 2.12.1"},
- {:gettext,
- git: "https://github.com/tusooa/gettext.git",
- ref: "72fb2496b6c5280ed911bdc3756890e7f38a4808",
- override: true},
+ {:gettext, "~> 0.20.0"},
{:bcrypt_elixir, "~> 2.2"},
- {:trailing_format_plug, "~> 0.0.7"},
{:fast_sanitize, "~> 0.2.3"},
- {:html_entities, "~> 0.5", override: true},
- {:phoenix_html, "~> 3.1", override: true},
+ {:html_entities, "~> 0.5"},
+ {:phoenix_html, "~> 3.2"},
{:calendar, "~> 1.0"},
{:cachex, "~> 3.4"},
- {:poison, "~> 5.0", override: true},
- {:tesla, "~> 1.4.4", override: true},
+ {:tesla, "~> 1.4.4"},
{:castore, "~> 0.1"},
- {:cowlib, "~> 2.9", override: true},
+ {:cowlib, "~> 2.9"},
{:finch, "~> 0.14.0"},
{:jason, "~> 1.2"},
+ {:trailing_format_plug, "~> 0.0.7"},
{:mogrify, "~> 0.9.1"},
{:ex_aws, "~> 2.1.6"},
{:ex_aws_s3, "~> 2.0"},
{:plug_static_index_html, "~> 1.0.0"},
{:flake_id, "~> 0.1.0"},
{:concurrent_limiter, "~> 0.1.1"},
- {:remote_ip,
- git: "https://git.pleroma.social/pleroma/remote_ip.git",
- ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"},
+ {:remote_ip, "~> 1.1.0"},
{:captcha,
git: "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git",
ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"},
{:restarter, path: "./restarter"},
{:majic, "~> 1.0"},
{:eblurhash, "~> 1.2.2"},
- {:open_api_spex, "3.10.0"},
+ {:open_api_spex, "~> 3.16.0"},
{:search_parser,
git: "https://github.com/FloatingGhost/pleroma-contrib-search-parser.git",
ref: "08971a81e68686f9ac465cfb6661d51c5e4e1e7f"},
{:nimble_parsec, "~> 1.0", override: true},
- {:phoenix_live_dashboard, "~> 0.6.2"},
+ {:phoenix_live_dashboard, "~> 0.7.2"},
{:ecto_psql_extras, "~> 0.6"},
{:elasticsearch,
git: "https://akkoma.dev/AkkomaGang/elasticsearch-elixir.git", ref: "main"},
{:mfm_parser,
git: "https://akkoma.dev/AkkomaGang/mfm-parser.git",
ref: "912fba81152d4d572e457fd5427f9875b2bc3dbe"},
-
- # indirect dependency version override
- {:plug, "~> 1.10.4", override: true},
+ {:poison, ">= 0.0.0"},
## dev & test
{:ex_doc, "~> 0.22", only: :dev, runtime: false},
{:ex_machina, "~> 2.4", only: :test},
- {:credo, "~> 1.6", only: [:dev, :test], runtime: false},
+ {:credo,
+ git: "https://github.com/rrrene/credo.git",
+ ref: "1c1b99ea41a457761383d81aaf6a606913996fe7",
+ only: [:dev, :test],
+ runtime: false},
{:mock, "~> 0.3.5", only: :test},
{:excoveralls, "0.15.1", only: :test},
{:mox, "~> 1.0", only: :test},
- {:websockex, "~> 0.4.3", only: :test}
+ {:websockex, "~> 0.4.3", only: :test},
+ {:dialyxir, "~> 1.0", only: [:dev], runtime: false}
] ++ oauth_deps()
end
# Pleroma: A lightweight social networking server
# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
-# Akkoma: The cooler pleroma
+# Akkoma: Magically expressive social media
# Copyright © 2022-#{year} Akkoma Authors <https://akkoma.dev/>
# SPDX-License-Identifier: AGPL-3.0-only
"cowboy": {:hex, :cowboy, "2.9.0", "865dd8b6607e14cf03282e10e934023a1bd8be6f6bacf921a7e2a96d800cd452", [:make, :rebar3], [{:cowlib, "2.11.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "2c729f934b4e1aa149aff882f57c6372c15399a20d54f65c8d67bef583021bde"},
"cowboy_telemetry": {:hex, :cowboy_telemetry, "0.3.1", "ebd1a1d7aff97f27c66654e78ece187abdc646992714164380d8a041eda16754", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3a6efd3366130eab84ca372cbd4a7d3c3a97bdfcfb4911233b035d117063f0af"},
"cowlib": {:hex, :cowlib, "2.11.0", "0b9ff9c346629256c42ebe1eeb769a83c6cb771a6ee5960bd110ab0b9b872063", [:make, :rebar3], [], "hexpm", "2b3e9da0b21c4565751a6d4901c20d1b4cc25cbb7fd50d91d2ab6dd287bc86a9"},
- "credo": {:hex, :credo, "1.6.7", "323f5734350fd23a456f2688b9430e7d517afb313fbd38671b8a4449798a7854", [:mix], [{:bunt, "~> 0.2.1", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2.8", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "41e110bfb007f7eda7f897c10bf019ceab9a0b269ce79f015d54b0dcf4fc7dd3"},
+ "credo": {:git, "https://github.com/rrrene/credo.git", "1c1b99ea41a457761383d81aaf6a606913996fe7", [ref: "1c1b99ea41a457761383d81aaf6a606913996fe7"]},
"crypt": {:git, "https://github.com/msantos/crypt.git", "f75cd55325e33cbea198fb41fe41871392f8fb76", [ref: "f75cd55325e33cbea198fb41fe41871392f8fb76"]},
"custom_base": {:hex, :custom_base, "0.2.1", "4a832a42ea0552299d81652aa0b1f775d462175293e99dfbe4d7dbaab785a706", [:mix], [], "hexpm", "8df019facc5ec9603e94f7270f1ac73ddf339f56ade76a721eaa57c1493ba463"},
"db_connection": {:hex, :db_connection, "2.4.3", "3b9aac9f27347ec65b271847e6baeb4443d8474289bd18c1d6f4de655b70c94d", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c127c15b0fa6cfb32eed07465e05da6c815b032508d4ed7c116122871df73c12"},
"decimal": {:hex, :decimal, "2.0.0", "a78296e617b0f5dd4c6caf57c714431347912ffb1d0842e998e9792b5642d697", [:mix], [], "hexpm", "34666e9c55dea81013e77d9d87370fe6cb6291d1ef32f46a1600230b1d44f577"},
"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
- "earmark": {:hex, :earmark, "1.4.33", "2b33a505180583f98bfa17317f03973b52081bdb24a11be05a7f4fa6d64dd8bf", [:mix], [{:earmark_parser, "~> 1.4.29", [hex: :earmark_parser, repo: "hexpm", optional: false]}], "hexpm", "21b31363d6a0a70802cfbaf2de88355778aa76654298a072bce2e01d1858ae06"},
+ "dialyxir": {:hex, :dialyxir, "1.2.0", "58344b3e87c2e7095304c81a9ae65cb68b613e28340690dfe1a5597fd08dec37", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "61072136427a851674cab81762be4dbeae7679f85b1272b6d25c3a839aff8463"},
+ "earmark": {:hex, :earmark, "1.4.34", "d7f89d3bbd7567a0bffc465e0a949f8f8dcbe43909c3acf96f4761a302cea10c", [:mix], [{:earmark_parser, "~> 1.4.29", [hex: :earmark_parser, repo: "hexpm", optional: false]}], "hexpm", "90b106f3dad85b133b10d7d628167c88246123fd1cecb4557d83d21ec9e65504"},
"earmark_parser": {:hex, :earmark_parser, "1.4.29", "149d50dcb3a93d9f3d6f3ecf18c918fb5a2d3c001b5d3305c926cddfbd33355b", [:mix], [], "hexpm", "4902af1b3eb139016aed210888748db8070b8125c2342ce3dcae4f38dcc63503"},
"eblurhash": {:hex, :eblurhash, "1.2.2", "7da4255aaea984b31bb71155f673257353b0e0554d0d30dcf859547e74602582", [:rebar3], [], "hexpm", "8c20ca00904de023a835a9dcb7b7762fed32264c85a80c3cafa85288e405044c"},
"ecto": {:hex, :ecto, "3.9.2", "017db3bc786ff64271108522c01a5d3f6ba0aea5c84912cfb0dd73bf13684108", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "21466d5177e09e55289ac7eade579a642578242c7a3a9f91ad5c6583337a9d15"},
"ecto_sql": {:hex, :ecto_sql, "3.9.1", "9bd5894eecc53d5b39d0c95180d4466aff00e10679e13a5cfa725f6f85c03c22", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.9.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "5fd470a4fff2e829bbf9dcceb7f3f9f6d1e49b4241e802f614de6b8b67c51118"},
"elasticsearch": {:git, "https://akkoma.dev/AkkomaGang/elasticsearch-elixir.git", "6cd946f75f6ab9042521a009d1d32d29a90113ca", [ref: "main"]},
"elixir_make": {:hex, :elixir_make, "0.6.3", "bc07d53221216838d79e03a8019d0839786703129599e9619f4ab74c8c096eac", [:mix], [], "hexpm", "f5cbd651c5678bcaabdbb7857658ee106b12509cd976c2c2fca99688e1daf716"},
+ "erlex": {:hex, :erlex, "0.2.6", "c7987d15e899c7a2f34f5420d2a2ea0d659682c06ac607572df55a43753aa12e", [:mix], [], "hexpm", "2ed2e25711feb44d52b17d2780eabf998452f6efda104877a3881c2f8c0c0c75"},
"eternal": {:hex, :eternal, "1.2.2", "d1641c86368de99375b98d183042dd6c2b234262b8d08dfd72b9eeaafc2a1abd", [:mix], [], "hexpm", "2c9fe32b9c3726703ba5e1d43a1d255a4f3f2d8f8f9bc19f094c7cb1a7a9e782"},
"ex_aws": {:hex, :ex_aws, "2.1.9", "dc4865ecc20a05190a34a0ac5213e3e5e2b0a75a0c2835e923ae7bfeac5e3c31", [:mix], [{:configparser_ex, "~> 4.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:jsx, "~> 3.0", [hex: :jsx, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "3e6c776703c9076001fbe1f7c049535f042cb2afa0d2cbd3b47cbc4e92ac0d10"},
"ex_aws_s3": {:hex, :ex_aws_s3, "2.3.3", "61412e524616ea31d3f31675d8bc4c73f277e367dee0ae8245610446f9b778aa", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "0044f0b6f9ce925666021eafd630de64c2b3404d79c85245cc7c8a9a32d7f104"},
"flake_id": {:hex, :flake_id, "0.1.0", "7716b086d2e405d09b647121a166498a0d93d1a623bead243e1f74216079ccb3", [:mix], [{:base62, "~> 1.2", [hex: :base62, repo: "hexpm", optional: false]}, {:ecto, ">= 2.0.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm", "31fc8090fde1acd267c07c36ea7365b8604055f897d3a53dd967658c691bd827"},
"floki": {:hex, :floki, "0.34.0", "002d0cc194b48794d74711731db004fafeb328fe676976f160685262d43706a8", [:mix], [], "hexpm", "9c3a9f43f40dde00332a589bd9d389b90c1f518aef500364d00636acc5ebc99c"},
"gen_smtp": {:hex, :gen_smtp, "0.15.0", "9f51960c17769b26833b50df0b96123605a8024738b62db747fece14eb2fbfcc", [:rebar3], [], "hexpm", "29bd14a88030980849c7ed2447b8db6d6c9278a28b11a44cafe41b791205440f"},
- "gettext": {:git, "https://github.com/tusooa/gettext.git", "72fb2496b6c5280ed911bdc3756890e7f38a4808", [ref: "72fb2496b6c5280ed911bdc3756890e7f38a4808"]},
+ "gettext": {:hex, :gettext, "0.20.0", "75ad71de05f2ef56991dbae224d35c68b098dd0e26918def5bb45591d5c8d429", [:mix], [], "hexpm", "1c03b177435e93a47441d7f681a7040bd2a816ece9e2666d1c9001035121eb3d"},
"hackney": {:hex, :hackney, "1.18.1", "f48bf88f521f2a229fc7bae88cf4f85adc9cd9bcf23b5dc8eb6a1788c662c4f6", [:rebar3], [{:certifi, "~> 2.9.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~> 6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~> 1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~> 1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.3.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~> 1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~> 0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "a4ecdaff44297e9b5894ae499e9a070ea1888c84afdd1fd9b7b2bc384950128e"},
"hpax": {:hex, :hpax, "0.1.2", "09a75600d9d8bbd064cdd741f21fc06fc1f4cf3d0fcc335e5aa19be1a7235c84", [:mix], [], "hexpm", "2c87843d5a23f5f16748ebe77969880e29809580efdaccd615cd3bed628a8c13"},
"html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
"nimble_parsec": {:hex, :nimble_parsec, "1.2.3", "244836e6e3f1200c7f30cb56733fd808744eca61fd182f731eac4af635cc6d0b", [:mix], [], "hexpm", "c8d789e39b9131acf7b99291e93dae60ab48ef14a7ee9d58c6964f59efb570b0"},
"nimble_pool": {:hex, :nimble_pool, "0.2.6", "91f2f4c357da4c4a0a548286c84a3a28004f68f05609b4534526871a22053cde", [:mix], [], "hexpm", "1c715055095d3f2705c4e236c18b618420a35490da94149ff8b580a2144f653f"},
"oban": {:hex, :oban, "2.12.1", "f604d7e6a8be9fda4a9b0f6cebbd633deba569f85dbff70c4d25d99a6f023177", [:mix], [{:ecto_sql, "~> 3.6", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9b1844c2b74e0d788b73e5144b0c9d5674cb775eae29d88a36f3c3b48d42d058"},
- "open_api_spex": {:hex, :open_api_spex, "3.10.0", "94e9521ad525b3fcf6dc77da7c45f87fdac24756d4de588cb0816b413e7c1844", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.1", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm", "2dbb2bde3d2b821f06936e8dfaf3284331186556291946d84eeba3750ac28765"},
+ "open_api_spex": {:hex, :open_api_spex, "3.16.0", "9843af4e87550cd8ac5821b10e4c74f1d51f0d4e3310f824d780614743423b25", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "bb0be24a648b73e8fc8cbda17f514b8486262275e8b33e8b5ae66283df972129"},
"parse_trans": {:hex, :parse_trans, "3.3.1", "16328ab840cc09919bd10dab29e431da3af9e9e7e7e6f0089dd5a2d2820011d8", [:rebar3], [], "hexpm", "07cd9577885f56362d414e8c4c4e6bdf10d43a8767abb92d24cbe8b24c54888b"},
"phoenix": {:hex, :phoenix, "1.6.15", "0a1d96bbc10747fd83525370d691953cdb6f3ccbac61aa01b4acb012474b047d", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 1.0 or ~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:plug, "~> 1.10", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.2", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "d70ab9fbf6b394755ea88b644d34d79d8b146e490973151f248cacd122d20672"},
"phoenix_ecto": {:hex, :phoenix_ecto, "4.4.0", "0672ed4e4808b3fbed494dded89958e22fb882de47a97634c0b13e7b0b5f7720", [:mix], [{:ecto, "~> 3.3", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "09864e558ed31ee00bd48fcc1d4fc58ae9678c9e81649075431e69dbabb43cc1"},
"phoenix_html": {:hex, :phoenix_html, "3.2.0", "1c1219d4b6cb22ac72f12f73dc5fad6c7563104d083f711c3fcd8551a1f4ae11", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "36ec97ba56d25c0136ef1992c37957e4246b649d620958a1f9fa86165f8bc54f"},
- "phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.6.5", "1495bb014be12c9a9252eca04b9af54246f6b5c1e4cd1f30210cd00ec540cf8e", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.3", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.17.7", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "ef4fa50dd78364409039c99cf6f98ab5209b4c5f8796c17f4db118324f0db852"},
- "phoenix_live_view": {:hex, :phoenix_live_view, "0.17.12", "74f4c0ad02d7deac2d04f50b52827a5efdc5c6e7fac5cede145f5f0e4183aedc", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.0 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.1", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "af6dd5e0aac16ff43571f527a8e0616d62cb80b10eb87aac82170243e50d99c8"},
+ "phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.7.2", "97cc4ff2dba1ebe504db72cb45098cb8e91f11160528b980bd282cc45c73b29c", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.18.3", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "0e5fdf063c7a3b620c566a30fcf68b7ee02e5e46fe48ee46a6ec3ba382dc05b7"},
+ "phoenix_live_view": {:hex, :phoenix_live_view, "0.18.3", "2e3d009422addf8b15c3dccc65ce53baccbe26f7cfd21d264680b5867789a9c1", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.1", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c8845177a866e017dcb7083365393c8f00ab061b8b6b2bda575891079dce81b2"},
"phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.1", "ba04e489ef03763bf28a17eb2eaddc2c20c6d217e2150a61e3298b0f4c2012b5", [:mix], [], "hexpm", "81367c6d1eea5878ad726be80808eb5a787a23dee699f96e72b1109c57cdd8d9"},
"phoenix_swoosh": {:hex, :phoenix_swoosh, "0.3.4", "615f8f393135de7e0cbb4bd00ba238b1e0cd324b0d90efbaee613c2f02ca5e5c", [:mix], [{:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:swoosh, "~> 1.0", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm", "3971221846232021ab5e3c7489fd62ec5bfd6a2e01cae10a317ccf6fb350571c"},
"phoenix_template": {:hex, :phoenix_template, "1.0.0", "c57bc5044f25f007dc86ab21895688c098a9f846a8dda6bc40e2d0ddc146e38f", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "1b066f99a26fd22064c12b2600a9a6e56700f591bf7b20b418054ea38b4d4357"},
"phoenix_view": {:hex, :phoenix_view, "2.0.2", "6bd4d2fd595ef80d33b439ede6a19326b78f0f1d8d62b9a318e3d9c1af351098", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "a929e7230ea5c7ee0e149ffcf44ce7cf7f4b6d2bfe1752dd7c084cdff152d36f"},
- "plug": {:hex, :plug, "1.10.4", "41eba7d1a2d671faaf531fa867645bd5a3dce0957d8e2a3f398ccff7d2ef017f", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ad1e233fe73d2eec56616568d260777b67f53148a999dc2d048f4eb9778fe4a0"},
+ "plug": {:hex, :plug, "1.14.0", "ba4f558468f69cbd9f6b356d25443d0b796fbdc887e03fa89001384a9cac638f", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "bf020432c7d4feb7b3af16a0c2701455cbbbb95e5b6866132cb09eb0c29adc14"},
"plug_cowboy": {:hex, :plug_cowboy, "2.6.0", "d1cf12ff96a1ca4f52207c5271a6c351a4733f413803488d75b70ccf44aebec2", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "073cf20b753ce6682ed72905cd62a2d4bd9bad1bf9f7feb02a1b8e525bd94fa6"},
"plug_crypto": {:hex, :plug_crypto, "1.2.3", "8f77d13aeb32bfd9e654cb68f0af517b371fb34c56c9f2b58fe3df1235c1251a", [:mix], [], "hexpm", "b5672099c6ad5c202c45f5a403f21a3411247f164e4a8fab056e5cd8a290f4a2"},
"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "79fd4fcf34d110605c26560cbae8f23c603ec4158c08298bd4360fdea90bb5cf"},
"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm", "dad79704ce5440f3d5a3681c8590b9dc25d1a561e8f5a9c995281012860901e3"},
"postgrex": {:hex, :postgrex, "0.16.5", "fcc4035cc90e23933c5d69a9cd686e329469446ef7abba2cf70f08e2c4b69810", [:mix], [{:connection, "~> 1.1", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "edead639dc6e882618c01d8fc891214c481ab9a3788dfe38dd5e37fd1d5fb2e8"},
"pot": {:hex, :pot, "1.0.2", "13abb849139fdc04ab8154986abbcb63bdee5de6ed2ba7e1713527e33df923dd", [:rebar3], [], "hexpm", "78fe127f5a4f5f919d6ea5a2a671827bd53eb9d37e5b4128c0ad3df99856c2e0"},
- "quack": {:hex, :quack, "0.1.1", "cca7b4da1a233757fdb44b3334fce80c94785b3ad5a602053b7a002b5a8967bf", [:mix], [{:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: false]}, {:tesla, "~> 1.2.0", [hex: :tesla, repo: "hexpm", optional: false]}], "hexpm", "d736bfa7444112eb840027bb887832a0e403a4a3437f48028c3b29a2dbbd2543"},
"ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
"recon": {:hex, :recon, "2.5.2", "cba53fa8db83ad968c9a652e09c3ed7ddcc4da434f27c3eaa9ca47ffb2b1ff03", [:mix, :rebar3], [], "hexpm", "2c7523c8dee91dff41f6b3d63cba2bd49eb6d2fe5bf1eec0df7f87eb5e230e1c"},
- "remote_ip": {:git, "https://git.pleroma.social/pleroma/remote_ip.git", "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8", [ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"]},
+ "remote_ip": {:hex, :remote_ip, "1.1.0", "cb308841595d15df3f9073b7c39243a1dd6ca56e5020295cb012c76fbec50f2d", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "616ffdf66aaad6a72fc546dabf42eed87e2a99e97b09cbd92b10cc180d02ed74"},
"search_parser": {:git, "https://github.com/FloatingGhost/pleroma-contrib-search-parser.git", "08971a81e68686f9ac465cfb6661d51c5e4e1e7f", [ref: "08971a81e68686f9ac465cfb6661d51c5e4e1e7f"]},
"sleeplocks": {:hex, :sleeplocks, "1.1.2", "d45aa1c5513da48c888715e3381211c859af34bee9b8290490e10c90bb6ff0ca", [:rebar3], [], "hexpm", "9fe5d048c5b781d6305c1a3a0f40bb3dfc06f49bf40571f3d2d0c57eaa7f59a5"},
"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.6", "cf344f5692c82d2cd7554f5ec8fd961548d4fd09e7d22f5b62482e5aeaebd4b0", [:make, :mix, :rebar3], [], "hexpm", "bdb0d2471f453c88ff3908e7686f86f9be327d065cc1ec16fa4540197ea04680"},
"statistex": {:hex, :statistex, "1.0.0", "f3dc93f3c0c6c92e5f291704cf62b99b553253d7969e9a5fa713e5481cd858a5", [:mix], [], "hexpm", "ff9d8bee7035028ab4742ff52fc80a2aa35cece833cf5319009b52f1b5a86c27"},
"sweet_xml": {:hex, :sweet_xml, "0.7.3", "debb256781c75ff6a8c5cbf7981146312b66f044a2898f453709a53e5031b45b", [:mix], [], "hexpm", "e110c867a1b3fe74bfc7dd9893aa851f0eed5518d0d7cad76d7baafd30e4f5ba"},
- "swoosh": {:hex, :swoosh, "1.8.2", "af9a22ab2c0d20b266f61acca737fa11a121902de9466a39e91bacdce012101c", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "d058ba750eafadb6c09a84a352c14c5d1eeeda6e84945fcc95785b7f3067b7db"},
+ "swoosh": {:hex, :swoosh, "1.8.3", "733357d9a65da19c162171f08d1e42a6259236cf44d02a64711b776afbbbaa78", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c699abbac7a296c205055a7501c5d5261320ea1f08bde2392699a9e899815bc7"},
"syslog": {:hex, :syslog, "1.1.0", "6419a232bea84f07b56dc575225007ffe34d9fdc91abe6f1b2f254fd71d8efc2", [:rebar3], [], "hexpm", "4c6a41373c7e20587be33ef841d3de6f3beba08519809329ecc4d27b15b659e1"},
"table_rex": {:hex, :table_rex, "3.1.1", "0c67164d1714b5e806d5067c1e96ff098ba7ae79413cc075973e17c38a587caa", [:mix], [], "hexpm", "678a23aba4d670419c23c17790f9dcd635a4a89022040df7d5d772cb21012490"},
"telemetry": {:hex, :telemetry, "0.4.3", "a06428a514bdbc63293cd9a6263aad00ddeb66f608163bdec7c8995784080818", [:rebar3], [], "hexpm", "eb72b8365ffda5bed68a620d1da88525e326cb82a75ee61354fc24b844768041"},
line_no: 1
)
end
+
+ defp append_issues_and_timings(_issues, exec) do
+ exec
+ end
end
test "it calls webfinger for 'acct:' accounts" do
with_mock(Pleroma.Web.WebFinger,
- finger: fn _ -> %{"ap_id" => "https://gensokyo.2hu/users/raymoo"} end
+ finger: fn _ -> {:ok, %{"ap_id" => "https://gensokyo.2hu/users/raymoo"}} end
) do
assert Signature.key_id_to_actor_id("acct:raymoo@gensokyo.2hu") ==
{:ok, "https://gensokyo.2hu/users/raymoo"}
user = insert(:user)
- conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")
+ conn =
+ get(build_conn(), "/api/v1/pleroma/admin/users/#{user.nickname}?admin_token=password123")
assert json_response(conn, 200)
end
- test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
+ test "GET /api/v1/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
%{admin: admin} do
user = insert(:user)
- url = "/api/pleroma/admin/users/#{user.nickname}"
+ url = "/api/v1/pleroma/admin/users/#{user.nickname}"
good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
end
end
- describe "PUT /api/pleroma/admin/users/tag" do
+ describe "PUT /api/v1/pleroma/admin/users/tag" do
setup %{conn: conn} do
user1 = insert(:user, %{tags: ["x"]})
user2 = insert(:user, %{tags: ["y"]})
conn
|> put_req_header("accept", "application/json")
|> put(
- "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
+ "/api/v1/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
"#{user2.nickname}&tags[]=foo&tags[]=bar"
)
end
end
- describe "DELETE /api/pleroma/admin/users/tag" do
+ describe "DELETE /api/v1/pleroma/admin/users/tag" do
setup %{conn: conn} do
user1 = insert(:user, %{tags: ["x"]})
user2 = insert(:user, %{tags: ["y", "z"]})
conn
|> put_req_header("accept", "application/json")
|> delete(
- "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
+ "/api/v1/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
"#{user2.nickname}&tags[]=x&tags[]=z"
)
end
end
- describe "/api/pleroma/admin/users/:nickname/permission_group" do
+ describe "/api/v1/pleroma/admin/users/:nickname/permission_group" do
test "GET is giving user_info", %{admin: admin, conn: conn} do
conn =
conn
|> put_req_header("accept", "application/json")
- |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
+ |> get("/api/v1/pleroma/admin/users/#{admin.nickname}/permission_group/")
assert json_response(conn, 200) == %{
"is_admin" => true,
conn =
conn
|> put_req_header("accept", "application/json")
- |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
+ |> post("/api/v1/pleroma/admin/users/#{user.nickname}/permission_group/admin")
assert json_response(conn, 200) == %{
"is_admin" => true
conn =
conn
|> put_req_header("accept", "application/json")
- |> post("/api/pleroma/admin/users/permission_group/admin", %{
+ |> post("/api/v1/pleroma/admin/users/permission_group/admin", %{
nicknames: [user_one.nickname, user_two.nickname]
})
conn =
conn
|> put_req_header("accept", "application/json")
- |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
+ |> delete("/api/v1/pleroma/admin/users/#{user.nickname}/permission_group/admin")
assert json_response(conn, 200) == %{"is_admin" => false}
conn =
conn
|> put_req_header("accept", "application/json")
- |> delete("/api/pleroma/admin/users/permission_group/admin", %{
+ |> delete("/api/v1/pleroma/admin/users/permission_group/admin", %{
nicknames: [user_one.nickname, user_two.nickname]
})
end
end
- test "/api/pleroma/admin/users/:nickname/password_reset", %{conn: conn} do
+ test "/api/v1/pleroma/admin/users/:nickname/password_reset", %{conn: conn} do
user = insert(:user)
conn =
conn
|> put_req_header("accept", "application/json")
- |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
+ |> get("/api/v1/pleroma/admin/users/#{user.nickname}/password_reset")
resp = json_response(conn, 200)
response =
conn
- |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: user.nickname})
+ |> put("/api/v1/pleroma/admin/users/disable_mfa", %{nickname: user.nickname})
|> json_response(200)
assert response == user.nickname
test "returns 404 if user not found", %{conn: conn} do
response =
conn
- |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})
+ |> put("/api/v1/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})
|> json_response(404)
assert response == %{"error" => "Not found"}
end
end
- describe "GET /api/pleroma/admin/restart" do
+ describe "GET /api/v1/pleroma/admin/restart" do
setup do: clear_config(:configurable_from_database, true)
test "pleroma restarts", %{conn: conn} do
capture_log(fn ->
- assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) == %{}
+ assert conn |> get("/api/v1/pleroma/admin/restart") |> json_response(200) == %{}
end) =~ "pleroma restarted"
refute Restarter.Pleroma.need_reboot?()
test "need_reboot flag", %{conn: conn} do
assert conn
- |> get("/api/pleroma/admin/need_reboot")
+ |> get("/api/v1/pleroma/admin/need_reboot")
|> json_response(200) == %{"need_reboot" => false}
Restarter.Pleroma.need_reboot()
assert conn
- |> get("/api/pleroma/admin/need_reboot")
+ |> get("/api/v1/pleroma/admin/need_reboot")
|> json_response(200) == %{"need_reboot" => true}
on_exit(fn -> Restarter.Pleroma.refresh() end)
end
- describe "GET /api/pleroma/admin/users/:nickname/statuses" do
+ describe "GET /api/v1/pleroma/admin/users/:nickname/statuses" do
setup do
user = insert(:user)
end
test "renders user's statuses", %{conn: conn, user: user} do
- conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
+ conn = get(conn, "/api/v1/pleroma/admin/users/#{user.nickname}/statuses")
assert %{"total" => 3, "activities" => activities} = json_response(conn, 200)
assert length(activities) == 3
test "renders user's statuses with pagination", %{conn: conn, user: user} do
%{"total" => 3, "activities" => [activity1]} =
conn
- |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=1")
+ |> get("/api/v1/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=1")
|> json_response(200)
%{"total" => 3, "activities" => [activity2]} =
conn
- |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=2")
+ |> get("/api/v1/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=2")
|> json_response(200)
refute activity1 == activity2
%{"total" => 4, "activities" => activities} =
conn
- |> get("/api/pleroma/admin/users/#{user.nickname}/statuses")
+ |> get("/api/v1/pleroma/admin/users/#{user.nickname}/statuses")
|> json_response(200)
assert length(activities) == 4
%{"total" => 5, "activities" => activities} =
conn
- |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
+ |> get("/api/v1/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
|> json_response(200)
assert length(activities) == 5
assert %{"total" => 0, "activities" => []} ==
conn
- |> get("/api/pleroma/admin/users/#{other_user.nickname}/statuses")
+ |> get("/api/v1/pleroma/admin/users/#{other_user.nickname}/statuses")
|> json_response(200)
assert %{"total" => 1, "activities" => [_]} =
conn
|> get(
- "/api/pleroma/admin/users/#{other_user.nickname}/statuses?with_reblogs=true"
+ "/api/v1/pleroma/admin/users/#{other_user.nickname}/statuses?with_reblogs=true"
)
|> json_response(200)
end
end
- describe "GET /api/pleroma/admin/moderation_log" do
+ describe "GET /api/v1/pleroma/admin/moderation_log" do
setup do
moderator = insert(:user, is_moderator: true)
inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
})
- conn = get(conn, "/api/pleroma/admin/moderation_log")
+ conn = get(conn, "/api/v1/pleroma/admin/moderation_log")
response = json_response(conn, 200)
[first_entry, second_entry] = response["items"]
inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
})
- conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
+ conn1 = get(conn, "/api/v1/pleroma/admin/moderation_log?page_size=1&page=1")
response1 = json_response(conn1, 200)
[first_entry] = response1["items"]
assert first_entry["message"] ==
"@#{admin.nickname} unfollowed relay: https://example.org/relay"
- conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
+ conn2 = get(conn, "/api/v1/pleroma/admin/moderation_log?page_size=1&page=2")
response2 = json_response(conn2, 200)
[second_entry] = response2["items"]
conn1 =
get(
conn,
- "/api/pleroma/admin/moderation_log?start_date=#{second_date}"
+ "/api/v1/pleroma/admin/moderation_log?start_date=#{second_date}"
)
response1 = json_response(conn1, 200)
}
})
- conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")
+ conn1 = get(conn, "/api/v1/pleroma/admin/moderation_log?user_id=#{moderator.id}")
response1 = json_response(conn1, 200)
[first_entry] = response1["items"]
target: "https://example.org/relay"
})
- conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")
+ conn1 = get(conn, "/api/v1/pleroma/admin/moderation_log?search=unfo")
response1 = json_response(conn1, 200)
[first_entry] = response1["items"]
%{conn: conn} do
clear_config(Pleroma.Config.get([:instance, :limit_to_local_content]), :unauthenticated)
user = insert(:user, %{local: false, nickname: "u@peer1.com"})
- conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
+ conn = get(conn, "/api/v1/pleroma/admin/users/#{user.nickname}/credentials")
assert json_response(conn, 200)
end
describe "GET /users/:nickname/credentials" do
test "gets the user credentials", %{conn: conn} do
user = insert(:user)
- conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
+ conn = get(conn, "/api/v1/pleroma/admin/users/#{user.nickname}/credentials")
response = assert json_response(conn, 200)
assert response["email"] == user.email
conn =
build_conn()
|> assign(:user, user)
- |> get("/api/pleroma/admin/users/#{user.nickname}/credentials")
+ |> get("/api/v1/pleroma/admin/users/#{user.nickname}/credentials")
assert json_response(conn, :forbidden)
end
assert user.password_reset_pending == false
conn =
- patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
+ patch(conn, "/api/v1/pleroma/admin/users/#{user.nickname}/credentials", %{
"password" => "new_password",
"email" => "new_email@example.com",
"name" => "new_name"
conn =
build_conn()
|> assign(:user, user)
- |> patch("/api/pleroma/admin/users/#{user.nickname}/credentials", %{
+ |> patch("/api/v1/pleroma/admin/users/#{user.nickname}/credentials", %{
"password" => "new_password",
"email" => "new_email@example.com",
"name" => "new_name"
test "changes actor type from permitted list", %{conn: conn, user: user} do
assert user.actor_type == "Person"
- assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
+ assert patch(conn, "/api/v1/pleroma/admin/users/#{user.nickname}/credentials", %{
"actor_type" => "Service"
})
|> json_response(200) == %{"status" => "success"}
assert updated_user.actor_type == "Service"
- assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
+ assert patch(conn, "/api/v1/pleroma/admin/users/#{user.nickname}/credentials", %{
"actor_type" => "Application"
})
|> json_response(400) == %{"errors" => %{"actor_type" => "is invalid"}}
end
test "update non existing user", %{conn: conn} do
- assert patch(conn, "/api/pleroma/admin/users/non-existing/credentials", %{
+ assert patch(conn, "/api/v1/pleroma/admin/users/non-existing/credentials", %{
"password" => "new_password"
})
|> json_response(404) == %{"error" => "Not found"}
assert user.password_reset_pending == false
conn =
- patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})
+ patch(conn, "/api/v1/pleroma/admin/users/force_password_reset", %{
+ nicknames: [user.nickname]
+ })
assert empty_json_response(conn) == ""
refute second_user.is_confirmed
ret_conn =
- patch(conn, "/api/pleroma/admin/users/confirm_email", %{
+ patch(conn, "/api/v1/pleroma/admin/users/confirm_email", %{
nicknames: [
first_user.nickname,
second_user.nickname
[first_user, second_user] = insert_pair(:user, is_confirmed: false)
ret_conn =
- patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
+ patch(conn, "/api/v1/pleroma/admin/users/resend_confirmation_email", %{
nicknames: [
first_user.nickname,
second_user.nickname
end
end
- describe "/api/pleroma/admin/stats" do
+ describe "/api/v1/pleroma/admin/stats" do
test "status visibility count", %{conn: conn} do
user = insert(:user)
CommonAPI.post(user, %{visibility: "public", status: "hey"})
response =
conn
- |> get("/api/pleroma/admin/stats")
+ |> get("/api/v1/pleroma/admin/stats")
|> json_response(200)
assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 2} =
response =
conn
- |> get("/api/pleroma/admin/stats", instance: instance2)
+ |> get("/api/v1/pleroma/admin/stats", instance: instance2)
|> json_response(200)
assert %{"direct" => 0, "private" => 1, "public" => 0, "unlisted" => 1} =
end
end
- describe "/api/pleroma/backups" do
+ describe "/api/v1/pleroma/backups" do
test "it creates a backup", %{conn: conn} do
admin = %{id: admin_id, nickname: admin_nickname} = insert(:user, is_admin: true)
token = insert(:oauth_admin_token, user: admin)
conn
|> assign(:user, admin)
|> assign(:token, token)
- |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
+ |> post("/api/v1/pleroma/admin/backups", %{nickname: user.nickname})
|> json_response(200)
assert [backup] = Repo.all(Pleroma.User.Backup)
conn
|> assign(:user, admin)
|> assign(:token, token)
- |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
+ |> post("/api/v1/pleroma/admin/backups", %{nickname: user.nickname})
|> json_response(200)
assert [_backup] = Repo.all(Pleroma.User.Backup)
conn
|> assign(:user, admin)
|> assign(:token, token)
- |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
+ |> post("/api/v1/pleroma/admin/backups", %{nickname: user.nickname})
|> json_response(200)
assert Repo.aggregate(Pleroma.User.Backup, :count) == 2
{:ok, %{admin: admin, token: token, conn: conn}}
end
- describe "GET /api/pleroma/admin/frontends" do
+ describe "GET /api/v1/pleroma/admin/frontends" do
test "it lists available frontends", %{conn: conn} do
response =
conn
- |> get("/api/pleroma/admin/frontends")
+ |> get("/api/v1/pleroma/admin/frontends")
|> json_response_and_validate_schema(:ok)
assert Enum.map(response, & &1["name"]) ==
response =
conn
- |> get("/api/pleroma/admin/frontends")
+ |> get("/api/v1/pleroma/admin/frontends")
|> json_response_and_validate_schema(:ok)
assert Enum.map(response, & &1["name"]) ==
end
end
- describe "POST /api/pleroma/admin/frontends/install" do
+ describe "POST /api/v1/pleroma/admin/frontends/install" do
test "from available frontends", %{conn: conn} do
clear_config([:frontends, :available], %{
"pleroma" => %{
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/frontends/install", %{name: "pleroma"})
+ |> post("/api/v1/pleroma/admin/frontends/install", %{name: "pleroma"})
|> json_response_and_validate_schema(:ok)
assert File.exists?(Path.join([@dir, "frontends", "pleroma", "fantasy", "test.txt"]))
response =
conn
- |> get("/api/pleroma/admin/frontends")
+ |> get("/api/v1/pleroma/admin/frontends")
|> json_response_and_validate_schema(:ok)
assert response == [
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/frontends/install", %{
+ |> post("/api/v1/pleroma/admin/frontends/install", %{
name: "pleroma",
file: "test/fixtures/tesla_mock/frontend.zip"
})
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/frontends/install", %{
+ |> post("/api/v1/pleroma/admin/frontends/install", %{
name: "unknown",
ref: "baka",
build_url: "http://gensokyo.2hu/madeup.zip",
result =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/frontends/install", %{
+ |> post("/api/v1/pleroma/admin/frontends/install", %{
name: "unknown",
ref: "baka",
build_url: "http://gensokyo.2hu/madeup.zip",
activity = insert(:note_activity, user: user2)
%{"total" => 2, "activities" => activities} =
- conn |> get("/api/pleroma/admin/instances/archae.me/statuses") |> json_response(200)
+ conn |> get("/api/v1/pleroma/admin/instances/archae.me/statuses") |> json_response(200)
assert length(activities) == 2
%{"total" => 1, "activities" => [_]} =
- conn |> get("/api/pleroma/admin/instances/test.com/statuses") |> json_response(200)
+ conn |> get("/api/v1/pleroma/admin/instances/test.com/statuses") |> json_response(200)
%{"total" => 0, "activities" => []} =
- conn |> get("/api/pleroma/admin/instances/nonexistent.com/statuses") |> json_response(200)
+ conn
+ |> get("/api/v1/pleroma/admin/instances/nonexistent.com/statuses")
+ |> json_response(200)
CommonAPI.repeat(activity.id, user)
%{"total" => 2, "activities" => activities} =
- conn |> get("/api/pleroma/admin/instances/archae.me/statuses") |> json_response(200)
+ conn |> get("/api/v1/pleroma/admin/instances/archae.me/statuses") |> json_response(200)
assert length(activities) == 2
%{"total" => 3, "activities" => activities} =
conn
- |> get("/api/pleroma/admin/instances/archae.me/statuses?with_reblogs=true")
+ |> get("/api/v1/pleroma/admin/instances/archae.me/statuses?with_reblogs=true")
|> json_response(200)
assert length(activities) == 3
response =
conn
- |> delete("/api/pleroma/admin/instances/lain.com")
+ |> delete("/api/v1/pleroma/admin/instances/lain.com")
|> json_response(200)
[:ok] = ObanHelpers.perform_all()
{:ok, %{admin: admin, token: token, conn: conn}}
end
- describe "GET /api/pleroma/admin/instance_document/:name" do
+ describe "GET /api/v1/pleroma/admin/instance_document/:name" do
test "return the instance document url", %{conn: conn} do
- conn = get(conn, "/api/pleroma/admin/instance_document/instance-panel")
+ conn = get(conn, "/api/v1/pleroma/admin/instance_document/instance-panel")
assert content = html_response(conn, 200)
assert String.contains?(content, @default_instance_panel)
build_conn()
|> assign(:user, non_admin_user)
|> assign(:token, token)
- |> get("/api/pleroma/admin/instance_document/instance-panel")
+ |> get("/api/v1/pleroma/admin/instance_document/instance-panel")
assert json_response(conn, :forbidden)
end
test "it returns 404 if the instance document with the given name doesn't exist", %{
conn: conn
} do
- conn = get(conn, "/api/pleroma/admin/instance_document/1234")
+ conn = get(conn, "/api/v1/pleroma/admin/instance_document/1234")
assert json_response_and_validate_schema(conn, 404)
end
end
- describe "PATCH /api/pleroma/admin/instance_document/:name" do
+ describe "PATCH /api/v1/pleroma/admin/instance_document/:name" do
test "uploads the instance document", %{conn: conn} do
image = %Plug.Upload{
content_type: "text/html",
conn =
conn
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/admin/instance_document/instance-panel", %{
+ |> patch("/api/v1/pleroma/admin/instance_document/instance-panel", %{
"file" => image
})
end
end
- describe "DELETE /api/pleroma/admin/instance_document/:name" do
+ describe "DELETE /api/v1/pleroma/admin/instance_document/:name" do
test "deletes the instance document", %{conn: conn} do
File.mkdir!(@dir <> "/instance/")
File.write!(@dir <> "/instance/panel.html", "Custom instance panel")
conn_resp =
conn
- |> get("/api/pleroma/admin/instance_document/instance-panel")
+ |> get("/api/v1/pleroma/admin/instance_document/instance-panel")
assert html_response(conn_resp, 200) == "Custom instance panel"
conn
- |> delete("/api/pleroma/admin/instance_document/instance-panel")
+ |> delete("/api/v1/pleroma/admin/instance_document/instance-panel")
|> json_response_and_validate_schema(200)
conn_resp =
conn
- |> get("/api/pleroma/admin/instance_document/instance-panel")
+ |> get("/api/v1/pleroma/admin/instance_document/instance-panel")
assert content = html_response(conn_resp, 200)
assert String.contains?(content, @default_instance_panel)
{:ok, %{admin: admin, token: token, conn: conn}}
end
- describe "POST /api/pleroma/admin/users/email_invite, with valid config" do
+ describe "POST /api/v1/pleroma/admin/users/email_invite, with valid config" do
setup do: clear_config([:instance, :registrations_open], false)
setup do: clear_config([:instance, :invites_enabled], true)
conn =
conn
|> put_req_header("content-type", "application/json;charset=utf-8")
- |> post("/api/pleroma/admin/users/email_invite", %{
+ |> post("/api/v1/pleroma/admin/users/email_invite", %{
email: recipient_email,
name: recipient_name
})
|> assign(:user, non_admin_user)
|> assign(:token, token)
|> put_req_header("content-type", "application/json;charset=utf-8")
- |> post("/api/pleroma/admin/users/email_invite", %{
+ |> post("/api/v1/pleroma/admin/users/email_invite", %{
email: "foo@bar.com",
name: "JD"
})
conn
|> put_req_header("content-type", "application/json;charset=utf-8")
- |> post("/api/pleroma/admin/users/email_invite", %{email: recipient_email})
+ |> post("/api/v1/pleroma/admin/users/email_invite", %{email: recipient_email})
|> json_response_and_validate_schema(:no_content)
token_record =
end
end
- describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
+ describe "POST /api/v1/pleroma/admin/users/email_invite, with invalid config" do
setup do: clear_config([:instance, :registrations_open])
setup do: clear_config([:instance, :invites_enabled])
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/email_invite", %{
+ |> post("/api/v1/pleroma/admin/users/email_invite", %{
email: "foo@bar.com",
name: "JD"
})
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/email_invite", %{
+ |> post("/api/v1/pleroma/admin/users/email_invite", %{
email: "foo@bar.com",
name: "JD"
})
end
end
- describe "POST /api/pleroma/admin/users/invite_token" do
+ describe "POST /api/v1/pleroma/admin/users/invite_token" do
test "without options", %{conn: conn} do
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/invite_token")
+ |> post("/api/v1/pleroma/admin/users/invite_token")
invite_json = json_response_and_validate_schema(conn, 200)
invite = UserInviteToken.find_by_token!(invite_json["token"])
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/invite_token", %{
+ |> post("/api/v1/pleroma/admin/users/invite_token", %{
"expires_at" => Date.to_string(Date.utc_today())
})
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/invite_token", %{"max_use" => 150})
+ |> post("/api/v1/pleroma/admin/users/invite_token", %{"max_use" => 150})
invite_json = json_response_and_validate_schema(conn, 200)
invite = UserInviteToken.find_by_token!(invite_json["token"])
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/invite_token", %{
+ |> post("/api/v1/pleroma/admin/users/invite_token", %{
"max_use" => 150,
"expires_at" => Date.to_string(Date.utc_today())
})
end
end
- describe "GET /api/pleroma/admin/users/invites" do
+ describe "GET /api/v1/pleroma/admin/users/invites" do
test "no invites", %{conn: conn} do
- conn = get(conn, "/api/pleroma/admin/users/invites")
+ conn = get(conn, "/api/v1/pleroma/admin/users/invites")
assert json_response_and_validate_schema(conn, 200) == %{"invites" => []}
end
test "with invite", %{conn: conn} do
{:ok, invite} = UserInviteToken.create_invite()
- conn = get(conn, "/api/pleroma/admin/users/invites")
+ conn = get(conn, "/api/v1/pleroma/admin/users/invites")
assert json_response_and_validate_schema(conn, 200) == %{
"invites" => [
end
end
- describe "POST /api/pleroma/admin/users/revoke_invite" do
+ describe "POST /api/v1/pleroma/admin/users/revoke_invite" do
test "with token", %{conn: conn} do
{:ok, invite} = UserInviteToken.create_invite()
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
+ |> post("/api/v1/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
assert json_response_and_validate_schema(conn, 200) == %{
"expires_at" => nil,
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
+ |> post("/api/v1/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
end
{:ok, %{admin: admin, token: token, conn: conn}}
end
- describe "GET /api/pleroma/admin/media_proxy_caches" do
+ describe "GET /api/v1/pleroma/admin/media_proxy_caches" do
test "shows banned MediaProxy URLs", %{conn: conn} do
MediaProxy.put_in_banned_urls([
"http://localhost:4001/media/a688346.jpg",
response =
conn
- |> get("/api/pleroma/admin/media_proxy_caches?page_size=2")
+ |> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2")
|> json_response_and_validate_schema(200)
assert response["page_size"] == 2
response =
conn
- |> get("/api/pleroma/admin/media_proxy_caches?page_size=2&page=2")
+ |> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2&page=2")
|> json_response_and_validate_schema(200)
assert response["page_size"] == 2
response =
conn
- |> get("/api/pleroma/admin/media_proxy_caches?page_size=2&page=3")
+ |> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2&page=3")
|> json_response_and_validate_schema(200)
results = results ++ response["urls"]
response =
conn
- |> get("/api/pleroma/admin/media_proxy_caches?page_size=2&query=F44")
+ |> get("/api/v1/pleroma/admin/media_proxy_caches?page_size=2&query=F44")
|> json_response_and_validate_schema(200)
assert response["urls"] |> Enum.sort() == [
end
end
- describe "POST /api/pleroma/admin/media_proxy_caches/delete" do
+ describe "POST /api/v1/pleroma/admin/media_proxy_caches/delete" do
test "deleted MediaProxy URLs from banned", %{conn: conn} do
MediaProxy.put_in_banned_urls([
"http://localhost:4001/media/a688346.jpg",
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/media_proxy_caches/delete", %{
+ |> post("/api/v1/pleroma/admin/media_proxy_caches/delete", %{
urls: ["http://localhost:4001/media/a688346.jpg"]
})
|> json_response_and_validate_schema(200)
end
end
- describe "POST /api/pleroma/admin/media_proxy_caches/purge" do
+ describe "POST /api/v1/pleroma/admin/media_proxy_caches/purge" do
test "perform invalidates cache of MediaProxy", %{conn: conn} do
urls = [
"http://example.com/media/a688346.jpg",
] do
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/media_proxy_caches/purge", %{urls: urls, ban: false})
+ |> post("/api/v1/pleroma/admin/media_proxy_caches/purge", %{urls: urls, ban: false})
|> json_response_and_validate_schema(200)
refute MediaProxy.in_banned_urls("http://example.com/media/a688346.jpg")
conn
|> put_req_header("content-type", "application/json")
|> post(
- "/api/pleroma/admin/media_proxy_caches/purge",
+ "/api/v1/pleroma/admin/media_proxy_caches/purge",
%{urls: urls, ban: true}
)
|> json_response_and_validate_schema(200)
{:ok, %{admin: admin, token: token, conn: conn}}
end
- describe "POST /api/pleroma/admin/oauth_app" do
+ describe "POST /api/v1/pleroma/admin/oauth_app" do
test "errors", %{conn: conn} do
response =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/oauth_app", %{})
+ |> post("/api/v1/pleroma/admin/oauth_app", %{})
|> json_response_and_validate_schema(400)
assert %{
response =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/oauth_app", %{
+ |> post("/api/v1/pleroma/admin/oauth_app", %{
name: app_name,
redirect_uris: base_url
})
response =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/oauth_app", %{
+ |> post("/api/v1/pleroma/admin/oauth_app", %{
name: app_name,
redirect_uris: base_url,
trusted: true
end
end
- describe "GET /api/pleroma/admin/oauth_app" do
+ describe "GET /api/v1/pleroma/admin/oauth_app" do
setup do
app = insert(:oauth_app)
{:ok, app: app}
test "list", %{conn: conn} do
response =
conn
- |> get("/api/pleroma/admin/oauth_app")
+ |> get("/api/v1/pleroma/admin/oauth_app")
|> json_response_and_validate_schema(200)
assert %{"apps" => apps, "count" => count, "page_size" => _} = response
response =
conn
- |> get("/api/pleroma/admin/oauth_app?page_size=#{page_size}")
+ |> get("/api/v1/pleroma/admin/oauth_app?page_size=#{page_size}")
|> json_response_and_validate_schema(200)
assert %{"apps" => apps, "count" => _, "page_size" => ^page_size} = response
test "search by client name", %{conn: conn, app: app} do
response =
conn
- |> get("/api/pleroma/admin/oauth_app?name=#{app.client_name}")
+ |> get("/api/v1/pleroma/admin/oauth_app?name=#{app.client_name}")
|> json_response_and_validate_schema(200)
assert %{"apps" => [returned], "count" => _, "page_size" => _} = response
test "search by client id", %{conn: conn, app: app} do
response =
conn
- |> get("/api/pleroma/admin/oauth_app?client_id=#{app.client_id}")
+ |> get("/api/v1/pleroma/admin/oauth_app?client_id=#{app.client_id}")
|> json_response_and_validate_schema(200)
assert %{"apps" => [returned], "count" => _, "page_size" => _} = response
response =
conn
- |> get("/api/pleroma/admin/oauth_app?trusted=true")
+ |> get("/api/v1/pleroma/admin/oauth_app?trusted=true")
|> json_response_and_validate_schema(200)
assert %{"apps" => [returned], "count" => _, "page_size" => _} = response
end
end
- describe "DELETE /api/pleroma/admin/oauth_app/:id" do
+ describe "DELETE /api/v1/pleroma/admin/oauth_app/:id" do
test "with id", %{conn: conn} do
app = insert(:oauth_app)
response =
conn
- |> delete("/api/pleroma/admin/oauth_app/" <> to_string(app.id))
+ |> delete("/api/v1/pleroma/admin/oauth_app/" <> to_string(app.id))
|> json_response_and_validate_schema(:no_content)
assert response == ""
test "with non existance id", %{conn: conn} do
response =
conn
- |> delete("/api/pleroma/admin/oauth_app/0")
+ |> delete("/api/v1/pleroma/admin/oauth_app/0")
|> json_response_and_validate_schema(:bad_request)
assert response == ""
end
end
- describe "PATCH /api/pleroma/admin/oauth_app/:id" do
+ describe "PATCH /api/v1/pleroma/admin/oauth_app/:id" do
test "with id", %{conn: conn} do
app = insert(:oauth_app)
response =
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/oauth_app/#{id}", %{
+ |> patch("/api/v1/pleroma/admin/oauth_app/#{id}", %{
name: name,
trusted: true,
redirect_uris: url,
response =
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/oauth_app/0")
+ |> patch("/api/v1/pleroma/admin/oauth_app/0")
|> json_response_and_validate_schema(:bad_request)
assert response == ""
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/relay", %{
+ |> post("/api/v1/pleroma/admin/relay", %{
relay_url: "http://mastodon.example.org/users/admin"
})
User.follow(relay_user, user)
end)
- conn = get(conn, "/api/pleroma/admin/relay")
+ conn = get(conn, "/api/v1/pleroma/admin/relay")
assert json_response_and_validate_schema(conn, 200)["relays"] |> Enum.sort() == [
%{
test "DELETE /relay", %{conn: conn, admin: admin} do
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/relay", %{
+ |> post("/api/v1/pleroma/admin/relay", %{
relay_url: "http://mastodon.example.org/users/admin"
})
conn =
conn
|> put_req_header("content-type", "application/json")
- |> delete("/api/pleroma/admin/relay", %{
+ |> delete("/api/v1/pleroma/admin/relay", %{
relay_url: "http://mastodon.example.org/users/admin"
})
{:ok, %{admin: admin, token: token, conn: conn}}
end
- describe "GET /api/pleroma/admin/reports/:id" do
+ describe "GET /api/v1/pleroma/admin/reports/:id" do
test "returns report by its id", %{conn: conn} do
[reporter, target_user] = insert_pair(:user)
activity = insert(:note_activity, user: target_user)
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
+ |> post("/api/v1/pleroma/admin/reports/#{report_id}/notes", %{
content: "this is an admin note"
})
response =
conn
- |> get("/api/pleroma/admin/reports/#{report_id}")
+ |> get("/api/v1/pleroma/admin/reports/#{report_id}")
|> json_response_and_validate_schema(:ok)
assert response["id"] == report_id
end
test "returns 404 when report id is invalid", %{conn: conn} do
- conn = get(conn, "/api/pleroma/admin/reports/test")
+ conn = get(conn, "/api/v1/pleroma/admin/reports/test")
assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
end
end
- describe "PATCH /api/pleroma/admin/reports" do
+ describe "PATCH /api/v1/pleroma/admin/reports" do
setup do
[reporter, target_user] = insert_pair(:user)
activity = insert(:note_activity, user: target_user)
conn
|> assign(:token, read_token)
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/reports", %{
+ |> patch("/api/v1/pleroma/admin/reports", %{
"reports" => [%{"state" => "resolved", "id" => id}]
})
|> json_response_and_validate_schema(403)
conn
|> assign(:token, write_token)
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/reports", %{
+ |> patch("/api/v1/pleroma/admin/reports", %{
"reports" => [%{"state" => "resolved", "id" => id}]
})
|> json_response_and_validate_schema(:no_content)
test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/reports", %{
+ |> patch("/api/v1/pleroma/admin/reports", %{
"reports" => [
%{"state" => "resolved", "id" => id}
]
test "closes report", %{conn: conn, id: id, admin: admin} do
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/reports", %{
+ |> patch("/api/v1/pleroma/admin/reports", %{
"reports" => [
%{"state" => "closed", "id" => id}
]
conn =
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/reports", %{
+ |> patch("/api/v1/pleroma/admin/reports", %{
"reports" => [
%{"state" => "test", "id" => id}
]
conn =
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/reports", %{
+ |> patch("/api/v1/pleroma/admin/reports", %{
"reports" => [
%{"state" => "closed", "id" => "test"}
]
} do
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/reports", %{
+ |> patch("/api/v1/pleroma/admin/reports", %{
"reports" => [
%{"state" => "resolved", "id" => id},
%{"state" => "closed", "id" => second_report_id}
end
end
- describe "GET /api/pleroma/admin/reports" do
+ describe "GET /api/v1/pleroma/admin/reports" do
test "returns empty response when no reports created", %{conn: conn} do
response =
conn
build_conn()
|> assign(:user, user)
|> assign(:token, token)
- |> get("/api/pleroma/admin/reports")
+ |> get("/api/v1/pleroma/admin/reports")
assert json_response(conn, :forbidden) ==
%{"error" => "User is not a staff member."}
end
test "returns 403 when requested by anonymous" do
- conn = get(build_conn(), "/api/pleroma/admin/reports")
+ conn = get(build_conn(), "/api/v1/pleroma/admin/reports")
assert json_response(conn, :forbidden) == %{
"error" => "Invalid credentials."
end
end
- describe "POST /api/pleroma/admin/reports/:id/notes" do
+ describe "POST /api/v1/pleroma/admin/reports/:id/notes" do
setup %{conn: conn, admin: admin} do
[reporter, target_user] = insert_pair(:user)
activity = insert(:note_activity, user: target_user)
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
+ |> post("/api/v1/pleroma/admin/reports/#{report_id}/notes", %{
content: "this is disgusting!"
})
conn
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
+ |> post("/api/v1/pleroma/admin/reports/#{report_id}/notes", %{
content: "this is disgusting2!"
})
end
test "it returns reports with notes", %{conn: conn, admin: admin} do
- conn = get(conn, "/api/pleroma/admin/reports")
+ conn = get(conn, "/api/v1/pleroma/admin/reports")
response = json_response_and_validate_schema(conn, 200)
notes = hd(response["reports"])["notes"]
assert ReportNote |> Repo.all() |> length() == 2
assert [note, _] = Repo.all(ReportNote)
- delete(conn, "/api/pleroma/admin/reports/#{report_id}/notes/#{note.id}")
+ delete(conn, "/api/v1/pleroma/admin/reports/#{report_id}/notes/#{note.id}")
assert ReportNote |> Repo.all() |> length() == 1
end
{:ok, %{admin: admin, token: token, conn: conn}}
end
- describe "GET /api/pleroma/admin/statuses/:id" do
+ describe "GET /api/v1/pleroma/admin/statuses/:id" do
test "not found", %{conn: conn} do
assert conn
- |> get("/api/pleroma/admin/statuses/not_found")
+ |> get("/api/v1/pleroma/admin/statuses/not_found")
|> json_response_and_validate_schema(:not_found)
end
response =
conn
- |> get("/api/pleroma/admin/statuses/#{activity.id}")
+ |> get("/api/v1/pleroma/admin/statuses/#{activity.id}")
|> json_response_and_validate_schema(200)
assert response["id"] == activity.id
end
end
- describe "PUT /api/pleroma/admin/statuses/:id" do
+ describe "PUT /api/v1/pleroma/admin/statuses/:id" do
setup do
activity = insert(:note_activity)
response =
conn
|> put_req_header("content-type", "application/json")
- |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
+ |> put("/api/v1/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
|> json_response_and_validate_schema(:ok)
assert response["sensitive"]
response =
conn
|> put_req_header("content-type", "application/json")
- |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
+ |> put("/api/v1/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
|> json_response_and_validate_schema(:ok)
refute response["sensitive"]
response =
conn
|> put_req_header("content-type", "application/json")
- |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
+ |> put("/api/v1/pleroma/admin/statuses/#{id}", %{visibility: "public"})
|> json_response_and_validate_schema(:ok)
assert response["visibility"] == "public"
response =
conn
|> put_req_header("content-type", "application/json")
- |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "private"})
+ |> put("/api/v1/pleroma/admin/statuses/#{id}", %{visibility: "private"})
|> json_response_and_validate_schema(:ok)
assert response["visibility"] == "private"
response =
conn
|> put_req_header("content-type", "application/json")
- |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
+ |> put("/api/v1/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
|> json_response_and_validate_schema(:ok)
assert response["visibility"] == "unlisted"
conn =
conn
|> put_req_header("content-type", "application/json")
- |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "test"})
+ |> put("/api/v1/pleroma/admin/statuses/#{id}", %{visibility: "test"})
assert %{"error" => "test - Invalid value for enum."} =
json_response_and_validate_schema(conn, :bad_request)
end
end
- describe "DELETE /api/pleroma/admin/statuses/:id" do
+ describe "DELETE /api/v1/pleroma/admin/statuses/:id" do
setup do
activity = insert(:note_activity)
test "deletes status", %{conn: conn, id: id, admin: admin} do
conn
- |> delete("/api/pleroma/admin/statuses/#{id}")
+ |> delete("/api/v1/pleroma/admin/statuses/#{id}")
|> json_response_and_validate_schema(:ok)
refute Activity.get_by_id(id)
end
test "returns 404 when the status does not exist", %{conn: conn} do
- conn = delete(conn, "/api/pleroma/admin/statuses/test")
+ conn = delete(conn, "/api/v1/pleroma/admin/statuses/test")
assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
end
end
- describe "GET /api/pleroma/admin/statuses" do
+ describe "GET /api/v1/pleroma/admin/statuses" do
test "returns all public and unlisted statuses", %{conn: conn, admin: admin} do
blocked = insert(:user)
user = insert(:user)
response =
conn
- |> get("/api/pleroma/admin/statuses")
+ |> get("/api/v1/pleroma/admin/statuses")
|> json_response_and_validate_schema(200)
refute "private" in Enum.map(response, & &1["visibility"])
response =
conn
- |> get("/api/pleroma/admin/statuses?local_only=true")
+ |> get("/api/v1/pleroma/admin/statuses?local_only=true")
|> json_response_and_validate_schema(200)
assert length(response) == 1
{:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
{:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
- conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
+ conn = get(conn, "/api/v1/pleroma/admin/statuses?godmode=true")
assert json_response_and_validate_schema(conn, 200) |> length() == 3
end
end
user = insert(:user)
- conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")
+ conn =
+ get(build_conn(), "/api/v1/pleroma/admin/users/#{user.nickname}?admin_token=password123")
assert json_response_and_validate_schema(conn, 200)
end
- test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
+ test "GET /api/v1/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
%{admin: admin} do
user = insert(:user)
- url = "/api/pleroma/admin/users/#{user.nickname}"
+ url = "/api/v1/pleroma/admin/users/#{user.nickname}"
good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
end
end
- describe "DELETE /api/pleroma/admin/users" do
+ describe "DELETE /api/v1/pleroma/admin/users" do
test "single user", %{admin: admin, conn: conn} do
clear_config([:instance, :federating], true)
conn =
conn
|> put_req_header("accept", "application/json")
- |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
+ |> delete("/api/v1/pleroma/admin/users?nickname=#{user.nickname}")
ObanHelpers.perform_all()
conn
|> put_req_header("accept", "application/json")
|> put_req_header("content-type", "application/json")
- |> delete("/api/pleroma/admin/users", %{
+ |> delete("/api/v1/pleroma/admin/users", %{
nicknames: [user_one.nickname, user_two.nickname]
})
|> json_response_and_validate_schema(200)
end
end
- describe "/api/pleroma/admin/users" do
+ describe "/api/v1/pleroma/admin/users" do
test "Create", %{conn: conn} do
response =
conn
|> put_req_header("accept", "application/json")
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users", %{
+ |> post("/api/v1/pleroma/admin/users", %{
"users" => [
%{
"nickname" => "lain",
conn
|> put_req_header("accept", "application/json")
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users", %{
+ |> post("/api/v1/pleroma/admin/users", %{
"users" => [
%{
"nickname" => "lain",
conn
|> put_req_header("accept", "application/json")
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users", %{
+ |> post("/api/v1/pleroma/admin/users", %{
"users" => [
%{
"nickname" => user.nickname,
conn
|> put_req_header("accept", "application/json")
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users", %{
+ |> post("/api/v1/pleroma/admin/users", %{
"users" => [
%{
"nickname" => "newuser",
end
end
- describe "/api/pleroma/admin/users/:nickname" do
+ describe "/api/v1/pleroma/admin/users/:nickname" do
test "Show", %{conn: conn} do
user = insert(:user)
- conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")
+ conn = get(conn, "/api/v1/pleroma/admin/users/#{user.nickname}")
assert user_response(user) == json_response_and_validate_schema(conn, 200)
end
test "when the user doesn't exist", %{conn: conn} do
user = build(:user)
- conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")
+ conn = get(conn, "/api/v1/pleroma/admin/users/#{user.nickname}")
assert %{"error" => "Not found"} == json_response_and_validate_schema(conn, 404)
end
end
- describe "/api/pleroma/admin/users/follow" do
+ describe "/api/v1/pleroma/admin/users/follow" do
test "allows to force-follow another user", %{admin: admin, conn: conn} do
user = insert(:user)
follower = insert(:user)
conn
|> put_req_header("accept", "application/json")
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/follow", %{
+ |> post("/api/v1/pleroma/admin/users/follow", %{
"follower" => follower.nickname,
"followed" => user.nickname
})
end
end
- describe "/api/pleroma/admin/users/unfollow" do
+ describe "/api/v1/pleroma/admin/users/unfollow" do
test "allows to force-unfollow another user", %{admin: admin, conn: conn} do
user = insert(:user)
follower = insert(:user)
conn
|> put_req_header("accept", "application/json")
|> put_req_header("content-type", "application/json")
- |> post("/api/pleroma/admin/users/unfollow", %{
+ |> post("/api/v1/pleroma/admin/users/unfollow", %{
"follower" => follower.nickname,
"followed" => user.nickname
})
end
end
- describe "GET /api/pleroma/admin/users" do
+ describe "GET /api/v1/pleroma/admin/users" do
test "renders users array for the first page", %{conn: conn, admin: admin} do
user = insert(:user, local: false, tags: ["foo", "bar"])
user2 = insert(:user, is_approved: false, registration_reason: "I'm a chill dude")
- conn = get(conn, "/api/pleroma/admin/users?page=1")
+ conn = get(conn, "/api/v1/pleroma/admin/users?page=1")
users = [
user_response(
assert %{"count" => 26, "page_size" => 10, "users" => users1} =
conn
- |> get("/api/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
+ |> get("/api/v1/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
|> json_response_and_validate_schema(200)
assert Enum.count(users1) == 10
assert %{"count" => 26, "page_size" => 10, "users" => users2} =
conn
- |> get("/api/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
+ |> get("/api/v1/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
|> json_response_and_validate_schema(200)
assert Enum.count(users2) == 10
assert %{"count" => 26, "page_size" => 10, "users" => users3} =
conn
- |> get("/api/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
+ |> get("/api/v1/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
|> json_response_and_validate_schema(200)
assert Enum.count(users3) == 6
test "renders empty array for the second page", %{conn: conn} do
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?page=2")
+ conn = get(conn, "/api/v1/pleroma/admin/users?page=2")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 2,
test "regular search", %{conn: conn} do
user = insert(:user, nickname: "bob")
- conn = get(conn, "/api/pleroma/admin/users?query=bo")
+ conn = get(conn, "/api/v1/pleroma/admin/users?query=bo")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
user = insert(:user, nickname: "nickname@domain.com")
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
+ conn = get(conn, "/api/v1/pleroma/admin/users?query=domain.com")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
user = insert(:user, nickname: "nickname@domain.com")
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
+ conn = get(conn, "/api/v1/pleroma/admin/users?query=nickname@domain.com")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
user = insert(:user, name: "Display name")
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?name=display")
+ conn = get(conn, "/api/v1/pleroma/admin/users?name=display")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
user = insert(:user, email: "email@example.com")
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
+ conn = get(conn, "/api/v1/pleroma/admin/users?email=email@example.com")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
user = insert(:user, nickname: "aalice")
user2 = insert(:user, nickname: "alice")
- conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
+ conn1 = get(conn, "/api/v1/pleroma/admin/users?query=a&page_size=1&page=1")
assert json_response_and_validate_schema(conn1, 200) == %{
"count" => 2,
"users" => [user_response(user2)]
}
- conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
+ conn2 = get(conn, "/api/v1/pleroma/admin/users?query=a&page_size=1&page=2")
assert json_response_and_validate_schema(conn2, 200) == %{
"count" => 2,
build_conn()
|> assign(:user, admin)
|> assign(:token, token)
- |> get("/api/pleroma/admin/users?query=bo&filters=local")
+ |> get("/api/v1/pleroma/admin/users?query=bo&filters=local")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
insert(:user, nickname: "bobb", local: false)
- conn = get(conn, "/api/pleroma/admin/users?filters=local")
+ conn = get(conn, "/api/v1/pleroma/admin/users?filters=local")
users = [
user_response(user),
result =
conn
- |> get("/api/pleroma/admin/users?filters=unconfirmed")
+ |> get("/api/v1/pleroma/admin/users?filters=unconfirmed")
|> json_response_and_validate_schema(200)
users =
insert(:user, nickname: "happyboy", is_approved: true)
- conn = get(conn, "/api/pleroma/admin/users?filters=need_approval")
+ conn = get(conn, "/api/v1/pleroma/admin/users?filters=need_approval")
users = [
user_response(
insert(:user)
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
+ conn = get(conn, "/api/v1/pleroma/admin/users?filters=is_admin")
users = [
user_response(second_admin, %{
insert(:user)
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
+ conn = get(conn, "/api/v1/pleroma/admin/users?filters=is_moderator")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
insert(:user)
insert(:user)
- conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
+ conn = get(conn, "/api/v1/pleroma/admin/users?tags[]=first&tags[]=second")
users = [
user_response(user2, %{"tags" => ["second"]}),
build_conn()
|> assign(:user, token.user)
|> assign(:token, token)
- |> get("/api/pleroma/admin/users?filters=active")
+ |> get("/api/v1/pleroma/admin/users?filters=active")
assert %{
"count" => 2,
build_conn()
|> assign(:user, admin)
|> assign(:token, token)
- |> get("/api/pleroma/admin/users?filters=deactivated,external")
+ |> get("/api/v1/pleroma/admin/users?filters=deactivated,external")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
test "it omits relay user", %{admin: admin, conn: conn} do
assert %User{} = Relay.get_actor()
- conn = get(conn, "/api/pleroma/admin/users")
+ conn = get(conn, "/api/v1/pleroma/admin/users")
assert json_response_and_validate_schema(conn, 200) == %{
"count" => 1,
end
end
- test "PATCH /api/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
+ test "PATCH /api/v1/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
user_one = insert(:user, is_active: false)
user_two = insert(:user, is_active: false)
conn
|> put_req_header("content-type", "application/json")
|> patch(
- "/api/pleroma/admin/users/activate",
+ "/api/v1/pleroma/admin/users/activate",
%{nicknames: [user_one.nickname, user_two.nickname]}
)
"@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
end
- test "PATCH /api/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
+ test "PATCH /api/v1/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
user_one = insert(:user, is_active: true)
user_two = insert(:user, is_active: true)
conn
|> put_req_header("content-type", "application/json")
|> patch(
- "/api/pleroma/admin/users/deactivate",
+ "/api/v1/pleroma/admin/users/deactivate",
%{nicknames: [user_one.nickname, user_two.nickname]}
)
"@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
end
- test "PATCH /api/pleroma/admin/users/approve", %{admin: admin, conn: conn} do
+ test "PATCH /api/v1/pleroma/admin/users/approve", %{admin: admin, conn: conn} do
user_one = insert(:user, is_approved: false)
user_two = insert(:user, is_approved: false)
conn
|> put_req_header("content-type", "application/json")
|> patch(
- "/api/pleroma/admin/users/approve",
+ "/api/v1/pleroma/admin/users/approve",
%{nicknames: [user_one.nickname, user_two.nickname]}
)
"@#{admin.nickname} approved users: @#{user_one.nickname}, @#{user_two.nickname}"
end
- test "PATCH /api/pleroma/admin/users/suggest", %{admin: admin, conn: conn} do
+ test "PATCH /api/v1/pleroma/admin/users/suggest", %{admin: admin, conn: conn} do
user1 = insert(:user, is_suggested: false)
user2 = insert(:user, is_suggested: false)
conn
|> put_req_header("content-type", "application/json")
|> patch(
- "/api/pleroma/admin/users/suggest",
+ "/api/v1/pleroma/admin/users/suggest",
%{nicknames: [user1.nickname, user2.nickname]}
)
|> json_response_and_validate_schema(200)
"@#{admin.nickname} added suggested users: @#{user1.nickname}, @#{user2.nickname}"
end
- test "PATCH /api/pleroma/admin/users/unsuggest", %{admin: admin, conn: conn} do
+ test "PATCH /api/v1/pleroma/admin/users/unsuggest", %{admin: admin, conn: conn} do
user1 = insert(:user, is_suggested: true)
user2 = insert(:user, is_suggested: true)
conn
|> put_req_header("content-type", "application/json")
|> patch(
- "/api/pleroma/admin/users/unsuggest",
+ "/api/v1/pleroma/admin/users/unsuggest",
%{nicknames: [user1.nickname, user2.nickname]}
)
|> json_response_and_validate_schema(200)
"@#{admin.nickname} removed suggested users: @#{user1.nickname}, @#{user2.nickname}"
end
- test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation", %{admin: admin, conn: conn} do
+ test "PATCH /api/v1/pleroma/admin/users/:nickname/toggle_activation", %{
+ admin: admin,
+ conn: conn
+ } do
user = insert(:user)
conn =
conn
|> put_req_header("content-type", "application/json")
- |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
+ |> patch("/api/v1/pleroma/admin/users/#{user.nickname}/toggle_activation")
assert json_response_and_validate_schema(conn, 200) ==
user_response(
end
end
- test "GET /api*path", %{conn: conn} do
- assert conn
- |> get("/api/foo")
- |> json_response(404) == %{"error" => "Not implemented"}
- end
-
test "GET /pleroma/admin -> /pleroma/admin/", %{conn: conn} do
assert redirected_to(get(conn, "/pleroma/admin")) =~ "/pleroma/admin/"
end
response =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{
+ |> post("/api/v1/statuses", %{
"content_type" => "text/plain",
"source" => "Pleroma FE",
"status" => "Hello world",
response =
conn
- |> get("api/v1/statuses/#{response["id"]}", %{})
+ |> get("/api/v1/statuses/#{response["id"]}", %{})
|> json_response_and_validate_schema(200)
assert response["reblogs_count"] == 0
conn_four =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{
+ |> post("/api/v1/statuses", %{
"status" => "oolong",
"expires_in" => expires_in
})
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{
+ |> post("/api/v1/statuses", %{
"status" => "aa chikichiki banban"
})
assert %{"error" => "Expiry date is too soon"} =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{
+ |> post("/api/v1/statuses", %{
"status" => "oolong",
"expires_in" => expires_in
})
assert %{"error" => "Expiry date is too soon"} =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{
+ |> post("/api/v1/statuses", %{
"status" => "oolong",
"expires_in" => expires_in
})
assert %{"error" => "[KeywordPolicy] Matches with rejected keyword"} =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{"status" => "GNO/Linux"})
+ |> post("/api/v1/statuses", %{"status" => "GNO/Linux"})
|> json_response_and_validate_schema(422)
end
conn =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
+ |> post("/api/v1/statuses", %{"status" => content, "visibility" => "direct"})
assert %{"id" => id} = response = json_response_and_validate_schema(conn, 200)
assert response["visibility"] == "direct"
result =
conn
- |> get("api/v1/statuses/#{activity}")
+ |> get("/api/v1/statuses/#{activity}")
assert %{
"content" => "cofe is my copilot",
result =
conn
- |> get("api/v1/statuses/#{activity}")
+ |> get("/api/v1/statuses/#{activity}")
assert %{
"content" => "club mate is my wingman",
assert %{"id" => id} =
conn
|> put_req_header("content-type", "application/json")
- |> post("api/v1/statuses", %{
+ |> post("/api/v1/statuses", %{
"status" => "oolong",
"expires_in" => expires_in
})
conn
|> assign(:user, user3)
|> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
- |> get("api/v1/timelines/home")
+ |> get("/api/v1/timelines/home")
[reblogged_activity] = json_response_and_validate_schema(conn3, 200)
get(conn, "/api/v1/timelines/public")
|> json_response_and_validate_schema(200)
- assert length(response) == 0
+ assert response == []
end
test "doesn't return replies if follow is posting with users from blocked domain" do
|> assign(:token, insert(:oauth_token, user: user_two, scopes: ["read:statuses"]))
# Only direct should be visible here
- res_conn = get(conn_user_two, "api/v1/timelines/direct")
+ res_conn = get(conn_user_two, "/api/v1/timelines/direct")
assert [status] = json_response_and_validate_schema(res_conn, :ok)
build_conn()
|> assign(:user, user_one)
|> assign(:token, insert(:oauth_token, user: user_one, scopes: ["read:statuses"]))
- |> get("api/v1/timelines/direct")
+ |> get("/api/v1/timelines/direct")
[status] = json_response_and_validate_schema(res_conn, :ok)
assert %{"visibility" => "direct"} = status
# Both should be visible here
- res_conn = get(conn_user_two, "api/v1/timelines/home")
+ res_conn = get(conn_user_two, "/api/v1/timelines/home")
[_s1, _s2] = json_response_and_validate_schema(res_conn, :ok)
})
end)
- res_conn = get(conn_user_two, "api/v1/timelines/direct")
+ res_conn = get(conn_user_two, "/api/v1/timelines/direct")
statuses = json_response_and_validate_schema(res_conn, :ok)
assert length(statuses) == 20
max_id = List.last(statuses)["id"]
- res_conn = get(conn_user_two, "api/v1/timelines/direct?max_id=#{max_id}")
+ res_conn = get(conn_user_two, "/api/v1/timelines/direct?max_id=#{max_id}")
assert [status] = json_response_and_validate_schema(res_conn, :ok)
visibility: "direct"
})
- res_conn = get(conn, "api/v1/timelines/direct")
+ res_conn = get(conn, "/api/v1/timelines/direct")
[status] = json_response_and_validate_schema(res_conn, :ok)
assert status["id"] == direct.id
"pleroma_background_image" => new_background_oversized
})
- assert user_response = json_response_and_validate_schema(res, 413)
+ assert json_response_and_validate_schema(res, 413)
assert user.background == %{}
clear_config([:instance, :upload_limit], upload_limit)
test "update fields", %{conn: conn} do
fields = [
- %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
- %{"name" => "link.io", "value" => "cofe.io"}
+ %{name: "<a href=\"http://google.com\">foo</a>", value: "<script>bar</script>"},
+ %{name: "link.io", value: "cofe.io"}
]
account_data =
conn
- |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
+ |> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
|> json_response_and_validate_schema(200)
assert account_data["fields"] == [
test "emojis in fields labels", %{conn: conn} do
fields = [
- %{"name" => ":firefox:", "value" => "is best 2hu"},
- %{"name" => "they wins", "value" => ":blank:"}
+ %{name: ":firefox:", value: "is best 2hu"},
+ %{name: "they wins", value: ":blank:"}
]
account_data =
conn
- |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
+ |> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
|> json_response_and_validate_schema(200)
assert account_data["fields"] == [
test "update fields with empty name", %{conn: conn} do
fields = [
- %{"name" => "foo", "value" => ""},
- %{"name" => "", "value" => "bar"}
+ %{name: "foo", value: ""},
+ %{name: "", value: "bar"}
]
account =
conn
- |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
+ |> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
|> json_response_and_validate_schema(200)
assert account["fields"] == [
long_name = Enum.map(0..name_limit, fn _ -> "x" end) |> Enum.join()
long_value = Enum.map(0..value_limit, fn _ -> "x" end) |> Enum.join()
- fields = [%{"name" => "foo", "value" => long_value}]
+ fields = [%{name: "foo", value: long_value}]
assert %{"error" => "Invalid request"} ==
conn
- |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
+ |> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
|> json_response_and_validate_schema(403)
- fields = [%{"name" => long_name, "value" => "bar"}]
+ fields = [%{name: long_name, value: "bar"}]
assert %{"error" => "Invalid request"} ==
conn
- |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
+ |> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
|> json_response_and_validate_schema(403)
clear_config([:instance, :max_account_fields], 1)
fields = [
- %{"name" => "foo", "value" => "bar"},
+ %{name: "foo", value: "bar"},
%{"name" => "link", "value" => "cofe.io"}
]
assert %{"error" => "Invalid request"} ==
conn
- |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
+ |> patch("/api/v1/accounts/update_credentials", %{fields_attributes: fields})
|> json_response_and_validate_schema(403)
end
end
|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
|> json_response_and_validate_schema(200)
- assert length(response) == 0
+ assert response == []
end
test "does not return others' favorited DM when user is not one of recipients", %{
{:ok, %{admin_conn: admin_conn}}
end
- describe "POST/PATCH/DELETE /api/pleroma/emoji/packs/files?name=:name" do
+ describe "POST/PATCH/DELETE /api/v1/pleroma/emoji/packs/files?name=:name" do
setup do
pack_file = "#{@emoji_path}/test_pack/pack.json"
original_content = File.read!(pack_file)
resp =
admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
file: %Plug.Upload{
content_type: "application/zip",
filename: "emojis.zip",
test "create shortcode exists", %{admin_conn: admin_conn} do
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank",
filename: "dir/blank.png",
file: %Plug.Upload{
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank3",
filename: "dir/blank.png",
file: %Plug.Upload{
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank",
new_shortcode: "blank2",
new_filename: "dir_2/blank_3.png"
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank3",
filename: "dir/blank.png",
file: %Plug.Upload{
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank3",
new_shortcode: "blank4",
new_filename: "dir_2/blank_3.png",
test "with empty filename", %{admin_conn: admin_conn} do
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank2",
filename: "",
file: %Plug.Upload{
test "add file with not loaded pack", %{admin_conn: admin_conn} do
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=not_loaded", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=not_loaded", %{
shortcode: "blank3",
filename: "dir/blank.png",
file: %Plug.Upload{
]) do
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=not_loaded", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=not_loaded", %{
shortcode: "blank3",
filename: "dir/blank.png",
file: %Plug.Upload{
test "remove file with not loaded pack", %{admin_conn: admin_conn} do
assert admin_conn
- |> delete("/api/pleroma/emoji/packs/files?name=not_loaded&shortcode=blank3")
+ |> delete("/api/v1/pleroma/emoji/packs/files?name=not_loaded&shortcode=blank3")
|> json_response_and_validate_schema(:not_found) == %{
"error" => "pack \"not_loaded\" is not found"
}
test "remove file with empty shortcode", %{admin_conn: admin_conn} do
assert admin_conn
- |> delete("/api/pleroma/emoji/packs/files?name=not_loaded&shortcode=")
+ |> delete("/api/v1/pleroma/emoji/packs/files?name=not_loaded&shortcode=")
|> json_response_and_validate_schema(:not_found) == %{
"error" => "pack \"not_loaded\" is not found"
}
test "update file with not loaded pack", %{admin_conn: admin_conn} do
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/packs/files?name=not_loaded", %{
+ |> patch("/api/v1/pleroma/emoji/packs/files?name=not_loaded", %{
shortcode: "blank4",
new_shortcode: "blank3",
new_filename: "dir_2/blank_3.png"
test "new with shortcode as file with update", %{admin_conn: admin_conn} do
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank4",
filename: "dir/blank.png",
file: %Plug.Upload{
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank4",
new_shortcode: "blank3",
new_filename: "dir_2/blank_3.png"
assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
assert admin_conn
- |> delete("/api/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
+ |> delete("/api/v1/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
|> json_response_and_validate_schema(200) == %{
"blank" => "blank.png",
"blank2" => "blank2.png"
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank_url",
file: "https://test-blank/blank_url.png"
})
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> post("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
file: %Plug.Upload{
filename: "shortcode.png",
path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
assert admin_conn
- |> delete("/api/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
+ |> delete("/api/v1/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "Emoji \"blank3\" does not exist"
}
test "update non existing emoji", %{admin_conn: admin_conn} do
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank3",
new_shortcode: "blank4",
new_filename: "dir_2/blank_3.png"
} =
admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
+ |> patch("/api/v1/pleroma/emoji/packs/files?name=test_pack", %{
shortcode: "blank",
new_filename: "dir_2/blank_3.png"
})
{:ok, %{admin_conn: admin_conn}}
end
- test "GET /api/pleroma/emoji/packs when :public: false", %{conn: conn} do
+ test "GET /api/v1/pleroma/emoji/packs when :public: false", %{conn: conn} do
clear_config([:instance, :public], false)
- conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
+ conn |> get("/api/v1/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
end
- test "GET /api/pleroma/emoji/packs", %{conn: conn} do
- resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
+ test "GET /api/v1/pleroma/emoji/packs", %{conn: conn} do
+ resp =
+ conn
+ |> get("/api/v1/pleroma/emoji/packs")
+ |> json_response_and_validate_schema(200)
assert resp["count"] == 4
resp =
conn
- |> get("/api/pleroma/emoji/packs?page_size=1")
+ |> get("/api/v1/pleroma/emoji/packs?page_size=1")
|> json_response_and_validate_schema(200)
assert resp["count"] == 4
resp =
conn
- |> get("/api/pleroma/emoji/packs?page_size=1&page=2")
+ |> get("/api/v1/pleroma/emoji/packs?page_size=1&page=2")
|> json_response_and_validate_schema(200)
assert resp["count"] == 4
resp =
conn
- |> get("/api/pleroma/emoji/packs?page_size=1&page=3")
+ |> get("/api/v1/pleroma/emoji/packs?page_size=1&page=3")
|> json_response_and_validate_schema(200)
assert resp["count"] == 4
resp =
conn
- |> get("/api/pleroma/emoji/packs?page_size=1&page=4")
+ |> get("/api/v1/pleroma/emoji/packs?page_size=1&page=4")
|> json_response_and_validate_schema(200)
assert resp["count"] == 4
assert [pack1, pack2, pack3, pack4] |> Enum.uniq() |> length() == 4
end
- describe "GET /api/pleroma/emoji/packs/remote" do
+ describe "GET /api/v1/pleroma/emoji/packs/remote" do
test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
resp =
conn
- |> get("/api/pleroma/emoji/packs?page=2&page_size=1")
+ |> get("/api/v1/pleroma/emoji/packs?page=2&page_size=1")
|> json_response_and_validate_schema(200)
mock(fn
%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: ["shareable_emoji_packs"]}})
- %{method: :get, url: "https://example.com/api/pleroma/emoji/packs?page=2&page_size=1"} ->
+ %{
+ method: :get,
+ url: "https://example.com/api/v1/pleroma/emoji/packs?page=2&page_size=1"
+ } ->
json(resp)
end)
assert admin_conn
- |> get("/api/pleroma/emoji/packs/remote?url=https://example.com&page=2&page_size=1")
+ |> get(
+ "/api/v1/pleroma/emoji/packs/remote?url=https://example.com&page=2&page_size=1"
+ )
|> json_response_and_validate_schema(200) == resp
end
end)
assert admin_conn
- |> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
+ |> get("/api/v1/pleroma/emoji/packs/remote?url=https://example.com")
|> json_response_and_validate_schema(500) == %{
"error" => "The requested instance does not support sharing emoji packs"
}
end
end
- describe "GET /api/pleroma/emoji/packs/archive?name=:name" do
+ describe "GET /api/v1/pleroma/emoji/packs/archive?name=:name" do
test "download shared pack", %{conn: conn} do
resp =
conn
- |> get("/api/pleroma/emoji/packs/archive?name=test_pack")
+ |> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack")
|> response(200)
{:ok, arch} = :zip.unzip(resp, [:memory])
test "non existing pack", %{conn: conn} do
assert conn
- |> get("/api/pleroma/emoji/packs/archive?name=test_pack_for_import")
+ |> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack_for_import")
|> json_response_and_validate_schema(:not_found) == %{
"error" => "Pack test_pack_for_import does not exist"
}
test "non downloadable pack", %{conn: conn} do
assert conn
- |> get("/api/pleroma/emoji/packs/archive?name=test_pack_nonshared")
+ |> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack_nonshared")
|> json_response_and_validate_schema(:forbidden) == %{
"error" =>
"Pack test_pack_nonshared cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
end
end
- describe "POST /api/pleroma/emoji/packs/download" do
+ describe "POST /api/v1/pleroma/emoji/packs/download" do
test "shared pack from remote and non shared from fallback-src", %{
admin_conn: admin_conn,
conn: conn
%{
method: :get,
- url: "https://example.com/api/pleroma/emoji/pack?name=test_pack"
+ url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack"
} ->
conn
- |> get("/api/pleroma/emoji/pack?name=test_pack")
+ |> get("/api/v1/pleroma/emoji/pack?name=test_pack")
|> json_response_and_validate_schema(200)
|> json()
%{
method: :get,
- url: "https://example.com/api/pleroma/emoji/packs/archive?name=test_pack"
+ url: "https://example.com/api/v1/pleroma/emoji/packs/archive?name=test_pack"
} ->
conn
- |> get("/api/pleroma/emoji/packs/archive?name=test_pack")
+ |> get("/api/v1/pleroma/emoji/packs/archive?name=test_pack")
|> response(200)
|> text()
%{
method: :get,
- url: "https://example.com/api/pleroma/emoji/pack?name=test_pack_nonshared"
+ url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack_nonshared"
} ->
conn
- |> get("/api/pleroma/emoji/pack?name=test_pack_nonshared")
+ |> get("/api/v1/pleroma/emoji/pack?name=test_pack_nonshared")
|> json_response_and_validate_schema(200)
|> json()
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/download", %{
+ |> post("/api/v1/pleroma/emoji/packs/download", %{
url: "https://example.com",
name: "test_pack",
as: "test_pack2"
assert File.exists?("#{@emoji_path}/test_pack2/blank.png")
assert admin_conn
- |> delete("/api/pleroma/emoji/pack?name=test_pack2")
+ |> delete("/api/v1/pleroma/emoji/pack?name=test_pack2")
|> json_response_and_validate_schema(200) == "ok"
refute File.exists?("#{@emoji_path}/test_pack2")
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post(
- "/api/pleroma/emoji/packs/download",
+ "/api/v1/pleroma/emoji/packs/download",
%{
url: "https://example.com",
name: "test_pack_nonshared",
assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")
assert admin_conn
- |> delete("/api/pleroma/emoji/pack?name=test_pack_nonshared2")
+ |> delete("/api/v1/pleroma/emoji/pack?name=test_pack_nonshared2")
|> json_response_and_validate_schema(200) == "ok"
refute File.exists?("#{@emoji_path}/test_pack_nonshared2")
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post(
- "/api/pleroma/emoji/packs/download",
+ "/api/v1/pleroma/emoji/packs/download",
%{
url: "https://old-instance",
name: "test_pack",
%{
method: :get,
- url: "https://example.com/api/pleroma/emoji/pack?name=pack_bad_sha"
+ url: "https://example.com/api/v1/pleroma/emoji/pack?name=pack_bad_sha"
} ->
{:ok, pack} = Pleroma.Emoji.Pack.load_pack("pack_bad_sha")
%Tesla.Env{status: 200, body: Jason.encode!(pack)}
%{
method: :get,
- url: "https://example.com/api/pleroma/emoji/packs/archive?name=pack_bad_sha"
+ url: "https://example.com/api/v1/pleroma/emoji/packs/archive?name=pack_bad_sha"
} ->
%Tesla.Env{
status: 200,
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/download", %{
+ |> post("/api/v1/pleroma/emoji/packs/download", %{
url: "https://example.com",
name: "pack_bad_sha",
as: "pack_bad_sha2"
%{
method: :get,
- url: "https://example.com/api/pleroma/emoji/pack?name=test_pack"
+ url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack"
} ->
{:ok, pack} = Pleroma.Emoji.Pack.load_pack("test_pack")
%Tesla.Env{status: 200, body: Jason.encode!(pack)}
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/emoji/packs/download", %{
+ |> post("/api/v1/pleroma/emoji/packs/download", %{
url: "https://example.com",
name: "test_pack",
as: "test_pack2"
end
end
- describe "PATCH/update /api/pleroma/emoji/pack?name=:name" do
+ describe "PATCH/update /api/v1/pleroma/emoji/pack?name=:name" do
setup do
pack_file = "#{@emoji_path}/test_pack/pack.json"
original_content = File.read!(pack_file)
assert conn
|> put_req_header("content-type", "multipart/form-data")
|> patch(
- "/api/pleroma/emoji/pack?name=test_pack",
+ "/api/v1/pleroma/emoji/pack?name=test_pack",
%{"metadata" => ctx[:new_data]}
)
|> json_response_and_validate_schema(500)
test "for a pack without a fallback source", ctx do
assert ctx[:admin_conn]
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/pack?name=test_pack", %{
+ |> patch("/api/v1/pleroma/emoji/pack?name=test_pack", %{
"metadata" => ctx[:new_data]
})
|> json_response_and_validate_schema(200) == ctx[:new_data]
assert ctx[:admin_conn]
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
+ |> patch("/api/v1/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
|> json_response_and_validate_schema(200) == new_data_with_sha
assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
assert ctx[:admin_conn]
|> put_req_header("content-type", "multipart/form-data")
- |> patch("/api/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
+ |> patch("/api/v1/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "The fallback archive does not have all files specified in pack.json"
}
end
end
- describe "POST/DELETE /api/pleroma/emoji/pack?name=:name" do
+ describe "POST/DELETE /api/v1/pleroma/emoji/pack?name=:name" do
test "returns an error on creates pack when file system not writable", %{
admin_conn: admin_conn
} do
{File, [:passthrough], [mkdir: fn ^path_pack -> {:error, :eacces} end]}
]) do
assert admin_conn
- |> post("/api/pleroma/emoji/pack?name=test_pack")
+ |> post("/api/v1/pleroma/emoji/pack?name=test_pack")
|> json_response_and_validate_schema(500) == %{
"error" =>
"Unexpected error occurred while creating pack. (POSIX error: Permission denied)"
{File, [:passthrough], [rm_rf: fn ^path_pack -> {:error, :eacces, path_pack} end]}
]) do
assert admin_conn
- |> delete("/api/pleroma/emoji/pack?name=test_emoji_pack")
+ |> delete("/api/v1/pleroma/emoji/pack?name=test_emoji_pack")
|> json_response_and_validate_schema(500) == %{
"error" =>
"Couldn't delete the `test_emoji_pack` pack (POSIX error: Permission denied)"
test "creating and deleting a pack", %{admin_conn: admin_conn} do
assert admin_conn
- |> post("/api/pleroma/emoji/pack?name=test_created")
+ |> post("/api/v1/pleroma/emoji/pack?name=test_created")
|> json_response_and_validate_schema(200) == "ok"
assert File.exists?("#{@emoji_path}/test_created/pack.json")
}
assert admin_conn
- |> delete("/api/pleroma/emoji/pack?name=test_created")
+ |> delete("/api/v1/pleroma/emoji/pack?name=test_created")
|> json_response_and_validate_schema(200) == "ok"
refute File.exists?("#{@emoji_path}/test_created/pack.json")
File.write!(Path.join(path, "pack.json"), pack_file)
assert admin_conn
- |> post("/api/pleroma/emoji/pack?name=test_created")
+ |> post("/api/v1/pleroma/emoji/pack?name=test_created")
|> json_response_and_validate_schema(:conflict) == %{
"error" => "A pack named \"test_created\" already exists"
}
test "with empty name", %{admin_conn: admin_conn} do
assert admin_conn
- |> post("/api/pleroma/emoji/pack?name= ")
+ |> post("/api/v1/pleroma/emoji/pack?name= ")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack name cannot be empty"
}
test "deleting nonexisting pack", %{admin_conn: admin_conn} do
assert admin_conn
- |> delete("/api/pleroma/emoji/pack?name=non_existing")
+ |> delete("/api/v1/pleroma/emoji/pack?name=non_existing")
|> json_response_and_validate_schema(:not_found) == %{
"error" => "Pack non_existing does not exist"
}
test "deleting with empty name", %{admin_conn: admin_conn} do
assert admin_conn
- |> delete("/api/pleroma/emoji/pack?name= ")
+ |> delete("/api/v1/pleroma/emoji/pack?name= ")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack name cannot be empty"
}
File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
end)
- resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
+ resp =
+ conn
+ |> get("/api/v1/pleroma/emoji/packs")
+ |> json_response_and_validate_schema(200)
refute Map.has_key?(resp["packs"], "test_pack_for_import")
assert admin_conn
- |> get("/api/pleroma/emoji/packs/import")
+ |> get("/api/v1/pleroma/emoji/packs/import")
|> json_response_and_validate_schema(200) == ["test_pack_for_import"]
- resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
+ resp =
+ conn
+ |> get("/api/v1/pleroma/emoji/packs")
+ |> json_response_and_validate_schema(200)
+
assert resp["packs"]["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}
File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)
assert admin_conn
- |> get("/api/pleroma/emoji/packs/import")
+ |> get("/api/v1/pleroma/emoji/packs/import")
|> json_response_and_validate_schema(200) == ["test_pack_for_import"]
- resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
+ resp =
+ conn
+ |> get("/api/v1/pleroma/emoji/packs")
+ |> json_response_and_validate_schema(200)
assert resp["packs"]["test_pack_for_import"]["files"] == %{
"blank" => "blank.png",
}
end
- describe "GET /api/pleroma/emoji/pack?name=:name" do
+ describe "GET /api/v1/pleroma/emoji/pack?name=:name" do
test "shows pack.json", %{conn: conn} do
assert %{
"files" => files,
}
} =
conn
- |> get("/api/pleroma/emoji/pack?name=test_pack")
+ |> get("/api/v1/pleroma/emoji/pack?name=test_pack")
|> json_response_and_validate_schema(200)
assert files == %{"blank" => "blank.png", "blank2" => "blank2.png"}
"files_count" => 2
} =
conn
- |> get("/api/pleroma/emoji/pack?name=test_pack&page_size=1")
+ |> get("/api/v1/pleroma/emoji/pack?name=test_pack&page_size=1")
|> json_response_and_validate_schema(200)
assert files |> Map.keys() |> length() == 1
"files_count" => 2
} =
conn
- |> get("/api/pleroma/emoji/pack?name=test_pack&page_size=1&page=2")
+ |> get("/api/v1/pleroma/emoji/pack?name=test_pack&page_size=1&page=2")
|> json_response_and_validate_schema(200)
assert files |> Map.keys() |> length() == 1
}
} =
conn
- |> get("/api/pleroma/emoji/pack?name=blobs.gg")
+ |> get("/api/v1/pleroma/emoji/pack?name=blobs.gg")
|> json_response_and_validate_schema(200)
end
test "non existing pack", %{conn: conn} do
assert conn
- |> get("/api/pleroma/emoji/pack?name=non_existing")
+ |> get("/api/v1/pleroma/emoji/pack?name=non_existing")
|> json_response_and_validate_schema(:not_found) == %{
"error" => "Pack non_existing does not exist"
}
test "error name", %{conn: conn} do
assert conn
- |> get("/api/pleroma/emoji/pack?name= ")
+ |> get("/api/v1/pleroma/emoji/pack?name= ")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack name cannot be empty"
}
assert conn
|> put_req_header("authorization", "Bearer #{token.token}")
- |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: code})
+ |> post("/api/pleroma/accounts/mfa/confirm/totp", %{
+ password: "test",
+ code: code
+ })
|> json_response(:ok)
settings = refresh_record(user).multi_factor_authentication_settings
assert conn
|> put_req_header("authorization", "Bearer #{token2.token}")
- |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: code})
+ |> post("/api/pleroma/accounts/mfa/confirm/totp", %{
+ password: "test",
+ code: code
+ })
|> json_response(403) == %{
"error" => "Insufficient permissions: write:security."
}
response =
conn
|> put_req_header("authorization", "Bearer #{token.token}")
- |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "xxx", code: code})
+ |> post("/api/pleroma/accounts/mfa/confirm/totp", %{
+ password: "xxx",
+ code: code
+ })
|> json_response(422)
settings = refresh_record(user).multi_factor_authentication_settings
response =
conn
|> put_req_header("authorization", "Bearer #{token.token}")
- |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: "code"})
+ |> post("/api/pleroma/accounts/mfa/confirm/totp", %{
+ password: "test",
+ code: "code"
+ })
|> json_response(422)
settings = refresh_record(user).multi_factor_authentication_settings
assert conn
|> put_req_header("authorization", "Bearer #{token2.token}")
- |> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: "code"})
+ |> post("/api/pleroma/accounts/mfa/confirm/totp", %{
+ password: "test",
+ code: "code"
+ })
|> json_response(403) == %{
"error" => "Insufficient permissions: write:security."
}
import Pleroma.Tests.Helpers, only: [clear_config: 2]
- setup do:
- clear_config(RemoteIp,
- enabled: true,
- headers: ["x-forwarded-for"],
- proxies: [],
- reserved: [
- "127.0.0.0/8",
- "::1/128",
- "fc00::/7",
- "10.0.0.0/8",
- "172.16.0.0/12",
- "192.168.0.0/16"
- ]
- )
+ setup do
+ clear_config([RemoteIp, :enabled], true)
+ clear_config([RemoteIp, :headers], ["x-forwarded-for"])
+ clear_config([RemoteIp, :proxies], [])
+
+ clear_config(
+ [RemoteIp, :reserved],
+ [
+ "127.0.0.0/8",
+ "::1/128",
+ "fc00::/7",
+ "10.0.0.0/8",
+ "172.16.0.0/12",
+ "192.168.0.0/16"
+ ]
+ )
+ end
test "disabled" do
- clear_config(RemoteIp, enabled: false)
+ clear_config([RemoteIp, :enabled], false)
%{remote_ip: remote_ip} = conn(:get, "/")
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("x-forwarded-for", "1.1.1.1")
|> RemoteIp.call(nil)
test "enabled" do
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("x-forwarded-for", "1.1.1.1")
|> RemoteIp.call(nil)
end
test "custom headers" do
- clear_config(RemoteIp, enabled: true, headers: ["cf-connecting-ip"])
+ clear_config([RemoteIp, :enabled], true)
+ clear_config([RemoteIp, :headers], ["cf-connecting-ip"])
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("x-forwarded-for", "1.1.1.1")
|> RemoteIp.call(nil)
refute conn.remote_ip == {1, 1, 1, 1}
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("cf-connecting-ip", "1.1.1.1")
|> RemoteIp.call(nil)
test "custom proxies" do
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("x-forwarded-for", "173.245.48.1, 1.1.1.1, 173.245.48.2")
|> RemoteIp.call(nil)
clear_config([RemoteIp, :proxies], ["173.245.48.0/20"])
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("x-forwarded-for", "173.245.48.1, 1.1.1.1, 173.245.48.2")
|> RemoteIp.call(nil)
clear_config([RemoteIp, :proxies], ["173.245.48.1"])
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("x-forwarded-for", "173.245.48.1, 1.1.1.1")
|> RemoteIp.call(nil)
clear_config([RemoteIp, :proxies], ["10.0.0.3/24"])
conn =
- conn(:get, "/")
+ :get
+ |> conn("/")
|> put_req_header("x-forwarded-for", "10.0.0.3, 1.1.1.1")
|> RemoteIp.call(nil)
import Pleroma.Factory
import Swoosh.TestAssertions
- describe "GET /api/pleroma/password_reset/token" do
+ describe "GET /api/v1/pleroma/password_reset/token" do
test "it returns error when token invalid", %{conn: conn} do
response =
conn
- |> get("/api/pleroma/password_reset/token")
+ |> get("/api/v1/pleroma/password_reset/token")
|> html_response(:ok)
assert response =~ "<h2>Invalid Token</h2>"
response =
conn
- |> get("/api/pleroma/password_reset/#{token.token}")
+ |> get("/api/v1/pleroma/password_reset/#{token.token}")
|> html_response(:ok)
assert response =~ "<h2>Password Reset for #{user.nickname}</h2>"
response =
conn
- |> get("/api/pleroma/password_reset/#{token.token}")
+ |> get("/api/v1/pleroma/password_reset/#{token.token}")
|> html_response(:ok)
assert response =~ "<h2>Invalid Token</h2>"
end
end
- describe "POST /api/pleroma/password_reset" do
+ describe "POST /api/v1/pleroma/password_reset" do
test "it fails for an expired token", %{conn: conn} do
clear_config([:instance, :password_reset_token_validity], 0)
response =
conn
|> assign(:user, user)
- |> post("/api/pleroma/password_reset", %{data: params})
+ |> post("/api/v1/pleroma/password_reset", %{data: params})
|> html_response(:ok)
refute response =~ "<h2>Password changed!</h2>"
response =
conn
|> assign(:user, user)
- |> post("/api/pleroma/password_reset", %{data: params})
+ |> post("/api/v1/pleroma/password_reset", %{data: params})
|> html_response(:ok)
assert response =~ "<h2>Password changed!</h2>"
conn
|> assign(:user, user)
- |> post("/api/pleroma/password_reset", %{data: params})
+ |> post("/api/v1/pleroma/password_reset", %{data: params})
|> html_response(:ok)
assert User.get_by_id(user.id).password_reset_pending == false
end
end
- describe "/api/pleroma/emoji" do
+ describe "/api/v1/pleroma/emoji" do
test "returns json with custom emoji with tags", %{conn: conn} do
emoji =
conn
- |> get("/api/pleroma/emoji")
+ |> get("/api/v1/pleroma/emoji")
|> json_response_and_validate_schema(200)
assert Enum.all?(emoji, fn
end
end
- describe "GET /api/pleroma/healthcheck" do
+ describe "GET /api/v1/pleroma/healthcheck" do
setup do: clear_config([:instance, :healthcheck])
test "returns 503 when healthcheck disabled", %{conn: conn} do
response =
conn
- |> get("/api/pleroma/healthcheck")
+ |> get("/api/v1/pleroma/healthcheck")
|> json_response_and_validate_schema(503)
assert response == %{}
system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
response =
conn
- |> get("/api/pleroma/healthcheck")
+ |> get("/api/v1/pleroma/healthcheck")
|> json_response_and_validate_schema(200)
assert %{
system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
response =
conn
- |> get("/api/pleroma/healthcheck")
+ |> get("/api/v1/pleroma/healthcheck")
|> json_response_and_validate_schema(503)
assert %{
new: fn -> "test_captcha" end do
resp =
conn
- |> get("/api/pleroma/captcha")
+ |> get("/api/v1/pleroma/captcha")
|> response(200)
assert resp == "\"test_captcha\""
conn =
conn
|> put_req_header("content-type", "multipart/form-data")
- |> post("/api/pleroma/change_email", %{password: "test", email: "cofe@foobar.com"})
+ |> post("/api/pleroma/change_email", %{
+ password: "test",
+ email: "cofe@foobar.com"
+ })
assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
end
conn =
conn
|> put_req_header("content-type", "application/json")
- |> delete("/api/pleroma/aliases", %{alias: non_alias_user |> User.full_nickname()})
+ |> delete("/api/pleroma/aliases", %{
+ alias: non_alias_user |> User.full_nickname()
+ })
assert %{"error" => "Account has no such alias."} =
json_response_and_validate_schema(conn, 404)
defp start_peer({node_host, override_configs}) do
log(node_host, "booting federated VM")
- {:ok, node} = :peer.start(%{host: ~c"127.0.0.1", name: node_name(node_host), args: vm_args()})
+
+ {:ok, _pid, node} =
+ :peer.start(%{host: ~c"127.0.0.1", name: node_name(node_host), args: vm_args()})
+
add_code_paths(node)
load_apps_and_transfer_configuration(node, override_configs)
ensure_apps_started(node)
projects / akkoma / commitdiff