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