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: %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       assert user.info.follow_request_count == 1
 950
 951       conn =
 952         build_conn()
 953         |> assign(:user, user)
 954         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 955
 956       assert relationship = json_response(conn, 200)
 957       assert to_string(other_user.id) == relationship["id"]
 958
 959       user = Repo.get(User, user.id)
 960       other_user = Repo.get(User, other_user.id)
 961
 962       assert User.following?(other_user, user) == true
 963       assert user.info.follow_request_count == 0
 964     end
 965
 966     test "verify_credentials", %{conn: conn} do
 967       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
 968
 969       conn =
 970         conn
 971         |> assign(:user, user)
 972         |> get("/api/v1/accounts/verify_credentials")
 973
 974       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 975       assert id == to_string(user.id)
 976     end
 977
 978     test "/api/v1/follow_requests/:id/reject works" do
 979       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 980       other_user = insert(:user)
 981
 982       {:ok, _activity} = ActivityPub.follow(other_user, user)
 983
 984       user = Repo.get(User, user.id)
 985       assert user.info.follow_request_count == 1
 986
 987       conn =
 988         build_conn()
 989         |> assign(:user, user)
 990         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 991
 992       assert relationship = json_response(conn, 200)
 993       assert to_string(other_user.id) == relationship["id"]
 994
 995       user = Repo.get(User, user.id)
 996       other_user = Repo.get(User, other_user.id)
 997
 998       assert User.following?(other_user, user) == false
 999       assert user.info.follow_request_count == 0
