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