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