From c01a81804835fb92c145b90e3a264c5d4cf9c886 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 25 Aug 2020 18:51:09 +0400
Subject: Add tests

---
 test/export_test.exs | 111 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 111 insertions(+)
 create mode 100644 test/export_test.exs

(limited to 'test')

diff --git a/test/export_test.exs b/test/export_test.exs
new file mode 100644
index 000000000..5afd58ccc
--- /dev/null
+++ b/test/export_test.exs
@@ -0,0 +1,111 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.ExportTest do
+  use Pleroma.DataCase
+  import Pleroma.Factory
+
+  alias Pleroma.Web.CommonAPI
+  alias Pleroma.Bookmark
+
+  test "it exports 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, path} = Pleroma.Export.run(user)
+    assert {:ok, zipfile} = :zip.zip_open(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
+end
-- 
cgit v1.2.3


From c82f9129592553718be4bd4712a2b1848dd0a447 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 25 Aug 2020 19:16:01 +0400
Subject: Fix credo warning

---
 test/export_test.exs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/export_test.exs b/test/export_test.exs
index 5afd58ccc..01ca8e7e8 100644
--- a/test/export_test.exs
+++ b/test/export_test.exs
@@ -6,8 +6,8 @@ defmodule Pleroma.ExportTest do
   use Pleroma.DataCase
   import Pleroma.Factory
 
-  alias Pleroma.Web.CommonAPI
   alias Pleroma.Bookmark
+  alias Pleroma.Web.CommonAPI
 
   test "it exports user data" do
     user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})
-- 
cgit v1.2.3


From be42ab70dc9538df54ac6f30ee123666223b7287 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 31 Aug 2020 20:31:21 +0400
Subject: Add backup upload

---
 test/export_test.exs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/export_test.exs b/test/export_test.exs
index 01ca8e7e8..fae269974 100644
--- a/test/export_test.exs
+++ b/test/export_test.exs
@@ -28,7 +28,7 @@ defmodule Pleroma.ExportTest do
     Bookmark.create(user.id, status3.id)
 
     assert {:ok, path} = Pleroma.Export.run(user)
-    assert {:ok, zipfile} = :zip.zip_open(path, [:memory])
+    assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(path), [:memory])
     assert {:ok, {'actor.json', json}} = :zip.zip_get('actor.json', zipfile)
 
     assert %{
@@ -108,4 +108,19 @@ defmodule Pleroma.ExportTest do
     :zip.zip_close(zipfile)
     File.rm!(path)
   end
+
+  test "it uploads an exported backup archive" do
+    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, path} = Pleroma.Export.run(user)
+    assert {:ok, %Pleroma.Upload{}} = Pleroma.Export.upload(path)
+  end
 end
-- 
cgit v1.2.3


From 75e07ba206b94155c5210151a49e29a11bce6e50 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 31 Aug 2020 23:07:14 +0400
Subject: Fix tests

---
 test/export_test.exs | 47 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 11 deletions(-)

(limited to 'test')

diff --git a/test/export_test.exs b/test/export_test.exs
index fae269974..d7e8f558c 100644
--- a/test/export_test.exs
+++ b/test/export_test.exs
@@ -5,6 +5,7 @@
 defmodule Pleroma.ExportTest do
   use Pleroma.DataCase
   import Pleroma.Factory
+  import Mock
 
   alias Pleroma.Bookmark
   alias Pleroma.Web.CommonAPI
@@ -109,18 +110,42 @@ defmodule Pleroma.ExportTest do
     File.rm!(path)
   end
 
-  test "it uploads an exported backup archive" do
-    user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})
+  describe "it uploads an exported backup archive" do
+    setup do
+      clear_config(Pleroma.Uploaders.S3,
+        bucket: "test_bucket",
+        public_endpoint: "https://s3.amazonaws.com"
+      )
 
-    {: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)
+      clear_config([Pleroma.Upload, :uploader])
 
-    assert {:ok, path} = Pleroma.Export.run(user)
-    assert {:ok, %Pleroma.Upload{}} = Pleroma.Export.upload(path)
+      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, path} = Pleroma.Export.run(user)
+
+      [path: path]
+    end
+
+    test "S3", %{path: path} do
+      Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
+
+      with_mock ExAws, request: fn _ -> {:ok, :ok} end do
+        assert {:ok, %Pleroma.Upload{}} = Pleroma.Export.upload(path)
+      end
+    end
+
+    test "Local", %{path: path} do
+      Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
+
+      assert {:ok, %Pleroma.Upload{}} = Pleroma.Export.upload(path)
+    end
   end
 end
-- 
cgit v1.2.3


From 4f3a6337454807f4145bbc1830c3d55dd883d46d Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 2 Sep 2020 20:21:33 +0400
Subject: Add `backups` table

---
 test/backup_test.exs | 179 +++++++++++++++++++++++++++++++++++++++++++++++++++
 test/export_test.exs | 151 -------------------------------------------
 2 files changed, 179 insertions(+), 151 deletions(-)
 create mode 100644 test/backup_test.exs
 delete mode 100644 test/export_test.exs

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
new file mode 100644
index 000000000..27f5cb7f7
--- /dev/null
+++ b/test/backup_test.exs
@@ -0,0 +1,179 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.BackupTest do
+  use Pleroma.DataCase
+  import Pleroma.Factory
+  import Mock
+
+  alias Pleroma.Backup
+  alias Pleroma.Bookmark
+  alias Pleroma.Web.CommonAPI
+
+  test "it creates a backup record" do
+    %{id: user_id} = user = insert(:user)
+    assert {:ok, backup} = Backup.create(user)
+
+    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 = 7
+
+    assert {:ok, backup} = Backup.create(user)
+    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
+    %{id: user_id} = user = insert(:user)
+    assert {:ok, %{id: backup_id} = backup} = Backup.create(user)
+    assert {:ok, %Backup{} = backup} = Backup.process(backup)
+    assert backup.file_size > 0
+    assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = 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.zip(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 a backup archive" do
+    setup do
+      clear_config(Pleroma.Uploaders.S3,
+        bucket: "test_bucket",
+        public_endpoint: "https://s3.amazonaws.com"
+      )
+
+      clear_config([Pleroma.Upload, :uploader])
+
+      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.zip(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 _ -> {:ok, :ok} end do
+        assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
+      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)
+    end
+  end
+end
diff --git a/test/export_test.exs b/test/export_test.exs
deleted file mode 100644
index d7e8f558c..000000000
--- a/test/export_test.exs
+++ /dev/null
@@ -1,151 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.ExportTest do
-  use Pleroma.DataCase
-  import Pleroma.Factory
-  import Mock
-
-  alias Pleroma.Bookmark
-  alias Pleroma.Web.CommonAPI
-
-  test "it exports 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, path} = Pleroma.Export.run(user)
-    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 an exported backup archive" do
-    setup do
-      clear_config(Pleroma.Uploaders.S3,
-        bucket: "test_bucket",
-        public_endpoint: "https://s3.amazonaws.com"
-      )
-
-      clear_config([Pleroma.Upload, :uploader])
-
-      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, path} = Pleroma.Export.run(user)
-
-      [path: path]
-    end
-
-    test "S3", %{path: path} do
-      Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
-
-      with_mock ExAws, request: fn _ -> {:ok, :ok} end do
-        assert {:ok, %Pleroma.Upload{}} = Pleroma.Export.upload(path)
-      end
-    end
-
-    test "Local", %{path: path} do
-      Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
-
-      assert {:ok, %Pleroma.Upload{}} = Pleroma.Export.upload(path)
-    end
-  end
-end
-- 
cgit v1.2.3


