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