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 default scope", %{conn: conn} do
 107       user = insert(:user)
 108
 109       conn =
 110         conn
 111         |> assign(:user, user)
 112         |> patch("/api/v1/accounts/update_credentials", %{default_scope: "cofe"})
 113
 114       assert user = json_response(conn, 200)
 115       assert user["source"]["privacy"] == "cofe"
 116     end
 117
 118     test "updates the user's hide_followers status", %{conn: conn} do
 119       user = insert(:user)
 120
 121       conn =
 122         conn
 123         |> assign(:user, user)
 124         |> patch("/api/v1/accounts/update_credentials", %{hide_followers: "true"})
 125
 126       assert user = json_response(conn, 200)
 127       assert user["pleroma"]["hide_followers"] == true
 128     end
 129
 130     test "updates the user's hide_followers_count and hide_follows_count", %{conn: conn} do
 131       user = insert(:user)
 132
 133       conn =
 134         conn
 135         |> assign(:user, user)
 136         |> patch("/api/v1/accounts/update_credentials", %{
 137           hide_followers_count: "true",
 138           hide_follows_count: "true"
 139         })
 140
 141       assert user = json_response(conn, 200)
 142       assert user["pleroma"]["hide_followers_count"] == true
 143       assert user["pleroma"]["hide_follows_count"] == true
 144     end
 145
 146     test "updates the user's skip_thread_containment option", %{conn: conn} do
 147       user = insert(:user)
 148
 149       response =
 150         conn
 151         |> assign(:user, user)
 152         |> patch("/api/v1/accounts/update_credentials", %{skip_thread_containment: "true"})
 153         |> json_response(200)
 154
 155       assert response["pleroma"]["skip_thread_containment"] == true
 156       assert refresh_record(user).info.skip_thread_containment
 157     end
 158
 159     test "updates the user's hide_follows status", %{conn: conn} do
 160       user = insert(:user)
 161
 162       conn =
 163         conn
 164         |> assign(:user, user)
 165         |> patch("/api/v1/accounts/update_credentials", %{hide_follows: "true"})
 166
 167       assert user = json_response(conn, 200)
 168       assert user["pleroma"]["hide_follows"] == true
 169     end
 170
 171     test "updates the user's hide_favorites status", %{conn: conn} do
 172       user = insert(:user)
 173
 174       conn =
 175         conn
 176         |> assign(:user, user)
 177         |> patch("/api/v1/accounts/update_credentials", %{hide_favorites: "true"})
 178
 179       assert user = json_response(conn, 200)
 180       assert user["pleroma"]["hide_favorites"] == true
 181     end
 182
 183     test "updates the user's show_role status", %{conn: conn} do
 184       user = insert(:user)
 185
 186       conn =
 187         conn
 188         |> assign(:user, user)
 189         |> patch("/api/v1/accounts/update_credentials", %{show_role: "false"})
 190
 191       assert user = json_response(conn, 200)
 192       assert user["source"]["pleroma"]["show_role"] == false
 193     end
 194
 195     test "updates the user's no_rich_text status", %{conn: conn} do
 196       user = insert(:user)
 197
 198       conn =
 199         conn
 200         |> assign(:user, user)
 201         |> patch("/api/v1/accounts/update_credentials", %{no_rich_text: "true"})
 202
 203       assert user = json_response(conn, 200)
 204       assert user["source"]["pleroma"]["no_rich_text"] == true
 205     end
 206
 207     test "updates the user's name", %{conn: conn} do
 208       user = insert(:user)
 209
 210       conn =
 211         conn
 212         |> assign(:user, user)
 213         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 214
 215       assert user = json_response(conn, 200)
 216       assert user["display_name"] == "markorepairs"
 217     end
 218
 219     test "updates the user's avatar", %{conn: conn} do
 220       user = insert(:user)
 221
 222       new_avatar = %Plug.Upload{
 223         content_type: "image/jpg",
 224         path: Path.absname("test/fixtures/image.jpg"),
 225         filename: "an_image.jpg"
 226       }
 227
 228       conn =
 229         conn
 230         |> assign(:user, user)
 231         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 232
 233       assert user_response = json_response(conn, 200)
 234       assert user_response["avatar"] != User.avatar_url(user)
 235     end
 236
 237     test "updates the user's banner", %{conn: conn} do
 238       user = insert(:user)
 239
 240       new_header = %Plug.Upload{
 241         content_type: "image/jpg",
 242         path: Path.absname("test/fixtures/image.jpg"),
 243         filename: "an_image.jpg"
 244       }
 245
 246       conn =
 247         conn
 248         |> assign(:user, user)
 249         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 250
 251       assert user_response = json_response(conn, 200)
 252       assert user_response["header"] != User.banner_url(user)
 253     end
 254
 255     test "updates the user's background", %{conn: conn} do
 256       user = insert(:user)
 257
 258       new_header = %Plug.Upload{
 259         content_type: "image/jpg",
 260         path: Path.absname("test/fixtures/image.jpg"),
 261         filename: "an_image.jpg"
 262       }
 263
 264       conn =
 265         conn
 266         |> assign(:user, user)
 267         |> patch("/api/v1/accounts/update_credentials", %{
 268           "pleroma_background_image" => new_header
 269         })
 270
 271       assert user_response = json_response(conn, 200)
 272       assert user_response["pleroma"]["background_image"]
 273     end
 274
 275     test "requires 'write' permission", %{conn: conn} do
 276       token1 = insert(:oauth_token, scopes: ["read"])
 277       token2 = insert(:oauth_token, scopes: ["write", "follow"])
 278
 279       for token <- [token1, token2] do
 280         conn =
 281           conn
 282           |> put_req_header("authorization", "Bearer #{token.token}")
 283           |> patch("/api/v1/accounts/update_credentials", %{})
 284
 285         if token == token1 do
 286           assert %{"error" => "Insufficient permissions: write."} == json_response(conn, 403)
 287         else
 288           assert json_response(conn, 200)
 289         end
 290       end
 291     end
 292
 293     test "updates profile emojos", %{conn: conn} do
 294       user = insert(:user)
 295
 296       note = "*sips :blank:*"
 297       name = "I am :firefox:"
 298
 299       conn =
 300         conn
 301         |> assign(:user, user)
 302         |> patch("/api/v1/accounts/update_credentials", %{
 303           "note" => note,
 304           "display_name" => name
 305         })
 306
 307       assert json_response(conn, 200)
 308
 309       conn =
 310         conn
 311         |> get("/api/v1/accounts/#{user.id}")
 312
 313       assert user = json_response(conn, 200)
 314
 315       assert user["note"] == note
 316       assert user["display_name"] == name
 317       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user["emojis"]
 318     end
 319
 320     test "update fields", %{conn: conn} do
 321       user = insert(:user)
 322
 323       fields = [
 324         %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
 325         %{"name" => "link", "value" => "cofe.io"}
 326       ]
 327
 328       account =
 329         conn
 330         |> assign(:user, user)
 331         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 332         |> json_response(200)
 333
 334       assert account["fields"] == [
 335                %{"name" => "foo", "value" => "bar"},
 336                %{"name" => "link", "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)}
 337              ]
 338
 339       assert account["source"]["fields"] == [
 340                %{
 341                  "name" => "<a href=\"http://google.com\">foo</a>",
 342                  "value" => "<script>bar</script>"
 343                },
 344                %{"name" => "link", "value" => "cofe.io"}
 345              ]
 346
 347       fields =
 348         [
 349           "fields_attributes[1][name]=link",
 350           "fields_attributes[1][value]=cofe.io",
 351           "fields_attributes[0][name]=<a href=\"http://google.com\">foo</a>",
 352           "fields_attributes[0][value]=bar"
 353         ]
 354         |> Enum.join("&")
 355
 356       account =
 357         conn
 358         |> put_req_header("content-type", "application/x-www-form-urlencoded")
 359         |> assign(:user, user)
 360         |> patch("/api/v1/accounts/update_credentials", fields)
 361         |> json_response(200)
 362
 363       assert account["fields"] == [
 364                %{"name" => "foo", "value" => "bar"},
 365                %{"name" => "link", "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)}
 366              ]
 367
 368       assert account["source"]["fields"] == [
 369                %{
 370                  "name" => "<a href=\"http://google.com\">foo</a>",
 371                  "value" => "bar"
 372                },
 373                %{"name" => "link", "value" => "cofe.io"}
 374              ]
 375
 376       name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
 377       value_limit = Pleroma.Config.get([:instance, :account_field_value_length])
 378
 379       long_value = Enum.map(0..value_limit, fn _ -> "x" end) |> Enum.join()
 380
 381       fields = [%{"name" => "<b>foo<b>", "value" => long_value}]
 382
 383       assert %{"error" => "Invalid request"} ==
 384                conn
 385                |> assign(:user, user)
 386                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 387                |> json_response(403)
 388
 389       long_name = Enum.map(0..name_limit, fn _ -> "x" end) |> Enum.join()
 390
 391       fields = [%{"name" => long_name, "value" => "bar"}]
 392
 393       assert %{"error" => "Invalid request"} ==
 394                conn
 395                |> assign(:user, user)
 396                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 397                |> json_response(403)
 398
 399       Pleroma.Config.put([:instance, :max_account_fields], 1)
 400
 401       fields = [
 402         %{"name" => "<b>foo<b>", "value" => "<i>bar</i>"},
 403         %{"name" => "link", "value" => "cofe.io"}
 404       ]
 405
 406       assert %{"error" => "Invalid request"} ==
 407                conn
 408                |> assign(:user, user)
 409                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 410                |> json_response(403)
 411
 412       fields = [
 413         %{"name" => "foo", "value" => ""},
 414         %{"name" => "", "value" => "bar"}
 415       ]
 416
 417       account =
 418         conn
 419         |> assign(:user, user)
 420         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 421         |> json_response(200)
 422
 423       assert account["fields"] == [
 424                %{"name" => "foo", "value" => ""}
 425              ]
 426     end
 427   end
 428 end