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