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 Ecto.Changeset
   9   alias Pleroma.Activity
  10   alias Pleroma.Notification
  11   alias Pleroma.Object
  12   alias Pleroma.Repo
  13   alias Pleroma.User
  14   alias Pleroma.Web.ActivityPub.ActivityPub
  15   alias Pleroma.Web.CommonAPI
  16   alias Pleroma.Web.MastodonAPI.FilterView
  17   alias Pleroma.Web.OAuth.App
  18   alias Pleroma.Web.OStatus
  19   alias Pleroma.Web.Push
  20   alias Pleroma.Web.TwitterAPI.TwitterAPI
  21   import Pleroma.Factory
  22   import ExUnit.CaptureLog
  23   import Tesla.Mock
  24
  25   setup do
  26     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  27     :ok
  28   end
  29
  30   test "the home timeline", %{conn: conn} do
  31     user = insert(:user)
  32     following = insert(:user)
  33
  34     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  35
  36     conn =
  37       conn
  38       |> assign(:user, user)
  39       |> get("/api/v1/timelines/home")
  40
  41     assert Enum.empty?(json_response(conn, 200))
  42
  43     {:ok, user} = User.follow(user, following)
  44
  45     conn =
  46       build_conn()
  47       |> assign(:user, user)
  48       |> get("/api/v1/timelines/home")
  49
  50     assert [%{"content" => "test"}] = json_response(conn, 200)
  51   end
  52
  53   test "the public timeline", %{conn: conn} do
  54     following = insert(:user)
  55
  56     capture_log(fn ->
  57       {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  58
  59       {:ok, [_activity]} =
  60         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  61
  62       conn =
  63         conn
  64         |> get("/api/v1/timelines/public", %{"local" => "False"})
  65
  66       assert length(json_response(conn, 200)) == 2
  67
  68       conn =
  69         build_conn()
  70         |> get("/api/v1/timelines/public", %{"local" => "True"})
  71
  72       assert [%{"content" => "test"}] = json_response(conn, 200)
  73
  74       conn =
  75         build_conn()
  76         |> get("/api/v1/timelines/public", %{"local" => "1"})
  77
  78       assert [%{"content" => "test"}] = json_response(conn, 200)
  79     end)
  80   end
  81
  82   test "posting a status", %{conn: conn} do
  83     user = insert(:user)
  84
  85     idempotency_key = "Pikachu rocks!"
  86
  87     conn_one =
  88       conn
  89       |> assign(:user, user)
  90       |> put_req_header("idempotency-key", idempotency_key)
  91       |> post("/api/v1/statuses", %{
  92         "status" => "cofe",
  93         "spoiler_text" => "2hu",
  94         "sensitive" => "false"
  95       })
  96
  97     {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  98     # Six hours
  99     assert ttl > :timer.seconds(6 * 60 * 60 - 1)
 100
 101     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
 102              json_response(conn_one, 200)
 103
 104     assert Repo.get(Activity, id)
 105
 106     conn_two =
 107       conn
 108       |> assign(:user, user)
 109       |> put_req_header("idempotency-key", idempotency_key)
 110       |> post("/api/v1/statuses", %{
 111         "status" => "cofe",
 112         "spoiler_text" => "2hu",
 113         "sensitive" => "false"
 114       })
 115
 116     assert %{"id" => second_id} = json_response(conn_two, 200)
 117
 118     assert id == second_id
 119
 120     conn_three =
 121       conn
 122       |> assign(:user, user)
 123       |> post("/api/v1/statuses", %{
 124         "status" => "cofe",
 125         "spoiler_text" => "2hu",
 126         "sensitive" => "false"
 127       })
 128
 129     assert %{"id" => third_id} = json_response(conn_three, 200)
 130
 131     refute id == third_id
 132   end
 133
 134   test "posting a sensitive status", %{conn: conn} do
 135     user = insert(:user)
 136
 137     conn =
 138       conn
 139       |> assign(:user, user)
 140       |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 141
 142     assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 143     assert Repo.get(Activity, id)
 144   end
 145
 146   test "posting a status with OGP link preview", %{conn: conn} do
 147     Pleroma.Config.put([:rich_media, :enabled], true)
 148     user = insert(:user)
 149
 150     conn =
 151       conn
 152       |> assign(:user, user)
 153       |> post("/api/v1/statuses", %{
 154         "status" => "http://example.com/ogp"
 155       })
 156
 157     assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
 158     assert Repo.get(Activity, id)
 159     Pleroma.Config.put([:rich_media, :enabled], false)
 160   end
 161
 162   test "posting a direct status", %{conn: conn} do
 163     user1 = insert(:user)
 164     user2 = insert(:user)
 165     content = "direct cofe @#{user2.nickname}"
 166
 167     conn =
 168       conn
 169       |> assign(:user, user1)
 170       |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 171
 172     assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
 173     assert activity = Repo.get(Activity, id)
 174     assert activity.recipients == [user2.ap_id, user1.ap_id]
 175     assert activity.data["to"] == [user2.ap_id]
 176     assert activity.data["cc"] == []
 177   end
 178
 179   test "direct timeline", %{conn: conn} do
 180     user_one = insert(:user)
 181     user_two = insert(:user)
 182
 183     {:ok, user_two} = User.follow(user_two, user_one)
 184
 185     {:ok, direct} =
 186       CommonAPI.post(user_one, %{
 187         "status" => "Hi @#{user_two.nickname}!",
 188         "visibility" => "direct"
 189       })
 190
 191     {:ok, _follower_only} =
 192       CommonAPI.post(user_one, %{
 193         "status" => "Hi @#{user_two.nickname}!",
 194         "visibility" => "private"
 195       })
 196
 197     # Only direct should be visible here
 198     res_conn =
 199       conn
 200       |> assign(:user, user_two)
 201       |> get("api/v1/timelines/direct")
 202
 203     [status] = json_response(res_conn, 200)
 204
 205     assert %{"visibility" => "direct"} = status
 206     assert status["url"] != direct.data["id"]
 207
 208     # User should be able to see his own direct message
 209     res_conn =
 210       build_conn()
 211       |> assign(:user, user_one)
 212       |> get("api/v1/timelines/direct")
 213
 214     [status] = json_response(res_conn, 200)
 215
 216     assert %{"visibility" => "direct"} = status
 217
 218     # Both should be visible here
 219     res_conn =
 220       conn
 221       |> assign(:user, user_two)
 222       |> get("api/v1/timelines/home")
 223
 224     [_s1, _s2] = json_response(res_conn, 200)
 225
 226     # Test pagination
 227     Enum.each(1..20, fn _ ->
 228       {:ok, _} =
 229         CommonAPI.post(user_one, %{
 230           "status" => "Hi @#{user_two.nickname}!",
 231           "visibility" => "direct"
 232         })
 233     end)
 234
 235     res_conn =
 236       conn
 237       |> assign(:user, user_two)
 238       |> get("api/v1/timelines/direct")
 239
 240     statuses = json_response(res_conn, 200)
 241     assert length(statuses) == 20
 242
 243     res_conn =
 244       conn
 245       |> assign(:user, user_two)
 246       |> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
 247
 248     [status] = json_response(res_conn, 200)
 249
 250     assert status["url"] != direct.data["id"]
 251   end
 252
 253   test "Conversations", %{conn: conn} do
 254     user_one = insert(:user)
 255     user_two = insert(:user)
 256
 257     {:ok, user_two} = User.follow(user_two, user_one)
 258
 259     {:ok, direct} =
 260       CommonAPI.post(user_one, %{
 261         "status" => "Hi @#{user_two.nickname}!",
 262         "visibility" => "direct"
 263       })
 264
 265     {:ok, _follower_only} =
 266       CommonAPI.post(user_one, %{
 267         "status" => "Hi @#{user_two.nickname}!",
 268         "visibility" => "private"
 269       })
 270
 271     res_conn =
 272       conn
 273       |> assign(:user, user)
 274       |> get("/api/v1/conversations")
 275
 276     assert response = json_response(res_conn, 200)
 277
 278     assert %{
 279              "id" => res_id,
 280              "accounts" => res_accounts,
 281              "last_status" => res_last_status,
 282              "unread" => unread
 283            } = reponse
 284
 285     assert unread == false
 286
 287     # Apparently undocumented API endpoint
 288     res_conn =
 289       conn
 290       |> assign(:user, user)
 291       |> get("/api/v1/conversations/#{res_id}/read")
 292
 293     assert response == json_response(res_conn, 200)
 294
 295     # (vanilla) Mastodon frontend behaviour
 296     res_conn =
 297       conn
 298       |> assign(:user, user)
 299       |> get("/api/v1/statuses/#{res_last_status.id}/context")
 300
 301     assert %{ancestors: [], descendants: []} == json_response(res_conn, 200)
 302   end
 303
 304   test "doesn't include DMs from blocked users", %{conn: conn} do
 305     blocker = insert(:user)
 306     blocked = insert(:user)
 307     user = insert(:user)
 308     {:ok, blocker} = User.block(blocker, blocked)
 309
 310     {:ok, _blocked_direct} =
 311       CommonAPI.post(blocked, %{
 312         "status" => "Hi @#{blocker.nickname}!",
 313         "visibility" => "direct"
 314       })
 315
 316     {:ok, direct} =
 317       CommonAPI.post(user, %{
 318         "status" => "Hi @#{blocker.nickname}!",
 319         "visibility" => "direct"
 320       })
 321
 322     res_conn =
 323       conn
 324       |> assign(:user, user)
 325       |> get("api/v1/timelines/direct")
 326
 327     [status] = json_response(res_conn, 200)
 328     assert status["id"] == direct.id
 329   end
 330
 331   test "replying to a status", %{conn: conn} do
 332     user = insert(:user)
 333
 334     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 335
 336     conn =
 337       conn
 338       |> assign(:user, user)
 339       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 340
 341     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 342
 343     activity = Repo.get(Activity, id)
 344
 345     assert activity.data["context"] == replied_to.data["context"]
 346     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
 347   end
 348
 349   test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
 350     user = insert(:user)
 351
 352     conn =
 353       conn
 354       |> assign(:user, user)
 355       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 356
 357     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 358
 359     activity = Repo.get(Activity, id)
 360
 361     assert activity
 362   end
 363
 364   test "verify_credentials", %{conn: conn} do
 365     user = insert(:user)
 366
 367     conn =
 368       conn
 369       |> assign(:user, user)
 370       |> get("/api/v1/accounts/verify_credentials")
 371
 372     assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
 373     assert id == to_string(user.id)
 374   end
 375
 376   test "verify_credentials default scope unlisted", %{conn: conn} do
 377     user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})
 378
 379     conn =
 380       conn
 381       |> assign(:user, user)
 382       |> get("/api/v1/accounts/verify_credentials")
 383
 384     assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
 385     assert id == to_string(user.id)
 386   end
 387
 388   test "apps/verify_credentials", %{conn: conn} do
 389     token = insert(:oauth_token)
 390
 391     conn =
 392       conn
 393       |> assign(:user, token.user)
 394       |> assign(:token, token)
 395       |> get("/api/v1/apps/verify_credentials")
 396
 397     app = Repo.preload(token, :app).app
 398
 399     expected = %{
 400       "name" => app.client_name,
 401       "website" => app.website,
 402       "vapid_key" => Push.vapid_config() |> Keyword.get(:public_key)
 403     }
 404
 405     assert expected == json_response(conn, 200)
 406   end
 407
 408   test "creates an oauth app", %{conn: conn} do
 409     user = insert(:user)
 410     app_attrs = build(:oauth_app)
 411
 412     conn =
 413       conn
 414       |> assign(:user, user)
 415       |> post("/api/v1/apps", %{
 416         client_name: app_attrs.client_name,
 417         redirect_uris: app_attrs.redirect_uris
 418       })
 419
 420     [app] = Repo.all(App)
 421
 422     expected = %{
 423       "name" => app.client_name,
 424       "website" => app.website,
 425       "client_id" => app.client_id,
 426       "client_secret" => app.client_secret,
 427       "id" => app.id |> to_string(),
 428       "redirect_uri" => app.redirect_uris,
 429       "vapid_key" => Push.vapid_config() |> Keyword.get(:public_key)
 430     }
 431
 432     assert expected == json_response(conn, 200)
 433   end
 434
 435   test "get a status", %{conn: conn} do
 436     activity = insert(:note_activity)
 437
 438     conn =
 439       conn
 440       |> get("/api/v1/statuses/#{activity.id}")
 441
 442     assert %{"id" => id} = json_response(conn, 200)
 443     assert id == to_string(activity.id)
 444   end
 445
 446   describe "deleting a status" do
 447     test "when you created it", %{conn: conn} do
 448       activity = insert(:note_activity)
 449       author = User.get_by_ap_id(activity.data["actor"])
 450
 451       conn =
 452         conn
 453         |> assign(:user, author)
 454         |> delete("/api/v1/statuses/#{activity.id}")
 455
 456       assert %{} = json_response(conn, 200)
 457
 458       refute Repo.get(Activity, activity.id)
 459     end
 460
 461     test "when you didn't create it", %{conn: conn} do
 462       activity = insert(:note_activity)
 463       user = insert(:user)
 464
 465       conn =
 466         conn
 467         |> assign(:user, user)
 468         |> delete("/api/v1/statuses/#{activity.id}")
 469
 470       assert %{"error" => _} = json_response(conn, 403)
 471
 472       assert Repo.get(Activity, activity.id) == activity
 473     end
 474
 475     test "when you're an admin or moderator", %{conn: conn} do
 476       activity1 = insert(:note_activity)
 477       activity2 = insert(:note_activity)
 478       admin = insert(:user, info: %{is_admin: true})
 479       moderator = insert(:user, info: %{is_moderator: true})
 480
 481       res_conn =
 482         conn
 483         |> assign(:user, admin)
 484         |> delete("/api/v1/statuses/#{activity1.id}")
 485
 486       assert %{} = json_response(res_conn, 200)
 487
 488       res_conn =
 489         conn
 490         |> assign(:user, moderator)
 491         |> delete("/api/v1/statuses/#{activity2.id}")
 492
 493       assert %{} = json_response(res_conn, 200)
 494
 495       refute Repo.get(Activity, activity1.id)
 496       refute Repo.get(Activity, activity2.id)
 497     end
 498   end
 499
 500   describe "filters" do
 501     test "creating a filter", %{conn: conn} do
 502       user = insert(:user)
 503
 504       filter = %Pleroma.Filter{
 505         phrase: "knights",
 506         context: ["home"]
 507       }
 508
 509       conn =
 510         conn
 511         |> assign(:user, user)
 512         |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
 513
 514       assert response = json_response(conn, 200)
 515       assert response["phrase"] == filter.phrase
 516       assert response["context"] == filter.context
 517       assert response["id"] != nil
 518       assert response["id"] != ""
 519     end
 520
 521     test "fetching a list of filters", %{conn: conn} do
 522       user = insert(:user)
 523
 524       query_one = %Pleroma.Filter{
 525         user_id: user.id,
 526         filter_id: 1,
 527         phrase: "knights",
 528         context: ["home"]
 529       }
 530
 531       query_two = %Pleroma.Filter{
 532         user_id: user.id,
 533         filter_id: 2,
 534         phrase: "who",
 535         context: ["home"]
 536       }
 537
 538       {:ok, filter_one} = Pleroma.Filter.create(query_one)
 539       {:ok, filter_two} = Pleroma.Filter.create(query_two)
 540
 541       response =
 542         conn
 543         |> assign(:user, user)
 544         |> get("/api/v1/filters")
 545         |> json_response(200)
 546
 547       assert response ==
 548                render_json(
 549                  FilterView,
 550                  "filters.json",
 551                  filters: [filter_two, filter_one]
 552                )
 553     end
 554
 555     test "get a filter", %{conn: conn} do
 556       user = insert(:user)
 557
 558       query = %Pleroma.Filter{
 559         user_id: user.id,
 560         filter_id: 2,
 561         phrase: "knight",
 562         context: ["home"]
 563       }
 564
 565       {:ok, filter} = Pleroma.Filter.create(query)
 566
 567       conn =
 568         conn
 569         |> assign(:user, user)
 570         |> get("/api/v1/filters/#{filter.filter_id}")
 571
 572       assert _response = json_response(conn, 200)
 573     end
 574
 575     test "update a filter", %{conn: conn} do
 576       user = insert(:user)
 577
 578       query = %Pleroma.Filter{
 579         user_id: user.id,
 580         filter_id: 2,
 581         phrase: "knight",
 582         context: ["home"]
 583       }
 584
 585       {:ok, _filter} = Pleroma.Filter.create(query)
 586
 587       new = %Pleroma.Filter{
 588         phrase: "nii",
 589         context: ["home"]
 590       }
 591
 592       conn =
 593         conn
 594         |> assign(:user, user)
 595         |> put("/api/v1/filters/#{query.filter_id}", %{
 596           phrase: new.phrase,
 597           context: new.context
 598         })
 599
 600       assert response = json_response(conn, 200)
 601       assert response["phrase"] == new.phrase
 602       assert response["context"] == new.context
 603     end
 604
 605     test "delete a filter", %{conn: conn} do
 606       user = insert(:user)
 607
 608       query = %Pleroma.Filter{
 609         user_id: user.id,
 610         filter_id: 2,
 611         phrase: "knight",
 612         context: ["home"]
 613       }
 614
 615       {:ok, filter} = Pleroma.Filter.create(query)
 616
 617       conn =
 618         conn
 619         |> assign(:user, user)
 620         |> delete("/api/v1/filters/#{filter.filter_id}")
 621
 622       assert response = json_response(conn, 200)
 623       assert response == %{}
 624     end
 625   end
 626
 627   describe "lists" do
 628     test "creating a list", %{conn: conn} do
 629       user = insert(:user)
 630
 631       conn =
 632         conn
 633         |> assign(:user, user)
 634         |> post("/api/v1/lists", %{"title" => "cuties"})
 635
 636       assert %{"title" => title} = json_response(conn, 200)
 637       assert title == "cuties"
 638     end
 639
 640     test "adding users to a list", %{conn: conn} do
 641       user = insert(:user)
 642       other_user = insert(:user)
 643       {:ok, list} = Pleroma.List.create("name", user)
 644
 645       conn =
 646         conn
 647         |> assign(:user, user)
 648         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 649
 650       assert %{} == json_response(conn, 200)
 651       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 652       assert following == [other_user.follower_address]
 653     end
 654
 655     test "removing users from a list", %{conn: conn} do
 656       user = insert(:user)
 657       other_user = insert(:user)
 658       third_user = insert(:user)
 659       {:ok, list} = Pleroma.List.create("name", user)
 660       {:ok, list} = Pleroma.List.follow(list, other_user)
 661       {:ok, list} = Pleroma.List.follow(list, third_user)
 662
 663       conn =
 664         conn
 665         |> assign(:user, user)
 666         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 667
 668       assert %{} == json_response(conn, 200)
 669       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 670       assert following == [third_user.follower_address]
 671     end
 672
 673     test "listing users in a list", %{conn: conn} do
 674       user = insert(:user)
 675       other_user = insert(:user)
 676       {:ok, list} = Pleroma.List.create("name", user)
 677       {:ok, list} = Pleroma.List.follow(list, other_user)
 678
 679       conn =
 680         conn
 681         |> assign(:user, user)
 682         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 683
 684       assert [%{"id" => id}] = json_response(conn, 200)
 685       assert id == to_string(other_user.id)
 686     end
 687
 688     test "retrieving a list", %{conn: conn} do
 689       user = insert(:user)
 690       {:ok, list} = Pleroma.List.create("name", user)
 691
 692       conn =
 693         conn
 694         |> assign(:user, user)
 695         |> get("/api/v1/lists/#{list.id}")
 696
 697       assert %{"id" => id} = json_response(conn, 200)
 698       assert id == to_string(list.id)
 699     end
 700
 701     test "renaming a list", %{conn: conn} do
 702       user = insert(:user)
 703       {:ok, list} = Pleroma.List.create("name", user)
 704
 705       conn =
 706         conn
 707         |> assign(:user, user)
 708         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 709
 710       assert %{"title" => name} = json_response(conn, 200)
 711       assert name == "newname"
 712     end
 713
 714     test "deleting a list", %{conn: conn} do
 715       user = insert(:user)
 716       {:ok, list} = Pleroma.List.create("name", user)
 717
 718       conn =
 719         conn
 720         |> assign(:user, user)
 721         |> delete("/api/v1/lists/#{list.id}")
 722
 723       assert %{} = json_response(conn, 200)
 724       assert is_nil(Repo.get(Pleroma.List, list.id))
 725     end
 726
 727     test "list timeline", %{conn: conn} do
 728       user = insert(:user)
 729       other_user = insert(:user)
 730       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 731       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 732       {:ok, list} = Pleroma.List.create("name", user)
 733       {:ok, list} = Pleroma.List.follow(list, other_user)
 734
 735       conn =
 736         conn
 737         |> assign(:user, user)
 738         |> get("/api/v1/timelines/list/#{list.id}")
 739
 740       assert [%{"id" => id}] = json_response(conn, 200)
 741
 742       assert id == to_string(activity_two.id)
 743     end
 744
 745     test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
 746       user = insert(:user)
 747       other_user = insert(:user)
 748       {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 749
 750       {:ok, _activity_two} =
 751         TwitterAPI.create_status(other_user, %{
 752           "status" => "Marisa is cute.",
 753           "visibility" => "private"
 754         })
 755
 756       {:ok, list} = Pleroma.List.create("name", user)
 757       {:ok, list} = Pleroma.List.follow(list, other_user)
 758
 759       conn =
 760         conn
 761         |> assign(:user, user)
 762         |> get("/api/v1/timelines/list/#{list.id}")
 763
 764       assert [%{"id" => id}] = json_response(conn, 200)
 765
 766       assert id == to_string(activity_one.id)
 767     end
 768   end
 769
 770   describe "notifications" do
 771     test "list of notifications", %{conn: conn} do
 772       user = insert(:user)
 773       other_user = insert(:user)
 774
 775       {:ok, activity} =
 776         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 777
 778       {:ok, [_notification]} = Notification.create_notifications(activity)
 779
 780       conn =
 781         conn
 782         |> assign(:user, user)
 783         |> get("/api/v1/notifications")
 784
 785       expected_response =
 786         "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 787           user.ap_id
 788         }\">@<span>#{user.nickname}</span></a></span>"
 789
 790       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 791       assert response == expected_response
 792     end
 793
 794     test "getting a single notification", %{conn: conn} do
 795       user = insert(:user)
 796       other_user = insert(:user)
 797
 798       {:ok, activity} =
 799         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 800
 801       {:ok, [notification]} = Notification.create_notifications(activity)
 802
 803       conn =
 804         conn
 805         |> assign(:user, user)
 806         |> get("/api/v1/notifications/#{notification.id}")
 807
 808       expected_response =
 809         "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 810           user.ap_id
 811         }\">@<span>#{user.nickname}</span></a></span>"
 812
 813       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 814       assert response == expected_response
 815     end
 816
 817     test "dismissing a single notification", %{conn: conn} do
 818       user = insert(:user)
 819       other_user = insert(:user)
 820
 821       {:ok, activity} =
 822         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 823
 824       {:ok, [notification]} = Notification.create_notifications(activity)
 825
 826       conn =
 827         conn
 828         |> assign(:user, user)
 829         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 830
 831       assert %{} = json_response(conn, 200)
 832     end
 833
 834     test "clearing all notifications", %{conn: conn} do
 835       user = insert(:user)
 836       other_user = insert(:user)
 837
 838       {:ok, activity} =
 839         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 840
 841       {:ok, [_notification]} = Notification.create_notifications(activity)
 842
 843       conn =
 844         conn
 845         |> assign(:user, user)
 846         |> post("/api/v1/notifications/clear")
 847
 848       assert %{} = json_response(conn, 200)
 849
 850       conn =
 851         build_conn()
 852         |> assign(:user, user)
 853         |> get("/api/v1/notifications")
 854
 855       assert all = json_response(conn, 200)
 856       assert all == []
 857     end
 858
 859     test "paginates notifications using min_id, since_id, max_id, and limit", %{conn: conn} do
 860       user = insert(:user)
 861       other_user = insert(:user)
 862
 863       {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 864       {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 865       {:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 866       {:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 867
 868       notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id |> to_string()
 869       notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id |> to_string()
 870       notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id |> to_string()
 871       notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id |> to_string()
 872
 873       conn =
 874         conn
 875         |> assign(:user, user)
 876
 877       # min_id
 878       conn_res =
 879         conn
 880         |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
 881
 882       result = json_response(conn_res, 200)
 883       assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 884
 885       # since_id
 886       conn_res =
 887         conn
 888         |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
 889
 890       result = json_response(conn_res, 200)
 891       assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 892
 893       # max_id
 894       conn_res =
 895         conn
 896         |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
 897
 898       result = json_response(conn_res, 200)
 899       assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 900     end
 901
 902     test "filters notifications using exclude_types", %{conn: conn} do
 903       user = insert(:user)
 904       other_user = insert(:user)
 905
 906       {:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
 907       {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
 908       {:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
 909       {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
 910       {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 911
 912       mention_notification_id =
 913         Repo.get_by(Notification, activity_id: mention_activity.id).id |> to_string()
 914
 915       favorite_notification_id =
 916         Repo.get_by(Notification, activity_id: favorite_activity.id).id |> to_string()
 917
 918       reblog_notification_id =
 919         Repo.get_by(Notification, activity_id: reblog_activity.id).id |> to_string()
 920
 921       follow_notification_id =
 922         Repo.get_by(Notification, activity_id: follow_activity.id).id |> to_string()
 923
 924       conn =
 925         conn
 926         |> assign(:user, user)
 927
 928       conn_res =
 929         get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})
 930
 931       assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)
 932
 933       conn_res =
 934         get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})
 935
 936       assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)
 937
 938       conn_res =
 939         get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})
 940
 941       assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)
 942
 943       conn_res =
 944         get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})
 945
 946       assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
 947     end
 948   end
 949
 950   describe "reblogging" do
 951     test "reblogs and returns the reblogged status", %{conn: conn} do
 952       activity = insert(:note_activity)
 953       user = insert(:user)
 954
 955       conn =
 956         conn
 957         |> assign(:user, user)
 958         |> post("/api/v1/statuses/#{activity.id}/reblog")
 959
 960       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 961                json_response(conn, 200)
 962
 963       assert to_string(activity.id) == id
 964     end
 965   end
 966
 967   describe "unreblogging" do
 968     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 969       activity = insert(:note_activity)
 970       user = insert(:user)
 971
 972       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 973
 974       conn =
 975         conn
 976         |> assign(:user, user)
 977         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 978
 979       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 980
 981       assert to_string(activity.id) == id
 982     end
 983   end
 984
 985   describe "favoriting" do
 986     test "favs a status and returns it", %{conn: conn} do
 987       activity = insert(:note_activity)
 988       user = insert(:user)
 989
 990       conn =
 991         conn
 992         |> assign(:user, user)
 993         |> post("/api/v1/statuses/#{activity.id}/favourite")
 994
 995       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 996                json_response(conn, 200)
 997
 998       assert to_string(activity.id) == id
 999     end
