@@ -68,7 +68,14 @@ defmodule Pleroma.Uploaders.Uploader do | |||
{:error, error} | |||
end | |||
after | |||
30_000 -> {:error, dgettext("errors", "Uploader callback timeout")} | |||
callback_timeout() -> {:error, dgettext("errors", "Uploader callback timeout")} | |||
end | |||
end | |||
defp callback_timeout do | |||
case Mix.env() do | |||
:test -> 1_000 | |||
_ -> 30_000 | |||
end | |||
end | |||
end |
@@ -11,10 +11,6 @@ defmodule Pleroma.Web.UploaderController do | |||
process_callback(conn, :global.whereis_name({Uploader, upload_path}), params) | |||
end | |||
def callbacks(conn, _) do | |||
render_error(conn, :bad_request, "bad request") | |||
end | |||
defp process_callback(conn, pid, params) when is_pid(pid) do | |||
send(pid, {Uploader, self(), conn, params}) | |||
@@ -42,19 +42,18 @@ defmodule Pleroma.DataCase do | |||
:ok | |||
end | |||
def ensure_local_uploader(_context) do | |||
def ensure_local_uploader(context) do | |||
test_uploader = Map.get(context, :uploader, Pleroma.Uploaders.Local) | |||
uploader = Pleroma.Config.get([Pleroma.Upload, :uploader]) | |||
filters = Pleroma.Config.get([Pleroma.Upload, :filters]) | |||
unless uploader == Pleroma.Uploaders.Local || filters != [] do | |||
Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local) | |||
Pleroma.Config.put([Pleroma.Upload, :filters], []) | |||
Pleroma.Config.put([Pleroma.Upload, :uploader], test_uploader) | |||
Pleroma.Config.put([Pleroma.Upload, :filters], []) | |||
on_exit(fn -> | |||
Pleroma.Config.put([Pleroma.Upload, :uploader], uploader) | |||
Pleroma.Config.put([Pleroma.Upload, :filters], filters) | |||
end) | |||
end | |||
on_exit(fn -> | |||
Pleroma.Config.put([Pleroma.Upload, :uploader], uploader) | |||
Pleroma.Config.put([Pleroma.Upload, :filters], filters) | |||
end) | |||
:ok | |||
end | |||
@@ -3,9 +3,96 @@ | |||
# SPDX-License-Identifier: AGPL-3.0-only | |||
defmodule Pleroma.UploadTest do | |||
alias Pleroma.Upload | |||
use Pleroma.DataCase | |||
alias Pleroma.Upload | |||
alias Pleroma.Uploaders.Uploader | |||
@upload_file %Plug.Upload{ | |||
content_type: "image/jpg", | |||
path: Path.absname("test/fixtures/image_tmp.jpg"), | |||
filename: "image.jpg" | |||
} | |||
defmodule TestUploaderBase do | |||
def put_file(%{path: path} = _upload, module_name) do | |||
task_pid = | |||
Task.async(fn -> | |||
:timer.sleep(10) | |||
{Uploader, path} | |||
|> :global.whereis_name() | |||
|> send({Uploader, self(), {:test}, %{}}) | |||
assert_receive {Uploader, {:test}}, 4_000 | |||
end) | |||
Agent.start(fn -> task_pid end, name: module_name) | |||
:wait_callback | |||
end | |||
end | |||
describe "Tried storing a file when http callback response success result" do | |||
defmodule TestUploaderSuccess do | |||
def http_callback(conn, _params), | |||
do: {:ok, conn, {:file, "post-process-file.jpg"}} | |||
def put_file(upload), do: TestUploaderBase.put_file(upload, __MODULE__) | |||
end | |||
setup do: [uploader: TestUploaderSuccess] | |||
setup [:ensure_local_uploader] | |||
test "it returns file" do | |||
File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg") | |||
assert Upload.store(@upload_file) == | |||
{:ok, | |||
%{ | |||
"name" => "image.jpg", | |||
"type" => "Document", | |||
"url" => [ | |||
%{ | |||
"href" => "http://localhost:4001/media/post-process-file.jpg", | |||
"mediaType" => "image/jpeg", | |||
"type" => "Link" | |||
} | |||
] | |||
}} | |||
Task.await(Agent.get(TestUploaderSuccess, fn task_pid -> task_pid end)) | |||
end | |||
end | |||
describe "Tried storing a file when http callback response error" do | |||
defmodule TestUploaderError do | |||
def http_callback(conn, _params), do: {:error, conn, "Errors"} | |||
def put_file(upload), do: TestUploaderBase.put_file(upload, __MODULE__) | |||
end | |||
setup do: [uploader: TestUploaderError] | |||
setup [:ensure_local_uploader] | |||
test "it returns error" do | |||
File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg") | |||
assert Upload.store(@upload_file) == {:error, "Errors"} | |||
Task.await(Agent.get(TestUploaderError, fn task_pid -> task_pid end)) | |||
end | |||
end | |||
describe "Tried storing a file when http callback doesn't response by timeout" do | |||
defmodule(TestUploader, do: def(put_file(_upload), do: :wait_callback)) | |||
setup do: [uploader: TestUploader] | |||
setup [:ensure_local_uploader] | |||
test "it returns error" do | |||
File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg") | |||
assert Upload.store(@upload_file) == {:error, "Uploader callback timeout"} | |||
end | |||
end | |||
describe "Storing a file with the Local uploader" do | |||
setup [:ensure_local_uploader] | |||
@@ -0,0 +1,43 @@ | |||
# Pleroma: A lightweight social networking server | |||
# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/> | |||
# SPDX-License-Identifier: AGPL-3.0-only | |||
defmodule Pleroma.Web.UploaderControllerTest do | |||
use Pleroma.Web.ConnCase | |||
alias Pleroma.Uploaders.Uploader | |||
describe "callback/2" do | |||
test "it returns 400 response when process callback isn't alive", %{conn: conn} do | |||
res = | |||
conn | |||
|> post(uploader_path(conn, :callback, "test-path")) | |||
assert res.status == 400 | |||
assert res.resp_body == "{\"error\":\"bad request\"}" | |||
end | |||
test "it returns success result", %{conn: conn} do | |||
task = | |||
Task.async(fn -> | |||
receive do | |||
{Uploader, pid, conn, _params} -> | |||
conn = | |||
conn | |||
|> put_status(:ok) | |||
|> Phoenix.Controller.json(%{upload_path: "test-path"}) | |||
send(pid, {Uploader, conn}) | |||
end | |||
end) | |||
:global.register_name({Uploader, "test-path"}, task.pid) | |||
res = | |||
conn | |||
|> post(uploader_path(conn, :callback, "test-path")) | |||
|> json_response(200) | |||
assert res == %{"upload_path" => "test-path"} | |||
end | |||
end | |||
end |