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