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
 253     test "gets an users media", %{conn: conn} do
 254       note = insert(:note_activity)
 255       user = User.get_by_ap_id(note.data["actor"])
 256
 257       file = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 258       media = TwitterAPI.upload(file, "json")
 259       |> Poison.decode!
 260
 261       {:ok, image_post} = TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 262
 263       conn = conn
 264       |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 265
 266       assert [%{"id" => id}] = json_response(conn, 200)
 267       assert id == to_string(image_post.id)
 268
 269       conn = build_conn()
 270       |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 271
 272       assert [%{"id" => id}] = json_response(conn, 200)
 273       assert id == to_string(image_post.id)
 274     end
 275   end
 276
 277   describe "user relationships" do
 278     test "returns the relationships for the current user", %{conn: conn} do
 279       user = insert(:user)
 280       other_user = insert(:user)
 281       {:ok, user} = User.follow(user, other_user)
 282
 283       conn = conn
 284       |> assign(:user, user)
 285       |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 286
 287       assert [relationship] = json_response(conn, 200)
 288
 289       assert to_string(other_user.id) == relationship["id"]
 290     end
 291   end
 292
 293   test "account fetching", %{conn: conn} do
 294     user = insert(:user)
 295
 296     conn = conn
 297     |> get("/api/v1/accounts/#{user.id}")
 298
 299     assert %{"id" => id} = json_response(conn, 200)
 300     assert id == to_string(user.id)
 301
 302     conn = build_conn()
 303     |> get("/api/v1/accounts/-1")
 304
 305     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 306   end
 307
 308   test "media upload", %{conn: conn} do
 309     file = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 310
 311     user = insert(:user)
 312
 313     conn = conn
 314     |> assign(:user, user)
 315     |> post("/api/v1/media", %{"file" => file})
 316
 317     assert media = json_response(conn, 200)
 318
 319     assert media["type"] == "image"
 320   end
 321
 322   test "hashtag timeline", %{conn: conn} do
 323     following = insert(:user)
 324
 325     {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 326     {:ok, [_activity]} = OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 327
 328     conn = conn
 329     |> get("/api/v1/timelines/tag/2hu")
 330
 331     assert [%{"id" => id}] = json_response(conn, 200)
 332
 333     assert id == to_string(activity.id)
 334   end
 335
 336   test "getting followers", %{conn: conn} do
 337     user = insert(:user)
 338     other_user = insert(:user)
 339     {:ok, user} = User.follow(user, other_user)
 340
 341     conn = conn
 342     |> get("/api/v1/accounts/#{other_user.id}/followers")
 343
 344     assert [%{"id" => id}] = json_response(conn, 200)
 345     assert id == to_string(user.id)
 346   end
 347
 348   test "getting following", %{conn: conn} do
 349     user = insert(:user)
 350     other_user = insert(:user)
 351     {:ok, user} = User.follow(user, other_user)
 352
 353     conn = conn
 354     |> get("/api/v1/accounts/#{user.id}/following")
 355
 356     assert [%{"id" => id}] = json_response(conn, 200)
 357     assert id == to_string(other_user.id)
 358   end
 359
 360   test "following / unfollowing a user", %{conn: conn} do
 361     user = insert(:user)
 362     other_user = insert(:user)
 363
 364     conn = conn
 365     |> assign(:user, user)
 366     |> post("/api/v1/accounts/#{other_user.id}/follow")
 367
 368     assert %{"id" => id, "following" => true} = json_response(conn, 200)
 369
 370     user = Repo.get(User, user.id)
 371     conn = build_conn()
 372     |> assign(:user, user)
 373     |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 374
 375     assert %{"id" => id, "following" => false} = json_response(conn, 200)
 376
 377     user = Repo.get(User, user.id)
 378     conn = build_conn()
 379     |> assign(:user, user)
 380     |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 381
 382     assert %{"id" => id} = json_response(conn, 200)
 383     assert id == to_string(other_user.id)
 384   end
 385
 386   test "blocking / unblocking a user", %{conn: conn} do
 387     user = insert(:user)
 388     other_user = insert(:user)
 389
 390     conn = conn
 391     |> assign(:user, user)
 392     |> post("/api/v1/accounts/#{other_user.id}/block")
 393
 394     assert %{"id" => id, "blocking" => true} = json_response(conn, 200)
 395
 396     user = Repo.get(User, user.id)
 397     conn = build_conn()
 398     |> assign(:user, user)
 399     |> post("/api/v1/accounts/#{other_user.id}/unblock")
 400
 401     assert %{"id" => id, "blocking" => false} = json_response(conn, 200)
 402   end
 403
 404   test "getting a list of blocks", %{conn: conn} do
 405     user = insert(:user)
 406     other_user = insert(:user)
 407
 408     {:ok, user} = User.block(user, other_user)
 409
 410     conn = conn
 411     |> assign(:user, user)
 412     |> get("/api/v1/blocks")
 413
 414     other_user_id = to_string(other_user.id)
 415     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
 416   end
 417
 418   test "unimplemented mute endpoints" do
 419     user = insert(:user)
 420     other_user = insert(:user)
 421
 422     ["mute", "unmute"]
 423     |> Enum.each(fn(endpoint) ->
 424       conn = build_conn()
 425       |> assign(:user, user)
 426       |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
 427
 428       assert %{"id" => id} = json_response(conn, 200)
 429       assert id == to_string(other_user.id)
 430     end)
 431   end
 432
 433   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
 434     user = insert(:user)
 435
 436     ["blocks", "domain_blocks", "mutes", "follow_requests"]
 437     |> Enum.each(fn(endpoint) ->
 438       conn = build_conn()
 439       |> assign(:user, user)
 440       |> get("/api/v1/#{endpoint}")
 441
 442       assert [] = json_response(conn, 200)
 443     end)
 444   end
 445
 446   test "account search", %{conn: conn} do
 447     user = insert(:user)
 448     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 449     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 450
 451     conn = conn
 452     |> assign(:user, user)
 453     |> get("/api/v1/accounts/search", %{"q" => "2hu"})
 454
 455     assert [account] = json_response(conn, 200)
 456     assert account["id"] == to_string(user_three.id)
 457   end
 458
 459   test "search", %{conn: conn} do
 460     user = insert(:user)
 461     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 462     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 463
 464     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 465     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 466
 467     conn = conn
 468     |> get("/api/v1/search", %{"q" => "2hu"})
 469
 470     assert results = json_response(conn, 200)
 471
 472     [account] = results["accounts"]
 473     assert account["id"] == to_string(user_three.id)
 474
 475     assert results["hashtags"] == []
 476
 477     [status] = results["statuses"]
 478     assert status["id"] == to_string(activity.id)
 479   end
 480
 481   test "search fetches remote statuses", %{conn: conn} do
 482     conn = conn
 483     |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 484     assert results = json_response(conn, 200)
 485
 486     [status] = results["statuses"]
 487     assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 488   end
 489
 490   test "search fetches remote accounts", %{conn: conn} do
 491     conn = conn
 492     |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
 493
 494     assert results = json_response(conn, 200)
 495     [account] = results["accounts"]
 496     assert account["acct"] == "shp@social.heldscal.la"
 497   end
 498
 499   test "returns the favorites of a user", %{conn: conn} do
 500     user = insert(:user)
 501     other_user = insert(:user)
 502
 503     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
 504     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
 505
 506     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 507
 508     conn = conn
 509     |> assign(:user, user)
 510     |> get("/api/v1/favourites")
 511
 512     assert [status] = json_response(conn, 200)
 513     assert status["id"] == to_string(activity.id)
 514   end
 515
 516   describe "updating credentials" do
 517     test "updates the user's bio" do
 518       user = insert(:user)
 519
 520       conn = conn
 521       |> assign(:user, user)
 522       |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
 523
 524       assert user = json_response(conn, 200)
 525       assert user["note"] == "I drink #cofe"
 526     end
 527
 528     test "updates the user's name" do
 529       user = insert(:user)
 530
 531       conn = conn
 532       |> assign(:user, user)
 533       |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 534
 535       assert user = json_response(conn, 200)
 536       assert user["display_name"] == "markorepairs"
 537     end
 538
 539     test "updates the user's avatar" do
 540       user = insert(:user)
 541
 542       new_avatar = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 543
 544       conn = conn
 545       |> assign(:user, user)
 546       |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 547
 548       assert user = json_response(conn, 200)
 549       assert user["avatar"] != "https://placehold.it/48x48"
 550     end
 551
 552     test "updates the user's banner" do
 553       user = insert(:user)
 554
 555       new_header = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 556
 557       conn = conn
 558       |> assign(:user, user)
 559       |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 560
 561       assert user = json_response(conn, 200)
 562       assert user["header"] != "https://placehold.it/700x335"
 563     end
 564   end
 565 end