No OneTemporary
Actions

Authored By

Unknown

Size

20 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/pleroma/upload_test.exs b/test/pleroma/upload_test.exs
	index f52d4dff6..cea161d8c 100644
	--- a/test/pleroma/upload_test.exs
	+++ b/test/pleroma/upload_test.exs
	@@ -1,255 +1,255 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UploadTest do
	use Pleroma.DataCase

	import ExUnit.CaptureLog

	alias Pleroma.Upload
	alias Pleroma.Uploaders.Uploader

	@upload_file %Plug.Upload{
	content_type: "image/jpeg",
	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",
	"mediaType" => "image/jpeg",
	"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 capture_log(fn ->
	assert Upload.store(@upload_file) == {:error, "Errors"}
	Task.await(Agent.get(TestUploaderError, fn task_pid -> task_pid end))
	end) =~
	"[error] Elixir.Pleroma.Upload store (using Pleroma.UploadTest.TestUploaderError) failed: \"Errors\""
	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 capture_log(fn ->
	assert Upload.store(@upload_file) == {:error, "Uploader callback timeout"}
	end) =~
	"[error] Elixir.Pleroma.Upload store (using Pleroma.UploadTest.TestUploader) failed: \"Uploader callback timeout\""
	end
	end

	describe "Storing a file with the Local uploader" do
	setup [:ensure_local_uploader]

	test "does not allow descriptions longer than the post limit" do
	clear_config([:instance, :description_limit], 2)
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: "image.jpg"
	}

	{:error, :description_too_long} = Upload.store(file, description: "123")
	end

	test "returns a media url" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: "image.jpg"
	}

	{:ok, data} = Upload.store(file)

	assert %{"url" => [%{"href" => url}]} = data

	assert String.starts_with?(url, Pleroma.Web.base_url() <> "/media/")
	end

	test "copies the file to the configured folder with deduping" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: "an [image.jpg"
	}

	{:ok, data} = Upload.store(file, filters: [Pleroma.Upload.Filter.Dedupe])

	assert List.first(data["url"])["href"] ==
	- Pleroma.Web.base_url() <>
	- "/media/e30397b58d226d6583ab5b8b3c5defb0c682bda5c31ef07a9f57c1c4986e3781.jpg"
	+ Pleroma.Upload.base_url() <>
	+ "e30397b58d226d6583ab5b8b3c5defb0c682bda5c31ef07a9f57c1c4986e3781.jpg"
	end

	test "copies the file to the configured folder without deduping" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: "an [image.jpg"
	}

	{:ok, data} = Upload.store(file)
	assert data["name"] == "an [image.jpg"
	end

	test "fixes incorrect content type when base64 is given" do
	params = %{
	img: "data:image/png;base64,#{Base.encode64(File.read!("test/fixtures/image.jpg"))}"
	}

	{:ok, data} = Upload.store(params)
	assert hd(data["url"])["mediaType"] == "image/jpeg"
	end

	test "adds extension when base64 is given" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	params = %{
	img: "data:image/png;base64,#{Base.encode64(File.read!("test/fixtures/image.jpg"))}"
	}

	{:ok, data} = Upload.store(params)
	assert String.ends_with?(data["name"], ".jpg")
	end

	test "copies the file to the configured folder with anonymizing filename" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: "an [image.jpg"
	}

	{:ok, data} = Upload.store(file, filters: [Pleroma.Upload.Filter.AnonymizeFilename])

	refute data["name"] == "an [image.jpg"
	end

	test "escapes invalid characters in url" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: "an… image.jpg"
	}

	{:ok, data} = Upload.store(file)
	[attachment_url \| _] = data["url"]

	assert Path.basename(attachment_url["href"]) == "an%E2%80%A6%20image.jpg"
	end

	test "escapes reserved uri characters" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: ":?#[]@!$&\\'()*+,;=.jpg"
	}

	{:ok, data} = Upload.store(file)
	[attachment_url \| _] = data["url"]

	assert Path.basename(attachment_url["href"]) ==
	"%3A%3F%23%5B%5D%40%21%24%26%5C%27%28%29%2A%2B%2C%3B%3D.jpg"
	end
	end

	describe "Setting a custom base_url for uploaded media" do
	setup do: clear_config([Pleroma.Upload, :base_url], "https://cache.pleroma.social")

	test "returns a media url with configured base_url" do
	base_url = Pleroma.Config.get([Pleroma.Upload, :base_url])

	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	filename: "image.jpg"
	}

	{:ok, data} = Upload.store(file, base_url: base_url)

	assert %{"url" => [%{"href" => url}]} = data

	refute String.starts_with?(url, base_url <> "/media/")
	end
	end
	end
	diff --git a/test/pleroma/uploaders/s3_test.exs b/test/pleroma/uploaders/s3_test.exs
	index 344cf7abe..f399f8ae5 100644
	--- a/test/pleroma/uploaders/s3_test.exs
	+++ b/test/pleroma/uploaders/s3_test.exs
	@@ -1,93 +1,98 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Uploaders.S3Test do
	use Pleroma.DataCase

	alias Pleroma.Config
	alias Pleroma.Uploaders.S3

	import Mock
	import ExUnit.CaptureLog

	setup do
	clear_config(Pleroma.Upload,
	uploader: Pleroma.Uploaders.S3
	)

	+ clear_config(Pleroma.Upload,
	+ base_url: "https://s3.amazonaws.com"
	+ )
	+
	clear_config(Pleroma.Uploaders.S3,
	- bucket: "test_bucket",
	- public_endpoint: "https://s3.amazonaws.com"
	+ bucket: "test_bucket"
	)
	end

	describe "get_file/1" do
	test "it returns path to local folder for files" do
	assert S3.get_file("test_image.jpg") == {
	:ok,
	{:url, "https://s3.amazonaws.com/test_bucket/test_image.jpg"}
	}
	end

	test "it returns path without bucket when truncated_namespace set to ''" do
	Config.put([Pleroma.Uploaders.S3],
	bucket: "test_bucket",
	- public_endpoint: "https://s3.amazonaws.com",
	truncated_namespace: ""
	)

	+ Config.put([Pleroma.Upload], base_url: "https://s3.amazonaws.com")
	+
	assert S3.get_file("test_image.jpg") == {
	:ok,
	{:url, "https://s3.amazonaws.com/test_image.jpg"}
	}
	end

	test "it returns path with bucket namespace when namespace is set" do
	Config.put([Pleroma.Uploaders.S3],
	bucket: "test_bucket",
	- public_endpoint: "https://s3.amazonaws.com",
	bucket_namespace: "family"
	)

	+ Config.put([Pleroma.Upload], base_url: "https://s3.amazonaws.com")
	+
	assert S3.get_file("test_image.jpg") == {
	:ok,
	{:url, "https://s3.amazonaws.com/family:test_bucket/test_image.jpg"}
	}
	end
	end

	describe "put_file/1" do
	setup do
	file_upload = %Pleroma.Upload{
	name: "image-tet.jpg",
	content_type: "image/jpeg",
	path: "test_folder/image-tet.jpg",
	tempfile: Path.absname("test/instance_static/add/shortcode.png")
	}

	[file_upload: file_upload]
	end

	test "save file", %{file_upload: file_upload} do
	with_mock ExAws, request: fn _ -> {:ok, :ok} end do
	assert S3.put_file(file_upload) == {:ok, {:file, "test_folder/image-tet.jpg"}}
	end
	end

	test "returns error", %{file_upload: file_upload} do
	with_mock ExAws, request: fn _ -> {:error, "S3 Upload failed"} end do
	assert capture_log(fn ->
	assert S3.put_file(file_upload) == {:error, "S3 Upload failed"}
	end) =~ "Elixir.Pleroma.Uploaders.S3: {:error, \"S3 Upload failed\"}"
	end
	end
	end

	describe "delete_file/1" do
	test_with_mock "deletes file", ExAws, request: fn _req -> {:ok, %{status_code: 204}} end do
	assert :ok = S3.delete_file("image.jpg")
	assert_called(ExAws.request(:_))
	end
	end
	end
	diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
	index f68e4a029..01a1ed962 100644
	--- a/test/pleroma/user/backup_test.exs
	+++ b/test/pleroma/user/backup_test.exs
	@@ -1,244 +1,244 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.BackupTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	import Mock
	import Pleroma.Factory
	import Swoosh.TestAssertions

	alias Pleroma.Bookmark
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User.Backup
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.BackupWorker

	setup do
	clear_config([Pleroma.Upload, :uploader])
	clear_config([Backup, :limit_days])
	clear_config([Pleroma.Emails.Mailer, :enabled], true)
	end

	test "it requries enabled email" do
	Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
	user = insert(:user)
	assert {:error, "Backups require enabled email"} == Backup.create(user)
	end

	test "it requries user's email" do
	user = insert(:user, %{email: nil})
	assert {:error, "Email is required"} == Backup.create(user)
	end

	test "it creates a backup record and an Oban job" do
	%{id: user_id} = user = insert(:user)
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	assert_enqueued(worker: BackupWorker, args: args)

	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup
	end

	test "it return an error if the export limit is over" do
	%{id: user_id} = user = insert(:user)
	limit_days = Pleroma.Config.get([Backup, :limit_days])
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup

	assert Backup.create(user) == {:error, "Last export was less than #{limit_days} days ago"}
	end

	test "it process a backup record" do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	delete_job_args = %{"op" => "delete", "backup_id" => backup_id}

	assert_enqueued(worker: BackupWorker, args: delete_job_args)
	assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
	refute Backup.get(backup_id)

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert_email_sent(
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it removes outdated backups after creating a fresh one" do
	Pleroma.Config.put([Backup, :limit_days], -1)
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	user = insert(:user)

	assert {:ok, job1} = Backup.create(user)

	assert {:ok, %Backup{}} = ObanHelpers.perform(job1)
	assert {:ok, job2} = Backup.create(user)
	assert Pleroma.Repo.aggregate(Backup, :count) == 2
	assert {:ok, backup2} = ObanHelpers.perform(job2)

	ObanHelpers.perform_all()

	assert [^backup2] = Pleroma.Repo.all(Backup)
	end

	test "it creates a zip archive with user data" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	{:ok, %{object: %{data: %{"id" => id1}}} = status1} =
	CommonAPI.post(user, %{status: "status1"})

	{:ok, %{object: %{data: %{"id" => id2}}} = status2} =
	CommonAPI.post(user, %{status: "status2"})

	{:ok, %{object: %{data: %{"id" => id3}}} = status3} =
	CommonAPI.post(user, %{status: "status3"})

	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)

	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup)
	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(path), [:memory])
	assert {:ok, {'actor.json', json}} = :zip.zip_get('actor.json', zipfile)

	assert %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{"@language" => "und"}
	],
	"bookmarks" => "bookmarks.json",
	"followers" => "http://cofe.io/users/cofe/followers",
	"following" => "http://cofe.io/users/cofe/following",
	"id" => "http://cofe.io/users/cofe",
	"inbox" => "http://cofe.io/users/cofe/inbox",
	"likes" => "likes.json",
	"name" => "Cofe",
	"outbox" => "http://cofe.io/users/cofe/outbox",
	"preferredUsername" => "cofe",
	"publicKey" => %{
	"id" => "http://cofe.io/users/cofe#main-key",
	"owner" => "http://cofe.io/users/cofe"
	},
	"type" => "Person",
	"url" => "http://cofe.io/users/cofe"
	} = Jason.decode!(json)

	assert {:ok, {'outbox.json', json}} = :zip.zip_get('outbox.json', zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "outbox.json",
	"orderedItems" => [
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status1",
	"type" => "Note"
	},
	"type" => "Create"
	},
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status2"
	}
	},
	%{
	"actor" => "http://cofe.io/users/cofe",
	"object" => %{
	"content" => "status3"
	}
	}
	],
	"totalItems" => 3,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {'likes.json', json}} = :zip.zip_get('likes.json', zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "likes.json",
	"orderedItems" => [^id1, ^id2],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	assert {:ok, {'bookmarks.json', json}} = :zip.zip_get('bookmarks.json', zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "bookmarks.json",
	"orderedItems" => [^id2, ^id3],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	:zip.zip_close(zipfile)
	File.rm!(path)
	end

	describe "it uploads and deletes a backup archive" do
	setup do
	clear_config(Pleroma.Uploaders.S3,
	- bucket: "test_bucket",
	- public_endpoint: "https://s3.amazonaws.com"
	+ bucket: "test_bucket"
	)

	clear_config([Pleroma.Upload, :uploader])
	+ clear_config([Pleroma.Upload, base_url: "https://s3.amazonaws.com"])

	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	{:ok, status1} = CommonAPI.post(user, %{status: "status1"})
	{:ok, status2} = CommonAPI.post(user, %{status: "status2"})
	{:ok, status3} = CommonAPI.post(user, %{status: "status3"})
	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)
	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup)

	[path: path, backup: backup]
	end

	test "S3", %{path: path, backup: backup} do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)

	with_mock ExAws,
	request: fn
	%{http_method: :put} -> {:ok, :ok}
	%{http_method: :delete} -> {:ok, %{status_code: 204}}
	end do
	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end

	with_mock ExAws, request: fn %{http_method: :delete} -> {:ok, %{status_code: 204}} end do
	end
	end

	test "Local", %{path: path, backup: backup} do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 4:41 AM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799470
Default Alt Text: (20 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions