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).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:accounts' 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:accounts."} ==
 287                    json_response(conn, 403)
 288         else
 289           assert json_response(conn, 200)
 290         end
 291       end
 292     end
 293
 294     test "updates profile emojos", %{conn: conn} do
 295       user = insert(:user)
 296
 297       note = "*sips :blank:*"
 298       name = "I am :firefox:"
 299
 300       conn =
 301         conn
 302         |> assign(:user, user)
 303         |> patch("/api/v1/accounts/update_credentials", %{
 304           "note" => note,
 305           "display_name" => name
 306         })
 307
 308       assert json_response(conn, 200)
 309
 310       conn =
 311         conn
 312         |> get("/api/v1/accounts/#{user.id}")
 313
 314       assert user = json_response(conn, 200)
 315
 316       assert user["note"] == note
 317       assert user["display_name"] == name
 318       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user["emojis"]
 319     end
 320
 321     test "update fields", %{conn: conn} do
 322       user = insert(:user)
 323
 324       fields = [
 325         %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
 326         %{"name" => "link", "value" => "cofe.io"}
 327       ]
 328
 329       account =
 330         conn
 331         |> assign(:user, user)
 332         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 333         |> json_response(200)
 334
 335       assert account["fields"] == [
 336                %{"name" => "foo", "value" => "bar"},
 337                %{"name" => "link", "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)}
 338              ]
 339
 340       assert account["source"]["fields"] == [
 341                %{
 342                  "name" => "<a href=\"http://google.com\">foo</a>",
 343                  "value" => "<script>bar</script>"
 344                },
 345                %{"name" => "link", "value" => "cofe.io"}
 346              ]
 347
 348       fields =
 349         [
 350           "fields_attributes[1][name]=link",
 351           "fields_attributes[1][value]=cofe.io",
 352           "fields_attributes[0][name]=<a href=\"http://google.com\">foo</a>",
 353           "fields_attributes[0][value]=bar"
 354         ]
 355         |> Enum.join("&")
 356
 357       account =
 358         conn
 359         |> put_req_header("content-type", "application/x-www-form-urlencoded")
 360         |> assign(:user, user)
 361         |> patch("/api/v1/accounts/update_credentials", fields)
 362         |> json_response(200)
 363
 364       assert account["fields"] == [
 365                %{"name" => "foo", "value" => "bar"},
 366                %{"name" => "link", "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)}
 367              ]
 368
 369       assert account["source"]["fields"] == [
 370                %{
 371                  "name" => "<a href=\"http://google.com\">foo</a>",
 372                  "value" => "bar"
 373                },
 374                %{"name" => "link", "value" => "cofe.io"}
 375              ]
 376
 377       name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
 378       value_limit = Pleroma.Config.get([:instance, :account_field_value_length])
 379
 380       long_value = Enum.map(0..value_limit, fn _ -> "x" end) |> Enum.join()
 381
 382       fields = [%{"name" => "<b>foo<b>", "value" => long_value}]
 383
 384       assert %{"error" => "Invalid request"} ==
 385                conn
 386                |> assign(:user, user)
 387                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 388                |> json_response(403)
 389
 390       long_name = Enum.map(0..name_limit, fn _ -> "x" end) |> Enum.join()
 391
 392       fields = [%{"name" => long_name, "value" => "bar"}]
 393
 394       assert %{"error" => "Invalid request"} ==
 395                conn
 396                |> assign(:user, user)
 397                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 398                |> json_response(403)
 399
 400       Pleroma.Config.put([:instance, :max_account_fields], 1)
 401
 402       fields = [
 403         %{"name" => "<b>foo<b>", "value" => "<i>bar</i>"},
 404         %{"name" => "link", "value" => "cofe.io"}
 405       ]
 406
 407       assert %{"error" => "Invalid request"} ==
 408                conn
 409                |> assign(:user, user)
 410                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 411                |> json_response(403)
 412
 413       fields = [
 414         %{"name" => "foo", "value" => ""},
 415         %{"name" => "", "value" => "bar"}
 416       ]
 417
 418       account =
 419         conn
 420         |> assign(:user, user)
 421         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 422         |> json_response(200)
 423
 424       assert account["fields"] == [
 425                %{"name" => "foo", "value" => ""}
 426              ]
 427     end
 428   end
 429 end