git.squeep.com Git - akkoma/blob - test/web/mastodon_api/controllers/account_controller/update_credentials_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.MastodonAPI.MastodonAPIController.UpdateCredentialsTest do
   6   alias Pleroma.Repo
   7   alias Pleroma.User
   8
   9   use Pleroma.Web.ConnCase
  10
  11   import Pleroma.Factory
  12   clear_config([:instance, :max_account_fields])
  13
  14   describe "updating credentials" do
  15     test "sets user settings in a generic way", %{conn: conn} do
  16       user = insert(:user)
  17
  18       res_conn =
  19         conn
  20         |> assign(:user, user)
  21         |> patch("/api/v1/accounts/update_credentials", %{
  22           "pleroma_settings_store" => %{
  23             pleroma_fe: %{
  24               theme: "bla"
  25             }
  26           }
  27         })
  28
  29       assert user = json_response(res_conn, 200)
  30       assert user["pleroma"]["settings_store"] == %{"pleroma_fe" => %{"theme" => "bla"}}
  31
  32       user = Repo.get(User, user["id"])
  33
  34       res_conn =
  35         conn
  36         |> assign(:user, user)
  37         |> patch("/api/v1/accounts/update_credentials", %{
  38           "pleroma_settings_store" => %{
  39             masto_fe: %{
  40               theme: "bla"
  41             }
  42           }
  43         })
  44
  45       assert user = json_response(res_conn, 200)
  46
  47       assert user["pleroma"]["settings_store"] ==
  48                %{
  49                  "pleroma_fe" => %{"theme" => "bla"},
  50                  "masto_fe" => %{"theme" => "bla"}
  51                }
  52
  53       user = Repo.get(User, user["id"])
  54
  55       res_conn =
  56         conn
  57         |> assign(:user, user)
  58         |> patch("/api/v1/accounts/update_credentials", %{
  59           "pleroma_settings_store" => %{
  60             masto_fe: %{
  61               theme: "blub"
  62             }
  63           }
  64         })
  65
  66       assert user = json_response(res_conn, 200)
  67
  68       assert user["pleroma"]["settings_store"] ==
  69                %{
  70                  "pleroma_fe" => %{"theme" => "bla"},
  71                  "masto_fe" => %{"theme" => "blub"}
  72                }
  73     end
  74
  75     test "updates the user's bio", %{conn: conn} do
  76       user = insert(:user)
  77       user2 = insert(:user)
  78
  79       conn =
  80         conn
  81         |> assign(:user, user)
  82         |> patch("/api/v1/accounts/update_credentials", %{
  83           "note" => "I drink #cofe with @#{user2.nickname}"
  84         })
  85
  86       assert user = json_response(conn, 200)
  87
  88       assert user["note"] ==
  89                ~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe">#cofe</a> with <span class="h-card"><a data-user="#{
  90                  user2.id
  91                }" class="u-url mention" href="#{user2.ap_id}" rel="ugc">@<span>#{user2.nickname}</span></a></span>)
  92     end
  93
  94     test "updates the user's locking status", %{conn: conn} do
  95       user = insert(:user)
  96
  97       conn =
  98         conn
  99         |> assign(:user, user)
 100         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
 101
 102       assert user = json_response(conn, 200)
 103       assert user["locked"] == true
 104     end
 105
 106     test "updates the user's allow_following_move", %{conn: conn} do
 107       user = insert(:user)
 108
 109       assert user.allow_following_move == true
 110
 111       conn =
 112         conn
 113         |> assign(:user, user)
 114         |> patch("/api/v1/accounts/update_credentials", %{allow_following_move: "false"})
 115
 116       assert refresh_record(user).allow_following_move == false
 117       assert user = json_response(conn, 200)
 118       assert user["pleroma"]["allow_following_move"] == false
 119     end
 120
 121     test "updates the user's default scope", %{conn: conn} do
 122       user = insert(:user)
 123
 124       conn =
 125         conn
 126         |> assign(:user, user)
 127         |> patch("/api/v1/accounts/update_credentials", %{default_scope: "cofe"})
 128
 129       assert user = json_response(conn, 200)
 130       assert user["source"]["privacy"] == "cofe"
 131     end
 132
 133     test "updates the user's hide_followers status", %{conn: conn} do
 134       user = insert(:user)
 135
 136       conn =
 137         conn
 138         |> assign(:user, user)
 139         |> patch("/api/v1/accounts/update_credentials", %{hide_followers: "true"})
 140
 141       assert user = json_response(conn, 200)
 142       assert user["pleroma"]["hide_followers"] == true
 143     end
 144
 145     test "updates the user's hide_followers_count and hide_follows_count", %{conn: conn} do
 146       user = insert(:user)
 147
 148       conn =
 149         conn
 150         |> assign(:user, user)
 151         |> patch("/api/v1/accounts/update_credentials", %{
 152           hide_followers_count: "true",
 153           hide_follows_count: "true"
 154         })
 155
 156       assert user = json_response(conn, 200)
 157       assert user["pleroma"]["hide_followers_count"] == true
 158       assert user["pleroma"]["hide_follows_count"] == true
 159     end
 160
 161     test "updates the user's skip_thread_containment option", %{conn: conn} do
 162       user = insert(:user)
 163
 164       response =
 165         conn
 166         |> assign(:user, user)
 167         |> patch("/api/v1/accounts/update_credentials", %{skip_thread_containment: "true"})
 168         |> json_response(200)
 169
 170       assert response["pleroma"]["skip_thread_containment"] == true
 171       assert refresh_record(user).skip_thread_containment
 172     end
 173
 174     test "updates the user's hide_follows status", %{conn: conn} do
 175       user = insert(:user)
 176
 177       conn =
 178         conn
 179         |> assign(:user, user)
 180         |> patch("/api/v1/accounts/update_credentials", %{hide_follows: "true"})
 181
 182       assert user = json_response(conn, 200)
 183       assert user["pleroma"]["hide_follows"] == true
 184     end
 185
 186     test "updates the user's hide_favorites status", %{conn: conn} do
 187       user = insert(:user)
 188
 189       conn =
 190         conn
 191         |> assign(:user, user)
 192         |> patch("/api/v1/accounts/update_credentials", %{hide_favorites: "true"})
 193
 194       assert user = json_response(conn, 200)
 195       assert user["pleroma"]["hide_favorites"] == true
 196     end
 197
 198     test "updates the user's show_role status", %{conn: conn} do
 199       user = insert(:user)
 200
 201       conn =
 202         conn
 203         |> assign(:user, user)
 204         |> patch("/api/v1/accounts/update_credentials", %{show_role: "false"})
 205
 206       assert user = json_response(conn, 200)
 207       assert user["source"]["pleroma"]["show_role"] == false
 208     end
 209
 210     test "updates the user's no_rich_text status", %{conn: conn} do
 211       user = insert(:user)
 212
 213       conn =
 214         conn
 215         |> assign(:user, user)
 216         |> patch("/api/v1/accounts/update_credentials", %{no_rich_text: "true"})
 217
 218       assert user = json_response(conn, 200)
 219       assert user["source"]["pleroma"]["no_rich_text"] == true
 220     end
 221
 222     test "updates the user's name", %{conn: conn} do
 223       user = insert(:user)
 224
 225       conn =
 226         conn
 227         |> assign(:user, user)
 228         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 229
 230       assert user = json_response(conn, 200)
 231       assert user["display_name"] == "markorepairs"
 232     end
 233
 234     test "updates the user's avatar", %{conn: conn} do
 235       user = insert(:user)
 236
 237       new_avatar = %Plug.Upload{
 238         content_type: "image/jpg",
 239         path: Path.absname("test/fixtures/image.jpg"),
 240         filename: "an_image.jpg"
 241       }
 242
 243       conn =
 244         conn
 245         |> assign(:user, user)
 246         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 247
 248       assert user_response = json_response(conn, 200)
 249       assert user_response["avatar"] != User.avatar_url(user)
 250     end
 251
 252     test "updates the user's banner", %{conn: conn} do
 253       user = insert(:user)
 254
 255       new_header = %Plug.Upload{
 256         content_type: "image/jpg",
 257         path: Path.absname("test/fixtures/image.jpg"),
 258         filename: "an_image.jpg"
 259       }
 260
 261       conn =
 262         conn
 263         |> assign(:user, user)
 264         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 265
 266       assert user_response = json_response(conn, 200)
 267       assert user_response["header"] != User.banner_url(user)
 268     end
 269
 270     test "updates the user's background", %{conn: conn} do
 271       user = insert(:user)
 272
 273       new_header = %Plug.Upload{
 274         content_type: "image/jpg",
 275         path: Path.absname("test/fixtures/image.jpg"),
 276         filename: "an_image.jpg"
 277       }
 278
 279       conn =
 280         conn
 281         |> assign(:user, user)
 282         |> patch("/api/v1/accounts/update_credentials", %{
 283           "pleroma_background_image" => new_header
 284         })
 285
 286       assert user_response = json_response(conn, 200)
 287       assert user_response["pleroma"]["background_image"]
 288     end
 289
 290     test "requires 'write:accounts' permission", %{conn: conn} do
 291       token1 = insert(:oauth_token, scopes: ["read"])
 292       token2 = insert(:oauth_token, scopes: ["write", "follow"])
 293
 294       for token <- [token1, token2] do
 295         conn =
 296           conn
 297           |> put_req_header("authorization", "Bearer #{token.token}")
 298           |> patch("/api/v1/accounts/update_credentials", %{})
 299
 300         if token == token1 do
 301           assert %{"error" => "Insufficient permissions: write:accounts."} ==
 302                    json_response(conn, 403)
 303         else
 304           assert json_response(conn, 200)
 305         end
 306       end
 307     end
 308
 309     test "updates profile emojos", %{conn: conn} do
 310       user = insert(:user)
 311
 312       note = "*sips :blank:*"
 313       name = "I am :firefox:"
 314
 315       conn =
 316         conn
 317         |> assign(:user, user)
 318         |> patch("/api/v1/accounts/update_credentials", %{
 319           "note" => note,
 320           "display_name" => name
 321         })
 322
 323       assert json_response(conn, 200)
 324
 325       conn =
 326         conn
 327         |> get("/api/v1/accounts/#{user.id}")
 328
 329       assert user = json_response(conn, 200)
 330
 331       assert user["note"] == note
 332       assert user["display_name"] == name
 333       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user["emojis"]
 334     end
 335
 336     test "update fields", %{conn: conn} do
 337       user = insert(:user)
 338
 339       fields = [
 340         %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
 341         %{"name" => "link", "value" => "cofe.io"}
 342       ]
 343
 344       account =
 345         conn
 346         |> assign(:user, user)
 347         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 348         |> json_response(200)
 349
 350       assert account["fields"] == [
 351                %{"name" => "foo", "value" => "bar"},
 352                %{"name" => "link", "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)}
 353              ]
 354
 355       assert account["source"]["fields"] == [
 356                %{
 357                  "name" => "<a href=\"http://google.com\">foo</a>",
 358                  "value" => "<script>bar</script>"
 359                },
 360                %{"name" => "link", "value" => "cofe.io"}
 361              ]
 362
 363       fields =
 364         [
 365           "fields_attributes[1][name]=link",
 366           "fields_attributes[1][value]=cofe.io",
 367           "fields_attributes[0][name]=<a href=\"http://google.com\">foo</a>",
 368           "fields_attributes[0][value]=bar"
 369         ]
 370         |> Enum.join("&")
 371
 372       account =
 373         conn
 374         |> put_req_header("content-type", "application/x-www-form-urlencoded")
 375         |> assign(:user, user)
 376         |> patch("/api/v1/accounts/update_credentials", fields)
 377         |> json_response(200)
 378
 379       assert account["fields"] == [
 380                %{"name" => "foo", "value" => "bar"},
 381                %{"name" => "link", "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)}
 382              ]
 383
 384       assert account["source"]["fields"] == [
 385                %{
 386                  "name" => "<a href=\"http://google.com\">foo</a>",
 387                  "value" => "bar"
 388                },
 389                %{"name" => "link", "value" => "cofe.io"}
 390              ]
 391
 392       name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
 393       value_limit = Pleroma.Config.get([:instance, :account_field_value_length])
 394
 395       long_value = Enum.map(0..value_limit, fn _ -> "x" end) |> Enum.join()
 396
 397       fields = [%{"name" => "<b>foo<b>", "value" => long_value}]
 398
 399       assert %{"error" => "Invalid request"} ==
 400                conn
 401                |> assign(:user, user)
 402                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 403                |> json_response(403)
 404
 405       long_name = Enum.map(0..name_limit, fn _ -> "x" end) |> Enum.join()
 406
 407       fields = [%{"name" => long_name, "value" => "bar"}]
 408
 409       assert %{"error" => "Invalid request"} ==
 410                conn
 411                |> assign(:user, user)
 412                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 413                |> json_response(403)
 414
 415       Pleroma.Config.put([:instance, :max_account_fields], 1)
 416
 417       fields = [
 418         %{"name" => "<b>foo<b>", "value" => "<i>bar</i>"},
 419         %{"name" => "link", "value" => "cofe.io"}
 420       ]
 421
 422       assert %{"error" => "Invalid request"} ==
 423                conn
 424                |> assign(:user, user)
 425                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 426                |> json_response(403)
 427
 428       fields = [
 429         %{"name" => "foo", "value" => ""},
 430         %{"name" => "", "value" => "bar"}
 431       ]
 432
 433       account =
 434         conn
 435         |> assign(:user, user)
 436         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 437         |> json_response(200)
 438
 439       assert account["fields"] == [
 440                %{"name" => "foo", "value" => ""}
 441              ]
 442     end
 443   end
 444 end