From a0ad9bd734e9af0ce912c32c7480a60ff87a4368 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 2 Sep 2020 21:45:22 +0400
Subject: Add BackupWorker

---
 test/backup_test.exs | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index 27f5cb7f7..5b1f76dd9 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -3,35 +3,43 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.BackupTest do
+  use Oban.Testing, repo: Pleroma.Repo
   use Pleroma.DataCase
+
   import Pleroma.Factory
   import Mock
 
   alias Pleroma.Backup
   alias Pleroma.Bookmark
   alias Pleroma.Web.CommonAPI
+  alias Pleroma.Workers.BackupWorker
+
+  setup do: clear_config([Pleroma.Upload, :uploader])
 
-  test "it creates a backup record" do
+  test "it creates a backup record and an Oban job" do
     %{id: user_id} = user = insert(:user)
-    assert {:ok, backup} = Backup.create(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 = 7
-
-    assert {:ok, backup} = Backup.create(user)
+    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, %{id: backup_id} = backup} = Backup.create(user)
-    assert {:ok, %Backup{} = backup} = Backup.process(backup)
+    assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id}} = job} = Backup.create(user)
+    assert {:ok, backup} = BackupWorker.perform(job)
     assert backup.file_size > 0
     assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup
   end
-- 
cgit v1.2.3


From 3ad7492f9dd1c76cdbc64ad2246f8e9c8c5c4ae6 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Fri, 4 Sep 2020 18:30:39 +0400
Subject: Add config for Pleroma.Backup

---
 test/backup_test.exs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index 5b1f76dd9..f343b0361 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -27,7 +27,7 @@ defmodule Pleroma.BackupTest do
 
   test "it return an error if the export limit is over" do
     %{id: user_id} = user = insert(:user)
-    limit_days = 7
+    limit_days = Pleroma.Config.get([Pleroma.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
-- 
cgit v1.2.3


From 739cb1463ba07513f047b2ac8f7e22a16c89ef4e Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Fri, 4 Sep 2020 21:48:52 +0400
Subject: Add backups deletion

---
 test/backup_test.exs         | 47 +++++++++++++++++++++++++++++++++++++++-----
 test/support/oban_helpers.ex |  3 +++
 2 files changed, 45 insertions(+), 5 deletions(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index f343b0361..59aebe360 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -13,8 +13,12 @@ defmodule Pleroma.BackupTest do
   alias Pleroma.Bookmark
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Workers.BackupWorker
+  alias Pleroma.Tests.ObanHelpers
 
-  setup do: clear_config([Pleroma.Upload, :uploader])
+  setup do
+    clear_config([Pleroma.Upload, :uploader])
+    clear_config([Pleroma.Backup, :limit_days])
+  end
 
   test "it creates a backup record and an Oban job" do
     %{id: user_id} = user = insert(:user)
@@ -38,10 +42,34 @@ defmodule Pleroma.BackupTest do
   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}} = job} = Backup.create(user)
