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 "unreblogging" do
 336     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 337       activity = insert(:note_activity)
 338       user = insert(:user)
 339
 340       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 341
 342       conn =
 343         conn
 344         |> assign(:user, user)
 345         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 346
 347       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 348
 349       assert to_string(activity.id) == id
 350     end
 351   end
 352
 353   describe "favoriting" do
 354     test "favs a status and returns it", %{conn: conn} do
 355       activity = insert(:note_activity)
 356       user = insert(:user)
 357
 358       conn =
 359         conn
 360         |> assign(:user, user)
 361         |> post("/api/v1/statuses/#{activity.id}/favourite")
 362
 363       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 364                json_response(conn, 200)
 365
 366       assert to_string(activity.id) == id
 367     end
 368   end
 369
 370   describe "unfavoriting" do
 371     test "unfavorites a status and returns it", %{conn: conn} do
 372       activity = insert(:note_activity)
 373       user = insert(:user)
 374
 375       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 376
 377       conn =
 378         conn
 379         |> assign(:user, user)
 380         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 381
 382       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 383                json_response(conn, 200)
 384
 385       assert to_string(activity.id) == id
 386     end
 387   end
 388
 389   describe "user timelines" do
 390     test "gets a users statuses", %{conn: conn} do
 391       user_one = insert(:user)
 392       user_two = insert(:user)
 393       user_three = insert(:user)
 394
 395       {:ok, user_three} = User.follow(user_three, user_one)
 396
 397       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 398
 399       {:ok, direct_activity} =
 400         CommonAPI.post(user_one, %{
 401           "status" => "Hi, @#{user_two.nickname}.",
 402           "visibility" => "direct"
 403         })
 404
 405       {:ok, private_activity} =
 406         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 407
 408       resp =
 409         conn
 410         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 411
 412       assert [%{"id" => id}] = json_response(resp, 200)
 413       assert id == to_string(activity.id)
 414
 415       resp =
 416         conn
 417         |> assign(:user, user_two)
 418         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 419
 420       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 421       assert id_one == to_string(direct_activity.id)
 422       assert id_two == to_string(activity.id)
 423
 424       resp =
 425         conn
 426         |> assign(:user, user_three)
 427         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 428
 429       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 430       assert id_one == to_string(private_activity.id)
 431       assert id_two == to_string(activity.id)
 432     end
 433
 434     test "unimplemented pinned statuses feature", %{conn: conn} do
 435       note = insert(:note_activity)
 436       user = User.get_by_ap_id(note.data["actor"])
 437
 438       conn =
 439         conn
 440         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 441
 442       assert json_response(conn, 200) == []
 443     end
 444
 445     test "gets an users media", %{conn: conn} do
 446       note = insert(:note_activity)
 447       user = User.get_by_ap_id(note.data["actor"])
 448
 449       file = %Plug.Upload{
 450         content_type: "image/jpg",
 451         path: Path.absname("test/fixtures/image.jpg"),
 452         filename: "an_image.jpg"
 453       }
 454
 455       media =
 456         TwitterAPI.upload(file, "json")
 457         |> Poison.decode!()
 458
 459       {:ok, image_post} =
 460         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 461
 462       conn =
 463         conn
 464         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 465
 466       assert [%{"id" => id}] = json_response(conn, 200)
 467       assert id == to_string(image_post.id)
 468
 469       conn =
 470         build_conn()
 471         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 472
 473       assert [%{"id" => id}] = json_response(conn, 200)
 474       assert id == to_string(image_post.id)
 475     end
 476   end
 477
 478   describe "user relationships" do
 479     test "returns the relationships for the current user", %{conn: conn} do
 480       user = insert(:user)
 481       other_user = insert(:user)
 482       {:ok, user} = User.follow(user, other_user)
 483
 484       conn =
 485         conn
 486         |> assign(:user, user)
 487         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 488
 489       assert [relationship] = json_response(conn, 200)
 490
 491       assert to_string(other_user.id) == relationship["id"]
 492     end
 493   end
 494
 495   test "account fetching", %{conn: conn} do
 496     user = insert(:user)
 497
 498     conn =
 499       conn
 500       |> get("/api/v1/accounts/#{user.id}")
 501
 502     assert %{"id" => id} = json_response(conn, 200)
 503     assert id == to_string(user.id)
 504
 505     conn =
 506       build_conn()
 507       |> get("/api/v1/accounts/-1")
 508
 509     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 510   end
 511
 512   test "media upload", %{conn: conn} do
 513     file = %Plug.Upload{
 514       content_type: "image/jpg",
 515       path: Path.absname("test/fixtures/image.jpg"),
 516       filename: "an_image.jpg"
 517     }
 518
 519     user = insert(:user)
 520
 521     conn =
 522       conn
 523       |> assign(:user, user)
 524       |> post("/api/v1/media", %{"file" => file})
 525
 526     assert media = json_response(conn, 200)
 527
 528     assert media["type"] == "image"
 529   end
 530
 531   test "hashtag timeline", %{conn: conn} do
 532     following = insert(:user)
 533
 534     capture_log(fn ->
 535       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 536
 537       {:ok, [_activity]} =
 538         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 539
 540       conn =
 541         conn
 542         |> get("/api/v1/timelines/tag/2hu")
 543
 544       assert [%{"id" => id}] = json_response(conn, 200)
 545
 546       assert id == to_string(activity.id)
 547     end)
 548   end
 549
 550   test "getting followers", %{conn: conn} do
 551     user = insert(:user)
 552     other_user = insert(:user)
 553     {:ok, user} = User.follow(user, other_user)
 554
 555     conn =
 556       conn
 557       |> get("/api/v1/accounts/#{other_user.id}/followers")
 558
 559     assert [%{"id" => id}] = json_response(conn, 200)
 560     assert id == to_string(user.id)
 561   end
 562
 563   test "getting following", %{conn: conn} do
 564     user = insert(:user)
 565     other_user = insert(:user)
 566     {:ok, user} = User.follow(user, other_user)
 567
 568     conn =
 569       conn
 570       |> get("/api/v1/accounts/#{user.id}/following")
 571
 572     assert [%{"id" => id}] = json_response(conn, 200)
 573     assert id == to_string(other_user.id)
 574   end
 575
 576   test "following / unfollowing a user", %{conn: conn} do
 577     user = insert(:user)
 578     other_user = insert(:user)
 579
 580     conn =
 581       conn
 582       |> assign(:user, user)
 583       |> post("/api/v1/accounts/#{other_user.id}/follow")
 584
 585     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
 586
 587     user = Repo.get(User, user.id)
 588
 589     conn =
 590       build_conn()
 591       |> assign(:user, user)
 592       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 593
 594     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
 595
 596     user = Repo.get(User, user.id)
 597
 598     conn =
 599       build_conn()
 600       |> assign(:user, user)
 601       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 602
 603     assert %{"id" => id} = json_response(conn, 200)
 604     assert id == to_string(other_user.id)
 605   end
 606
 607   test "blocking / unblocking a user", %{conn: conn} do
 608     user = insert(:user)
 609     other_user = insert(:user)
 610
 611     conn =
 612       conn
 613       |> assign(:user, user)
 614       |> post("/api/v1/accounts/#{other_user.id}/block")
 615
 616     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
 617
 618     user = Repo.get(User, user.id)
 619
 620     conn =
 621       build_conn()
 622       |> assign(:user, user)
 623       |> post("/api/v1/accounts/#{other_user.id}/unblock")
 624
 625     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
 626   end
 627
 628   test "getting a list of blocks", %{conn: conn} do
 629     user = insert(:user)
 630     other_user = insert(:user)
 631
 632     {:ok, user} = User.block(user, other_user)
 633
 634     conn =
 635       conn
 636       |> assign(:user, user)
 637       |> get("/api/v1/blocks")
 638
 639     other_user_id = to_string(other_user.id)
 640     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
 641   end
 642
 643   test "unimplemented mute endpoints" do
 644     user = insert(:user)
 645     other_user = insert(:user)
 646
 647     ["mute", "unmute"]
 648     |> Enum.each(fn endpoint ->
 649       conn =
 650         build_conn()
 651         |> assign(:user, user)
 652         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
 653
 654       assert %{"id" => id} = json_response(conn, 200)
 655       assert id == to_string(other_user.id)
 656     end)
 657   end
 658
 659   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
 660     user = insert(:user)
 661
 662     ["blocks", "domain_blocks", "mutes", "follow_requests"]
 663     |> Enum.each(fn endpoint ->
 664       conn =
 665         build_conn()
 666         |> assign(:user, user)
 667         |> get("/api/v1/#{endpoint}")
 668
 669       assert [] = json_response(conn, 200)
 670     end)
 671   end
 672
 673   test "account search", %{conn: conn} do
 674     user = insert(:user)
 675     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 676     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 677
 678     results =
 679       conn
 680       |> assign(:user, user)
 681       |> get("/api/v1/accounts/search", %{"q" => "shp"})
 682       |> json_response(200)
 683
 684     result_ids = for result <- results, do: result["acct"]
 685
 686     assert user_two.nickname in result_ids
 687     assert user_three.nickname in result_ids
 688
 689     results =
 690       conn
 691       |> assign(:user, user)
 692       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
 693       |> json_response(200)
 694
 695     result_ids = for result <- results, do: result["acct"]
 696
 697     assert user_three.nickname in result_ids
 698   end
 699
 700   test "search", %{conn: conn} do
 701     user = insert(:user)
 702     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 703     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 704
 705     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 706
 707     {:ok, _activity} =
 708       CommonAPI.post(user, %{
 709         "status" => "This is about 2hu, but private",
 710         "visibility" => "private"
 711       })
 712
 713     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 714
 715     conn =
 716       conn
 717       |> get("/api/v1/search", %{"q" => "2hu"})
 718
 719     assert results = json_response(conn, 200)
 720
 721     [account | _] = results["accounts"]
 722     assert account["id"] == to_string(user_three.id)
 723
 724     assert results["hashtags"] == []
 725
 726     [status] = results["statuses"]
 727     assert status["id"] == to_string(activity.id)
 728   end
 729
 730   test "search fetches remote statuses", %{conn: conn} do
 731     capture_log(fn ->
 732       conn =
 733         conn
 734         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 735
 736       assert results = json_response(conn, 200)
 737
 738       [status] = results["statuses"]
 739       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 740     end)
 741   end
 742
 743   test "search fetches remote accounts", %{conn: conn} do
 744     conn =
 745       conn
 746       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
 747
 748     assert results = json_response(conn, 200)
 749     [account] = results["accounts"]
 750     assert account["acct"] == "shp@social.heldscal.la"
 751   end
 752
 753   test "returns the favorites of a user", %{conn: conn} do
 754     user = insert(:user)
 755     other_user = insert(:user)
 756
 757     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
 758     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
 759
 760     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 761
 762     conn =
 763       conn
 764       |> assign(:user, user)
 765       |> get("/api/v1/favourites")
 766
 767     assert [status] = json_response(conn, 200)
 768     assert status["id"] == to_string(activity.id)
 769   end
 770
 771   describe "updating credentials" do
 772     test "updates the user's bio", %{conn: conn} do
 773       user = insert(:user)
 774
 775       conn =
 776         conn
 777         |> assign(:user, user)
 778         |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
 779
 780       assert user = json_response(conn, 200)
 781       assert user["note"] == "I drink #cofe"
 782     end
 783
 784     test "updates the user's name", %{conn: conn} do
 785       user = insert(:user)
 786
 787       conn =
 788         conn
 789         |> assign(:user, user)
 790         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 791
 792       assert user = json_response(conn, 200)
 793       assert user["display_name"] == "markorepairs"
 794     end
 795
 796     test "updates the user's avatar", %{conn: conn} do
 797       user = insert(:user)
 798
 799       new_avatar = %Plug.Upload{
 800         content_type: "image/jpg",
 801         path: Path.absname("test/fixtures/image.jpg"),
 802         filename: "an_image.jpg"
 803       }
 804
 805       conn =
 806         conn
 807         |> assign(:user, user)
 808         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 809
 810       assert user = json_response(conn, 200)
 811       assert user["avatar"] != "https://placehold.it/48x48"
 812     end
 813
 814     test "updates the user's banner", %{conn: conn} do
 815       user = insert(:user)
 816
 817       new_header = %Plug.Upload{
 818         content_type: "image/jpg",
 819         path: Path.absname("test/fixtures/image.jpg"),
 820         filename: "an_image.jpg"
 821       }
 822
 823       conn =
 824         conn
 825         |> assign(:user, user)
 826         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 827
 828       assert user = json_response(conn, 200)
 829       assert user["header"] != "https://placehold.it/700x335"
 830     end
 831   end
 832
 833   test "get instance information", %{conn: conn} do
 834     insert(:user, %{local: true})
 835     user = insert(:user, %{local: true})
 836     insert(:user, %{local: false})
 837
 838     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 839
 840     Pleroma.Stats.update_stats()
 841
 842     conn =
 843       conn
 844       |> get("/api/v1/instance")
 845
 846     assert result = json_response(conn, 200)
 847
 848     assert result["stats"]["user_count"] == 2
 849     assert result["stats"]["status_count"] == 1
 850   end
 851 end