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
  10   test "the home timeline", %{conn: conn} do
  11     user = insert(:user)
  12     following = insert(:user)
  13
  14     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  15
  16     conn = conn
  17     |> assign(:user, user)
  18     |> get("/api/v1/timelines/home")
  19
  20     assert length(json_response(conn, 200)) == 0
  21
  22     {:ok, user} = User.follow(user, following)
  23
  24     conn = build_conn()
  25     |> assign(:user, user)
  26     |> get("/api/v1/timelines/home")
  27
  28     assert [%{"content" => "test"}] = json_response(conn, 200)
  29   end
  30
  31   test "the public timeline", %{conn: conn} do
  32     following = insert(:user)
  33
  34     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  35     {:ok, [_activity]} = OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  36
  37     conn = conn
  38     |> get("/api/v1/timelines/public")
  39
  40     assert length(json_response(conn, 200)) == 2
  41
  42     conn = build_conn()
  43     |> get("/api/v1/timelines/public", %{"local" => "True"})
  44
  45     assert [%{"content" => "test"}] = json_response(conn, 200)
  46   end
  47
  48   test "posting a status", %{conn: conn} do
  49     user = insert(:user)
  50
  51     conn = conn
  52     |> assign(:user, user)
  53     |> post("/api/v1/statuses", %{"status" => "cofe", "spoiler_text" => "2hu"})
  54
  55     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu"} = json_response(conn, 200)
  56     assert Repo.get(Activity, id)
  57   end
  58
  59   test "replying to a status", %{conn: conn} do
  60     user = insert(:user)
  61
  62     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
  63
  64     conn = conn
  65     |> assign(:user, user)
  66     |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
  67
  68     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
  69
  70     activity = Repo.get(Activity, id)
  71
  72     assert activity.data["context"] == replied_to.data["context"]
  73     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
  74   end
  75
  76   test "verify_credentials", %{conn: conn} do
  77     user = insert(:user)
  78
  79     conn = conn
  80     |> assign(:user, user)
  81     |> get("/api/v1/accounts/verify_credentials")
  82
  83     assert %{"id" => id} = json_response(conn, 200)
  84     assert id == to_string(user.id)
  85   end
  86
  87   test "get a status", %{conn: conn} do
  88     activity = insert(:note_activity)
  89
  90     conn = conn
  91     |> get("/api/v1/statuses/#{activity.id}")
  92
  93     assert %{"id" => id} = json_response(conn, 200)
  94     assert id == to_string(activity.id)
  95   end
  96
  97   describe "deleting a status" do
  98     test "when you created it", %{conn: conn} do
  99       activity = insert(:note_activity)
 100       author = User.get_by_ap_id(activity.data["actor"])
 101
 102       conn = conn
 103       |> assign(:user, author)
 104       |> delete("/api/v1/statuses/#{activity.id}")
 105
 106       assert %{} = json_response(conn, 200)
 107
 108       assert Repo.get(Activity, activity.id) == nil
 109     end
 110
 111     test "when you didn't create it", %{conn: conn} do
 112       activity = insert(:note_activity)
 113       user = insert(:user)
 114
 115       conn = conn
 116       |> assign(:user, user)
 117       |> delete("/api/v1/statuses/#{activity.id}")
 118
 119       assert %{"error" => _} = json_response(conn, 403)
 120
 121       assert Repo.get(Activity, activity.id) == activity
 122     end
 123   end
 124
 125   describe "notifications" do
 126     test "list of notifications", %{conn: conn} do
 127       user = insert(:user)
 128       other_user = insert(:user)
 129
 130       {:ok, activity} = TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 131       {:ok, [notification]} = Notification.create_notifications(activity)
 132
 133       conn = conn
 134       |> assign(:user, user)
 135       |> get("/api/v1/notifications")
 136
 137       expected_response = "hi <a href=\"#{user.ap_id}\">@#{user.nickname}</a>"
 138       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 139       assert response == expected_response
 140     end
 141
 142     test "getting a single notification", %{conn: conn} do
 143       user = insert(:user)
 144       other_user = insert(:user)
 145
 146       {:ok, activity} = TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 147       {:ok, [notification]} = Notification.create_notifications(activity)
 148
 149       conn = conn
 150       |> assign(:user, user)
 151       |> get("/api/v1/notifications/#{notification.id}")
 152
 153       expected_response = "hi <a href=\"#{user.ap_id}\">@#{user.nickname}</a>"
 154       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 155       assert response == expected_response
 156     end
 157
 158     test "dismissing a single notification", %{conn: conn} do
 159       user = insert(:user)
 160       other_user = insert(:user)
 161
 162       {:ok, activity} = TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 163       {:ok, [notification]} = Notification.create_notifications(activity)
 164
 165       conn = conn
 166       |> assign(:user, user)
 167       |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 168
 169       assert %{} = json_response(conn, 200)
 170     end
 171
 172     test "clearing all notifications", %{conn: conn} do
 173       user = insert(:user)
 174       other_user = insert(:user)
 175
 176       {:ok, activity} = TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 177       {:ok, [notification]} = Notification.create_notifications(activity)
 178
 179       conn = conn
 180       |> assign(:user, user)
 181       |> post("/api/v1/notifications/clear")
 182
 183       assert %{} = json_response(conn, 200)
 184
 185       conn = build_conn()
 186       |> assign(:user, user)
 187       |> get("/api/v1/notifications")
 188
 189       assert all = json_response(conn, 200)
 190       assert all == []
 191     end
 192   end
 193
 194   describe "reblogging" do
 195     test "reblogs and returns the reblogged status", %{conn: conn} do
 196       activity = insert(:note_activity)
 197       user = insert(:user)
 198
 199       conn = conn
 200       |> assign(:user, user)
 201       |> post("/api/v1/statuses/#{activity.id}/reblog")
 202
 203       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} = json_response(conn, 200)
 204       assert to_string(activity.id) == id
 205     end
 206   end
 207
 208   describe "favoriting" do
 209     test "favs a status and returns it", %{conn: conn} do
 210       activity = insert(:note_activity)
 211       user = insert(:user)
 212
 213       conn = conn
 214       |> assign(:user, user)
 215       |> post("/api/v1/statuses/#{activity.id}/favourite")
 216
 217       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} = json_response(conn, 200)
 218       assert to_string(activity.id) == id
 219     end
 220   end
 221
 222   describe "unfavoriting" do
 223     test "unfavorites a status and returns it", %{conn: conn} do
 224       activity = insert(:note_activity)
 225       user = insert(:user)
 226
 227       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 228
 229       conn = conn
 230       |> assign(:user, user)
 231       |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 232
 233       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} = json_response(conn, 200)
 234       assert to_string(activity.id) == id
 235     end
 236   end
 237
 238   describe "user timelines" do
 239     test "gets a users statuses", %{conn: conn} do
 240       _note = insert(:note_activity)
 241       note_two = insert(:note_activity)
 242
 243       user = User.get_by_ap_id(note_two.data["actor"])
 244
 245       conn = conn
 246       |> get("/api/v1/accounts/#{user.id}/statuses")
 247
 248       assert [%{"id" => id}] = json_response(conn, 200)
 249
 250       assert id == to_string(note_two.id)
 251     end
 252   end
 253
 254   describe "user relationships" do
 255     test "returns the relationships for the current user", %{conn: conn} do
 256       user = insert(:user)
 257       other_user = insert(:user)
 258       {:ok, user} = User.follow(user, other_user)
 259
 260       conn = conn
 261       |> assign(:user, user)
 262       |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 263
 264       assert [relationship] = json_response(conn, 200)
 265
 266       assert to_string(other_user.id) == relationship["id"]
 267     end
 268   end
 269
 270   test "account fetching", %{conn: conn} do
 271     user = insert(:user)
 272
 273     conn = conn
 274     |> get("/api/v1/accounts/#{user.id}")
 275
 276     assert %{"id" => id} = json_response(conn, 200)
 277     assert id == to_string(user.id)
 278
 279     conn = build_conn()
 280     |> get("/api/v1/accounts/-1")
 281
 282     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 283   end
 284
 285   test "media upload", %{conn: conn} do
 286     file = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 287
 288     user = insert(:user)
 289
 290     conn = conn
 291     |> assign(:user, user)
 292     |> post("/api/v1/media", %{"file" => file})
 293
 294     assert media = json_response(conn, 200)
 295
 296     assert media["type"] == "image"
 297   end
 298
 299   test "hashtag timeline", %{conn: conn} do
 300     following = insert(:user)
 301
 302     {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 303     {:ok, [_activity]} = OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 304
 305     conn = conn
 306     |> get("/api/v1/timelines/tag/2hu")
 307
 308     assert [%{"id" => id}] = json_response(conn, 200)
 309
 310     assert id == to_string(activity.id)
 311   end
 312
 313   test "getting followers", %{conn: conn} do
 314     user = insert(:user)
 315     other_user = insert(:user)
 316     {:ok, user} = User.follow(user, other_user)
 317
 318     conn = conn
 319     |> get("/api/v1/accounts/#{other_user.id}/followers")
 320
 321     assert [%{"id" => id}] = json_response(conn, 200)
 322     assert id == to_string(user.id)
 323   end
 324
 325   test "getting following", %{conn: conn} do
 326     user = insert(:user)
 327     other_user = insert(:user)
 328     {:ok, user} = User.follow(user, other_user)
 329
 330     conn = conn
 331     |> get("/api/v1/accounts/#{user.id}/following")
 332
 333     assert [%{"id" => id}] = json_response(conn, 200)
 334     assert id == to_string(other_user.id)
 335   end
 336
 337   test "following / unfollowing a user", %{conn: conn} do
 338     user = insert(:user)
 339     other_user = insert(:user)
 340
 341     conn = conn
 342     |> assign(:user, user)
 343     |> post("/api/v1/accounts/#{other_user.id}/follow")
 344
 345     assert %{"id" => id, "following" => true} = json_response(conn, 200)
 346
 347     user = Repo.get(User, user.id)
 348     conn = build_conn()
 349     |> assign(:user, user)
 350     |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 351
 352     assert %{"id" => id, "following" => false} = json_response(conn, 200)
 353
 354     user = Repo.get(User, user.id)
 355     conn = build_conn()
 356     |> assign(:user, user)
 357     |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 358
 359     assert %{"id" => id} = json_response(conn, 200)
 360     assert id == to_string(other_user.id)
 361   end
 362
 363   test "blocking / unblocking a user", %{conn: conn} do
 364     user = insert(:user)
 365     other_user = insert(:user)
 366
 367     conn = conn
 368     |> assign(:user, user)
 369     |> post("/api/v1/accounts/#{other_user.id}/block")
 370
 371     assert %{"id" => id, "blocking" => true} = json_response(conn, 200)
 372
 373     user = Repo.get(User, user.id)
 374     conn = build_conn()
 375     |> assign(:user, user)
 376     |> post("/api/v1/accounts/#{other_user.id}/unblock")
 377
 378     assert %{"id" => id, "blocking" => false} = json_response(conn, 200)
 379   end
 380
 381   test "getting a list of blocks", %{conn: conn} do
 382     user = insert(:user)
 383     other_user = insert(:user)
 384
 385     {:ok, user} = User.block(user, other_user)
 386
 387     conn = conn
 388     |> assign(:user, user)
 389     |> get("/api/v1/blocks")
 390
 391     other_user_id = to_string(other_user.id)
 392     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
 393   end
 394
 395   test "unimplemented mute endpoints" do
 396     user = insert(:user)
 397     other_user = insert(:user)
 398
 399     ["mute", "unmute"]
 400     |> Enum.each(fn(endpoint) ->
 401       conn = build_conn()
 402       |> assign(:user, user)
 403       |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
 404
 405       assert %{"id" => id} = json_response(conn, 200)
 406       assert id == to_string(other_user.id)
 407     end)
 408   end
 409
 410   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
 411     user = insert(:user)
 412
 413     ["blocks", "domain_blocks", "mutes", "follow_requests"]
 414     |> Enum.each(fn(endpoint) ->
 415       conn = build_conn()
 416       |> assign(:user, user)
 417       |> get("/api/v1/#{endpoint}")
 418
 419       assert [] = json_response(conn, 200)
 420     end)
 421   end
 422
 423   test "account search", %{conn: conn} do
 424     user = insert(:user)
 425     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 426     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 427
 428     conn = conn
 429     |> assign(:user, user)
 430     |> get("/api/v1/accounts/search", %{"q" => "2hu"})
 431
 432     assert [account] = json_response(conn, 200)
 433     assert account["id"] == to_string(user_three.id)
 434   end
 435
 436   test "search", %{conn: conn} do
 437     user = insert(:user)
 438     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 439     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 440
 441     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 442     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 443
 444     conn = conn
 445     |> get("/api/v1/search", %{"q" => "2hu"})
 446
 447     assert results = json_response(conn, 200)
 448
 449     [account] = results["accounts"]
 450     assert account["id"] == to_string(user_three.id)
 451
 452     assert results["hashtags"] == []
 453
 454     [status] = results["statuses"]
 455     assert status["id"] == to_string(activity.id)
 456   end
 457
 458   test "search fetches remote statuses", %{conn: conn} do
 459     conn = conn
 460     |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 461     assert results = json_response(conn, 200)
 462
 463     [status] = results["statuses"]
 464     assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 465   end
 466
 467   test "search fetches remote accounts", %{conn: conn} do
 468     conn = conn
 469     |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
 470
 471     assert results = json_response(conn, 200)
 472     [account] = results["accounts"]
 473     assert account["acct"] == "shp@social.heldscal.la"
 474   end
 475
 476   test "returns the favorites of a user", %{conn: conn} do
 477     user = insert(:user)
 478     other_user = insert(:user)
 479
 480     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
 481     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
 482
 483     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 484
 485     conn = conn
 486     |> assign(:user, user)
 487     |> get("/api/v1/favourites")
 488
 489     assert [status] = json_response(conn, 200)
 490     assert status["id"] == to_string(activity.id)
 491   end
 492
 493   describe "updating credentials" do
 494     test "updates the user's bio" do
 495       user = insert(:user)
 496
 497       conn = conn
 498       |> assign(:user, user)
 499       |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
 500
 501       assert user = json_response(conn, 200)
 502       assert user["note"] == "I drink #cofe"
 503     end
 504
 505     test "updates the user's name" do
 506       user = insert(:user)
 507
 508       conn = conn
 509       |> assign(:user, user)
 510       |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 511
 512       assert user = json_response(conn, 200)
 513       assert user["display_name"] == "markorepairs"
 514     end
 515
 516     test "updates the user's avatar" do
 517       user = insert(:user)
 518
 519       new_avatar = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 520
 521       conn = conn
 522       |> assign(:user, user)
 523       |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 524
 525       assert user = json_response(conn, 200)
 526       assert user["avatar"] != "https://placehold.it/48x48"
 527     end
 528
 529     test "updates the user's banner" do
 530       user = insert(:user)
 531
 532       new_header = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 533
 534       conn = conn
 535       |> assign(:user, user)
 536       |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 537
 538       assert user = json_response(conn, 200)
 539       assert user["header"] != "https://placehold.it/700x335"
 540     end
 541   end
 542 end