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