git.squeep.com Git - akkoma/blob - test/pleroma/web/mastodon_api/update_credentials_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.UpdateCredentialsTest do
   6   alias Pleroma.Repo
   7   alias Pleroma.User
   8
   9   use Pleroma.Web.ConnCase
  10
  11   import Mock
  12   import Pleroma.Factory
  13
  14   describe "updating credentials" do
  15     setup do: oauth_access(["write:accounts"])
  16     setup :request_content_type
  17
  18     test "sets user settings in a generic way", %{conn: conn} do
  19       res_conn =
  20         patch(conn, "/api/v1/accounts/update_credentials", %{
  21           "pleroma_settings_store" => %{
  22             pleroma_fe: %{
  23               theme: "bla"
  24             }
  25           }
  26         })
  27
  28       assert user_data = json_response_and_validate_schema(res_conn, 200)
  29       assert user_data["pleroma"]["settings_store"] == %{"pleroma_fe" => %{"theme" => "bla"}}
  30
  31       user = Repo.get(User, user_data["id"])
  32
  33       res_conn =
  34         conn
  35         |> assign(:user, user)
  36         |> patch("/api/v1/accounts/update_credentials", %{
  37           "pleroma_settings_store" => %{
  38             soapbox_fe: %{
  39               themeMode: "bla"
  40             }
  41           }
  42         })
  43
  44       assert user_data = json_response_and_validate_schema(res_conn, 200)
  45
  46       assert user_data["pleroma"]["settings_store"] ==
  47                %{
  48                  "pleroma_fe" => %{"theme" => "bla"},
  49                  "soapbox_fe" => %{"themeMode" => "bla"}
  50                }
  51
  52       user = Repo.get(User, user_data["id"])
  53
  54       clear_config([:instance, :federating], true)
  55
  56       with_mock Pleroma.Web.Federator,
  57         publish: fn _activity -> :ok end do
  58         res_conn =
  59           conn
  60           |> assign(:user, user)
  61           |> patch("/api/v1/accounts/update_credentials", %{
  62             "pleroma_settings_store" => %{
  63               soapbox_fe: %{
  64                 themeMode: "blub"
  65               }
  66             }
  67           })
  68
  69         assert user_data = json_response_and_validate_schema(res_conn, 200)
  70
  71         assert user_data["pleroma"]["settings_store"] ==
  72                  %{
  73                    "pleroma_fe" => %{"theme" => "bla"},
  74                    "soapbox_fe" => %{"themeMode" => "blub"}
  75                  }
  76
  77         assert_called(Pleroma.Web.Federator.publish(:_))
  78       end
  79     end
  80
  81     test "updates the user's bio", %{conn: conn} do
  82       user2 = insert(:user)
  83
  84       raw_bio = "I drink #cofe with @#{user2.nickname}\n\nsuya.."
  85
  86       conn = patch(conn, "/api/v1/accounts/update_credentials", %{"note" => raw_bio})
  87
  88       assert user_data = json_response_and_validate_schema(conn, 200)
  89
  90       assert user_data["note"] ==
  91                ~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe">#cofe</a> with <span class="h-card"><a class="u-url mention" data-user="#{user2.id}" href="#{user2.ap_id}" rel="ugc">@<span>#{user2.nickname}</span></a></span><br/><br/>suya..)
  92
  93       assert user_data["source"]["note"] == raw_bio
  94
  95       user = Repo.get(User, user_data["id"])
  96
  97       assert user.raw_bio == raw_bio
  98     end
  99
 100     test "updates the user's locking status", %{conn: conn} do
 101       conn = patch(conn, "/api/v1/accounts/update_credentials", %{locked: "true"})
 102
 103       assert user_data = json_response_and_validate_schema(conn, 200)
 104       assert user_data["locked"] == true
 105     end
 106
 107     test "updates the user's chat acceptance status", %{conn: conn} do
 108       conn = patch(conn, "/api/v1/accounts/update_credentials", %{accepts_chat_messages: "false"})
 109
 110       assert user_data = json_response_and_validate_schema(conn, 200)
 111       assert user_data["pleroma"]["accepts_chat_messages"] == false
 112     end
 113
 114     test "updates the user's allow_following_move", %{user: user, conn: conn} do
 115       assert user.allow_following_move == true
 116
 117       conn = patch(conn, "/api/v1/accounts/update_credentials", %{allow_following_move: "false"})
 118
 119       assert refresh_record(user).allow_following_move == false
 120       assert user_data = json_response_and_validate_schema(conn, 200)
 121       assert user_data["pleroma"]["allow_following_move"] == false
 122     end
 123
 124     test "updates the user's default scope", %{conn: conn} do
 125       conn = patch(conn, "/api/v1/accounts/update_credentials", %{default_scope: "unlisted"})
 126
 127       assert user_data = json_response_and_validate_schema(conn, 200)
 128       assert user_data["source"]["privacy"] == "unlisted"
 129     end
 130
 131     test "updates the user's privacy", %{conn: conn} do
 132       conn = patch(conn, "/api/v1/accounts/update_credentials", %{source: %{privacy: "unlisted"}})
 133
 134       assert user_data = json_response_and_validate_schema(conn, 200)
 135       assert user_data["source"]["privacy"] == "unlisted"
 136     end
 137
 138     test "updates the user's hide_followers status", %{conn: conn} do
 139       conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_followers: "true"})
 140
 141       assert user_data = json_response_and_validate_schema(conn, 200)
 142       assert user_data["pleroma"]["hide_followers"] == true
 143     end
 144
 145     test "updates the user's discoverable status", %{conn: conn} do
 146       assert %{"source" => %{"pleroma" => %{"discoverable" => true}}} =
 147                conn
 148                |> patch("/api/v1/accounts/update_credentials", %{discoverable: "true"})
 149                |> json_response_and_validate_schema(:ok)
 150
 151       assert %{"source" => %{"pleroma" => %{"discoverable" => false}}} =
 152                conn
 153                |> patch("/api/v1/accounts/update_credentials", %{discoverable: "false"})
 154                |> json_response_and_validate_schema(:ok)
 155     end
 156
 157     test "updates the user's hide_followers_count and hide_follows_count", %{conn: conn} do
 158       conn =
 159         patch(conn, "/api/v1/accounts/update_credentials", %{
 160           hide_followers_count: "true",
 161           hide_follows_count: "true"
 162         })
 163
 164       assert user_data = json_response_and_validate_schema(conn, 200)
 165       assert user_data["pleroma"]["hide_followers_count"] == true
 166       assert user_data["pleroma"]["hide_follows_count"] == true
 167     end
 168
 169     test "updates the user's skip_thread_containment option", %{user: user, conn: conn} do
 170       response =
 171         conn
 172         |> patch("/api/v1/accounts/update_credentials", %{skip_thread_containment: "true"})
 173         |> json_response_and_validate_schema(200)
 174
 175       assert response["pleroma"]["skip_thread_containment"] == true
 176       assert refresh_record(user).skip_thread_containment
 177     end
 178
 179     test "updates the user's hide_follows status", %{conn: conn} do
 180       conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_follows: "true"})
 181
 182       assert user_data = json_response_and_validate_schema(conn, 200)
 183       assert user_data["pleroma"]["hide_follows"] == true
 184     end
 185
 186     test "updates the user's hide_favorites status", %{conn: conn} do
 187       conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_favorites: "true"})
 188
 189       assert user_data = json_response_and_validate_schema(conn, 200)
 190       assert user_data["pleroma"]["hide_favorites"] == true
 191     end
 192
 193     test "updates the user's show_role status", %{conn: conn} do
 194       conn = patch(conn, "/api/v1/accounts/update_credentials", %{show_role: "false"})
 195
 196       assert user_data = json_response_and_validate_schema(conn, 200)
 197       assert user_data["source"]["pleroma"]["show_role"] == false
 198     end
 199
 200     test "updates the user's no_rich_text status", %{conn: conn} do
 201       conn = patch(conn, "/api/v1/accounts/update_credentials", %{no_rich_text: "true"})
 202
 203       assert user_data = json_response_and_validate_schema(conn, 200)
 204       assert user_data["source"]["pleroma"]["no_rich_text"] == true
 205     end
 206
 207     test "updates the user's name", %{conn: conn} do
 208       conn =
 209         patch(conn, "/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 210
 211       assert user_data = json_response_and_validate_schema(conn, 200)
 212       assert user_data["display_name"] == "markorepairs"
 213
 214       update_activity = Repo.one(Pleroma.Activity)
 215       assert update_activity.data["type"] == "Update"
 216       assert update_activity.data["object"]["name"] == "markorepairs"
 217     end
 218
 219     test "updates the user's AKAs", %{conn: conn} do
 220       conn =
 221         patch(conn, "/api/v1/accounts/update_credentials", %{
 222           "also_known_as" => ["https://mushroom.kingdom/users/mario"]
 223         })
 224
 225       assert user_data = json_response_and_validate_schema(conn, 200)
 226       assert user_data["pleroma"]["also_known_as"] == ["https://mushroom.kingdom/users/mario"]
 227     end
 228
 229     test "doesn't update non-url akas", %{conn: conn} do
 230       conn =
 231         patch(conn, "/api/v1/accounts/update_credentials", %{
 232           "also_known_as" => ["aReallyCoolGuy"]
 233         })
 234
 235       assert json_response_and_validate_schema(conn, 403)
 236     end
 237
 238     test "updates the user's avatar", %{user: user, conn: conn} do
 239       new_avatar = %Plug.Upload{
 240         content_type: "image/jpeg",
 241         path: Path.absname("test/fixtures/image.jpg"),
 242         filename: "an_image.jpg"
 243       }
 244
 245       assert user.avatar == %{}
 246
 247       res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 248
 249       assert user_response = json_response_and_validate_schema(res, 200)
 250       assert user_response["avatar"] != User.avatar_url(user)
 251
 252       user = User.get_by_id(user.id)
 253       refute user.avatar == %{}
 254
 255       # Also resets it
 256       _res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => ""})
 257
 258       user = User.get_by_id(user.id)
 259       assert user.avatar == nil
 260     end
 261
 262     test "updates the user's banner", %{user: user, conn: conn} do
 263       new_header = %Plug.Upload{
 264         content_type: "image/jpeg",
 265         path: Path.absname("test/fixtures/image.jpg"),
 266         filename: "an_image.jpg"
 267       }
 268
 269       res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header})
 270
 271       assert user_response = json_response_and_validate_schema(res, 200)
 272       assert user_response["header"] != User.banner_url(user)
 273
 274       # Also resets it
 275       _res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => ""})
 276
 277       user = User.get_by_id(user.id)
 278       assert user.banner == nil
 279     end
 280
 281     test "updates the user's background", %{conn: conn, user: user} do
 282       new_header = %Plug.Upload{
 283         content_type: "image/jpeg",
 284         path: Path.absname("test/fixtures/image.jpg"),
 285         filename: "an_image.jpg"
 286       }
 287
 288       res =
 289         patch(conn, "/api/v1/accounts/update_credentials", %{
 290           "pleroma_background_image" => new_header
 291         })
 292
 293       assert user_response = json_response_and_validate_schema(res, 200)
 294       assert user_response["pleroma"]["background_image"]
 295       #
 296       # Also resets it
 297       _res =
 298         patch(conn, "/api/v1/accounts/update_credentials", %{"pleroma_background_image" => ""})
 299
 300       user = User.get_by_id(user.id)
 301       assert user.background == nil
 302     end
 303
 304     test "requires 'write:accounts' permission" do
 305       token1 = insert(:oauth_token, scopes: ["read"])
 306       token2 = insert(:oauth_token, scopes: ["write", "follow"])
 307
 308       for token <- [token1, token2] do
 309         conn =
 310           build_conn()
 311           |> put_req_header("content-type", "multipart/form-data")
 312           |> put_req_header("authorization", "Bearer #{token.token}")
 313           |> patch("/api/v1/accounts/update_credentials", %{})
 314
 315         if token == token1 do
 316           assert %{"error" => "Insufficient permissions: write:accounts."} ==
 317                    json_response_and_validate_schema(conn, 403)
 318         else
 319           assert json_response_and_validate_schema(conn, 200)
 320         end
 321       end
 322     end
 323
 324     test "updates profile emojos", %{user: user, conn: conn} do
 325       note = "*sips :blank:*"
 326       name = "I am :firefox:"
 327
 328       ret_conn =
 329         patch(conn, "/api/v1/accounts/update_credentials", %{
 330           "note" => note,
 331           "display_name" => name
 332         })
 333
 334       assert json_response_and_validate_schema(ret_conn, 200)
 335
 336       conn = get(conn, "/api/v1/accounts/#{user.id}")
 337
 338       assert user_data = json_response_and_validate_schema(conn, 200)
 339
 340       assert user_data["note"] == note
 341       assert user_data["display_name"] == name
 342       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user_data["emojis"]
 343     end
 344
 345     test "update fields", %{conn: conn} do
 346       fields = [
 347         %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
 348         %{"name" => "link.io", "value" => "cofe.io"}
 349       ]
 350
 351       account_data =
 352         conn
 353         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 354         |> json_response_and_validate_schema(200)
 355
 356       assert account_data["fields"] == [
 357                %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "bar"},
 358                %{
 359                  "name" => "link.io",
 360                  "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)
 361                }
 362              ]
 363
 364       assert account_data["source"]["fields"] == [
 365                %{
 366                  "name" => "<a href=\"http://google.com\">foo</a>",
 367                  "value" => "<script>bar</script>"
 368                },
 369                %{"name" => "link.io", "value" => "cofe.io"}
 370              ]
 371     end
 372
 373     test "emojis in fields labels", %{conn: conn} do
 374       fields = [
 375         %{"name" => ":firefox:", "value" => "is best 2hu"},
 376         %{"name" => "they wins", "value" => ":blank:"}
 377       ]
 378
 379       account_data =
 380         conn
 381         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 382         |> json_response_and_validate_schema(200)
 383
 384       assert account_data["fields"] == [
 385                %{"name" => ":firefox:", "value" => "is best 2hu"},
 386                %{"name" => "they wins", "value" => ":blank:"}
 387              ]
 388
 389       assert account_data["source"]["fields"] == [
 390                %{"name" => ":firefox:", "value" => "is best 2hu"},
 391                %{"name" => "they wins", "value" => ":blank:"}
 392              ]
 393
 394       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = account_data["emojis"]
 395     end
 396
 397     test "update fields via x-www-form-urlencoded", %{conn: conn} do
 398       fields =
 399         [
 400           "fields_attributes[1][name]=link",
 401           "fields_attributes[1][value]=http://cofe.io",
 402           "fields_attributes[0][name]=foo",
 403           "fields_attributes[0][value]=bar"
 404         ]
 405         |> Enum.join("&")
 406
 407       account =
 408         conn
 409         |> put_req_header("content-type", "application/x-www-form-urlencoded")
 410         |> patch("/api/v1/accounts/update_credentials", fields)
 411         |> json_response_and_validate_schema(200)
 412
 413       assert account["fields"] == [
 414                %{"name" => "foo", "value" => "bar"},
 415                %{
 416                  "name" => "link",
 417                  "value" => ~S(<a href="http://cofe.io" rel="ugc">http://cofe.io</a>)
 418                }
 419              ]
 420
 421       assert account["source"]["fields"] == [
 422                %{"name" => "foo", "value" => "bar"},
 423                %{"name" => "link", "value" => "http://cofe.io"}
 424              ]
 425     end
 426
 427     test "update fields with empty name", %{conn: conn} do
 428       fields = [
 429         %{"name" => "foo", "value" => ""},
 430         %{"name" => "", "value" => "bar"}
 431       ]
 432
 433       account =
 434         conn
 435         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 436         |> json_response_and_validate_schema(200)
 437
 438       assert account["fields"] == [
 439                %{"name" => "foo", "value" => ""}
 440              ]
 441     end
 442
 443     test "update fields when invalid request", %{conn: conn} do
 444       name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
 445       value_limit = Pleroma.Config.get([:instance, :account_field_value_length])
 446
 447       long_name = Enum.map(0..name_limit, fn _ -> "x" end) |> Enum.join()
 448       long_value = Enum.map(0..value_limit, fn _ -> "x" end) |> Enum.join()
 449
 450       fields = [%{"name" => "foo", "value" => long_value}]
 451
 452       assert %{"error" => "Invalid request"} ==
 453                conn
 454                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 455                |> json_response_and_validate_schema(403)
 456
 457       fields = [%{"name" => long_name, "value" => "bar"}]
 458
 459       assert %{"error" => "Invalid request"} ==
 460                conn
 461                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 462                |> json_response_and_validate_schema(403)
 463
 464       clear_config([:instance, :max_account_fields], 1)
 465
 466       fields = [
 467         %{"name" => "foo", "value" => "bar"},
 468         %{"name" => "link", "value" => "cofe.io"}
 469       ]
 470
 471       assert %{"error" => "Invalid request"} ==
 472                conn
 473                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 474                |> json_response_and_validate_schema(403)
 475     end
 476   end
 477
 478   describe "Mark account as bot" do
 479     setup do: oauth_access(["write:accounts"])
 480     setup :request_content_type
 481
 482     test "changing actor_type to Service makes account a bot", %{conn: conn} do
 483       account =
 484         conn
 485         |> patch("/api/v1/accounts/update_credentials", %{actor_type: "Service"})
 486         |> json_response_and_validate_schema(200)
 487
 488       assert account["bot"]
 489       assert account["source"]["pleroma"]["actor_type"] == "Service"
 490     end
 491
 492     test "changing actor_type to Person makes account a human", %{conn: conn} do
 493       account =
 494         conn
 495         |> patch("/api/v1/accounts/update_credentials", %{actor_type: "Person"})
 496         |> json_response_and_validate_schema(200)
 497
 498       refute account["bot"]
 499       assert account["source"]["pleroma"]["actor_type"] == "Person"
 500     end
 501
 502     test "changing actor_type to Application causes error", %{conn: conn} do
 503       response =
 504         conn
 505         |> patch("/api/v1/accounts/update_credentials", %{actor_type: "Application"})
 506         |> json_response_and_validate_schema(403)
 507
 508       assert %{"error" => "Invalid request"} == response
 509     end
 510
 511     test "changing bot field to true changes actor_type to Service", %{conn: conn} do
 512       account =
 513         conn
 514         |> patch("/api/v1/accounts/update_credentials", %{bot: "true"})
 515         |> json_response_and_validate_schema(200)
 516
 517       assert account["bot"]
 518       assert account["source"]["pleroma"]["actor_type"] == "Service"
 519     end
 520
 521     test "changing bot field to false changes actor_type to Person", %{conn: conn} do
 522       account =
 523         conn
 524         |> patch("/api/v1/accounts/update_credentials", %{bot: "false"})
 525         |> json_response_and_validate_schema(200)
 526
 527       refute account["bot"]
 528       assert account["source"]["pleroma"]["actor_type"] == "Person"
 529     end
 530
 531     test "actor_type field has a higher priority than bot", %{conn: conn} do
 532       account =
 533         conn
 534         |> patch("/api/v1/accounts/update_credentials", %{
 535           actor_type: "Person",
 536           bot: "true"
 537         })
 538         |> json_response_and_validate_schema(200)
 539
 540       refute account["bot"]
 541       assert account["source"]["pleroma"]["actor_type"] == "Person"
 542     end
 543   end
 544 end