git.squeep.com Git - akkoma/blob - test/moderation_log_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.ModerationLogTest do
   6   alias Pleroma.Activity
   7   alias Pleroma.ModerationLog
   8
   9   use Pleroma.DataCase
  10
  11   import Pleroma.Factory
  12
  13   describe "user moderation" do
  14     setup do
  15       admin = insert(:user, info: %{is_admin: true})
  16       moderator = insert(:user, info: %{is_moderator: true})
  17       subject1 = insert(:user)
  18       subject2 = insert(:user)
  19
  20       [admin: admin, moderator: moderator, subject1: subject1, subject2: subject2]
  21     end
  22
  23     test "logging user deletion by moderator", %{moderator: moderator, subject1: subject1} do
  24       {:ok, _} =
  25         ModerationLog.insert_log(%{
  26           actor: moderator,
  27           subject: subject1,
  28           action: "delete"
  29         })
  30
  31       log = Repo.one(ModerationLog)
  32
  33       assert ModerationLog.get_log_entry_message(log) ==
  34                "@#{moderator.nickname} deleted user @#{subject1.nickname}"
  35     end
  36
  37     test "logging user creation by moderator", %{
  38       moderator: moderator,
  39       subject1: subject1,
  40       subject2: subject2
  41     } do
  42       {:ok, _} =
  43         ModerationLog.insert_log(%{
  44           actor: moderator,
  45           subjects: [subject1, subject2],
  46           action: "create"
  47         })
  48
  49       log = Repo.one(ModerationLog)
  50
  51       assert ModerationLog.get_log_entry_message(log) ==
  52                "@#{moderator.nickname} created users: @#{subject1.nickname}, @#{subject2.nickname}"
  53     end
  54
  55     test "logging user follow by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
  56       {:ok, _} =
  57         ModerationLog.insert_log(%{
  58           actor: admin,
  59           followed: subject1,
  60           follower: subject2,
  61           action: "follow"
  62         })
  63
  64       log = Repo.one(ModerationLog)
  65
  66       assert ModerationLog.get_log_entry_message(log) ==
  67                "@#{admin.nickname} made @#{subject2.nickname} follow @#{subject1.nickname}"
  68     end
  69
  70     test "logging user unfollow by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
  71       {:ok, _} =
  72         ModerationLog.insert_log(%{
  73           actor: admin,
  74           followed: subject1,
  75           follower: subject2,
  76           action: "unfollow"
  77         })
  78
  79       log = Repo.one(ModerationLog)
  80
  81       assert ModerationLog.get_log_entry_message(log) ==
  82                "@#{admin.nickname} made @#{subject2.nickname} unfollow @#{subject1.nickname}"
  83     end
  84
  85     test "logging user tagged by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
  86       {:ok, _} =
  87         ModerationLog.insert_log(%{
  88           actor: admin,
  89           nicknames: [subject1.nickname, subject2.nickname],
  90           tags: ["foo", "bar"],
  91           action: "tag"
  92         })
  93
  94       log = Repo.one(ModerationLog)
  95
  96       users =
  97         [subject1.nickname, subject2.nickname]
  98         |> Enum.map(&"@#{&1}")
  99         |> Enum.join(", ")
 100
 101       tags = ["foo", "bar"] |> Enum.join(", ")
 102
 103       assert ModerationLog.get_log_entry_message(log) ==
 104                "@#{admin.nickname} added tags: #{tags} to users: #{users}"
 105     end
 106
 107     test "logging user untagged by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
 108       {:ok, _} =
 109         ModerationLog.insert_log(%{
 110           actor: admin,
 111           nicknames: [subject1.nickname, subject2.nickname],
 112           tags: ["foo", "bar"],
 113           action: "untag"
 114         })
 115
 116       log = Repo.one(ModerationLog)
 117
 118       users =
 119         [subject1.nickname, subject2.nickname]
 120         |> Enum.map(&"@#{&1}")
 121         |> Enum.join(", ")
 122
 123       tags = ["foo", "bar"] |> Enum.join(", ")
 124
 125       assert ModerationLog.get_log_entry_message(log) ==
 126                "@#{admin.nickname} removed tags: #{tags} from users: #{users}"
 127     end
 128
 129     test "logging user grant by moderator", %{moderator: moderator, subject1: subject1} do
 130       {:ok, _} =
 131         ModerationLog.insert_log(%{
 132           actor: moderator,
 133           subject: subject1,
 134           action: "grant",
 135           permission: "moderator"
 136         })
 137
 138       log = Repo.one(ModerationLog)
 139
 140       assert ModerationLog.get_log_entry_message(log) ==
 141                "@#{moderator.nickname} made @#{subject1.nickname} moderator"
 142     end
 143
 144     test "logging user revoke by moderator", %{moderator: moderator, subject1: subject1} do
 145       {:ok, _} =
 146         ModerationLog.insert_log(%{
 147           actor: moderator,
 148           subject: subject1,
 149           action: "revoke",
 150           permission: "moderator"
 151         })
 152
 153       log = Repo.one(ModerationLog)
 154
 155       assert ModerationLog.get_log_entry_message(log) ==
 156                "@#{moderator.nickname} revoked moderator role from @#{subject1.nickname}"
 157     end
 158
 159     test "logging relay follow", %{moderator: moderator} do
 160       {:ok, _} =
 161         ModerationLog.insert_log(%{
 162           actor: moderator,
 163           action: "relay_follow",
 164           target: "https://example.org/relay"
 165         })
 166
 167       log = Repo.one(ModerationLog)
 168
 169       assert ModerationLog.get_log_entry_message(log) ==
 170                "@#{moderator.nickname} followed relay: https://example.org/relay"
 171     end
 172
 173     test "logging relay unfollow", %{moderator: moderator} do
 174       {:ok, _} =
 175         ModerationLog.insert_log(%{
 176           actor: moderator,
 177           action: "relay_unfollow",
 178           target: "https://example.org/relay"
 179         })
 180
 181       log = Repo.one(ModerationLog)
 182
 183       assert ModerationLog.get_log_entry_message(log) ==
 184                "@#{moderator.nickname} unfollowed relay: https://example.org/relay"
 185     end
 186
 187     test "logging report update", %{moderator: moderator} do
 188       report = %Activity{
 189         id: "9m9I1F4p8ftrTP6QTI",
 190         data: %{
 191           "type" => "Flag",
 192           "state" => "resolved"
 193         }
 194       }
 195
 196       {:ok, _} =
 197         ModerationLog.insert_log(%{
 198           actor: moderator,
 199           action: "report_update",
 200           subject: report
 201         })
 202
 203       log = Repo.one(ModerationLog)
 204
 205       assert ModerationLog.get_log_entry_message(log) ==
 206                "@#{moderator.nickname} updated report ##{report.id} with 'resolved' state"
 207     end
 208
 209     test "logging report response", %{moderator: moderator} do
 210       report = %Activity{
 211         id: "9m9I1F4p8ftrTP6QTI",
 212         data: %{
 213           "type" => "Note"
 214         }
 215       }
 216
 217       {:ok, _} =
 218         ModerationLog.insert_log(%{
 219           actor: moderator,
 220           action: "report_response",
 221           subject: report,
 222           text: "look at this"
 223         })
 224
 225       log = Repo.one(ModerationLog)
 226
 227       assert ModerationLog.get_log_entry_message(log) ==
 228                "@#{moderator.nickname} responded with 'look at this' to report ##{report.id}"
 229     end
 230
 231     test "logging status sensitivity update", %{moderator: moderator} do
 232       note = insert(:note_activity)
 233
 234       {:ok, _} =
 235         ModerationLog.insert_log(%{
 236           actor: moderator,
 237           action: "status_update",
 238           subject: note,
 239           sensitive: "true",
 240           visibility: nil
 241         })
 242
 243       log = Repo.one(ModerationLog)
 244
 245       assert ModerationLog.get_log_entry_message(log) ==
 246                "@#{moderator.nickname} updated status ##{note.id}, set sensitive: 'true'"
 247     end
 248
 249     test "logging status visibility update", %{moderator: moderator} do
 250       note = insert(:note_activity)
 251
 252       {:ok, _} =
 253         ModerationLog.insert_log(%{
 254           actor: moderator,
 255           action: "status_update",
 256           subject: note,
 257           sensitive: nil,
 258           visibility: "private"
 259         })
 260
 261       log = Repo.one(ModerationLog)
 262
 263       assert ModerationLog.get_log_entry_message(log) ==
 264                "@#{moderator.nickname} updated status ##{note.id}, set visibility: 'private'"
 265     end
 266
 267     test "logging status sensitivity & visibility update", %{moderator: moderator} do
 268       note = insert(:note_activity)
 269
 270       {:ok, _} =
 271         ModerationLog.insert_log(%{
 272           actor: moderator,
 273           action: "status_update",
 274           subject: note,
 275           sensitive: "true",
 276           visibility: "private"
 277         })
 278
 279       log = Repo.one(ModerationLog)
 280
 281       assert ModerationLog.get_log_entry_message(log) ==
 282                "@#{moderator.nickname} updated status ##{note.id}, set sensitive: 'true', visibility: 'private'"
 283     end
 284
 285     test "logging status deletion", %{moderator: moderator} do
 286       note = insert(:note_activity)
 287
 288       {:ok, _} =
 289         ModerationLog.insert_log(%{
 290           actor: moderator,
 291           action: "status_delete",
 292           subject_id: note.id
 293         })
 294
 295       log = Repo.one(ModerationLog)
 296
 297       assert ModerationLog.get_log_entry_message(log) ==
 298                "@#{moderator.nickname} deleted status ##{note.id}"
 299     end
 300   end
 301 end