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, Object, Activity, Notification}
   6   alias Pleroma.Web.{OStatus, CommonAPI}
   7   alias Pleroma.Web.ActivityPub.ActivityPub
   8   alias Pleroma.Web.MastodonAPI.FilterView
   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       refute Repo.get(Activity, activity.id)
 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
 312     # test "404 when making an attempt to get it" do
 313     #   activity = insert(:note_activity)
 314     #   author = User.get_by_ap_id(activity.data["actor"])
 315
 316     #   conn =
 317     #     conn
 318     #     |> assign(:user, author)
 319     #     |> delete("/api/v1/statuses/#{activity.id}")
 320
 321     #   assert %{} = json_response(conn, 200)
 322
 323     #   conn =
 324     #     build_conn()
 325     #     |> assign(:user, author)
 326     #     |> get("/api/v1/statuses/#{activity.id}")
 327
 328     #   assert %{} = json_response(conn, 200)
 329     # end
 330   end
 331
 332   describe "filters" do
 333     test "creating a filter", %{conn: conn} do
 334       user = insert(:user)
 335
 336       filter = %Pleroma.Filter{
 337         phrase: "knights",
 338         context: ["home"]
 339       }
 340
 341       conn =
 342         conn
 343         |> assign(:user, user)
 344         |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
 345
 346       assert response = json_response(conn, 200)
 347       assert response["phrase"] == filter.phrase
 348       assert response["context"] == filter.context
 349       assert response["id"] != nil
 350       assert response["id"] != ""
 351     end
 352
 353     test "fetching a list of filters", %{conn: conn} do
 354       user = insert(:user)
 355
 356       query_one = %Pleroma.Filter{
 357         user_id: user.id,
 358         filter_id: 1,
 359         phrase: "knights",
 360         context: ["home"]
 361       }
 362
 363       query_two = %Pleroma.Filter{
 364         user_id: user.id,
 365         filter_id: 2,
 366         phrase: "who",
 367         context: ["home"]
 368       }
 369
 370       {:ok, filter_one} = Pleroma.Filter.create(query_one)
 371       {:ok, filter_two} = Pleroma.Filter.create(query_two)
 372
 373       response =
 374         conn
 375         |> assign(:user, user)
 376         |> get("/api/v1/filters")
 377         |> json_response(200)
 378
 379       assert response ==
 380                render_json(
 381                  FilterView,
 382                  "filters.json",
 383                  filters: [filter_two, filter_one]
 384                )
 385     end
 386
 387     test "get a filter", %{conn: conn} do
 388       user = insert(:user)
 389
 390       query = %Pleroma.Filter{
 391         user_id: user.id,
 392         filter_id: 2,
 393         phrase: "knight",
 394         context: ["home"]
 395       }
 396
 397       {:ok, filter} = Pleroma.Filter.create(query)
 398
 399       conn =
 400         conn
 401         |> assign(:user, user)
 402         |> get("/api/v1/filters/#{filter.filter_id}")
 403
 404       assert response = json_response(conn, 200)
 405     end
 406
 407     test "update a filter", %{conn: conn} do
 408       user = insert(:user)
 409
 410       query = %Pleroma.Filter{
 411         user_id: user.id,
 412         filter_id: 2,
 413         phrase: "knight",
 414         context: ["home"]
 415       }
 416
 417       {:ok, _filter} = Pleroma.Filter.create(query)
 418
 419       new = %Pleroma.Filter{
 420         phrase: "nii",
 421         context: ["home"]
 422       }
 423
 424       conn =
 425         conn
 426         |> assign(:user, user)
 427         |> put("/api/v1/filters/#{query.filter_id}", %{
 428           phrase: new.phrase,
 429           context: new.context
 430         })
 431
 432       assert response = json_response(conn, 200)
 433       assert response["phrase"] == new.phrase
 434       assert response["context"] == new.context
 435     end
 436
 437     test "delete a filter", %{conn: conn} do
 438       user = insert(:user)
 439
 440       query = %Pleroma.Filter{
 441         user_id: user.id,
 442         filter_id: 2,
 443         phrase: "knight",
 444         context: ["home"]
 445       }
 446
 447       {:ok, filter} = Pleroma.Filter.create(query)
 448
 449       conn =
 450         conn
 451         |> assign(:user, user)
 452         |> delete("/api/v1/filters/#{filter.filter_id}")
 453
 454       assert response = json_response(conn, 200)
 455       assert response == %{}
 456     end
 457   end
 458
 459   describe "lists" do
 460     test "creating a list", %{conn: conn} do
 461       user = insert(:user)
 462
 463       conn =
 464         conn
 465         |> assign(:user, user)
 466         |> post("/api/v1/lists", %{"title" => "cuties"})
 467
 468       assert %{"title" => title} = json_response(conn, 200)
 469       assert title == "cuties"
 470     end
 471
 472     test "adding users to a list", %{conn: conn} do
 473       user = insert(:user)
 474       other_user = insert(:user)
 475       {:ok, list} = Pleroma.List.create("name", user)
 476
 477       conn =
 478         conn
 479         |> assign(:user, user)
 480         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 481
 482       assert %{} == json_response(conn, 200)
 483       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 484       assert following == [other_user.follower_address]
 485     end
 486
 487     test "removing users from a list", %{conn: conn} do
 488       user = insert(:user)
 489       other_user = insert(:user)
 490       third_user = insert(:user)
 491       {:ok, list} = Pleroma.List.create("name", user)
 492       {:ok, list} = Pleroma.List.follow(list, other_user)
 493       {:ok, list} = Pleroma.List.follow(list, third_user)
 494
 495       conn =
 496         conn
 497         |> assign(:user, user)
 498         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 499
 500       assert %{} == json_response(conn, 200)
 501       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 502       assert following == [third_user.follower_address]
 503     end
 504
 505     test "listing users in a list", %{conn: conn} do
 506       user = insert(:user)
 507       other_user = insert(:user)
 508       {:ok, list} = Pleroma.List.create("name", user)
 509       {:ok, list} = Pleroma.List.follow(list, other_user)
 510
 511       conn =
 512         conn
 513         |> assign(:user, user)
 514         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 515
 516       assert [%{"id" => id}] = json_response(conn, 200)
 517       assert id == to_string(other_user.id)
 518     end
 519
 520     test "retrieving a list", %{conn: conn} do
 521       user = insert(:user)
 522       {:ok, list} = Pleroma.List.create("name", user)
 523
 524       conn =
 525         conn
 526         |> assign(:user, user)
 527         |> get("/api/v1/lists/#{list.id}")
 528
 529       assert %{"id" => id} = json_response(conn, 200)
 530       assert id == to_string(list.id)
 531     end
 532
 533     test "renaming a list", %{conn: conn} do
 534       user = insert(:user)
 535       {:ok, list} = Pleroma.List.create("name", user)
 536
 537       conn =
 538         conn
 539         |> assign(:user, user)
 540         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 541
 542       assert %{"title" => name} = json_response(conn, 200)
 543       assert name == "newname"
 544     end
 545
 546     test "deleting a list", %{conn: conn} do
 547       user = insert(:user)
 548       {:ok, list} = Pleroma.List.create("name", user)
 549
 550       conn =
 551         conn
 552         |> assign(:user, user)
 553         |> delete("/api/v1/lists/#{list.id}")
 554
 555       assert %{} = json_response(conn, 200)
 556       assert is_nil(Repo.get(Pleroma.List, list.id))
 557     end
 558
 559     test "list timeline", %{conn: conn} do
 560       user = insert(:user)
 561       other_user = insert(:user)
 562       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 563       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 564       {:ok, list} = Pleroma.List.create("name", user)
 565       {:ok, list} = Pleroma.List.follow(list, other_user)
 566
 567       conn =
 568         conn
 569         |> assign(:user, user)
 570         |> get("/api/v1/timelines/list/#{list.id}")
 571
 572       assert [%{"id" => id}] = json_response(conn, 200)
 573
 574       assert id == to_string(activity_two.id)
 575     end
 576
 577     test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
 578       user = insert(:user)
 579       other_user = insert(:user)
 580       {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 581
 582       {:ok, _activity_two} =
 583         TwitterAPI.create_status(other_user, %{
 584           "status" => "Marisa is cute.",
 585           "visibility" => "private"
 586         })
 587
 588       {:ok, list} = Pleroma.List.create("name", user)
 589       {:ok, list} = Pleroma.List.follow(list, other_user)
 590
 591       conn =
 592         conn
 593         |> assign(:user, user)
 594         |> get("/api/v1/timelines/list/#{list.id}")
 595
 596       assert [%{"id" => id}] = json_response(conn, 200)
 597
 598       assert id == to_string(activity_one.id)
 599     end
 600   end
 601
 602   describe "notifications" do
 603     test "list of notifications", %{conn: conn} do
 604       user = insert(:user)
 605       other_user = insert(:user)
 606
 607       {:ok, activity} =
 608         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 609
 610       {:ok, [_notification]} = Notification.create_notifications(activity)
 611
 612       conn =
 613         conn
 614         |> assign(:user, user)
 615         |> get("/api/v1/notifications")
 616
 617       expected_response =
 618         "hi <span><a data-user=\"#{user.id}\" href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 619
 620       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 621       assert response == expected_response
 622     end
 623
 624     test "getting a single notification", %{conn: conn} do
 625       user = insert(:user)
 626       other_user = insert(:user)
 627
 628       {:ok, activity} =
 629         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 630
 631       {:ok, [notification]} = Notification.create_notifications(activity)
 632
 633       conn =
 634         conn
 635         |> assign(:user, user)
 636         |> get("/api/v1/notifications/#{notification.id}")
 637
 638       expected_response =
 639         "hi <span><a data-user=\"#{user.id}\" href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 640
 641       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 642       assert response == expected_response
 643     end
 644
 645     test "dismissing a single notification", %{conn: conn} do
 646       user = insert(:user)
 647       other_user = insert(:user)
 648
 649       {:ok, activity} =
 650         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 651
 652       {:ok, [notification]} = Notification.create_notifications(activity)
 653
 654       conn =
 655         conn
 656         |> assign(:user, user)
 657         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 658
 659       assert %{} = json_response(conn, 200)
 660     end
 661
 662     test "clearing all notifications", %{conn: conn} do
 663       user = insert(:user)
 664       other_user = insert(:user)
 665
 666       {:ok, activity} =
 667         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 668
 669       {:ok, [_notification]} = Notification.create_notifications(activity)
 670
 671       conn =
 672         conn
 673         |> assign(:user, user)
 674         |> post("/api/v1/notifications/clear")
 675
 676       assert %{} = json_response(conn, 200)
 677
 678       conn =
 679         build_conn()
 680         |> assign(:user, user)
 681         |> get("/api/v1/notifications")
 682
 683       assert all = json_response(conn, 200)
 684       assert all == []
 685     end
 686   end
 687
 688   describe "reblogging" do
 689     test "reblogs and returns the reblogged status", %{conn: conn} do
 690       activity = insert(:note_activity)
 691       user = insert(:user)
 692
 693       conn =
 694         conn
 695         |> assign(:user, user)
 696         |> post("/api/v1/statuses/#{activity.id}/reblog")
 697
 698       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 699                json_response(conn, 200)
 700
 701       assert to_string(activity.id) == id
 702     end
 703   end
 704
 705   describe "unreblogging" do
 706     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 707       activity = insert(:note_activity)
 708       user = insert(:user)
 709
 710       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 711
 712       conn =
 713         conn
 714         |> assign(:user, user)
 715         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 716
 717       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 718
 719       assert to_string(activity.id) == id
 720     end
 721   end
 722
 723   describe "favoriting" do
 724     test "favs a status and returns it", %{conn: conn} do
 725       activity = insert(:note_activity)
 726       user = insert(:user)
 727
 728       conn =
 729         conn
 730         |> assign(:user, user)
 731         |> post("/api/v1/statuses/#{activity.id}/favourite")
 732
 733       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 734                json_response(conn, 200)
 735
 736       assert to_string(activity.id) == id
 737     end
 738
 739     test "returns 500 for a wrong id", %{conn: conn} do
 740       user = insert(:user)
 741
 742       resp =
 743         conn
 744         |> assign(:user, user)
 745         |> post("/api/v1/statuses/1/favourite")
 746         |> json_response(500)
 747
 748       assert resp == "Something went wrong"
 749     end
 750   end
 751
 752   describe "unfavoriting" do
 753     test "unfavorites a status and returns it", %{conn: conn} do
 754       activity = insert(:note_activity)
 755       user = insert(:user)
 756
 757       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 758
 759       conn =
 760         conn
 761         |> assign(:user, user)
 762         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 763
 764       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 765                json_response(conn, 200)
 766
 767       assert to_string(activity.id) == id
 768     end
 769   end
 770
 771   describe "user timelines" do
 772     test "gets a users statuses", %{conn: conn} do
 773       user_one = insert(:user)
 774       user_two = insert(:user)
 775       user_three = insert(:user)
 776
 777       {:ok, user_three} = User.follow(user_three, user_one)
 778
 779       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 780
 781       {:ok, direct_activity} =
 782         CommonAPI.post(user_one, %{
 783           "status" => "Hi, @#{user_two.nickname}.",
 784           "visibility" => "direct"
 785         })
 786
 787       {:ok, private_activity} =
 788         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 789
 790       resp =
 791         conn
 792         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 793
 794       assert [%{"id" => id}] = json_response(resp, 200)
 795       assert id == to_string(activity.id)
 796
 797       resp =
 798         conn
 799         |> assign(:user, user_two)
 800         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 801
 802       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 803       assert id_one == to_string(direct_activity.id)
 804       assert id_two == to_string(activity.id)
 805
 806       resp =
 807         conn
 808         |> assign(:user, user_three)
 809         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 810
 811       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 812       assert id_one == to_string(private_activity.id)
 813       assert id_two == to_string(activity.id)
 814     end
 815
 816     test "unimplemented pinned statuses feature", %{conn: conn} do
 817       note = insert(:note_activity)
 818       user = User.get_by_ap_id(note.data["actor"])
 819
 820       conn =
 821         conn
 822         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 823
 824       assert json_response(conn, 200) == []
 825     end
 826
 827     test "gets an users media", %{conn: conn} do
 828       note = insert(:note_activity)
 829       user = User.get_by_ap_id(note.data["actor"])
 830
 831       file = %Plug.Upload{
 832         content_type: "image/jpg",
 833         path: Path.absname("test/fixtures/image.jpg"),
 834         filename: "an_image.jpg"
 835       }
 836
 837       media =
 838         TwitterAPI.upload(file, user, "json")
 839         |> Poison.decode!()
 840
 841       {:ok, image_post} =
 842         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 843
 844       conn =
 845         conn
 846         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 847
 848       assert [%{"id" => id}] = json_response(conn, 200)
 849       assert id == to_string(image_post.id)
 850
 851       conn =
 852         build_conn()
 853         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 854
 855       assert [%{"id" => id}] = json_response(conn, 200)
 856       assert id == to_string(image_post.id)
 857     end
 858   end
 859
 860   describe "user relationships" do
 861     test "returns the relationships for the current user", %{conn: conn} do
 862       user = insert(:user)
 863       other_user = insert(:user)
 864       {:ok, user} = User.follow(user, other_user)
 865
 866       conn =
 867         conn
 868         |> assign(:user, user)
 869         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 870
 871       assert [relationship] = json_response(conn, 200)
 872
 873       assert to_string(other_user.id) == relationship["id"]
 874     end
 875   end
 876
 877   describe "locked accounts" do
 878     test "/api/v1/follow_requests works" do
 879       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 880       other_user = insert(:user)
 881
 882       {:ok, _activity} = ActivityPub.follow(other_user, user)
 883
 884       user = Repo.get(User, user.id)
 885       other_user = Repo.get(User, other_user.id)
 886
 887       assert User.following?(other_user, user) == false
 888
 889       conn =
 890         build_conn()
 891         |> assign(:user, user)
 892         |> get("/api/v1/follow_requests")
 893
 894       assert [relationship] = json_response(conn, 200)
 895       assert to_string(other_user.id) == relationship["id"]
 896     end
 897
 898     test "/api/v1/follow_requests/:id/authorize works" do
 899       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 900       other_user = insert(:user)
 901
 902       {:ok, _activity} = ActivityPub.follow(other_user, user)
 903
 904       user = Repo.get(User, user.id)
 905       other_user = Repo.get(User, other_user.id)
 906
 907       assert User.following?(other_user, user) == false
 908
 909       conn =
 910         build_conn()
 911         |> assign(:user, user)
 912         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 913
 914       assert relationship = json_response(conn, 200)
 915       assert to_string(other_user.id) == relationship["id"]
 916
 917       user = Repo.get(User, user.id)
 918       other_user = Repo.get(User, other_user.id)
 919
 920       assert User.following?(other_user, user) == true
 921     end
 922
 923     test "verify_credentials", %{conn: conn} do
 924       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
 925
 926       conn =
 927         conn
 928         |> assign(:user, user)
 929         |> get("/api/v1/accounts/verify_credentials")
 930
 931       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 932       assert id == to_string(user.id)
 933     end
 934
 935     test "/api/v1/follow_requests/:id/reject works" do
 936       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 937       other_user = insert(:user)
 938
 939       {:ok, _activity} = ActivityPub.follow(other_user, user)
 940
 941       conn =
 942         build_conn()
 943         |> assign(:user, user)
 944         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 945
 946       assert relationship = json_response(conn, 200)
 947       assert to_string(other_user.id) == relationship["id"]
 948
 949       user = Repo.get(User, user.id)
 950       other_user = Repo.get(User, other_user.id)
 951
 952       assert User.following?(other_user, user) == false
 953     end
 954   end
 955
 956   test "account fetching", %{conn: conn} do
 957     user = insert(:user)
 958
 959     conn =
 960       conn
 961       |> get("/api/v1/accounts/#{user.id}")
 962
 963     assert %{"id" => id} = json_response(conn, 200)
 964     assert id == to_string(user.id)
 965
 966     conn =
 967       build_conn()
 968       |> get("/api/v1/accounts/-1")
 969
 970     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 971   end
 972
 973   test "media upload", %{conn: conn} do
 974     file = %Plug.Upload{
 975       content_type: "image/jpg",
 976       path: Path.absname("test/fixtures/image.jpg"),
 977       filename: "an_image.jpg"
 978     }
 979
 980     desc = "Description of the image"
 981
 982     user = insert(:user)
 983
 984     conn =
 985       conn
 986       |> assign(:user, user)
 987       |> post("/api/v1/media", %{"file" => file, "description" => desc})
 988
 989     assert media = json_response(conn, 200)
 990
 991     assert media["type"] == "image"
 992     assert media["description"] == desc
 993     assert media["id"]
 994
 995     object = Repo.get(Object, media["id"])
 996     assert object.data["actor"] == User.ap_id(user)
 997   end
 998
 999   test "hashtag timeline", %{conn: conn} do
1000     following = insert(:user)
1001
1002     capture_log(fn ->
1003       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1004
1005       {:ok, [_activity]} =
1006         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1007
1008       nconn =
1009         conn
1010         |> get("/api/v1/timelines/tag/2hu")
1011
1012       assert [%{"id" => id}] = json_response(nconn, 200)
1013
1014       assert id == to_string(activity.id)
1015
1016       # works for different capitalization too
1017       nconn =
1018         conn
1019         |> get("/api/v1/timelines/tag/2HU")
1020
1021       assert [%{"id" => id}] = json_response(nconn, 200)
1022
1023       assert id == to_string(activity.id)
1024     end)
1025   end
1026
1027   test "getting followers", %{conn: conn} do
1028     user = insert(:user)
1029     other_user = insert(:user)
1030     {:ok, user} = User.follow(user, other_user)
1031
1032     conn =
1033       conn
1034       |> get("/api/v1/accounts/#{other_user.id}/followers")
1035
1036     assert [%{"id" => id}] = json_response(conn, 200)
1037     assert id == to_string(user.id)
1038   end
1039
1040   test "getting followers, hide_network", %{conn: conn} do
1041     user = insert(:user)
1042     other_user = insert(:user, %{info: %{hide_network: true}})
1043     {:ok, _user} = User.follow(user, other_user)
1044
1045     conn =
1046       conn
1047       |> get("/api/v1/accounts/#{other_user.id}/followers")
1048
1049     assert [] == json_response(conn, 200)
1050   end
1051
1052   test "getting followers, hide_network, same user requesting", %{conn: conn} do
1053     user = insert(:user)
1054     other_user = insert(:user, %{info: %{hide_network: true}})
1055     {:ok, _user} = User.follow(user, other_user)
1056
1057     conn =
1058       conn
1059       |> assign(:user, other_user)
1060       |> get("/api/v1/accounts/#{other_user.id}/followers")
1061
1062     refute [] == json_response(conn, 200)
1063   end
1064
1065   test "getting following", %{conn: conn} do
1066     user = insert(:user)
1067     other_user = insert(:user)
1068     {:ok, user} = User.follow(user, other_user)
1069
1070     conn =
1071       conn
1072       |> get("/api/v1/accounts/#{user.id}/following")
1073
1074     assert [%{"id" => id}] = json_response(conn, 200)
1075     assert id == to_string(other_user.id)
1076   end
1077
1078   test "getting following, hide_network", %{conn: conn} do
1079     user = insert(:user, %{info: %{hide_network: true}})
1080     other_user = insert(:user)
1081     {:ok, user} = User.follow(user, other_user)
1082
1083     conn =
1084       conn
1085       |> get("/api/v1/accounts/#{user.id}/following")
1086
1087     assert [] == json_response(conn, 200)
1088   end
1089
1090   test "getting following, hide_network, same user requesting", %{conn: conn} do
1091     user = insert(:user, %{info: %{hide_network: true}})
1092     other_user = insert(:user)
1093     {:ok, user} = User.follow(user, other_user)
1094
1095     conn =
1096       conn
1097       |> assign(:user, user)
1098       |> get("/api/v1/accounts/#{user.id}/following")
1099
1100     refute [] == json_response(conn, 200)
1101   end
1102
1103   test "following / unfollowing a user", %{conn: conn} do
1104     user = insert(:user)
1105     other_user = insert(:user)
1106
1107     conn =
1108       conn
1109       |> assign(:user, user)
1110       |> post("/api/v1/accounts/#{other_user.id}/follow")
1111
1112     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1113
1114     user = Repo.get(User, user.id)
1115
1116     conn =
1117       build_conn()
1118       |> assign(:user, user)
1119       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1120
1121     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1122
1123     user = Repo.get(User, user.id)
1124
1125     conn =
1126       build_conn()
1127       |> assign(:user, user)
1128       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1129
1130     assert %{"id" => id} = json_response(conn, 200)
1131     assert id == to_string(other_user.id)
1132   end
1133
1134   test "blocking / unblocking a user", %{conn: conn} do
1135     user = insert(:user)
1136     other_user = insert(:user)
1137
1138     conn =
1139       conn
1140       |> assign(:user, user)
1141       |> post("/api/v1/accounts/#{other_user.id}/block")
1142
1143     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1144
1145     user = Repo.get(User, user.id)
1146
1147     conn =
1148       build_conn()
1149       |> assign(:user, user)
1150       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1151
1152     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1153   end
1154
1155   test "getting a list of blocks", %{conn: conn} do
1156     user = insert(:user)
1157     other_user = insert(:user)
1158
1159     {:ok, user} = User.block(user, other_user)
1160
1161     conn =
1162       conn
1163       |> assign(:user, user)
1164       |> get("/api/v1/blocks")
1165
1166     other_user_id = to_string(other_user.id)
1167     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1168   end
1169
1170   test "blocking / unblocking a domain", %{conn: conn} do
1171     user = insert(:user)
1172     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1173
1174     conn =
1175       conn
1176       |> assign(:user, user)
1177       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1178
1179     assert %{} = json_response(conn, 200)
1180     user = User.get_cached_by_ap_id(user.ap_id)
1181     assert User.blocks?(user, other_user)
1182
1183     conn =
1184       build_conn()
1185       |> assign(:user, user)
1186       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1187
1188     assert %{} = json_response(conn, 200)
1189     user = User.get_cached_by_ap_id(user.ap_id)
1190     refute User.blocks?(user, other_user)
1191   end
1192
1193   test "getting a list of domain blocks", %{conn: conn} do
1194     user = insert(:user)
1195
1196     {:ok, user} = User.block_domain(user, "bad.site")
1197     {:ok, user} = User.block_domain(user, "even.worse.site")
1198
1199     conn =
1200       conn
1201       |> assign(:user, user)
1202       |> get("/api/v1/domain_blocks")
1203
1204     domain_blocks = json_response(conn, 200)
1205
1206     assert "bad.site" in domain_blocks
1207     assert "even.worse.site" in domain_blocks
1208   end
1209
1210   test "unimplemented mute endpoints" do
1211     user = insert(:user)
1212     other_user = insert(:user)
1213
1214     ["mute", "unmute"]
1215     |> Enum.each(fn endpoint ->
1216       conn =
1217         build_conn()
1218         |> assign(:user, user)
1219         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1220
1221       assert %{"id" => id} = json_response(conn, 200)
1222       assert id == to_string(other_user.id)
1223     end)
1224   end
1225
1226   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1227     user = insert(:user)
1228
1229     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1230     |> Enum.each(fn endpoint ->
1231       conn =
1232         build_conn()
1233         |> assign(:user, user)
1234         |> get("/api/v1/#{endpoint}")
1235
1236       assert [] = json_response(conn, 200)
1237     end)
1238   end
1239
1240   test "account search", %{conn: conn} do
1241     user = insert(:user)
1242     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1243     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1244
1245     results =
1246       conn
1247       |> assign(:user, user)
1248       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1249       |> json_response(200)
1250
1251     result_ids = for result <- results, do: result["acct"]
1252
1253     assert user_two.nickname in result_ids
1254     assert user_three.nickname in result_ids
1255
1256     results =
1257       conn
1258       |> assign(:user, user)
1259       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1260       |> json_response(200)
1261
1262     result_ids = for result <- results, do: result["acct"]
1263
1264     assert user_three.nickname in result_ids
1265   end
1266
1267   test "search", %{conn: conn} do
1268     user = insert(:user)
1269     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1270     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1271
1272     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1273
1274     {:ok, _activity} =
1275       CommonAPI.post(user, %{
1276         "status" => "This is about 2hu, but private",
1277         "visibility" => "private"
1278       })
1279
1280     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1281
1282     conn =
1283       conn
1284       |> get("/api/v1/search", %{"q" => "2hu"})
1285
1286     assert results = json_response(conn, 200)
1287
1288     [account | _] = results["accounts"]
1289     assert account["id"] == to_string(user_three.id)
1290
1291     assert results["hashtags"] == []
1292
1293     [status] = results["statuses"]
1294     assert status["id"] == to_string(activity.id)
1295   end
1296
1297   test "search fetches remote statuses", %{conn: conn} do
1298     capture_log(fn ->
1299       conn =
1300         conn
1301         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1302
1303       assert results = json_response(conn, 200)
1304
1305       [status] = results["statuses"]
1306       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1307     end)
1308   end
1309
1310   test "search fetches remote accounts", %{conn: conn} do
1311     conn =
1312       conn
1313       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1314
1315     assert results = json_response(conn, 200)
1316     [account] = results["accounts"]
1317     assert account["acct"] == "shp@social.heldscal.la"
1318   end
1319
1320   test "returns the favorites of a user", %{conn: conn} do
1321     user = insert(:user)
1322     other_user = insert(:user)
1323
1324     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1325     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1326
1327     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1328
1329     conn =
1330       conn
1331       |> assign(:user, user)
1332       |> get("/api/v1/favourites")
1333
1334     assert [status] = json_response(conn, 200)
1335     assert status["id"] == to_string(activity.id)
1336   end
1337
1338   describe "updating credentials" do
1339     test "updates the user's bio", %{conn: conn} do
1340       user = insert(:user)
1341       user2 = insert(:user)
1342
1343       conn =
1344         conn
1345         |> assign(:user, user)
1346         |> patch("/api/v1/accounts/update_credentials", %{
1347           "note" => "I drink #cofe with @#{user2.nickname}"
1348         })
1349
1350       assert user = json_response(conn, 200)
1351
1352       assert user["note"] ==
1353                "I drink <a data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a data-user=\"#{
1354                  user2.id
1355                }\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1356     end
1357
1358     test "updates the user's locking status", %{conn: conn} do
1359       user = insert(:user)
1360
1361       conn =
1362         conn
1363         |> assign(:user, user)
1364         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1365
1366       assert user = json_response(conn, 200)
1367       assert user["locked"] == true
1368     end
1369
1370     test "updates the user's name", %{conn: conn} do
1371       user = insert(:user)
1372
1373       conn =
1374         conn
1375         |> assign(:user, user)
1376         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1377
1378       assert user = json_response(conn, 200)
1379       assert user["display_name"] == "markorepairs"
1380     end
1381
1382     test "updates the user's avatar", %{conn: conn} do
1383       user = insert(:user)
1384
1385       new_avatar = %Plug.Upload{
1386         content_type: "image/jpg",
1387         path: Path.absname("test/fixtures/image.jpg"),
1388         filename: "an_image.jpg"
1389       }
1390
1391       conn =
1392         conn
1393         |> assign(:user, user)
1394         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1395
1396       assert user_response = json_response(conn, 200)
1397       assert user_response["avatar"] != User.avatar_url(user)
1398     end
1399
1400     test "updates the user's banner", %{conn: conn} do
1401       user = insert(:user)
1402
1403       new_header = %Plug.Upload{
1404         content_type: "image/jpg",
1405         path: Path.absname("test/fixtures/image.jpg"),
1406         filename: "an_image.jpg"
1407       }
1408
1409       conn =
1410         conn
1411         |> assign(:user, user)
1412         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1413
1414       assert user_response = json_response(conn, 200)
1415       assert user_response["header"] != User.banner_url(user)
1416     end
1417   end
1418
1419   test "get instance information", %{conn: conn} do
1420     insert(:user, %{local: true})
1421     user = insert(:user, %{local: true})
1422     insert(:user, %{local: false})
1423
1424     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1425
1426     Pleroma.Stats.update_stats()
1427
1428     conn =
1429       conn
1430       |> get("/api/v1/instance")
1431
1432     assert result = json_response(conn, 200)
1433
1434     assert result["stats"]["user_count"] == 2
1435     assert result["stats"]["status_count"] == 1
1436   end
1437
1438   test "put settings", %{conn: conn} do
1439     user = insert(:user)
1440
1441     conn =
1442       conn
1443       |> assign(:user, user)
1444       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1445
1446     assert result = json_response(conn, 200)
1447
1448     user = User.get_cached_by_ap_id(user.ap_id)
1449     assert user.info.settings == %{"programming" => "socks"}
1450   end
1451 end