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" 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       |> post("/api/v1/notifications/#{notification.id}/dismiss")
 152
 153     assert %{} = json_response_and_validate_schema(conn, 200)
 154   end
 155
 156   test "clearing all notifications" do
 157     %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
 158     other_user = insert(:user)
 159
 160     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 161
 162     {:ok, [_notification]} = Notification.create_notifications(activity)
 163
 164     ret_conn = post(conn, "/api/v1/notifications/clear")
 165
 166     assert %{} = json_response_and_validate_schema(ret_conn, 200)
 167
 168     ret_conn = get(conn, "/api/v1/notifications")
 169
 170     assert all = json_response_and_validate_schema(ret_conn, 200)
 171     assert all == []
 172   end
 173
 174   test "paginates notifications using min_id, since_id, max_id, and limit" do
 175     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 176     other_user = insert(:user)
 177
 178     {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 179     {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 180     {:ok, activity3} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 181     {:ok, activity4} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 182
 183     notification1_id = get_notification_id_by_activity(activity1)
 184     notification2_id = get_notification_id_by_activity(activity2)
 185     notification3_id = get_notification_id_by_activity(activity3)
 186     notification4_id = get_notification_id_by_activity(activity4)
 187
 188     conn = assign(conn, :user, user)
 189
 190     # min_id
 191     result =
 192       conn
 193       |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
 194       |> json_response_and_validate_schema(:ok)
 195
 196     assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 197
 198     # since_id
 199     result =
 200       conn
 201       |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
 202       |> json_response_and_validate_schema(:ok)
 203
 204     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 205
 206     # max_id
 207     result =
 208       conn
 209       |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
 210       |> json_response_and_validate_schema(:ok)
 211
 212     assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 213   end
 214
 215   describe "exclude_visibilities" do
 216     test "filters notifications for mentions" do
 217       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 218       other_user = insert(:user)
 219
 220       {:ok, public_activity} =
 221         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "public"})
 222
 223       {:ok, direct_activity} =
 224         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 225
 226       {:ok, unlisted_activity} =
 227         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "unlisted"})
 228
 229       {:ok, private_activity} =
 230         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "private"})
 231
 232       query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
 233       conn_res = get(conn, "/api/v1/notifications?" <> query)
 234
 235       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 236       assert id == direct_activity.id
 237
 238       query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "direct"]})
 239       conn_res = get(conn, "/api/v1/notifications?" <> query)
 240
 241       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 242       assert id == private_activity.id
 243
 244       query = params_to_query(%{exclude_visibilities: ["public", "private", "direct"]})
 245       conn_res = get(conn, "/api/v1/notifications?" <> query)
 246
 247       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 248       assert id == unlisted_activity.id
 249
 250       query = params_to_query(%{exclude_visibilities: ["unlisted", "private", "direct"]})
 251       conn_res = get(conn, "/api/v1/notifications?" <> query)
 252
 253       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 254       assert id == public_activity.id
 255     end
 256
 257     test "filters notifications for Like activities" do
 258       user = insert(:user)
 259       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 260
 261       {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
 262
 263       {:ok, direct_activity} =
 264         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 265
 266       {:ok, unlisted_activity} =
 267         CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 268
 269       {:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})
 270
 271       {:ok, _} = CommonAPI.favorite(user, public_activity.id)
 272       {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
 273       {:ok, _} = CommonAPI.favorite(user, unlisted_activity.id)
 274       {:ok, _} = CommonAPI.favorite(user, private_activity.id)
 275
 276       activity_ids =
 277         conn
 278         |> get("/api/v1/notifications?exclude_visibilities[]=direct")
 279         |> json_response_and_validate_schema(200)
 280         |> Enum.map(& &1["status"]["id"])
 281
 282       assert public_activity.id in activity_ids
 283       assert unlisted_activity.id in activity_ids
 284       assert private_activity.id in activity_ids
 285       refute direct_activity.id in activity_ids
 286
 287       activity_ids =
 288         conn
 289         |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
 290         |> json_response_and_validate_schema(200)
 291         |> Enum.map(& &1["status"]["id"])
 292
 293       assert public_activity.id in activity_ids
 294       refute unlisted_activity.id in activity_ids
 295       assert private_activity.id in activity_ids
 296       assert direct_activity.id in activity_ids
 297
 298       activity_ids =
 299         conn
 300         |> get("/api/v1/notifications?exclude_visibilities[]=private")
 301         |> json_response_and_validate_schema(200)
 302         |> Enum.map(& &1["status"]["id"])
 303
 304       assert public_activity.id in activity_ids
 305       assert unlisted_activity.id in activity_ids
 306       refute private_activity.id in activity_ids
 307       assert direct_activity.id in activity_ids
 308
 309       activity_ids =
 310         conn
 311         |> get("/api/v1/notifications?exclude_visibilities[]=public")
 312         |> json_response_and_validate_schema(200)
 313         |> Enum.map(& &1["status"]["id"])
 314
 315       refute public_activity.id in activity_ids
 316       assert unlisted_activity.id in activity_ids
 317       assert private_activity.id in activity_ids
 318       assert direct_activity.id in activity_ids
 319     end
 320
 321     test "filters notifications for Announce activities" do
 322       user = insert(:user)
 323       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 324
 325       {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
 326
 327       {:ok, unlisted_activity} =
 328         CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 329
 330       {:ok, _} = CommonAPI.repeat(public_activity.id, user)
 331       {:ok, _} = CommonAPI.repeat(unlisted_activity.id, user)
 332
 333       activity_ids =
 334         conn
 335         |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
 336         |> json_response_and_validate_schema(200)
 337         |> Enum.map(& &1["status"]["id"])
 338
 339       assert public_activity.id in activity_ids
 340       refute unlisted_activity.id in activity_ids
 341     end
 342
 343     test "doesn't return less than the requested amount of records when the user's reply is liked" do
 344       user = insert(:user)
 345       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 346
 347       {:ok, mention} =
 348         CommonAPI.post(user, %{status: "@#{other_user.nickname}", visibility: "public"})
 349
 350       {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 351
 352       {:ok, reply} =
 353         CommonAPI.post(other_user, %{
 354           status: ".",
 355           visibility: "public",
 356           in_reply_to_status_id: activity.id
 357         })
 358
 359       {:ok, _favorite} = CommonAPI.favorite(user, reply.id)
 360
 361       activity_ids =
 362         conn
 363         |> get("/api/v1/notifications?exclude_visibilities[]=direct&limit=2")
 364         |> json_response_and_validate_schema(200)
 365         |> Enum.map(& &1["status"]["id"])
 366
 367       assert [reply.id, mention.id] == activity_ids
 368     end
 369   end
 370
 371   test "filters notifications using exclude_types" do
 372     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 373     other_user = insert(:user)
 374
 375     {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
 376     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 377     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
 378     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
 379     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 380
 381     mention_notification_id = get_notification_id_by_activity(mention_activity)
 382     favorite_notification_id = get_notification_id_by_activity(favorite_activity)
 383     reblog_notification_id = get_notification_id_by_activity(reblog_activity)
 384     follow_notification_id = get_notification_id_by_activity(follow_activity)
 385
 386     query = params_to_query(%{exclude_types: ["mention", "favourite", "reblog"]})
 387     conn_res = get(conn, "/api/v1/notifications?" <> query)
 388
 389     assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 390
 391     query = params_to_query(%{exclude_types: ["favourite", "reblog", "follow"]})
 392     conn_res = get(conn, "/api/v1/notifications?" <> query)
 393
 394     assert [%{"id" => ^mention_notification_id}] =
 395              json_response_and_validate_schema(conn_res, 200)
 396
 397     query = params_to_query(%{exclude_types: ["reblog", "follow", "mention"]})
 398     conn_res = get(conn, "/api/v1/notifications?" <> query)
 399
 400     assert [%{"id" => ^favorite_notification_id}] =
 401              json_response_and_validate_schema(conn_res, 200)
 402
 403     query = params_to_query(%{exclude_types: ["follow", "mention", "favourite"]})
 404     conn_res = get(conn, "/api/v1/notifications?" <> query)
 405
 406     assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 407   end
 408
 409   test "filters notifications using include_types" do
 410     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 411     other_user = insert(:user)
 412
 413     {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
 414     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 415     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
 416     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
 417     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 418
 419     mention_notification_id = get_notification_id_by_activity(mention_activity)
 420     favorite_notification_id = get_notification_id_by_activity(favorite_activity)
 421     reblog_notification_id = get_notification_id_by_activity(reblog_activity)
 422     follow_notification_id = get_notification_id_by_activity(follow_activity)
 423
 424     conn_res = get(conn, "/api/v1/notifications?include_types[]=follow")
 425
 426     assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 427
 428     conn_res = get(conn, "/api/v1/notifications?include_types[]=mention")
 429
 430     assert [%{"id" => ^mention_notification_id}] =
 431              json_response_and_validate_schema(conn_res, 200)
 432
 433     conn_res = get(conn, "/api/v1/notifications?include_types[]=favourite")
 434
 435     assert [%{"id" => ^favorite_notification_id}] =
 436              json_response_and_validate_schema(conn_res, 200)
 437
 438     conn_res = get(conn, "/api/v1/notifications?include_types[]=reblog")
 439
 440     assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 441
 442     result = conn |> get("/api/v1/notifications") |> json_response_and_validate_schema(200)
 443
 444     assert length(result) == 4
 445
 446     query = params_to_query(%{include_types: ["follow", "mention", "favourite", "reblog"]})
 447
 448     result =
 449       conn
 450       |> get("/api/v1/notifications?" <> query)
 451       |> json_response_and_validate_schema(200)
 452
 453     assert length(result) == 4
 454   end
 455
 456   test "destroy multiple" do
 457     %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
 458     other_user = insert(:user)
 459
 460     {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 461     {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 462     {:ok, activity3} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
 463     {:ok, activity4} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
 464
 465     notification1_id = get_notification_id_by_activity(activity1)
 466     notification2_id = get_notification_id_by_activity(activity2)
 467     notification3_id = get_notification_id_by_activity(activity3)
 468     notification4_id = get_notification_id_by_activity(activity4)
 469
 470     result =
 471       conn
 472       |> get("/api/v1/notifications")
 473       |> json_response_and_validate_schema(:ok)
 474
 475     assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result
 476
 477     conn2 =
 478       conn
 479       |> assign(:user, other_user)
 480       |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))
 481
 482     result =
 483       conn2
 484       |> get("/api/v1/notifications")
 485       |> json_response_and_validate_schema(:ok)
 486
 487     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 488
 489     query = params_to_query(%{ids: [notification1_id, notification2_id]})
 490     conn_destroy = delete(conn, "/api/v1/notifications/destroy_multiple?" <> query)
 491
 492     assert json_response_and_validate_schema(conn_destroy, 200) == %{}
 493
 494     result =
 495       conn2
 496       |> get("/api/v1/notifications")
 497       |> json_response_and_validate_schema(:ok)
 498
 499     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 500   end
 501
 502   test "doesn't see notifications after muting user with notifications" do
 503     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 504     user2 = insert(:user)
 505
 506     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 507     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 508
 509     ret_conn = get(conn, "/api/v1/notifications")
 510
 511     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 512
 513     {:ok, _user_relationships} = User.mute(user, user2)
 514
 515     conn = get(conn, "/api/v1/notifications")
 516
 517     assert json_response_and_validate_schema(conn, 200) == []
 518   end
 519
 520   test "see notifications after muting user without notifications" do
 521     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 522     user2 = insert(:user)
 523
 524     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 525     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 526
 527     ret_conn = get(conn, "/api/v1/notifications")
 528
 529     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 530
 531     {:ok, _user_relationships} = User.mute(user, user2, %{notifications: false})
 532
 533     conn = get(conn, "/api/v1/notifications")
 534
 535     assert length(json_response_and_validate_schema(conn, 200)) == 1
 536   end
 537
 538   test "see notifications after muting user with notifications and with_muted parameter" do
 539     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 540     user2 = insert(:user)
 541
 542     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 543     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 544
 545     ret_conn = get(conn, "/api/v1/notifications")
 546
 547     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 548
 549     {:ok, _user_relationships} = User.mute(user, user2)
 550
 551     conn = get(conn, "/api/v1/notifications?with_muted=true")
 552
 553     assert length(json_response_and_validate_schema(conn, 200)) == 1
 554   end
 555
 556   test "see move notifications" do
 557     old_user = insert(:user)
 558     new_user = insert(:user, also_known_as: [old_user.ap_id])
 559     %{user: follower, conn: conn} = oauth_access(["read:notifications"])
 560
 561     User.follow(follower, old_user)
 562     Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
 563     Pleroma.Tests.ObanHelpers.perform_all()
 564
 565     conn = get(conn, "/api/v1/notifications")
 566
 567     assert length(json_response_and_validate_schema(conn, 200)) == 1
 568   end
 569
 570   describe "link headers" do
 571     test "preserves parameters in link headers" do
 572       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 573       other_user = insert(:user)
 574
 575       {:ok, activity1} =
 576         CommonAPI.post(other_user, %{
 577           status: "hi @#{user.nickname}",
 578           visibility: "public"
 579         })
 580
 581       {:ok, activity2} =
 582         CommonAPI.post(other_user, %{
 583           status: "hi @#{user.nickname}",
 584           visibility: "public"
 585         })
 586
 587       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
 588       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
 589
 590       conn =
 591         conn
 592         |> assign(:user, user)
 593         |> get("/api/v1/notifications?limit=5")
 594
 595       assert [link_header] = get_resp_header(conn, "link")
 596       assert link_header =~ ~r/limit=5/
 597       assert link_header =~ ~r/min_id=#{notification2.id}/
 598       assert link_header =~ ~r/max_id=#{notification1.id}/
 599     end
 600   end
 601
 602   describe "from specified user" do
 603     test "account_id" do
 604       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 605
 606       %{id: account_id} = other_user1 = insert(:user)
 607       other_user2 = insert(:user)
 608
 609       {:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
 610       {:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})
 611
 612       assert [%{"account" => %{"id" => ^account_id}}] =
 613                conn
 614                |> assign(:user, user)
 615                |> get("/api/v1/notifications?account_id=#{account_id}")
 616                |> json_response_and_validate_schema(200)
 617
 618       assert %{"error" => "Account is not found"} =
 619                conn
 620                |> assign(:user, user)
 621                |> get("/api/v1/notifications?account_id=cofe")
 622                |> json_response_and_validate_schema(404)
 623     end
 624   end
 625
 626   defp get_notification_id_by_activity(%{id: id}) do
 627     Notification
 628     |> Repo.get_by(activity_id: id)
 629     |> Map.get(:id)
 630     |> to_string()
 631   end
 632
 633   defp params_to_query(%{} = params) do
 634     Enum.map_join(params, "&", fn
 635       {k, v} when is_list(v) -> Enum.map_join(v, "&", &"#{k}[]=#{&1}")
 636       {k, v} -> k <> "=" <> v
 637     end)
 638   end
 639 end