git.squeep.com Git - akkoma/blob - test/web/twitter_api/remote_follow_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.TwitterAPI.RemoteFollowControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.User
   9   alias Pleroma.Web.CommonAPI
  10   import ExUnit.CaptureLog
  11   import Pleroma.Factory
  12
  13   setup do
  14     Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  15     :ok
  16   end
  17
  18   clear_config([:instance])
  19   clear_config([:frontend_configurations, :pleroma_fe])
  20   clear_config([:user, :deny_follow_blocked])
  21
  22   describe "GET /ostatus_subscribe - remote_follow/2" do
  23     test "adds status to pleroma instance if the `acct` is a status", %{conn: conn} do
  24       assert conn
  25              |> get(
  26                remote_follow_path(conn, :follow, %{
  27                  acct: "https://mastodon.social/users/emelie/statuses/101849165031453009"
  28                })
  29              )
  30              |> redirected_to() =~ "/notice/"
  31     end
  32
  33     test "show follow account page if the `acct` is a account link", %{conn: conn} do
  34       response =
  35         conn
  36         |> get(remote_follow_path(conn, :follow, %{acct: "https://mastodon.social/users/emelie"}))
  37         |> html_response(200)
  38
  39       assert response =~ "Log in to follow"
  40     end
  41
  42     test "show follow page if the `acct` is a account link", %{conn: conn} do
  43       user = insert(:user)
  44
  45       response =
  46         conn
  47         |> assign(:user, user)
  48         |> get(remote_follow_path(conn, :follow, %{acct: "https://mastodon.social/users/emelie"}))
  49         |> html_response(200)
  50
  51       assert response =~ "Remote follow"
  52     end
  53
  54     test "show follow page with error when user cannot fecth by `acct` link", %{conn: conn} do
  55       user = insert(:user)
  56
  57       assert capture_log(fn ->
  58                response =
  59                  conn
  60                  |> assign(:user, user)
  61                  |> get(
  62                    remote_follow_path(conn, :follow, %{
  63                      acct: "https://mastodon.social/users/not_found"
  64                    })
  65                  )
  66                  |> html_response(200)
  67
  68                assert response =~ "Error fetching user"
  69              end) =~ "Object has been deleted"
  70     end
  71   end
  72
  73   describe "POST /ostatus_subscribe - do_remote_follow/2 with assigned user " do
  74     test "follows user", %{conn: conn} do
  75       user = insert(:user)
  76       user2 = insert(:user)
  77
  78       response =
  79         conn
  80         |> assign(:user, user)
  81         |> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
  82         |> response(200)
  83
  84       assert response =~ "Account followed!"
  85       assert user2.follower_address in User.following(user)
  86     end
  87
  88     test "returns error when user is deactivated", %{conn: conn} do
  89       user = insert(:user, deactivated: true)
  90       user2 = insert(:user)
  91
  92       response =
  93         conn
  94         |> assign(:user, user)
  95         |> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
  96         |> response(200)
  97
  98       assert response =~ "Error following account"
  99     end
 100
 101     test "returns error when user is blocked", %{conn: conn} do
 102       Pleroma.Config.put([:user, :deny_follow_blocked], true)
 103       user = insert(:user)
 104       user2 = insert(:user)
 105
 106       {:ok, _user_block} = Pleroma.User.block(user2, user)
 107
 108       response =
 109         conn
 110         |> assign(:user, user)
 111         |> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
 112         |> response(200)
 113
 114       assert response =~ "Error following account"
 115     end
 116
 117     test "returns error when followee not found", %{conn: conn} do
 118       user = insert(:user)
 119
 120       response =
 121         conn
 122         |> assign(:user, user)
 123         |> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => "jimm"}})
 124         |> response(200)
 125
 126       assert response =~ "Error following account"
 127     end
 128
 129     test "returns success result when user already in followers", %{conn: conn} do
 130       user = insert(:user)
 131       user2 = insert(:user)
 132       {:ok, _, _, _} = CommonAPI.follow(user, user2)
 133
 134       response =
 135         conn
 136         |> assign(:user, refresh_record(user))
 137         |> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
 138         |> response(200)
 139
 140       assert response =~ "Account followed!"
 141     end
 142   end
 143
 144   describe "POST /ostatus_subscribe - do_remote_follow/2 without assigned user " do
 145     test "follows", %{conn: conn} do
 146       user = insert(:user)
 147       user2 = insert(:user)
 148
 149       response =
 150         conn
 151         |> post(remote_follow_path(conn, :do_follow), %{
 152           "authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
 153         })
 154         |> response(200)
 155
 156       assert response =~ "Account followed!"
 157       assert user2.follower_address in User.following(user)
 158     end
 159
 160     test "returns error when followee not found", %{conn: conn} do
 161       user = insert(:user)
 162
 163       response =
 164         conn
 165         |> post(remote_follow_path(conn, :do_follow), %{
 166           "authorization" => %{"name" => user.nickname, "password" => "test", "id" => "jimm"}
 167         })
 168         |> response(200)
 169
 170       assert response =~ "Error following account"
 171     end
 172
 173     test "returns error when login invalid", %{conn: conn} do
 174       user = insert(:user)
 175
 176       response =
 177         conn
 178         |> post(remote_follow_path(conn, :do_follow), %{
 179           "authorization" => %{"name" => "jimm", "password" => "test", "id" => user.id}
 180         })
 181         |> response(200)
 182
 183       assert response =~ "Wrong username or password"
 184     end
 185
 186     test "returns error when password invalid", %{conn: conn} do
 187       user = insert(:user)
 188       user2 = insert(:user)
 189
 190       response =
 191         conn
 192         |> post(remote_follow_path(conn, :do_follow), %{
 193           "authorization" => %{"name" => user.nickname, "password" => "42", "id" => user2.id}
 194         })
 195         |> response(200)
 196
 197       assert response =~ "Wrong username or password"
 198     end
 199
 200     test "returns error when user is blocked", %{conn: conn} do
 201       Pleroma.Config.put([:user, :deny_follow_blocked], true)
 202       user = insert(:user)
 203       user2 = insert(:user)
 204       {:ok, _user_block} = Pleroma.User.block(user2, user)
 205
 206       response =
 207         conn
 208         |> post(remote_follow_path(conn, :do_follow), %{
 209           "authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
 210         })
 211         |> response(200)
 212
 213       assert response =~ "Error following account"
 214     end
 215   end
 216 end