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-2020 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 == [user2]
  51       end
  52     end
  53
  54     test "it imports new-style mastodon follow lists", %{conn: conn} do
  55       user2 = insert(:user)
  56
  57       response =
  58         conn
  59         |> put_req_header("content-type", "application/json")
  60         |> post("/api/pleroma/follow_import", %{
  61           "list" => "Account address,Show boosts\n#{user2.ap_id},true"
  62         })
  63         |> json_response_and_validate_schema(200)
  64
  65       assert response == "job started"
  66     end
  67
  68     test "requires 'follow' or 'write:follows' permissions" do
  69       token1 = insert(:oauth_token, scopes: ["read", "write"])
  70       token2 = insert(:oauth_token, scopes: ["follow"])
  71       token3 = insert(:oauth_token, scopes: ["something"])
  72       another_user = insert(:user)
  73
  74       for token <- [token1, token2, token3] do
  75         conn =
  76           build_conn()
  77           |> put_req_header("authorization", "Bearer #{token.token}")
  78           |> put_req_header("content-type", "application/json")
  79           |> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})
  80
  81         if token == token3 do
  82           assert %{"error" => "Insufficient permissions: follow | write:follows."} ==
  83                    json_response(conn, 403)
  84         else
  85           assert json_response(conn, 200)
  86         end
  87       end
  88     end
  89
  90     test "it imports follows with different nickname variations", %{conn: conn} do
  91       users = [user2, user3, user4, user5, user6] = insert_list(5, :user)
  92
  93       identifiers =
  94         [
  95           user2.ap_id,
  96           user3.nickname,
  97           "  ",
  98           "@" <> user4.nickname,
  99           user5.nickname <> "@localhost",
 100           "@" <> user6.nickname <> "@localhost"
 101         ]
 102         |> Enum.join("\n")
 103
 104       assert "job started" ==
 105                conn
 106                |> put_req_header("content-type", "application/json")
 107                |> post("/api/pleroma/follow_import", %{"list" => identifiers})
 108                |> json_response_and_validate_schema(200)
 109
 110       assert [{:ok, job_result}] = ObanHelpers.perform_all()
 111       assert job_result == users
 112     end
 113   end
 114
 115   describe "POST /api/pleroma/blocks_import" do
 116     # Note: "follow" or "write:blocks" permission is required
 117     setup do: oauth_access(["write:blocks"])
 118
 119     test "it returns HTTP 200", %{conn: conn} do
 120       user2 = insert(:user)
 121
 122       assert "job started" ==
 123                conn
 124                |> put_req_header("content-type", "application/json")
 125                |> post("/api/pleroma/blocks_import", %{"list" => "#{user2.ap_id}"})
 126                |> json_response_and_validate_schema(200)
 127     end
 128
 129     test "it imports blocks users from file", %{conn: conn} do
 130       users = [user2, user3] = insert_list(2, :user)
 131
 132       with_mocks([
 133         {File, [], read!: fn "blocks_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
 134       ]) do
 135         assert "job started" ==
 136                  conn
 137                  |> put_req_header("content-type", "application/json")
 138                  |> post("/api/pleroma/blocks_import", %{
 139                    "list" => %Plug.Upload{path: "blocks_list.txt"}
 140                  })
 141                  |> json_response_and_validate_schema(200)
 142
 143         assert [{:ok, job_result}] = ObanHelpers.perform_all()
 144         assert job_result == users
 145       end
 146     end
 147
 148     test "it imports blocks with different nickname variations", %{conn: conn} do
 149       users = [user2, user3, user4, user5, user6] = insert_list(5, :user)
 150
 151       identifiers =
 152         [
 153           user2.ap_id,
 154           user3.nickname,
 155           "@" <> user4.nickname,
 156           user5.nickname <> "@localhost",
 157           "@" <> user6.nickname <> "@localhost"
 158         ]
 159         |> Enum.join(" ")
 160
 161       assert "job started" ==
 162                conn
 163                |> put_req_header("content-type", "application/json")
 164                |> post("/api/pleroma/blocks_import", %{"list" => identifiers})
 165                |> json_response_and_validate_schema(200)
 166
 167       assert [{:ok, job_result}] = ObanHelpers.perform_all()
 168       assert job_result == users
 169     end
 170   end
 171
 172   describe "POST /api/pleroma/mutes_import" do
 173     # Note: "follow" or "write:mutes" permission is required
 174     setup do: oauth_access(["write:mutes"])
 175
 176     test "it returns HTTP 200", %{user: user, conn: conn} do
 177       user2 = insert(:user)
 178
 179       assert "job started" ==
 180                conn
 181                |> put_req_header("content-type", "application/json")
 182                |> post("/api/pleroma/mutes_import", %{"list" => "#{user2.ap_id}"})
 183                |> json_response_and_validate_schema(200)
 184
 185       assert [{:ok, job_result}] = ObanHelpers.perform_all()
 186       assert job_result == [user2]
 187       assert Pleroma.User.mutes?(user, user2)
 188     end
 189
 190     test "it imports mutes users from file", %{user: user, conn: conn} do
 191       users = [user2, user3] = insert_list(2, :user)
 192
 193       with_mocks([
 194         {File, [], read!: fn "mutes_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
 195       ]) do
 196         assert "job started" ==
 197                  conn
 198                  |> put_req_header("content-type", "application/json")
 199                  |> post("/api/pleroma/mutes_import", %{
 200                    "list" => %Plug.Upload{path: "mutes_list.txt"}
 201                  })
 202                  |> json_response_and_validate_schema(200)
 203
 204         assert [{:ok, job_result}] = ObanHelpers.perform_all()
 205         assert job_result == users
 206         assert Enum.all?(users, &Pleroma.User.mutes?(user, &1))
 207       end
 208     end
 209
 210     test "it imports mutes with different nickname variations", %{user: user, conn: conn} do
 211       users = [user2, user3, user4, user5, user6] = insert_list(5, :user)
 212
 213       identifiers =
 214         [
 215           user2.ap_id,
 216           user3.nickname,
 217           "@" <> user4.nickname,
 218           user5.nickname <> "@localhost",
 219           "@" <> user6.nickname <> "@localhost"
 220         ]
 221         |> Enum.join(" ")
 222
 223       assert "job started" ==
 224                conn
 225                |> put_req_header("content-type", "application/json")
 226                |> post("/api/pleroma/mutes_import", %{"list" => identifiers})
 227                |> json_response_and_validate_schema(200)
 228
 229       assert [{:ok, job_result}] = ObanHelpers.perform_all()
 230       assert job_result == users
 231       assert Enum.all?(users, &Pleroma.User.mutes?(user, &1))
 232     end
 233   end
 234 end