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