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