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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 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=\"#{
  48         user.ap_id
  49       }\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
  50
  51     assert [%{"status" => %{"content" => response}} | _rest] =
  52              json_response_and_validate_schema(conn, 200)
  53
  54     assert response == expected_response
  55   end
  56
  57   test "getting a single notification" do
  58     %{user: user, conn: conn} = oauth_access(["read:notifications"])
  59     other_user = insert(:user)
  60
  61     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
  62
  63     {:ok, [notification]} = Notification.create_notifications(activity)
  64
  65     conn = get(conn, "/api/v1/notifications/#{notification.id}")
  66
  67     expected_response =
  68       "hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{
  69         user.ap_id
  70       }\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
  71
  72     assert %{"status" => %{"content" => response}} = json_response_and_validate_schema(conn, 200)
  73     assert response == expected_response
  74   end
  75
  76   test "dismissing a single notification (deprecated endpoint)" do
  77     %{user: user, conn: conn} = oauth_access(["write:notifications"])
  78     other_user = insert(:user)
  79
  80     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
  81
  82     {:ok, [notification]} = Notification.create_notifications(activity)
  83
  84     conn =
  85       conn
  86       |> assign(:user, user)
  87       |> put_req_header("content-type", "application/json")
  88       |> post("/api/v1/notifications/dismiss", %{"id" => to_string(notification.id)})
  89
  90     assert %{} = json_response_and_validate_schema(conn, 200)
  91   end
  92
  93   test "dismissing a single notification" do
  94     %{user: user, conn: conn} = oauth_access(["write:notifications"])
  95     other_user = insert(:user)
  96
  97     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
  98
  99     {:ok, [notification]} = Notification.create_notifications(activity)
 100
 101     conn =
 102       conn
 103       |> assign(:user, user)
 104       |> post("/api/v1/notifications/#{notification.id}/dismiss")
 105
 106     assert %{} = json_response_and_validate_schema(conn, 200)
 107   end
 108
 109   test "clearing all notifications" do
 110     %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
 111     other_user = insert(:user)
 112
 113     {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 114
 115     {:ok, [_notification]} = Notification.create_notifications(activity)
 116
 117     ret_conn = post(conn, "/api/v1/notifications/clear")
 118
 119     assert %{} = json_response_and_validate_schema(ret_conn, 200)
 120
 121     ret_conn = get(conn, "/api/v1/notifications")
 122
 123     assert all = json_response_and_validate_schema(ret_conn, 200)
 124     assert all == []
 125   end
 126
 127   test "paginates notifications using min_id, since_id, max_id, and limit" do
 128     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 129     other_user = insert(:user)
 130
 131     {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 132     {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 133     {:ok, activity3} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 134     {:ok, activity4} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 135
 136     notification1_id = get_notification_id_by_activity(activity1)
 137     notification2_id = get_notification_id_by_activity(activity2)
 138     notification3_id = get_notification_id_by_activity(activity3)
 139     notification4_id = get_notification_id_by_activity(activity4)
 140
 141     conn = assign(conn, :user, user)
 142
 143     # min_id
 144     result =
 145       conn
 146       |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
 147       |> json_response_and_validate_schema(:ok)
 148
 149     assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 150
 151     # since_id
 152     result =
 153       conn
 154       |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
 155       |> json_response_and_validate_schema(:ok)
 156
 157     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 158
 159     # max_id
 160     result =
 161       conn
 162       |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
 163       |> json_response_and_validate_schema(:ok)
 164
 165     assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 166   end
 167
 168   describe "exclude_visibilities" do
 169     test "filters notifications for mentions" do
 170       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 171       other_user = insert(:user)
 172
 173       {:ok, public_activity} =
 174         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "public"})
 175
 176       {:ok, direct_activity} =
 177         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 178
 179       {:ok, unlisted_activity} =
 180         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "unlisted"})
 181
 182       {:ok, private_activity} =
 183         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "private"})
 184
 185       query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
 186       conn_res = get(conn, "/api/v1/notifications?" <> query)
 187
 188       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 189       assert id == direct_activity.id
 190
 191       query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "direct"]})
 192       conn_res = get(conn, "/api/v1/notifications?" <> query)
 193
 194       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 195       assert id == private_activity.id
 196
 197       query = params_to_query(%{exclude_visibilities: ["public", "private", "direct"]})
 198       conn_res = get(conn, "/api/v1/notifications?" <> query)
 199
 200       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 201       assert id == unlisted_activity.id
 202
 203       query = params_to_query(%{exclude_visibilities: ["unlisted", "private", "direct"]})
 204       conn_res = get(conn, "/api/v1/notifications?" <> query)
 205
 206       assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
 207       assert id == public_activity.id
 208     end
 209
 210     test "filters notifications for Like activities" do
 211       user = insert(:user)
 212       %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
 213
 214       {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
 215
 216       {:ok, direct_activity} =
 217         CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
 218
 219       {:ok, unlisted_activity} =
 220         CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 221
 222       {:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})
 223
 224       {:ok, _} = CommonAPI.favorite(user, public_activity.id)
 225       {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
 226       {:ok, _} = CommonAPI.favorite(user, unlisted_activity.id)
 227       {:ok, _} = CommonAPI.favorite(user, private_activity.id)
 228
 229       activity_ids =
 230         conn
 231         |> get("/api/v1/notifications?exclude_visibilities[]=direct")
 232         |> json_response_and_validate_schema(200)
 233         |> Enum.map(& &1["status"]["id"])
 234
 235       assert public_activity.id in activity_ids
 236       assert unlisted_activity.id in activity_ids
 237       assert private_activity.id in activity_ids
 238       refute direct_activity.id in activity_ids
 239
 240       activity_ids =
 241         conn
 242         |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
 243         |> json_response_and_validate_schema(200)
 244         |> Enum.map(& &1["status"]["id"])
 245
 246       assert public_activity.id in activity_ids
 247       refute unlisted_activity.id in activity_ids
 248       assert private_activity.id in activity_ids
 249       assert direct_activity.id in activity_ids
 250
 251       activity_ids =
 252         conn
 253         |> get("/api/v1/notifications?exclude_visibilities[]=private")
 254         |> json_response_and_validate_schema(200)
 255         |> Enum.map(& &1["status"]["id"])
 256
 257       assert public_activity.id in activity_ids
 258       assert unlisted_activity.id in activity_ids
 259       refute private_activity.id in activity_ids
 260       assert direct_activity.id in activity_ids
 261
 262       activity_ids =
 263         conn
 264         |> get("/api/v1/notifications?exclude_visibilities[]=public")
 265         |> json_response_and_validate_schema(200)
 266         |> Enum.map(& &1["status"]["id"])
 267
 268       refute public_activity.id in activity_ids
 269       assert unlisted_activity.id in activity_ids
 270       assert private_activity.id in activity_ids
 271       assert direct_activity.id in activity_ids
 272     end
 273
 274     test "filters notifications for Announce 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, unlisted_activity} =
 281         CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
 282
 283       {:ok, _} = CommonAPI.repeat(public_activity.id, user)
 284       {:ok, _} = CommonAPI.repeat(unlisted_activity.id, user)
 285
 286       activity_ids =
 287         conn
 288         |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
 289         |> json_response_and_validate_schema(200)
 290         |> Enum.map(& &1["status"]["id"])
 291
 292       assert public_activity.id in activity_ids
 293       refute unlisted_activity.id in activity_ids
 294     end
 295   end
 296
 297   test "filters notifications using exclude_types" do
 298     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 299     other_user = insert(:user)
 300
 301     {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
 302     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 303     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
 304     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
 305     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 306
 307     mention_notification_id = get_notification_id_by_activity(mention_activity)
 308     favorite_notification_id = get_notification_id_by_activity(favorite_activity)
 309     reblog_notification_id = get_notification_id_by_activity(reblog_activity)
 310     follow_notification_id = get_notification_id_by_activity(follow_activity)
 311
 312     query = params_to_query(%{exclude_types: ["mention", "favourite", "reblog"]})
 313     conn_res = get(conn, "/api/v1/notifications?" <> query)
 314
 315     assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 316
 317     query = params_to_query(%{exclude_types: ["favourite", "reblog", "follow"]})
 318     conn_res = get(conn, "/api/v1/notifications?" <> query)
 319
 320     assert [%{"id" => ^mention_notification_id}] =
 321              json_response_and_validate_schema(conn_res, 200)
 322
 323     query = params_to_query(%{exclude_types: ["reblog", "follow", "mention"]})
 324     conn_res = get(conn, "/api/v1/notifications?" <> query)
 325
 326     assert [%{"id" => ^favorite_notification_id}] =
 327              json_response_and_validate_schema(conn_res, 200)
 328
 329     query = params_to_query(%{exclude_types: ["follow", "mention", "favourite"]})
 330     conn_res = get(conn, "/api/v1/notifications?" <> query)
 331
 332     assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 333   end
 334
 335   test "filters notifications using include_types" do
 336     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 337     other_user = insert(:user)
 338
 339     {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
 340     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 341     {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
 342     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
 343     {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 344
 345     mention_notification_id = get_notification_id_by_activity(mention_activity)
 346     favorite_notification_id = get_notification_id_by_activity(favorite_activity)
 347     reblog_notification_id = get_notification_id_by_activity(reblog_activity)
 348     follow_notification_id = get_notification_id_by_activity(follow_activity)
 349
 350     conn_res = get(conn, "/api/v1/notifications?include_types[]=follow")
 351
 352     assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 353
 354     conn_res = get(conn, "/api/v1/notifications?include_types[]=mention")
 355
 356     assert [%{"id" => ^mention_notification_id}] =
 357              json_response_and_validate_schema(conn_res, 200)
 358
 359     conn_res = get(conn, "/api/v1/notifications?include_types[]=favourite")
 360
 361     assert [%{"id" => ^favorite_notification_id}] =
 362              json_response_and_validate_schema(conn_res, 200)
 363
 364     conn_res = get(conn, "/api/v1/notifications?include_types[]=reblog")
 365
 366     assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
 367
 368     result = conn |> get("/api/v1/notifications") |> json_response_and_validate_schema(200)
 369
 370     assert length(result) == 4
 371
 372     query = params_to_query(%{include_types: ["follow", "mention", "favourite", "reblog"]})
 373
 374     result =
 375       conn
 376       |> get("/api/v1/notifications?" <> query)
 377       |> json_response_and_validate_schema(200)
 378
 379     assert length(result) == 4
 380   end
 381
 382   test "destroy multiple" do
 383     %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
 384     other_user = insert(:user)
 385
 386     {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 387     {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
 388     {:ok, activity3} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
 389     {:ok, activity4} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
 390
 391     notification1_id = get_notification_id_by_activity(activity1)
 392     notification2_id = get_notification_id_by_activity(activity2)
 393     notification3_id = get_notification_id_by_activity(activity3)
 394     notification4_id = get_notification_id_by_activity(activity4)
 395
 396     result =
 397       conn
 398       |> get("/api/v1/notifications")
 399       |> json_response_and_validate_schema(:ok)
 400
 401     assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result
 402
 403     conn2 =
 404       conn
 405       |> assign(:user, other_user)
 406       |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))
 407
 408     result =
 409       conn2
 410       |> get("/api/v1/notifications")
 411       |> json_response_and_validate_schema(:ok)
 412
 413     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 414
 415     query = params_to_query(%{ids: [notification1_id, notification2_id]})
 416     conn_destroy = delete(conn, "/api/v1/notifications/destroy_multiple?" <> query)
 417
 418     assert json_response_and_validate_schema(conn_destroy, 200) == %{}
 419
 420     result =
 421       conn2
 422       |> get("/api/v1/notifications")
 423       |> json_response_and_validate_schema(:ok)
 424
 425     assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 426   end
 427
 428   test "doesn't see notifications after muting user with notifications" do
 429     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 430     user2 = insert(:user)
 431
 432     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 433     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 434
 435     ret_conn = get(conn, "/api/v1/notifications")
 436
 437     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 438
 439     {:ok, _user_relationships} = User.mute(user, user2)
 440
 441     conn = get(conn, "/api/v1/notifications")
 442
 443     assert json_response_and_validate_schema(conn, 200) == []
 444   end
 445
 446   test "see notifications after muting user without notifications" do
 447     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 448     user2 = insert(:user)
 449
 450     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 451     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 452
 453     ret_conn = get(conn, "/api/v1/notifications")
 454
 455     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 456
 457     {:ok, _user_relationships} = User.mute(user, user2, false)
 458
 459     conn = get(conn, "/api/v1/notifications")
 460
 461     assert length(json_response_and_validate_schema(conn, 200)) == 1
 462   end
 463
 464   test "see notifications after muting user with notifications and with_muted parameter" do
 465     %{user: user, conn: conn} = oauth_access(["read:notifications"])
 466     user2 = insert(:user)
 467
 468     {:ok, _, _, _} = CommonAPI.follow(user, user2)
 469     {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
 470
 471     ret_conn = get(conn, "/api/v1/notifications")
 472
 473     assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
 474
 475     {:ok, _user_relationships} = User.mute(user, user2)
 476
 477     conn = get(conn, "/api/v1/notifications?with_muted=true")
 478
 479     assert length(json_response_and_validate_schema(conn, 200)) == 1
 480   end
 481
 482   @tag capture_log: true
 483   test "see move notifications" do
 484     old_user = insert(:user)
 485     new_user = insert(:user, also_known_as: [old_user.ap_id])
 486     %{user: follower, conn: conn} = oauth_access(["read:notifications"])
 487
 488     old_user_url = old_user.ap_id
 489
 490     body =
 491       File.read!("test/fixtures/users_mock/localhost.json")
 492       |> String.replace("{{nickname}}", old_user.nickname)
 493       |> Jason.encode!()
 494
 495     Tesla.Mock.mock(fn
 496       %{method: :get, url: ^old_user_url} ->
 497         %Tesla.Env{status: 200, body: body}
 498     end)
 499
 500     User.follow(follower, old_user)
 501     Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
 502     Pleroma.Tests.ObanHelpers.perform_all()
 503
 504     conn = get(conn, "/api/v1/notifications")
 505
 506     assert length(json_response_and_validate_schema(conn, 200)) == 1
 507   end
 508
 509   describe "link headers" do
 510     test "preserves parameters in link headers" do
 511       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 512       other_user = insert(:user)
 513
 514       {:ok, activity1} =
 515         CommonAPI.post(other_user, %{
 516           status: "hi @#{user.nickname}",
 517           visibility: "public"
 518         })
 519
 520       {:ok, activity2} =
 521         CommonAPI.post(other_user, %{
 522           status: "hi @#{user.nickname}",
 523           visibility: "public"
 524         })
 525
 526       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
 527       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
 528
 529       conn =
 530         conn
 531         |> assign(:user, user)
 532         |> get("/api/v1/notifications?limit=5")
 533
 534       assert [link_header] = get_resp_header(conn, "link")
 535       assert link_header =~ ~r/limit=5/
 536       assert link_header =~ ~r/min_id=#{notification2.id}/
 537       assert link_header =~ ~r/max_id=#{notification1.id}/
 538     end
 539   end
 540
 541   describe "from specified user" do
 542     test "account_id" do
 543       %{user: user, conn: conn} = oauth_access(["read:notifications"])
 544
 545       %{id: account_id} = other_user1 = insert(:user)
 546       other_user2 = insert(:user)
 547
 548       {:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
 549       {:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})
 550
 551       assert [%{"account" => %{"id" => ^account_id}}] =
 552                conn
 553                |> assign(:user, user)
 554                |> get("/api/v1/notifications?account_id=#{account_id}")
 555                |> json_response_and_validate_schema(200)
 556
 557       assert %{"error" => "Account is not found"} =
 558                conn
 559                |> assign(:user, user)
 560                |> get("/api/v1/notifications?account_id=cofe")
 561                |> json_response_and_validate_schema(404)
 562     end
 563   end
 564
 565   defp get_notification_id_by_activity(%{id: id}) do
 566     Notification
 567     |> Repo.get_by(activity_id: id)
 568     |> Map.get(:id)
 569     |> to_string()
 570   end
 571
 572   defp params_to_query(%{} = params) do
 573     Enum.map_join(params, "&", fn
 574       {k, v} when is_list(v) -> Enum.map_join(v, "&", &"#{k}[]=#{&1}")
 575       {k, v} -> k <> "=" <> v
 576     end)
 577   end
 578 end