1000     end
1001   end
1002
1003   test "account fetching", %{conn: conn} do
1004     user = insert(:user)
1005
1006     conn =
1007       conn
1008       |> get("/api/v1/accounts/#{user.id}")
1009
1010     assert %{"id" => id} = json_response(conn, 200)
1011     assert id == to_string(user.id)
1012
1013     conn =
1014       build_conn()
1015       |> get("/api/v1/accounts/-1")
1016
1017     assert %{"error" => "Can't find user"} = json_response(conn, 404)
1018   end
1019
1020   test "media upload", %{conn: conn} do
1021     file = %Plug.Upload{
1022       content_type: "image/jpg",
1023       path: Path.absname("test/fixtures/image.jpg"),
1024       filename: "an_image.jpg"
1025     }
1026
1027     desc = "Description of the image"
1028
1029     user = insert(:user)
1030
1031     conn =
1032       conn
1033       |> assign(:user, user)
1034       |> post("/api/v1/media", %{"file" => file, "description" => desc})
1035
1036     assert media = json_response(conn, 200)
1037
1038     assert media["type"] == "image"
1039     assert media["description"] == desc
1040     assert media["id"]
1041
1042     object = Repo.get(Object, media["id"])
1043     assert object.data["actor"] == User.ap_id(user)
1044   end
1045
1046   test "hashtag timeline", %{conn: conn} do
1047     following = insert(:user)
1048
1049     capture_log(fn ->
1050       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1051
1052       {:ok, [_activity]} =
1053         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1054
1055       nconn =
1056         conn
1057         |> get("/api/v1/timelines/tag/2hu")
1058
1059       assert [%{"id" => id}] = json_response(nconn, 200)
1060
1061       assert id == to_string(activity.id)
1062
1063       # works for different capitalization too
1064       nconn =
1065         conn
1066         |> get("/api/v1/timelines/tag/2HU")
1067
1068       assert [%{"id" => id}] = json_response(nconn, 200)
1069
1070       assert id == to_string(activity.id)
1071     end)
1072   end
1073
1074   test "multi-hashtag timeline", %{conn: conn} do
1075     user = insert(:user)
1076
1077     {:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
1078     {:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
1079     {:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})
1080
1081     any_test =
1082       conn
1083       |> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})
1084
1085     [status_none, status_test1, status_test] = json_response(any_test, 200)
1086
1087     assert to_string(activity_test.id) == status_test["id"]
1088     assert to_string(activity_test1.id) == status_test1["id"]
1089     assert to_string(activity_none.id) == status_none["id"]
1090
1091     restricted_test =
1092       conn
1093       |> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})
1094
1095     assert [status_test1] == json_response(restricted_test, 200)
1096
1097     all_test = conn |> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})
1098
1099     assert [status_none] == json_response(all_test, 200)
1100   end
1101
1102   test "getting followers", %{conn: conn} do
1103     user = insert(:user)
1104     other_user = insert(:user)
1105     {:ok, user} = User.follow(user, other_user)
1106
1107     conn =
1108       conn
1109       |> get("/api/v1/accounts/#{other_user.id}/followers")
1110
1111     assert [%{"id" => id}] = json_response(conn, 200)
1112     assert id == to_string(user.id)
1113   end
1114
1115   test "getting followers, hide_followers", %{conn: conn} do
1116     user = insert(:user)
1117     other_user = insert(:user, %{info: %{hide_followers: true}})
1118     {:ok, _user} = User.follow(user, other_user)
1119
1120     conn =
1121       conn
1122       |> get("/api/v1/accounts/#{other_user.id}/followers")
1123
1124     assert [] == json_response(conn, 200)
1125   end
1126
1127   test "getting followers, hide_followers, same user requesting", %{conn: conn} do
1128     user = insert(:user)
1129     other_user = insert(:user, %{info: %{hide_followers: true}})
1130     {:ok, _user} = User.follow(user, other_user)
1131
1132     conn =
1133       conn
1134       |> assign(:user, other_user)
1135       |> get("/api/v1/accounts/#{other_user.id}/followers")
1136
1137     refute [] == json_response(conn, 200)
1138   end
1139
1140   test "getting following", %{conn: conn} do
1141     user = insert(:user)
1142     other_user = insert(:user)
1143     {:ok, user} = User.follow(user, other_user)
1144
1145     conn =
1146       conn
1147       |> get("/api/v1/accounts/#{user.id}/following")
1148
1149     assert [%{"id" => id}] = json_response(conn, 200)
1150     assert id == to_string(other_user.id)
1151   end
1152
1153   test "getting following, hide_follows", %{conn: conn} do
1154     user = insert(:user, %{info: %{hide_follows: true}})
1155     other_user = insert(:user)
1156     {:ok, user} = User.follow(user, other_user)
1157
1158     conn =
1159       conn
1160       |> get("/api/v1/accounts/#{user.id}/following")
1161
1162     assert [] == json_response(conn, 200)
1163   end
1164
1165   test "getting following, hide_follows, same user requesting", %{conn: conn} do
1166     user = insert(:user, %{info: %{hide_follows: true}})
1167     other_user = insert(:user)
1168     {:ok, user} = User.follow(user, other_user)
1169
1170     conn =
1171       conn
1172       |> assign(:user, user)
1173       |> get("/api/v1/accounts/#{user.id}/following")
1174
1175     refute [] == json_response(conn, 200)
1176   end
1177
1178   test "following / unfollowing a user", %{conn: conn} do
1179     user = insert(:user)
1180     other_user = insert(:user)
1181
1182     conn =
1183       conn
1184       |> assign(:user, user)
1185       |> post("/api/v1/accounts/#{other_user.id}/follow")
1186
1187     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1188
1189     user = Repo.get(User, user.id)
1190
1191     conn =
1192       build_conn()
1193       |> assign(:user, user)
1194       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1195
1196     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1197
1198     user = Repo.get(User, user.id)
1199
1200     conn =
1201       build_conn()
1202       |> assign(:user, user)
1203       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1204
1205     assert %{"id" => id} = json_response(conn, 200)
1206     assert id == to_string(other_user.id)
1207   end
1208
1209   test "blocking / unblocking a user", %{conn: conn} do
1210     user = insert(:user)
1211     other_user = insert(:user)
1212
1213     conn =
1214       conn
1215       |> assign(:user, user)
1216       |> post("/api/v1/accounts/#{other_user.id}/block")
1217
1218     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1219
1220     user = Repo.get(User, user.id)
1221
1222     conn =
1223       build_conn()
1224       |> assign(:user, user)
1225       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1226
1227     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1228   end
1229
1230   test "getting a list of blocks", %{conn: conn} do
1231     user = insert(:user)
1232     other_user = insert(:user)
1233
1234     {:ok, user} = User.block(user, other_user)
1235
1236     conn =
1237       conn
1238       |> assign(:user, user)
1239       |> get("/api/v1/blocks")
1240
1241     other_user_id = to_string(other_user.id)
1242     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1243   end
1244
1245   test "blocking / unblocking a domain", %{conn: conn} do
1246     user = insert(:user)
1247     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1248
1249     conn =
1250       conn
1251       |> assign(:user, user)
1252       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1253
1254     assert %{} = json_response(conn, 200)
1255     user = User.get_cached_by_ap_id(user.ap_id)
1256     assert User.blocks?(user, other_user)
1257
1258     conn =
1259       build_conn()
1260       |> assign(:user, user)
1261       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1262
1263     assert %{} = json_response(conn, 200)
1264     user = User.get_cached_by_ap_id(user.ap_id)
1265     refute User.blocks?(user, other_user)
1266   end
1267
1268   test "getting a list of domain blocks", %{conn: conn} do
1269     user = insert(:user)
1270
1271     {:ok, user} = User.block_domain(user, "bad.site")
1272     {:ok, user} = User.block_domain(user, "even.worse.site")
1273
1274     conn =
1275       conn
1276       |> assign(:user, user)
1277       |> get("/api/v1/domain_blocks")
1278
1279     domain_blocks = json_response(conn, 200)
1280
1281     assert "bad.site" in domain_blocks
1282     assert "even.worse.site" in domain_blocks
1283   end
1284
1285   test "unimplemented mute endpoints" do
1286     user = insert(:user)
1287     other_user = insert(:user)
1288
1289     ["mute", "unmute"]
1290     |> Enum.each(fn endpoint ->
1291       conn =
1292         build_conn()
1293         |> assign(:user, user)
1294         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1295
1296       assert %{"id" => id} = json_response(conn, 200)
1297       assert id == to_string(other_user.id)
1298     end)
1299   end
1300
1301   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1302     user = insert(:user)
1303
1304     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1305     |> Enum.each(fn endpoint ->
1306       conn =
1307         build_conn()
1308         |> assign(:user, user)
1309         |> get("/api/v1/#{endpoint}")
1310
1311       assert [] = json_response(conn, 200)
1312     end)
1313   end
1314
1315   test "account search", %{conn: conn} do
1316     user = insert(:user)
1317     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1318     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1319
1320     results =
1321       conn
1322       |> assign(:user, user)
1323       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1324       |> json_response(200)
1325
1326     result_ids = for result <- results, do: result["acct"]
1327
1328     assert user_two.nickname in result_ids
1329     assert user_three.nickname in result_ids
1330
1331     results =
1332       conn
1333       |> assign(:user, user)
1334       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1335       |> json_response(200)
1336
1337     result_ids = for result <- results, do: result["acct"]
1338
1339     assert user_three.nickname in result_ids
1340   end
1341
1342   test "search", %{conn: conn} do
1343     user = insert(:user)
1344     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1345     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1346
1347     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1348
1349     {:ok, _activity} =
1350       CommonAPI.post(user, %{
1351         "status" => "This is about 2hu, but private",
1352         "visibility" => "private"
1353       })
1354
1355     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1356
1357     conn =
1358       conn
1359       |> get("/api/v1/search", %{"q" => "2hu"})
1360
1361     assert results = json_response(conn, 200)
1362
1363     [account | _] = results["accounts"]
1364     assert account["id"] == to_string(user_three.id)
1365
1366     assert results["hashtags"] == []
1367
1368     [status] = results["statuses"]
1369     assert status["id"] == to_string(activity.id)
1370   end
1371
1372   test "search fetches remote statuses", %{conn: conn} do
1373     capture_log(fn ->
1374       conn =
1375         conn
1376         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1377
1378       assert results = json_response(conn, 200)
1379
1380       [status] = results["statuses"]
1381       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1382     end)
1383   end
1384
1385   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1386     {:ok, activity} =
1387       CommonAPI.post(insert(:user), %{
1388         "status" => "This is about 2hu, but private",
1389         "visibility" => "private"
1390       })
1391
1392     capture_log(fn ->
1393       conn =
1394         conn
1395         |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1396
1397       assert results = json_response(conn, 200)
1398
1399       [] = results["statuses"]
1400     end)
1401   end
1402
1403   test "search fetches remote accounts", %{conn: conn} do
1404     conn =
1405       conn
1406       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1407
1408     assert results = json_response(conn, 200)
1409     [account] = results["accounts"]
1410     assert account["acct"] == "shp@social.heldscal.la"
1411   end
1412
1413   test "returns the favorites of a user", %{conn: conn} do
1414     user = insert(:user)
1415     other_user = insert(:user)
1416
1417     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1418     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1419
1420     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1421
1422     first_conn =
1423       conn
1424       |> assign(:user, user)
1425       |> get("/api/v1/favourites")
1426
1427     assert [status] = json_response(first_conn, 200)
1428     assert status["id"] == to_string(activity.id)
1429
1430     assert [{"link", _link_header}] =
1431              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1432
1433     # Honours query params
1434     {:ok, second_activity} =
1435       CommonAPI.post(other_user, %{
1436         "status" =>
1437           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1438       })
1439
1440     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1441
1442     last_like = status["id"]
1443
1444     second_conn =
1445       conn
1446       |> assign(:user, user)
1447       |> get("/api/v1/favourites?since_id=#{last_like}")
1448
1449     assert [second_status] = json_response(second_conn, 200)
1450     assert second_status["id"] == to_string(second_activity.id)
1451
1452     third_conn =
1453       conn
1454       |> assign(:user, user)
1455       |> get("/api/v1/favourites?limit=0")
1456
1457     assert [] = json_response(third_conn, 200)
1458   end
1459
1460   describe "updating credentials" do
1461     test "updates the user's bio", %{conn: conn} do
1462       user = insert(:user)
1463       user2 = insert(:user)
1464
1465       conn =
1466         conn
1467         |> assign(:user, user)
1468         |> patch("/api/v1/accounts/update_credentials", %{
1469           "note" => "I drink #cofe with @#{user2.nickname}"
1470         })
1471
1472       assert user = json_response(conn, 200)
1473
1474       assert user["note"] ==
1475                "I drink <a class=\"hashtag\" data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span class=\"h-card\"><a data-user=\"#{
1476                  user2.id
1477                }\" class=\"u-url mention\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1478     end
1479
1480     test "updates the user's locking status", %{conn: conn} do
1481       user = insert(:user)
1482
1483       conn =
1484         conn
1485         |> assign(:user, user)
1486         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1487
1488       assert user = json_response(conn, 200)
1489       assert user["locked"] == true
1490     end
1491
1492     test "updates the user's name", %{conn: conn} do
1493       user = insert(:user)
1494
1495       conn =
1496         conn
1497         |> assign(:user, user)
1498         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1499
1500       assert user = json_response(conn, 200)
1501       assert user["display_name"] == "markorepairs"
1502     end
1503
1504     test "updates the user's avatar", %{conn: conn} do
1505       user = insert(:user)
1506
1507       new_avatar = %Plug.Upload{
1508         content_type: "image/jpg",
1509         path: Path.absname("test/fixtures/image.jpg"),
1510         filename: "an_image.jpg"
1511       }
1512
1513       conn =
1514         conn
1515         |> assign(:user, user)
1516         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1517
1518       assert user_response = json_response(conn, 200)
1519       assert user_response["avatar"] != User.avatar_url(user)
1520     end
1521
1522     test "updates the user's banner", %{conn: conn} do
1523       user = insert(:user)
1524
1525       new_header = %Plug.Upload{
1526         content_type: "image/jpg",
1527         path: Path.absname("test/fixtures/image.jpg"),
1528         filename: "an_image.jpg"
1529       }
1530
1531       conn =
1532         conn
1533         |> assign(:user, user)
1534         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1535
1536       assert user_response = json_response(conn, 200)
1537       assert user_response["header"] != User.banner_url(user)
1538     end
1539   end
1540
1541   test "get instance information", %{conn: conn} do
1542     user = insert(:user, %{local: true})
1543
1544     user2 = insert(:user, %{local: true})
1545     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
1546
1547     insert(:user, %{local: false, nickname: "u@peer1.com"})
1548     insert(:user, %{local: false, nickname: "u@peer2.com"})
1549
1550     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1551
1552     # Stats should count users with missing or nil `info.deactivated` value
1553     user = Repo.get(User, user.id)
1554     info_change = Changeset.change(user.info, %{deactivated: nil})
1555
1556     {:ok, _user} =
1557       user
1558       |> Changeset.change()
1559       |> Changeset.put_embed(:info, info_change)
1560       |> User.update_and_set_cache()
1561
1562     Pleroma.Stats.update_stats()
1563
1564     conn = get(conn, "/api/v1/instance")
1565
1566     assert result = json_response(conn, 200)
1567
1568     stats = result["stats"]
1569
1570     assert stats
1571     assert stats["user_count"] == 1
1572     assert stats["status_count"] == 1
1573     assert stats["domain_count"] == 2
1574   end
1575
1576   test "get peers", %{conn: conn} do
1577     insert(:user, %{local: false, nickname: "u@peer1.com"})
1578     insert(:user, %{local: false, nickname: "u@peer2.com"})
1579
1580     Pleroma.Stats.update_stats()
1581
1582     conn = get(conn, "/api/v1/instance/peers")
1583
1584     assert result = json_response(conn, 200)
1585
1586     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
1587   end
1588
1589   test "put settings", %{conn: conn} do
1590     user = insert(:user)
1591
1592     conn =
1593       conn
1594       |> assign(:user, user)
1595       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1596
1597     assert _result = json_response(conn, 200)
1598
1599     user = User.get_cached_by_ap_id(user.ap_id)
1600     assert user.info.settings == %{"programming" => "socks"}
1601   end
1602
1603   describe "pinned statuses" do
1604     setup do
1605       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
1606
1607       user = insert(:user)
1608       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
1609
1610       [user: user, activity: activity]
1611     end
1612
1613     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
1614       {:ok, _} = CommonAPI.pin(activity.id, user)
1615
1616       result =
1617         conn
1618         |> assign(:user, user)
1619         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1620         |> json_response(200)
1621
1622       id_str = to_string(activity.id)
1623
1624       assert [%{"id" => ^id_str, "pinned" => true}] = result
1625     end
1626
1627     test "pin status", %{conn: conn, user: user, activity: activity} do
1628       id_str = to_string(activity.id)
1629
1630       assert %{"id" => ^id_str, "pinned" => true} =
1631                conn
1632                |> assign(:user, user)
1633                |> post("/api/v1/statuses/#{activity.id}/pin")
1634                |> json_response(200)
1635
1636       assert [%{"id" => ^id_str, "pinned" => true}] =
1637                conn
1638                |> assign(:user, user)
1639                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1640                |> json_response(200)
1641     end
1642
1643     test "unpin status", %{conn: conn, user: user, activity: activity} do
1644       {:ok, _} = CommonAPI.pin(activity.id, user)
1645
1646       id_str = to_string(activity.id)
1647       user = refresh_record(user)
1648
1649       assert %{"id" => ^id_str, "pinned" => false} =
1650                conn
1651                |> assign(:user, user)
1652                |> post("/api/v1/statuses/#{activity.id}/unpin")
1653                |> json_response(200)
1654
1655       assert [] =
1656                conn
1657                |> assign(:user, user)
1658                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1659                |> json_response(200)
1660     end
1661
1662     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
1663       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1664
1665       id_str_one = to_string(activity_one.id)
1666
1667       assert %{"id" => ^id_str_one, "pinned" => true} =
1668                conn
1669                |> assign(:user, user)
1670                |> post("/api/v1/statuses/#{id_str_one}/pin")
1671                |> json_response(200)
1672
1673       user = refresh_record(user)
1674
1675       assert %{"error" => "You have already pinned the maximum number of statuses"} =
1676                conn
1677                |> assign(:user, user)
1678                |> post("/api/v1/statuses/#{activity_two.id}/pin")
1679                |> json_response(400)
1680     end
1681
1682     test "Status rich-media Card", %{conn: conn, user: user} do
1683       Pleroma.Config.put([:rich_media, :enabled], true)
1684       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})
1685
1686       response =
1687         conn
1688         |> get("/api/v1/statuses/#{activity.id}/card")
1689         |> json_response(200)
1690
1691       assert response == %{
1692                "image" => "http://ia.media-imdb.com/images/rock.jpg",
1693                "provider_name" => "www.imdb.com",
1694                "provider_url" => "http://www.imdb.com",
1695                "title" => "The Rock",
1696                "type" => "link",
1697                "url" => "http://www.imdb.com/title/tt0117500/",
1698                "description" => nil,
1699                "pleroma" => %{
1700                  "opengraph" => %{
1701                    "image" => "http://ia.media-imdb.com/images/rock.jpg",
1702                    "title" => "The Rock",
1703                    "type" => "video.movie",
1704                    "url" => "http://www.imdb.com/title/tt0117500/"
1705                  }
1706                }
1707              }
1708
1709       Pleroma.Config.put([:rich_media, :enabled], false)
1710     end
1711   end
1712
1713   test "bookmarks" do
1714     user = insert(:user)
1715     for_user = insert(:user)
1716
1717     {:ok, activity1} =
1718       CommonAPI.post(user, %{
1719         "status" => "heweoo?"
1720       })
1721
1722     {:ok, activity2} =
1723       CommonAPI.post(user, %{
1724         "status" => "heweoo!"
1725       })
1726
1727     response1 =
1728       build_conn()
1729       |> assign(:user, for_user)
1730       |> post("/api/v1/statuses/#{activity1.id}/bookmark")
1731
1732     assert json_response(response1, 200)["bookmarked"] == true
1733
1734     response2 =
1735       build_conn()
1736       |> assign(:user, for_user)
1737       |> post("/api/v1/statuses/#{activity2.id}/bookmark")
1738
1739     assert json_response(response2, 200)["bookmarked"] == true
1740
1741     bookmarks =
1742       build_conn()
1743       |> assign(:user, for_user)
1744       |> get("/api/v1/bookmarks")
1745
1746     assert [json_response(response2, 200), json_response(response1, 200)] ==
1747              json_response(bookmarks, 200)
1748
1749     response1 =
1750       build_conn()
1751       |> assign(:user, for_user)
1752       |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
1753
1754     assert json_response(response1, 200)["bookmarked"] == false
1755
1756     bookmarks =
1757       build_conn()
1758       |> assign(:user, for_user)
1759       |> get("/api/v1/bookmarks")
1760
1761     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
1762   end
1763
1764   describe "conversation muting" do
1765     setup do
1766       user = insert(:user)
1767       {:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})
1768
1769       [user: user, activity: activity]
1770     end
1771
1772     test "mute conversation", %{conn: conn, user: user, activity: activity} do
1773       id_str = to_string(activity.id)
1774
1775       assert %{"id" => ^id_str, "muted" => true} =
1776                conn
1777                |> assign(:user, user)
1778                |> post("/api/v1/statuses/#{activity.id}/mute")
1779                |> json_response(200)
1780     end
1781
1782     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
1783       {:ok, _} = CommonAPI.add_mute(user, activity)
1784
1785       id_str = to_string(activity.id)
1786       user = refresh_record(user)
1787
1788       assert %{"id" => ^id_str, "muted" => false} =
1789                conn
1790                |> assign(:user, user)
1791                |> post("/api/v1/statuses/#{activity.id}/unmute")
1792                |> json_response(200)
1793     end
1794   end
1795
1796   test "flavours switching (Pleroma Extension)", %{conn: conn} do
1797     user = insert(:user)
1798
1799     get_old_flavour =
1800       conn
1801       |> assign(:user, user)
1802       |> get("/api/v1/pleroma/flavour")
1803
1804     assert "glitch" == json_response(get_old_flavour, 200)
1805
1806     set_flavour =
1807       conn
1808       |> assign(:user, user)
1809       |> post("/api/v1/pleroma/flavour/vanilla")
1810
1811     assert "vanilla" == json_response(set_flavour, 200)
1812
1813     get_new_flavour =
1814       conn
1815       |> assign(:user, user)
1816       |> post("/api/v1/pleroma/flavour/vanilla")
1817
1818     assert json_response(set_flavour, 200) == json_response(get_new_flavour, 200)
1819   end
1820 end