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