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