git.squeep.com Git - akkoma/blob - test/pleroma/web/pleroma_api/controllers/user_import_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.PleromaAPI.UserImportControllerTest do
   6   use Pleroma.Web.ConnCase
   7   use Oban.Testing, repo: Pleroma.Repo
   8
   9   alias Pleroma.Tests.ObanHelpers
  10
  11   import Pleroma.Factory
  12   import Mock
  13
  14   setup do
  15     Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  16     :ok
  17   end
  18
  19   describe "POST /api/pleroma/follow_import" do
  20     setup do: oauth_access(["follow"])
  21
  22     test "it returns HTTP 200", %{conn: conn} do
  23       user2 = insert(:user)
  24
  25       assert "job started" ==
  26                conn
  27                |> put_req_header("content-type", "application/json")
  28                |> post("/api/pleroma/follow_import", %{"list" => "#{user2.ap_id}"})
  29                |> json_response_and_validate_schema(200)
  30     end
  31
  32     test "it imports follow lists from file", %{conn: conn} do
  33       user2 = insert(:user)
  34
  35       with_mocks([
  36         {File, [],
  37          read!: fn "follow_list.txt" ->
  38            "Account address,Show boosts\n#{user2.ap_id},true"
  39          end}
  40       ]) do
  41         assert "job started" ==
  42                  conn
  43                  |> put_req_header("content-type", "application/json")
  44                  |> post("/api/pleroma/follow_import", %{
  45                    "list" => %Plug.Upload{path: "follow_list.txt"}
  46                  })
  47                  |> json_response_and_validate_schema(200)
  48
  49         assert [{:ok, job_result}] = ObanHelpers.perform_all()
  50         assert job_result == refresh_record(user2)
  51         assert %Pleroma.User{follower_count: 1} = job_result
  52       end
  53     end
  54
  55     test "it imports new-style mastodon follow lists", %{conn: conn} do
  56       user2 = insert(:user)
  57
  58       response =
  59         conn
  60         |> put_req_header("content-type", "application/json")
  61         |> post("/api/pleroma/follow_import", %{
  62           "list" => "Account address,Show boosts\n#{user2.ap_id},true"
  63         })
  64         |> json_response_and_validate_schema(200)
  65
  66       assert response == "job started"
  67     end
  68
  69     test "requires 'follow' or 'write:follows' permissions" do
  70       token1 = insert(:oauth_token, scopes: ["read", "write"])
  71       token2 = insert(:oauth_token, scopes: ["follow"])
  72       token3 = insert(:oauth_token, scopes: ["something"])
  73       another_user = insert(:user)
  74
  75       for token <- [token1, token2, token3] do
  76         conn =
  77           build_conn()
  78           |> put_req_header("authorization", "Bearer #{token.token}")
  79           |> put_req_header("content-type", "application/json")
  80           |> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})
  81
  82         if token == token3 do
  83           assert %{"error" => "Insufficient permissions: follow | write:follows."} ==
  84                    json_response(conn, 403)
  85         else
  86           assert json_response_and_validate_schema(conn, 200)
  87         end
  88       end
  89     end
  90
  91     test "it imports follows with different nickname variations", %{conn: conn} do
  92       users = [user2, user3, user4, user5, user6] = insert_list(5, :user)
  93
  94       identifiers =
  95         [
  96           user2.ap_id,
  97           user3.nickname,
  98           "  ",
  99           "@" <> user4.nickname,
 100           user5.nickname <> "@localhost",
 101           "@" <> user6.nickname <> "@localhost"
 102         ]
 103         |> Enum.join("\n")
 104
 105       assert "job started" ==
 106                conn
 107                |> put_req_header("content-type", "application/json")
 108                |> post("/api/pleroma/follow_import", %{"list" => identifiers})
 109                |> json_response_and_validate_schema(200)
 110
 111       job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
 112       assert job_results == Enum.map(users, &refresh_record/1)
 113     end
 114   end
 115
 116   describe "POST /api/pleroma/blocks_import" do
 117     # Note: "follow" or "write:blocks" permission is required
 118     setup do: oauth_access(["write:blocks"])
 119
 120     test "it returns HTTP 200", %{conn: conn} do
 121       user2 = insert(:user)
 122
 123       assert "job started" ==
 124                conn
 125                |> put_req_header("content-type", "application/json")
 126                |> post("/api/pleroma/blocks_import", %{"list" => "#{user2.ap_id}"})
 127                |> json_response_and_validate_schema(200)
 128     end
 129
 130     test "it imports blocks users from file", %{conn: conn} do
 131       users = [user2, user3] = insert_list(2, :user)
 132
 133       with_mocks([
 134         {File, [], read!: fn "blocks_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
 135       ]) do
 136         assert "job started" ==
 137                  conn
 138                  |> put_req_header("content-type", "application/json")
 139                  |> post("/api/pleroma/blocks_import", %{
 140                    "list" => %Plug.Upload{path: "blocks_list.txt"}
 141                  })
 142                  |> json_response_and_validate_schema(200)
 143
 144         job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
 145         assert job_results == users
 146       end
 147     end
 148
 149     test "it imports blocks with different nickname variations", %{conn: conn} do
 150       users = [user2, user3, user4, user5, user6] = insert_list(5, :user)
 151
 152       identifiers =
 153         [
 154           user2.ap_id,
 155           user3.nickname,
 156           "@" <> user4.nickname,
 157           user5.nickname <> "@localhost",
 158           "@" <> user6.nickname <> "@localhost"
 159         ]
 160         |> Enum.join(" ")
 161
 162       assert "job started" ==
 163                conn
 164                |> put_req_header("content-type", "application/json")
 165                |> post("/api/pleroma/blocks_import", %{"list" => identifiers})
 166                |> json_response_and_validate_schema(200)
 167
 168       job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
 169       assert job_results == users
 170     end
 171   end
 172
 173   describe "POST /api/pleroma/mutes_import" do
 174     # Note: "follow" or "write:mutes" permission is required
 175     setup do: oauth_access(["write:mutes"])
 176
 177     test "it returns HTTP 200", %{user: user, conn: conn} do
 178       user2 = insert(:user)
 179
 180       assert "job started" ==
 181                conn
 182                |> put_req_header("content-type", "application/json")
 183                |> post("/api/pleroma/mutes_import", %{"list" => "#{user2.ap_id}"})
 184                |> json_response_and_validate_schema(200)
 185
 186       job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
 187       assert job_results == [user2]
 188       assert Pleroma.User.mutes?(user, user2)
 189     end
 190
 191     test "it imports muted users from file", %{user: user, conn: conn} do
 192       users = [user2, user3] = insert_list(2, :user)
 193
 194       with_mocks([
 195         {File, [], read!: fn "mutes_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
 196       ]) do
 197         assert "job started" ==
 198                  conn
 199                  |> put_req_header("content-type", "application/json")
 200                  |> post("/api/pleroma/mutes_import", %{
 201                    "list" => %Plug.Upload{path: "mutes_list.txt"}
 202                  })
 203                  |> json_response_and_validate_schema(200)
 204
 205         job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
 206         assert job_results == users
 207         assert Enum.all?(users, &Pleroma.User.mutes?(user, &1))
 208       end
 209     end
 210
 211     test "it imports mutes with different nickname variations", %{user: user, conn: conn} do
 212       users = [user2, user3, user4, user5, user6] = insert_list(5, :user)
 213
 214       identifiers =
 215         [
 216           user2.ap_id,
 217           user3.nickname,
 218           "@" <> user4.nickname,
 219           user5.nickname <> "@localhost",
 220           "@" <> user6.nickname <> "@localhost"
 221         ]
 222         |> Enum.join(" ")
 223
 224       assert "job started" ==
 225                conn
 226                |> put_req_header("content-type", "application/json")
 227                |> post("/api/pleroma/mutes_import", %{"list" => identifiers})
 228                |> json_response_and_validate_schema(200)
 229
 230       job_results = Enum.map(ObanHelpers.perform_all(), fn {:ok, result} -> result end)
 231       assert job_results == users
 232       assert Enum.all?(users, &Pleroma.User.mutes?(user, &1))
 233     end
 234   end
 235 end