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