git.squeep.com Git - akkoma/blob - test/web/common_api/common_api_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.CommonAPITest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Activity
   8   alias Pleroma.Object
   9   alias Pleroma.User
  10   alias Pleroma.Web.CommonAPI
  11
  12   import Pleroma.Factory
  13
  14   test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
  15     har = insert(:user)
  16     jafnhar = insert(:user)
  17     tridi = insert(:user)
  18     option = Pleroma.Config.get([:instance, :safe_dm_mentions])
  19     Pleroma.Config.put([:instance, :safe_dm_mentions], true)
  20
  21     {:ok, activity} =
  22       CommonAPI.post(har, %{
  23         "status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
  24         "visibility" => "direct"
  25       })
  26
  27     refute tridi.ap_id in activity.recipients
  28     assert jafnhar.ap_id in activity.recipients
  29     Pleroma.Config.put([:instance, :safe_dm_mentions], option)
  30   end
  31
  32   test "it de-duplicates tags" do
  33     user = insert(:user)
  34     {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})
  35
  36     object = Object.normalize(activity.data["object"])
  37
  38     assert object.data["tag"] == ["2hu"]
  39   end
  40
  41   test "it adds emoji in the object" do
  42     user = insert(:user)
  43     {:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})
  44
  45     assert Object.normalize(activity).data["emoji"]["firefox"]
  46   end
  47
  48   test "it adds emoji when updating profiles" do
  49     user = insert(:user, %{name: ":firefox:"})
  50
  51     CommonAPI.update(user)
  52     user = User.get_cached_by_ap_id(user.ap_id)
  53     [firefox] = user.info.source_data["tag"]
  54
  55     assert firefox["name"] == ":firefox:"
  56   end
  57
  58   describe "posting" do
  59     test "it filters out obviously bad tags when accepting a post as HTML" do
  60       user = insert(:user)
  61
  62       post = "<p><b>2hu</b></p><script>alert('xss')</script>"
  63
  64       {:ok, activity} =
  65         CommonAPI.post(user, %{
  66           "status" => post,
  67           "content_type" => "text/html"
  68         })
  69
  70       object = Object.normalize(activity.data["object"])
  71
  72       assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
  73     end
  74
  75     test "it filters out obviously bad tags when accepting a post as Markdown" do
  76       user = insert(:user)
  77
  78       post = "<p><b>2hu</b></p><script>alert('xss')</script>"
  79
  80       {:ok, activity} =
  81         CommonAPI.post(user, %{
  82           "status" => post,
  83           "content_type" => "text/markdown"
  84         })
  85
  86       object = Object.normalize(activity.data["object"])
  87
  88       assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
  89     end
  90
  91     test "it does not allow replies to direct messages that are not direct messages themselves" do
  92       user = insert(:user)
  93
  94       {:ok, activity} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
  95
  96       assert {:ok, _} =
  97                CommonAPI.post(user, %{
  98                  "status" => "suya..",
  99                  "visibility" => "direct",
 100                  "in_reply_to_status_id" => activity.id
 101                })
 102
 103       Enum.each(["public", "private", "unlisted"], fn visibility ->
 104         assert {:error, {:private_to_public, _}} =
 105                  CommonAPI.post(user, %{
 106                    "status" => "suya..",
 107                    "visibility" => visibility,
 108                    "in_reply_to_status_id" => activity.id
 109                  })
 110       end)
 111     end
 112
 113     test "it allows to address a list" do
 114       user = insert(:user)
 115       {:ok, list} = Pleroma.List.create("foo", user)
 116
 117       {:ok, activity} =
 118         CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
 119
 120       assert activity.data["bcc"] == [list.ap_id]
 121       assert activity.recipients == [list.ap_id, user.ap_id]
 122     end
 123   end
 124
 125   describe "reactions" do
 126     test "repeating a status" do
 127       user = insert(:user)
 128       other_user = insert(:user)
 129
 130       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 131
 132       {:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
 133     end
 134
 135     test "favoriting a status" do
 136       user = insert(:user)
 137       other_user = insert(:user)
 138
 139       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 140
 141       {:ok, %Activity{}, _} = CommonAPI.favorite(activity.id, user)
 142     end
 143
 144     test "retweeting a status twice returns an error" do
 145       user = insert(:user)
 146       other_user = insert(:user)
 147
 148       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 149       {:ok, %Activity{}, _object} = CommonAPI.repeat(activity.id, user)
 150       {:error, _} = CommonAPI.repeat(activity.id, user)
 151     end
 152
 153     test "favoriting a status twice returns an error" do
 154       user = insert(:user)
 155       other_user = insert(:user)
 156
 157       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 158       {:ok, %Activity{}, _object} = CommonAPI.favorite(activity.id, user)
 159       {:error, _} = CommonAPI.favorite(activity.id, user)
 160     end
 161   end
 162
 163   describe "pinned statuses" do
 164     setup do
 165       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
 166
 167       user = insert(:user)
 168       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
 169
 170       [user: user, activity: activity]
 171     end
 172
 173     test "pin status", %{user: user, activity: activity} do
 174       assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
 175
 176       id = activity.id
 177       user = refresh_record(user)
 178
 179       assert %User{info: %{pinned_activities: [^id]}} = user
 180     end
 181
 182     test "only self-authored can be pinned", %{activity: activity} do
 183       user = insert(:user)
 184
 185       assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
 186     end
 187
 188     test "max pinned statuses", %{user: user, activity: activity_one} do
 189       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
 190
 191       assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)
 192
 193       user = refresh_record(user)
 194
 195       assert {:error, "You have already pinned the maximum number of statuses"} =
 196                CommonAPI.pin(activity_two.id, user)
 197     end
 198
 199     test "unpin status", %{user: user, activity: activity} do
 200       {:ok, activity} = CommonAPI.pin(activity.id, user)
 201
 202       user = refresh_record(user)
 203
 204       assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)
 205
 206       user = refresh_record(user)
 207
 208       assert %User{info: %{pinned_activities: []}} = user
 209     end
 210
 211     test "should unpin when deleting a status", %{user: user, activity: activity} do
 212       {:ok, activity} = CommonAPI.pin(activity.id, user)
 213
 214       user = refresh_record(user)
 215
 216       assert {:ok, _} = CommonAPI.delete(activity.id, user)
 217
 218       user = refresh_record(user)
 219
 220       assert %User{info: %{pinned_activities: []}} = user
 221     end
 222   end
 223
 224   describe "mute tests" do
 225     setup do
 226       user = insert(:user)
 227
 228       activity = insert(:note_activity)
 229
 230       [user: user, activity: activity]
 231     end
 232
 233     test "add mute", %{user: user, activity: activity} do
 234       {:ok, _} = CommonAPI.add_mute(user, activity)
 235       assert CommonAPI.thread_muted?(user, activity)
 236     end
 237
 238     test "remove mute", %{user: user, activity: activity} do
 239       CommonAPI.add_mute(user, activity)
 240       {:ok, _} = CommonAPI.remove_mute(user, activity)
 241       refute CommonAPI.thread_muted?(user, activity)
 242     end
 243
 244     test "check that mutes can't be duplicate", %{user: user, activity: activity} do
 245       CommonAPI.add_mute(user, activity)
 246       {:error, _} = CommonAPI.add_mute(user, activity)
 247     end
 248   end
 249
 250   describe "reports" do
 251     test "creates a report" do
 252       reporter = insert(:user)
 253       target_user = insert(:user)
 254
 255       {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
 256
 257       reporter_ap_id = reporter.ap_id
 258       target_ap_id = target_user.ap_id
 259       activity_ap_id = activity.data["id"]
 260       comment = "foobar"
 261
 262       report_data = %{
 263         "account_id" => target_user.id,
 264         "comment" => comment,
 265         "status_ids" => [activity.id]
 266       }
 267
 268       assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)
 269
 270       assert %Activity{
 271                actor: ^reporter_ap_id,
 272                data: %{
 273                  "type" => "Flag",
 274                  "content" => ^comment,
 275                  "object" => [^target_ap_id, ^activity_ap_id],
 276                  "state" => "open"
 277                }
 278              } = flag_activity
 279     end
 280
 281     test "updates report state" do
 282       [reporter, target_user] = insert_pair(:user)
 283       activity = insert(:note_activity, user: target_user)
 284
 285       {:ok, %Activity{id: report_id}} =
 286         CommonAPI.report(reporter, %{
 287           "account_id" => target_user.id,
 288           "comment" => "I feel offended",
 289           "status_ids" => [activity.id]
 290         })
 291
 292       {:ok, report} = CommonAPI.update_report_state(report_id, "resolved")
 293
 294       assert report.data["state"] == "resolved"
 295     end
 296
 297     test "does not update report state when state is unsupported" do
 298       [reporter, target_user] = insert_pair(:user)
 299       activity = insert(:note_activity, user: target_user)
 300
 301       {:ok, %Activity{id: report_id}} =
 302         CommonAPI.report(reporter, %{
 303           "account_id" => target_user.id,
 304           "comment" => "I feel offended",
 305           "status_ids" => [activity.id]
 306         })
 307
 308       assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
 309     end
 310   end
 311
 312   describe "reblog muting" do
 313     setup do
 314       muter = insert(:user)
 315
 316       muted = insert(:user)
 317
 318       [muter: muter, muted: muted]
 319     end
 320
 321     test "add a reblog mute", %{muter: muter, muted: muted} do
 322       {:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
 323
 324       assert User.showing_reblogs?(muter, muted) == false
 325     end
 326
 327     test "remove a reblog mute", %{muter: muter, muted: muted} do
 328       {:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
 329       {:ok, muter} = CommonAPI.show_reblogs(muter, muted)
 330
 331       assert User.showing_reblogs?(muter, muted) == true
 332     end
 333   end
 334 end