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

   1 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   2   use Pleroma.Web.ConnCase
   3
   4   alias Pleroma.Web.TwitterAPI.TwitterAPI
   5   alias Pleroma.{Repo, User, Activity, Notification}
   6   alias Pleroma.Web.{OStatus, CommonAPI}
   7
   8   import Pleroma.Factory
   9   import ExUnit.CaptureLog
  10
  11   test "the home timeline", %{conn: conn} do
  12     user = insert(:user)
  13     following = insert(:user)
  14
  15     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  16
  17     conn =
  18       conn
  19       |> assign(:user, user)
  20       |> get("/api/v1/timelines/home")
  21
  22     assert length(json_response(conn, 200)) == 0
  23
  24     {:ok, user} = User.follow(user, following)
  25
  26     conn =
  27       build_conn()
  28       |> assign(:user, user)
  29       |> get("/api/v1/timelines/home")
  30
  31     assert [%{"content" => "test"}] = json_response(conn, 200)
  32   end
  33
  34   test "the public timeline", %{conn: conn} do
  35     following = insert(:user)
  36
  37     capture_log(fn ->
  38       {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  39
  40       {:ok, [_activity]} =
  41         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  42
  43       conn =
  44         conn
  45         |> get("/api/v1/timelines/public", %{"local" => "False"})
  46
  47       assert length(json_response(conn, 200)) == 2
  48
  49       conn =
  50         build_conn()
  51         |> get("/api/v1/timelines/public", %{"local" => "True"})
  52
  53       assert [%{"content" => "test"}] = json_response(conn, 200)
  54
  55       conn =
  56         build_conn()
  57         |> get("/api/v1/timelines/public", %{"local" => "1"})
  58
  59       assert [%{"content" => "test"}] = json_response(conn, 200)
  60     end)
  61   end
  62
  63   test "posting a status", %{conn: conn} do
  64     user = insert(:user)
  65
  66     idempotency_key = "Pikachu rocks!"
  67
  68     conn_one =
  69       conn
  70       |> assign(:user, user)
  71       |> put_req_header("idempotency-key", idempotency_key)
  72       |> post("/api/v1/statuses", %{
  73         "status" => "cofe",
  74         "spoiler_text" => "2hu",
  75         "sensitive" => "false"
  76       })
  77
  78     {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  79     # Six hours
  80     assert ttl > :timer.seconds(6 * 60 * 60 - 1)
  81
  82     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
  83              json_response(conn_one, 200)
  84
  85     assert Repo.get(Activity, id)
  86
  87     conn_two =
  88       conn
  89       |> assign(:user, user)
  90       |> put_req_header("idempotency-key", idempotency_key)
  91       |> post("/api/v1/statuses", %{
  92         "status" => "cofe",
  93         "spoiler_text" => "2hu",
  94         "sensitive" => "false"
  95       })
  96
  97     assert %{"id" => second_id} = json_response(conn_two, 200)
  98
  99     assert id == second_id
 100
 101     conn_three =
 102       conn
 103       |> assign(:user, user)
 104       |> post("/api/v1/statuses", %{
 105         "status" => "cofe",
 106         "spoiler_text" => "2hu",
 107         "sensitive" => "false"
 108       })
 109
 110     assert %{"id" => third_id} = json_response(conn_three, 200)
 111
 112     refute id == third_id
 113   end
 114
 115   test "posting a sensitive status", %{conn: conn} do
 116     user = insert(:user)
 117
 118     conn =
 119       conn
 120       |> assign(:user, user)
 121       |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 122
 123     assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 124     assert Repo.get(Activity, id)
 125   end
 126
 127   test "posting a direct status", %{conn: conn} do
 128     user1 = insert(:user)
 129     user2 = insert(:user)
 130     content = "direct cofe @#{user2.nickname}"
 131
 132     conn =
 133       conn
 134       |> assign(:user, user1)
 135       |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 136
 137     assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
 138     assert activity = Repo.get(Activity, id)
 139     assert user2.follower_address not in activity.data["to"]
 140   end
 141
 142   test "direct timeline", %{conn: conn} do
 143     dm = insert(:direct_note_activity)
 144     reg_note = insert(:note_activity)
 145
 146     recipient = User.get_by_ap_id(hd(dm.recipients))
 147
 148     conn =
 149       conn
 150       |> assign(:user, recipient)
 151       |> get("api/v1/timelines/direct")
 152
 153     resp = json_response(conn, 200)
 154     first_status = hd(resp)
 155
 156     assert length(resp) == 1
 157     assert %{"visibility" => "direct"} = first_status
 158     assert first_status["url"] != reg_note.data["id"]
 159   end
 160
 161   test "replying to a status", %{conn: conn} do
 162     user = insert(:user)
 163
 164     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 165
 166     conn =
 167       conn
 168       |> assign(:user, user)
 169       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 170
 171     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 172
 173     activity = Repo.get(Activity, id)
 174
 175     assert activity.data["context"] == replied_to.data["context"]
 176     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
 177   end
 178
 179   test "verify_credentials", %{conn: conn} do
 180     user = insert(:user)
 181
 182     conn =
 183       conn
 184       |> assign(:user, user)
 185       |> get("/api/v1/accounts/verify_credentials")
 186
 187     assert %{"id" => id} = json_response(conn, 200)
 188     assert id == to_string(user.id)
 189   end
 190
 191   test "get a status", %{conn: conn} do
 192     activity = insert(:note_activity)
 193
 194     conn =
 195       conn
 196       |> get("/api/v1/statuses/#{activity.id}")
 197
 198     assert %{"id" => id} = json_response(conn, 200)
 199     assert id == to_string(activity.id)
 200   end
 201
 202   describe "deleting a status" do
 203     test "when you created it", %{conn: conn} do
 204       activity = insert(:note_activity)
 205       author = User.get_by_ap_id(activity.data["actor"])
 206
 207       conn =
 208         conn
 209         |> assign(:user, author)
 210         |> delete("/api/v1/statuses/#{activity.id}")
 211
 212       assert %{} = json_response(conn, 200)
 213
 214       assert Repo.get(Activity, activity.id) == nil
 215     end
 216
 217     test "when you didn't create it", %{conn: conn} do
 218       activity = insert(:note_activity)
 219       user = insert(:user)
 220
 221       conn =
 222         conn
 223         |> assign(:user, user)
 224         |> delete("/api/v1/statuses/#{activity.id}")
 225
 226       assert %{"error" => _} = json_response(conn, 403)
 227
 228       assert Repo.get(Activity, activity.id) == activity
 229     end
 230   end
 231
 232   describe "notifications" do
 233     test "list of notifications", %{conn: conn} do
 234       user = insert(:user)
 235       other_user = insert(:user)
 236
 237       {:ok, activity} =
 238         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 239
 240       {:ok, [_notification]} = Notification.create_notifications(activity)
 241
 242       conn =
 243         conn
 244         |> assign(:user, user)
 245         |> get("/api/v1/notifications")
 246
 247       expected_response =
 248         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 249
 250       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 251       assert response == expected_response
 252     end
 253
 254     test "getting a single notification", %{conn: conn} do
 255       user = insert(:user)
 256       other_user = insert(:user)
 257
 258       {:ok, activity} =
 259         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 260
 261       {:ok, [notification]} = Notification.create_notifications(activity)
 262
 263       conn =
 264         conn
 265         |> assign(:user, user)
 266         |> get("/api/v1/notifications/#{notification.id}")
 267
 268       expected_response =
 269         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 270
 271       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 272       assert response == expected_response
 273     end
 274
 275     test "dismissing a single notification", %{conn: conn} do
 276       user = insert(:user)
 277       other_user = insert(:user)
 278
 279       {:ok, activity} =
 280         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 281
 282       {:ok, [notification]} = Notification.create_notifications(activity)
 283
 284       conn =
 285         conn
 286         |> assign(:user, user)
 287         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 288
 289       assert %{} = json_response(conn, 200)
 290     end
 291
 292     test "clearing all notifications", %{conn: conn} do
 293       user = insert(:user)
 294       other_user = insert(:user)
 295
 296       {:ok, activity} =
 297         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 298
 299       {:ok, [_notification]} = Notification.create_notifications(activity)
 300
 301       conn =
 302         conn
 303         |> assign(:user, user)
 304         |> post("/api/v1/notifications/clear")
 305
 306       assert %{} = json_response(conn, 200)
 307
 308       conn =
 309         build_conn()
 310         |> assign(:user, user)
 311         |> get("/api/v1/notifications")
 312
 313       assert all = json_response(conn, 200)
 314       assert all == []
 315     end
 316   end
 317
 318   describe "reblogging" do
 319     test "reblogs and returns the reblogged status", %{conn: conn} do
 320       activity = insert(:note_activity)
 321       user = insert(:user)
 322
 323       conn =
 324         conn
 325         |> assign(:user, user)
 326         |> post("/api/v1/statuses/#{activity.id}/reblog")
 327
 328       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 329                json_response(conn, 200)
 330
 331       assert to_string(activity.id) == id
 332     end
 333   end
 334
 335   describe "favoriting" do
 336     test "favs a status and returns it", %{conn: conn} do
 337       activity = insert(:note_activity)
 338       user = insert(:user)
 339
 340       conn =
 341         conn
 342         |> assign(:user, user)
 343         |> post("/api/v1/statuses/#{activity.id}/favourite")
 344
 345       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 346                json_response(conn, 200)
 347
 348       assert to_string(activity.id) == id
 349     end
 350   end
 351
 352   describe "unfavoriting" do
 353     test "unfavorites a status and returns it", %{conn: conn} do
 354       activity = insert(:note_activity)
 355       user = insert(:user)
 356
 357       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 358
 359       conn =
 360         conn
 361         |> assign(:user, user)
 362         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 363
 364       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 365                json_response(conn, 200)
 366
 367       assert to_string(activity.id) == id
 368     end
 369   end
 370
 371   describe "user timelines" do
 372     test "gets a users statuses", %{conn: conn} do
 373       _note = insert(:note_activity)
 374       note_two = insert(:note_activity)
 375
 376       user = User.get_by_ap_id(note_two.data["actor"])
 377
 378       conn =
 379         conn
 380         |> get("/api/v1/accounts/#{user.id}/statuses")
 381
 382       assert [%{"id" => id}] = json_response(conn, 200)
 383
 384       assert id == to_string(note_two.id)
 385     end
 386
 387     test "unimplemented pinned statuses feature", %{conn: conn} do
 388       note = insert(:note_activity)
 389       user = User.get_by_ap_id(note.data["actor"])
 390
 391       conn =
 392         conn
 393         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 394
 395       assert json_response(conn, 200) == []
 396     end
 397
 398     test "gets an users media", %{conn: conn} do
 399       note = insert(:note_activity)
 400       user = User.get_by_ap_id(note.data["actor"])
 401
 402       file = %Plug.Upload{
 403         content_type: "image/jpg",
 404         path: Path.absname("test/fixtures/image.jpg"),
 405         filename: "an_image.jpg"
 406       }
 407
 408       media =
 409         TwitterAPI.upload(file, "json")
 410         |> Poison.decode!()
 411
 412       {:ok, image_post} =
 413         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 414
 415       conn =
 416         conn
 417         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 418
 419       assert [%{"id" => id}] = json_response(conn, 200)
 420       assert id == to_string(image_post.id)
 421
 422       conn =
 423         build_conn()
 424         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 425
 426       assert [%{"id" => id}] = json_response(conn, 200)
 427       assert id == to_string(image_post.id)
 428     end
 429   end
 430
 431   describe "user relationships" do
 432     test "returns the relationships for the current user", %{conn: conn} do
 433       user = insert(:user)
 434       other_user = insert(:user)
 435       {:ok, user} = User.follow(user, other_user)
 436
 437       conn =
 438         conn
 439         |> assign(:user, user)
 440         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 441
 442       assert [relationship] = json_response(conn, 200)
 443
 444       assert to_string(other_user.id) == relationship["id"]
 445     end
 446   end
 447
 448   test "account fetching", %{conn: conn} do
 449     user = insert(:user)
 450
 451     conn =
 452       conn
 453       |> get("/api/v1/accounts/#{user.id}")
 454
 455     assert %{"id" => id} = json_response(conn, 200)
 456     assert id == to_string(user.id)
 457
 458     conn =
 459       build_conn()
 460       |> get("/api/v1/accounts/-1")
 461
 462     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 463   end
 464
 465   test "media upload", %{conn: conn} do
 466     file = %Plug.Upload{
 467       content_type: "image/jpg",
 468       path: Path.absname("test/fixtures/image.jpg"),
 469       filename: "an_image.jpg"
 470     }
 471
 472     user = insert(:user)
 473
 474     conn =
 475       conn
 476       |> assign(:user, user)
 477       |> post("/api/v1/media", %{"file" => file})
 478
 479     assert media = json_response(conn, 200)
 480
 481     assert media["type"] == "image"
 482   end
 483
 484   test "hashtag timeline", %{conn: conn} do
 485     following = insert(:user)
 486
 487     capture_log(fn ->
 488       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 489
 490       {:ok, [_activity]} =
 491         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 492
 493       conn =
 494         conn
 495         |> get("/api/v1/timelines/tag/2hu")
 496
 497       assert [%{"id" => id}] = json_response(conn, 200)
 498
 499       assert id == to_string(activity.id)
 500     end)
 501   end
 502
 503   test "getting followers", %{conn: conn} do
 504     user = insert(:user)
 505     other_user = insert(:user)
 506     {:ok, user} = User.follow(user, other_user)
 507
 508     conn =
 509       conn
 510       |> get("/api/v1/accounts/#{other_user.id}/followers")
 511
 512     assert [%{"id" => id}] = json_response(conn, 200)
 513     assert id == to_string(user.id)
 514   end
 515
 516   test "getting following", %{conn: conn} do
 517     user = insert(:user)
 518     other_user = insert(:user)
 519     {:ok, user} = User.follow(user, other_user)
 520
 521     conn =
 522       conn
 523       |> get("/api/v1/accounts/#{user.id}/following")
 524
 525     assert [%{"id" => id}] = json_response(conn, 200)
 526     assert id == to_string(other_user.id)
 527   end
 528
 529   test "following / unfollowing a user", %{conn: conn} do
 530     user = insert(:user)
 531     other_user = insert(:user)
 532
 533     conn =
 534       conn
 535       |> assign(:user, user)
 536       |> post("/api/v1/accounts/#{other_user.id}/follow")
 537
 538     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
 539
 540     user = Repo.get(User, user.id)
 541
 542     conn =
 543       build_conn()
 544       |> assign(:user, user)
 545       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 546
 547     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
 548
 549     user = Repo.get(User, user.id)
 550
 551     conn =
 552       build_conn()
 553       |> assign(:user, user)
 554       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 555
 556     assert %{"id" => id} = json_response(conn, 200)
 557     assert id == to_string(other_user.id)
 558   end
 559
 560   test "blocking / unblocking a user", %{conn: conn} do
 561     user = insert(:user)
 562     other_user = insert(:user)
 563
 564     conn =
 565       conn
 566       |> assign(:user, user)
 567       |> post("/api/v1/accounts/#{other_user.id}/block")
 568
 569     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
 570
 571     user = Repo.get(User, user.id)
 572
 573     conn =
 574       build_conn()
 575       |> assign(:user, user)
 576       |> post("/api/v1/accounts/#{other_user.id}/unblock")
 577
 578     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
 579   end
 580
 581   test "getting a list of blocks", %{conn: conn} do
 582     user = insert(:user)
 583     other_user = insert(:user)
 584
 585     {:ok, user} = User.block(user, other_user)
 586
 587     conn =
 588       conn
 589       |> assign(:user, user)
 590       |> get("/api/v1/blocks")
 591
 592     other_user_id = to_string(other_user.id)
 593     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
 594   end
 595
 596   test "unimplemented mute endpoints" do
 597     user = insert(:user)
 598     other_user = insert(:user)
 599
 600     ["mute", "unmute"]
 601     |> Enum.each(fn endpoint ->
 602       conn =
 603         build_conn()
 604         |> assign(:user, user)
 605         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
 606
 607       assert %{"id" => id} = json_response(conn, 200)
 608       assert id == to_string(other_user.id)
 609     end)
 610   end
 611
 612   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
 613     user = insert(:user)
 614
 615     ["blocks", "domain_blocks", "mutes", "follow_requests"]
 616     |> Enum.each(fn endpoint ->
 617       conn =
 618         build_conn()
 619         |> assign(:user, user)
 620         |> get("/api/v1/#{endpoint}")
 621
 622       assert [] = json_response(conn, 200)
 623     end)
 624   end
 625
 626   test "account search", %{conn: conn} do
 627     user = insert(:user)
 628     _user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 629     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 630
 631     conn =
 632       conn
 633       |> assign(:user, user)
 634       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
 635
 636     assert [account] = json_response(conn, 200)
 637     assert account["id"] == to_string(user_three.id)
 638   end
 639
 640   test "search", %{conn: conn} do
 641     user = insert(:user)
 642     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 643     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 644
 645     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 646
 647     {:ok, _activity} =
 648       CommonAPI.post(user, %{
 649         "status" => "This is about 2hu, but private",
 650         "visibility" => "private"
 651       })
 652
 653     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 654
 655     conn =
 656       conn
 657       |> get("/api/v1/search", %{"q" => "2hu"})
 658
 659     assert results = json_response(conn, 200)
 660
 661     [account] = results["accounts"]
 662     assert account["id"] == to_string(user_three.id)
 663
 664     assert results["hashtags"] == []
 665
 666     [status] = results["statuses"]
 667     assert status["id"] == to_string(activity.id)
 668   end
 669
 670   test "search fetches remote statuses", %{conn: conn} do
 671     capture_log(fn ->
 672       conn =
 673         conn
 674         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 675
 676       assert results = json_response(conn, 200)
 677
 678       [status] = results["statuses"]
 679       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 680     end)
 681   end
 682
 683   test "search fetches remote accounts", %{conn: conn} do
 684     conn =
 685       conn
 686       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
 687
 688     assert results = json_response(conn, 200)
 689     [account] = results["accounts"]
 690     assert account["acct"] == "shp@social.heldscal.la"
 691   end
 692
 693   test "returns the favorites of a user", %{conn: conn} do
 694     user = insert(:user)
 695     other_user = insert(:user)
 696
 697     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
 698     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
 699
 700     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 701
 702     conn =
 703       conn
 704       |> assign(:user, user)
 705       |> get("/api/v1/favourites")
 706
 707     assert [status] = json_response(conn, 200)
 708     assert status["id"] == to_string(activity.id)
 709   end
 710
 711   describe "updating credentials" do
 712     test "updates the user's bio", %{conn: conn} do
 713       user = insert(:user)
 714
 715       conn =
 716         conn
 717         |> assign(:user, user)
 718         |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
 719
 720       assert user = json_response(conn, 200)
 721       assert user["note"] == "I drink #cofe"
 722     end
 723
 724     test "updates the user's name", %{conn: conn} do
 725       user = insert(:user)
 726
 727       conn =
 728         conn
 729         |> assign(:user, user)
 730         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 731
 732       assert user = json_response(conn, 200)
 733       assert user["display_name"] == "markorepairs"
 734     end
 735
 736     test "updates the user's avatar", %{conn: conn} do
 737       user = insert(:user)
 738
 739       new_avatar = %Plug.Upload{
 740         content_type: "image/jpg",
 741         path: Path.absname("test/fixtures/image.jpg"),
 742         filename: "an_image.jpg"
 743       }
 744
 745       conn =
 746         conn
 747         |> assign(:user, user)
 748         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 749
 750       assert user = json_response(conn, 200)
 751       assert user["avatar"] != "https://placehold.it/48x48"
 752     end
 753
 754     test "updates the user's banner", %{conn: conn} do
 755       user = insert(:user)
 756
 757       new_header = %Plug.Upload{
 758         content_type: "image/jpg",
 759         path: Path.absname("test/fixtures/image.jpg"),
 760         filename: "an_image.jpg"
 761       }
 762
 763       conn =
 764         conn
 765         |> assign(:user, user)
 766         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 767
 768       assert user = json_response(conn, 200)
 769       assert user["header"] != "https://placehold.it/700x335"
 770     end
 771   end
 772
 773   test "get instance information", %{conn: conn} do
 774     insert(:user, %{local: true})
 775     user = insert(:user, %{local: true})
 776     insert(:user, %{local: false})
 777
 778     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 779
 780     Pleroma.Stats.update_stats()
 781
 782     conn =
 783       conn
 784       |> get("/api/v1/instance")
 785
 786     assert result = json_response(conn, 200)
 787
 788     assert result["stats"]["user_count"] == 2
 789     assert result["stats"]["status_count"] == 1
 790   end
 791 end