git.squeep.com Git - akkoma/blob - test/backup_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.BackupTest do
   6   use Oban.Testing, repo: Pleroma.Repo
   7   use Pleroma.DataCase
   8
   9   import Pleroma.Factory
  10   import Mock
  11
  12   alias Pleroma.Backup
  13   alias Pleroma.Bookmark
  14   alias Pleroma.Tests.ObanHelpers
  15   alias Pleroma.Web.CommonAPI
  16   alias Pleroma.Workers.BackupWorker
  17
  18   setup do
  19     clear_config([Pleroma.Upload, :uploader])
  20     clear_config([Pleroma.Backup, :limit_days])
  21     clear_config([Pleroma.Emails.Mailer, :enabled])
  22   end
  23
  24   test "it requries enabled email" do
  25     Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
  26     user = insert(:user)
  27     assert {:error, "Backups require enabled email"} == Backup.create(user)
  28   end
  29
  30   test "it requries user's email" do
  31     user = insert(:user, %{email: nil})
  32     assert {:error, "Email is required"} == Backup.create(user)
  33   end
  34
  35   test "it creates a backup record and an Oban job" do
  36     %{id: user_id} = user = insert(:user)
  37     assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
  38     assert_enqueued(worker: BackupWorker, args: args)
  39
  40     backup = Backup.get(args["backup_id"])
  41     assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup
  42   end
  43
  44   test "it return an error if the export limit is over" do
  45     %{id: user_id} = user = insert(:user)
  46     limit_days = Pleroma.Config.get([Pleroma.Backup, :limit_days])
  47     assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
  48     backup = Backup.get(args["backup_id"])
  49     assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup
  50
  51     assert Backup.create(user) == {:error, "Last export was less than #{limit_days} days ago"}
  52   end
  53
  54   test "it process a backup record" do
  55     Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
  56     %{id: user_id} = user = insert(:user)
  57
  58     assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
  59     assert {:ok, backup} = perform_job(BackupWorker, args)
  60     assert backup.file_size > 0
  61     assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup
  62
  63     delete_job_args = %{"op" => "delete", "backup_id" => backup_id}
  64
  65     assert_enqueued(worker: BackupWorker, args: delete_job_args)
  66     assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
  67     refute Backup.get(backup_id)
  68   end
  69
  70   test "it removes outdated backups after creating a fresh one" do
  71     Pleroma.Config.put([Pleroma.Backup, :limit_days], -1)
  72     Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
  73     user = insert(:user)
  74
  75     assert {:ok, job1} = Backup.create(user)
  76
  77     assert {:ok, %Backup{id: backup1_id}} = ObanHelpers.perform(job1)
  78     assert {:ok, job2} = Backup.create(user)
  79     assert Pleroma.Repo.aggregate(Backup, :count) == 2
  80     assert {:ok, backup2} = ObanHelpers.perform(job2)
  81
  82     ObanHelpers.perform_all()
  83
  84     assert [^backup2] = Pleroma.Repo.all(Backup)
  85   end
  86
  87   test "it creates a zip archive with user data" do
  88     user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})
  89
  90     {:ok, %{object: %{data: %{"id" => id1}}} = status1} =
  91       CommonAPI.post(user, %{status: "status1"})
  92
  93     {:ok, %{object: %{data: %{"id" => id2}}} = status2} =
  94       CommonAPI.post(user, %{status: "status2"})
  95
  96     {:ok, %{object: %{data: %{"id" => id3}}} = status3} =
  97       CommonAPI.post(user, %{status: "status3"})
  98
  99     CommonAPI.favorite(user, status1.id)
 100     CommonAPI.favorite(user, status2.id)
 101
 102     Bookmark.create(user.id, status2.id)
 103     Bookmark.create(user.id, status3.id)
 104
 105     assert {:ok, backup} = user |> Backup.new() |> Repo.insert()
 106     assert {:ok, path} = Backup.export(backup)
 107     assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(path), [:memory])
 108     assert {:ok, {'actor.json', json}} = :zip.zip_get('actor.json', zipfile)
 109
 110     assert %{
 111              "@context" => [
 112                "https://www.w3.org/ns/activitystreams",
 113                "http://localhost:4001/schemas/litepub-0.1.jsonld",
 114                %{"@language" => "und"}
 115              ],
 116              "bookmarks" => "bookmarks.json",
 117              "followers" => "http://cofe.io/users/cofe/followers",
 118              "following" => "http://cofe.io/users/cofe/following",
 119              "id" => "http://cofe.io/users/cofe",
 120              "inbox" => "http://cofe.io/users/cofe/inbox",
 121              "likes" => "likes.json",
 122              "name" => "Cofe",
 123              "outbox" => "http://cofe.io/users/cofe/outbox",
 124              "preferredUsername" => "cofe",
 125              "publicKey" => %{
 126                "id" => "http://cofe.io/users/cofe#main-key",
 127                "owner" => "http://cofe.io/users/cofe"
 128              },
 129              "type" => "Person",
 130              "url" => "http://cofe.io/users/cofe"
 131            } = Jason.decode!(json)
 132
 133     assert {:ok, {'outbox.json', json}} = :zip.zip_get('outbox.json', zipfile)
 134
 135     assert %{
 136              "@context" => "https://www.w3.org/ns/activitystreams",
 137              "id" => "outbox.json",
 138              "orderedItems" => [
 139                %{
 140                  "object" => %{
 141                    "actor" => "http://cofe.io/users/cofe",
 142                    "content" => "status1",
 143                    "type" => "Note"
 144                  },
 145                  "type" => "Create"
 146                },
 147                %{
 148                  "object" => %{
 149                    "actor" => "http://cofe.io/users/cofe",
 150                    "content" => "status2"
 151                  }
 152                },
 153                %{
 154                  "actor" => "http://cofe.io/users/cofe",
 155                  "object" => %{
 156                    "content" => "status3"
 157                  }
 158                }
 159              ],
 160              "totalItems" => 3,
 161              "type" => "OrderedCollection"
 162            } = Jason.decode!(json)
 163
 164     assert {:ok, {'likes.json', json}} = :zip.zip_get('likes.json', zipfile)
 165
 166     assert %{
 167              "@context" => "https://www.w3.org/ns/activitystreams",
 168              "id" => "likes.json",
 169              "orderedItems" => [^id1, ^id2],
 170              "totalItems" => 2,
 171              "type" => "OrderedCollection"
 172            } = Jason.decode!(json)
 173
 174     assert {:ok, {'bookmarks.json', json}} = :zip.zip_get('bookmarks.json', zipfile)
 175
 176     assert %{
 177              "@context" => "https://www.w3.org/ns/activitystreams",
 178              "id" => "bookmarks.json",
 179              "orderedItems" => [^id2, ^id3],
 180              "totalItems" => 2,
 181              "type" => "OrderedCollection"
 182            } = Jason.decode!(json)
 183
 184     :zip.zip_close(zipfile)
 185     File.rm!(path)
 186   end
 187
 188   describe "it uploads and deletes a backup archive" do
 189     setup do
 190       clear_config(Pleroma.Uploaders.S3,
 191         bucket: "test_bucket",
 192         public_endpoint: "https://s3.amazonaws.com"
 193       )
 194
 195       clear_config([Pleroma.Upload, :uploader])
 196
 197       user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})
 198
 199       {:ok, status1} = CommonAPI.post(user, %{status: "status1"})
 200       {:ok, status2} = CommonAPI.post(user, %{status: "status2"})
 201       {:ok, status3} = CommonAPI.post(user, %{status: "status3"})
 202       CommonAPI.favorite(user, status1.id)
 203       CommonAPI.favorite(user, status2.id)
 204       Bookmark.create(user.id, status2.id)
 205       Bookmark.create(user.id, status3.id)
 206
 207       assert {:ok, backup} = user |> Backup.new() |> Repo.insert()
 208       assert {:ok, path} = Backup.export(backup)
 209
 210       [path: path, backup: backup]
 211     end
 212
 213     test "S3", %{path: path, backup: backup} do
 214       Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
 215
 216       with_mock ExAws,
 217         request: fn
 218           %{http_method: :put} -> {:ok, :ok}
 219           %{http_method: :delete} -> {:ok, %{status_code: 204}}
 220         end do
 221         assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
 222         assert {:ok, _backup} = Backup.delete(backup)
 223       end
 224
 225       with_mock ExAws, request: fn %{http_method: :delete} -> {:ok, %{status_code: 204}} end do
 226       end
 227     end
 228
 229     test "Local", %{path: path, backup: backup} do
 230       Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
 231
 232       assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
 233       assert {:ok, _backup} = Backup.delete(backup)
 234     end
 235   end
 236 end