git.squeep.com Git - akkoma/blob - test/web/mastodon_api/mastodon_api_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Web.TwitterAPI.TwitterAPI
   9   alias Pleroma.{Repo, User, Object, Activity, Notification}
  10   alias Pleroma.Web.{OStatus, CommonAPI}
  11   alias Pleroma.Web.ActivityPub.ActivityPub
  12   alias Pleroma.Web.MastodonAPI.FilterView
  13   alias Ecto.Changeset
  14   import Pleroma.Factory
  15   import ExUnit.CaptureLog
  16   import Tesla.Mock
  17
  18   setup do
  19     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  20     :ok
  21   end
  22
  23   test "the home timeline", %{conn: conn} do
  24     user = insert(:user)
  25     following = insert(:user)
  26
  27     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  28
  29     conn =
  30       conn
  31       |> assign(:user, user)
  32       |> get("/api/v1/timelines/home")
  33
  34     assert length(json_response(conn, 200)) == 0
  35
  36     {:ok, user} = User.follow(user, following)
  37
  38     conn =
  39       build_conn()
  40       |> assign(:user, user)
  41       |> get("/api/v1/timelines/home")
  42
  43     assert [%{"content" => "test"}] = json_response(conn, 200)
  44   end
  45
  46   test "the public timeline", %{conn: conn} do
  47     following = insert(:user)
  48
  49     capture_log(fn ->
  50       {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  51
  52       {:ok, [_activity]} =
  53         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  54
  55       conn =
  56         conn
  57         |> get("/api/v1/timelines/public", %{"local" => "False"})
  58
  59       assert length(json_response(conn, 200)) == 2
  60
  61       conn =
  62         build_conn()
  63         |> get("/api/v1/timelines/public", %{"local" => "True"})
  64
  65       assert [%{"content" => "test"}] = json_response(conn, 200)
  66
  67       conn =
  68         build_conn()
  69         |> get("/api/v1/timelines/public", %{"local" => "1"})
  70
  71       assert [%{"content" => "test"}] = json_response(conn, 200)
  72     end)
  73   end
  74
  75   test "posting a status", %{conn: conn} do
  76     user = insert(:user)
  77
  78     idempotency_key = "Pikachu rocks!"
  79
  80     conn_one =
  81       conn
  82       |> assign(:user, user)
  83       |> put_req_header("idempotency-key", idempotency_key)
  84       |> post("/api/v1/statuses", %{
  85         "status" => "cofe",
  86         "spoiler_text" => "2hu",
  87         "sensitive" => "false"
  88       })
  89
  90     {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  91     # Six hours
  92     assert ttl > :timer.seconds(6 * 60 * 60 - 1)
  93
  94     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
  95              json_response(conn_one, 200)
  96
  97     assert Repo.get(Activity, id)
  98
  99     conn_two =
 100       conn
 101       |> assign(:user, user)
 102       |> put_req_header("idempotency-key", idempotency_key)
 103       |> post("/api/v1/statuses", %{
 104         "status" => "cofe",
 105         "spoiler_text" => "2hu",
 106         "sensitive" => "false"
 107       })
 108
 109     assert %{"id" => second_id} = json_response(conn_two, 200)
 110
 111     assert id == second_id
 112
 113     conn_three =
 114       conn
 115       |> assign(:user, user)
 116       |> post("/api/v1/statuses", %{
 117         "status" => "cofe",
 118         "spoiler_text" => "2hu",
 119         "sensitive" => "false"
 120       })
 121
 122     assert %{"id" => third_id} = json_response(conn_three, 200)
 123
 124     refute id == third_id
 125   end
 126
 127   test "posting a sensitive status", %{conn: conn} do
 128     user = insert(:user)
 129
 130     conn =
 131       conn
 132       |> assign(:user, user)
 133       |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 134
 135     assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 136     assert Repo.get(Activity, id)
 137   end
 138
 139   test "posting a status with OGP link preview", %{conn: conn} do
 140     user = insert(:user)
 141
 142     conn =
 143       conn
 144       |> assign(:user, user)
 145       |> post("/api/v1/statuses", %{
 146         "status" => "http://example.com/ogp"
 147       })
 148
 149     assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
 150     assert Repo.get(Activity, id)
 151   end
 152
 153   test "posting a direct status", %{conn: conn} do
 154     user1 = insert(:user)
 155     user2 = insert(:user)
 156     content = "direct cofe @#{user2.nickname}"
 157
 158     conn =
 159       conn
 160       |> assign(:user, user1)
 161       |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 162
 163     assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
 164     assert activity = Repo.get(Activity, id)
 165     assert activity.recipients == [user2.ap_id, user1.ap_id]
 166     assert activity.data["to"] == [user2.ap_id]
 167     assert activity.data["cc"] == []
 168   end
 169
 170   test "direct timeline", %{conn: conn} do
 171     user_one = insert(:user)
 172     user_two = insert(:user)
 173
 174     {:ok, user_two} = User.follow(user_two, user_one)
 175
 176     {:ok, direct} =
 177       CommonAPI.post(user_one, %{
 178         "status" => "Hi @#{user_two.nickname}!",
 179         "visibility" => "direct"
 180       })
 181
 182     {:ok, _follower_only} =
 183       CommonAPI.post(user_one, %{
 184         "status" => "Hi @#{user_two.nickname}!",
 185         "visibility" => "private"
 186       })
 187
 188     # Only direct should be visible here
 189     res_conn =
 190       conn
 191       |> assign(:user, user_two)
 192       |> get("api/v1/timelines/direct")
 193
 194     [status] = json_response(res_conn, 200)
 195
 196     assert %{"visibility" => "direct"} = status
 197     assert status["url"] != direct.data["id"]
 198
 199     # User should be able to see his own direct message
 200     res_conn =
 201       build_conn()
 202       |> assign(:user, user_one)
 203       |> get("api/v1/timelines/direct")
 204
 205     [status] = json_response(res_conn, 200)
 206
 207     assert %{"visibility" => "direct"} = status
 208
 209     # Both should be visible here
 210     res_conn =
 211       conn
 212       |> assign(:user, user_two)
 213       |> get("api/v1/timelines/home")
 214
 215     [_s1, _s2] = json_response(res_conn, 200)
 216
 217     # Test pagination
 218     Enum.each(1..20, fn _ ->
 219       {:ok, _} =
 220         CommonAPI.post(user_one, %{
 221           "status" => "Hi @#{user_two.nickname}!",
 222           "visibility" => "direct"
 223         })
 224     end)
 225
 226     res_conn =
 227       conn
 228       |> assign(:user, user_two)
 229       |> get("api/v1/timelines/direct")
 230
 231     statuses = json_response(res_conn, 200)
 232     assert length(statuses) == 20
 233
 234     res_conn =
 235       conn
 236       |> assign(:user, user_two)
 237       |> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
 238
 239     [status] = json_response(res_conn, 200)
 240
 241     assert status["url"] != direct.data["id"]
 242   end
 243
 244   test "replying to a status", %{conn: conn} do
 245     user = insert(:user)
 246
 247     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 248
 249     conn =
 250       conn
 251       |> assign(:user, user)
 252       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 253
 254     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 255
 256     activity = Repo.get(Activity, id)
 257
 258     assert activity.data["context"] == replied_to.data["context"]
 259     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
 260   end
 261
 262   test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
 263     user = insert(:user)
 264
 265     conn =
 266       conn
 267       |> assign(:user, user)
 268       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 269
 270     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 271
 272     activity = Repo.get(Activity, id)
 273
 274     assert activity
 275   end
 276
 277   test "verify_credentials", %{conn: conn} do
 278     user = insert(:user)
 279
 280     conn =
 281       conn
 282       |> assign(:user, user)
 283       |> get("/api/v1/accounts/verify_credentials")
 284
 285     assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
 286     assert id == to_string(user.id)
 287   end
 288
 289   test "verify_credentials default scope unlisted", %{conn: conn} do
 290     user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})
 291
 292     conn =
 293       conn
 294       |> assign(:user, user)
 295       |> get("/api/v1/accounts/verify_credentials")
 296
 297     assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
 298     assert id == to_string(user.id)
 299   end
 300
 301   test "get a status", %{conn: conn} do
 302     activity = insert(:note_activity)
 303
 304     conn =
 305       conn
 306       |> get("/api/v1/statuses/#{activity.id}")
 307
 308     assert %{"id" => id} = json_response(conn, 200)
 309     assert id == to_string(activity.id)
 310   end
 311
 312   describe "deleting a status" do
 313     test "when you created it", %{conn: conn} do
 314       activity = insert(:note_activity)
 315       author = User.get_by_ap_id(activity.data["actor"])
 316
 317       conn =
 318         conn
 319         |> assign(:user, author)
 320         |> delete("/api/v1/statuses/#{activity.id}")
 321
 322       assert %{} = json_response(conn, 200)
 323
 324       refute Repo.get(Activity, activity.id)
 325     end
 326
 327     test "when you didn't create it", %{conn: conn} do
 328       activity = insert(:note_activity)
 329       user = insert(:user)
 330
 331       conn =
 332         conn
 333         |> assign(:user, user)
 334         |> delete("/api/v1/statuses/#{activity.id}")
 335
 336       assert %{"error" => _} = json_response(conn, 403)
 337
 338       assert Repo.get(Activity, activity.id) == activity
 339     end
 340   end
 341
 342   describe "filters" do
 343     test "creating a filter", %{conn: conn} do
 344       user = insert(:user)
 345
 346       filter = %Pleroma.Filter{
 347         phrase: "knights",
 348         context: ["home"]
 349       }
 350
 351       conn =
 352         conn
 353         |> assign(:user, user)
 354         |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
 355
 356       assert response = json_response(conn, 200)
 357       assert response["phrase"] == filter.phrase
 358       assert response["context"] == filter.context
 359       assert response["id"] != nil
 360       assert response["id"] != ""
 361     end
 362
 363     test "fetching a list of filters", %{conn: conn} do
 364       user = insert(:user)
 365
 366       query_one = %Pleroma.Filter{
 367         user_id: user.id,
 368         filter_id: 1,
 369         phrase: "knights",
 370         context: ["home"]
 371       }
 372
 373       query_two = %Pleroma.Filter{
 374         user_id: user.id,
 375         filter_id: 2,
 376         phrase: "who",
 377         context: ["home"]
 378       }
 379
 380       {:ok, filter_one} = Pleroma.Filter.create(query_one)
 381       {:ok, filter_two} = Pleroma.Filter.create(query_two)
 382
 383       response =
 384         conn
 385         |> assign(:user, user)
 386         |> get("/api/v1/filters")
 387         |> json_response(200)
 388
 389       assert response ==
 390                render_json(
 391                  FilterView,
 392                  "filters.json",
 393                  filters: [filter_two, filter_one]
 394                )
 395     end
 396
 397     test "get a filter", %{conn: conn} do
 398       user = insert(:user)
 399
 400       query = %Pleroma.Filter{
 401         user_id: user.id,
 402         filter_id: 2,
 403         phrase: "knight",
 404         context: ["home"]
 405       }
 406
 407       {:ok, filter} = Pleroma.Filter.create(query)
 408
 409       conn =
 410         conn
 411         |> assign(:user, user)
 412         |> get("/api/v1/filters/#{filter.filter_id}")
 413
 414       assert _response = json_response(conn, 200)
 415     end
 416
 417     test "update a filter", %{conn: conn} do
 418       user = insert(:user)
 419
 420       query = %Pleroma.Filter{
 421         user_id: user.id,
 422         filter_id: 2,
 423         phrase: "knight",
 424         context: ["home"]
 425       }
 426
 427       {:ok, _filter} = Pleroma.Filter.create(query)
 428
 429       new = %Pleroma.Filter{
 430         phrase: "nii",
 431         context: ["home"]
 432       }
 433
 434       conn =
 435         conn
 436         |> assign(:user, user)
 437         |> put("/api/v1/filters/#{query.filter_id}", %{
 438           phrase: new.phrase,
 439           context: new.context
 440         })
 441
 442       assert response = json_response(conn, 200)
 443       assert response["phrase"] == new.phrase
 444       assert response["context"] == new.context
 445     end
 446
 447     test "delete a filter", %{conn: conn} do
 448       user = insert(:user)
 449
 450       query = %Pleroma.Filter{
 451         user_id: user.id,
 452         filter_id: 2,
 453         phrase: "knight",
 454         context: ["home"]
 455       }
 456
 457       {:ok, filter} = Pleroma.Filter.create(query)
 458
 459       conn =
 460         conn
 461         |> assign(:user, user)
 462         |> delete("/api/v1/filters/#{filter.filter_id}")
 463
 464       assert response = json_response(conn, 200)
 465       assert response == %{}
 466     end
 467   end
 468
 469   describe "lists" do
 470     test "creating a list", %{conn: conn} do
 471       user = insert(:user)
 472
 473       conn =
 474         conn
 475         |> assign(:user, user)
 476         |> post("/api/v1/lists", %{"title" => "cuties"})
 477
 478       assert %{"title" => title} = json_response(conn, 200)
 479       assert title == "cuties"
 480     end
 481
 482     test "adding users to a list", %{conn: conn} do
 483       user = insert(:user)
 484       other_user = insert(:user)
 485       {:ok, list} = Pleroma.List.create("name", user)
 486
 487       conn =
 488         conn
 489         |> assign(:user, user)
 490         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 491
 492       assert %{} == json_response(conn, 200)
 493       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 494       assert following == [other_user.follower_address]
 495     end
 496
 497     test "removing users from a list", %{conn: conn} do
 498       user = insert(:user)
 499       other_user = insert(:user)
 500       third_user = insert(:user)
 501       {:ok, list} = Pleroma.List.create("name", user)
 502       {:ok, list} = Pleroma.List.follow(list, other_user)
 503       {:ok, list} = Pleroma.List.follow(list, third_user)
 504
 505       conn =
 506         conn
 507         |> assign(:user, user)
 508         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 509
 510       assert %{} == json_response(conn, 200)
 511       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 512       assert following == [third_user.follower_address]
 513     end
 514
 515     test "listing users in a list", %{conn: conn} do
 516       user = insert(:user)
 517       other_user = insert(:user)
 518       {:ok, list} = Pleroma.List.create("name", user)
 519       {:ok, list} = Pleroma.List.follow(list, other_user)
 520
 521       conn =
 522         conn
 523         |> assign(:user, user)
 524         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 525
 526       assert [%{"id" => id}] = json_response(conn, 200)
 527       assert id == to_string(other_user.id)
 528     end
 529
 530     test "retrieving a list", %{conn: conn} do
 531       user = insert(:user)
 532       {:ok, list} = Pleroma.List.create("name", user)
 533
 534       conn =
 535         conn
 536         |> assign(:user, user)
 537         |> get("/api/v1/lists/#{list.id}")
 538
 539       assert %{"id" => id} = json_response(conn, 200)
 540       assert id == to_string(list.id)
 541     end
 542
 543     test "renaming a list", %{conn: conn} do
 544       user = insert(:user)
 545       {:ok, list} = Pleroma.List.create("name", user)
 546
 547       conn =
 548         conn
 549         |> assign(:user, user)
 550         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 551
 552       assert %{"title" => name} = json_response(conn, 200)
 553       assert name == "newname"
 554     end
 555
 556     test "deleting a list", %{conn: conn} do
 557       user = insert(:user)
 558       {:ok, list} = Pleroma.List.create("name", user)
 559
 560       conn =
 561         conn
 562         |> assign(:user, user)
 563         |> delete("/api/v1/lists/#{list.id}")
 564
 565       assert %{} = json_response(conn, 200)
 566       assert is_nil(Repo.get(Pleroma.List, list.id))
 567     end
 568
 569     test "list timeline", %{conn: conn} do
 570       user = insert(:user)
 571       other_user = insert(:user)
 572       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 573       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 574       {:ok, list} = Pleroma.List.create("name", user)
 575       {:ok, list} = Pleroma.List.follow(list, other_user)
 576
 577       conn =
 578         conn
 579         |> assign(:user, user)
 580         |> get("/api/v1/timelines/list/#{list.id}")
 581
 582       assert [%{"id" => id}] = json_response(conn, 200)
 583
 584       assert id == to_string(activity_two.id)
 585     end
 586
 587     test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
 588       user = insert(:user)
 589       other_user = insert(:user)
 590       {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 591
 592       {:ok, _activity_two} =
 593         TwitterAPI.create_status(other_user, %{
 594           "status" => "Marisa is cute.",
 595           "visibility" => "private"
 596         })
 597
 598       {:ok, list} = Pleroma.List.create("name", user)
 599       {:ok, list} = Pleroma.List.follow(list, other_user)
 600
 601       conn =
 602         conn
 603         |> assign(:user, user)
 604         |> get("/api/v1/timelines/list/#{list.id}")
 605
 606       assert [%{"id" => id}] = json_response(conn, 200)
 607
 608       assert id == to_string(activity_one.id)
 609     end
 610   end
 611
 612   describe "notifications" do
 613     test "list of notifications", %{conn: conn} do
 614       user = insert(:user)
 615       other_user = insert(:user)
 616
 617       {:ok, activity} =
 618         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 619
 620       {:ok, [_notification]} = Notification.create_notifications(activity)
 621
 622       conn =
 623         conn
 624         |> assign(:user, user)
 625         |> get("/api/v1/notifications")
 626
 627       expected_response =
 628         "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 629           user.ap_id
 630         }\">@<span>#{user.nickname}</span></a></span>"
 631
 632       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 633       assert response == expected_response
 634     end
 635
 636     test "getting a single notification", %{conn: conn} do
 637       user = insert(:user)
 638       other_user = insert(:user)
 639
 640       {:ok, activity} =
 641         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 642
 643       {:ok, [notification]} = Notification.create_notifications(activity)
 644
 645       conn =
 646         conn
 647         |> assign(:user, user)
 648         |> get("/api/v1/notifications/#{notification.id}")
 649
 650       expected_response =
 651         "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 652           user.ap_id
 653         }\">@<span>#{user.nickname}</span></a></span>"
 654
 655       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 656       assert response == expected_response
 657     end
 658
 659     test "dismissing a single notification", %{conn: conn} do
 660       user = insert(:user)
 661       other_user = insert(:user)
 662
 663       {:ok, activity} =
 664         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 665
 666       {:ok, [notification]} = Notification.create_notifications(activity)
 667
 668       conn =
 669         conn
 670         |> assign(:user, user)
 671         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 672
 673       assert %{} = json_response(conn, 200)
 674     end
 675
 676     test "clearing all notifications", %{conn: conn} do
 677       user = insert(:user)
 678       other_user = insert(:user)
 679
 680       {:ok, activity} =
 681         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 682
 683       {:ok, [_notification]} = Notification.create_notifications(activity)
 684
 685       conn =
 686         conn
 687         |> assign(:user, user)
 688         |> post("/api/v1/notifications/clear")
 689
 690       assert %{} = json_response(conn, 200)
 691
 692       conn =
 693         build_conn()
 694         |> assign(:user, user)
 695         |> get("/api/v1/notifications")
 696
 697       assert all = json_response(conn, 200)
 698       assert all == []
 699     end
 700   end
 701
 702   describe "reblogging" do
 703     test "reblogs and returns the reblogged status", %{conn: conn} do
 704       activity = insert(:note_activity)
 705       user = insert(:user)
 706
 707       conn =
 708         conn
 709         |> assign(:user, user)
 710         |> post("/api/v1/statuses/#{activity.id}/reblog")
 711
 712       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 713                json_response(conn, 200)
 714
 715       assert to_string(activity.id) == id
 716     end
 717   end
 718
 719   describe "unreblogging" do
 720     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 721       activity = insert(:note_activity)
 722       user = insert(:user)
 723
 724       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 725
 726       conn =
 727         conn
 728         |> assign(:user, user)
 729         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 730
 731       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 732
 733       assert to_string(activity.id) == id
 734     end
 735   end
 736
 737   describe "favoriting" do
 738     test "favs a status and returns it", %{conn: conn} do
 739       activity = insert(:note_activity)
 740       user = insert(:user)
 741
 742       conn =
 743         conn
 744         |> assign(:user, user)
 745         |> post("/api/v1/statuses/#{activity.id}/favourite")
 746
 747       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 748                json_response(conn, 200)
 749
 750       assert to_string(activity.id) == id
 751     end
 752
 753     test "returns 500 for a wrong id", %{conn: conn} do
 754       user = insert(:user)
 755
 756       resp =
 757         conn
 758         |> assign(:user, user)
 759         |> post("/api/v1/statuses/1/favourite")
 760         |> json_response(500)
 761
 762       assert resp == "Something went wrong"
 763     end
 764   end
 765
 766   describe "unfavoriting" do
 767     test "unfavorites a status and returns it", %{conn: conn} do
 768       activity = insert(:note_activity)
 769       user = insert(:user)
 770
 771       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 772
 773       conn =
 774         conn
 775         |> assign(:user, user)
 776         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 777
 778       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 779                json_response(conn, 200)
 780
 781       assert to_string(activity.id) == id
 782     end
 783   end
 784
 785   describe "user timelines" do
 786     test "gets a users statuses", %{conn: conn} do
 787       user_one = insert(:user)
 788       user_two = insert(:user)
 789       user_three = insert(:user)
 790
 791       {:ok, user_three} = User.follow(user_three, user_one)
 792
 793       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 794
 795       {:ok, direct_activity} =
 796         CommonAPI.post(user_one, %{
 797           "status" => "Hi, @#{user_two.nickname}.",
 798           "visibility" => "direct"
 799         })
 800
 801       {:ok, private_activity} =
 802         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 803
 804       resp =
 805         conn
 806         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 807
 808       assert [%{"id" => id}] = json_response(resp, 200)
 809       assert id == to_string(activity.id)
 810
 811       resp =
 812         conn
 813         |> assign(:user, user_two)
 814         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 815
 816       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 817       assert id_one == to_string(direct_activity.id)
 818       assert id_two == to_string(activity.id)
 819
 820       resp =
 821         conn
 822         |> assign(:user, user_three)
 823         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 824
 825       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 826       assert id_one == to_string(private_activity.id)
 827       assert id_two == to_string(activity.id)
 828     end
 829
 830     test "unimplemented pinned statuses feature", %{conn: conn} do
 831       note = insert(:note_activity)
 832       user = User.get_by_ap_id(note.data["actor"])
 833
 834       conn =
 835         conn
 836         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 837
 838       assert json_response(conn, 200) == []
 839     end
 840
 841     test "gets an users media", %{conn: conn} do
 842       note = insert(:note_activity)
 843       user = User.get_by_ap_id(note.data["actor"])
 844
 845       file = %Plug.Upload{
 846         content_type: "image/jpg",
 847         path: Path.absname("test/fixtures/image.jpg"),
 848         filename: "an_image.jpg"
 849       }
 850
 851       media =
 852         TwitterAPI.upload(file, user, "json")
 853         |> Poison.decode!()
 854
 855       {:ok, image_post} =
 856         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 857
 858       conn =
 859         conn
 860         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 861
 862       assert [%{"id" => id}] = json_response(conn, 200)
 863       assert id == to_string(image_post.id)
 864
 865       conn =
 866         build_conn()
 867         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 868
 869       assert [%{"id" => id}] = json_response(conn, 200)
 870       assert id == to_string(image_post.id)
 871     end
 872
 873     test "gets a user's statuses without reblogs", %{conn: conn} do
 874       user = insert(:user)
 875       {:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
 876       {:ok, _, _} = CommonAPI.repeat(post.id, user)
 877
 878       conn =
 879         conn
 880         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})
 881
 882       assert [%{"id" => id}] = json_response(conn, 200)
 883       assert id == to_string(post.id)
 884
 885       conn =
 886         conn
 887         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})
 888
 889       assert [%{"id" => id}] = json_response(conn, 200)
 890       assert id == to_string(post.id)
 891     end
 892   end
 893
 894   describe "user relationships" do
 895     test "returns the relationships for the current user", %{conn: conn} do
 896       user = insert(:user)
 897       other_user = insert(:user)
 898       {:ok, user} = User.follow(user, other_user)
 899
 900       conn =
 901         conn
 902         |> assign(:user, user)
 903         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 904
 905       assert [relationship] = json_response(conn, 200)
 906
 907       assert to_string(other_user.id) == relationship["id"]
 908     end
 909   end
 910
 911   describe "locked accounts" do
 912     test "/api/v1/follow_requests works" do
 913       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 914       other_user = insert(:user)
 915
 916       {:ok, _activity} = ActivityPub.follow(other_user, user)
 917
 918       user = Repo.get(User, user.id)
 919       other_user = Repo.get(User, other_user.id)
 920
 921       assert User.following?(other_user, user) == false
 922
 923       conn =
 924         build_conn()
 925         |> assign(:user, user)
 926         |> get("/api/v1/follow_requests")
 927
 928       assert [relationship] = json_response(conn, 200)
 929       assert to_string(other_user.id) == relationship["id"]
 930     end
 931
 932     test "/api/v1/follow_requests/:id/authorize works" do
 933       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 934       other_user = insert(:user)
 935
 936       {:ok, _activity} = ActivityPub.follow(other_user, user)
 937
 938       user = Repo.get(User, user.id)
 939       other_user = Repo.get(User, other_user.id)
 940
 941       assert User.following?(other_user, user) == false
 942
 943       conn =
 944         build_conn()
 945         |> assign(:user, user)
 946         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 947
 948       assert relationship = json_response(conn, 200)
 949       assert to_string(other_user.id) == relationship["id"]
 950
 951       user = Repo.get(User, user.id)
 952       other_user = Repo.get(User, other_user.id)
 953
 954       assert User.following?(other_user, user) == true
 955     end
 956
 957     test "verify_credentials", %{conn: conn} do
 958       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
 959
 960       conn =
 961         conn
 962         |> assign(:user, user)
 963         |> get("/api/v1/accounts/verify_credentials")
 964
 965       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 966       assert id == to_string(user.id)
 967     end
 968
 969     test "/api/v1/follow_requests/:id/reject works" do
 970       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 971       other_user = insert(:user)
 972
 973       {:ok, _activity} = ActivityPub.follow(other_user, user)
 974
 975       conn =
 976         build_conn()
 977         |> assign(:user, user)
 978         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 979
 980       assert relationship = json_response(conn, 200)
 981       assert to_string(other_user.id) == relationship["id"]
 982
 983       user = Repo.get(User, user.id)
 984       other_user = Repo.get(User, other_user.id)
 985
 986       assert User.following?(other_user, user) == false
 987     end
 988   end
 989
 990   test "account fetching", %{conn: conn} do
 991     user = insert(:user)
 992
 993     conn =
 994       conn
 995       |> get("/api/v1/accounts/#{user.id}")
 996
 997     assert %{"id" => id} = json_response(conn, 200)
 998     assert id == to_string(user.id)
 999