-    assert {:ok, backup} = BackupWorker.perform(job)
+
+    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)
+  end
+
+  test "it removes outdated backups after creating a fresh one" do
+    Pleroma.Config.put([Pleroma.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{id: backup1_id}} = 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
@@ -145,7 +173,7 @@ defmodule Pleroma.BackupTest do
     File.rm!(path)
   end
 
-  describe "it uploads a backup archive" do
+  describe "it uploads and deletes a backup archive" do
     setup do
       clear_config(Pleroma.Uploaders.S3,
         bucket: "test_bucket",
@@ -173,8 +201,16 @@ defmodule Pleroma.BackupTest do
     test "S3", %{path: path, backup: backup} do
       Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
 
-      with_mock ExAws, request: fn _ -> {:ok, :ok} end do
+      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
 
@@ -182,6 +218,7 @@ defmodule Pleroma.BackupTest 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
diff --git a/test/support/oban_helpers.ex b/test/support/oban_helpers.ex
index 9f90a821c..2468f66dc 100644
--- a/test/support/oban_helpers.ex
+++ b/test/support/oban_helpers.ex
@@ -7,6 +7,8 @@ defmodule Pleroma.Tests.ObanHelpers do
   Oban test helpers.
   """
 
+  require Ecto.Query
+
   alias Pleroma.Repo
 
   def wipe_all do
@@ -15,6 +17,7 @@ defmodule Pleroma.Tests.ObanHelpers do
 
   def perform_all do
     Oban.Job
+    |> Ecto.Query.where(state: "available")
     |> Repo.all()
     |> perform()
   end
-- 
cgit v1.2.3


From abdffc6b8c2eec8f81ffe89f943f11d1f90d7074 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Fri, 4 Sep 2020 22:00:26 +0400
Subject: Fix Credo warning

---
 test/backup_test.exs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index 59aebe360..5fc519eab 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -11,9 +11,9 @@ defmodule Pleroma.BackupTest do
 
   alias Pleroma.Backup
   alias Pleroma.Bookmark
+  alias Pleroma.Tests.ObanHelpers
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Workers.BackupWorker
-  alias Pleroma.Tests.ObanHelpers
 
   setup do
     clear_config([Pleroma.Upload, :uploader])
-- 
cgit v1.2.3


From 2c73bfe1227065fa203b0b78c9eb12cf86ab3948 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 9 Sep 2020 01:04:00 +0400
Subject: Add API endpoints for Backups

---
 .../controllers/backup_controller_test.exs         | 84 ++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 test/web/pleroma_api/controllers/backup_controller_test.exs

(limited to 'test')

diff --git a/test/web/pleroma_api/controllers/backup_controller_test.exs b/test/web/pleroma_api/controllers/backup_controller_test.exs
new file mode 100644
index 000000000..1ad1b63c4
--- /dev/null
+++ b/test/web/pleroma_api/controllers/backup_controller_test.exs
@@ -0,0 +1,84 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
+  use Pleroma.Web.ConnCase
+
+  alias Pleroma.Backup
+
+  setup do
+    clear_config([Pleroma.Upload, :uploader])
+    clear_config([Backup, :limit_days])
+    oauth_access(["read:accounts"])
+  end
+
+  test "GET /api/pleroma/backups", %{user: user, conn: conn} do
+    assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id}}} = Backup.create(user)
+
+    backup = Backup.get(backup_id)
+
+    response =
+      conn
+      |> get("/api/pleroma/backups")
+      |> json_response_and_validate_schema(:ok)
+
+    assert [
+             %{
+               "content_type" => "application/zip",
+               "file_name" => file_name,
+               "file_size" => 0,
+               "processed" => false,
+               "inserted_at" => _
+             }
+           ] = response
+
+    assert file_name == backup.file_name
+
+    Pleroma.Tests.ObanHelpers.perform_all()
+
+    assert [
+             %{
+               "file_name" => ^file_name,
+               "processed" => true
+             }
+           ] =
+             conn
+             |> get("/api/pleroma/backups")
+             |> json_response_and_validate_schema(:ok)
+  end
+
+  test "POST /api/pleroma/backups", %{user: _user, conn: conn} do
+    assert [
+             %{
+               "content_type" => "application/zip",
+               "file_name" => file_name,
+               "file_size" => 0,
+               "processed" => false,
+               "inserted_at" => _
+             }
+           ] =
+             conn
+             |> post("/api/pleroma/backups")
+             |> json_response_and_validate_schema(:ok)
+
+    Pleroma.Tests.ObanHelpers.perform_all()
+
+    assert [
+             %{
+               "file_name" => ^file_name,
+               "processed" => true
+             }
+           ] =
+             conn
+             |> get("/api/pleroma/backups")
+             |> json_response_and_validate_schema(:ok)
+
+    days = Pleroma.Config.get([Backup, :limit_days])
+
+    assert %{"error" => "Last export was less than #{days} days ago"} ==
+             conn
+             |> post("/api/pleroma/backups")
+             |> json_response_and_validate_schema(400)
+  end
+end
-- 
cgit v1.2.3


From 86ce4afd9338d81f741fa57f962509a6f0f50aff Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 9 Sep 2020 20:02:20 +0400
Subject: Improve backup urls

---
 test/web/pleroma_api/controllers/backup_controller_test.exs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'test')

diff --git a/test/web/pleroma_api/controllers/backup_controller_test.exs b/test/web/pleroma_api/controllers/backup_controller_test.exs
index 1ad1b63c4..5d2f1206e 100644
--- a/test/web/pleroma_api/controllers/backup_controller_test.exs
+++ b/test/web/pleroma_api/controllers/backup_controller_test.exs
@@ -6,6 +6,7 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
   use Pleroma.Web.ConnCase
 
   alias Pleroma.Backup
+  alias Pleroma.Web.PleromaAPI.BackupView
 
   setup do
     clear_config([Pleroma.Upload, :uploader])
@@ -26,20 +27,20 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
     assert [
              %{
                "content_type" => "application/zip",
-               "file_name" => file_name,
+               "url" => url,
                "file_size" => 0,
                "processed" => false,
                "inserted_at" => _
              }
            ] = response
 
-    assert file_name == backup.file_name
+    assert url == BackupView.download_url(backup)
 
     Pleroma.Tests.ObanHelpers.perform_all()
 
     assert [
              %{
-               "file_name" => ^file_name,
+               "url" => ^url,
                "processed" => true
              }
            ] =
@@ -52,7 +53,7 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
     assert [
              %{
                "content_type" => "application/zip",
-               "file_name" => file_name,
+               "url" => url,
                "file_size" => 0,
                "processed" => false,
                "inserted_at" => _
@@ -66,7 +67,7 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
 
     assert [
              %{
-               "file_name" => ^file_name,
+               "url" => ^url,
                "processed" => true
              }
            ] =
-- 
cgit v1.2.3


From 27bc121ec00a7b088030d6fb36c7e731f5b072b6 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 15 Sep 2020 18:07:28 +0400
Subject: Require email

---
 test/backup_test.exs | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index 5fc519eab..318c8c419 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -18,6 +18,18 @@ defmodule Pleroma.BackupTest do
   setup do
     clear_config([Pleroma.Upload, :uploader])
     clear_config([Pleroma.Backup, :limit_days])
+    clear_config([Pleroma.Emails.Mailer, :enabled])
+  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
@@ -91,7 +103,7 @@ defmodule Pleroma.BackupTest do
     Bookmark.create(user.id, status3.id)
 
     assert {:ok, backup} = user |> Backup.new() |> Repo.insert()
-    assert {:ok, path} = Backup.zip(backup)
+    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)
 
@@ -193,7 +205,7 @@ defmodule Pleroma.BackupTest do
       Bookmark.create(user.id, status3.id)
 
       assert {:ok, backup} = user |> Backup.new() |> Repo.insert()
-      assert {:ok, path} = Backup.zip(backup)
+      assert {:ok, path} = Backup.export(backup)
 
       [path: path, backup: backup]
     end
-- 
cgit v1.2.3


From 7fdd81d000d857cbcd5bf442f68c91b1c5b1cebb Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Thu, 17 Sep 2020 18:42:24 +0400
Subject: Add "Your backup is ready" email

---
 test/backup_test.exs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index 318c8c419..0ea40e6fd 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -6,8 +6,9 @@ defmodule Pleroma.BackupTest do
   use Oban.Testing, repo: Pleroma.Repo
   use Pleroma.DataCase
 
-  import Pleroma.Factory
   import Mock
+  import Pleroma.Factory
+  import Swoosh.TestAssertions
 
   alias Pleroma.Backup
   alias Pleroma.Bookmark
@@ -65,6 +66,8 @@ defmodule Pleroma.BackupTest do
     assert_enqueued(worker: BackupWorker, args: delete_job_args)
     assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
     refute Backup.get(backup_id)
+
+    assert_email_sent(Pleroma.Emails.UserEmail.backup_is_ready_email(backup))
   end
 
   test "it removes outdated backups after creating a fresh one" do
-- 
cgit v1.2.3


From 7c22c9afb410668d87dcd4a90651d62d9a1e9e4d Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Fri, 18 Sep 2020 22:18:34 +0400
Subject: Allow admins request user backups

---
 .../controllers/admin_api_controller_test.exs       | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'test')

diff --git a/test/web/admin_api/controllers/admin_api_controller_test.exs b/test/web/admin_api/controllers/admin_api_controller_test.exs
index cba6b43d3..4d331779e 100644
--- a/test/web/admin_api/controllers/admin_api_controller_test.exs
+++ b/test/web/admin_api/controllers/admin_api_controller_test.exs
@@ -2024,6 +2024,27 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
                response["status_visibility"]
     end
   end
+
+  describe "/api/pleroma/backups" do
+    test "it creates a backup", %{conn: conn} do
+      admin = insert(:user, is_admin: true)
+      token = insert(:oauth_admin_token, user: admin)
+      user = insert(:user)
+
+      assert "" ==
+               conn
+               |> assign(:user, admin)
+               |> assign(:token, token)
+               |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
+               |> json_response(200)
+
+      assert [backup] = Repo.all(Pleroma.Backup)
+
+      ObanHelpers.perform_all()
+
+      assert_email_sent(Pleroma.Emails.UserEmail.backup_is_ready_email(backup, admin.id))
+    end
+  end
 end
 
 # Needed for testing
-- 
cgit v1.2.3


From 17562bf4147ab03e171b1f1d365a512f2e5b3202 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Sun, 20 Sep 2020 20:43:27 +0400
Subject: Move API endpoints to `/api/v1/pleroma/backups`

---
 .../web/pleroma_api/controllers/backup_controller_test.exs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'test')

diff --git a/test/web/pleroma_api/controllers/backup_controller_test.exs b/test/web/pleroma_api/controllers/backup_controller_test.exs
index 5d2f1206e..b2ac74c7d 100644
--- a/test/web/pleroma_api/controllers/backup_controller_test.exs
+++ b/test/web/pleroma_api/controllers/backup_controller_test.exs
@@ -14,14 +14,14 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
     oauth_access(["read:accounts"])
   end
 
-  test "GET /api/pleroma/backups", %{user: user, conn: conn} do
+  test "GET /api/v1/pleroma/backups", %{user: user, conn: conn} do
     assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id}}} = Backup.create(user)
 
     backup = Backup.get(backup_id)
 
     response =
       conn
-      |> get("/api/pleroma/backups")
+      |> get("/api/v1/pleroma/backups")
       |> json_response_and_validate_schema(:ok)
 
     assert [
@@ -45,11 +45,11 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
              }
            ] =
              conn
-             |> get("/api/pleroma/backups")
+             |> get("/api/v1/pleroma/backups")
              |> json_response_and_validate_schema(:ok)
   end
 
-  test "POST /api/pleroma/backups", %{user: _user, conn: conn} do
+  test "POST /api/v1/pleroma/backups", %{user: _user, conn: conn} do
     assert [
              %{
                "content_type" => "application/zip",
@@ -60,7 +60,7 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
              }
            ] =
              conn
-             |> post("/api/pleroma/backups")
+             |> post("/api/v1/pleroma/backups")
              |> json_response_and_validate_schema(:ok)
 
     Pleroma.Tests.ObanHelpers.perform_all()
@@ -72,14 +72,14 @@ defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
              }
            ] =
              conn
-             |> get("/api/pleroma/backups")
+             |> get("/api/v1/pleroma/backups")
              |> json_response_and_validate_schema(:ok)
 
     days = Pleroma.Config.get([Backup, :limit_days])
 
     assert %{"error" => "Last export was less than #{days} days ago"} ==
              conn
-             |> post("/api/pleroma/backups")
+             |> post("/api/v1/pleroma/backups")
              |> json_response_and_validate_schema(400)
   end
 end
-- 
cgit v1.2.3


From e4792ce76af3094d378a3a201ca429ae38203696 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Sun, 20 Sep 2020 21:06:16 +0400
Subject: Do not limit admins

---
 .../controllers/admin_api_controller_test.exs      | 24 ++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'test')

diff --git a/test/web/admin_api/controllers/admin_api_controller_test.exs b/test/web/admin_api/controllers/admin_api_controller_test.exs
index 4d331779e..4b3abce0d 100644
--- a/test/web/admin_api/controllers/admin_api_controller_test.exs
+++ b/test/web/admin_api/controllers/admin_api_controller_test.exs
@@ -2044,6 +2044,30 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
 
       assert_email_sent(Pleroma.Emails.UserEmail.backup_is_ready_email(backup, admin.id))
     end
+
+    test "it doesn't limit admins", %{conn: conn} do
+      admin = insert(:user, is_admin: true)
+      token = insert(:oauth_admin_token, user: admin)
+      user = insert(:user)
+
+      assert "" ==
+               conn
+               |> assign(:user, admin)
+               |> assign(:token, token)
+               |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
+               |> json_response(200)
+
+      assert [_backup] = Repo.all(Pleroma.Backup)
+
+      assert "" ==
+               conn
+               |> assign(:user, admin)
+               |> assign(:token, token)
+               |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
+               |> json_response(200)
+
+      assert Repo.aggregate(Pleroma.Backup, :count) == 2
+    end
   end
 end
 
-- 
cgit v1.2.3


From f1e4333dd7976e8cbef44a3bcfe5c96bef177c6f Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 23 Sep 2020 20:23:11 +0400
Subject: Fix test

---
 test/backup_test.exs                                         | 7 ++++++-
 test/web/admin_api/controllers/admin_api_controller_test.exs | 5 ++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index 0ea40e6fd..23c08b680 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -67,7 +67,12 @@ defmodule Pleroma.BackupTest do
     assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
     refute Backup.get(backup_id)
 
-    assert_email_sent(Pleroma.Emails.UserEmail.backup_is_ready_email(backup))
+    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
diff --git a/test/web/admin_api/controllers/admin_api_controller_test.exs b/test/web/admin_api/controllers/admin_api_controller_test.exs
index 4b3abce0d..a6dc4f62d 100644
--- a/test/web/admin_api/controllers/admin_api_controller_test.exs
+++ b/test/web/admin_api/controllers/admin_api_controller_test.exs
@@ -2042,7 +2042,10 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
 
       ObanHelpers.perform_all()
 
-      assert_email_sent(Pleroma.Emails.UserEmail.backup_is_ready_email(backup, admin.id))
+      email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup, admin.id)
+
+      assert String.contains?(email.html_body, "Admin @#{admin.nickname} requested a full backup")
+      assert_email_sent(to: {user.name, user.email}, html_body: email.html_body)
     end
 
     test "it doesn't limit admins", %{conn: conn} do
-- 
cgit v1.2.3


From bc3db724030707e9903d161a70b10fe217a83212 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Sat, 26 Sep 2020 23:16:56 +0400
Subject: Use ModerationLog instead of Logger

---
 .../controllers/admin_api_controller_test.exs      | 23 ++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

(limited to 'test')

diff --git a/test/web/admin_api/controllers/admin_api_controller_test.exs b/test/web/admin_api/controllers/admin_api_controller_test.exs
index a6dc4f62d..34d48c2c1 100644
--- a/test/web/admin_api/controllers/admin_api_controller_test.exs
+++ b/test/web/admin_api/controllers/admin_api_controller_test.exs
@@ -2027,9 +2027,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
 
   describe "/api/pleroma/backups" do
     test "it creates a backup", %{conn: conn} do
-      admin = insert(:user, is_admin: true)
+      admin = %{id: admin_id, nickname: admin_nickname} = insert(:user, is_admin: true)
       token = insert(:oauth_admin_token, user: admin)
-      user = insert(:user)
+      user = %{id: user_id, nickname: user_nickname} = insert(:user)
 
       assert "" ==
                conn
@@ -2046,6 +2046,25 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
 
       assert String.contains?(email.html_body, "Admin @#{admin.nickname} requested a full backup")
       assert_email_sent(to: {user.name, user.email}, html_body: email.html_body)
+
+      log_message = "@#{admin_nickname} requested account backup for @#{user_nickname}"
+
+      assert [
+               %{
+                 data: %{
+                   "action" => "create_backup",
+                   "actor" => %{
+                     "id" => ^admin_id,
+                     "nickname" => ^admin_nickname
+                   },
+                   "message" => ^log_message,
+                   "subject" => %{
+                     "id" => ^user_id,
+                     "nickname" => ^user_nickname
+                   }
+                 }
+               }
+             ] = Pleroma.ModerationLog |> Repo.all()
     end
 
     test "it doesn't limit admins", %{conn: conn} do
-- 
cgit v1.2.3


From 98f32cf8204113c6d019653c22e446e558147248 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 19 Oct 2020 15:30:32 +0400
Subject: Fix tests

---
 test/backup_test.exs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
index 23c08b680..078e03621 100644
--- a/test/backup_test.exs
+++ b/test/backup_test.exs
@@ -19,7 +19,7 @@ defmodule Pleroma.BackupTest do
   setup do
     clear_config([Pleroma.Upload, :uploader])
     clear_config([Pleroma.Backup, :limit_days])
-    clear_config([Pleroma.Emails.Mailer, :enabled])
+    clear_config([Pleroma.Emails.Mailer, :enabled], true)
   end
 
   test "it requries enabled email" do
-- 
cgit v1.2.3


From c1976d5b19fbceaecf1f52711fe35e1c7d5312aa Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 19 Oct 2020 18:14:39 +0400
Subject: Fix credo warnings

---
 test/backup_test.exs                               | 244 ---------------------
 test/pleroma/backup_test.exs                       | 244 +++++++++++++++++++++
 .../controllers/backup_controller_test.exs         |  85 +++++++
 .../controllers/backup_controller_test.exs         |  85 -------
 4 files changed, 329 insertions(+), 329 deletions(-)
 delete mode 100644 test/backup_test.exs
 create mode 100644 test/pleroma/backup_test.exs
 create mode 100644 test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs
 delete mode 100644 test/web/pleroma_api/controllers/backup_controller_test.exs

(limited to 'test')

diff --git a/test/backup_test.exs b/test/backup_test.exs
deleted file mode 100644
index 078e03621..000000000
--- a/test/backup_test.exs
+++ /dev/null
@@ -1,244 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.BackupTest do
-  use Oban.Testing, repo: Pleroma.Repo
-  use Pleroma.DataCase
-
-  import Mock
-  import Pleroma.Factory
-  import Swoosh.TestAssertions
-
-  alias Pleroma.Backup
-  alias Pleroma.Bookmark
-  alias Pleroma.Tests.ObanHelpers
-  alias Pleroma.Web.CommonAPI
-  alias Pleroma.Workers.BackupWorker
-
-  setup do
-    clear_config([Pleroma.Upload, :uploader])
-    clear_config([Pleroma.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([Pleroma.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([Pleroma.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{id: backup1_id}} = 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"
-      )
-
-      clear_config([Pleroma.Upload, :uploader])
-
-      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
diff --git a/test/pleroma/backup_test.exs b/test/pleroma/backup_test.exs
new file mode 100644
index 000000000..078e03621
--- /dev/null
+++ b/test/pleroma/backup_test.exs
@@ -0,0 +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.BackupTest do
+  use Oban.Testing, repo: Pleroma.Repo
+  use Pleroma.DataCase
+
+  import Mock
+  import Pleroma.Factory
+  import Swoosh.TestAssertions
+
+  alias Pleroma.Backup
+  alias Pleroma.Bookmark
+  alias Pleroma.Tests.ObanHelpers
+  alias Pleroma.Web.CommonAPI
+  alias Pleroma.Workers.BackupWorker
+
+  setup do
+    clear_config([Pleroma.Upload, :uploader])
+    clear_config([Pleroma.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([Pleroma.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([Pleroma.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{id: backup1_id}} = 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"
+      )
+
+      clear_config([Pleroma.Upload, :uploader])
+
+      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
diff --git a/test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs
new file mode 100644
index 000000000..b2ac74c7d
--- /dev/null
+++ b/test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs
@@ -0,0 +1,85 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
+  use Pleroma.Web.ConnCase
+
+  alias Pleroma.Backup
+  alias Pleroma.Web.PleromaAPI.BackupView
+
+  setup do
+    clear_config([Pleroma.Upload, :uploader])
+    clear_config([Backup, :limit_days])
+    oauth_access(["read:accounts"])
+  end
+
+  test "GET /api/v1/pleroma/backups", %{user: user, conn: conn} do
+    assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id}}} = Backup.create(user)
+
+    backup = Backup.get(backup_id)
+
+    response =
+      conn
+      |> get("/api/v1/pleroma/backups")
+      |> json_response_and_validate_schema(:ok)
+
+    assert [
+             %{
+               "content_type" => "application/zip",
+               "url" => url,
+               "file_size" => 0,
+               "processed" => false,
+               "inserted_at" => _
+             }
+           ] = response
+
+    assert url == BackupView.download_url(backup)
+
+    Pleroma.Tests.ObanHelpers.perform_all()
+
+    assert [
+             %{
+               "url" => ^url,
+               "processed" => true
+             }
+           ] =
+             conn
+             |> get("/api/v1/pleroma/backups")
+             |> json_response_and_validate_schema(:ok)
+  end
+
+  test "POST /api/v1/pleroma/backups", %{user: _user, conn: conn} do
+    assert [
+             %{
+               "content_type" => "application/zip",
+               "url" => url,
+               "file_size" => 0,
+               "processed" => false,
+               "inserted_at" => _
+             }
+           ] =
+             conn
+             |> post("/api/v1/pleroma/backups")
+             |> json_response_and_validate_schema(:ok)
+
+    Pleroma.Tests.ObanHelpers.perform_all()
+
+    assert [
+             %{
+               "url" => ^url,
+               "processed" => true
+             }
+           ] =
+             conn
+             |> get("/api/v1/pleroma/backups")
+             |> json_response_and_validate_schema(:ok)
+
+    days = Pleroma.Config.get([Backup, :limit_days])
+
+    assert %{"error" => "Last export was less than #{days} days ago"} ==
+             conn
+             |> post("/api/v1/pleroma/backups")
+             |> json_response_and_validate_schema(400)
+  end
+end
diff --git a/test/web/pleroma_api/controllers/backup_controller_test.exs b/test/web/pleroma_api/controllers/backup_controller_test.exs
deleted file mode 100644
index b2ac74c7d..000000000
--- a/test/web/pleroma_api/controllers/backup_controller_test.exs
+++ /dev/null
@@ -1,85 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
-  use Pleroma.Web.ConnCase
-
-  alias Pleroma.Backup
-  alias Pleroma.Web.PleromaAPI.BackupView
-
-  setup do
-    clear_config([Pleroma.Upload, :uploader])
-    clear_config([Backup, :limit_days])
-    oauth_access(["read:accounts"])
-  end
-
-  test "GET /api/v1/pleroma/backups", %{user: user, conn: conn} do
-    assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id}}} = Backup.create(user)
-
-    backup = Backup.get(backup_id)
-
-    response =
-      conn
-      |> get("/api/v1/pleroma/backups")
-      |> json_response_and_validate_schema(:ok)
-
-    assert [
-             %{
-               "content_type" => "application/zip",
-               "url" => url,
-               "file_size" => 0,
-               "processed" => false,
-               "inserted_at" => _
-             }
-           ] = response
-
-    assert url == BackupView.download_url(backup)
-
-    Pleroma.Tests.ObanHelpers.perform_all()
-
-    assert [
-             %{
-               "url" => ^url,
-               "processed" => true
-             }
-           ] =
-             conn
-             |> get("/api/v1/pleroma/backups")
-             |> json_response_and_validate_schema(:ok)
-  end
-
-  test "POST /api/v1/pleroma/backups", %{user: _user, conn: conn} do
-    assert [
-             %{
-               "content_type" => "application/zip",
-               "url" => url,
-               "file_size" => 0,
-               "processed" => false,
-               "inserted_at" => _
-             }
-           ] =
-             conn
-             |> post("/api/v1/pleroma/backups")
-             |> json_response_and_validate_schema(:ok)
-
-    Pleroma.Tests.ObanHelpers.perform_all()
-
-    assert [
-             %{
-               "url" => ^url,
-               "processed" => true
-             }
-           ] =
-             conn
-             |> get("/api/v1/pleroma/backups")
-             |> json_response_and_validate_schema(:ok)
-
-    days = Pleroma.Config.get([Backup, :limit_days])
-
-    assert %{"error" => "Last export was less than #{days} days ago"} ==
-             conn
-             |> post("/api/v1/pleroma/backups")
-             |> json_response_and_validate_schema(400)
-  end
-end
-- 
cgit v1.2.3


From ad605e3e16ba3f6ee3df7a0a3e6705036fef369f Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 20 Oct 2020 17:16:58 +0400
Subject: Rename `Pleroma.Backup` to `Pleroma.User.Backup`

---
 test/pleroma/backup_test.exs                       | 244 ---------------------
 test/pleroma/user/backup_test.exs                  | 244 +++++++++++++++++++++
 .../controllers/admin_api_controller_test.exs      |   6 +-
 .../controllers/backup_controller_test.exs         |   2 +-
 4 files changed, 248 insertions(+), 248 deletions(-)
 delete mode 100644 test/pleroma/backup_test.exs
 create mode 100644 test/pleroma/user/backup_test.exs

(limited to 'test')

diff --git a/test/pleroma/backup_test.exs b/test/pleroma/backup_test.exs
deleted file mode 100644
index 078e03621..000000000
--- a/test/pleroma/backup_test.exs
+++ /dev/null
@@ -1,244 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.BackupTest do
-  use Oban.Testing, repo: Pleroma.Repo
-  use Pleroma.DataCase
-
-  import Mock
-  import Pleroma.Factory
-  import Swoosh.TestAssertions
-
-  alias Pleroma.Backup
-  alias Pleroma.Bookmark
-  alias Pleroma.Tests.ObanHelpers
-  alias Pleroma.Web.CommonAPI
-  alias Pleroma.Workers.BackupWorker
-
-  setup do
-    clear_config([Pleroma.Upload, :uploader])
-    clear_config([Pleroma.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([Pleroma.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([Pleroma.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{id: backup1_id}} = 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"
-      )
-
-      clear_config([Pleroma.Upload, :uploader])
-
-      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
diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
new file mode 100644
index 000000000..5ad587833
--- /dev/null
+++ b/test/pleroma/user/backup_test.exs
@@ -0,0 +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.User.Backup
+  alias Pleroma.Bookmark
+  alias Pleroma.Tests.ObanHelpers
+  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{id: backup1_id}} = 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"
+      )
+
+      clear_config([Pleroma.Upload, :uploader])
+
+      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
diff --git a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
index 34d48c2c1..5efe8ef71 100644
--- a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
@@ -2038,7 +2038,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
                |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
                |> json_response(200)
 
-      assert [backup] = Repo.all(Pleroma.Backup)
+      assert [backup] = Repo.all(Pleroma.User.Backup)
 
       ObanHelpers.perform_all()
 
@@ -2079,7 +2079,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
                |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
                |> json_response(200)
 
-      assert [_backup] = Repo.all(Pleroma.Backup)
+      assert [_backup] = Repo.all(Pleroma.User.Backup)
 
       assert "" ==
                conn
@@ -2088,7 +2088,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
                |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
                |> json_response(200)
 
-      assert Repo.aggregate(Pleroma.Backup, :count) == 2
+      assert Repo.aggregate(Pleroma.User.Backup, :count) == 2
     end
   end
 end
diff --git a/test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs
index b2ac74c7d..f1941f6dd 100644
--- a/test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs
+++ b/test/pleroma/web/pleroma_api/controllers/backup_controller_test.exs
@@ -5,7 +5,7 @@
 defmodule Pleroma.Web.PleromaAPI.BackupControllerTest do
   use Pleroma.Web.ConnCase
 
-  alias Pleroma.Backup
+  alias Pleroma.User.Backup
   alias Pleroma.Web.PleromaAPI.BackupView
 
   setup do
-- 
cgit v1.2.3


From 034ac43f3a91178694d3c621c52ce68207ec4f69 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 20 Oct 2020 17:47:04 +0400
Subject: Fix credo warnings

---
 test/pleroma/user/backup_test.exs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
index 5ad587833..513798911 100644
--- a/test/pleroma/user/backup_test.exs
+++ b/test/pleroma/user/backup_test.exs
@@ -10,9 +10,9 @@ defmodule Pleroma.User.BackupTest do
   import Pleroma.Factory
   import Swoosh.TestAssertions
 
-  alias Pleroma.User.Backup
   alias Pleroma.Bookmark
   alias Pleroma.Tests.ObanHelpers
+  alias Pleroma.User.Backup
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Workers.BackupWorker
 
-- 
cgit v1.2.3


From 4f90077767b416f3469fe7c8acfaa6932c579ec2 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 28 Oct 2020 15:32:44 +0400
Subject: Fix warning

---
 test/pleroma/user/backup_test.exs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
index 513798911..f68e4a029 100644
--- a/test/pleroma/user/backup_test.exs
+++ b/test/pleroma/user/backup_test.exs
@@ -82,7 +82,7 @@ defmodule Pleroma.User.BackupTest do
 
     assert {:ok, job1} = Backup.create(user)
 
-    assert {:ok, %Backup{id: backup1_id}} = ObanHelpers.perform(job1)
+    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)
-- 
cgit v1.2.3


From 1a98476f48db380b5d26b882dad7fba745b3f160 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Fri, 30 Oct 2020 16:39:14 +0400
Subject: Remove unused aliases

---
 test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs     | 1 -
 test/pleroma/web/admin_api/controllers/chat_controller_test.exs          | 1 -
 .../web/admin_api/controllers/instance_document_controller_test.exs      | 1 -
 test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs    | 1 -
 test/pleroma/web/admin_api/controllers/relay_controller_test.exs         | 1 -
 test/pleroma/web/admin_api/controllers/report_controller_test.exs        | 1 -
 test/pleroma/web/admin_api/controllers/status_controller_test.exs        | 1 -
 test/pleroma/web/admin_api/controllers/user_controller_test.exs          | 1 -
 test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs   | 1 -
 test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs | 1 -
 test/pleroma/web/plugs/http_security_plug_test.exs                       | 1 -
 test/pleroma/web/twitter_api/remote_follow_controller_test.exs           | 1 -
 12 files changed, 12 deletions(-)

(limited to 'test')

diff --git a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
index 34b26dddf..e2d6d5f6e 100644
--- a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
@@ -11,7 +11,6 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
   import Swoosh.TestAssertions
 
   alias Pleroma.Activity
-  alias Pleroma.Config
   alias Pleroma.MFA
   alias Pleroma.ModerationLog
   alias Pleroma.Repo
diff --git a/test/pleroma/web/admin_api/controllers/chat_controller_test.exs b/test/pleroma/web/admin_api/controllers/chat_controller_test.exs
index bd4c9c9d1..5aefa1e60 100644
--- a/test/pleroma/web/admin_api/controllers/chat_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/chat_controller_test.exs
@@ -9,7 +9,6 @@ defmodule Pleroma.Web.AdminAPI.ChatControllerTest do
 
   alias Pleroma.Chat
   alias Pleroma.Chat.MessageReference
-  alias Pleroma.Config
   alias Pleroma.ModerationLog
   alias Pleroma.Object
   alias Pleroma.Repo
diff --git a/test/pleroma/web/admin_api/controllers/instance_document_controller_test.exs b/test/pleroma/web/admin_api/controllers/instance_document_controller_test.exs
index 5f7b042f6..ce867dd0e 100644
--- a/test/pleroma/web/admin_api/controllers/instance_document_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/instance_document_controller_test.exs
@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.AdminAPI.InstanceDocumentControllerTest do
   use Pleroma.Web.ConnCase, async: true
   import Pleroma.Factory
-  alias Pleroma.Config
 
   @dir "test/tmp/instance_static"
   @default_instance_panel ~s(<p>Welcome to <a href="https://pleroma.social" target="_blank">Pleroma!</a></p>)
diff --git a/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs b/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs
index ed7c4172c..f388375d1 100644
--- a/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs
@@ -8,7 +8,6 @@ defmodule Pleroma.Web.AdminAPI.OAuthAppControllerTest do
 
   import Pleroma.Factory
 
-  alias Pleroma.Config
   alias Pleroma.Web
 
   setup do
diff --git a/test/pleroma/web/admin_api/controllers/relay_controller_test.exs b/test/pleroma/web/admin_api/controllers/relay_controller_test.exs
index adadf2b5c..b4c5e7567 100644
--- a/test/pleroma/web/admin_api/controllers/relay_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/relay_controller_test.exs
@@ -7,7 +7,6 @@ defmodule Pleroma.Web.AdminAPI.RelayControllerTest do
 
   import Pleroma.Factory
 
-  alias Pleroma.Config
   alias Pleroma.ModerationLog
   alias Pleroma.Repo
   alias Pleroma.User
diff --git a/test/pleroma/web/admin_api/controllers/report_controller_test.exs b/test/pleroma/web/admin_api/controllers/report_controller_test.exs
index 57946e6bb..fa746d6ea 100644
--- a/test/pleroma/web/admin_api/controllers/report_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/report_controller_test.exs
@@ -8,7 +8,6 @@ defmodule Pleroma.Web.AdminAPI.ReportControllerTest do
   import Pleroma.Factory
 
   alias Pleroma.Activity
-  alias Pleroma.Config
   alias Pleroma.ModerationLog
   alias Pleroma.Repo
   alias Pleroma.ReportNote
diff --git a/test/pleroma/web/admin_api/controllers/status_controller_test.exs b/test/pleroma/web/admin_api/controllers/status_controller_test.exs
index eff78fb0a..a18ef9e4b 100644
--- a/test/pleroma/web/admin_api/controllers/status_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/status_controller_test.exs
@@ -8,7 +8,6 @@ defmodule Pleroma.Web.AdminAPI.StatusControllerTest do
   import Pleroma.Factory
 
   alias Pleroma.Activity
-  alias Pleroma.Config
   alias Pleroma.ModerationLog
   alias Pleroma.Repo
   alias Pleroma.User
diff --git a/test/pleroma/web/admin_api/controllers/user_controller_test.exs b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
index da26caf25..5705306c7 100644
--- a/test/pleroma/web/admin_api/controllers/user_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
@@ -9,7 +9,6 @@ defmodule Pleroma.Web.AdminAPI.UserControllerTest do
   import Mock
   import Pleroma.Factory
 
-  alias Pleroma.Config
   alias Pleroma.HTML
   alias Pleroma.ModerationLog
   alias Pleroma.Repo
diff --git a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
index c6e0268fd..9f1ee0424 100644
--- a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
+++ b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
@@ -8,7 +8,6 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
   import Pleroma.Factory
   import Tesla.Mock
 
-  alias Pleroma.Config
   alias Pleroma.User
   alias Pleroma.Web.CommonAPI
 
diff --git a/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs
index 433c97e81..68723de71 100644
--- a/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs
+++ b/test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs
@@ -6,7 +6,6 @@ defmodule Pleroma.Web.PleromaAPI.UserImportControllerTest do
   use Pleroma.Web.ConnCase
   use Oban.Testing, repo: Pleroma.Repo
 
-  alias Pleroma.Config
   alias Pleroma.Tests.ObanHelpers
 
   import Pleroma.Factory
diff --git a/test/pleroma/web/plugs/http_security_plug_test.exs b/test/pleroma/web/plugs/http_security_plug_test.exs
index 2297e3dac..df2b5ebb3 100644
--- a/test/pleroma/web/plugs/http_security_plug_test.exs
+++ b/test/pleroma/web/plugs/http_security_plug_test.exs
@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.Plugs.HTTPSecurityPlugTest do
   use Pleroma.Web.ConnCase
 
-  alias Pleroma.Config
   alias Plug.Conn
 
   describe "http security enabled" do
diff --git a/test/pleroma/web/twitter_api/remote_follow_controller_test.exs b/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
index 3852c7ce9..a3e784d13 100644
--- a/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
+++ b/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.TwitterAPI.RemoteFollowControllerTest do
   use Pleroma.Web.ConnCase
 
-  alias Pleroma.Config
   alias Pleroma.MFA
   alias Pleroma.MFA.TOTP
   alias Pleroma.User
-- 
cgit v1.2.3


From 8e41baff40555ef7c74c8842d6fbfebc2368631a Mon Sep 17 00:00:00 2001
From: eugenijm <eugenijm@protonmail.com>
Date: Sat, 31 Oct 2020 05:50:48 +0300
Subject: Add idempotency_key to the chat_message entity.

---
 test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs    | 2 ++
 .../web/pleroma_api/views/chat_message_reference_view_test.exs       | 5 ++++-
 test/pleroma/web/streamer_test.exs                                   | 4 +++-
 3 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'test')

diff --git a/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
index 6381f9757..fa6b9db65 100644
--- a/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
+++ b/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
@@ -82,11 +82,13 @@ defmodule Pleroma.Web.PleromaAPI.ChatControllerTest do
       result =
         conn
         |> put_req_header("content-type", "application/json")
+        |> put_req_header("idempotency-key", "123")
         |> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{"content" => "Hallo!!"})
         |> json_response_and_validate_schema(200)
 
       assert result["content"] == "Hallo!!"
       assert result["chat_id"] == chat.id |> to_string()
+      assert result["idempotency_key"] == "123"
     end
 
     test "it fails if there is no content", %{conn: conn, user: user} do
diff --git a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
index f171a1e55..ae8257870 100644
--- a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
+++ b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
@@ -25,7 +25,9 @@ defmodule Pleroma.Web.PleromaAPI.ChatMessageReferenceViewTest do
     }
 
     {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
-    {:ok, activity} = CommonAPI.post_chat_message(user, recipient, "kippis :firefox:")
+
+    {:ok, activity} =
+      CommonAPI.post_chat_message(user, recipient, "kippis :firefox:", idempotency_key: "123")
 
     chat = Chat.get(user.id, recipient.ap_id)
 
@@ -42,6 +44,7 @@ defmodule Pleroma.Web.PleromaAPI.ChatMessageReferenceViewTest do
     assert chat_message[:created_at]
     assert chat_message[:unread] == false
     assert match?([%{shortcode: "firefox"}], chat_message[:emojis])
+    assert chat_message[:idempotency_key] == "123"
 
     clear_config([:rich_media, :enabled], true)
 
diff --git a/test/pleroma/web/streamer_test.exs b/test/pleroma/web/streamer_test.exs
index 185724a9f..395016da2 100644
--- a/test/pleroma/web/streamer_test.exs
+++ b/test/pleroma/web/streamer_test.exs
@@ -255,7 +255,9 @@ defmodule Pleroma.Web.StreamerTest do
     } do
       other_user = insert(:user)
 
-      {:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey cirno")
+      {:ok, create_activity} =
+        CommonAPI.post_chat_message(other_user, user, "hey cirno", idempotency_key: "123")
+
       object = Object.normalize(create_activity, false)
       chat = Chat.get(user.id, other_user.ap_id)
       cm_ref = MessageReference.for_chat_and_object(chat, object)
-- 
cgit v1.2.3


From 4caad4e9101c34debfa90d2e89850d4125a471b3 Mon Sep 17 00:00:00 2001
From: "Haelwenn (lanodan) Monnier" <contact@hacktivis.me>
Date: Mon, 2 Nov 2020 05:43:06 +0100
Subject: =?UTF-8?q?side=5Feffects:=20Don=E2=80=99t=20increase=5Freplies=5F?=
 =?UTF-8?q?count=20when=20it=E2=80=99s=20an=20Answer?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
index 0f6605c3f..e7d85a2c5 100644
--- a/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
+++ b/test/pleroma/web/activity_pub/transmogrifier/answer_handling_test.exs
@@ -27,6 +27,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.AnswerHandlingTest do
       })
 
     object = Object.normalize(activity)
+    assert object.data["repliesCount"] == nil
 
     data =
       File.read!("test/fixtures/mastodon-vote.json")
@@ -41,7 +42,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.AnswerHandlingTest do
     assert answer_object.data["inReplyTo"] == object.data["id"]
 
     new_object = Object.get_by_ap_id(object.data["id"])
-    assert new_object.data["replies_count"] == object.data["replies_count"]
+    assert new_object.data["repliesCount"] == nil
 
     assert Enum.any?(
              new_object.data["oneOf"],
-- 
cgit v1.2.3


From 53dd048590b93da67f9d4abac8cc111424c4d5c0 Mon Sep 17 00:00:00 2001
From: Mark Felder <feld@FreeBSD.org>
Date: Mon, 2 Nov 2020 15:49:07 -0600
Subject: Test the note is returned when fetching a single report

---
 .../pleroma/web/admin_api/controllers/report_controller_test.exs | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'test')

diff --git a/test/pleroma/web/admin_api/controllers/report_controller_test.exs b/test/pleroma/web/admin_api/controllers/report_controller_test.exs
index fa746d6ea..958e1d3ab 100644
--- a/test/pleroma/web/admin_api/controllers/report_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/report_controller_test.exs
@@ -37,12 +37,21 @@ defmodule Pleroma.Web.AdminAPI.ReportControllerTest do
           status_ids: [activity.id]
         })
 
+      conn
+      |> put_req_header("content-type", "application/json")
+      |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
+        content: "this is an admin note"
+      })
+
       response =
         conn
         |> get("/api/pleroma/admin/reports/#{report_id}")
         |> json_response_and_validate_schema(:ok)
 
       assert response["id"] == report_id
+
+      [notes] = response["notes"]
+      assert notes["content"] == "this is an admin note"
     end
 
     test "returns 404 when report id is invalid", %{conn: conn} do
-- 
cgit v1.2.3