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