1000     conn =
1001       build_conn()
1002       |> get("/api/v1/accounts/-1")
1003
1004     assert %{"error" => "Can't find user"} = json_response(conn, 404)
1005   end
1006
1007   test "media upload", %{conn: conn} do
1008     file = %Plug.Upload{
1009       content_type: "image/jpg",
1010       path: Path.absname("test/fixtures/image.jpg"),
1011       filename: "an_image.jpg"
1012     }
1013
1014     desc = "Description of the image"
1015
1016     user = insert(:user)
1017
1018     conn =
1019       conn
1020       |> assign(:user, user)
1021       |> post("/api/v1/media", %{"file" => file, "description" => desc})
1022
1023     assert media = json_response(conn, 200)
1024
1025     assert media["type"] == "image"
1026     assert media["description"] == desc
1027     assert media["id"]
1028
1029     object = Repo.get(Object, media["id"])
1030     assert object.data["actor"] == User.ap_id(user)
1031   end
1032
1033   test "hashtag timeline", %{conn: conn} do
1034     following = insert(:user)
1035
1036     capture_log(fn ->
1037       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1038
1039       {:ok, [_activity]} =
1040         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1041
1042       nconn =
1043         conn
1044         |> get("/api/v1/timelines/tag/2hu")
1045
1046       assert [%{"id" => id}] = json_response(nconn, 200)
1047
1048       assert id == to_string(activity.id)
1049
1050       # works for different capitalization too
1051       nconn =
1052         conn
1053         |> get("/api/v1/timelines/tag/2HU")
1054
1055       assert [%{"id" => id}] = json_response(nconn, 200)
1056
1057       assert id == to_string(activity.id)
1058     end)
1059   end
1060
1061   test "multi-hashtag timeline", %{conn: conn} do
1062     user = insert(:user)
1063
1064     {:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
1065     {:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
1066     {:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})
1067
1068     any_test =
1069       conn
1070       |> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})
1071
1072     [status_none, status_test1, status_test] = json_response(any_test, 200)
1073
1074     assert to_string(activity_test.id) == status_test["id"]
1075     assert to_string(activity_test1.id) == status_test1["id"]
1076     assert to_string(activity_none.id) == status_none["id"]
1077
1078     restricted_test =
1079       conn
1080       |> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})
1081
1082     assert [status_test1] == json_response(restricted_test, 200)
1083
1084     all_test = conn |> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})
1085
1086     assert [status_none] == json_response(all_test, 200)
1087   end
1088
1089   test "getting followers", %{conn: conn} do
1090     user = insert(:user)
1091     other_user = insert(:user)
1092     {:ok, user} = User.follow(user, other_user)
1093
1094     conn =
1095       conn
1096       |> get("/api/v1/accounts/#{other_user.id}/followers")
1097
1098     assert [%{"id" => id}] = json_response(conn, 200)
1099     assert id == to_string(user.id)
1100   end
1101
1102   test "getting followers, hide_network", %{conn: conn} do
1103     user = insert(:user)
1104     other_user = insert(:user, %{info: %{hide_network: true}})
1105     {:ok, _user} = User.follow(user, other_user)
1106
1107     conn =
1108       conn
1109       |> get("/api/v1/accounts/#{other_user.id}/followers")
1110
1111     assert [] == json_response(conn, 200)
1112   end
1113
1114   test "getting followers, hide_network, same user requesting", %{conn: conn} do
1115     user = insert(:user)
1116     other_user = insert(:user, %{info: %{hide_network: true}})
1117     {:ok, _user} = User.follow(user, other_user)
1118
1119     conn =
1120       conn
1121       |> assign(:user, other_user)
1122       |> get("/api/v1/accounts/#{other_user.id}/followers")
1123
1124     refute [] == json_response(conn, 200)
1125   end
1126
1127   test "getting following", %{conn: conn} do
1128     user = insert(:user)
1129     other_user = insert(:user)
1130     {:ok, user} = User.follow(user, other_user)
1131
1132     conn =
1133       conn
1134       |> get("/api/v1/accounts/#{user.id}/following")
1135
1136     assert [%{"id" => id}] = json_response(conn, 200)
1137     assert id == to_string(other_user.id)
1138   end
1139
1140   test "getting following, hide_network", %{conn: conn} do
1141     user = insert(:user, %{info: %{hide_network: true}})
1142     other_user = insert(:user)
1143     {:ok, user} = User.follow(user, other_user)
1144
1145     conn =
1146       conn
1147       |> get("/api/v1/accounts/#{user.id}/following")
1148
1149     assert [] == json_response(conn, 200)
1150   end
1151
1152   test "getting following, hide_network, same user requesting", %{conn: conn} do
1153     user = insert(:user, %{info: %{hide_network: true}})
1154     other_user = insert(:user)
1155     {:ok, user} = User.follow(user, other_user)
1156
1157     conn =
1158       conn
1159       |> assign(:user, user)
1160       |> get("/api/v1/accounts/#{user.id}/following")
1161
1162     refute [] == json_response(conn, 200)
1163   end
1164
1165   test "following / unfollowing a user", %{conn: conn} do
1166     user = insert(:user)
1167     other_user = insert(:user)
1168
1169     conn =
1170       conn
1171       |> assign(:user, user)
1172       |> post("/api/v1/accounts/#{other_user.id}/follow")
1173
1174     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1175
1176     user = Repo.get(User, user.id)
1177
1178     conn =
1179       build_conn()
1180       |> assign(:user, user)
1181       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1182
1183     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1184
1185     user = Repo.get(User, user.id)
1186
1187     conn =
1188       build_conn()
1189       |> assign(:user, user)
1190       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1191
1192     assert %{"id" => id} = json_response(conn, 200)
1193     assert id == to_string(other_user.id)
1194   end
1195
1196   test "blocking / unblocking a user", %{conn: conn} do
1197     user = insert(:user)
1198     other_user = insert(:user)
1199
1200     conn =
1201       conn
1202       |> assign(:user, user)
1203       |> post("/api/v1/accounts/#{other_user.id}/block")
1204
1205     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1206
1207     user = Repo.get(User, user.id)
1208
1209     conn =
1210       build_conn()
1211       |> assign(:user, user)
1212       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1213
1214     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1215   end
1216
1217   test "getting a list of blocks", %{conn: conn} do
1218     user = insert(:user)
1219     other_user = insert(:user)
1220
1221     {:ok, user} = User.block(user, other_user)
1222
1223     conn =
1224       conn
1225       |> assign(:user, user)
1226       |> get("/api/v1/blocks")
1227
1228     other_user_id = to_string(other_user.id)
1229     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1230   end
1231
1232   test "blocking / unblocking a domain", %{conn: conn} do
1233     user = insert(:user)
1234     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1235
1236     conn =
1237       conn
1238       |> assign(:user, user)
1239       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1240
1241     assert %{} = json_response(conn, 200)
1242     user = User.get_cached_by_ap_id(user.ap_id)
1243     assert User.blocks?(user, other_user)
1244
1245     conn =
1246       build_conn()
1247       |> assign(:user, user)
1248       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1249
1250     assert %{} = json_response(conn, 200)
1251     user = User.get_cached_by_ap_id(user.ap_id)
1252     refute User.blocks?(user, other_user)
1253   end
1254
1255   test "getting a list of domain blocks", %{conn: conn} do
1256     user = insert(:user)
1257
1258     {:ok, user} = User.block_domain(user, "bad.site")
1259     {:ok, user} = User.block_domain(user, "even.worse.site")
1260
1261     conn =
1262       conn
1263       |> assign(:user, user)
1264       |> get("/api/v1/domain_blocks")
1265
1266     domain_blocks = json_response(conn, 200)
1267
1268     assert "bad.site" in domain_blocks
1269     assert "even.worse.site" in domain_blocks
1270   end
1271
1272   test "unimplemented mute endpoints" do
1273     user = insert(:user)
1274     other_user = insert(:user)
1275
1276     ["mute", "unmute"]
1277     |> Enum.each(fn endpoint ->
1278       conn =
1279         build_conn()
1280         |> assign(:user, user)
1281         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1282
1283       assert %{"id" => id} = json_response(conn, 200)
1284       assert id == to_string(other_user.id)
1285     end)
1286   end
1287
1288   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1289     user = insert(:user)
1290
1291     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1292     |> Enum.each(fn endpoint ->
1293       conn =
1294         build_conn()
1295         |> assign(:user, user)
1296         |> get("/api/v1/#{endpoint}")
1297
1298       assert [] = json_response(conn, 200)
1299     end)
1300   end
1301
1302   test "account search", %{conn: conn} do
1303     user = insert(:user)
1304     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1305     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1306
1307     results =
1308       conn
1309       |> assign(:user, user)
1310       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1311       |> json_response(200)
1312
1313     result_ids = for result <- results, do: result["acct"]
1314
1315     assert user_two.nickname in result_ids
1316     assert user_three.nickname in result_ids
1317
1318     results =
1319       conn
1320       |> assign(:user, user)
1321       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1322       |> json_response(200)
1323
1324     result_ids = for result <- results, do: result["acct"]
1325
1326     assert user_three.nickname in result_ids
1327   end
1328
1329   test "search", %{conn: conn} do
1330     user = insert(:user)
1331     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1332     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1333
1334     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1335
1336     {:ok, _activity} =
1337       CommonAPI.post(user, %{
1338         "status" => "This is about 2hu, but private",
1339         "visibility" => "private"
1340       })
1341
1342     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1343
1344     conn =
1345       conn
1346       |> get("/api/v1/search", %{"q" => "2hu"})
1347
1348     assert results = json_response(conn, 200)
1349
1350     [account | _] = results["accounts"]
1351     assert account["id"] == to_string(user_three.id)
1352
1353     assert results["hashtags"] == []
1354
1355     [status] = results["statuses"]
1356     assert status["id"] == to_string(activity.id)
1357   end
1358
1359   test "search fetches remote statuses", %{conn: conn} do
1360     capture_log(fn ->
1361       conn =
1362         conn
1363         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1364
1365       assert results = json_response(conn, 200)
1366
1367       [status] = results["statuses"]
1368       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1369     end)
1370   end
1371
1372   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1373     {:ok, activity} =
1374       CommonAPI.post(insert(:user), %{
1375         "status" => "This is about 2hu, but private",
1376         "visibility" => "private"
1377       })
1378
1379     capture_log(fn ->
1380       conn =
1381         conn
1382         |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1383
1384       assert results = json_response(conn, 200)
1385
1386       [] = results["statuses"]
1387     end)
1388   end
1389
1390   test "search fetches remote accounts", %{conn: conn} do
1391     conn =
1392       conn
1393       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1394
1395     assert results = json_response(conn, 200)
1396     [account] = results["accounts"]
1397     assert account["acct"] == "shp@social.heldscal.la"
1398   end
1399
1400   test "returns the favorites of a user", %{conn: conn} do
1401     user = insert(:user)
1402     other_user = insert(:user)
1403
1404     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1405     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1406
1407     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1408
1409     first_conn =
1410       conn
1411       |> assign(:user, user)
1412       |> get("/api/v1/favourites")
1413
1414     assert [status] = json_response(first_conn, 200)
1415     assert status["id"] == to_string(activity.id)
1416
1417     assert [{"link", _link_header}] =
1418              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1419
1420     # Honours query params
1421     {:ok, second_activity} =
1422       CommonAPI.post(other_user, %{
1423         "status" =>
1424           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1425       })
1426
1427     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1428
1429     last_like = status["id"]
1430
1431     second_conn =
1432       conn
1433       |> assign(:user, user)
1434       |> get("/api/v1/favourites?since_id=#{last_like}")
1435
1436     assert [second_status] = json_response(second_conn, 200)
1437     assert second_status["id"] == to_string(second_activity.id)
1438
1439     third_conn =
1440       conn
1441       |> assign(:user, user)
1442       |> get("/api/v1/favourites?limit=0")
1443
1444     assert [] = json_response(third_conn, 200)
1445   end
1446
1447   describe "updating credentials" do
1448     test "updates the user's bio", %{conn: conn} do
1449       user = insert(:user)
1450       user2 = insert(:user)
1451
1452       conn =
1453         conn
1454         |> assign(:user, user)
1455         |> patch("/api/v1/accounts/update_credentials", %{
1456           "note" => "I drink #cofe with @#{user2.nickname}"
1457         })
1458
1459       assert user = json_response(conn, 200)
1460
1461       assert user["note"] ==
1462                "I drink <a class=\"hashtag\" data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span class=\"h-card\"><a data-user=\"#{
1463                  user2.id
1464                }\" class=\"u-url mention\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1465     end
1466
1467     test "updates the user's locking status", %{conn: conn} do
1468       user = insert(:user)
1469
1470       conn =
1471         conn
1472         |> assign(:user, user)
1473         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1474
1475       assert user = json_response(conn, 200)
1476       assert user["locked"] == true
1477     end
1478
1479     test "updates the user's name", %{conn: conn} do
1480       user = insert(:user)
1481
1482       conn =
1483         conn
1484         |> assign(:user, user)
1485         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1486
1487       assert user = json_response(conn, 200)
1488       assert user["display_name"] == "markorepairs"
1489     end
1490
1491     test "updates the user's avatar", %{conn: conn} do
1492       user = insert(:user)
1493
1494       new_avatar = %Plug.Upload{
1495         content_type: "image/jpg",
1496         path: Path.absname("test/fixtures/image.jpg"),
1497         filename: "an_image.jpg"
1498       }
1499
1500       conn =
1501         conn
1502         |> assign(:user, user)
1503         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1504
1505       assert user_response = json_response(conn, 200)
1506       assert user_response["avatar"] != User.avatar_url(user)
1507     end
1508
1509     test "updates the user's banner", %{conn: conn} do
1510       user = insert(:user)
1511
1512       new_header = %Plug.Upload{
1513         content_type: "image/jpg",
1514         path: Path.absname("test/fixtures/image.jpg"),
1515         filename: "an_image.jpg"
1516       }
1517
1518       conn =
1519         conn
1520         |> assign(:user, user)
1521         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1522
1523       assert user_response = json_response(conn, 200)
1524       assert user_response["header"] != User.banner_url(user)
1525     end
1526   end
1527
1528   test "get instance information", %{conn: conn} do
1529     user = insert(:user, %{local: true})
1530
1531     user2 = insert(:user, %{local: true})
1532     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
1533
1534     insert(:user, %{local: false, nickname: "u@peer1.com"})
1535     insert(:user, %{local: false, nickname: "u@peer2.com"})
1536
1537     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1538
1539     # Stats should count users with missing or nil `info.deactivated` value
1540     user = Repo.get(User, user.id)
1541     info_change = Changeset.change(user.info, %{deactivated: nil})
1542
1543     {:ok, _user} =
1544       user
1545       |> Changeset.change()
1546       |> Changeset.put_embed(:info, info_change)
1547       |> User.update_and_set_cache()
1548
1549     Pleroma.Stats.update_stats()
1550
1551     conn = get(conn, "/api/v1/instance")
1552
1553     assert result = json_response(conn, 200)
1554
1555     stats = result["stats"]
1556
1557     assert stats
1558     assert stats["user_count"] == 1
1559     assert stats["status_count"] == 1
1560     assert stats["domain_count"] == 2
1561   end
1562
1563   test "get peers", %{conn: conn} do
1564     insert(:user, %{local: false, nickname: "u@peer1.com"})
1565     insert(:user, %{local: false, nickname: "u@peer2.com"})
1566
1567     Pleroma.Stats.update_stats()
1568
1569     conn = get(conn, "/api/v1/instance/peers")
1570
1571     assert result = json_response(conn, 200)
1572
1573     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
1574   end
1575
1576   test "put settings", %{conn: conn} do
1577     user = insert(:user)
1578
1579     conn =
1580       conn
1581       |> assign(:user, user)
1582       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1583
1584     assert _result = json_response(conn, 200)
1585
1586     user = User.get_cached_by_ap_id(user.ap_id)
1587     assert user.info.settings == %{"programming" => "socks"}
1588   end
1589
1590   describe "pinned statuses" do
1591     setup do
1592       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
1593
1594       user = insert(:user)
1595       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
1596
1597       [user: user, activity: activity]
1598     end
1599
1600     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
1601       {:ok, _} = CommonAPI.pin(activity.id, user)
1602
1603       result =
1604         conn
1605         |> assign(:user, user)
1606         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1607         |> json_response(200)
1608
1609       id_str = to_string(activity.id)
1610
1611       assert [%{"id" => ^id_str, "pinned" => true}] = result
1612     end
1613
1614     test "pin status", %{conn: conn, user: user, activity: activity} do
1615       id_str = to_string(activity.id)
1616
1617       assert %{"id" => ^id_str, "pinned" => true} =
1618                conn
1619                |> assign(:user, user)
1620                |> post("/api/v1/statuses/#{activity.id}/pin")
1621                |> json_response(200)
1622
1623       assert [%{"id" => ^id_str, "pinned" => true}] =
1624                conn
1625                |> assign(:user, user)
1626                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1627                |> json_response(200)
1628     end
1629
1630     test "unpin status", %{conn: conn, user: user, activity: activity} do
1631       {:ok, _} = CommonAPI.pin(activity.id, user)
1632
1633       id_str = to_string(activity.id)
1634       user = refresh_record(user)
1635
1636       assert %{"id" => ^id_str, "pinned" => false} =
1637                conn
1638                |> assign(:user, user)
1639                |> post("/api/v1/statuses/#{activity.id}/unpin")
1640                |> json_response(200)
1641
1642       assert [] =
1643                conn
1644                |> assign(:user, user)
1645                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1646                |> json_response(200)
1647     end
1648
1649     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
1650       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1651
1652       id_str_one = to_string(activity_one.id)
1653
1654       assert %{"id" => ^id_str_one, "pinned" => true} =
1655                conn
1656                |> assign(:user, user)
1657                |> post("/api/v1/statuses/#{id_str_one}/pin")
1658                |> json_response(200)
1659
1660       user = refresh_record(user)
1661
1662       assert %{"error" => "You have already pinned the maximum number of statuses"} =
1663                conn
1664                |> assign(:user, user)
1665                |> post("/api/v1/statuses/#{activity_two.id}/pin")
1666                |> json_response(400)
1667     end
1668
1669     test "Status rich-media Card", %{conn: conn, user: user} do
1670       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})
1671
1672       response =
1673         conn
1674         |> get("/api/v1/statuses/#{activity.id}/card")
1675         |> json_response(200)
1676
1677       assert response == %{
1678                "image" => "http://ia.media-imdb.com/images/rock.jpg",
1679                "provider_name" => "www.imdb.com",
1680                "provider_url" => "http://www.imdb.com",
1681                "title" => "The Rock",
1682                "type" => "link",
1683                "url" => "http://www.imdb.com/title/tt0117500/",
1684                "description" => nil,
1685                "pleroma" => %{
1686                  "opengraph" => %{
1687                    "image" => "http://ia.media-imdb.com/images/rock.jpg",
1688                    "title" => "The Rock",
1689                    "type" => "video.movie",
1690                    "url" => "http://www.imdb.com/title/tt0117500/"
1691                  }
1692                }
1693              }
1694     end
1695   end
1696
1697   test "bookmarks" do
1698     user = insert(:user)
1699     for_user = insert(:user)
1700
1701     {:ok, activity1} =
1702       CommonAPI.post(user, %{
1703         "status" => "heweoo?"
1704       })
1705
1706     {:ok, activity2} =
1707       CommonAPI.post(user, %{
1708         "status" => "heweoo!"
1709       })
1710
1711     response1 =
1712       build_conn()
1713       |> assign(:user, for_user)
1714       |> post("/api/v1/statuses/#{activity1.id}/bookmark")
1715
1716     assert json_response(response1, 200)["bookmarked"] == true
1717
1718     response2 =
1719       build_conn()
1720       |> assign(:user, for_user)
1721       |> post("/api/v1/statuses/#{activity2.id}/bookmark")
1722
1723     assert json_response(response2, 200)["bookmarked"] == true
1724
1725     bookmarks =
1726       build_conn()
1727       |> assign(:user, for_user)
1728       |> get("/api/v1/bookmarks")
1729
1730     assert [json_response(response2, 200), json_response(response1, 200)] ==
1731              json_response(bookmarks, 200)
1732
1733     response1 =
1734       build_conn()
1735       |> assign(:user, for_user)
1736       |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
1737
1738     assert json_response(response1, 200)["bookmarked"] == false
1739
1740     bookmarks =
1741       build_conn()
1742       |> assign(:user, for_user)
1743       |> get("/api/v1/bookmarks")
1744
1745     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
1746   end
1747 end