git.squeep.com Git - akkoma/blob - test/web/pleroma_api/controllers/account_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.PleromaAPI.AccountControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Config
   9   alias Pleroma.Tests.ObanHelpers
  10   alias Pleroma.User
  11   alias Pleroma.Web.CommonAPI
  12
  13   import Pleroma.Factory
  14   import Swoosh.TestAssertions
  15
  16   @image "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
  17
  18   describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
  19     setup do
  20       {:ok, user} =
  21         insert(:user)
  22         |> User.confirmation_changeset(need_confirmation: true)
  23         |> User.update_and_set_cache()
  24
  25       assert user.confirmation_pending
  26
  27       [user: user]
  28     end
  29
  30     clear_config([:instance, :account_activation_required]) do
  31       Config.put([:instance, :account_activation_required], true)
  32     end
  33
  34     test "resend account confirmation email", %{conn: conn, user: user} do
  35       conn
  36       |> assign(:user, user)
  37       |> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
  38       |> json_response(:no_content)
  39
  40       ObanHelpers.perform_all()
  41
  42       email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
  43       notify_email = Config.get([:instance, :notify_email])
  44       instance_name = Config.get([:instance, :name])
  45
  46       assert_email_sent(
  47         from: {instance_name, notify_email},
  48         to: {user.name, user.email},
  49         html_body: email.html_body
  50       )
  51     end
  52   end
  53
  54   describe "PATCH /api/v1/pleroma/accounts/update_avatar" do
  55     test "user avatar can be set", %{conn: conn} do
  56       user = insert(:user)
  57       avatar_image = File.read!("test/fixtures/avatar_data_uri")
  58
  59       conn =
  60         conn
  61         |> assign(:user, user)
  62         |> patch("/api/v1/pleroma/accounts/update_avatar", %{img: avatar_image})
  63
  64       user = refresh_record(user)
  65
  66       assert %{
  67                "name" => _,
  68                "type" => _,
  69                "url" => [
  70                  %{
  71                    "href" => _,
  72                    "mediaType" => _,
  73                    "type" => _
  74                  }
  75                ]
  76              } = user.avatar
  77
  78       assert %{"url" => _} = json_response(conn, 200)
  79     end
  80
  81     test "user avatar can be reset", %{conn: conn} do
  82       user = insert(:user)
  83
  84       conn =
  85         conn
  86         |> assign(:user, user)
  87         |> patch("/api/v1/pleroma/accounts/update_avatar", %{img: ""})
  88
  89       user = User.get_cached_by_id(user.id)
  90
  91       assert user.avatar == nil
  92
  93       assert %{"url" => nil} = json_response(conn, 200)
  94     end
  95   end
  96
  97   describe "PATCH /api/v1/pleroma/accounts/update_banner" do
  98     test "can set profile banner", %{conn: conn} do
  99       user = insert(:user)
 100
 101       conn =
 102         conn
 103         |> assign(:user, user)
 104         |> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => @image})
 105
 106       user = refresh_record(user)
 107       assert user.banner["type"] == "Image"
 108
 109       assert %{"url" => _} = json_response(conn, 200)
 110     end
 111
 112     test "can reset profile banner", %{conn: conn} do
 113       user = insert(:user)
 114
 115       conn =
 116         conn
 117         |> assign(:user, user)
 118         |> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => ""})
 119
 120       user = refresh_record(user)
 121       assert user.banner == %{}
 122
 123       assert %{"url" => nil} = json_response(conn, 200)
 124     end
 125   end
 126
 127   describe "PATCH /api/v1/pleroma/accounts/update_background" do
 128     test "background image can be set", %{conn: conn} do
 129       user = insert(:user)
 130
 131       conn =
 132         conn
 133         |> assign(:user, user)
 134         |> patch("/api/v1/pleroma/accounts/update_background", %{"img" => @image})
 135
 136       user = refresh_record(user)
 137       assert user.background["type"] == "Image"
 138       assert %{"url" => _} = json_response(conn, 200)
 139     end
 140
 141     test "background image can be reset", %{conn: conn} do
 142       user = insert(:user)
 143
 144       conn =
 145         conn
 146         |> assign(:user, user)
 147         |> patch("/api/v1/pleroma/accounts/update_background", %{"img" => ""})
 148
 149       user = refresh_record(user)
 150       assert user.background == %{}
 151       assert %{"url" => nil} = json_response(conn, 200)
 152     end
 153   end
 154
 155   describe "getting favorites timeline of specified user" do
 156     setup do
 157       [current_user, user] = insert_pair(:user, hide_favorites: false)
 158       [current_user: current_user, user: user]
 159     end
 160
 161     test "returns list of statuses favorited by specified user", %{
 162       conn: conn,
 163       current_user: current_user,
 164       user: user
 165     } do
 166       [activity | _] = insert_pair(:note_activity)
 167       CommonAPI.favorite(activity.id, user)
 168
 169       response =
 170         conn
 171         |> assign(:user, current_user)
 172         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 173         |> json_response(:ok)
 174
 175       [like] = response
 176
 177       assert length(response) == 1
 178       assert like["id"] == activity.id
 179     end
 180
 181     test "returns favorites for specified user_id when user is not logged in", %{
 182       conn: conn,
 183       user: user
 184     } do
 185       activity = insert(:note_activity)
 186       CommonAPI.favorite(activity.id, user)
 187
 188       response =
 189         conn
 190         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 191         |> json_response(:ok)
 192
 193       assert length(response) == 1
 194     end
 195
 196     test "returns favorited DM only when user is logged in and he is one of recipients", %{
 197       conn: conn,
 198       current_user: current_user,
 199       user: user
 200     } do
 201       {:ok, direct} =
 202         CommonAPI.post(current_user, %{
 203           "status" => "Hi @#{user.nickname}!",
 204           "visibility" => "direct"
 205         })
 206
 207       CommonAPI.favorite(direct.id, user)
 208
 209       response =
 210         conn
 211         |> assign(:user, current_user)
 212         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 213         |> json_response(:ok)
 214
 215       assert length(response) == 1
 216
 217       anonymous_response =
 218         conn
 219         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 220         |> json_response(:ok)
 221
 222       assert Enum.empty?(anonymous_response)
 223     end
 224
 225     test "does not return others' favorited DM when user is not one of recipients", %{
 226       conn: conn,
 227       current_user: current_user,
 228       user: user
 229     } do
 230       user_two = insert(:user)
 231
 232       {:ok, direct} =
 233         CommonAPI.post(user_two, %{
 234           "status" => "Hi @#{user.nickname}!",
 235           "visibility" => "direct"
 236         })
 237
 238       CommonAPI.favorite(direct.id, user)
 239
 240       response =
 241         conn
 242         |> assign(:user, current_user)
 243         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 244         |> json_response(:ok)
 245
 246       assert Enum.empty?(response)
 247     end
 248
 249     test "paginates favorites using since_id and max_id", %{
 250       conn: conn,
 251       current_user: current_user,
 252       user: user
 253     } do
 254       activities = insert_list(10, :note_activity)
 255
 256       Enum.each(activities, fn activity ->
 257         CommonAPI.favorite(activity.id, user)
 258       end)
 259
 260       third_activity = Enum.at(activities, 2)
 261       seventh_activity = Enum.at(activities, 6)
 262
 263       response =
 264         conn
 265         |> assign(:user, current_user)
 266         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{
 267           since_id: third_activity.id,
 268           max_id: seventh_activity.id
 269         })
 270         |> json_response(:ok)
 271
 272       assert length(response) == 3
 273       refute third_activity in response
 274       refute seventh_activity in response
 275     end
 276
 277     test "limits favorites using limit parameter", %{
 278       conn: conn,
 279       current_user: current_user,
 280       user: user
 281     } do
 282       7
 283       |> insert_list(:note_activity)
 284       |> Enum.each(fn activity ->
 285         CommonAPI.favorite(activity.id, user)
 286       end)
 287
 288       response =
 289         conn
 290         |> assign(:user, current_user)
 291         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{limit: "3"})
 292         |> json_response(:ok)
 293
 294       assert length(response) == 3
 295     end
 296
 297     test "returns empty response when user does not have any favorited statuses", %{
 298       conn: conn,
 299       current_user: current_user,
 300       user: user
 301     } do
 302       response =
 303         conn
 304         |> assign(:user, current_user)
 305         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 306         |> json_response(:ok)
 307
 308       assert Enum.empty?(response)
 309     end
 310
 311     test "returns 404 error when specified user is not exist", %{conn: conn} do
 312       conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")
 313
 314       assert json_response(conn, 404) == %{"error" => "Record not found"}
 315     end
 316
 317     test "returns 403 error when user has hidden own favorites", %{
 318       conn: conn,
 319       current_user: current_user
 320     } do
 321       user = insert(:user, hide_favorites: true)
 322       activity = insert(:note_activity)
 323       CommonAPI.favorite(activity.id, user)
 324
 325       conn =
 326         conn
 327         |> assign(:user, current_user)
 328         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 329
 330       assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
 331     end
 332
 333     test "hides favorites for new users by default", %{conn: conn, current_user: current_user} do
 334       user = insert(:user)
 335       activity = insert(:note_activity)
 336       CommonAPI.favorite(activity.id, user)
 337
 338       conn =
 339         conn
 340         |> assign(:user, current_user)
 341         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
 342
 343       assert user.hide_favorites
 344       assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
 345     end
 346   end
 347
 348   describe "subscribing / unsubscribing" do
 349     test "subscribing / unsubscribing to a user", %{conn: conn} do
 350       user = insert(:user)
 351       subscription_target = insert(:user)
 352
 353       conn =
 354         conn
 355         |> assign(:user, user)
 356         |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
 357
 358       assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)
 359
 360       conn =
 361         build_conn()
 362         |> assign(:user, user)
 363         |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
 364
 365       assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
 366     end
 367   end
 368
 369   describe "subscribing" do
 370     test "returns 404 when subscription_target not found", %{conn: conn} do
 371       user = insert(:user)
 372
 373       conn =
 374         conn
 375         |> assign(:user, user)
 376         |> post("/api/v1/pleroma/accounts/target_id/subscribe")
 377
 378       assert %{"error" => "Record not found"} = json_response(conn, 404)
 379     end
 380   end
 381
 382   describe "unsubscribing" do
 383     test "returns 404 when subscription_target not found", %{conn: conn} do
 384       user = insert(:user)
 385
 386       conn =
 387         conn
 388         |> assign(:user, user)
 389         |> post("/api/v1/pleroma/accounts/target_id/unsubscribe")
 390
 391       assert %{"error" => "Record not found"} = json_response(conn, 404)
 392     end
 393   end
 394 end