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   alias Pleroma.Web.ActivityPub.ActivityPub
   8
   9   import Pleroma.Factory
  10   import ExUnit.CaptureLog
  11   import Tesla.Mock
  12
  13   setup do
  14     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  15     :ok
  16   end
  17
  18   test "the home timeline", %{conn: conn} do
  19     user = insert(:user)
  20     following = insert(:user)
  21
  22     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  23
  24     conn =
  25       conn
  26       |> assign(:user, user)
  27       |> get("/api/v1/timelines/home")
  28
  29     assert length(json_response(conn, 200)) == 0
  30
  31     {:ok, user} = User.follow(user, following)
  32
  33     conn =
  34       build_conn()
  35       |> assign(:user, user)
  36       |> get("/api/v1/timelines/home")
  37
  38     assert [%{"content" => "test"}] = json_response(conn, 200)
  39   end
  40
  41   test "the public timeline", %{conn: conn} do
  42     following = insert(:user)
  43
  44     capture_log(fn ->
  45       {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  46
  47       {:ok, [_activity]} =
  48         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  49
  50       conn =
  51         conn
  52         |> get("/api/v1/timelines/public", %{"local" => "False"})
  53
  54       assert length(json_response(conn, 200)) == 2
  55
  56       conn =
  57         build_conn()
  58         |> get("/api/v1/timelines/public", %{"local" => "True"})
  59
  60       assert [%{"content" => "test"}] = json_response(conn, 200)
  61
  62       conn =
  63         build_conn()
  64         |> get("/api/v1/timelines/public", %{"local" => "1"})
  65
  66       assert [%{"content" => "test"}] = json_response(conn, 200)
  67     end)
  68   end
  69
  70   test "posting a status", %{conn: conn} do
  71     user = insert(:user)
  72
  73     idempotency_key = "Pikachu rocks!"
  74
  75     conn_one =
  76       conn
  77       |> assign(:user, user)
  78       |> put_req_header("idempotency-key", idempotency_key)
  79       |> post("/api/v1/statuses", %{
  80         "status" => "cofe",
  81         "spoiler_text" => "2hu",
  82         "sensitive" => "false"
  83       })
  84
  85     {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  86     # Six hours
  87     assert ttl > :timer.seconds(6 * 60 * 60 - 1)
  88
  89     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
  90              json_response(conn_one, 200)
  91
  92     assert Repo.get(Activity, id)
  93
  94     conn_two =
  95       conn
  96       |> assign(:user, user)
  97       |> put_req_header("idempotency-key", idempotency_key)
  98       |> post("/api/v1/statuses", %{
  99         "status" => "cofe",
 100         "spoiler_text" => "2hu",
 101         "sensitive" => "false"
 102       })
 103
 104     assert %{"id" => second_id} = json_response(conn_two, 200)
 105
 106     assert id == second_id
 107
 108     conn_three =
 109       conn
 110       |> assign(:user, user)
 111       |> post("/api/v1/statuses", %{
 112         "status" => "cofe",
 113         "spoiler_text" => "2hu",
 114         "sensitive" => "false"
 115       })
 116
 117     assert %{"id" => third_id} = json_response(conn_three, 200)
 118
 119     refute id == third_id
 120   end
 121
 122   test "posting a sensitive status", %{conn: conn} do
 123     user = insert(:user)
 124
 125     conn =
 126       conn
 127       |> assign(:user, user)
 128       |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 129
 130     assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 131     assert Repo.get(Activity, id)
 132   end
 133
 134   test "posting a direct status", %{conn: conn} do
 135     user1 = insert(:user)
 136     user2 = insert(:user)
 137     content = "direct cofe @#{user2.nickname}"
 138
 139     conn =
 140       conn
 141       |> assign(:user, user1)
 142       |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 143
 144     assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
 145     assert activity = Repo.get(Activity, id)
 146     assert activity.recipients == [user2.ap_id]
 147     assert activity.data["to"] == [user2.ap_id]
 148     assert activity.data["cc"] == []
 149   end
 150
 151   test "direct timeline", %{conn: conn} do
 152     user_one = insert(:user)
 153     user_two = insert(:user)
 154
 155     {:ok, user_two} = User.follow(user_two, user_one)
 156
 157     {:ok, direct} =
 158       CommonAPI.post(user_one, %{
 159         "status" => "Hi @#{user_two.nickname}!",
 160         "visibility" => "direct"
 161       })
 162
 163     {:ok, _follower_only} =
 164       CommonAPI.post(user_one, %{
 165         "status" => "Hi @#{user_two.nickname}!",
 166         "visibility" => "private"
 167       })
 168
 169     # Only direct should be visible here
 170     res_conn =
 171       conn
 172       |> assign(:user, user_two)
 173       |> get("api/v1/timelines/direct")
 174
 175     [status] = json_response(res_conn, 200)
 176
 177     assert %{"visibility" => "direct"} = status
 178     assert status["url"] != direct.data["id"]
 179
 180     # Both should be visible here
 181     res_conn =
 182       conn
 183       |> assign(:user, user_two)
 184       |> get("api/v1/timelines/home")
 185
 186     [_s1, _s2] = json_response(res_conn, 200)
 187
 188     # Test pagination
 189     Enum.each(1..20, fn _ ->
 190       {:ok, _} =
 191         CommonAPI.post(user_one, %{
 192           "status" => "Hi @#{user_two.nickname}!",
 193           "visibility" => "direct"
 194         })
 195     end)
 196
 197     res_conn =
 198       conn
 199       |> assign(:user, user_two)
 200       |> get("api/v1/timelines/direct")
 201
 202     statuses = json_response(res_conn, 200)
 203     assert length(statuses) == 20
 204
 205     res_conn =
 206       conn
 207       |> assign(:user, user_two)
 208       |> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
 209
 210     [status] = json_response(res_conn, 200)
 211
 212     assert status["url"] != direct.data["id"]
 213   end
 214
 215   test "replying to a status", %{conn: conn} do
 216     user = insert(:user)
 217
 218     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 219
 220     conn =
 221       conn
 222       |> assign(:user, user)
 223       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 224
 225     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 226
 227     activity = Repo.get(Activity, id)
 228
 229     assert activity.data["context"] == replied_to.data["context"]
 230     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
 231   end
 232
 233   test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
 234     user = insert(:user)
 235
 236     conn =
 237       conn
 238       |> assign(:user, user)
 239       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 240
 241     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 242
 243     activity = Repo.get(Activity, id)
 244
 245     assert activity
 246   end
 247
 248   test "verify_credentials", %{conn: conn} do
 249     user = insert(:user)
 250
 251     conn =
 252       conn
 253       |> assign(:user, user)
 254       |> get("/api/v1/accounts/verify_credentials")
 255
 256     assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
 257     assert id == to_string(user.id)
 258   end
 259
 260   test "verify_credentials default scope unlisted", %{conn: conn} do
 261     user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})
 262
 263     conn =
 264       conn
 265       |> assign(:user, user)
 266       |> get("/api/v1/accounts/verify_credentials")
 267
 268     assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
 269     assert id == to_string(user.id)
 270   end
 271
 272   test "get a status", %{conn: conn} do
 273     activity = insert(:note_activity)
 274
 275     conn =
 276       conn
 277       |> get("/api/v1/statuses/#{activity.id}")
 278
 279     assert %{"id" => id} = json_response(conn, 200)
 280     assert id == to_string(activity.id)
 281   end
 282
 283   describe "deleting a status" do
 284     test "when you created it", %{conn: conn} do
 285       activity = insert(:note_activity)
 286       author = User.get_by_ap_id(activity.data["actor"])
 287
 288       conn =
 289         conn
 290         |> assign(:user, author)
 291         |> delete("/api/v1/statuses/#{activity.id}")
 292
 293       assert %{} = json_response(conn, 200)
 294
 295       assert Repo.get(Activity, activity.id) == nil
 296     end
 297
 298     test "when you didn't create it", %{conn: conn} do
 299       activity = insert(:note_activity)
 300       user = insert(:user)
 301
 302       conn =
 303         conn
 304         |> assign(:user, user)
 305         |> delete("/api/v1/statuses/#{activity.id}")
 306
 307       assert %{"error" => _} = json_response(conn, 403)
 308
 309       assert Repo.get(Activity, activity.id) == activity
 310     end
 311   end
 312
 313   describe "filters" do
 314     test "creating a filter", %{conn: conn} do
 315       user = insert(:user)
 316
 317       filter = %Pleroma.Filter{
 318         phrase: "knights",
 319         context: ["home"]
 320       }
 321
 322       conn =
 323         conn
 324         |> assign(:user, user)
 325         |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
 326
 327       assert response = json_response(conn, 200)
 328       assert response["phrase"] == filter.phrase
 329       assert response["context"] == filter.context
 330       assert response["id"] != nil
 331       assert response["id"] != ""
 332     end
 333
 334     test "fetching a list of filters", %{conn: conn} do
 335       user = insert(:user)
 336
 337       query_one = %Pleroma.Filter{
 338         user_id: user.id,
 339         filter_id: 1,
 340         phrase: "knights",
 341         context: ["home"]
 342       }
 343
 344       query_two = %Pleroma.Filter{
 345         user_id: user.id,
 346         filter_id: 2,
 347         phrase: "who",
 348         context: ["home"]
 349       }
 350
 351       {:ok, filter_one} = Pleroma.Filter.create(query_one)
 352       {:ok, filter_two} = Pleroma.Filter.create(query_two)
 353
 354       conn =
 355         conn
 356         |> assign(:user, user)
 357         |> get("/api/v1/filters")
 358
 359       assert response = json_response(conn, 200)
 360     end
 361
 362     test "get a filter", %{conn: conn} do
 363       user = insert(:user)
 364
 365       query = %Pleroma.Filter{
 366         user_id: user.id,
 367         filter_id: 2,
 368         phrase: "knight",
 369         context: ["home"]
 370       }
 371
 372       {:ok, filter} = Pleroma.Filter.create(query)
 373
 374       conn =
 375         conn
 376         |> assign(:user, user)
 377         |> get("/api/v1/filters/#{filter.filter_id}")
 378
 379       assert response = json_response(conn, 200)
 380     end
 381
 382     test "update a filter", %{conn: conn} do
 383       user = insert(:user)
 384
 385       query = %Pleroma.Filter{
 386         user_id: user.id,
 387         filter_id: 2,
 388         phrase: "knight",
 389         context: ["home"]
 390       }
 391
 392       {:ok, filter} = Pleroma.Filter.create(query)
 393
 394       new = %Pleroma.Filter{
 395         phrase: "nii",
 396         context: ["home"]
 397       }
 398
 399       conn =
 400         conn
 401         |> assign(:user, user)
 402         |> put("/api/v1/filters/#{query.filter_id}", %{
 403           phrase: new.phrase,
 404           context: new.context
 405         })
 406
 407       assert response = json_response(conn, 200)
 408       assert response["phrase"] == new.phrase
 409       assert response["context"] == new.context
 410     end
 411
 412     test "delete a filter", %{conn: conn} do
 413       user = insert(:user)
 414
 415       query = %Pleroma.Filter{
 416         user_id: user.id,
 417         filter_id: 2,
 418         phrase: "knight",
 419         context: ["home"]
 420       }
 421
 422       {:ok, filter} = Pleroma.Filter.create(query)
 423
 424       conn =
 425         conn
 426         |> assign(:user, user)
 427         |> delete("/api/v1/filters/#{filter.filter_id}")
 428
 429       assert response = json_response(conn, 200)
 430       assert response == %{}
 431     end
 432   end
 433
 434   describe "lists" do
 435     test "creating a list", %{conn: conn} do
 436       user = insert(:user)
 437
 438       conn =
 439         conn
 440         |> assign(:user, user)
 441         |> post("/api/v1/lists", %{"title" => "cuties"})
 442
 443       assert %{"title" => title} = json_response(conn, 200)
 444       assert title == "cuties"
 445     end
 446
 447     test "adding users to a list", %{conn: conn} do
 448       user = insert(:user)
 449       other_user = insert(:user)
 450       {:ok, list} = Pleroma.List.create("name", user)
 451
 452       conn =
 453         conn
 454         |> assign(:user, user)
 455         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 456
 457       assert %{} == json_response(conn, 200)
 458       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 459       assert following == [other_user.follower_address]
 460     end
 461
 462     test "removing users from a list", %{conn: conn} do
 463       user = insert(:user)
 464       other_user = insert(:user)
 465       third_user = insert(:user)
 466       {:ok, list} = Pleroma.List.create("name", user)
 467       {:ok, list} = Pleroma.List.follow(list, other_user)
 468       {:ok, list} = Pleroma.List.follow(list, third_user)
 469
 470       conn =
 471         conn
 472         |> assign(:user, user)
 473         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 474
 475       assert %{} == json_response(conn, 200)
 476       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 477       assert following == [third_user.follower_address]
 478     end
 479
 480     test "listing users in a list", %{conn: conn} do
 481       user = insert(:user)
 482       other_user = insert(:user)
 483       {:ok, list} = Pleroma.List.create("name", user)
 484       {:ok, list} = Pleroma.List.follow(list, other_user)
 485
 486       conn =
 487         conn
 488         |> assign(:user, user)
 489         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 490
 491       assert [%{"id" => id}] = json_response(conn, 200)
 492       assert id == to_string(other_user.id)
 493     end
 494
 495     test "retrieving a list", %{conn: conn} do
 496       user = insert(:user)
 497       {:ok, list} = Pleroma.List.create("name", user)
 498
 499       conn =
 500         conn
 501         |> assign(:user, user)
 502         |> get("/api/v1/lists/#{list.id}")
 503
 504       assert %{"id" => id} = json_response(conn, 200)
 505       assert id == to_string(list.id)
 506     end
 507
 508     test "renaming a list", %{conn: conn} do
 509       user = insert(:user)
 510       {:ok, list} = Pleroma.List.create("name", user)
 511
 512       conn =
 513         conn
 514         |> assign(:user, user)
 515         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 516
 517       assert %{"title" => name} = json_response(conn, 200)
 518       assert name == "newname"
 519     end
 520
 521     test "deleting a list", %{conn: conn} do
 522       user = insert(:user)
 523       {:ok, list} = Pleroma.List.create("name", user)
 524
 525       conn =
 526         conn
 527         |> assign(:user, user)
 528         |> delete("/api/v1/lists/#{list.id}")
 529
 530       assert %{} = json_response(conn, 200)
 531       assert is_nil(Repo.get(Pleroma.List, list.id))
 532     end
 533
 534     test "list timeline", %{conn: conn} do
 535       user = insert(:user)
 536       other_user = insert(:user)
 537       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 538       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 539       {:ok, list} = Pleroma.List.create("name", user)
 540       {:ok, list} = Pleroma.List.follow(list, other_user)
 541
 542       conn =
 543         conn
 544         |> assign(:user, user)
 545         |> get("/api/v1/timelines/list/#{list.id}")
 546
 547       assert [%{"id" => id}] = json_response(conn, 200)
 548
 549       assert id == to_string(activity_two.id)
 550     end
 551
 552     test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
 553       user = insert(:user)
 554       other_user = insert(:user)
 555       {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 556
 557       {:ok, activity_two} =
 558         TwitterAPI.create_status(other_user, %{
 559           "status" => "Marisa is cute.",
 560           "visibility" => "private"
 561         })
 562
 563       {:ok, list} = Pleroma.List.create("name", user)
 564       {:ok, list} = Pleroma.List.follow(list, other_user)
 565
 566       conn =
 567         conn
 568         |> assign(:user, user)
 569         |> get("/api/v1/timelines/list/#{list.id}")
 570
 571       assert [%{"id" => id}] = json_response(conn, 200)
 572
 573       assert id == to_string(activity_one.id)
 574     end
 575   end
 576
 577   describe "notifications" do
 578     test "list of notifications", %{conn: conn} do
 579       user = insert(:user)
 580       other_user = insert(:user)
 581
 582       {:ok, activity} =
 583         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 584
 585       {:ok, [_notification]} = Notification.create_notifications(activity)
 586
 587       conn =
 588         conn
 589         |> assign(:user, user)
 590         |> get("/api/v1/notifications")
 591
 592       expected_response =
 593         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 594
 595       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 596       assert response == expected_response
 597     end
 598
 599     test "getting a single notification", %{conn: conn} do
 600       user = insert(:user)
 601       other_user = insert(:user)
 602
 603       {:ok, activity} =
 604         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 605
 606       {:ok, [notification]} = Notification.create_notifications(activity)
 607
 608       conn =
 609         conn
 610         |> assign(:user, user)
 611         |> get("/api/v1/notifications/#{notification.id}")
 612
 613       expected_response =
 614         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 615
 616       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 617       assert response == expected_response
 618     end
 619
 620     test "dismissing a single notification", %{conn: conn} do
 621       user = insert(:user)
 622       other_user = insert(:user)
 623
 624       {:ok, activity} =
 625         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 626
 627       {:ok, [notification]} = Notification.create_notifications(activity)
 628
 629       conn =
 630         conn
 631         |> assign(:user, user)
 632         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 633
 634       assert %{} = json_response(conn, 200)
 635     end
 636
 637     test "clearing all notifications", %{conn: conn} do
 638       user = insert(:user)
 639       other_user = insert(:user)
 640
 641       {:ok, activity} =
 642         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 643
 644       {:ok, [_notification]} = Notification.create_notifications(activity)
 645
 646       conn =
 647         conn
 648         |> assign(:user, user)
 649         |> post("/api/v1/notifications/clear")
 650
 651       assert %{} = json_response(conn, 200)
 652
 653       conn =
 654         build_conn()
 655         |> assign(:user, user)
 656         |> get("/api/v1/notifications")
 657
 658       assert all = json_response(conn, 200)
 659       assert all == []
 660     end
 661   end
 662
 663   describe "reblogging" do
 664     test "reblogs and returns the reblogged status", %{conn: conn} do
 665       activity = insert(:note_activity)
 666       user = insert(:user)
 667
 668       conn =
 669         conn
 670         |> assign(:user, user)
 671         |> post("/api/v1/statuses/#{activity.id}/reblog")
 672
 673       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 674                json_response(conn, 200)
 675
 676       assert to_string(activity.id) == id
 677     end
 678   end
 679
 680   describe "unreblogging" do
 681     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 682       activity = insert(:note_activity)
 683       user = insert(:user)
 684
 685       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 686
 687       conn =
 688         conn
 689         |> assign(:user, user)
 690         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 691
 692       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 693
 694       assert to_string(activity.id) == id
 695     end
 696   end
 697
 698   describe "favoriting" do
 699     test "favs a status and returns it", %{conn: conn} do
 700       activity = insert(:note_activity)
 701       user = insert(:user)
 702
 703       conn =
 704         conn
 705         |> assign(:user, user)
 706         |> post("/api/v1/statuses/#{activity.id}/favourite")
 707
 708       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 709                json_response(conn, 200)
 710
 711       assert to_string(activity.id) == id
 712     end
 713
 714     test "returns 500 for a wrong id", %{conn: conn} do
 715       user = insert(:user)
 716
 717       resp =
 718         conn
 719         |> assign(:user, user)
 720         |> post("/api/v1/statuses/1/favourite")
 721         |> json_response(500)
 722
 723       assert resp == "Something went wrong"
 724     end
 725   end
 726
 727   describe "unfavoriting" do
 728     test "unfavorites a status and returns it", %{conn: conn} do
 729       activity = insert(:note_activity)
 730       user = insert(:user)
 731
 732       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 733
 734       conn =
 735         conn
 736         |> assign(:user, user)
 737         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 738
 739       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 740                json_response(conn, 200)
 741
 742       assert to_string(activity.id) == id
 743     end
 744   end
 745
 746   describe "user timelines" do
 747     test "gets a users statuses", %{conn: conn} do
 748       user_one = insert(:user)
 749       user_two = insert(:user)
 750       user_three = insert(:user)
 751
 752       {:ok, user_three} = User.follow(user_three, user_one)
 753
 754       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 755
 756       {:ok, direct_activity} =
 757         CommonAPI.post(user_one, %{
 758           "status" => "Hi, @#{user_two.nickname}.",
 759           "visibility" => "direct"
 760         })
 761
 762       {:ok, private_activity} =
 763         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 764
 765       resp =
 766         conn
 767         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 768
 769       assert [%{"id" => id}] = json_response(resp, 200)
 770       assert id == to_string(activity.id)
 771
 772       resp =
 773         conn
 774         |> assign(:user, user_two)
 775         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 776
 777       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 778       assert id_one == to_string(direct_activity.id)
 779       assert id_two == to_string(activity.id)
 780
 781       resp =
 782         conn
 783         |> assign(:user, user_three)
 784         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 785
 786       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 787       assert id_one == to_string(private_activity.id)
 788       assert id_two == to_string(activity.id)
 789     end
 790
 791     test "unimplemented pinned statuses feature", %{conn: conn} do
 792       note = insert(:note_activity)
 793       user = User.get_by_ap_id(note.data["actor"])
 794
 795       conn =
 796         conn
 797         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 798
 799       assert json_response(conn, 200) == []
 800     end
 801
 802     test "gets an users media", %{conn: conn} do
 803       note = insert(:note_activity)
 804       user = User.get_by_ap_id(note.data["actor"])
 805
 806       file = %Plug.Upload{
 807         content_type: "image/jpg",
 808         path: Path.absname("test/fixtures/image.jpg"),
 809         filename: "an_image.jpg"
 810       }
 811
 812       media =
 813         TwitterAPI.upload(file, "json")
 814         |> Poison.decode!()
 815
 816       {:ok, image_post} =
 817         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 818
 819       conn =
 820         conn
 821         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 822
 823       assert [%{"id" => id}] = json_response(conn, 200)
 824       assert id == to_string(image_post.id)
 825
 826       conn =
 827         build_conn()
 828         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 829
 830       assert [%{"id" => id}] = json_response(conn, 200)
 831       assert id == to_string(image_post.id)
 832     end
 833   end
 834
 835   describe "user relationships" do
 836     test "returns the relationships for the current user", %{conn: conn} do
 837       user = insert(:user)
 838       other_user = insert(:user)
 839       {:ok, user} = User.follow(user, other_user)
 840
 841       conn =
 842         conn
 843         |> assign(:user, user)
 844         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 845
 846       assert [relationship] = json_response(conn, 200)
 847
 848       assert to_string(other_user.id) == relationship["id"]
 849     end
 850   end
 851
 852   describe "locked accounts" do
 853     test "/api/v1/follow_requests works" do
 854       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 855       other_user = insert(:user)
 856
 857       {:ok, activity} = ActivityPub.follow(other_user, user)
 858
 859       user = Repo.get(User, user.id)
 860       other_user = Repo.get(User, other_user.id)
 861
 862       assert User.following?(other_user, user) == false
 863
 864       conn =
 865         build_conn()
 866         |> assign(:user, user)
 867         |> get("/api/v1/follow_requests")
 868
 869       assert [relationship] = json_response(conn, 200)
 870       assert to_string(other_user.id) == relationship["id"]
 871     end
 872
 873     test "/api/v1/follow_requests/:id/authorize works" do
 874       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 875       other_user = insert(:user)
 876
 877       {:ok, activity} = ActivityPub.follow(other_user, user)
 878
 879       user = Repo.get(User, user.id)
 880       other_user = Repo.get(User, other_user.id)
 881
 882       assert User.following?(other_user, user) == false
 883
 884       conn =
 885         build_conn()
 886         |> assign(:user, user)
 887         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 888
 889       assert relationship = json_response(conn, 200)
 890       assert to_string(other_user.id) == relationship["id"]
 891
 892       user = Repo.get(User, user.id)
 893       other_user = Repo.get(User, other_user.id)
 894
 895       assert User.following?(other_user, user) == true
 896     end
 897
 898     test "verify_credentials", %{conn: conn} do
 899       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
 900
 901       conn =
 902         conn
 903         |> assign(:user, user)
 904         |> get("/api/v1/accounts/verify_credentials")
 905
 906       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 907       assert id == to_string(user.id)
 908     end
 909
 910     test "/api/v1/follow_requests/:id/reject works" do
 911       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 912       other_user = insert(:user)
 913
 914       {:ok, activity} = ActivityPub.follow(other_user, user)
 915
 916       conn =
 917         build_conn()
 918         |> assign(:user, user)
 919         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 920
 921       assert relationship = json_response(conn, 200)
 922       assert to_string(other_user.id) == relationship["id"]
 923
 924       user = Repo.get(User, user.id)
 925       other_user = Repo.get(User, other_user.id)
 926
 927       assert User.following?(other_user, user) == false
 928     end
 929   end
 930
 931   test "account fetching", %{conn: conn} do
 932     user = insert(:user)
 933
 934     conn =
 935       conn
 936       |> get("/api/v1/accounts/#{user.id}")
 937
 938     assert %{"id" => id} = json_response(conn, 200)
 939     assert id == to_string(user.id)
 940
 941     conn =
 942       build_conn()
 943       |> get("/api/v1/accounts/-1")
 944
 945     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 946   end
 947
 948   test "media upload", %{conn: conn} do
 949     file = %Plug.Upload{
 950       content_type: "image/jpg",
 951       path: Path.absname("test/fixtures/image.jpg"),
 952       filename: "an_image.jpg"
 953     }
 954
 955     desc = "Description of the image"
 956
 957     user = insert(:user)
 958
 959     conn =
 960       conn
 961       |> assign(:user, user)
 962       |> post("/api/v1/media", %{"file" => file, "description" => desc})
 963
 964     assert media = json_response(conn, 200)
 965
 966     assert media["type"] == "image"
 967     assert media["description"] == desc
 968   end
 969
 970   test "hashtag timeline", %{conn: conn} do
 971     following = insert(:user)
 972
 973     capture_log(fn ->
 974       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 975
 976       {:ok, [_activity]} =
 977         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 978
 979       nconn =
 980         conn
 981         |> get("/api/v1/timelines/tag/2hu")
 982
 983       assert [%{"id" => id}] = json_response(nconn, 200)
 984
 985       assert id == to_string(activity.id)
 986
 987       # works for different capitalization too
 988       nconn =
 989         conn
 990         |> get("/api/v1/timelines/tag/2HU")
 991
 992       assert [%{"id" => id}] = json_response(nconn, 200)
 993
 994       assert id == to_string(activity.id)
 995     end)
 996   end
 997
 998   test "getting followers", %{conn: conn} do
 999     user = insert(:user)
1000     other_user = insert(:user)
1001     {:ok, user} = User.follow(user, other_user)
1002
1003     conn =
1004       conn
1005       |> get("/api/v1/accounts/#{other_user.id}/followers")
1006
1007     assert [%{"id" => id}] = json_response(conn, 200)
1008     assert id == to_string(user.id)
1009   end
1010
1011   test "getting following", %{conn: conn} do
1012     user = insert(:user)
1013     other_user = insert(:user)
1014     {:ok, user} = User.follow(user, other_user)
1015
1016     conn =
1017       conn
1018       |> get("/api/v1/accounts/#{user.id}/following")
1019
1020     assert [%{"id" => id}] = json_response(conn, 200)
1021     assert id == to_string(other_user.id)
1022   end
1023
1024   test "following / unfollowing a user", %{conn: conn} do
1025     user = insert(:user)
1026     other_user = insert(:user)
1027
1028     conn =
1029       conn
1030       |> assign(:user, user)
1031       |> post("/api/v1/accounts/#{other_user.id}/follow")
1032
1033     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1034
1035     user = Repo.get(User, user.id)
1036
1037     conn =
1038       build_conn()
1039       |> assign(:user, user)
1040       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1041
1042     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1043
1044     user = Repo.get(User, user.id)
1045
1046     conn =
1047       build_conn()
1048       |> assign(:user, user)
1049       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1050
1051     assert %{"id" => id} = json_response(conn, 200)
1052     assert id == to_string(other_user.id)
1053   end
1054
1055   test "blocking / unblocking a user", %{conn: conn} do
1056     user = insert(:user)
1057     other_user = insert(:user)
1058
1059     conn =
1060       conn
1061       |> assign(:user, user)
1062       |> post("/api/v1/accounts/#{other_user.id}/block")
1063
1064     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1065
1066     user = Repo.get(User, user.id)
1067
1068     conn =
1069       build_conn()
1070       |> assign(:user, user)
1071       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1072
1073     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1074   end
1075
1076   test "getting a list of blocks", %{conn: conn} do
1077     user = insert(:user)
1078     other_user = insert(:user)
1079
1080     {:ok, user} = User.block(user, other_user)
1081
1082     conn =
1083       conn
1084       |> assign(:user, user)
1085       |> get("/api/v1/blocks")
1086
1087     other_user_id = to_string(other_user.id)
1088     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1089   end
1090
1091   test "blocking / unblocking a domain", %{conn: conn} do
1092     user = insert(:user)
1093     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1094
1095     conn =
1096       conn
1097       |> assign(:user, user)
1098       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1099
1100     assert %{} = json_response(conn, 200)
1101     user = User.get_cached_by_ap_id(user.ap_id)
1102     assert User.blocks?(user, other_user)
1103
1104     conn =
1105       build_conn()
1106       |> assign(:user, user)
1107       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1108
1109     assert %{} = json_response(conn, 200)
1110     user = User.get_cached_by_ap_id(user.ap_id)
1111     refute User.blocks?(user, other_user)
1112   end
1113
1114   test "getting a list of domain blocks", %{conn: conn} do
1115     user = insert(:user)
1116
1117     {:ok, user} = User.block_domain(user, "bad.site")
1118     {:ok, user} = User.block_domain(user, "even.worse.site")
1119
1120     conn =
1121       conn
1122       |> assign(:user, user)
1123       |> get("/api/v1/domain_blocks")
1124
1125     domain_blocks = json_response(conn, 200)
1126
1127     assert "bad.site" in domain_blocks
1128     assert "even.worse.site" in domain_blocks
1129   end
1130
1131   test "unimplemented mute endpoints" do
1132     user = insert(:user)
1133     other_user = insert(:user)
1134
1135     ["mute", "unmute"]
1136     |> Enum.each(fn endpoint ->
1137       conn =
1138         build_conn()
1139         |> assign(:user, user)
1140         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1141
1142       assert %{"id" => id} = json_response(conn, 200)
1143       assert id == to_string(other_user.id)
1144     end)
1145   end
1146
1147   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1148     user = insert(:user)
1149
1150     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1151     |> Enum.each(fn endpoint ->
1152       conn =
1153         build_conn()
1154         |> assign(:user, user)
1155         |> get("/api/v1/#{endpoint}")
1156
1157       assert [] = json_response(conn, 200)
1158     end)
1159   end
1160
1161   test "account search", %{conn: conn} do
1162     user = insert(:user)
1163     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1164     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1165
1166     results =
1167       conn
1168       |> assign(:user, user)
1169       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1170       |> json_response(200)
1171
1172     result_ids = for result <- results, do: result["acct"]
1173
1174     assert user_two.nickname in result_ids
1175     assert user_three.nickname in result_ids
1176
1177     results =
1178       conn
1179       |> assign(:user, user)
1180       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1181       |> json_response(200)
1182
1183     result_ids = for result <- results, do: result["acct"]
1184
1185     assert user_three.nickname in result_ids
1186   end
1187
1188   test "search", %{conn: conn} do
1189     user = insert(:user)
1190     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1191     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1192
1193     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1194
1195     {:ok, _activity} =
1196       CommonAPI.post(user, %{
1197         "status" => "This is about 2hu, but private",
1198         "visibility" => "private"
1199       })
1200
1201     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1202
1203     conn =
1204       conn
1205       |> get("/api/v1/search", %{"q" => "2hu"})
1206
1207     assert results = json_response(conn, 200)
1208
1209     [account | _] = results["accounts"]
1210     assert account["id"] == to_string(user_three.id)
1211
1212     assert results["hashtags"] == []
1213
1214     [status] = results["statuses"]
1215     assert status["id"] == to_string(activity.id)
1216   end
1217
1218   test "search fetches remote statuses", %{conn: conn} do
1219     capture_log(fn ->
1220       conn =
1221         conn
1222         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1223
1224       assert results = json_response(conn, 200)
1225
1226       [status] = results["statuses"]
1227       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1228     end)
1229   end
1230
1231   test "search fetches remote accounts", %{conn: conn} do
1232     conn =
1233       conn
1234       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1235
1236     assert results = json_response(conn, 200)
1237     [account] = results["accounts"]
1238     assert account["acct"] == "shp@social.heldscal.la"
1239   end
1240
1241   test "returns the favorites of a user", %{conn: conn} do
1242     user = insert(:user)
1243     other_user = insert(:user)
1244
1245     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1246     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1247
1248     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1249
1250     conn =
1251       conn
1252       |> assign(:user, user)
1253       |> get("/api/v1/favourites")
1254
1255     assert [status] = json_response(conn, 200)
1256     assert status["id"] == to_string(activity.id)
1257   end
1258
1259   describe "updating credentials" do
1260     test "updates the user's bio", %{conn: conn} do
1261       user = insert(:user)
1262       user2 = insert(:user)
1263
1264       conn =
1265         conn
1266         |> assign(:user, user)
1267         |> patch("/api/v1/accounts/update_credentials", %{
1268           "note" => "I drink #cofe with @#{user2.nickname}"
1269         })
1270
1271       assert user = json_response(conn, 200)
1272
1273       assert user["note"] ==
1274                "I drink <a href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a href=\"#{
1275                  user2.ap_id
1276                }\">@<span>#{user2.nickname}</span></a></span>"
1277     end
1278
1279     test "updates the user's locking status", %{conn: conn} do
1280       user = insert(:user)
1281
1282       conn =
1283         conn
1284         |> assign(:user, user)
1285         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1286
1287       assert user = json_response(conn, 200)
1288       assert user["locked"] == true
1289     end
1290
1291     test "updates the user's name", %{conn: conn} do
1292       user = insert(:user)
1293
1294       conn =
1295         conn
1296         |> assign(:user, user)
1297         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1298
1299       assert user = json_response(conn, 200)
1300       assert user["display_name"] == "markorepairs"
1301     end
1302
1303     test "updates the user's avatar", %{conn: conn} do
1304       user = insert(:user)
1305
1306       new_avatar = %Plug.Upload{
1307         content_type: "image/jpg",
1308         path: Path.absname("test/fixtures/image.jpg"),
1309         filename: "an_image.jpg"
1310       }
1311
1312       conn =
1313         conn
1314         |> assign(:user, user)
1315         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1316
1317       assert user_response = json_response(conn, 200)
1318       assert user_response["avatar"] != User.avatar_url(user)
1319     end
1320
1321     test "updates the user's banner", %{conn: conn} do
1322       user = insert(:user)
1323
1324       new_header = %Plug.Upload{
1325         content_type: "image/jpg",
1326         path: Path.absname("test/fixtures/image.jpg"),
1327         filename: "an_image.jpg"
1328       }
1329
1330       conn =
1331         conn
1332         |> assign(:user, user)
1333         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1334
1335       assert user_response = json_response(conn, 200)
1336       assert user_response["header"] != User.banner_url(user)
1337     end
1338   end
1339
1340   test "get instance information", %{conn: conn} do
1341     insert(:user, %{local: true})
1342     user = insert(:user, %{local: true})
1343     insert(:user, %{local: false})
1344
1345     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1346
1347     Pleroma.Stats.update_stats()
1348
1349     conn =
1350       conn
1351       |> get("/api/v1/instance")
1352
1353     assert result = json_response(conn, 200)
1354
1355     assert result["stats"]["user_count"] == 2
1356     assert result["stats"]["status_count"] == 1
1357   end
1358 end