refactor emoji api with fixes

This commit is contained in:
Alexander Strizhakov 2020-03-28 13:34:32 +03:00
parent 5839e67eb8
commit 342f55fb92
No known key found for this signature in database
GPG Key ID: 022896A53AEF1381
9 changed files with 1327 additions and 779 deletions

509
lib/pleroma/emoji/pack.ex Normal file
View File

@ -0,0 +1,509 @@
defmodule Pleroma.Emoji.Pack do
@derive {Jason.Encoder, only: [:files, :pack]}
defstruct files: %{},
pack_file: nil,
path: nil,
pack: %{},
name: nil
@type t() :: %__MODULE__{
files: %{String.t() => Path.t()},
pack_file: Path.t(),
path: Path.t(),
pack: map(),
name: String.t()
}
alias Pleroma.Emoji
@spec emoji_path() :: Path.t()
def emoji_path do
static = Pleroma.Config.get!([:instance, :static_dir])
Path.join(static, "emoji")
end
@spec create(String.t()) :: :ok | {:error, File.posix()} | {:error, :empty_values}
def create(name) when byte_size(name) > 0 do
dir = Path.join(emoji_path(), name)
with :ok <- File.mkdir(dir) do
%__MODULE__{
pack_file: Path.join(dir, "pack.json")
}
|> save_pack()
end
end
def create(_), do: {:error, :empty_values}
@spec show(String.t()) :: {:ok, t()} | {:loaded, nil} | {:error, :empty_values}
def show(name) when byte_size(name) > 0 do
with {_, %__MODULE__{} = pack} <- {:loaded, load_pack(name)},
{_, pack} <- validate_pack(pack) do
{:ok, pack}
end
end
def show(_), do: {:error, :empty_values}
@spec delete(String.t()) ::
{:ok, [binary()]} | {:error, File.posix(), binary()} | {:error, :empty_values}
def delete(name) when byte_size(name) > 0 do
emoji_path()
|> Path.join(name)
|> File.rm_rf()
end
def delete(_), do: {:error, :empty_values}
@spec add_file(String.t(), String.t(), Path.t(), Plug.Upload.t() | String.t()) ::
{:ok, t()} | {:error, File.posix()} | {:error, :empty_values}
def add_file(name, shortcode, filename, file)
when byte_size(name) > 0 and byte_size(shortcode) > 0 and byte_size(filename) > 0 do
with {_, nil} <- {:exists, Emoji.get(shortcode)},
{_, %__MODULE__{} = pack} <- {:loaded, load_pack(name)} do
file_path = Path.join(pack.path, filename)
create_subdirs(file_path)
case file do
%Plug.Upload{path: upload_path} ->
# Copy the uploaded file from the temporary directory
File.copy!(upload_path, file_path)
url when is_binary(url) ->
# Download and write the file
file_contents = Tesla.get!(url).body
File.write!(file_path, file_contents)
end
files = Map.put(pack.files, shortcode, filename)
updated_pack = %{pack | files: files}
case save_pack(updated_pack) do
:ok ->
Emoji.reload()
{:ok, updated_pack}
e ->
e
end
end
end
def add_file(_, _, _, _), do: {:error, :empty_values}
defp create_subdirs(file_path) do
if String.contains?(file_path, "/") do
file_path
|> Path.dirname()
|> File.mkdir_p!()
end
end
@spec remove_file(String.t(), String.t()) ::
{:ok, t()} | {:error, File.posix()} | {:error, :empty_values}
def remove_file(name, shortcode) when byte_size(name) > 0 and byte_size(shortcode) > 0 do
with {_, %__MODULE__{} = pack} <- {:loaded, load_pack(name)},
{_, {filename, files}} when not is_nil(filename) <-
{:exists, Map.pop(pack.files, shortcode)},
emoji <- Path.join(pack.path, filename),
{_, true} <- {:exists, File.exists?(emoji)} do
emoji_dir = Path.dirname(emoji)
File.rm!(emoji)
if String.contains?(filename, "/") and File.ls!(emoji_dir) == [] do
File.rmdir!(emoji_dir)
end
updated_pack = %{pack | files: files}
case save_pack(updated_pack) do
:ok ->
Emoji.reload()
{:ok, updated_pack}
e ->
e
end
end
end
def remove_file(_, _), do: {:error, :empty_values}
@spec update_file(String.t(), String.t(), String.t(), String.t(), boolean()) ::
{:ok, t()} | {:error, File.posix()} | {:error, :empty_values}
def update_file(name, shortcode, new_shortcode, new_filename, force)
when byte_size(name) > 0 and byte_size(shortcode) > 0 and byte_size(new_shortcode) > 0 and
byte_size(new_filename) > 0 do
with {_, %__MODULE__{} = pack} <- {:loaded, load_pack(name)},
{_, {filename, files}} when not is_nil(filename) <-
{:exists, Map.pop(pack.files, shortcode)},
{_, true} <- {:not_used, force or is_nil(Emoji.get(new_shortcode))} do
old_path = Path.join(pack.path, filename)
old_dir = Path.dirname(old_path)
new_path = Path.join(pack.path, new_filename)
create_subdirs(new_path)
:ok = File.rename(old_path, new_path)
if String.contains?(filename, "/") and File.ls!(old_dir) == [] do
File.rmdir!(old_dir)
end
files = Map.put(files, new_shortcode, new_filename)
updated_pack = %{pack | files: files}
case save_pack(updated_pack) do
:ok ->
Emoji.reload()
{:ok, updated_pack}
e ->
e
end
end
end
def update_file(_, _, _, _, _), do: {:error, :empty_values}
@spec import_from_filesystem() :: {:ok, [String.t()]} | {:error, atom()}
def import_from_filesystem do
emoji_path = emoji_path()
with {:ok, %{access: :read_write}} <- File.stat(emoji_path),
{:ok, results} <- File.ls(emoji_path) do
names =
results
|> Enum.map(&Path.join(emoji_path, &1))
|> Enum.reject(fn path ->
File.dir?(path) and File.exists?(Path.join(path, "pack.json"))
end)
|> Enum.map(&write_pack_contents/1)
|> Enum.filter(& &1)
{:ok, names}
else
{:ok, %{access: _}} -> {:error, :not_writable}
e -> e
end
end
defp write_pack_contents(path) do
pack = %__MODULE__{
files: files_from_path(path),
path: path,
pack_file: Path.join(path, "pack.json")
}
case save_pack(pack) do
:ok -> Path.basename(path)
_ -> nil
end
end
defp files_from_path(path) do
txt_path = Path.join(path, "emoji.txt")
if File.exists?(txt_path) do
# There's an emoji.txt file, it's likely from a pack installed by the pack manager.
# Make a pack.json file from the contents of that emoji.txt file
# FIXME: Copy-pasted from Pleroma.Emoji/load_from_file_stream/2
# Create a map of shortcodes to filenames from emoji.txt
File.read!(txt_path)
|> String.split("\n")
|> Enum.map(&String.trim/1)
|> Enum.map(fn line ->
case String.split(line, ~r/,\s*/) do
# This matches both strings with and without tags
# and we don't care about tags here
[name, file | _] ->
file_dir_name = Path.dirname(file)
file =
if String.ends_with?(path, file_dir_name) do
Path.basename(file)
else
file
end
{name, file}
_ ->
nil
end
end)
|> Enum.filter(& &1)
|> Enum.into(%{})
else
# If there's no emoji.txt, assume all files
# that are of certain extensions from the config are emojis and import them all
pack_extensions = Pleroma.Config.get!([:emoji, :pack_extensions])
Emoji.Loader.make_shortcode_to_file_map(path, pack_extensions)
end
end
@spec list_remote_packs(String.t()) :: {:ok, map()}
def list_remote_packs(url) do
uri =
url
|> String.trim()
|> URI.parse()
with {_, true} <- {:shareable, shareable_packs_available?(uri)} do
packs =
uri
|> URI.merge("/api/pleroma/emoji/packs")
|> to_string()
|> Tesla.get!()
|> Map.get(:body)
|> Jason.decode!()
{:ok, packs}
end
end
@spec list_local_packs() :: {:ok, map()}
def list_local_packs do
emoji_path = emoji_path()
# Create the directory first if it does not exist. This is probably the first request made
# with the API so it should be sufficient
with {:create_dir, :ok} <- {:create_dir, File.mkdir_p(emoji_path)},
{:ls, {:ok, results}} <- {:ls, File.ls(emoji_path)} do
packs =
results
|> Enum.map(&load_pack/1)
|> Enum.filter(& &1)
|> Enum.map(&validate_pack/1)
|> Map.new()
{:ok, packs}
end
end
defp validate_pack(pack) do
if downloadable?(pack) do
archive = fetch_archive(pack)
archive_sha = :crypto.hash(:sha256, archive) |> Base.encode16()
info =
pack.pack
|> Map.put("can-download", true)
|> Map.put("download-sha256", archive_sha)
{pack.name, Map.put(pack, :pack, info)}
else
info = Map.put(pack.pack, "can-download", false)
{pack.name, Map.put(pack, :pack, info)}
end
end
defp downloadable?(pack) do
# If the pack is set as shared, check if it can be downloaded
# That means that when asked, the pack can be packed and sent to the remote
# Otherwise, they'd have to download it from external-src
pack.pack["share-files"] &&
Enum.all?(pack.files, fn {_, file} ->
File.exists?(Path.join(pack.path, file))
end)
end
@spec download(String.t()) :: {:ok, binary()}
def download(name) do
with {_, %__MODULE__{} = pack} <- {:exists?, load_pack(name)},
{_, true} <- {:can_download?, downloadable?(pack)} do
{:ok, fetch_archive(pack)}
end
end
defp fetch_archive(pack) do
hash = :crypto.hash(:md5, File.read!(pack.pack_file))
case Cachex.get!(:emoji_packs_cache, pack.name) do
%{hash: ^hash, pack_data: archive} ->
archive
_ ->
create_archive_and_cache(pack, hash)
end
end
defp create_archive_and_cache(pack, hash) do
files = ['pack.json' | Enum.map(pack.files, fn {_, file} -> to_charlist(file) end)]
{:ok, {_, result}} =
:zip.zip('#{pack.name}.zip', files, [:memory, cwd: to_charlist(pack.path)])
ttl_per_file = Pleroma.Config.get!([:emoji, :shared_pack_cache_seconds_per_file])
overall_ttl = :timer.seconds(ttl_per_file * Enum.count(files))
Cachex.put!(
:emoji_packs_cache,
pack.name,
# if pack.json MD5 changes, the cache is not valid anymore
%{hash: hash, pack_data: result},
# Add a minute to cache time for every file in the pack
ttl: overall_ttl
)
result
end
@spec download_from_source(String.t(), String.t(), String.t()) :: :ok
def download_from_source(name, url, as) do
uri =
url
|> String.trim()
|> URI.parse()
with {_, true} <- {:shareable, shareable_packs_available?(uri)} do
# TODO: why do we load all packs, if we know the name of pack we need
remote_pack =
uri
|> URI.merge("/api/pleroma/emoji/packs/#{name}")
|> to_string()
|> Tesla.get!()
|> Map.get(:body)
|> Jason.decode!()
result =
case remote_pack["pack"] do
%{"share-files" => true, "can-download" => true, "download-sha256" => sha} ->
{:ok,
%{
sha: sha,
url:
URI.merge(uri, "/api/pleroma/emoji/packs/#{name}/download_shared") |> to_string()
}}
%{"fallback-src" => src, "fallback-src-sha256" => sha} when is_binary(src) ->
{:ok,
%{
sha: sha,
url: src,
fallback: true
}}
_ ->
{:error,
"The pack was not set as shared and there is no fallback src to download from"}
end
with {:ok, %{sha: sha, url: url} = pinfo} <- result,
%{body: archive} <- Tesla.get!(url),
{_, true} <- {:checksum, Base.decode16!(sha) == :crypto.hash(:sha256, archive)} do
local_name = as || name
path = Path.join(emoji_path(), local_name)
pack = %__MODULE__{
name: local_name,
path: path,
files: remote_pack["files"],
pack_file: Path.join(path, "pack.json")
}
File.mkdir_p!(pack.path)
files = Enum.map(remote_pack["files"], fn {_, path} -> to_charlist(path) end)
# Fallback cannot contain a pack.json file
files = if pinfo[:fallback], do: files, else: ['pack.json' | files]
{:ok, _} = :zip.unzip(archive, cwd: to_charlist(pack.path), file_list: files)
# Fallback can't contain a pack.json file, since that would cause the fallback-src-sha256
# in it to depend on itself
if pinfo[:fallback] do
save_pack(pack)
end
:ok
end
end
end
defp save_pack(pack), do: File.write(pack.pack_file, Jason.encode!(pack, pretty: true))
@spec save_metadata(map(), t()) :: {:ok, t()} | {:error, File.posix()}
def save_metadata(metadata, %__MODULE__{} = pack) do
pack = Map.put(pack, :pack, metadata)
with :ok <- save_pack(pack) do
{:ok, pack}
end
end
@spec update_metadata(String.t(), map()) :: {:ok, t()} | {:error, File.posix()}
def update_metadata(name, data) do
pack = load_pack(name)
fb_sha_changed? =
not is_nil(data["fallback-src"]) and data["fallback-src"] != pack.pack["fallback-src"]
with {_, true} <- {:update?, fb_sha_changed?},
{:ok, %{body: zip}} <- Tesla.get(data["fallback-src"]),
{:ok, f_list} <- :zip.unzip(zip, [:memory]),
{_, true} <- {:has_all_files?, has_all_files?(pack.files, f_list)} do
fallback_sha = :crypto.hash(:sha256, zip) |> Base.encode16()
data
|> Map.put("fallback-src-sha256", fallback_sha)
|> save_metadata(pack)
else
{:update?, _} -> save_metadata(data, pack)
e -> e
end
end
# Check if all files from the pack.json are in the archive
defp has_all_files?(files, f_list) do
Enum.all?(files, fn {_, from_manifest} ->
List.keyfind(f_list, to_charlist(from_manifest), 0)
end)
end
@spec load_pack(String.t()) :: t() | nil
def load_pack(name) do
pack_file = Path.join([emoji_path(), name, "pack.json"])
if File.exists?(pack_file) do
pack_file
|> File.read!()
|> from_json()
|> Map.put(:pack_file, pack_file)
|> Map.put(:path, Path.dirname(pack_file))
|> Map.put(:name, name)
end
end
defp from_json(json) do
map = Jason.decode!(json)
struct(__MODULE__, %{files: map["files"], pack: map["pack"]})
end
defp shareable_packs_available?(uri) do
uri
|> URI.merge("/.well-known/nodeinfo")
|> to_string()
|> Tesla.get!()
|> Map.get(:body)
|> Jason.decode!()
|> Map.get("links")
|> List.last()
|> Map.get("href")
# Get the actual nodeinfo address and fetch it
|> Tesla.get!()
|> Map.get(:body)
|> Jason.decode!()
|> get_in(["metadata", "features"])
|> Enum.member?("shareable_emoji_packs")
end
end