1000
1001     test "returns 500 for a wrong id", %{conn: conn} do
1002       user = insert(:user)
1003
1004       resp =
1005         conn
1006         |> assign(:user, user)
1007         |> post("/api/v1/statuses/1/favourite")
1008         |> json_response(500)
1009
1010       assert resp == "Something went wrong"
1011     end
1012   end
1013
1014   describe "unfavoriting" do
1015     test "unfavorites a status and returns it", %{conn: conn} do
1016       activity = insert(:note_activity)
1017       user = insert(:user)
1018
1019       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1020
1021       conn =
1022         conn
1023         |> assign(:user, user)
1024         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
1025
1026       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
1027                json_response(conn, 200)
1028
1029       assert to_string(activity.id) == id
1030     end
1031   end
1032
1033   describe "user timelines" do
1034     test "gets a users statuses", %{conn: conn} do
1035       user_one = insert(:user)
1036       user_two = insert(:user)
1037       user_three = insert(:user)
1038
1039       {:ok, user_three} = User.follow(user_three, user_one)
1040
1041       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
1042
1043       {:ok, direct_activity} =
1044         CommonAPI.post(user_one, %{
1045           "status" => "Hi, @#{user_two.nickname}.",
1046           "visibility" => "direct"
1047         })
1048
1049       {:ok, private_activity} =
1050         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
1051
1052       resp =
1053         conn
1054         |> get("/api/v1/accounts/#{user_one.id}/statuses")
1055
1056       assert [%{"id" => id}] = json_response(resp, 200)
1057       assert id == to_string(activity.id)
1058
1059       resp =
1060         conn
1061         |> assign(:user, user_two)
1062         |> get("/api/v1/accounts/#{user_one.id}/statuses")
1063
1064       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
1065       assert id_one == to_string(direct_activity.id)
1066       assert id_two == to_string(activity.id)
1067
1068       resp =
1069         conn
1070         |> assign(:user, user_three)
1071         |> get("/api/v1/accounts/#{user_one.id}/statuses")
1072
1073       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
1074       assert id_one == to_string(private_activity.id)
1075       assert id_two == to_string(activity.id)
1076     end
1077
1078     test "unimplemented pinned statuses feature", %{conn: conn} do
1079       note = insert(:note_activity)
1080       user = User.get_by_ap_id(note.data["actor"])
1081
1082       conn =
1083         conn
1084         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1085
1086       assert json_response(conn, 200) == []
1087     end
1088
1089     test "gets an users media", %{conn: conn} do
1090       note = insert(:note_activity)
1091       user = User.get_by_ap_id(note.data["actor"])
1092
1093       file = %Plug.Upload{
1094         content_type: "image/jpg",
1095         path: Path.absname("test/fixtures/image.jpg"),
1096         filename: "an_image.jpg"
1097       }
1098
1099       media =
1100         TwitterAPI.upload(file, user, "json")
1101         |> Poison.decode!()
1102
1103       {:ok, image_post} =
1104         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
1105
1106       conn =
1107         conn
1108         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
1109
1110       assert [%{"id" => id}] = json_response(conn, 200)
1111       assert id == to_string(image_post.id)
1112
1113       conn =
1114         build_conn()
1115         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
1116
1117       assert [%{"id" => id}] = json_response(conn, 200)
1118       assert id == to_string(image_post.id)
1119     end
1120
1121     test "gets a user's statuses without reblogs", %{conn: conn} do
1122       user = insert(:user)
1123       {:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
1124       {:ok, _, _} = CommonAPI.repeat(post.id, user)
1125
1126       conn =
1127         conn
1128         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})
1129
1130       assert [%{"id" => id}] = json_response(conn, 200)
1131       assert id == to_string(post.id)
1132
1133       conn =
1134         conn
1135         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})
1136
1137       assert [%{"id" => id}] = json_response(conn, 200)
1138       assert id == to_string(post.id)
1139     end
1140   end
1141
1142   describe "user relationships" do
1143     test "returns the relationships for the current user", %{conn: conn} do
1144       user = insert(:user)
1145       other_user = insert(:user)
1146       {:ok, user} = User.follow(user, other_user)
1147
1148       conn =
1149         conn
1150         |> assign(:user, user)
1151         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
1152
1153       assert [relationship] = json_response(conn, 200)
1154
1155       assert to_string(other_user.id) == relationship["id"]
1156     end
1157   end
1158
1159   describe "locked accounts" do
1160     test "/api/v1/follow_requests works" do
1161       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
1162       other_user = insert(:user)
1163
1164       {:ok, _activity} = ActivityPub.follow(other_user, user)
1165
1166       user = Repo.get(User, user.id)
1167       other_user = Repo.get(User, other_user.id)
1168
1169       assert User.following?(other_user, user) == false
1170
1171       conn =
1172         build_conn()
1173         |> assign(:user, user)
1174         |> get("/api/v1/follow_requests")
1175
1176       assert [relationship] = json_response(conn, 200)
1177       assert to_string(other_user.id) == relationship["id"]
1178     end
1179
1180     test "/api/v1/follow_requests/:id/authorize works" do
1181       user = insert(:user, %{info: %User.Info{locked: true}})
1182       other_user = insert(:user)
1183
1184       {:ok, _activity} = ActivityPub.follow(other_user, user)
1185
1186       user = Repo.get(User, user.id)
1187       other_user = Repo.get(User, other_user.id)
1188
1189       assert User.following?(other_user, user) == false
1190
1191       conn =
1192         build_conn()
1193         |> assign(:user, user)
1194         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
1195
1196       assert relationship = json_response(conn, 200)
1197       assert to_string(other_user.id) == relationship["id"]
1198
1199       user = Repo.get(User, user.id)
1200       other_user = Repo.get(User, other_user.id)
1201
1202       assert User.following?(other_user, user) == true
1203     end
1204
1205     test "verify_credentials", %{conn: conn} do
1206       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
1207
1208       conn =
1209         conn
1210         |> assign(:user, user)
1211         |> get("/api/v1/accounts/verify_credentials")
1212
1213       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
1214       assert id == to_string(user.id)
1215     end
1216
1217     test "/api/v1/follow_requests/:id/reject works" do
1218       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
1219       other_user = insert(:user)
1220
1221       {:ok, _activity} = ActivityPub.follow(other_user, user)
1222
1223       user = Repo.get(User, user.id)
1224
1225       conn =
1226         build_conn()
1227         |> assign(:user, user)
1228         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
1229
1230       assert relationship = json_response(conn, 200)
1231       assert to_string(other_user.id) == relationship["id"]
1232
1233       user = Repo.get(User, user.id)
1234       other_user = Repo.get(User, other_user.id)
1235
1236       assert User.following?(other_user, user) == false
1237     end
1238   end
1239
1240   test "account fetching", %{conn: conn} do
1241     user = insert(:user)
1242
1243     conn =
1244       conn
1245       |> get("/api/v1/accounts/#{user.id}")
1246
1247     assert %{"id" => id} = json_response(conn, 200)
1248     assert id == to_string(user.id)
1249
1250     conn =
1251       build_conn()
1252       |> get("/api/v1/accounts/-1")
1253
1254     assert %{"error" => "Can't find user"} = json_response(conn, 404)
1255   end
1256
1257   test "account fetching also works nickname", %{conn: conn} do
1258     user = insert(:user)
1259
1260     conn =
1261       conn
1262       |> get("/api/v1/accounts/#{user.nickname}")
1263
1264     assert %{"id" => id} = json_response(conn, 200)
1265     assert id == user.id
1266   end
1267
1268   test "media upload", %{conn: conn} do
1269     file = %Plug.Upload{
1270       content_type: "image/jpg",
1271       path: Path.absname("test/fixtures/image.jpg"),
1272       filename: "an_image.jpg"
1273     }
1274
1275     desc = "Description of the image"
1276
1277     user = insert(:user)
1278
1279     conn =
1280       conn
1281       |> assign(:user, user)
1282       |> post("/api/v1/media", %{"file" => file, "description" => desc})
1283
1284     assert media = json_response(conn, 200)
1285
1286     assert media["type"] == "image"
1287     assert media["description"] == desc
1288     assert media["id"]
1289
1290     object = Repo.get(Object, media["id"])
1291     assert object.data["actor"] == User.ap_id(user)
1292   end
1293
1294   test "hashtag timeline", %{conn: conn} do
1295     following = insert(:user)
1296
1297     capture_log(fn ->
1298       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1299
1300       {:ok, [_activity]} =
1301         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1302
1303       nconn =
1304         conn
1305         |> get("/api/v1/timelines/tag/2hu")
1306
1307       assert [%{"id" => id}] = json_response(nconn, 200)
1308
1309       assert id == to_string(activity.id)
1310
1311       # works for different capitalization too
1312       nconn =
1313         conn
1314         |> get("/api/v1/timelines/tag/2HU")
1315
1316       assert [%{"id" => id}] = json_response(nconn, 200)
1317
1318       assert id == to_string(activity.id)
1319     end)
1320   end
1321
1322   test "multi-hashtag timeline", %{conn: conn} do
1323     user = insert(:user)
1324
1325     {:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
1326     {:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
1327     {:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})
1328
1329     any_test =
1330       conn
1331       |> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})
1332
1333     [status_none, status_test1, status_test] = json_response(any_test, 200)
1334
1335     assert to_string(activity_test.id) == status_test["id"]
1336     assert to_string(activity_test1.id) == status_test1["id"]
1337     assert to_string(activity_none.id) == status_none["id"]
1338
1339     restricted_test =
1340       conn
1341       |> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})
1342
1343     assert [status_test1] == json_response(restricted_test, 200)
1344
1345     all_test = conn |> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})
1346
1347     assert [status_none] == json_response(all_test, 200)
1348   end
1349
1350   test "getting followers", %{conn: conn} do
1351     user = insert(:user)
1352     other_user = insert(:user)
1353     {:ok, user} = User.follow(user, other_user)
1354
1355     conn =
1356       conn
1357       |> get("/api/v1/accounts/#{other_user.id}/followers")
1358
1359     assert [%{"id" => id}] = json_response(conn, 200)
1360     assert id == to_string(user.id)
1361   end
1362
1363   test "getting followers, hide_followers", %{conn: conn} do
1364     user = insert(:user)
1365     other_user = insert(:user, %{info: %{hide_followers: true}})
1366     {:ok, _user} = User.follow(user, other_user)
1367
1368     conn =
1369       conn
1370       |> get("/api/v1/accounts/#{other_user.id}/followers")
1371
1372     assert [] == json_response(conn, 200)
1373   end
1374
1375   test "getting followers, hide_followers, same user requesting", %{conn: conn} do
1376     user = insert(:user)
1377     other_user = insert(:user, %{info: %{hide_followers: true}})
1378     {:ok, _user} = User.follow(user, other_user)
1379
1380     conn =
1381       conn
1382       |> assign(:user, other_user)
1383       |> get("/api/v1/accounts/#{other_user.id}/followers")
1384
1385     refute [] == json_response(conn, 200)
1386   end
1387
1388   test "getting followers, pagination", %{conn: conn} do
1389     user = insert(:user)
1390     follower1 = insert(:user)
1391     follower2 = insert(:user)
1392     follower3 = insert(:user)
1393     {:ok, _} = User.follow(follower1, user)
1394     {:ok, _} = User.follow(follower2, user)
1395     {:ok, _} = User.follow(follower3, user)
1396
1397     conn =
1398       conn
1399       |> assign(:user, user)
1400
1401     res_conn =
1402       conn
1403       |> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1.id}")
1404
1405     assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
1406     assert id3 == follower3.id
1407     assert id2 == follower2.id
1408
1409     res_conn =
1410       conn
1411       |> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3.id}")
1412
1413     assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
1414     assert id2 == follower2.id
1415     assert id1 == follower1.id
1416
1417     res_conn =
1418       conn
1419       |> get("/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3.id}")
1420
1421     assert [%{"id" => id2}] = json_response(res_conn, 200)
1422     assert id2 == follower2.id
1423
1424     assert [link_header] = get_resp_header(res_conn, "link")
1425     assert link_header =~ ~r/since_id=#{follower2.id}/
1426     assert link_header =~ ~r/max_id=#{follower2.id}/
1427   end
1428
1429   test "getting following", %{conn: conn} do
1430     user = insert(:user)
1431     other_user = insert(:user)
1432     {:ok, user} = User.follow(user, other_user)
1433
1434     conn =
1435       conn
1436       |> get("/api/v1/accounts/#{user.id}/following")
1437
1438     assert [%{"id" => id}] = json_response(conn, 200)
1439     assert id == to_string(other_user.id)
1440   end
1441
1442   test "getting following, hide_follows", %{conn: conn} do
1443     user = insert(:user, %{info: %{hide_follows: true}})
1444     other_user = insert(:user)
1445     {:ok, user} = User.follow(user, other_user)
1446
1447     conn =
1448       conn
1449       |> get("/api/v1/accounts/#{user.id}/following")
1450
1451     assert [] == json_response(conn, 200)
1452   end
1453
1454   test "getting following, hide_follows, same user requesting", %{conn: conn} do
1455     user = insert(:user, %{info: %{hide_follows: true}})
1456     other_user = insert(:user)
1457     {:ok, user} = User.follow(user, other_user)
1458
1459     conn =
1460       conn
1461       |> assign(:user, user)
1462       |> get("/api/v1/accounts/#{user.id}/following")
1463
1464     refute [] == json_response(conn, 200)
1465   end
1466
1467   test "getting following, pagination", %{conn: conn} do
1468     user = insert(:user)
1469     following1 = insert(:user)
1470     following2 = insert(:user)
1471     following3 = insert(:user)
1472     {:ok, _} = User.follow(user, following1)
1473     {:ok, _} = User.follow(user, following2)
1474     {:ok, _} = User.follow(user, following3)
1475
1476     conn =
1477       conn
1478       |> assign(:user, user)
1479
1480     res_conn =
1481       conn
1482       |> get("/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")
1483
1484     assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
1485     assert id3 == following3.id
1486     assert id2 == following2.id
1487
1488     res_conn =
1489       conn
1490       |> get("/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")
1491
1492     assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
1493     assert id2 == following2.id
1494     assert id1 == following1.id
1495
1496     res_conn =
1497       conn
1498       |> get("/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")
1499
1500     assert [%{"id" => id2}] = json_response(res_conn, 200)
1501     assert id2 == following2.id
1502
1503     assert [link_header] = get_resp_header(res_conn, "link")
1504     assert link_header =~ ~r/since_id=#{following2.id}/
1505     assert link_header =~ ~r/max_id=#{following2.id}/
1506   end
1507
1508   test "following / unfollowing a user", %{conn: conn} do
1509     user = insert(:user)
1510     other_user = insert(:user)
1511
1512     conn =
1513       conn
1514       |> assign(:user, user)
1515       |> post("/api/v1/accounts/#{other_user.id}/follow")
1516
1517     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1518
1519     user = Repo.get(User, user.id)
1520
1521     conn =
1522       build_conn()
1523       |> assign(:user, user)
1524       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1525
1526     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1527
1528     user = Repo.get(User, user.id)
1529
1530     conn =
1531       build_conn()
1532       |> assign(:user, user)
1533       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1534
1535     assert %{"id" => id} = json_response(conn, 200)
1536     assert id == to_string(other_user.id)
1537   end
1538
1539   test "muting / unmuting a user", %{conn: conn} do
1540     user = insert(:user)
1541     other_user = insert(:user)
1542
1543     conn =
1544       conn
1545       |> assign(:user, user)
1546       |> post("/api/v1/accounts/#{other_user.id}/mute")
1547
1548     assert %{"id" => _id, "muting" => true} = json_response(conn, 200)
1549
1550     user = Repo.get(User, user.id)
1551
1552     conn =
1553       build_conn()
1554       |> assign(:user, user)
1555       |> post("/api/v1/accounts/#{other_user.id}/unmute")
1556
1557     assert %{"id" => _id, "muting" => false} = json_response(conn, 200)
1558   end
1559
1560   test "getting a list of mutes", %{conn: conn} do
1561     user = insert(:user)
1562     other_user = insert(:user)
1563
1564     {:ok, user} = User.mute(user, other_user)
1565
1566     conn =
1567       conn
1568       |> assign(:user, user)
1569       |> get("/api/v1/mutes")
1570
1571     other_user_id = to_string(other_user.id)
1572     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1573   end
1574
1575   test "blocking / unblocking a user", %{conn: conn} do
1576     user = insert(:user)
1577     other_user = insert(:user)
1578
1579     conn =
1580       conn
1581       |> assign(:user, user)
1582       |> post("/api/v1/accounts/#{other_user.id}/block")
1583
1584     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1585
1586     user = Repo.get(User, user.id)
1587
1588     conn =
1589       build_conn()
1590       |> assign(:user, user)
1591       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1592
1593     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1594   end
1595
1596   test "getting a list of blocks", %{conn: conn} do
1597     user = insert(:user)
1598     other_user = insert(:user)
1599
1600     {:ok, user} = User.block(user, other_user)
1601
1602     conn =
1603       conn
1604       |> assign(:user, user)
1605       |> get("/api/v1/blocks")
1606
1607     other_user_id = to_string(other_user.id)
1608     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1609   end
1610
1611   test "blocking / unblocking a domain", %{conn: conn} do
1612     user = insert(:user)
1613     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1614
1615     conn =
1616       conn
1617       |> assign(:user, user)
1618       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1619
1620     assert %{} = json_response(conn, 200)
1621     user = User.get_cached_by_ap_id(user.ap_id)
1622     assert User.blocks?(user, other_user)
1623
1624     conn =
1625       build_conn()
1626       |> assign(:user, user)
1627       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1628
1629     assert %{} = json_response(conn, 200)
1630     user = User.get_cached_by_ap_id(user.ap_id)
1631     refute User.blocks?(user, other_user)
1632   end
1633
1634   test "getting a list of domain blocks", %{conn: conn} do
1635     user = insert(:user)
1636
1637     {:ok, user} = User.block_domain(user, "bad.site")
1638     {:ok, user} = User.block_domain(user, "even.worse.site")
1639
1640     conn =
1641       conn
1642       |> assign(:user, user)
1643       |> get("/api/v1/domain_blocks")
1644
1645     domain_blocks = json_response(conn, 200)
1646
1647     assert "bad.site" in domain_blocks
1648     assert "even.worse.site" in domain_blocks
1649   end
1650
1651   test "unimplemented follow_requests, blocks, domain blocks" do
1652     user = insert(:user)
1653
1654     ["blocks", "domain_blocks", "follow_requests"]
1655     |> Enum.each(fn endpoint ->
1656       conn =
1657         build_conn()
1658         |> assign(:user, user)
1659         |> get("/api/v1/#{endpoint}")
1660
1661       assert [] = json_response(conn, 200)
1662     end)
1663   end
1664
1665   test "account search", %{conn: conn} do
1666     user = insert(:user)
1667     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1668     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1669
1670     results =
1671       conn
1672       |> assign(:user, user)
1673       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1674       |> json_response(200)
1675
1676     result_ids = for result <- results, do: result["acct"]
1677
1678     assert user_two.nickname in result_ids
1679     assert user_three.nickname in result_ids
1680
1681     results =
1682       conn
1683       |> assign(:user, user)
1684       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1685       |> json_response(200)
1686
1687     result_ids = for result <- results, do: result["acct"]
1688
1689     assert user_three.nickname in result_ids
1690   end
1691
1692   test "search", %{conn: conn} do
1693     user = insert(:user)
1694     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1695     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1696
1697     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1698
1699     {:ok, _activity} =
1700       CommonAPI.post(user, %{
1701         "status" => "This is about 2hu, but private",
1702         "visibility" => "private"
1703       })
1704
1705     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1706
1707     conn =
1708       conn
1709       |> get("/api/v1/search", %{"q" => "2hu"})
1710
1711     assert results = json_response(conn, 200)
1712
1713     [account | _] = results["accounts"]
1714     assert account["id"] == to_string(user_three.id)
1715
1716     assert results["hashtags"] == []
1717
1718     [status] = results["statuses"]
1719     assert status["id"] == to_string(activity.id)
1720   end
1721
1722   test "search fetches remote statuses", %{conn: conn} do
1723     capture_log(fn ->
1724       conn =
1725         conn
1726         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1727
1728       assert results = json_response(conn, 200)
1729
1730       [status] = results["statuses"]
1731       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1732     end)
1733   end
1734
1735   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1736     {:ok, activity} =
1737       CommonAPI.post(insert(:user), %{
1738         "status" => "This is about 2hu, but private",
1739         "visibility" => "private"
1740       })
1741
1742     capture_log(fn ->
1743       conn =
1744         conn
1745         |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1746
1747       assert results = json_response(conn, 200)
1748
1749       [] = results["statuses"]
1750     end)
1751   end
1752
1753   test "search fetches remote accounts", %{conn: conn} do
1754     conn =
1755       conn
1756       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1757
1758     assert results = json_response(conn, 200)
1759     [account] = results["accounts"]
1760     assert account["acct"] == "shp@social.heldscal.la"
1761   end
1762
1763   test "returns the favorites of a user", %{conn: conn} do
1764     user = insert(:user)
1765     other_user = insert(:user)
1766
1767     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1768     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1769
1770     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1771
1772     first_conn =
1773       conn
1774       |> assign(:user, user)
1775       |> get("/api/v1/favourites")
1776
1777     assert [status] = json_response(first_conn, 200)
1778     assert status["id"] == to_string(activity.id)
1779
1780     assert [{"link", _link_header}] =
1781              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1782
1783     # Honours query params
1784     {:ok, second_activity} =
1785       CommonAPI.post(other_user, %{
1786         "status" =>
1787           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1788       })
1789
1790     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1791
1792     last_like = status["id"]
1793
1794     second_conn =
1795       conn
1796       |> assign(:user, user)
1797       |> get("/api/v1/favourites?since_id=#{last_like}")
1798
1799     assert [second_status] = json_response(second_conn, 200)
1800     assert second_status["id"] == to_string(second_activity.id)
1801
1802     third_conn =
1803       conn
1804       |> assign(:user, user)
1805       |> get("/api/v1/favourites?limit=0")
1806
1807     assert [] = json_response(third_conn, 200)
1808   end
1809
1810   describe "updating credentials" do
1811     test "updates the user's bio", %{conn: conn} do
1812       user = insert(:user)
1813       user2 = insert(:user)
1814
1815       conn =
1816         conn
1817         |> assign(:user, user)
1818         |> patch("/api/v1/accounts/update_credentials", %{
1819           "note" => "I drink #cofe with @#{user2.nickname}"
1820         })
1821
1822       assert user = json_response(conn, 200)
1823
1824       assert user["note"] ==
1825                ~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe" rel="tag">#cofe</a> with <span class="h-card"><a data-user=") <>
1826                  user2.id <>
1827                  ~s(" class="u-url mention" href=") <>
1828                  user2.ap_id <> ~s(">@<span>) <> user2.nickname <> ~s(</span></a></span>)
1829     end
1830
1831     test "updates the user's locking status", %{conn: conn} do
1832       user = insert(:user)
1833
1834       conn =
1835         conn
1836         |> assign(:user, user)
1837         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1838
1839       assert user = json_response(conn, 200)
1840       assert user["locked"] == true
1841     end
1842
1843     test "updates the user's name", %{conn: conn} do
1844       user = insert(:user)
1845
1846       conn =
1847         conn
1848         |> assign(:user, user)
1849         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1850
1851       assert user = json_response(conn, 200)
1852       assert user["display_name"] == "markorepairs"
1853     end
1854
1855     test "updates the user's avatar", %{conn: conn} do
1856       user = insert(:user)
1857
1858       new_avatar = %Plug.Upload{
1859         content_type: "image/jpg",
1860         path: Path.absname("test/fixtures/image.jpg"),
1861         filename: "an_image.jpg"
1862       }
1863
1864       conn =
1865         conn
1866         |> assign(:user, user)
1867         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1868
1869       assert user_response = json_response(conn, 200)
1870       assert user_response["avatar"] != User.avatar_url(user)
1871     end
1872
1873     test "updates the user's banner", %{conn: conn} do
1874       user = insert(:user)
1875
1876       new_header = %Plug.Upload{
1877         content_type: "image/jpg",
1878         path: Path.absname("test/fixtures/image.jpg"),
1879         filename: "an_image.jpg"
1880       }
1881
1882       conn =
1883         conn
1884         |> assign(:user, user)
1885         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1886
1887       assert user_response = json_response(conn, 200)
1888       assert user_response["header"] != User.banner_url(user)
1889     end
1890
1891     test "requires 'write' permission", %{conn: conn} do
1892       token1 = insert(:oauth_token, scopes: ["read"])
1893       token2 = insert(:oauth_token, scopes: ["write", "follow"])
1894
1895       for token <- [token1, token2] do
1896         conn =
1897           conn
1898           |> put_req_header("authorization", "Bearer #{token.token}")
1899           |> patch("/api/v1/accounts/update_credentials", %{})
1900
1901         if token == token1 do
1902           assert %{"error" => "Insufficient permissions: write."} == json_response(conn, 403)
1903         else
1904           assert json_response(conn, 200)
1905         end
1906       end
1907     end
1908   end
1909
1910   test "get instance information", %{conn: conn} do
1911     conn = get(conn, "/api/v1/instance")
1912     assert result = json_response(conn, 200)
1913
1914     # Note: not checking for "max_toot_chars" since it's optional
1915     assert %{
1916              "uri" => _,
1917              "title" => _,
1918              "description" => _,
1919              "version" => _,
1920              "email" => _,
1921              "urls" => %{
1922                "streaming_api" => _
1923              },
1924              "stats" => _,
1925              "thumbnail" => _,
1926              "languages" => _,
1927              "registrations" => _
1928            } = result
1929   end
1930
1931   test "get instance stats", %{conn: conn} do
1932     user = insert(:user, %{local: true})
1933
1934     user2 = insert(:user, %{local: true})
1935     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
1936
1937     insert(:user, %{local: false, nickname: "u@peer1.com"})
1938     insert(:user, %{local: false, nickname: "u@peer2.com"})
1939
1940     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1941
1942     # Stats should count users with missing or nil `info.deactivated` value
1943     user = Repo.get(User, user.id)
1944     info_change = Changeset.change(user.info, %{deactivated: nil})
1945
1946     {:ok, _user} =
1947       user
1948       |> Changeset.change()
1949       |> Changeset.put_embed(:info, info_change)
1950       |> User.update_and_set_cache()
1951
1952     Pleroma.Stats.update_stats()
1953
1954     conn = get(conn, "/api/v1/instance")
1955
1956     assert result = json_response(conn, 200)
1957
1958     stats = result["stats"]
1959
1960     assert stats
1961     assert stats["user_count"] == 1
1962     assert stats["status_count"] == 1
1963     assert stats["domain_count"] == 2
1964   end
1965
1966   test "get peers", %{conn: conn} do
1967     insert(:user, %{local: false, nickname: "u@peer1.com"})
1968     insert(:user, %{local: false, nickname: "u@peer2.com"})
1969
1970     Pleroma.Stats.update_stats()
1971
1972     conn = get(conn, "/api/v1/instance/peers")
1973
1974     assert result = json_response(conn, 200)
1975
1976     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
1977   end
1978
1979   test "put settings", %{conn: conn} do
1980     user = insert(:user)
1981
1982     conn =
1983       conn
1984       |> assign(:user, user)
1985       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1986
1987     assert _result = json_response(conn, 200)
1988
1989     user = User.get_cached_by_ap_id(user.ap_id)
1990     assert user.info.settings == %{"programming" => "socks"}
1991   end
1992
1993   describe "pinned statuses" do
1994     setup do
1995       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
1996
1997       user = insert(:user)
1998       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
1999
2000       [user: user, activity: activity]
2001     end
2002
2003     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
2004       {:ok, _} = CommonAPI.pin(activity.id, user)
2005
2006       result =
2007         conn
2008         |> assign(:user, user)
2009         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2010         |> json_response(200)
2011
2012       id_str = to_string(activity.id)
2013
2014       assert [%{"id" => ^id_str, "pinned" => true}] = result
2015     end
2016
2017     test "pin status", %{conn: conn, user: user, activity: activity} do
2018       id_str = to_string(activity.id)
2019
2020       assert %{"id" => ^id_str, "pinned" => true} =
2021                conn
2022                |> assign(:user, user)
2023                |> post("/api/v1/statuses/#{activity.id}/pin")
2024                |> json_response(200)
2025
2026       assert [%{"id" => ^id_str, "pinned" => true}] =
2027                conn
2028                |> assign(:user, user)
2029                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2030                |> json_response(200)
2031     end
2032
2033     test "unpin status", %{conn: conn, user: user, activity: activity} do
2034       {:ok, _} = CommonAPI.pin(activity.id, user)
2035
2036       id_str = to_string(activity.id)
2037       user = refresh_record(user)
2038
2039       assert %{"id" => ^id_str, "pinned" => false} =
2040                conn
2041                |> assign(:user, user)
2042                |> post("/api/v1/statuses/#{activity.id}/unpin")
2043                |> json_response(200)
2044
2045       assert [] =
2046                conn
2047                |> assign(:user, user)
2048                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2049                |> json_response(200)
2050     end
2051
2052     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
2053       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
2054
2055       id_str_one = to_string(activity_one.id)
2056
2057       assert %{"id" => ^id_str_one, "pinned" => true} =
2058                conn
2059                |> assign(:user, user)
2060                |> post("/api/v1/statuses/#{id_str_one}/pin")
2061                |> json_response(200)
2062
2063       user = refresh_record(user)
2064
2065       assert %{"error" => "You have already pinned the maximum number of statuses"} =
2066                conn
2067                |> assign(:user, user)
2068                |> post("/api/v1/statuses/#{activity_two.id}/pin")
2069                |> json_response(400)
2070     end
2071
2072     test "Status rich-media Card", %{conn: conn, user: user} do
2073       Pleroma.Config.put([:rich_media, :enabled], true)
2074       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})
2075
2076       response =
2077         conn
2078         |> get("/api/v1/statuses/#{activity.id}/card")
2079         |> json_response(200)
2080
2081       assert response == %{
2082                "image" => "http://ia.media-imdb.com/images/rock.jpg",
2083                "provider_name" => "www.imdb.com",
2084                "provider_url" => "http://www.imdb.com",
2085                "title" => "The Rock",
2086                "type" => "link",
2087                "url" => "http://www.imdb.com/title/tt0117500/",
2088                "description" => nil,
2089                "pleroma" => %{
2090                  "opengraph" => %{
2091                    "image" => "http://ia.media-imdb.com/images/rock.jpg",
2092                    "title" => "The Rock",
2093                    "type" => "video.movie",
2094                    "url" => "http://www.imdb.com/title/tt0117500/"
2095                  }
2096                }
2097              }
2098
2099       # works with private posts
2100       {:ok, activity} =
2101         CommonAPI.post(user, %{"status" => "http://example.com/ogp", "visibility" => "direct"})
2102
2103       response_two =
2104         conn
2105         |> assign(:user, user)
2106         |> get("/api/v1/statuses/#{activity.id}/card")
2107         |> json_response(200)
2108
2109       assert response_two == response
2110
2111       Pleroma.Config.put([:rich_media, :enabled], false)
2112     end
2113   end
2114
2115   test "bookmarks" do
2116     user = insert(:user)
2117     for_user = insert(:user)
2118
2119     {:ok, activity1} =
2120       CommonAPI.post(user, %{
2121         "status" => "heweoo?"
2122       })
2123
2124     {:ok, activity2} =
2125       CommonAPI.post(user, %{
2126         "status" => "heweoo!"
2127       })
2128
2129     response1 =
2130       build_conn()
2131       |> assign(:user, for_user)
2132       |> post("/api/v1/statuses/#{activity1.id}/bookmark")
2133
2134     assert json_response(response1, 200)["bookmarked"] == true
2135
2136     response2 =
2137       build_conn()
2138       |> assign(:user, for_user)
2139       |> post("/api/v1/statuses/#{activity2.id}/bookmark")
2140
2141     assert json_response(response2, 200)["bookmarked"] == true
2142
2143     bookmarks =
2144       build_conn()
2145       |> assign(:user, for_user)
2146       |> get("/api/v1/bookmarks")
2147
2148     assert [json_response(response2, 200), json_response(response1, 200)] ==
2149              json_response(bookmarks, 200)
2150
2151     response1 =
2152       build_conn()
2153       |> assign(:user, for_user)
2154       |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
2155
2156     assert json_response(response1, 200)["bookmarked"] == false
2157
2158     bookmarks =
2159       build_conn()
2160       |> assign(:user, for_user)
2161       |> get("/api/v1/bookmarks")
2162
2163     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
2164   end
2165
2166   describe "conversation muting" do
2167     setup do
2168       user = insert(:user)
2169       {:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})
2170
2171       [user: user, activity: activity]
2172     end
2173
2174     test "mute conversation", %{conn: conn, user: user, activity: activity} do
2175       id_str = to_string(activity.id)
2176
2177       assert %{"id" => ^id_str, "muted" => true} =
2178                conn
2179                |> assign(:user, user)
2180                |> post("/api/v1/statuses/#{activity.id}/mute")
2181                |> json_response(200)
2182     end
2183
2184     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
2185       {:ok, _} = CommonAPI.add_mute(user, activity)
2186
2187       id_str = to_string(activity.id)
2188       user = refresh_record(user)
2189
2190       assert %{"id" => ^id_str, "muted" => false} =
2191                conn
2192                |> assign(:user, user)
2193                |> post("/api/v1/statuses/#{activity.id}/unmute")
2194                |> json_response(200)
2195     end
2196   end
2197
2198   test "flavours switching (Pleroma Extension)", %{conn: conn} do
2199     user = insert(:user)
2200
2201     get_old_flavour =
2202       conn
2203       |> assign(:user, user)
2204       |> get("/api/v1/pleroma/flavour")
2205
2206     assert "glitch" == json_response(get_old_flavour, 200)
2207
2208     set_flavour =
2209       conn
2210       |> assign(:user, user)
2211       |> post("/api/v1/pleroma/flavour/vanilla")
2212
2213     assert "vanilla" == json_response(set_flavour, 200)
2214
2215     get_new_flavour =
2216       conn
2217       |> assign(:user, user)
2218       |> post("/api/v1/pleroma/flavour/vanilla")
2219
2220     assert json_response(set_flavour, 200) == json_response(get_new_flavour, 200)
2221   end
2222
2223   describe "reports" do
2224     setup do
2225       reporter = insert(:user)
2226       target_user = insert(:user)
2227
2228       {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
2229
2230       [reporter: reporter, target_user: target_user, activity: activity]
2231     end
2232
2233     test "submit a basic report", %{conn: conn, reporter: reporter, target_user: target_user} do
2234       assert %{"action_taken" => false, "id" => _} =
2235                conn
2236                |> assign(:user, reporter)
2237                |> post("/api/v1/reports", %{"account_id" => target_user.id})
2238                |> json_response(200)
2239     end
2240
2241     test "submit a report with statuses and comment", %{
2242       conn: conn,
2243       reporter: reporter,
2244       target_user: target_user,
2245       activity: activity
2246     } do
2247       assert %{"action_taken" => false, "id" => _} =
2248                conn
2249                |> assign(:user, reporter)
2250                |> post("/api/v1/reports", %{
2251                  "account_id" => target_user.id,
2252                  "status_ids" => [activity.id],
2253                  "comment" => "bad status!"
2254                })
2255                |> json_response(200)
2256     end
2257
2258     test "account_id is required", %{
2259       conn: conn,
2260       reporter: reporter,
2261       activity: activity
2262     } do
2263       assert %{"error" => "Valid `account_id` required"} =
2264                conn
2265                |> assign(:user, reporter)
2266                |> post("/api/v1/reports", %{"status_ids" => [activity.id]})
2267                |> json_response(400)
2268     end
2269
2270     test "comment must be up to the size specified in the config", %{
2271       conn: conn,
2272       reporter: reporter,
2273       target_user: target_user
2274     } do
2275       max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
2276       comment = String.pad_trailing("a", max_size + 1, "a")
2277
2278       error = %{"error" => "Comment must be up to #{max_size} characters"}
2279
2280       assert ^error =
2281                conn
2282                |> assign(:user, reporter)
2283                |> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
2284                |> json_response(400)
2285     end
2286   end
2287
2288   describe "link headers" do
2289     test "preserves parameters in link headers", %{conn: conn} do
2290       user = insert(:user)
2291       other_user = insert(:user)
2292
2293       {:ok, activity1} =
2294         CommonAPI.post(other_user, %{
2295           "status" => "hi @#{user.nickname}",
2296           "visibility" => "public"
2297         })
2298
2299       {:ok, activity2} =
2300         CommonAPI.post(other_user, %{
2301           "status" => "hi @#{user.nickname}",
2302           "visibility" => "public"
2303         })
2304
2305       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
2306       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
2307
2308       conn =
2309         conn
2310         |> assign(:user, user)
2311         |> get("/api/v1/notifications", %{media_only: true})
2312
2313       assert [link_header] = get_resp_header(conn, "link")
2314       assert link_header =~ ~r/media_only=true/
2315       assert link_header =~ ~r/since_id=#{notification2.id}/
2316       assert link_header =~ ~r/max_id=#{notification1.id}/
2317     end
2318   end
2319 end