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

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