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