View File

@ -1,18 +1,15 @@
defmodule Pleroma.Web.PleromaAPI.EmojiAPIController do defmodule Pleroma.Web.PleromaAPI.EmojiAPIController do
use Pleroma.Web, :controller use Pleroma.Web, :controller
alias Pleroma.Plugs.ExpectPublicOrAuthenticatedCheckPlug alias Pleroma.Emoji.Pack
alias Pleroma.Plugs.OAuthScopesPlug
require Logger
plug( plug(
OAuthScopesPlug, Pleroma.Plugs.OAuthScopesPlug,
%{scopes: ["write"], admin: true} %{scopes: ["write"], admin: true}
when action in [ when action in [
:create, :create,
:delete, :delete,
:save_from, :download_from,
:import_from_fs, :import_from_fs,
:update_file, :update_file,
:update_metadata :update_metadata
@ -21,17 +18,10 @@ defmodule Pleroma.Web.PleromaAPI.EmojiAPIController do
plug( plug(
:skip_plug, :skip_plug,
[OAuthScopesPlug, ExpectPublicOrAuthenticatedCheckPlug] [Pleroma.Plugs.OAuthScopesPlug, Pleroma.Plugs.ExpectPublicOrAuthenticatedCheckPlug]
when action in [:download_shared, :list_packs, :list_from] when action in [:download_shared, :list_packs, :list_from]
) )
defp emoji_dir_path do
Path.join(
Pleroma.Config.get!([:instance, :static_dir]),
"emoji"
)
end
@doc """ @doc """
Lists packs from the remote instance. Lists packs from the remote instance.
@ -39,14 +29,10 @@ defp emoji_dir_path do
be done by the server be done by the server
""" """
def list_from(conn, %{"instance_address" => address}) do def list_from(conn, %{"instance_address" => address}) do
address = String.trim(address) with {:ok, packs} <- Pack.list_remote_packs(address) do
json(conn, packs)
if shareable_packs_available(address) do
list_resp =
"#{address}/api/pleroma/emoji/packs" |> Tesla.get!() |> Map.get(:body) |> Jason.decode!()
json(conn, list_resp)
else else
{:shareable, _} ->
conn conn
|> put_status(:internal_server_error) |> put_status(:internal_server_error)
|> json(%{error: "The requested instance does not support sharing emoji packs"}) |> json(%{error: "The requested instance does not support sharing emoji packs"})
@ -60,113 +46,44 @@ def list_from(conn, %{"instance_address" => address}) do
a map of "pack directory name" to pack.json contents. a map of "pack directory name" to pack.json contents.
""" """
def list_packs(conn, _params) do def list_packs(conn, _params) do
# Create the directory first if it does not exist. This is probably the first request made emoji_path =
# with the API so it should be sufficient Path.join(
with {:create_dir, :ok} <- {:create_dir, File.mkdir_p(emoji_dir_path())}, Pleroma.Config.get!([:instance, :static_dir]),
{:ls, {:ok, results}} <- {:ls, File.ls(emoji_dir_path())} do "emoji"
pack_infos = )
results
|> Enum.filter(&has_pack_json?/1)
|> Enum.map(&load_pack/1)
# Check if all the files are in place and can be sent
|> Enum.map(&validate_pack/1)
# Transform into a map of pack-name => pack-data
|> Enum.into(%{})
json(conn, pack_infos) with {:ok, packs} <- Pack.list_local_packs() do
json(conn, packs)
else else
{:create_dir, {:error, e}} -> {:create_dir, {:error, e}} ->
conn conn
|> put_status(:internal_server_error) |> put_status(:internal_server_error)
|> json(%{error: "Failed to create the emoji pack directory at #{emoji_dir_path()}: #{e}"}) |> json(%{error: "Failed to create the emoji pack directory at #{emoji_path}: #{e}"})
{:ls, {:error, e}} -> {:ls, {:error, e}} ->
conn conn
|> put_status(:internal_server_error) |> put_status(:internal_server_error)
|> json(%{ |> json(%{
error: error: "Failed to get the contents of the emoji pack directory at #{emoji_path}: #{e}"
"Failed to get the contents of the emoji pack directory at #{emoji_dir_path()}: #{e}"
}) })
end end
end end
defp has_pack_json?(file) do def show(conn, %{"name" => name}) do
dir_path = Path.join(emoji_dir_path(), file) name = String.trim(name)
# Filter to only use the pack.json packs
File.dir?(dir_path) and File.exists?(Path.join(dir_path, "pack.json"))
end
defp load_pack(pack_name) do with {:ok, pack} <- Pack.show(name) do
pack_path = Path.join(emoji_dir_path(), pack_name) json(conn, pack)
pack_file = Path.join(pack_path, "pack.json")
{pack_name, Jason.decode!(File.read!(pack_file))}
end
defp validate_pack({name, pack}) do
pack_path = Path.join(emoji_dir_path(), name)
if can_download?(pack, pack_path) do
archive_for_sha = make_archive(name, pack, pack_path)
archive_sha = :crypto.hash(:sha256, archive_for_sha) |> Base.encode16()
pack =
pack
|> put_in(["pack", "can-download"], true)
|> put_in(["pack", "download-sha256"], archive_sha)
{name, pack}
else else
{name, put_in(pack, ["pack", "can-download"], false)} {:loaded, _} ->
end conn
end |> put_status(:not_found)
|> json(%{error: "Pack #{name} does not exist"})
defp can_download?(pack, pack_path) do {:error, :empty_values} ->
# If the pack is set as shared, check if it can be downloaded conn
# That means that when asked, the pack can be packed and sent to the remote |> put_status(:bad_request)
# Otherwise, they'd have to download it from external-src |> json(%{error: "pack name cannot be empty"})
pack["pack"]["share-files"] &&
Enum.all?(pack["files"], fn {_, path} ->
File.exists?(Path.join(pack_path, path))
end)
end
defp create_archive_and_cache(name, pack, pack_dir, md5) do
files =
['pack.json'] ++
(pack["files"] |> Enum.map(fn {_, path} -> to_charlist(path) end))
{:ok, {_, zip_result}} = :zip.zip('#{name}.zip', files, [:memory, cwd: to_charlist(pack_dir)])
cache_seconds_per_file = Pleroma.Config.get!([:emoji, :shared_pack_cache_seconds_per_file])
cache_ms = :timer.seconds(cache_seconds_per_file * Enum.count(files))
Cachex.put!(
:emoji_packs_cache,
name,
# if pack.json MD5 changes, the cache is not valid anymore
%{pack_json_md5: md5, pack_data: zip_result},
# Add a minute to cache time for every file in the pack
ttl: cache_ms
)
Logger.debug("Created an archive for the '#{name}' emoji pack, \
keeping it in cache for #{div(cache_ms, 1000)}s")
zip_result
end
defp make_archive(name, pack, pack_dir) do
# Having a different pack.json md5 invalidates cache
pack_file_md5 = :crypto.hash(:md5, File.read!(Path.join(pack_dir, "pack.json")))
case Cachex.get!(:emoji_packs_cache, name) do
%{pack_file_md5: ^pack_file_md5, pack_data: zip_result} ->
Logger.debug("Using cache for the '#{name}' shared emoji pack")
zip_result
_ ->
create_archive_and_cache(name, pack, pack_dir, pack_file_md5)
end end
end end
@ -175,21 +92,15 @@ defp make_archive(name, pack, pack_dir) do
to download packs that the instance shares. to download packs that the instance shares.
""" """
def download_shared(conn, %{"name" => name}) do def download_shared(conn, %{"name" => name}) do
pack_dir = Path.join(emoji_dir_path(), name) with {:ok, archive} <- Pack.download(name) do
pack_file = Path.join(pack_dir, "pack.json") send_download(conn, {:binary, archive}, filename: "#{name}.zip")
with {_, true} <- {:exists?, File.exists?(pack_file)},
pack = Jason.decode!(File.read!(pack_file)),
{_, true} <- {:can_download?, can_download?(pack, pack_dir)} do
zip_result = make_archive(name, pack, pack_dir)
send_download(conn, {:binary, zip_result}, filename: "#{name}.zip")
else else
{:can_download?, _} -> {:can_download?, _} ->
conn conn
|> put_status(:forbidden) |> put_status(:forbidden)
|> json(%{ |> json(%{
error: "Pack #{name} cannot be downloaded from this instance, either pack sharing\ error:
was disabled for this pack or some files are missing" "Pack #{name} cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
}) })
{:exists?, _} -> {:exists?, _} ->
@ -199,22 +110,6 @@ def download_shared(conn, %{"name" => name}) do
end end
end end
defp shareable_packs_available(address) do
"#{address}/.well-known/nodeinfo"
|> Tesla.get!()
|> Map.get(:body)
|> Jason.decode!()
|> Map.get("links")
|> List.last()
|> Map.get("href")
# Get the actual nodeinfo address and fetch it
|> Tesla.get!()
|> Map.get(:body)
|> Jason.decode!()
|> get_in(["metadata", "features"])
|> Enum.member?("shareable_emoji_packs")
end
@doc """ @doc """
An admin endpoint to request downloading and storing a pack named `pack_name` from the instance An admin endpoint to request downloading and storing a pack named `pack_name` from the instance
`instance_address`. `instance_address`.
@ -222,74 +117,24 @@ defp shareable_packs_available(address) do
If the requested instance's admin chose to share the pack, it will be downloaded If the requested instance's admin chose to share the pack, it will be downloaded
from that instance, otherwise it will be downloaded from the fallback source, if there is one. from that instance, otherwise it will be downloaded from the fallback source, if there is one.
""" """
def save_from(conn, %{"instance_address" => address, "pack_name" => name} = data) do def download_from(conn, %{"instance_address" => address, "pack_name" => name} = params) do
address = String.trim(address) with :ok <- Pack.download_from_source(name, address, params["as"]) do
if shareable_packs_available(address) do
full_pack =
"#{address}/api/pleroma/emoji/packs/list"
|> Tesla.get!()
|> Map.get(:body)
|> Jason.decode!()
|> Map.get(name)
pack_info_res =
case full_pack["pack"] do
%{"share-files" => true, "can-download" => true, "download-sha256" => sha} ->
{:ok,
%{
sha: sha,
uri: "#{address}/api/pleroma/emoji/packs/download_shared/#{name}"
}}
%{"fallback-src" => src, "fallback-src-sha256" => sha} when is_binary(src) ->
{:ok,
%{
sha: sha,
uri: src,
fallback: true
}}
_ ->
{:error,
"The pack was not set as shared and there is no fallback src to download from"}
end
with {:ok, %{sha: sha, uri: uri} = pinfo} <- pack_info_res,
%{body: emoji_archive} <- Tesla.get!(uri),
{_, true} <- {:checksum, Base.decode16!(sha) == :crypto.hash(:sha256, emoji_archive)} do
local_name = data["as"] || name
pack_dir = Path.join(emoji_dir_path(), local_name)
File.mkdir_p!(pack_dir)
files = Enum.map(full_pack["files"], fn {_, path} -> to_charlist(path) end)
# Fallback cannot contain a pack.json file
files = if pinfo[:fallback], do: files, else: ['pack.json'] ++ files
{:ok, _} = :zip.unzip(emoji_archive, cwd: to_charlist(pack_dir), file_list: files)
# Fallback can't contain a pack.json file, since that would cause the fallback-src-sha256
# in it to depend on itself
if pinfo[:fallback] do
pack_file_path = Path.join(pack_dir, "pack.json")
File.write!(pack_file_path, Jason.encode!(full_pack, pretty: true))
end
json(conn, "ok") json(conn, "ok")
else else
{:error, e} -> {:shareable, _} ->
conn |> put_status(:internal_server_error) |> json(%{error: e}) conn
|> put_status(:internal_server_error)
|> json(%{error: "The requested instance does not support sharing emoji packs"})
{:checksum, _} -> {:checksum, _} ->
conn conn
|> put_status(:internal_server_error) |> put_status(:internal_server_error)
|> json(%{error: "SHA256 for the pack doesn't match the one sent by the server"}) |> json(%{error: "SHA256 for the pack doesn't match the one sent by the server"})
end
else {:error, e} ->
conn conn
|> put_status(:internal_server_error) |> put_status(:internal_server_error)
|> json(%{error: "The requested instance does not support sharing emoji packs"}) |> json(%{error: e})
end end
end end
@ -297,23 +142,27 @@ def save_from(conn, %{"instance_address" => address, "pack_name" => name} = data
Creates an empty pack named `name` which then can be updated via the admin UI. Creates an empty pack named `name` which then can be updated via the admin UI.
""" """
def create(conn, %{"name" => name}) do def create(conn, %{"name" => name}) do
pack_dir = Path.join(emoji_dir_path(), name) name = String.trim(name)
if not File.exists?(pack_dir) do with :ok <- Pack.create(name) do
File.mkdir_p!(pack_dir) json(conn, "ok")
pack_file_p = Path.join(pack_dir, "pack.json")
File.write!(
pack_file_p,
Jason.encode!(%{pack: %{}, files: %{}}, pretty: true)
)
conn |> json("ok")
else else
{:error, :eexist} ->
conn conn
|> put_status(:conflict) |> put_status(:conflict)
|> json(%{error: "A pack named \"#{name}\" already exists"}) |> json(%{error: "A pack named \"#{name}\" already exists"})
{:error, :empty_values} ->
conn
|> put_status(:bad_request)
|> json(%{error: "pack name cannot be empty"})
{:error, _} ->
render_error(
conn,
:internal_server_error,
"Unexpected error occurred while creating pack."
)
end end
end end
@ -321,11 +170,20 @@ def create(conn, %{"name" => name}) do
Deletes the pack `name` and all it's files. Deletes the pack `name` and all it's files.
""" """
def delete(conn, %{"name" => name}) do def delete(conn, %{"name" => name}) do
pack_dir = Path.join(emoji_dir_path(), name) name = String.trim(name)
case File.rm_rf(pack_dir) do with {:ok, deleted} when deleted != [] <- Pack.delete(name) do
{:ok, _} -> json(conn, "ok")
conn |> json("ok") else
{:ok, []} ->
conn
|> put_status(:not_found)
|> json(%{error: "Pack #{name} does not exist"})
{:error, :empty_values} ->
conn
|> put_status(:bad_request)
|> json(%{error: "pack name cannot be empty"})
{:error, _, _} -> {:error, _, _} ->
conn conn
@ -340,82 +198,23 @@ def delete(conn, %{"name" => name}) do
`new_data` is the new metadata for the pack, that will replace the old metadata. `new_data` is the new metadata for the pack, that will replace the old metadata.
""" """
def update_metadata(conn, %{"pack_name" => name, "new_data" => new_data}) do def update_metadata(conn, %{"pack_name" => name, "new_data" => new_data}) do
pack_file_p = Path.join([emoji_dir_path(), name, "pack.json"]) with {:ok, pack} <- Pack.update_metadata(name, new_data) do
json(conn, pack.pack)
full_pack = Jason.decode!(File.read!(pack_file_p))
# The new fallback-src is in the new data and it's not the same as it was in the old data
should_update_fb_sha =
not is_nil(new_data["fallback-src"]) and
new_data["fallback-src"] != full_pack["pack"]["fallback-src"]
with {_, true} <- {:should_update?, should_update_fb_sha},
%{body: pack_arch} <- Tesla.get!(new_data["fallback-src"]),
{:ok, flist} <- :zip.unzip(pack_arch, [:memory]),
{_, true} <- {:has_all_files?, has_all_files?(full_pack, flist)} do
fallback_sha = :crypto.hash(:sha256, pack_arch) |> Base.encode16()
new_data = Map.put(new_data, "fallback-src-sha256", fallback_sha)
update_metadata_and_send(conn, full_pack, new_data, pack_file_p)
else else
{:should_update?, _} ->
update_metadata_and_send(conn, full_pack, new_data, pack_file_p)
{:has_all_files?, _} -> {:has_all_files?, _} ->
conn conn
|> put_status(:bad_request) |> put_status(:bad_request)
|> json(%{error: "The fallback archive does not have all files specified in pack.json"}) |> json(%{error: "The fallback archive does not have all files specified in pack.json"})
{:error, _} ->
render_error(
conn,
:internal_server_error,
"Unexpected error occurred while updating pack metadata."
)
end end
end end
# Check if all files from the pack.json are in the archive
defp has_all_files?(%{"files" => files}, flist) do
Enum.all?(files, fn {_, from_manifest} ->
Enum.find(flist, fn {from_archive, _} ->
to_string(from_archive) == from_manifest
end)
end)
end
defp update_metadata_and_send(conn, full_pack, new_data, pack_file_p) do
full_pack = Map.put(full_pack, "pack", new_data)
File.write!(pack_file_p, Jason.encode!(full_pack, pretty: true))
# Send new data back with fallback sha filled
json(conn, new_data)
end
defp get_filename(%Plug.Upload{filename: filename}), do: filename
defp get_filename(url) when is_binary(url), do: Path.basename(url)
defp empty?(str), do: String.trim(str) == ""
defp update_pack_file(updated_full_pack, pack_file_p) do
content = Jason.encode!(updated_full_pack, pretty: true)
File.write!(pack_file_p, content)
end
defp create_subdirs(file_path) do
if String.contains?(file_path, "/") do
file_path
|> Path.dirname()
|> File.mkdir_p!()
end
end
defp pack_info(pack_name) do
dir = Path.join(emoji_dir_path(), pack_name)
json_path = Path.join(dir, "pack.json")
json =
json_path
|> File.read!()
|> Jason.decode!()
{dir, json_path, json}
end
@doc """ @doc """
Updates a file in a pack. Updates a file in a pack.
@ -436,50 +235,33 @@ def update_file(
conn, conn,
%{"pack_name" => pack_name, "action" => "add"} = params %{"pack_name" => pack_name, "action" => "add"} = params
) do ) do
shortcode = filename = params["filename"] || get_filename(params["file"])
if params["shortcode"] do shortcode = params["shortcode"] || Path.basename(filename, Path.extname(filename))
params["shortcode"]
with {:ok, pack} <- Pack.add_file(pack_name, shortcode, filename, params["file"]) do
json(conn, pack.files)
else else
filename = get_filename(params["file"]) {:exists, _} ->
Path.basename(filename, Path.extname(filename))
end
{pack_dir, pack_file_p, full_pack} = pack_info(pack_name)
with {_, false} <- {:has_shortcode, Map.has_key?(full_pack["files"], shortcode)},
filename <- params["filename"] || get_filename(params["file"]),
false <- empty?(shortcode),
false <- empty?(filename),
file_path <- Path.join(pack_dir, filename) do
# If the name contains directories, create them
create_subdirs(file_path)
case params["file"] do
%Plug.Upload{path: upload_path} ->
# Copy the uploaded file from the temporary directory
File.copy!(upload_path, file_path)
url when is_binary(url) ->
# Download and write the file
file_contents = Tesla.get!(url).body
File.write!(file_path, file_contents)
end
full_pack
|> put_in(["files", shortcode], filename)
|> update_pack_file(pack_file_p)
json(conn, %{shortcode => filename})
else
{:has_shortcode, _} ->
conn conn
|> put_status(:conflict) |> put_status(:conflict)
|> json(%{error: "An emoji with the \"#{shortcode}\" shortcode already exists"}) |> json(%{error: "An emoji with the \"#{shortcode}\" shortcode already exists"})
true -> {:loaded, _} ->
conn conn
|> put_status(:bad_request) |> put_status(:bad_request)
|> json(%{error: "shortcode or filename cannot be empty"}) |> json(%{error: "pack \"#{pack_name}\" is not found"})
{:error, :empty_values} ->
conn
|> put_status(:bad_request)
|> json(%{error: "pack name, shortcode or filename cannot be empty"})
{:error, _} ->
render_error(
conn,
:internal_server_error,
"Unexpected error occurred while adding file to pack."
)
end end
end end
@ -489,87 +271,74 @@ def update_file(conn, %{
"action" => "remove", "action" => "remove",
"shortcode" => shortcode "shortcode" => shortcode
}) do }) do
{pack_dir, pack_file_p, full_pack} = pack_info(pack_name) with {:ok, pack} <- Pack.remove_file(pack_name, shortcode) do
json(conn, pack.files)
if Map.has_key?(full_pack["files"], shortcode) do
{emoji_file_path, updated_full_pack} = pop_in(full_pack, ["files", shortcode])
emoji_file_path = Path.join(pack_dir, emoji_file_path)
# Delete the emoji file
File.rm!(emoji_file_path)
# If the old directory has no more files, remove it
if String.contains?(emoji_file_path, "/") do
dir = Path.dirname(emoji_file_path)
if Enum.empty?(File.ls!(dir)) do
File.rmdir!(dir)
end
end
update_pack_file(updated_full_pack, pack_file_p)
json(conn, %{shortcode => full_pack["files"][shortcode]})
else else
{:exists, _} ->
conn conn
|> put_status(:bad_request) |> put_status(:bad_request)
|> json(%{error: "Emoji \"#{shortcode}\" does not exist"}) |> json(%{error: "Emoji \"#{shortcode}\" does not exist"})
{:loaded, _} ->
conn
|> put_status(:bad_request)
|> json(%{error: "pack \"#{pack_name}\" is not found"})
{:error, :empty_values} ->
conn
|> put_status(:bad_request)
|> json(%{error: "pack name or shortcode cannot be empty"})
{:error, _} ->
render_error(
conn,
:internal_server_error,
"Unexpected error occurred while removing file from pack."
)
end end
end end
# Update # Update
def update_file( def update_file(
conn, conn,
%{"pack_name" => pack_name, "action" => "update", "shortcode" => shortcode} = params %{"pack_name" => name, "action" => "update", "shortcode" => shortcode} = params
) do ) do
{pack_dir, pack_file_p, full_pack} = pack_info(pack_name) new_shortcode = params["new_shortcode"]
new_filename = params["new_filename"]
force = params["force"] == true
with {_, true} <- {:has_shortcode, Map.has_key?(full_pack["files"], shortcode)}, with {:ok, pack} <- Pack.update_file(name, shortcode, new_shortcode, new_filename, force) do
%{"new_shortcode" => new_shortcode, "new_filename" => new_filename} <- params, json(conn, pack.files)
false <- empty?(new_shortcode),
false <- empty?(new_filename) do
# First, remove the old shortcode, saving the old path
{old_emoji_file_path, updated_full_pack} = pop_in(full_pack, ["files", shortcode])
old_emoji_file_path = Path.join(pack_dir, old_emoji_file_path)
new_emoji_file_path = Path.join(pack_dir, new_filename)
# If the name contains directories, create them
create_subdirs(new_emoji_file_path)
# Move/Rename the old filename to a new filename
# These are probably on the same filesystem, so just rename should work
:ok = File.rename(old_emoji_file_path, new_emoji_file_path)
# If the old directory has no more files, remove it
if String.contains?(old_emoji_file_path, "/") do
dir = Path.dirname(old_emoji_file_path)
if Enum.empty?(File.ls!(dir)) do
File.rmdir!(dir)
end
end
# Then, put in the new shortcode with the new path
updated_full_pack
|> put_in(["files", new_shortcode], new_filename)
|> update_pack_file(pack_file_p)
json(conn, %{new_shortcode => new_filename})
else else
{:has_shortcode, _} -> {:exists, _} ->
conn conn
|> put_status(:bad_request) |> put_status(:bad_request)
|> json(%{error: "Emoji \"#{shortcode}\" does not exist"}) |> json(%{error: "Emoji \"#{shortcode}\" does not exist"})
true -> {:not_used, _} ->
conn
|> put_status(:conflict)
|> json(%{
error:
"New shortcode \"#{new_shortcode}\" is already used. If you want to override emoji use 'force' option"
})
{:loaded, _} ->
conn
|> put_status(:bad_request)
|> json(%{error: "pack \"#{name}\" is not found"})
{:error, :empty_values} ->
conn conn
|> put_status(:bad_request) |> put_status(:bad_request)
|> json(%{error: "new_shortcode or new_filename cannot be empty"}) |> json(%{error: "new_shortcode or new_filename cannot be empty"})
_ -> {:error, _} ->
conn render_error(
|> put_status(:bad_request) conn,
|> json(%{error: "new_shortcode or new_file were not specified"}) :internal_server_error,
"Unexpected error occurred while updating file in pack."
)
end end
end end
@ -589,23 +358,12 @@ def update_file(conn, %{"action" => action}) do
neither, all the files with specific configured extenstions will be neither, all the files with specific configured extenstions will be
assumed to be emojis and stored in the new `pack.json` file. assumed to be emojis and stored in the new `pack.json` file.
""" """
def import_from_fs(conn, _params) do def import_from_fs(conn, _params) do
emoji_path = emoji_dir_path() with {:ok, names} <- Pack.import_from_filesystem() do
json(conn, names)
with {:ok, %{access: :read_write}} <- File.stat(emoji_path),
{:ok, results} <- File.ls(emoji_path) do
imported_pack_names =
results
|> Enum.filter(fn file ->
dir_path = Path.join(emoji_path, file)
# Find the directories that do NOT have pack.json
File.dir?(dir_path) and not File.exists?(Path.join(dir_path, "pack.json"))
end)
|> Enum.map(&write_pack_json_contents/1)
json(conn, imported_pack_names)
else else
{:ok, %{access: _}} -> {:error, :not_writable} ->
conn conn
|> put_status(:internal_server_error) |> put_status(:internal_server_error)
|> json(%{error: "Error: emoji pack directory must be writable"}) |> json(%{error: "Error: emoji pack directory must be writable"})
@ -617,44 +375,6 @@ def import_from_fs(conn, _params) do
end end
end end
defp write_pack_json_contents(dir) do defp get_filename(%Plug.Upload{filename: filename}), do: filename
dir_path = Path.join(emoji_dir_path(), dir) defp get_filename(url) when is_binary(url), do: Path.basename(url)
emoji_txt_path = Path.join(dir_path, "emoji.txt")
files_for_pack = files_for_pack(emoji_txt_path, dir_path)
pack_json_contents = Jason.encode!(%{pack: %{}, files: files_for_pack})
File.write!(Path.join(dir_path, "pack.json"), pack_json_contents)
dir
end
defp files_for_pack(emoji_txt_path, dir_path) do
if File.exists?(emoji_txt_path) do
# There's an emoji.txt file, it's likely from a pack installed by the pack manager.
# Make a pack.json file from the contents of that emoji.txt fileh
# FIXME: Copy-pasted from Pleroma.Emoji/load_from_file_stream/2
# Create a map of shortcodes to filenames from emoji.txt
File.read!(emoji_txt_path)
|> String.split("\n")
|> Enum.map(&String.trim/1)
|> Enum.map(fn line ->
case String.split(line, ~r/,\s*/) do
# This matches both strings with and without tags
# and we don't care about tags here
[name, file | _] -> {name, file}
_ -> nil
end
end)
|> Enum.filter(fn x -> not is_nil(x) end)
|> Enum.into(%{})
else
# If there's no emoji.txt, assume all files
# that are of certain extensions from the config are emojis and import them all
pack_extensions = Pleroma.Config.get!([:emoji, :pack_extensions])
Pleroma.Emoji.Loader.make_shortcode_to_file_map(dir_path, pack_extensions)
end
end
end end

View File

@ -221,12 +221,13 @@ defmodule Pleroma.Web.Router do
delete("/:name", EmojiAPIController, :delete) delete("/:name", EmojiAPIController, :delete)
# Note: /download_from downloads and saves to instance, not to requester # Note: /download_from downloads and saves to instance, not to requester
post("/download_from", EmojiAPIController, :save_from) post("/download_from", EmojiAPIController, :download_from)
end end
# Pack info / downloading # Pack info / downloading
scope "/packs" do scope "/packs" do
get("/", EmojiAPIController, :list_packs) get("/", EmojiAPIController, :list_packs)
get("/:name", EmojiAPIController, :show)
get("/:name/download_shared/", EmojiAPIController, :download_shared) get("/:name/download_shared/", EmojiAPIController, :download_shared)
get("/list_from", EmojiAPIController, :list_from) get("/list_from", EmojiAPIController, :list_from)

Binary file not shown.

After

Width:  |  Height:  |  Size: 95 B

View File

@ -0,0 +1,13 @@
{
"pack": {
"license": "Test license",
"homepage": "https://pleroma.social",
"description": "Test description",
"can-download": true,
"share-files": true,
"download-sha256": "57482F30674FD3DE821FF48C81C00DA4D4AF1F300209253684ABA7075E5FC238"
},
"files": {
"blank": "blank.png"
}
}

View File

@ -1,13 +1,11 @@
{ {
"pack": {
"license": "Test license",
"homepage": "https://pleroma.social",
"description": "Test description",
"share-files": true
},
"files": { "files": {
"blank": "blank.png" "blank": "blank.png"
},
"pack": {
"description": "Test description",
"homepage": "https://pleroma.social",
"license": "Test license",
"share-files": true
} }
} }

View File

@ -3,13 +3,10 @@
"license": "Test license", "license": "Test license",
"homepage": "https://pleroma.social", "homepage": "https://pleroma.social",
"description": "Test description", "description": "Test description",
"fallback-src": "https://nonshared-pack", "fallback-src": "https://nonshared-pack",
"fallback-src-sha256": "74409E2674DAA06C072729C6C8426C4CB3B7E0B85ED77792DB7A436E11D76DAF", "fallback-src-sha256": "74409E2674DAA06C072729C6C8426C4CB3B7E0B85ED77792DB7A436E11D76DAF",
"share-files": false "share-files": false
}, },
"files": { "files": {
"blank": "blank.png" "blank": "blank.png"
} }

