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