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 allows to address a list" do
  92       user = insert(:user)
  93       {:ok, list} = Pleroma.List.create("foo", user)
  94
  95       list_ap_id = Pleroma.List.ap_id(user, list.id)
  96
  97       {:ok, activity} =
  98         CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
  99
 100       assert activity.data["bcc"] == [list_ap_id]
 101       assert activity.recipients == [list_ap_id, user.ap_id]
 102     end
 103   end
 104
 105   describe "reactions" do
 106     test "repeating a status" do
 107       user = insert(:user)
 108       other_user = insert(:user)
 109
 110       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 111
 112       {:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
 113     end
 114
 115     test "favoriting a status" do
 116       user = insert(:user)
 117       other_user = insert(:user)
 118
 119       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 120
 121       {:ok, %Activity{}, _} = CommonAPI.favorite(activity.id, user)
 122     end
 123
 124     test "retweeting a status twice returns an error" do
 125       user = insert(:user)
 126       other_user = insert(:user)
 127
 128       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 129       {:ok, %Activity{}, _object} = CommonAPI.repeat(activity.id, user)
 130       {:error, _} = CommonAPI.repeat(activity.id, user)
 131     end
 132
 133     test "favoriting a status twice returns an error" do
 134       user = insert(:user)
 135       other_user = insert(:user)
 136
 137       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
 138       {:ok, %Activity{}, _object} = CommonAPI.favorite(activity.id, user)
 139       {:error, _} = CommonAPI.favorite(activity.id, user)
 140     end
 141   end
 142
 143   describe "pinned statuses" do
 144     setup do
 145       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
 146
 147       user = insert(:user)
 148       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
 149
 150       [user: user, activity: activity]
 151     end
 152
 153     test "pin status", %{user: user, activity: activity} do
 154       assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
 155
 156       id = activity.id
 157       user = refresh_record(user)
 158
 159       assert %User{info: %{pinned_activities: [^id]}} = user
 160     end
 161
 162     test "only self-authored can be pinned", %{activity: activity} do
 163       user = insert(:user)
 164
 165       assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
 166     end
 167
 168     test "max pinned statuses", %{user: user, activity: activity_one} do
 169       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
 170
 171       assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)
 172
 173       user = refresh_record(user)
 174
 175       assert {:error, "You have already pinned the maximum number of statuses"} =
 176                CommonAPI.pin(activity_two.id, user)
 177     end
 178
 179     test "unpin status", %{user: user, activity: activity} do
 180       {:ok, activity} = CommonAPI.pin(activity.id, user)
 181
 182       user = refresh_record(user)
 183
 184       assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)
 185
 186       user = refresh_record(user)
 187
 188       assert %User{info: %{pinned_activities: []}} = user
 189     end
 190
 191     test "should unpin when deleting a status", %{user: user, activity: activity} do
 192       {:ok, activity} = CommonAPI.pin(activity.id, user)
 193
 194       user = refresh_record(user)
 195
 196       assert {:ok, _} = CommonAPI.delete(activity.id, user)
 197
 198       user = refresh_record(user)
 199
 200       assert %User{info: %{pinned_activities: []}} = user
 201     end
 202   end
 203
 204   describe "mute tests" do
 205     setup do
 206       user = insert(:user)
 207
 208       activity = insert(:note_activity)
 209
 210       [user: user, activity: activity]
 211     end
 212
 213     test "add mute", %{user: user, activity: activity} do
 214       {:ok, _} = CommonAPI.add_mute(user, activity)
 215       assert CommonAPI.thread_muted?(user, activity)
 216     end
 217
 218     test "remove mute", %{user: user, activity: activity} do
 219       CommonAPI.add_mute(user, activity)
 220       {:ok, _} = CommonAPI.remove_mute(user, activity)
 221       refute CommonAPI.thread_muted?(user, activity)
 222     end
 223
 224     test "check that mutes can't be duplicate", %{user: user, activity: activity} do
 225       CommonAPI.add_mute(user, activity)
 226       {:error, _} = CommonAPI.add_mute(user, activity)
 227     end
 228   end
 229
 230   describe "reports" do
 231     test "creates a report" do
 232       reporter = insert(:user)
 233       target_user = insert(:user)
 234
 235       {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
 236
 237       reporter_ap_id = reporter.ap_id
 238       target_ap_id = target_user.ap_id
 239       activity_ap_id = activity.data["id"]
 240       comment = "foobar"
 241
 242       report_data = %{
 243         "account_id" => target_user.id,
 244         "comment" => comment,
 245         "status_ids" => [activity.id]
 246       }
 247
 248       assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)
 249
 250       assert %Activity{
 251                actor: ^reporter_ap_id,
 252                data: %{
 253                  "type" => "Flag",
 254                  "content" => ^comment,
 255                  "object" => [^target_ap_id, ^activity_ap_id]
 256                }
 257              } = flag_activity
 258     end
 259   end
 260
 261   describe "reblog muting" do
 262     setup do
 263       muter = insert(:user)
 264
 265       muted = insert(:user)
 266
 267       [muter: muter, muted: muted]
 268     end
 269
 270     test "add a reblog mute", %{muter: muter, muted: muted} do
 271       {:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
 272
 273       assert Pleroma.User.showing_reblogs?(muter, muted) == false
 274     end
 275
 276     test "remove a reblog mute", %{muter: muter, muted: muted} do
 277       {:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
 278       {:ok, muter} = CommonAPI.show_reblogs(muter, muted)
 279
 280       assert Pleroma.User.showing_reblogs?(muter, muted) == true
 281     end
 282   end
 283 end