No OneTemporary
Actions

Authored By

Unknown

Size

28 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/user/backup.ex b/lib/pleroma/user/backup.ex
	index c6927eada..c01eb20a9 100644
	--- a/lib/pleroma/user/backup.ex
	+++ b/lib/pleroma/user/backup.ex
	@@ -1,417 +1,423 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.Backup do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	import Pleroma.Web.Gettext

	require Logger
	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	- alias Pleroma.Config
	alias Pleroma.Chat
	+ alias Pleroma.Config
	alias Pleroma.Repo
	alias Pleroma.SafeZip
	alias Pleroma.Uploaders.Uploader
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Workers.BackupWorker

	@type t :: %__MODULE__{}

	schema "backups" do
	field(:content_type, :string)
	field(:file_name, :string)
	field(:file_size, :integer, default: 0)
	field(:processed, :boolean, default: false)
	field(:tempdir, :string)

	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)

	timestamps()
	end

	@doc """
	Schedules a job to backup a user if the number of backup requests has not exceeded the limit.

	Admins can directly call new/1 and schedule_backup/1 to bypass the limit.
	"""
	@spec user(User.t()) :: {:ok, t()} \| {:error, any()}
	def user(user) do
	days = Config.get([__MODULE__, :limit_days])

	with true <- permitted?(user),
	%__MODULE__{} = backup <- new(user),
	{:ok, inserted_backup} <- Repo.insert(backup),
	{:ok, %Oban.Job{}} <- schedule_backup(inserted_backup) do
	{:ok, inserted_backup}
	else
	false ->
	{:error,
	dngettext(
	"errors",
	"Last export was less than a day ago",
	"Last export was less than %{days} days ago",
	days,
	days: days
	)}

	e ->
	{:error, e}
	end
	end

	@doc "Generates a %Backup{} for a user with a random file name"
	@spec new(User.t()) :: t()
	def new(user) do
	rand_str = :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false)
	datetime = Calendar.NaiveDateTime.Format.iso8601_basic(NaiveDateTime.utc_now())
	name = "archive-#{user.nickname}-#{datetime}-#{rand_str}.zip"

	%__MODULE__{
	content_type: "application/zip",
	file_name: name,
	tempdir: tempdir(),
	user: user
	}
	end

	@doc "Schedules the execution of the provided backup"
	@spec schedule_backup(t()) :: {:ok, Oban.Job.t()} \| {:error, any()}
	def schedule_backup(backup) do
	with false <- is_nil(backup.id) do
	%{"op" => "process", "backup_id" => backup.id}
	\|> BackupWorker.new()
	\|> Oban.insert()
	else
	true ->
	{:error, "Backup is missing id. Please insert it into the Repo first."}
	end
	end

	@doc "Deletes the backup archive file and removes the database record"
	@spec delete_archive(t()) :: {:ok, Ecto.Schema.t()} \| {:error, Ecto.Changeset.t()}
	def delete_archive(backup) do
	uploader = Config.get([Pleroma.Upload, :uploader])

	with :ok <- uploader.delete_file(Path.join("backups", backup.file_name)) do
	Repo.delete(backup)
	end
	end

	@doc "Schedules a job to delete the backup archive"
	@spec schedule_delete(t()) :: {:ok, Oban.Job.t()} \| {:error, any()}
	def schedule_delete(backup) do
	days = Config.get([__MODULE__, :purge_after_days])
	time = 60 * 60 * 24 * days
	scheduled_at = Calendar.NaiveDateTime.add!(backup.inserted_at, time)

	%{"op" => "delete", "backup_id" => backup.id}
	\|> BackupWorker.new(scheduled_at: scheduled_at)
	\|> Oban.insert()
	end

	defp permitted?(user) do
	with {_, %__MODULE__{inserted_at: inserted_at}} <- {:last, get_last(user)} do
	days = Config.get([__MODULE__, :limit_days])
	diff = Timex.diff(NaiveDateTime.utc_now(), inserted_at, :days)

	diff > days
	else
	{:last, nil} -> true
	end
	end

	@doc "Returns last backup for the provided user"
	@spec get_last(User.t()) :: t()
	def get_last(%User{id: user_id}) do
	__MODULE__
	\|> where(user_id: ^user_id)
	\|> order_by(desc: :id)
	\|> limit(1)
	\|> Repo.one()
	end

	@doc "Lists all existing backups for a user"
	@spec list(User.t()) :: [Ecto.Schema.t() \| term()]
	def list(%User{id: user_id}) do
	__MODULE__
	\|> where(user_id: ^user_id)
	\|> order_by(desc: :id)
	\|> Repo.all()
	end

	@doc "Schedules deletion of all but the the most recent backup"
	@spec remove_outdated(User.t()) :: :ok
	def remove_outdated(user) do
	with %__MODULE__{} = latest_backup <- get_last(user) do
	__MODULE__
	\|> where(user_id: ^user.id)
	\|> where([b], b.id != ^latest_backup.id)
	\|> Repo.all()
	\|> Enum.each(&schedule_delete/1)
	else
	_ -> :ok
	end
	end

	def get_by_id(id), do: Repo.get(__MODULE__, id)

	@doc "Generates changeset for %Pleroma.User.Backup{}"
	@spec changeset(%__MODULE__{}, map()) :: %Ecto.Changeset{}
	def changeset(backup \\ %__MODULE__{}, attrs) do
	backup
	\|> cast(attrs, [:content_type, :file_name, :file_size, :processed, :tempdir])
	end

	@doc "Updates the backup record"
	@spec update_record(%__MODULE__{}, map()) :: {:ok, %__MODULE__{}} \| {:error, %Ecto.Changeset{}}
	def update_record(%__MODULE__{} = backup, attrs) do
	backup
	\|> changeset(attrs)
	\|> Repo.update()
	end

	- @files [
	- "actor.json",
	- "outbox.json",
	- "likes.json",
	- "bookmarks.json",
	- "followers.json",
	- "following.json",
	- 'chats.json',
	- 'chat_messages.json'
	- ]
	+ defp files(%{id: user_id}) do
	+ [
	+ "actor.json",
	+ "outbox.json",
	+ "likes.json",
	+ "bookmarks.json",
	+ "followers.json",
	+ "following.json",
	+ "chats.json"
	+ ] ++
	+ (Chat.for_user_query(user_id)
	+ \|> Repo.all()
	+ \|> Enum.map(fn ch -> "#{chat_file(ch)}.json" end))
	+ end

	@spec run(t()) :: {:ok, t()} \| {:error, :failed}
	def run(%__MODULE__{} = backup) do
	backup = Repo.preload(backup, :user)
	tempfile = Path.join([backup.tempdir, backup.file_name])

	with {_, :ok} <- {:mkdir, Pleroma.Backports.mkdir_p(backup.tempdir)},
	{_, :ok} <- {:actor, actor(backup.tempdir, backup.user)},
	{_, :ok} <- {:statuses, statuses(backup.tempdir, backup.user)},
	{_, :ok} <- {:likes, likes(backup.tempdir, backup.user)},
	{_, :ok} <- {:bookmarks, bookmarks(backup.tempdir, backup.user)},
	{_, :ok} <- {:followers, followers(backup.tempdir, backup.user)},
	{_, :ok} <- {:following, following(backup.tempdir, backup.user)},
	- {_, :ok} <- chats(dir, backup.user, caller_pid),
	- {_, :ok} <- chat_messages(dir, backup.user, caller_pid),
	+ {_, :ok} <- {:chats, chats(backup.tempdir, backup.user)},
	+ {_, :ok} <- {:chat_messages, chat_messages(backup.tempdir, backup.user)},
	{_, {:ok, _zip_path}} <-
	- {:zip, SafeZip.zip(tempfile, @files, backup.tempdir)},
	+ {:zip, SafeZip.zip(tempfile, files(backup.user), backup.tempdir)},
	{_, {:ok, %File.Stat{size: zip_size}}} <- {:filestat, File.stat(tempfile)},
	{:ok, updated_backup} <- update_record(backup, %{file_size: zip_size}) do
	{:ok, updated_backup}
	else
	_ ->
	File.rm_rf(backup.tempdir)
	{:error, :failed}
	end
	end

	defp tempdir do
	rand = :crypto.strong_rand_bytes(8) \|> Base.url_encode64(padding: false)
	subdir = "backup-#{rand}"

	case Config.get([__MODULE__, :tempdir]) do
	nil ->
	Path.join([System.tmp_dir!(), subdir])

	path ->
	Path.join([path, subdir])
	end
	end

	@doc "Uploads the completed backup and marks it as processed"
	@spec upload(t()) :: {:ok, t()}
	def upload(%__MODULE__{tempdir: tempdir} = backup) when is_binary(tempdir) do
	uploader = Config.get([Pleroma.Upload, :uploader])

	upload = %Pleroma.Upload{
	name: backup.file_name,
	tempfile: Path.join([tempdir, backup.file_name]),
	content_type: backup.content_type,
	path: Path.join("backups", backup.file_name)
	}

	with {:ok, _} <- Uploader.put_file(uploader, upload),
	{:ok, uploaded_backup} <- update_record(backup, %{processed: true}),
	{:ok, _} <- File.rm_rf(tempdir) do
	{:ok, uploaded_backup}
	end
	end

	defp actor(dir, user) do
	with {:ok, json} <-
	UserView.render("user.json", %{user: user})
	\|> Map.merge(%{
	"bookmarks" => "bookmarks.json",
	"likes" => "likes.json",
	"outbox" => "outbox.json",
	"followers" => "followers.json",
	"following" => "following.json"
	})
	\|> Jason.encode() do
	File.write(Path.join(dir, "actor.json"), json)
	end
	end

	defp write_header(file, name) do
	IO.write(
	file,
	"""
	{
	"@context": "https://www.w3.org/ns/activitystreams",
	"id": "#{name}.json",
	"type": "OrderedCollection",
	"orderedItems": [

	"""
	)
	end

	defp write(query, dir, name, fun) do
	path = Path.join(dir, "#{name}.json")

	chunk_size = Config.get([__MODULE__, :process_chunk_size])

	with {:ok, file} <- File.open(path, [:write, :utf8]),
	:ok <- write_header(file, name) do
	total =
	query
	\|> Pleroma.Repo.chunk_stream(chunk_size, _returns_as = :one, timeout: :infinity)
	\|> Enum.reduce(0, fn i, acc ->
	with {:ok, data} <-
	(try do
	fun.(i)
	rescue
	e -> {:error, e}
	end),
	{:ok, str} <- Jason.encode(data),
	:ok <- IO.write(file, str <> ",\n") do
	acc + 1
	else
	{:error, e} ->
	Logger.warning(
	"Error processing backup item: #{inspect(e)}\n The item is: #{inspect(i)}"
	)

	acc
	end
	end)

	with :ok <- :file.pwrite(file, {:eof, -2}, "\n],\n \"totalItems\": #{total}}") do
	File.close(file)
	end
	end
	end

	defp bookmarks(dir, %{id: user_id} = _user) do
	Bookmark
	\|> where(user_id: ^user_id)
	\|> join(:inner, [b], activity in assoc(b, :activity))
	\|> select([b, a], %{id: b.id, object: fragment("(?)->>'object'", a.data)})
	\|> write(dir, "bookmarks", fn a -> {:ok, a.object} end)
	end

	defp likes(dir, user) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> select([like], %{id: like.id, object: fragment("(?)->>'object'", like.data)})
	\|> write(dir, "likes", fn a -> {:ok, a.object} end)
	end

	defp statuses(dir, user) do
	opts =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:actor_id, user.ap_id)

	[
	[Pleroma.Constants.as_public(), user.ap_id],
	User.following(user),
	Pleroma.List.memberships(user)
	]
	\|> Enum.concat()
	\|> ActivityPub.fetch_activities_query(opts)
	\|> write(
	dir,
	"outbox",
	fn a ->
	with {:ok, activity} <- Transmogrifier.prepare_outgoing(a.data) do
	{:ok, Map.delete(activity, "@context")}
	end
	end
	)
	end

	- defp chats(dir, user, caller_pid) do
	+ defp chat_file(%{:id => chat_id}), do: "chat_messages_#{chat_id}"
	+
	+ defp chats(dir, user) do
	Chat.for_user_query(user.id)
	\|> write(
	dir,
	"chats",
	fn chat ->
	{:ok,
	%{
	"type" => "Chat",
	"id" => "#{Pleroma.Web.Endpoint.url()}/chats/#{chat.id}",
	"actor" => user.ap_id,
	"to" => [chat.recipient],
	"published" =>
	- chat.inserted_at \|> DateTime.from_naive!("Etc/UTC") \|> DateTime.to_iso8601()
	+ chat.inserted_at \|> DateTime.from_naive!("Etc/UTC") \|> DateTime.to_iso8601(),
	+ "messages" => "#{chat_file(chat)}.json"
	}}
	- end,
	- caller_pid
	+ end
	)
	end

	- defp chat_messages(dir, %{id: user_id}, caller_pid) do
	- chats_subquery =
	- from(c in Chat,
	- where: c.user_id == ^user_id,
	- select: c.id
	- )
	+ defp chat_messages(dir, %{id: user_id}) do
	+ results =
	+ Chat.for_user_query(user_id)
	+ \|> Repo.all()
	+ \|> Enum.map(fn ch ->
	+ from(
	+ cr in Chat.MessageReference,
	+ where: cr.chat_id == ^ch.id,
	+ preload: [:object]
	+ )
	+ \|> write(
	+ dir,
	+ chat_file(ch),
	+ fn reference ->
	+ with {:ok, activity} <- Transmogrifier.prepare_outgoing(reference.object.data),
	+ {:ok, activity} <-
	+ {:ok,
	+ Map.put(
	+ activity,
	+ "context",
	+ "#{Pleroma.Web.Endpoint.url()}/chats/#{reference.chat_id}"
	+ )} do
	+ {:ok, Map.delete(activity, "@context")}
	+ end
	+ end
	+ )
	+ end)

	- from(cr in Chat.MessageReference,
	- where: cr.chat_id in subquery(chats_subquery),
	- preload: [:object]
	- )
	- \|> write(
	- dir,
	- "chat_messages",
	- fn reference ->
	- with {:ok, activity} <- Transmogrifier.prepare_outgoing(reference.object.data),
	- {:ok, activity} <-
	- {:ok,
	- Map.put(
	- activity,
	- "context",
	- "#{Pleroma.Web.Endpoint.url()}/chats/#{reference.chat_id}"
	- )} do
	- {:ok, Map.delete(activity, "@context")}
	- end
	- end,
	- caller_pid
	- )
	+ if Enum.all?(results, fn r -> r == :ok end), do: :ok, else: results
	end
	-end

	defp followers(dir, user) do
	User.get_followers_query(user)
	\|> write(dir, "followers", fn a -> {:ok, a.ap_id} end)
	end

	defp following(dir, user) do
	User.get_friends_query(user)
	\|> write(dir, "following", fn a -> {:ok, a.ap_id} end)
	end
	end
	diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
	index 634d4719d..d9b18735c 100644
	--- a/test/pleroma/user/backup_test.exs
	+++ b/test/pleroma/user/backup_test.exs
	@@ -1,394 +1,397 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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 Pleroma.Factory
	import Swoosh.TestAssertions
	import Mox

	alias Pleroma.Bookmark
	alias Pleroma.Chat
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Uploaders.S3.ExAwsMock
	alias Pleroma.User
	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)

	ConfigMock
	\|> stub_with(Pleroma.Config)

	:ok
	end

	test "it does not requrie enabled email" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	user = insert(:user)
	assert {:ok, _} = Backup.user(user)
	end

	test "it does not require user's email" do
	user = insert(:user, %{email: nil})
	assert {:ok, _} = Backup.user(user)
	end

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

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

	test "it return an error if the export limit is over" do
	user = insert(:user)
	limit_days = Pleroma.Config.get([Backup, :limit_days])
	{:ok, first_backup} = Backup.user(user)
	{:ok, _run_backup} = Backup.run(first_backup)

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

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

	assert {:ok, %Backup{id: backup_id}} = Backup.user(user)

	oban_args = %{"op" => "process", "backup_id" => backup_id}

	assert {:ok, backup} = perform_job(BackupWorker, oban_args)
	assert backup.file_size > 0
	assert match?(%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_by_id(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 does not send an email if the user does not have an email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: nil})

	assert {:ok, %Backup{} = backup} = Backup.user(user)

	expected_args = %{"op" => "process", "backup_id" => backup.id}

	assert_enqueued(worker: BackupWorker, args: %{"backup_id" => backup.id})
	assert {:ok, completed_backup} = perform_job(BackupWorker, expected_args)
	assert completed_backup.file_size > 0
	assert completed_backup.processed
	assert completed_backup.user_id == user_id

	assert_no_email_sent()
	end

	test "it does not send an email if mailer is not on" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Backup{id: backup_id}} = Backup.user(user)

	oban_args = %{"op" => "process", "backup_id" => backup_id}

	assert {:ok, backup} = perform_job(BackupWorker, oban_args)
	assert backup.file_size > 0
	assert match?(%Backup{id: ^backup_id, processed: true, user_id: ^user_id}, backup)

	assert_no_email_sent()
	end

	test "it does not send an email if the user has an empty email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: ""})

	assert {:ok, %Backup{id: backup_id} = backup} = Backup.user(user)

	expected_args = %{"op" => "process", "backup_id" => backup.id}

	assert_enqueued(worker: BackupWorker, args: expected_args)

	assert {:ok, backup} = perform_job(BackupWorker, expected_args)
	assert backup.file_size > 0
	assert match?(%Backup{id: ^backup_id, processed: true, user_id: ^user_id}, backup)

	assert_no_email_sent()
	end

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

	assert {:ok, %{id: backup_one_id}} = Backup.user(user)
	assert {:ok, %{id: _backup_two_id}} = Backup.user(user)

	# Run the backups
	ObanHelpers.perform_all()

	assert_enqueued(worker: BackupWorker, args: %{"op" => "delete", "backup_id" => backup_one_id})
	end

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

	%User{ap_id: other_ap_id} = other_user = insert(:user)

	{: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(status1.id, user)
	CommonAPI.favorite(status2.id, user)

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

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)

	{:ok, _message_1} = CommonAPI.post_chat_message(user, other_user, "hey")
	{:ok, _message_2} = CommonAPI.post_chat_message(other_user, user, "ho")

	CommonAPI.follow(other_user, user)

	assert {:ok, backup} = Backup.user(user)
	assert {:ok, run_backup} = Backup.run(backup)

	tempfile = Path.join([run_backup.tempdir, run_backup.file_name])

	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(tempfile), [:memory])
	assert {:ok, {~c"actor.json", json}} = :zip.zip_get(~c"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" => "followers.json",
	"following" => "following.json",
	"id" => "http://cofe.io/users/cofe",
	"inbox" => "http://cofe.io/users/cofe/inbox",
	"likes" => "likes.json",
	"name" => "Cofe",
	"outbox" => "outbox.json",
	"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, {~c"outbox.json", json}} = :zip.zip_get(~c"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, {~c"likes.json", json}} = :zip.zip_get(~c"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, {~c"bookmarks.json", json}} = :zip.zip_get(~c"bookmarks.json", zipfile)

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

	assert {:ok, {~c"following.json", json}} = :zip.zip_get(~c"following.json", zipfile)

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

	- assert {:ok, {'chats.json', json}} = :zip.zip_get('chats.json', zipfile)
	+ assert {:ok, {~c"chats.json", json}} = :zip.zip_get(~c"chats.json", zipfile)

	chat_id = "http://localhost:4001/chats/#{chat.id}"

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "chats.json",
	"orderedItems" => [
	%{
	"type" => "Chat",
	"id" => ^chat_id,
	"actor" => ^ap_id,
	"to" => [^other_ap_id]
	}
	],
	"totalItems" => 1,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	- assert {:ok, {'chat_messages.json', json}} = :zip.zip_get('chat_messages.json', zipfile)
	+ chat_json_name = ~c'chat_messages_#{chat.id}.json'
	+ chat_json_name_string = to_string(chat_json_name)
	+
	+ assert {:ok, {^chat_json_name, json}} = :zip.zip_get(chat_json_name, zipfile)

	chat_id = "http://localhost:4001/chats/#{chat.id}"

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	- "id" => "chat_messages.json",
	+ "id" => ^chat_json_name_string,
	"orderedItems" => [
	%{
	"type" => "ChatMessage",
	"actor" => ^ap_id,
	"to" => [^other_ap_id],
	"context" => ^chat_id,
	"content" => "hey"
	},
	%{
	"type" => "ChatMessage",
	"actor" => ^other_ap_id,
	"to" => [^ap_id],
	"context" => ^chat_id,
	"content" => "ho"
	}
	],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	:zip.zip_close(zipfile)
	File.rm_rf!(run_backup.tempdir)
	end

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

	Enum.map(1..120, fn i ->
	{:ok, status} = CommonAPI.post(user, %{status: "status #{i}"})
	CommonAPI.favorite(status.id, user)
	Bookmark.create(user.id, status.id)
	end)

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

	zip_path = Path.join([backup.tempdir, backup.file_name])

	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(zip_path), [:memory])

	backup_parts = [~c"likes.json", ~c"bookmarks.json", ~c"outbox.json"]

	Enum.each(backup_parts, fn part ->
	assert {:ok, {_part, part_json}} = :zip.zip_get(part, zipfile)
	{:ok, decoded_part} = Jason.decode(part_json)
	assert decoded_part["totalItems"] == 120
	end)

	Backup.delete_archive(backup)
	end

	describe "it uploads and deletes a backup archive" do
	setup do
	clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
	clear_config([Pleroma.Uploaders.S3, :bucket], "test_bucket")

	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(status1.id, user)
	CommonAPI.favorite(status2.id, user)
	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

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

	[backup: backup]
	end

	test "S3", %{backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
	clear_config([Pleroma.Uploaders.S3, :streaming_enabled], false)

	ExAwsMock
	\|> expect(:request, 2, fn
	%{http_method: :put} -> {:ok, :ok}
	%{http_method: :delete} -> {:ok, %{status_code: 204}}
	end)

	assert {:ok, backup} = Backup.run(backup)
	assert {:ok, %Backup{processed: true}} = Backup.upload(backup)
	assert {:ok, _backup} = Backup.delete_archive(backup)
	end

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

	assert {:ok, backup} = Backup.run(backup)
	assert {:ok, %Backup{processed: true}} = Backup.upload(backup)
	assert {:ok, _backup} = Backup.delete_archive(backup)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 6:33 PM (19 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1801665
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions