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