View File

@ -8,41 +8,44 @@ defmodule Pleroma.Web.PleromaAPI.EmojiAPIControllerTest do
import Tesla.Mock import Tesla.Mock
import Pleroma.Factory import Pleroma.Factory
@emoji_dir_path Path.join( @emoji_path Path.join(
Pleroma.Config.get!([:instance, :static_dir]), Pleroma.Config.get!([:instance, :static_dir]),
"emoji" "emoji"
) )
setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false) setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)
test "shared & non-shared pack information in list_packs is ok" do setup do
conn = build_conn() admin = insert(:user, is_admin: true)
resp = conn |> get(emoji_api_path(conn, :list_packs)) |> json_response(200) token = insert(:oauth_admin_token, user: admin)
assert Map.has_key?(resp, "test_pack") admin_conn =
build_conn()
|> assign(:user, admin)
|> assign(:token, token)
pack = resp["test_pack"] Pleroma.Emoji.reload()
{:ok, %{admin_conn: admin_conn}}
assert Map.has_key?(pack["pack"], "download-sha256")
assert pack["pack"]["can-download"]
assert pack["files"] == %{"blank" => "blank.png"}
# Non-shared pack
assert Map.has_key?(resp, "test_pack_nonshared")
pack = resp["test_pack_nonshared"]
refute pack["pack"]["shared"]
refute pack["pack"]["can-download"]
end end
test "listing remote packs" do test "GET /api/pleroma/emoji/packs", %{conn: conn} do
conn = build_conn() resp = conn |> get("/api/pleroma/emoji/packs") |> json_response(200)
shared = resp["test_pack"]
assert shared["files"] == %{"blank" => "blank.png"}
assert Map.has_key?(shared["pack"], "download-sha256")
assert shared["pack"]["can-download"]
assert shared["pack"]["share-files"]
non_shared = resp["test_pack_nonshared"]
assert non_shared["pack"]["share-files"] == false
assert non_shared["pack"]["can-download"] == false
end
describe "POST /api/pleroma/emoji/packs/list_from" do
test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
resp = resp =
build_conn() conn
|> get(emoji_api_path(conn, :list_packs)) |> get("/api/pleroma/emoji/packs")
|> json_response(200) |> json_response(200)
mock(fn mock(fn
@ -56,17 +59,37 @@ test "listing remote packs" do
json(resp) json(resp)
end) end)
assert conn assert admin_conn
|> post(emoji_api_path(conn, :list_from), %{instance_address: "https://example.com"}) |> post("/api/pleroma/emoji/packs/list_from", %{
instance_address: "https://example.com"
})
|> json_response(200) == resp |> json_response(200) == resp
end end
test "downloading a shared pack from download_shared" do test "non shareable instance", %{admin_conn: admin_conn} do
conn = build_conn() mock(fn
%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: []}})
end)
assert admin_conn
|> post("/api/pleroma/emoji/packs/list_from", %{
instance_address: "https://example.com"
})
|> json_response(500) == %{
"error" => "The requested instance does not support sharing emoji packs"
}
end
end
describe "GET /api/pleroma/emoji/packs/:name/download_shared" do
test "download shared pack", %{conn: conn} do
resp = resp =
conn conn
|> get(emoji_api_path(conn, :download_shared, "test_pack")) |> get("/api/pleroma/emoji/packs/test_pack/download_shared")
|> response(200) |> response(200)
{:ok, arch} = :zip.unzip(resp, [:memory]) {:ok, arch} = :zip.unzip(resp, [:memory])
@ -75,19 +98,30 @@ test "downloading a shared pack from download_shared" do
assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end) assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
end end
test "downloading shared & unshared packs from another instance, deleting them" do test "non existing pack", %{conn: conn} do
on_exit(fn -> assert conn
File.rm_rf!("#{@emoji_dir_path}/test_pack2") |> get("/api/pleroma/emoji/packs/test_pack_for_import/download_shared")
File.rm_rf!("#{@emoji_dir_path}/test_pack_nonshared2") |> json_response(:not_found) == %{
end) "error" => "Pack test_pack_for_import does not exist"
}
end
test "non downloadable pack", %{conn: conn} do
assert conn
|> get("/api/pleroma/emoji/packs/test_pack_nonshared/download_shared")
|> json_response(: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_from" do
test "shared pack from remote and non shared from fallback-src", %{
admin_conn: admin_conn,
conn: conn
} do
mock(fn mock(fn
%{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://old-instance/nodeinfo/2.1.json"}]})
%{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: []}})
%{method: :get, url: "https://example.com/.well-known/nodeinfo"} -> %{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]}) json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
@ -96,124 +130,187 @@ test "downloading shared & unshared packs from another instance, deleting them"
%{ %{
method: :get, method: :get,
url: "https://example.com/api/pleroma/emoji/packs/list" url: "https://example.com/api/pleroma/emoji/packs/test_pack"
} -> } ->
conn = build_conn()
conn conn
|> get(emoji_api_path(conn, :list_packs)) |> get("/api/pleroma/emoji/packs/test_pack")
|> json_response(200) |> json_response(200)
|> json() |> json()
%{ %{
method: :get, method: :get,
url: "https://example.com/api/pleroma/emoji/packs/download_shared/test_pack" url: "https://example.com/api/pleroma/emoji/packs/test_pack/download_shared"
} -> } ->
conn = build_conn()
conn conn
|> get(emoji_api_path(conn, :download_shared, "test_pack")) |> get("/api/pleroma/emoji/packs/test_pack/download_shared")
|> response(200) |> response(200)
|> text() |> text()
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/test_pack_nonshared"
} ->
conn
|> get("/api/pleroma/emoji/packs/test_pack_nonshared")
|> json_response(200)
|> json()
%{ %{
method: :get, method: :get,
url: "https://nonshared-pack" url: "https://nonshared-pack"
} -> } ->
text(File.read!("#{@emoji_dir_path}/test_pack_nonshared/nonshared.zip")) text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
end) end)
admin = insert(:user, is_admin: true) assert admin_conn
|> post("/api/pleroma/emoji/packs/download_from", %{
conn =
build_conn()
|> assign(:user, admin)
|> assign(:token, insert(:oauth_admin_token, user: admin, scopes: ["admin:write"]))
assert (conn
|> put_req_header("content-type", "application/json")
|> post(
emoji_api_path(
conn,
:save_from
),
%{
instance_address: "https://old-instance",
pack_name: "test_pack",
as: "test_pack2"
}
|> Jason.encode!()
)
|> json_response(500))["error"] =~ "does not support"
assert conn
|> put_req_header("content-type", "application/json")
|> post(
emoji_api_path(
conn,
:save_from
),
%{
instance_address: "https://example.com", instance_address: "https://example.com",
pack_name: "test_pack", pack_name: "test_pack",
as: "test_pack2" as: "test_pack2"
} })
|> Jason.encode!()
)
|> json_response(200) == "ok" |> json_response(200) == "ok"
assert File.exists?("#{@emoji_dir_path}/test_pack2/pack.json") assert File.exists?("#{@emoji_path}/test_pack2/pack.json")
assert File.exists?("#{@emoji_dir_path}/test_pack2/blank.png") assert File.exists?("#{@emoji_path}/test_pack2/blank.png")
assert conn assert admin_conn
|> delete(emoji_api_path(conn, :delete, "test_pack2")) |> delete("/api/pleroma/emoji/packs/test_pack2")
|> json_response(200) == "ok" |> json_response(200) == "ok"
refute File.exists?("#{@emoji_dir_path}/test_pack2") refute File.exists?("#{@emoji_path}/test_pack2")
# non-shared, downloaded from the fallback URL assert admin_conn
assert conn
|> put_req_header("content-type", "application/json")
|> post( |> post(
emoji_api_path( "/api/pleroma/emoji/packs/download_from",
conn,
:save_from
),
%{ %{
instance_address: "https://example.com", instance_address: "https://example.com",
pack_name: "test_pack_nonshared", pack_name: "test_pack_nonshared",
as: "test_pack_nonshared2" as: "test_pack_nonshared2"
} }
|> Jason.encode!()
) )
|> json_response(200) == "ok" |> json_response(200) == "ok"
assert File.exists?("#{@emoji_dir_path}/test_pack_nonshared2/pack.json") assert File.exists?("#{@emoji_path}/test_pack_nonshared2/pack.json")
assert File.exists?("#{@emoji_dir_path}/test_pack_nonshared2/blank.png") assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")
assert conn assert admin_conn
|> delete(emoji_api_path(conn, :delete, "test_pack_nonshared2")) |> delete("/api/pleroma/emoji/packs/test_pack_nonshared2")
|> json_response(200) == "ok" |> json_response(200) == "ok"
refute File.exists?("#{@emoji_dir_path}/test_pack_nonshared2") refute File.exists?("#{@emoji_path}/test_pack_nonshared2")
end
test "nonshareable instance", %{admin_conn: admin_conn} do
mock(fn
%{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://old-instance/nodeinfo/2.1.json"}]})
%{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: []}})
end)
assert admin_conn
|> post(
"/api/pleroma/emoji/packs/download_from",
%{
instance_address: "https://old-instance",
pack_name: "test_pack",
as: "test_pack2"
}
)
|> json_response(500) == %{
"error" => "The requested instance does not support sharing emoji packs"
}
end
test "checksum fail", %{admin_conn: admin_conn} do
mock(fn
%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
%{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/pack_bad_sha"
} ->
%Tesla.Env{
status: 200,
body: Pleroma.Emoji.Pack.load_pack("pack_bad_sha") |> Jason.encode!()
}
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha/download_shared"
} ->
%Tesla.Env{
status: 200,
body: File.read!("test/instance_static/emoji/pack_bad_sha/pack_bad_sha.zip")
}
end)
assert admin_conn
|> post("/api/pleroma/emoji/packs/download_from", %{
instance_address: "https://example.com",
pack_name: "pack_bad_sha",
as: "pack_bad_sha2"
})
|> json_response(:internal_server_error) == %{
"error" => "SHA256 for the pack doesn't match the one sent by the server"
}
end
test "other error", %{admin_conn: admin_conn} do
mock(fn
%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
%{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/test_pack"
} ->
%Tesla.Env{
status: 200,
body: %{"test_pack" => Pleroma.Emoji.Pack.load_pack("test_pack")} |> Jason.encode!()
}
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/test_pack/download_shared"
} ->
%Tesla.Env{
status: 200,
body: File.read!("test/instance_static/emoji/test_pack/pack.json")
}
end)
assert admin_conn
|> post("/api/pleroma/emoji/packs/download_from", %{
instance_address: "https://example.com",
pack_name: "test_pack",
as: "test_pack2"
})
|> json_response(:internal_server_error) == %{
"error" =>
"The pack was not set as shared and there is no fallback src to download from"
}
end
end end
describe "updating pack metadata" do describe "updating pack metadata" do
setup do setup do
pack_file = "#{@emoji_dir_path}/test_pack/pack.json" pack_file = "#{@emoji_path}/test_pack/pack.json"
original_content = File.read!(pack_file) original_content = File.read!(pack_file)
on_exit(fn -> on_exit(fn ->
File.write!(pack_file, original_content) File.write!(pack_file, original_content)
end) end)
admin = insert(:user, is_admin: true)
%{conn: conn} = oauth_access(["admin:write"], user: admin)
{:ok, {:ok,
admin: admin,
conn: conn,
pack_file: pack_file, pack_file: pack_file,
new_data: %{ new_data: %{
"license" => "Test license changed", "license" => "Test license changed",
@ -224,11 +321,9 @@ test "downloading shared & unshared packs from another instance, deleting them"
end end
test "for a pack without a fallback source", ctx do test "for a pack without a fallback source", ctx do
conn = ctx[:conn] assert ctx[:admin_conn]
assert conn
|> post( |> post(
emoji_api_path(conn, :update_metadata, "test_pack"), "/api/pleroma/emoji/packs/test_pack/update_metadata",
%{ %{
"new_data" => ctx[:new_data] "new_data" => ctx[:new_data]
} }
@ -244,7 +339,7 @@ test "for a pack with a fallback source", ctx do
method: :get, method: :get,
url: "https://nonshared-pack" url: "https://nonshared-pack"
} -> } ->
text(File.read!("#{@emoji_dir_path}/test_pack_nonshared/nonshared.zip")) text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
end) end)
new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack") new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
@ -256,11 +351,9 @@ test "for a pack with a fallback source", ctx do
"74409E2674DAA06C072729C6C8426C4CB3B7E0B85ED77792DB7A436E11D76DAF" "74409E2674DAA06C072729C6C8426C4CB3B7E0B85ED77792DB7A436E11D76DAF"
) )
conn = ctx[:conn] assert ctx[:admin_conn]
assert conn
|> post( |> post(
emoji_api_path(conn, :update_metadata, "test_pack"), "/api/pleroma/emoji/packs/test_pack/update_metadata",
%{ %{
"new_data" => new_data "new_data" => new_data
} }
@ -282,37 +375,241 @@ test "when the fallback source doesn't have all the files", ctx do
new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack") new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
conn = ctx[:conn] assert ctx[:admin_conn]
assert (conn
|> post( |> post(
emoji_api_path(conn, :update_metadata, "test_pack"), "/api/pleroma/emoji/packs/test_pack/update_metadata",
%{ %{
"new_data" => new_data "new_data" => new_data
} }
) )
|> json_response(:bad_request))["error"] =~ "does not have all" |> json_response(:bad_request) == %{
"error" => "The fallback archive does not have all files specified in pack.json"
}
end end
end end
describe "update_file/2" do describe "POST /api/pleroma/emoji/packs/:pack_name/update_file" do
setup do setup do
pack_file = "#{@emoji_dir_path}/test_pack/pack.json" pack_file = "#{@emoji_path}/test_pack/pack.json"
original_content = File.read!(pack_file) original_content = File.read!(pack_file)
on_exit(fn -> on_exit(fn ->
File.write!(pack_file, original_content) File.write!(pack_file, original_content)
end) end)
admin = insert(:user, is_admin: true) :ok
%{conn: conn} = oauth_access(["admin:write"], user: admin)
{:ok, conn: conn}
end end
test "update file without shortcode", %{conn: conn} do test "create shortcode exists", %{admin_conn: admin_conn} do
on_exit(fn -> File.rm_rf!("#{@emoji_dir_path}/test_pack/shortcode.png") end) assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "add",
"shortcode" => "blank",
"filename" => "dir/blank.png",
"file" => %Plug.Upload{
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response(:conflict) == %{
"error" => "An emoji with the \"blank\" shortcode already exists"
}
end
assert conn test "don't rewrite old emoji", %{admin_conn: admin_conn} do
on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir/") end)
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "add",
"shortcode" => "blank2",
"filename" => "dir/blank.png",
"file" => %Plug.Upload{
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response(200) == %{"blank" => "blank.png", "blank2" => "dir/blank.png"}
assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "update",
"shortcode" => "blank",
"new_shortcode" => "blank2",
"new_filename" => "dir_2/blank_3.png"
})
|> json_response(:conflict) == %{
"error" =>
"New shortcode \"blank2\" is already used. If you want to override emoji use 'force' option"
}
end
test "rewrite old emoji with force option", %{admin_conn: admin_conn} do
on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir_2/") end)
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "add",
"shortcode" => "blank2",
"filename" => "dir/blank.png",
"file" => %Plug.Upload{
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response(200) == %{"blank" => "blank.png", "blank2" => "dir/blank.png"}
assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "update",
"shortcode" => "blank2",
"new_shortcode" => "blank3",
"new_filename" => "dir_2/blank_3.png",
"force" => true
})
|> json_response(200) == %{
"blank" => "blank.png",
"blank3" => "dir_2/blank_3.png"
}
assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
end
test "with empty filename", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "add",
"shortcode" => "blank2",
"filename" => "",
"file" => %Plug.Upload{
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response(:bad_request) == %{
"error" => "pack name, shortcode or filename cannot be empty"
}
end
test "add file with not loaded pack", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/not_loaded/update_file", %{
"action" => "add",
"shortcode" => "blank2",
"filename" => "dir/blank.png",
"file" => %Plug.Upload{
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response(:bad_request) == %{
"error" => "pack \"not_loaded\" is not found"
}
end
test "remove file with not loaded pack", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/not_loaded/update_file", %{
"action" => "remove",
"shortcode" => "blank3"
})
|> json_response(:bad_request) == %{"error" => "pack \"not_loaded\" is not found"}
end
test "remove file with empty shortcode", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/not_loaded/update_file", %{
"action" => "remove",
"shortcode" => ""
})
|> json_response(:bad_request) == %{
"error" => "pack name or shortcode cannot be empty"
}
end
test "update file with not loaded pack", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/not_loaded/update_file", %{
"action" => "update",
"shortcode" => "blank4",
"new_shortcode" => "blank3",
"new_filename" => "dir_2/blank_3.png"
})
|> json_response(:bad_request) == %{"error" => "pack \"not_loaded\" is not found"}
end
test "new with shortcode as file with update", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "add",
"shortcode" => "blank4",
"filename" => "dir/blank.png",
"file" => %Plug.Upload{
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response(200) == %{"blank" => "blank.png", "blank4" => "dir/blank.png"}
assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "update",
"shortcode" => "blank4",
"new_shortcode" => "blank3",
"new_filename" => "dir_2/blank_3.png"
})
|> json_response(200) == %{"blank3" => "dir_2/blank_3.png", "blank" => "blank.png"}
refute File.exists?("#{@emoji_path}/test_pack/dir/")
assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "remove",
"shortcode" => "blank3"
})
|> json_response(200) == %{"blank" => "blank.png"}
refute File.exists?("#{@emoji_path}/test_pack/dir_2/")
on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir") end)
end
test "new with shortcode from url", %{admin_conn: admin_conn} do
mock(fn
%{
method: :get,
url: "https://test-blank/blank_url.png"
} ->
text(File.read!("#{@emoji_path}/test_pack/blank.png"))
end)
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "add",
"shortcode" => "blank_url",
"file" => "https://test-blank/blank_url.png"
})
|> json_response(200) == %{
"blank_url" => "blank_url.png",
"blank" => "blank.png"
}
assert File.exists?("#{@emoji_path}/test_pack/blank_url.png")
on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/blank_url.png") end)
end
test "new without shortcode", %{admin_conn: admin_conn} do
on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/shortcode.png") end)
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{ |> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"action" => "add", "action" => "add",
"file" => %Plug.Upload{ "file" => %Plug.Upload{
@ -320,163 +617,176 @@ test "update file without shortcode", %{conn: conn} do
path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png" path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
} }
}) })
|> json_response(200) == %{"shortcode" => "shortcode.png"} |> json_response(200) == %{"shortcode" => "shortcode.png", "blank" => "blank.png"}
end end
test "updating pack files", %{conn: conn} do test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
on_exit(fn -> assert admin_conn
File.rm_rf!("#{@emoji_dir_path}/test_pack/blank_url.png") |> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
File.rm_rf!("#{@emoji_dir_path}/test_pack/dir") "action" => "remove",
File.rm_rf!("#{@emoji_dir_path}/test_pack/dir_2") "shortcode" => "blank2"
end) })
|> json_response(:bad_request) == %{"error" => "Emoji \"blank2\" does not exist"}
end
same_name = %{ test "update non existing emoji", %{admin_conn: admin_conn} do
"action" => "add", assert admin_conn
"shortcode" => "blank", |> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"filename" => "dir/blank.png",
"file" => %Plug.Upload{
filename: "blank.png",
path: "#{@emoji_dir_path}/test_pack/blank.png"
}
}
different_name = %{same_name | "shortcode" => "blank_2"}
assert (conn
|> post(emoji_api_path(conn, :update_file, "test_pack"), same_name)
|> json_response(:conflict))["error"] =~ "already exists"
assert conn
|> post(emoji_api_path(conn, :update_file, "test_pack"), different_name)
|> json_response(200) == %{"blank_2" => "dir/blank.png"}
assert File.exists?("#{@emoji_dir_path}/test_pack/dir/blank.png")
assert conn
|> post(emoji_api_path(conn, :update_file, "test_pack"), %{
"action" => "update", "action" => "update",
"shortcode" => "blank_2", "shortcode" => "blank2",
"new_shortcode" => "blank_3", "new_shortcode" => "blank3",
"new_filename" => "dir_2/blank_3.png" "new_filename" => "dir_2/blank_3.png"
}) })
|> json_response(200) == %{"blank_3" => "dir_2/blank_3.png"} |> json_response(:bad_request) == %{"error" => "Emoji \"blank2\" does not exist"}
end
refute File.exists?("#{@emoji_dir_path}/test_pack/dir/") test "update with empty shortcode", %{admin_conn: admin_conn} do
assert File.exists?("#{@emoji_dir_path}/test_pack/dir_2/blank_3.png") assert admin_conn
|> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
assert conn "action" => "update",
|> post(emoji_api_path(conn, :update_file, "test_pack"), %{ "shortcode" => "blank",
"action" => "remove", "new_filename" => "dir_2/blank_3.png"
"shortcode" => "blank_3"
}) })
|> json_response(200) == %{"blank_3" => "dir_2/blank_3.png"} |> json_response(:bad_request) == %{
"error" => "new_shortcode or new_filename cannot be empty"
refute File.exists?("#{@emoji_dir_path}/test_pack/dir_2/")
mock(fn
%{
method: :get,
url: "https://test-blank/blank_url.png"
} ->
text(File.read!("#{@emoji_dir_path}/test_pack/blank.png"))
end)
# The name should be inferred from the URL ending
from_url = %{
"action" => "add",
"shortcode" => "blank_url",
"file" => "https://test-blank/blank_url.png"
} }
end
assert conn test "undefined action", %{admin_conn: admin_conn} do
|> post(emoji_api_path(conn, :update_file, "test_pack"), from_url) assert admin_conn
|> json_response(200) == %{ |> post("/api/pleroma/emoji/packs/test_pack/update_file", %{
"blank_url" => "blank_url.png" "action" => "undefined"
}
assert File.exists?("#{@emoji_dir_path}/test_pack/blank_url.png")
assert conn
|> post(emoji_api_path(conn, :update_file, "test_pack"), %{
"action" => "remove",
"shortcode" => "blank_url"
}) })
|> json_response(200) == %{"blank_url" => "blank_url.png"} |> json_response(:bad_request) == %{
"error" => "Unknown action: undefined"
refute File.exists?("#{@emoji_dir_path}/test_pack/blank_url.png") }
end end
end end
test "creating and deleting a pack" do describe "PUT /api/pleroma/emoji/packs/:name" do
on_exit(fn -> test "creating and deleting a pack", %{admin_conn: admin_conn} do
File.rm_rf!("#{@emoji_dir_path}/test_created") assert admin_conn
end) |> put("/api/pleroma/emoji/packs/test_created")
admin = insert(:user, is_admin: true)
%{conn: conn} = oauth_access(["admin:write"], user: admin)
assert conn
|> put_req_header("content-type", "application/json")
|> put(
emoji_api_path(
conn,
:create,
"test_created"
)
)
|> json_response(200) == "ok" |> json_response(200) == "ok"
assert File.exists?("#{@emoji_dir_path}/test_created/pack.json") assert File.exists?("#{@emoji_path}/test_created/pack.json")
assert Jason.decode!(File.read!("#{@emoji_dir_path}/test_created/pack.json")) == %{ assert Jason.decode!(File.read!("#{@emoji_path}/test_created/pack.json")) == %{
"pack" => %{}, "pack" => %{},
"files" => %{} "files" => %{}
} }
assert conn assert admin_conn
|> delete(emoji_api_path(conn, :delete, "test_created")) |> delete("/api/pleroma/emoji/packs/test_created")
|> json_response(200) == "ok" |> json_response(200) == "ok"
refute File.exists?("#{@emoji_dir_path}/test_created/pack.json") refute File.exists?("#{@emoji_path}/test_created/pack.json")
end end
test "filesystem import" do test "if pack exists", %{admin_conn: admin_conn} do
path = Path.join(@emoji_path, "test_created")
File.mkdir(path)
pack_file = Jason.encode!(%{files: %{}, pack: %{}})
File.write!(Path.join(path, "pack.json"), pack_file)
assert admin_conn
|> put("/api/pleroma/emoji/packs/test_created")
|> json_response(:conflict) == %{
"error" => "A pack named \"test_created\" already exists"
}
on_exit(fn -> File.rm_rf(path) end)
end
test "with empty name", %{admin_conn: admin_conn} do
assert admin_conn
|> put("/api/pleroma/emoji/packs/ ")
|> json_response(:bad_request) == %{"error" => "pack name cannot be empty"}
end
end
test "deleting nonexisting pack", %{admin_conn: admin_conn} do
assert admin_conn
|> delete("/api/pleroma/emoji/packs/non_existing")
|> json_response(:not_found) == %{"error" => "Pack non_existing does not exist"}
end
test "deleting with empty name", %{admin_conn: admin_conn} do
assert admin_conn
|> delete("/api/pleroma/emoji/packs/ ")
|> json_response(:bad_request) == %{"error" => "pack name cannot be empty"}
end
test "filesystem import", %{admin_conn: admin_conn, conn: conn} do
on_exit(fn -> on_exit(fn ->
File.rm!("#{@emoji_dir_path}/test_pack_for_import/emoji.txt") File.rm!("#{@emoji_path}/test_pack_for_import/emoji.txt")
File.rm!("#{@emoji_dir_path}/test_pack_for_import/pack.json") File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
end) end)
conn = build_conn() resp = conn |> get("/api/pleroma/emoji/packs") |> json_response(200)
resp = conn |> get(emoji_api_path(conn, :list_packs)) |> json_response(200)
refute Map.has_key?(resp, "test_pack_for_import") refute Map.has_key?(resp, "test_pack_for_import")
admin = insert(:user, is_admin: true) assert admin_conn
%{conn: conn} = oauth_access(["admin:write"], user: admin) |> post("/api/pleroma/emoji/packs/import_from_fs")
assert conn
|> post(emoji_api_path(conn, :import_from_fs))
|> json_response(200) == ["test_pack_for_import"] |> json_response(200) == ["test_pack_for_import"]
resp = conn |> get(emoji_api_path(conn, :list_packs)) |> json_response(200) resp = conn |> get("/api/pleroma/emoji/packs") |> json_response(200)
assert resp["test_pack_for_import"]["files"] == %{"blank" => "blank.png"} assert resp["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}
File.rm!("#{@emoji_dir_path}/test_pack_for_import/pack.json") File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
refute File.exists?("#{@emoji_dir_path}/test_pack_for_import/pack.json") refute File.exists?("#{@emoji_path}/test_pack_for_import/pack.json")
emoji_txt_content = "blank, blank.png, Fun\n\nblank2, blank.png" emoji_txt_content = """
blank, blank.png, Fun
blank2, blank.png
foo, /emoji/test_pack_for_import/blank.png
bar
"""
File.write!("#{@emoji_dir_path}/test_pack_for_import/emoji.txt", emoji_txt_content) File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)
assert conn assert admin_conn
|> post(emoji_api_path(conn, :import_from_fs)) |> post("/api/pleroma/emoji/packs/import_from_fs")
|> json_response(200) == ["test_pack_for_import"] |> json_response(200) == ["test_pack_for_import"]
resp = build_conn() |> get(emoji_api_path(conn, :list_packs)) |> json_response(200) resp = conn |> get("/api/pleroma/emoji/packs") |> json_response(200)
assert resp["test_pack_for_import"]["files"] == %{ assert resp["test_pack_for_import"]["files"] == %{
"blank" => "blank.png", "blank" => "blank.png",
"blank2" => "blank.png" "blank2" => "blank.png",
"foo" => "blank.png"
} }
end end
describe "GET /api/pleroma/emoji/packs/:name" do
test "shows pack.json", %{conn: conn} do
assert %{
"files" => %{"blank" => "blank.png"},
"pack" => %{
"can-download" => true,
"description" => "Test description",
"download-sha256" => _,
"homepage" => "https://pleroma.social",
"license" => "Test license",
"share-files" => true
}
} =
conn
|> get("/api/pleroma/emoji/packs/test_pack")
|> json_response(200)
end
test "non existing pack", %{conn: conn} do
assert conn
|> get("/api/pleroma/emoji/packs/non_existing")
|> json_response(:not_found) == %{"error" => "Pack non_existing does not exist"}
end
test "error name", %{conn: conn} do
assert conn
|> get("/api/pleroma/emoji/packs/ ")
|> json_response(:bad_request) == %{"error" => "pack name cannot be empty"}
end
end
end end