git.squeep.com Git - akkoma/blob - test/web/mastodon_api/mastodon_api_controller_test.exs

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