pleroma/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs

855 lines
30 KiB
Elixir
Raw Normal View History

2019-09-30 03:28:12 -04:00
# Pleroma: A lightweight social networking server
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
2019-09-30 03:28:12 -04:00
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.PleromaAPI.EmojiPackControllerTest do
2019-08-12 03:35:34 -04:00
use Pleroma.Web.ConnCase
import Tesla.Mock
import Pleroma.Factory
2020-03-28 06:34:32 -04:00
@emoji_path Path.join(
Pleroma.Config.get!([:instance, :static_dir]),
"emoji"
)
setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)
2020-03-28 06:34:32 -04:00
setup do
admin = insert(:user, is_admin: true)
token = insert(:oauth_admin_token, user: admin)
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
admin_conn =
build_conn()
|> assign(:user, admin)
|> assign(:token, token)
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
Pleroma.Emoji.reload()
{:ok, %{admin_conn: admin_conn}}
end
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
test "GET /api/pleroma/emoji/packs", %{conn: conn} do
resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
2019-08-12 03:35:34 -04:00
assert resp["count"] == 3
2020-06-20 03:56:28 -04:00
assert resp["packs"]
|> Map.keys()
|> length() == 3
shared = resp["packs"]["test_pack"]
2020-06-18 11:50:03 -04:00
assert shared["files"] == %{"blank" => "blank.png", "blank2" => "blank2.png"}
2020-03-28 06:34:32 -04:00
assert Map.has_key?(shared["pack"], "download-sha256")
assert shared["pack"]["can-download"]
assert shared["pack"]["share-files"]
2019-08-12 03:35:34 -04:00
non_shared = resp["packs"]["test_pack_nonshared"]
2020-03-28 06:34:32 -04:00
assert non_shared["pack"]["share-files"] == false
assert non_shared["pack"]["can-download"] == false
2020-06-18 07:32:21 -04:00
resp =
conn
|> get("/api/pleroma/emoji/packs?page_size=1")
|> json_response_and_validate_schema(200)
assert resp["count"] == 3
2020-06-20 03:56:28 -04:00
packs = Map.keys(resp["packs"])
assert length(packs) == 1
[pack1] = packs
2020-06-18 07:32:21 -04:00
resp =
conn
|> get("/api/pleroma/emoji/packs?page_size=1&page=2")
|> json_response_and_validate_schema(200)
assert resp["count"] == 3
2020-06-20 03:56:28 -04:00
packs = Map.keys(resp["packs"])
assert length(packs) == 1
[pack2] = packs
2020-06-18 07:32:21 -04:00
resp =
conn
|> get("/api/pleroma/emoji/packs?page_size=1&page=3")
|> json_response_and_validate_schema(200)
assert resp["count"] == 3
2020-06-20 03:56:28 -04:00
packs = Map.keys(resp["packs"])
assert length(packs) == 1
[pack3] = packs
2020-06-18 07:32:21 -04:00
assert [pack1, pack2, pack3] |> Enum.uniq() |> length() == 3
2020-03-28 06:34:32 -04:00
end
2019-08-12 03:35:34 -04:00
describe "GET /api/pleroma/emoji/packs/remote" do
2020-03-28 06:34:32 -04:00
test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
resp =
conn
|> get("/api/pleroma/emoji/packs")
|> json_response_and_validate_schema(200)
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
mock(fn
%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: ["shareable_emoji_packs"]}})
2020-03-28 06:34:32 -04:00
%{method: :get, url: "https://example.com/api/pleroma/emoji/packs"} ->
json(resp)
end)
2020-03-28 06:34:32 -04:00
assert admin_conn
|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
|> json_response_and_validate_schema(200) == resp
2020-03-28 06:34:32 -04:00
end
2020-03-28 06:34:32 -04:00
test "non shareable instance", %{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"}]})
2020-03-28 06:34:32 -04:00
%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: []}})
end)
2020-03-28 06:34:32 -04:00
assert admin_conn
|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
|> json_response_and_validate_schema(500) == %{
2020-03-28 06:34:32 -04:00
"error" => "The requested instance does not support sharing emoji packs"
}
end
end
describe "GET /api/pleroma/emoji/packs/:name/archive" do
2020-03-28 06:34:32 -04:00
test "download shared pack", %{conn: conn} do
resp =
conn
|> get("/api/pleroma/emoji/packs/test_pack/archive")
2020-03-28 06:34:32 -04:00
|> response(200)
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
{:ok, arch} = :zip.unzip(resp, [:memory])
assert Enum.find(arch, fn {n, _} -> n == 'pack.json' end)
assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
end
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
test "non existing pack", %{conn: conn} do
assert conn
|> get("/api/pleroma/emoji/packs/test_pack_for_import/archive")
|> json_response_and_validate_schema(:not_found) == %{
2020-03-28 06:34:32 -04:00
"error" => "Pack test_pack_for_import does not exist"
}
end
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
test "non downloadable pack", %{conn: conn} do
assert conn
|> get("/api/pleroma/emoji/packs/test_pack_nonshared/archive")
|> json_response_and_validate_schema(:forbidden) == %{
2020-03-28 06:34:32 -04:00
"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
2019-08-12 03:35:34 -04:00
end
describe "POST /api/pleroma/emoji/packs/download" do
2020-03-28 06:34:32 -04:00
test "shared pack from remote and non shared from fallback-src", %{
admin_conn: admin_conn,
conn: conn
} do
mock(fn
%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: ["shareable_emoji_packs"]}})
2020-03-28 06:34:32 -04:00
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/test_pack"
} ->
conn
|> get("/api/pleroma/emoji/packs/test_pack")
|> json_response_and_validate_schema(200)
2020-03-28 06:34:32 -04:00
|> json()
2020-03-28 06:34:32 -04:00
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/test_pack/archive"
2020-03-28 06:34:32 -04:00
} ->
conn
|> get("/api/pleroma/emoji/packs/test_pack/archive")
2020-03-28 06:34:32 -04:00
|> response(200)
|> text()
2020-03-28 06:34:32 -04:00
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/test_pack_nonshared"
} ->
conn
|> get("/api/pleroma/emoji/packs/test_pack_nonshared")
|> json_response_and_validate_schema(200)
2020-03-28 06:34:32 -04:00
|> json()
2020-03-28 06:34:32 -04:00
%{
method: :get,
url: "https://nonshared-pack"
} ->
text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
end)
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post("/api/pleroma/emoji/packs/download", %{
url: "https://example.com",
name: "test_pack",
2020-03-28 06:34:32 -04:00
as: "test_pack2"
})
|> json_response_and_validate_schema(200) == "ok"
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_pack2/pack.json")
assert File.exists?("#{@emoji_path}/test_pack2/blank.png")
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
assert admin_conn
|> delete("/api/pleroma/emoji/packs/test_pack2")
|> json_response_and_validate_schema(200) == "ok"
2020-03-28 06:34:32 -04:00
refute File.exists?("#{@emoji_path}/test_pack2")
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
2020-03-28 06:34:32 -04:00
|> post(
"/api/pleroma/emoji/packs/download",
2020-03-28 06:34:32 -04:00
%{
url: "https://example.com",
name: "test_pack_nonshared",
2020-03-28 06:34:32 -04:00
as: "test_pack_nonshared2"
}
)
|> json_response_and_validate_schema(200) == "ok"
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_pack_nonshared2/pack.json")
assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")
assert admin_conn
|> delete("/api/pleroma/emoji/packs/test_pack_nonshared2")
|> json_response_and_validate_schema(200) == "ok"
2020-03-28 06:34:32 -04:00
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
|> put_req_header("content-type", "multipart/form-data")
2020-03-28 06:34:32 -04:00
|> post(
"/api/pleroma/emoji/packs/download",
2020-03-28 06:34:32 -04:00
%{
url: "https://old-instance",
name: "test_pack",
2020-03-28 06:34:32 -04:00
as: "test_pack2"
}
)
|> json_response_and_validate_schema(500) == %{
2020-03-28 06:34:32 -04:00
"error" => "The requested instance does not support sharing emoji packs"
2019-08-12 03:35:34 -04:00
}
2020-03-28 06:34:32 -04:00
end
2019-08-12 03:35:34 -04:00
2020-03-28 06:34:32 -04:00
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"}]})
2020-03-28 06:34:32 -04:00
%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
json(%{metadata: %{features: ["shareable_emoji_packs"]}})
2020-03-28 06:34:32 -04:00
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha"
} ->
2020-05-18 11:43:23 -04:00
{:ok, pack} = Pleroma.Emoji.Pack.load_pack("pack_bad_sha")
%Tesla.Env{status: 200, body: Jason.encode!(pack)}
2020-03-28 06:34:32 -04:00
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha/archive"
2020-03-28 06:34:32 -04:00
} ->
%Tesla.Env{
status: 200,
body: File.read!("test/instance_static/emoji/pack_bad_sha/pack_bad_sha.zip")
}
end)
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post("/api/pleroma/emoji/packs/download", %{
url: "https://example.com",
name: "pack_bad_sha",
2020-03-28 06:34:32 -04:00
as: "pack_bad_sha2"
})
|> json_response_and_validate_schema(:internal_server_error) == %{
2020-03-28 06:34:32 -04:00
"error" => "SHA256 for the pack doesn't match the one sent by the server"
}
2020-03-28 06:34:32 -04:00
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"]}})
2020-03-28 06:34:32 -04:00
%{
method: :get,
url: "https://example.com/api/pleroma/emoji/packs/test_pack"
} ->
2020-05-18 11:43:23 -04:00
{:ok, pack} = Pleroma.Emoji.Pack.load_pack("test_pack")
%Tesla.Env{status: 200, body: Jason.encode!(pack)}
2020-03-28 06:34:32 -04:00
end)
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post("/api/pleroma/emoji/packs/download", %{
url: "https://example.com",
name: "test_pack",
2020-03-28 06:34:32 -04:00
as: "test_pack2"
})
|> json_response_and_validate_schema(:internal_server_error) == %{
2020-03-28 06:34:32 -04:00
"error" =>
"The pack was not set as shared and there is no fallback src to download from"
}
end
2019-08-16 06:22:14 -04:00
end
describe "PATCH /api/pleroma/emoji/packs/:name" do
2019-08-16 06:22:14 -04:00
setup do
2020-03-28 06:34:32 -04:00
pack_file = "#{@emoji_path}/test_pack/pack.json"
2019-08-16 06:22:14 -04:00
original_content = File.read!(pack_file)
on_exit(fn ->
File.write!(pack_file, original_content)
end)
{:ok,
pack_file: pack_file,
new_data: %{
"license" => "Test license changed",
"homepage" => "https://pleroma.social",
"description" => "Test description",
"share-files" => false
}}
end
test "for a pack without a fallback source", ctx do
2020-03-28 06:34:32 -04:00
assert ctx[:admin_conn]
|> put_req_header("content-type", "multipart/form-data")
|> patch("/api/pleroma/emoji/packs/test_pack", %{"metadata" => ctx[:new_data]})
|> json_response_and_validate_schema(200) == ctx[:new_data]
2019-08-16 06:22:14 -04:00
assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == ctx[:new_data]
end
test "for a pack with a fallback source", ctx do
mock(fn
%{
method: :get,
url: "https://nonshared-pack"
} ->
2020-03-28 06:34:32 -04:00
text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
2019-08-16 06:22:14 -04:00
end)
new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
new_data_with_sha =
Map.put(
new_data,
"fallback-src-sha256",
2020-06-18 11:50:03 -04:00
"1967BB4E42BCC34BCC12D57BE7811D3B7BE52F965BCE45C87BD377B9499CE11D"
2019-08-16 06:22:14 -04:00
)
2020-03-28 06:34:32 -04:00
assert ctx[:admin_conn]
|> put_req_header("content-type", "multipart/form-data")
|> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
|> json_response_and_validate_schema(200) == new_data_with_sha
2019-08-16 06:22:14 -04:00
assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
end
test "when the fallback source doesn't have all the files", ctx do
mock(fn
%{
method: :get,
url: "https://nonshared-pack"
} ->
{:ok, {'empty.zip', empty_arch}} = :zip.zip('empty.zip', [], [:memory])
text(empty_arch)
end)
new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
2020-03-28 06:34:32 -04:00
assert ctx[:admin_conn]
|> put_req_header("content-type", "multipart/form-data")
|> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
|> json_response_and_validate_schema(:bad_request) == %{
2020-03-28 06:34:32 -04:00
"error" => "The fallback archive does not have all files specified in pack.json"
}
2019-08-16 06:22:14 -04:00
end
2019-08-12 03:35:34 -04:00
end
describe "POST/PATCH/DELETE /api/pleroma/emoji/packs/:name/files" do
2020-02-06 10:01:12 -05:00
setup do
2020-03-28 06:34:32 -04:00
pack_file = "#{@emoji_path}/test_pack/pack.json"
2020-02-06 10:01:12 -05:00
original_content = File.read!(pack_file)
2020-02-06 10:01:12 -05:00
on_exit(fn ->
File.write!(pack_file, original_content)
end)
2020-03-28 06:34:32 -04:00
:ok
end
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/test_pack/files", %{
shortcode: "blank",
filename: "dir/blank.png",
file: %Plug.Upload{
2020-03-28 06:34:32 -04:00
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response_and_validate_schema(:conflict) == %{
2020-03-28 06:34:32 -04:00
"error" => "An emoji with the \"blank\" shortcode already exists"
}
2020-02-06 10:01:12 -05:00
end
2020-03-28 06:34:32 -04:00
test "don't rewrite old emoji", %{admin_conn: admin_conn} do
on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir/") end)
2020-02-06 10:01:12 -05:00
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post("/api/pleroma/emoji/packs/test_pack/files", %{
2020-06-18 11:50:03 -04:00
shortcode: "blank3",
filename: "dir/blank.png",
file: %Plug.Upload{
2020-03-28 06:34:32 -04:00
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
2020-02-06 10:01:12 -05:00
}
})
|> json_response_and_validate_schema(200) == %{
"blank" => "blank.png",
2020-06-18 11:50:03 -04:00
"blank2" => "blank2.png",
"blank3" => "dir/blank.png"
}
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
shortcode: "blank",
new_shortcode: "blank2",
new_filename: "dir_2/blank_3.png"
2020-03-28 06:34:32 -04:00
})
|> json_response_and_validate_schema(:conflict) == %{
2020-03-28 06:34:32 -04:00
"error" =>
"New shortcode \"blank2\" is already used. If you want to override emoji use 'force' option"
}
2020-02-06 10:01:12 -05:00
end
2020-03-28 06:34:32 -04:00
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)
2020-02-06 10:01:12 -05:00
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post("/api/pleroma/emoji/packs/test_pack/files", %{
2020-06-18 11:50:03 -04:00
shortcode: "blank3",
filename: "dir/blank.png",
file: %Plug.Upload{
2020-03-28 06:34:32 -04:00
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response_and_validate_schema(200) == %{
"blank" => "blank.png",
2020-06-18 11:50:03 -04:00
"blank2" => "blank2.png",
"blank3" => "dir/blank.png"
}
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
2020-06-18 11:50:03 -04:00
shortcode: "blank3",
new_shortcode: "blank4",
new_filename: "dir_2/blank_3.png",
force: true
2020-03-28 06:34:32 -04:00
})
|> json_response_and_validate_schema(200) == %{
2020-03-28 06:34:32 -04:00
"blank" => "blank.png",
2020-06-18 11:50:03 -04:00
"blank2" => "blank2.png",
"blank4" => "dir_2/blank_3.png"
2020-03-28 06:34:32 -04:00
}
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
end
2020-03-28 06:34:32 -04:00
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/test_pack/files", %{
shortcode: "blank2",
filename: "",
file: %Plug.Upload{
2020-03-28 06:34:32 -04:00
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response_and_validate_schema(:bad_request) == %{
2020-03-28 06:34:32 -04:00
"error" => "pack name, shortcode or filename cannot be empty"
}
end
2020-03-28 06:34:32 -04:00
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/not_loaded/files", %{
2020-06-18 11:50:03 -04:00
shortcode: "blank3",
filename: "dir/blank.png",
file: %Plug.Upload{
2020-03-28 06:34:32 -04:00
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response_and_validate_schema(:bad_request) == %{
2020-03-28 06:34:32 -04:00
"error" => "pack \"not_loaded\" is not found"
}
end
test "remove file with not loaded pack", %{admin_conn: admin_conn} do
assert admin_conn
|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=blank3")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack \"not_loaded\" is not found"
}
2020-03-28 06:34:32 -04:00
end
test "remove file with empty shortcode", %{admin_conn: admin_conn} do
assert admin_conn
|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=")
|> json_response_and_validate_schema(:bad_request) == %{
2020-03-28 06:34:32 -04:00
"error" => "pack name or shortcode cannot be empty"
}
end
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/not_loaded/files", %{
shortcode: "blank4",
new_shortcode: "blank3",
new_filename: "dir_2/blank_3.png"
2020-03-28 06:34:32 -04:00
})
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack \"not_loaded\" is not found"
}
2020-03-28 06:34:32 -04:00
end
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/test_pack/files", %{
shortcode: "blank4",
filename: "dir/blank.png",
file: %Plug.Upload{
2020-03-28 06:34:32 -04:00
filename: "blank.png",
path: "#{@emoji_path}/test_pack/blank.png"
}
})
|> json_response_and_validate_schema(200) == %{
"blank" => "blank.png",
2020-06-18 11:50:03 -04:00
"blank4" => "dir/blank.png",
"blank2" => "blank2.png"
}
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
shortcode: "blank4",
new_shortcode: "blank3",
new_filename: "dir_2/blank_3.png"
2020-02-06 10:01:12 -05:00
})
|> json_response_and_validate_schema(200) == %{
"blank3" => "dir_2/blank_3.png",
2020-06-18 11:50:03 -04:00
"blank" => "blank.png",
"blank2" => "blank2.png"
}
2020-03-28 06:34:32 -04:00
refute File.exists?("#{@emoji_path}/test_pack/dir/")
assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
2020-03-28 06:34:32 -04:00
assert admin_conn
|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
2020-06-18 11:50:03 -04:00
|> json_response_and_validate_schema(200) == %{
"blank" => "blank.png",
"blank2" => "blank2.png"
}
2020-03-28 06:34:32 -04:00
refute File.exists?("#{@emoji_path}/test_pack/dir_2/")
2020-03-28 06:34:32 -04:00
on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir") end)
end
2020-03-28 06:34:32 -04:00
test "new with shortcode from url", %{admin_conn: admin_conn} do
2020-02-06 10:01:12 -05:00
mock(fn
%{
method: :get,
url: "https://test-blank/blank_url.png"
} ->
2020-03-28 06:34:32 -04:00
text(File.read!("#{@emoji_path}/test_pack/blank.png"))
2020-02-06 10:01:12 -05:00
end)
2020-03-28 06:34:32 -04:00
assert admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> post("/api/pleroma/emoji/packs/test_pack/files", %{
shortcode: "blank_url",
file: "https://test-blank/blank_url.png"
2020-03-28 06:34:32 -04:00
})
|> json_response_and_validate_schema(200) == %{
2020-03-28 06:34:32 -04:00
"blank_url" => "blank_url.png",
2020-06-18 11:50:03 -04:00
"blank" => "blank.png",
"blank2" => "blank2.png"
2020-02-06 10:01:12 -05:00
}
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_pack/blank_url.png")
2020-03-28 06:34:32 -04:00
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
|> put_req_header("content-type", "multipart/form-data")
|> post("/api/pleroma/emoji/packs/test_pack/files", %{
file: %Plug.Upload{
2020-03-28 06:34:32 -04:00
filename: "shortcode.png",
path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
}
})
|> json_response_and_validate_schema(200) == %{
"shortcode" => "shortcode.png",
2020-06-18 11:50:03 -04:00
"blank" => "blank.png",
"blank2" => "blank2.png"
}
2020-03-28 06:34:32 -04:00
end
test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
assert admin_conn
2020-06-18 11:50:03 -04:00
|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
|> json_response_and_validate_schema(:bad_request) == %{
2020-06-18 11:50:03 -04:00
"error" => "Emoji \"blank3\" does not exist"
}
2020-03-28 06:34:32 -04:00
end
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/test_pack/files", %{
2020-06-18 11:50:03 -04:00
shortcode: "blank3",
new_shortcode: "blank4",
new_filename: "dir_2/blank_3.png"
2020-02-06 10:01:12 -05:00
})
|> json_response_and_validate_schema(:bad_request) == %{
2020-06-18 11:50:03 -04:00
"error" => "Emoji \"blank3\" does not exist"
}
2020-03-28 06:34:32 -04:00
end
test "update with empty shortcode", %{admin_conn: admin_conn} do
assert %{
"error" => "Missing field: new_shortcode."
} =
admin_conn
|> put_req_header("content-type", "multipart/form-data")
|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
shortcode: "blank",
new_filename: "dir_2/blank_3.png"
})
|> json_response_and_validate_schema(:bad_request)
2020-03-28 06:34:32 -04:00
end
end
describe "POST/DELETE /api/pleroma/emoji/packs/:name" do
2020-03-28 06:34:32 -04:00
test "creating and deleting a pack", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/test_created")
|> json_response_and_validate_schema(200) == "ok"
2020-03-28 06:34:32 -04:00
assert File.exists?("#{@emoji_path}/test_created/pack.json")
assert Jason.decode!(File.read!("#{@emoji_path}/test_created/pack.json")) == %{
"pack" => %{},
"files" => %{},
"files_count" => 0
2020-03-28 06:34:32 -04:00
}
2020-03-28 06:34:32 -04:00
assert admin_conn
|> delete("/api/pleroma/emoji/packs/test_created")
|> json_response_and_validate_schema(200) == "ok"
2020-03-28 06:34:32 -04:00
refute File.exists?("#{@emoji_path}/test_created/pack.json")
end
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
|> post("/api/pleroma/emoji/packs/test_created")
|> json_response_and_validate_schema(:conflict) == %{
2020-03-28 06:34:32 -04:00
"error" => "A pack named \"test_created\" already exists"
}
on_exit(fn -> File.rm_rf(path) end)
end
2020-03-28 06:34:32 -04:00
test "with empty name", %{admin_conn: admin_conn} do
assert admin_conn
|> post("/api/pleroma/emoji/packs/ ")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack name cannot be empty"
}
2020-03-28 06:34:32 -04:00
end
end
test "deleting nonexisting pack", %{admin_conn: admin_conn} do
assert admin_conn
|> delete("/api/pleroma/emoji/packs/non_existing")
|> json_response_and_validate_schema(:not_found) == %{
"error" => "Pack non_existing does not exist"
}
2020-03-28 06:34:32 -04:00
end
2020-03-28 06:34:32 -04:00
test "deleting with empty name", %{admin_conn: admin_conn} do
assert admin_conn
|> delete("/api/pleroma/emoji/packs/ ")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack name cannot be empty"
}
end
2020-03-28 06:34:32 -04:00
test "filesystem import", %{admin_conn: admin_conn, conn: conn} do
on_exit(fn ->
2020-03-28 06:34:32 -04:00
File.rm!("#{@emoji_path}/test_pack_for_import/emoji.txt")
File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
end)
resp = conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
refute Map.has_key?(resp["packs"], "test_pack_for_import")
2020-03-28 06:34:32 -04:00
assert admin_conn
|> get("/api/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)
assert resp["packs"]["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}
2020-03-28 06:34:32 -04:00
File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
refute File.exists?("#{@emoji_path}/test_pack_for_import/pack.json")
2020-03-28 06:34:32 -04:00
emoji_txt_content = """
blank, blank.png, Fun
blank2, blank.png
foo, /emoji/test_pack_for_import/blank.png
bar
"""
2020-03-28 06:34:32 -04:00
File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)
2020-03-28 06:34:32 -04:00
assert admin_conn
|> get("/api/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)
assert resp["packs"]["test_pack_for_import"]["files"] == %{
"blank" => "blank.png",
2020-03-28 06:34:32 -04:00
"blank2" => "blank.png",
"foo" => "blank.png"
}
end
2020-03-28 06:34:32 -04:00
describe "GET /api/pleroma/emoji/packs/:name" do
test "shows pack.json", %{conn: conn} do
assert %{
2020-06-18 11:50:03 -04:00
"files" => files,
"files_count" => 2,
2020-03-28 06:34:32 -04:00
"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_and_validate_schema(200)
2020-06-18 11:50:03 -04:00
assert files == %{"blank" => "blank.png", "blank2" => "blank2.png"}
assert %{
"files" => files,
"files_count" => 2
2020-06-18 11:50:03 -04:00
} =
conn
|> get("/api/pleroma/emoji/packs/test_pack?page_size=1")
|> json_response_and_validate_schema(200)
assert files |> Map.keys() |> length() == 1
assert %{
"files" => files,
"files_count" => 2
2020-06-18 11:50:03 -04:00
} =
conn
|> get("/api/pleroma/emoji/packs/test_pack?page_size=1&page=2")
|> json_response_and_validate_schema(200)
assert files |> Map.keys() |> length() == 1
2020-03-28 06:34:32 -04:00
end
test "non existing pack", %{conn: conn} do
assert conn
|> get("/api/pleroma/emoji/packs/non_existing")
|> json_response_and_validate_schema(:not_found) == %{
"error" => "Pack non_existing does not exist"
}
2020-03-28 06:34:32 -04:00
end
test "error name", %{conn: conn} do
assert conn
|> get("/api/pleroma/emoji/packs/ ")
|> json_response_and_validate_schema(:bad_request) == %{
"error" => "pack name cannot be empty"
}
2020-03-28 06:34:32 -04:00
end
end
2019-08-12 03:35:34 -04:00
end