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