git.squeep.com Git - akkoma/blob - test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Notification
   9   alias Pleroma.Repo
  10   alias Pleroma.User
  11   alias Pleroma.Web.CommonAPI
  12
  13   import Pleroma.Factory
  14
  15   test "does NOT render account/pleroma/relationship by default" do
  16     %{user: user, conn: conn} = oauth_access(["read:notifications"])
  17     other_user = insert(:user)
  18
  19     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
  20     {:ok, [_notification]} = Notification.create_notifications(activity)
  21
  22     response =
  23       conn
  24       |> assign(:user, user)
  25       |> get("/api/v1/notifications")
  26       |> json_response_and_validate_schema(200)
  27
  28     assert Enum.all?(response, fn n ->
  29              get_in(n, ["account", "pleroma", "relationship"]) == %{}
  30            end)
  31   end
  32
  33   test "list of notifications" do
  34     %{user: user, conn: conn} = oauth_access(["read:notifications"])
  35     other_user = insert(:user)
  36
  37     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
  38
  39     {:ok, [_notification]} = Notification.create_notifications(activity)
  40
  41     conn =
  42       conn
  43       |> assign(:user, user)
  44       |> get("/api/v1/notifications")
  45
  46     expected_response =
  47       "hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{user.ap_id}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
  48
  49     assert [%{"status" => %{"content" => response}} | _rest] =
  50              json_response_and_validate_schema(conn, 200)
  51
  52     assert response == expected_response
  53   end
  54
  55   test "by default, does not contain pleroma:chat_mention" do
  56     %{user: user, conn: conn} = oauth_access(["read:notifications"])
  57     other_user = insert(:user)
  58
  59     {:ok, _activity} = CommonAPI.post_chat_message(other_user, user, "hey")
  60
  61     result =
  62       conn
  63       |> get("/api/v1/notifications")
  64       |> json_response_and_validate_schema(200)
  65
  66     assert [] == result
  67
  68     result =
  69       conn
  70       |> get("/api/v1/notifications?include_types[]=pleroma:chat_mention")
  71       |> json_response_and_validate_schema(200)
  72
  73     assert [_] = result
  74   end
  75
  76   test "by default, does not contain pleroma:report" do
  77     %{user: user, conn: conn} = oauth_access(["read:notifications"])
  78     other_user = insert(:user)
  79     third_user = insert(:user)
  80
  81     user
  82     |> User.admin_api_update(%{is_moderator: true})
  83
  84     {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
  85
  86     {:ok, _report} =
  87       CommonAPI.report(third_user, %{account_id: other_user.id, status_ids: [activity.id]})
  88
  89     result =
  90       conn
  91       |> get("/api/v1/notifications")
  92       |> json_response_and_validate_schema(200)
  93
  94     assert [] == result
  95
  96     result =
  97       conn
  98       |> get("/api/v1/notifications?include_types[]=pleroma:report")
  99       |> json_response_and_validate_schema(200)
 100
 101     assert [_] = result
 102   end
 103
 104   test "excludes mentions from blockers when blockers_visible is false" do
 105     clear_config([:activitypub, :blockers_visible], false)
 106
 107     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 108     blocker = insert(:user)
 109
 110     {:ok, _} = CommonAPI.block(blocker, user)
 111     {:ok, activity} = CommonAPI.post(blocker, %{status: "hi @#{user.nickname}"})
 112
 113     {:ok, [_notification]} = Notification.create_notifications(activity)
 114
 115     conn =
 116       conn
 117       |> assign(:user, user)
 118       |> get("/api/v1/notifications")
 119
 120     assert [] == json_response_and_validate_schema(conn, 200)
 121   end
 122
 123   test "getting a single notification" do
 124     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 125     other_user = insert(:user)
 126
 127     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 128
 129     {:ok, [notification]} = Notification.create_notifications(activity)
 130
 131     conn = get(conn, "/api/v1/notifications/#{notification.id}")
 132
 133     expected_response =
 134       "hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{user.ap_id}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
 135
 136     assert %{"status" => %{"content" => response}} = json_response_and_validate_schema(conn, 200)
 137     assert response == expected_response
 138   end
 139
 140   test "dismissing a single notification (deprecated endpoint)" do
 141     %{user: user, conn: conn} = oauth_access(["write:notifications"])
 142     other_user = insert(:user)
 143
 144     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 145
 146     {:ok, [notification]} = Notification.create_notifications(activity)
 147
 148     conn =
 149       conn
 150       |> assign(:user, user)
 151       |> put_req_header("content-type", "application/json")
 152       |> post("/api/v1/notifications/dismiss", %{"id" => to_string(notification.id)})
 153
 154     assert %{} = json_response_and_validate_schema(conn, 200)
 155   end
 156
 157   test "dismissing a single notification" do
 158     %{user: user, conn: conn} = oauth_access(["write:notifications"])
 159     other_user = insert(:user)
 160
 161     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 162
 163     {:ok, [notification]} = Notification.create_notifications(activity)
 164
 165     conn =
 166       conn
 167       |> assign(:user, user)
 168       |> post("/api/v1/notifications/#{notification.id}/dismiss")
 169
 170     assert %{} = json_response_and_validate_schema(conn, 200)
 171   end
 172
 173   test "clearing all notifications" do
 174     %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
 175     other_user = insert(:user)
 176
 177     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 178
 179     {:ok, [_notification]} = Notification.create_notifications(activity)
 180
 181     ret_conn = post(conn, "/api/v1/notifications/clear")
 182
 183     assert %{} = json_response_and_validate_schema(ret_conn, 200)
 184
 185     ret_conn = get(conn, "/api/v1/notifications")
 186
 187     assert all = json_response_and_validate_schema(ret_conn, 200)
 188     assert all == []
 189   end
 190
 191   test "paginates notifications using min_id, since_id, max_id, and limit" do
 192     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 193     other_user = insert(:user)
 194
 195     {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 196     {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 197     {:ok, activity3} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 198     {:ok, activity4} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 199
 200     notification1_id = get_notification_id_by_activity(activity1)
 201     notification2_id = get_notification_id_by_activity(activity2)
 202     notification3_id = get_notification_id_by_activity(activity3)
 203     notification4_id = get_notification_id_by_activity(activity4)
 204
 205     conn = assign(conn, :user, user)
 206
 207     # min_id
 208     result =
 209       conn
 210       |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
 211       |> json_response_and_validate_schema(:ok)
 212
 213     assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 214
 215     # since_id
 216     result =
 217       conn
 218       |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
 219       |> json_response_and_validate_schema(:ok)
 220
 221     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 222
 223     # max_id
 224     result =
 225       conn
 226       |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
 227       |> json_response_and_validate_schema(:ok)
 228
 229     assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 230   end
 231
 232   describe "exclude_visibilities" do
 233     test "filters notifications for mentions" do
 234       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 235       other_user = insert(:user)
 236
 237       {:ok, public_activity} =
 238         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "public"})
 239
 240       {:ok, direct_activity} =
 241         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 242
 243       {:ok, unlisted_activity} =
 244         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "unlisted"})
 245
 246       {:ok, private_activity} =
 247         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "private"})
 248
 249       query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
 250       conn_res = get(conn, "/api/v1/notifications?" <> query)
 251
 252       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 253       assert id == direct_activity.id
 254
 255       query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "direct"]})
 256       conn_res = get(conn, "/api/v1/notifications?" <> query)
 257
 258       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 259       assert id == private_activity.id
 260
 261       query = params_to_query(%{exclude_visibilities: ["public", "private", "direct"]})
 262       conn_res = get(conn, "/api/v1/notifications?" <> query)
 263
 264       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 265       assert id == unlisted_activity.id
 266
 267       query = params_to_query(%{exclude_visibilities: ["unlisted", "private", "direct"]})
 268       conn_res = get(conn, "/api/v1/notifications?" <> query)
 269
 270       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 271       assert id == public_activity.id
 272     end
 273
 274     test "filters notifications for Like activities" do
 275       user = insert(:user)
 276       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 277
 278       {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
 279
 280       {:ok, direct_activity} =
 281         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 282
 283       {:ok, unlisted_activity} =
 284         CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 285
 286       {:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})
 287
 288       {:ok, _} = CommonAPI.favorite(user, public_activity.id)
 289       {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
 290       {:ok, _} = CommonAPI.favorite(user, unlisted_activity.id)
 291       {:ok, _} = CommonAPI.favorite(user, private_activity.id)
 292
 293       activity_ids =
 294         conn
 295         |> get("/api/v1/notifications?exclude_visibilities[]=direct")
 296         |> json_response_and_validate_schema(200)
 297         |> Enum.map(& &1["status"]["id"])
 298
 299       assert public_activity.id in activity_ids
 300       assert unlisted_activity.id in activity_ids
 301       assert private_activity.id in activity_ids
 302       refute direct_activity.id in activity_ids
 303
 304       activity_ids =
 305         conn
 306         |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
 307         |> json_response_and_validate_schema(200)
 308         |> Enum.map(& &1["status"]["id"])
 309
 310       assert public_activity.id in activity_ids
 311       refute unlisted_activity.id in activity_ids
 312       assert private_activity.id in activity_ids
 313       assert direct_activity.id in activity_ids
 314
 315       activity_ids =
 316         conn
 317         |> get("/api/v1/notifications?exclude_visibilities[]=private")
 318         |> json_response_and_validate_schema(200)
 319         |> Enum.map(& &1["status"]["id"])
 320
 321       assert public_activity.id in activity_ids
 322       assert unlisted_activity.id in activity_ids
 323       refute private_activity.id in activity_ids
 324       assert direct_activity.id in activity_ids
 325
 326       activity_ids =
 327         conn
 328         |> get("/api/v1/notifications?exclude_visibilities[]=public")
 329         |> json_response_and_validate_schema(200)
 330         |> Enum.map(& &1["status"]["id"])
 331
 332       refute public_activity.id in activity_ids
 333       assert unlisted_activity.id in activity_ids
 334       assert private_activity.id in activity_ids
 335       assert direct_activity.id in activity_ids
 336     end
 337
 338     test "filters notifications for Announce activities" do
 339       user = insert(:user)
 340       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 341
 342       {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
 343
 344       {:ok, unlisted_activity} =
 345         CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 346
 347       {:ok, _} = CommonAPI.repeat(public_activity.id, user)
 348       {:ok, _} = CommonAPI.repeat(unlisted_activity.id, user)
 349
 350       activity_ids =
 351         conn
 352         |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
 353         |> json_response_and_validate_schema(200)
 354         |> Enum.map(& &1["status"]["id"])
 355
 356       assert public_activity.id in activity_ids
 357       refute unlisted_activity.id in activity_ids
 358     end
 359
 360     test "doesn't return less than the requested amount of records when the user's reply is liked" do
 361       user = insert(:user)
 362       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 363
 364       {:ok, mention} =
 365         CommonAPI.post(user, %{status: "@#{other_user.nickname}", visibility: "public"})
 366
 367       {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 368
 369       {:ok, reply} =
 370         CommonAPI.post(other_user, %{
 371           status: ".",
 372           visibility: "public",
 373           in_reply_to_status_id: activity.id
 374         })
 375
 376       {:ok, _favorite} = CommonAPI.favorite(user, reply.id)
 377
 378       activity_ids =
 379         conn
 380         |> get("/api/v1/notifications?exclude_visibilities[]=direct&limit=2")
 381         |> json_response_and_validate_schema(200)
 382         |> Enum.map(& &1["status"]["id"])
 383
 384       assert [reply.id, mention.id] == activity_ids
 385     end
 386   end
 387
 388   test "filters notifications using exclude_types" do
 389     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 390     other_user = insert(:user)
 391
 392     {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
 393     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 394     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
 395     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
 396     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 397
 398     mention_notification_id = get_notification_id_by_activity(mention_activity)
 399     favorite_notification_id = get_notification_id_by_activity(favorite_activity)
 400     reblog_notification_id = get_notification_id_by_activity(reblog_activity)
 401     follow_notification_id = get_notification_id_by_activity(follow_activity)
 402
 403     query = params_to_query(%{exclude_types: ["mention", "favourite", "reblog"]})
 404     conn_res = get(conn, "/api/v1/notifications?" <> query)
 405
 406     assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 407
 408     query = params_to_query(%{exclude_types: ["favourite", "reblog", "follow"]})
 409     conn_res = get(conn, "/api/v1/notifications?" <> query)
 410
 411     assert [%{"id" => ^mention_notification_id}] =
 412              json_response_and_validate_schema(conn_res, 200)
 413
 414     query = params_to_query(%{exclude_types: ["reblog", "follow", "mention"]})
 415     conn_res = get(conn, "/api/v1/notifications?" <> query)
 416
 417     assert [%{"id" => ^favorite_notification_id}] =
 418              json_response_and_validate_schema(conn_res, 200)
 419
 420     query = params_to_query(%{exclude_types: ["follow", "mention", "favourite"]})
 421     conn_res = get(conn, "/api/v1/notifications?" <> query)
 422
 423     assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 424   end
 425
 426   test "filters notifications using include_types" do
 427     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 428     other_user = insert(:user)
 429
 430     {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
 431     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 432     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
 433     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
 434     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 435
 436     mention_notification_id = get_notification_id_by_activity(mention_activity)
 437     favorite_notification_id = get_notification_id_by_activity(favorite_activity)
 438     reblog_notification_id = get_notification_id_by_activity(reblog_activity)
 439     follow_notification_id = get_notification_id_by_activity(follow_activity)
 440
 441     conn_res = get(conn, "/api/v1/notifications?include_types[]=follow")
 442
 443     assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 444
 445     conn_res = get(conn, "/api/v1/notifications?include_types[]=mention")
 446
 447     assert [%{"id" => ^mention_notification_id}] =
 448              json_response_and_validate_schema(conn_res, 200)
 449
 450     conn_res = get(conn, "/api/v1/notifications?include_types[]=favourite")
 451
 452     assert [%{"id" => ^favorite_notification_id}] =
 453              json_response_and_validate_schema(conn_res, 200)
 454
 455     conn_res = get(conn, "/api/v1/notifications?include_types[]=reblog")
 456
 457     assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 458
 459     result = conn |> get("/api/v1/notifications") |> json_response_and_validate_schema(200)
 460
 461     assert length(result) == 4
 462
 463     query = params_to_query(%{include_types: ["follow", "mention", "favourite", "reblog"]})
 464
 465     result =
 466       conn
 467       |> get("/api/v1/notifications?" <> query)
 468       |> json_response_and_validate_schema(200)
 469
 470     assert length(result) == 4
 471   end
 472
 473   test "destroy multiple" do
 474     %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
 475     other_user = insert(:user)
 476
 477     {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 478     {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 479     {:ok, activity3} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
 480     {:ok, activity4} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
 481
 482     notification1_id = get_notification_id_by_activity(activity1)
 483     notification2_id = get_notification_id_by_activity(activity2)
 484     notification3_id = get_notification_id_by_activity(activity3)
 485     notification4_id = get_notification_id_by_activity(activity4)
 486
 487     result =
 488       conn
 489       |> get("/api/v1/notifications")
 490       |> json_response_and_validate_schema(:ok)
 491
 492     assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result
 493
 494     conn2 =
 495       conn
 496       |> assign(:user, other_user)
 497       |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))
 498
 499     result =
 500       conn2
 501       |> get("/api/v1/notifications")
 502       |> json_response_and_validate_schema(:ok)
 503
 504     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 505
 506     query = params_to_query(%{ids: [notification1_id, notification2_id]})
 507     conn_destroy = delete(conn, "/api/v1/notifications/destroy_multiple?" <> query)
 508
 509     assert json_response_and_validate_schema(conn_destroy, 200) == %{}
 510
 511     result =
 512       conn2
 513       |> get("/api/v1/notifications")
 514       |> json_response_and_validate_schema(:ok)
 515
 516     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 517   end
 518
 519   test "doesn't see notifications after muting user with notifications" do
 520     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 521     user2 = insert(:user)
 522
 523     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 524     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 525
 526     ret_conn = get(conn, "/api/v1/notifications")
 527
 528     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 529
 530     {:ok, _user_relationships} = User.mute(user, user2)
 531
 532     conn = get(conn, "/api/v1/notifications")
 533
 534     assert json_response_and_validate_schema(conn, 200) == []
 535   end
 536
 537   test "see notifications after muting user without notifications" do
 538     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 539     user2 = insert(:user)
 540
 541     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 542     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 543
 544     ret_conn = get(conn, "/api/v1/notifications")
 545
 546     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 547
 548     {:ok, _user_relationships} = User.mute(user, user2, %{notifications: false})
 549
 550     conn = get(conn, "/api/v1/notifications")
 551
 552     assert length(json_response_and_validate_schema(conn, 200)) == 1
 553   end
 554
 555   test "see notifications after muting user with notifications and with_muted parameter" do
 556     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 557     user2 = insert(:user)
 558
 559     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 560     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 561
 562     ret_conn = get(conn, "/api/v1/notifications")
 563
 564     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 565
 566     {:ok, _user_relationships} = User.mute(user, user2)
 567
 568     conn = get(conn, "/api/v1/notifications?with_muted=true")
 569
 570     assert length(json_response_and_validate_schema(conn, 200)) == 1
 571   end
 572
 573   test "see move notifications" do
 574     old_user = insert(:user)
 575     new_user = insert(:user, also_known_as: [old_user.ap_id])
 576     %{user: follower, conn: conn} = oauth_access(["read:notifications"])
 577
 578     User.follow(follower, old_user)
 579     Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
 580     Pleroma.Tests.ObanHelpers.perform_all()
 581
 582     conn = get(conn, "/api/v1/notifications")
 583
 584     assert length(json_response_and_validate_schema(conn, 200)) == 1
 585   end
 586
 587   describe "link headers" do
 588     test "preserves parameters in link headers" do
 589       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 590       other_user = insert(:user)
 591
 592       {:ok, activity1} =
 593         CommonAPI.post(other_user, %{
 594           status: "hi @#{user.nickname}",
 595           visibility: "public"
 596         })
 597
 598       {:ok, activity2} =
 599         CommonAPI.post(other_user, %{
 600           status: "hi @#{user.nickname}",
 601           visibility: "public"
 602         })
 603
 604       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
 605       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
 606
 607       conn =
 608         conn
 609         |> assign(:user, user)
 610         |> get("/api/v1/notifications?limit=5")
 611
 612       assert [link_header] = get_resp_header(conn, "link")
 613       assert link_header =~ ~r/limit=5/
 614       assert link_header =~ ~r/min_id=#{notification2.id}/
 615       assert link_header =~ ~r/max_id=#{notification1.id}/
 616     end
 617   end
 618
 619   describe "from specified user" do
 620     test "account_id" do
 621       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 622
 623       %{id: account_id} = other_user1 = insert(:user)
 624       other_user2 = insert(:user)
 625
 626       {:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
 627       {:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})
 628
 629       assert [%{"account" => %{"id" => ^account_id}}] =
 630                conn
 631                |> assign(:user, user)
 632                |> get("/api/v1/notifications?account_id=#{account_id}")
 633                |> json_response_and_validate_schema(200)
 634
 635       assert %{"error" => "Account is not found"} =
 636                conn
 637                |> assign(:user, user)
 638                |> get("/api/v1/notifications?account_id=cofe")
 639                |> json_response_and_validate_schema(404)
 640     end
 641   end
 642
 643   defp get_notification_id_by_activity(%{id: id}) do
 644     Notification
 645     |> Repo.get_by(activity_id: id)
 646     |> Map.get(:id)
 647     |> to_string()
 648   end
 649
 650   defp params_to_query(%{} = params) do
 651     Enum.map_join(params, "&", fn
 652       {k, v} when is_list(v) -> Enum.map_join(v, "&", &"#{k}[]=#{&1}")
 653       {k, v} -> k <> "=" <> v
 654     end)
 655   end
 656 end