Git of dcc - anni/blob - test/pleroma/web/mastodon_api/update_credentials_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 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 avatar, upload_limit, returns a HTTP 413", %{conn: conn, user: user} do
 263       upload_limit = Config.get([:instance, :upload_limit]) * 8 + 8
 264
 265       assert :ok ==
 266                File.write(Path.absname("test/tmp/large_binary.data"), <<0::size(upload_limit)>>)
 267
 268       new_avatar_oversized = %Plug.Upload{
 269         content_type: nil,
 270         path: Path.absname("test/tmp/large_binary.data"),
 271         filename: "large_binary.data"
 272       }
 273
 274       assert user.avatar == %{}
 275
 276       res =
 277         patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => new_avatar_oversized})
 278
 279       assert user_response = json_response_and_validate_schema(res, 413)
 280       assert user_response["avatar"] != User.avatar_url(user)
 281
 282       user = User.get_by_id(user.id)
 283       assert user.avatar == %{}
 284
 285       clear_config([:instance, :upload_limit], upload_limit)
 286
 287       assert :ok == File.rm(Path.absname("test/tmp/large_binary.data"))
 288     end
 289
 290     test "updates the user's banner", %{user: user, conn: conn} do
 291       new_header = %Plug.Upload{
 292         content_type: "image/jpeg",
 293         path: Path.absname("test/fixtures/image.jpg"),
 294         filename: "an_image.jpg"
 295       }
 296
 297       res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header})
 298
 299       assert user_response = json_response_and_validate_schema(res, 200)
 300       assert user_response["header"] != User.banner_url(user)
 301
 302       # Also resets it
 303       _res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => ""})
 304
 305       user = User.get_by_id(user.id)
 306       assert user.banner == nil
 307     end
 308
 309     test "updates the user's banner, upload_limit, returns a HTTP 413", %{conn: conn, user: user} do
 310       upload_limit = Config.get([:instance, :upload_limit]) * 8 + 8
 311
 312       assert :ok ==
 313                File.write(Path.absname("test/tmp/large_binary.data"), <<0::size(upload_limit)>>)
 314
 315       new_header_oversized = %Plug.Upload{
 316         content_type: nil,
 317         path: Path.absname("test/tmp/large_binary.data"),
 318         filename: "large_binary.data"
 319       }
 320
 321       res =
 322         patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header_oversized})
 323
 324       assert user_response = json_response_and_validate_schema(res, 413)
 325       assert user_response["header"] != User.banner_url(user)
 326
 327       user = User.get_by_id(user.id)
 328       assert user.banner == %{}
 329
 330       clear_config([:instance, :upload_limit], upload_limit)
 331
 332       assert :ok == File.rm(Path.absname("test/tmp/large_binary.data"))
 333     end
 334
 335     test "updates the user's background", %{conn: conn, user: user} do
 336       new_header = %Plug.Upload{
 337         content_type: "image/jpeg",
 338         path: Path.absname("test/fixtures/image.jpg"),
 339         filename: "an_image.jpg"
 340       }
 341
 342       res =
 343         patch(conn, "/api/v1/accounts/update_credentials", %{
 344           "pleroma_background_image" => new_header
 345         })
 346
 347       assert user_response = json_response_and_validate_schema(res, 200)
 348       assert user_response["pleroma"]["background_image"]
 349       #
 350       # Also resets it
 351       _res =
 352         patch(conn, "/api/v1/accounts/update_credentials", %{"pleroma_background_image" => ""})
 353
 354       user = User.get_by_id(user.id)
 355       assert user.background == nil
 356     end
 357
 358     test "updates the user's background, upload_limit, returns a HTTP 413", %{
 359       conn: conn,
 360       user: user
 361     } do
 362       upload_limit = Config.get([:instance, :upload_limit]) * 8 + 8
 363
 364       assert :ok ==
 365                File.write(Path.absname("test/tmp/large_binary.data"), <<0::size(upload_limit)>>)
 366
 367       new_background_oversized = %Plug.Upload{
 368         content_type: nil,
 369         path: Path.absname("test/tmp/large_binary.data"),
 370         filename: "large_binary.data"
 371       }
 372
 373       res =
 374         patch(conn, "/api/v1/accounts/update_credentials", %{
 375           "pleroma_background_image" => new_background_oversized
 376         })
 377
 378       assert _user_response = json_response_and_validate_schema(res, 413)
 379       assert user.background == %{}
 380
 381       clear_config([:instance, :upload_limit], upload_limit)
 382
 383       assert :ok == File.rm(Path.absname("test/tmp/large_binary.data"))
 384     end
 385
 386     test "Strip / from upload files", %{user: user, conn: conn} do
 387       new_image = %Plug.Upload{
 388         content_type: "image/jpeg",
 389         path: Path.absname("test/fixtures/image.jpg"),
 390         filename: "../../../../nested/an_image.jpg"
 391       }
 392
 393       assert user.avatar == %{}
 394
 395       res =
 396         patch(conn, "/api/v1/accounts/update_credentials", %{
 397           "avatar" => new_image,
 398           "header" => new_image,
 399           "pleroma_background_image" => new_image
 400         })
 401
 402       assert user_response = json_response_and_validate_schema(res, 200)
 403       assert user_response["avatar"]
 404       assert user_response["header"]
 405       assert user_response["pleroma"]["background_image"]
 406       refute Regex.match?(~r"/nested/", user_response["avatar"])
 407       refute Regex.match?(~r"/nested/", user_response["header"])
 408       refute Regex.match?(~r"/nested/", user_response["pleroma"]["background_image"])
 409
 410       user = User.get_by_id(user.id)
 411       refute user.avatar == %{}
 412     end
 413
 414     test "requires 'write:accounts' permission" do
 415       token1 = insert(:oauth_token, scopes: ["read"])
 416       token2 = insert(:oauth_token, scopes: ["write", "follow"])
 417
 418       for token <- [token1, token2] do
 419         conn =
 420           build_conn()
 421           |> put_req_header("content-type", "multipart/form-data")
 422           |> put_req_header("authorization", "Bearer #{token.token}")
 423           |> patch("/api/v1/accounts/update_credentials", %{})
 424
 425         if token == token1 do
 426           assert %{"error" => "Insufficient permissions: write:accounts."} ==
 427                    json_response_and_validate_schema(conn, 403)
 428         else
 429           assert json_response_and_validate_schema(conn, 200)
 430         end
 431       end
 432     end
 433
 434     test "updates profile emojos", %{user: user, conn: conn} do
 435       note = "*sips :blank:*"
 436       name = "I am :firefox:"
 437
 438       ret_conn =
 439         patch(conn, "/api/v1/accounts/update_credentials", %{
 440           "note" => note,
 441           "display_name" => name
 442         })
 443
 444       assert json_response_and_validate_schema(ret_conn, 200)
 445
 446       conn = get(conn, "/api/v1/accounts/#{user.id}")
 447
 448       assert user_data = json_response_and_validate_schema(conn, 200)
 449
 450       assert user_data["note"] == note
 451       assert user_data["display_name"] == name
 452       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user_data["emojis"]
 453     end
 454
 455     test "update fields", %{conn: conn} do
 456       fields = [
 457         %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
 458         %{"name" => "link.io", "value" => "cofe.io"}
 459       ]
 460
 461       account_data =
 462         conn
 463         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 464         |> json_response_and_validate_schema(200)
 465
 466       assert account_data["fields"] == [
 467                %{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "bar"},
 468                %{
 469                  "name" => "link.io",
 470                  "value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)
 471                }
 472              ]
 473
 474       assert account_data["source"]["fields"] == [
 475                %{
 476                  "name" => "<a href=\"http://google.com\">foo</a>",
 477                  "value" => "<script>bar</script>"
 478                },
 479                %{"name" => "link.io", "value" => "cofe.io"}
 480              ]
 481     end
 482
 483     test "updates birth date", %{conn: conn} do
 484       res =
 485         patch(conn, "/api/v1/accounts/update_credentials", %{
 486           "birthday" => "2001-02-12"
 487         })
 488
 489       assert user_data = json_response_and_validate_schema(res, 200)
 490       assert user_data["pleroma"]["birthday"] == "2001-02-12"
 491     end
 492
 493     test "updates the user's show_birthday status", %{conn: conn} do
 494       res =
 495         patch(conn, "/api/v1/accounts/update_credentials", %{
 496           "show_birthday" => true
 497         })
 498
 499       assert user_data = json_response_and_validate_schema(res, 200)
 500       assert user_data["source"]["pleroma"]["show_birthday"] == true
 501     end
 502
 503     test "unsets birth date", %{conn: conn} do
 504       patch(conn, "/api/v1/accounts/update_credentials", %{
 505         "birthday" => "2001-02-12"
 506       })
 507
 508       res =
 509         patch(conn, "/api/v1/accounts/update_credentials", %{
 510           "birthday" => ""
 511         })
 512
 513       assert user_data = json_response_and_validate_schema(res, 200)
 514       assert user_data["pleroma"]["birthday"] == nil
 515     end
 516
 517     test "emojis in fields labels", %{conn: conn} do
 518       fields = [
 519         %{"name" => ":firefox:", "value" => "is best 2hu"},
 520         %{"name" => "they wins", "value" => ":blank:"}
 521       ]
 522
 523       account_data =
 524         conn
 525         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 526         |> json_response_and_validate_schema(200)
 527
 528       assert account_data["fields"] == [
 529                %{"name" => ":firefox:", "value" => "is best 2hu"},
 530                %{"name" => "they wins", "value" => ":blank:"}
 531              ]
 532
 533       assert account_data["source"]["fields"] == [
 534                %{"name" => ":firefox:", "value" => "is best 2hu"},
 535                %{"name" => "they wins", "value" => ":blank:"}
 536              ]
 537
 538       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = account_data["emojis"]
 539     end
 540
 541     test "update fields via x-www-form-urlencoded", %{conn: conn} do
 542       fields =
 543         [
 544           "fields_attributes[1][name]=link",
 545           "fields_attributes[1][value]=http://cofe.io",
 546           "fields_attributes[0][name]=foo",
 547           "fields_attributes[0][value]=bar"
 548         ]
 549         |> Enum.join("&")
 550
 551       account =
 552         conn
 553         |> put_req_header("content-type", "application/x-www-form-urlencoded")
 554         |> patch("/api/v1/accounts/update_credentials", fields)
 555         |> json_response_and_validate_schema(200)
 556
 557       assert account["fields"] == [
 558                %{"name" => "foo", "value" => "bar"},
 559                %{
 560                  "name" => "link",
 561                  "value" => ~S(<a href="http://cofe.io" rel="ugc">http://cofe.io</a>)
 562                }
 563              ]
 564
 565       assert account["source"]["fields"] == [
 566                %{"name" => "foo", "value" => "bar"},
 567                %{"name" => "link", "value" => "http://cofe.io"}
 568              ]
 569     end
 570
 571     test "update fields with empty name", %{conn: conn} do
 572       fields = [
 573         %{"name" => "foo", "value" => ""},
 574         %{"name" => "", "value" => "bar"}
 575       ]
 576
 577       account =
 578         conn
 579         |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 580         |> json_response_and_validate_schema(200)
 581
 582       assert account["fields"] == [
 583                %{"name" => "foo", "value" => ""}
 584              ]
 585     end
 586
 587     test "update fields when invalid request", %{conn: conn} do
 588       name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
 589       value_limit = Pleroma.Config.get([:instance, :account_field_value_length])
 590
 591       long_name = Enum.map(0..name_limit, fn _ -> "x" end) |> Enum.join()
 592       long_value = Enum.map(0..value_limit, fn _ -> "x" end) |> Enum.join()
 593
 594       fields = [%{"name" => "foo", "value" => long_value}]
 595
 596       assert %{"error" => "Invalid request"} ==
 597                conn
 598                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 599                |> json_response_and_validate_schema(403)
 600
 601       fields = [%{"name" => long_name, "value" => "bar"}]
 602
 603       assert %{"error" => "Invalid request"} ==
 604                conn
 605                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 606                |> json_response_and_validate_schema(403)
 607
 608       clear_config([:instance, :max_account_fields], 1)
 609
 610       fields = [
 611         %{"name" => "foo", "value" => "bar"},
 612         %{"name" => "link", "value" => "cofe.io"}
 613       ]
 614
 615       assert %{"error" => "Invalid request"} ==
 616                conn
 617                |> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
 618                |> json_response_and_validate_schema(403)
 619     end
 620   end
 621
 622   describe "Mark account as bot" do
 623     setup do: oauth_access(["write:accounts"])
 624     setup :request_content_type
 625
 626     test "changing actor_type to Service makes account a bot", %{conn: conn} do
 627       account =
 628         conn
 629         |> patch("/api/v1/accounts/update_credentials", %{actor_type: "Service"})
 630         |> json_response_and_validate_schema(200)
 631
 632       assert account["bot"]
 633       assert account["source"]["pleroma"]["actor_type"] == "Service"
 634     end
 635
 636     test "changing actor_type to Person makes account a human", %{conn: conn} do
 637       account =
 638         conn
 639         |> patch("/api/v1/accounts/update_credentials", %{actor_type: "Person"})
 640         |> json_response_and_validate_schema(200)
 641
 642       refute account["bot"]
 643       assert account["source"]["pleroma"]["actor_type"] == "Person"
 644     end
 645
 646     test "changing actor_type to Application causes error", %{conn: conn} do
 647       response =
 648         conn
 649         |> patch("/api/v1/accounts/update_credentials", %{actor_type: "Application"})
 650         |> json_response_and_validate_schema(403)
 651
 652       assert %{"error" => "Invalid request"} == response
 653     end
 654
 655     test "changing bot field to true changes actor_type to Service", %{conn: conn} do
 656       account =
 657         conn
 658         |> patch("/api/v1/accounts/update_credentials", %{bot: "true"})
 659         |> json_response_and_validate_schema(200)
 660
 661       assert account["bot"]
 662       assert account["source"]["pleroma"]["actor_type"] == "Service"
 663     end
 664
 665     test "changing bot field to false changes actor_type to Person", %{conn: conn} do
 666       account =
 667         conn
 668         |> patch("/api/v1/accounts/update_credentials", %{bot: "false"})
 669         |> json_response_and_validate_schema(200)
 670
 671       refute account["bot"]
 672       assert account["source"]["pleroma"]["actor_type"] == "Person"
 673     end
 674
 675     test "actor_type field has a higher priority than bot", %{conn: conn} do
 676       account =
 677         conn
 678         |> patch("/api/v1/accounts/update_credentials", %{
 679           actor_type: "Person",
 680           bot: "true"
 681         })
 682         |> json_response_and_validate_schema(200)
 683
 684       refute account["bot"]
 685       assert account["source"]["pleroma"]["actor_type"] == "Person"
 686     end
 687   end
 688 end