test/controllers/moderation_zones_controller_test.rb

   1 # frozen_string_literal: true
   2
   3 require "test_helper"
   4
   5 class ModerationZonesControllerTest < ActionDispatch::IntegrationTest
   6   test "routes" do
   7     assert_routing(
   8       { :path => "/moderation_zones", :method => :get },
   9       { :controller => "moderation_zones", :action => "index" }
  10     )
  11     assert_routing(
  12       { :path => "/moderation_zones/new", :method => :get },
  13       { :controller => "moderation_zones", :action => "new" }
  14     )
  15     assert_routing(
  16       { :path => "/moderation_zones/123/edit", :method => :get },
  17       { :controller => "moderation_zones", :action => "edit", :id => "123" }
  18     )
  19     assert_routing(
  20       { :path => "/moderation_zones", :method => :post },
  21       { :controller => "moderation_zones", :action => "create" }
  22     )
  23     assert_routing(
  24       { :path => "/moderation_zones/123", :method => :put },
  25       { :controller => "moderation_zones", :action => "update", :id => "123" }
  26     )
  27   end
  28
  29   test "index, unauthenticated" do
  30     get moderation_zones_url
  31     assert_redirected_to login_url(:referer => moderation_zones_path)
  32   end
  33
  34   test "index, as normal user" do
  35     session_for(create(:user))
  36     get moderation_zones_url
  37     assert_redirected_to "/403"
  38   end
  39
  40   test "index, as moderator" do
  41     create(:moderation_zone, :ends_at => 1.week.ago)
  42     create(:moderation_zone, :ends_at => 1.week.from_now)
  43     revoker = create(:moderator_user, :display_name => "Revokator")
  44     create(:moderation_zone, :ends_at => 1.week.ago, :revoker => revoker)
  45
  46     session_for(create(:moderator_user))
  47     get moderation_zones_url
  48     assert_response :success
  49     assert_dom "td", :text => "active"
  50     assert_dom "td", :text => "ended"
  51     assert_dom "td", :text => "revoked by Revokator"
  52   end
  53
  54   test "new, unauthenticated" do
  55     get new_moderation_zone_url
  56     assert_redirected_to login_url(:referer => new_moderation_zone_path)
  57   end
  58
  59   test "new, as normal user" do
  60     session_for(create(:user))
  61     get new_moderation_zone_url
  62     assert_redirected_to "/403"
  63   end
  64
  65   test "new, as moderator" do
  66     session_for(create(:moderator_user))
  67     get new_moderation_zone_url
  68     assert_response :success
  69   end
  70
  71   test "create, unauthenticated" do
  72     post(
  73       moderation_zones_url,
  74       :params => { :moderation_zone => {} }
  75     )
  76     assert_response :forbidden
  77   end
  78
  79   test "create, as normal user" do
  80     session_for(create(:user))
  81     post(
  82       moderation_zones_url,
  83       :params => {
  84         :moderation_zone => {
  85           **attributes_for(:moderation_zone)
  86             .slice(:name, :reason, :zone),
  87           :period => 2.days.in_hours
  88         }
  89       }
  90     )
  91     assert_redirected_to "/403"
  92   end
  93
  94   test "create, as moderator" do
  95     moderator = create(:moderator_user)
  96     session_for(moderator)
  97
  98     assert_difference("ModerationZone.count") do
  99       post(
 100         moderation_zones_url,
 101         :params => {
 102           :moderation_zone => {
 103             **attributes_for(:moderation_zone)
 104               .slice(:name, :reason, :zone),
 105             :period => 2.days.in_hours
 106           }
 107         }
 108       )
 109     end
 110
 111     moderation_zone = ModerationZone.last
 112     assert_redirected_to moderation_zones_url
 113
 114     assert_in_delta moderation_zone.ends_at, 2.days.from_now, 10.seconds
 115   end
 116
 117   test "create, with errors" do
 118     moderator = create(:moderator_user)
 119     session_for(moderator)
 120
 121     assert_no_difference("ModerationZone.count") do
 122       post(
 123         moderation_zones_url,
 124         :params => {
 125           :moderation_zone => {
 126             **attributes_for(:moderation_zone)
 127               .slice(:name, :zone),
 128             :period => 6.months.in_hours
 129           }
 130         }
 131       )
 132     end
 133
 134     assert_response :unprocessable_content
 135     assert_dom "option[selected]", :text => "6 months"
 136   end
 137
 138   test "edit, unauthenticated" do
 139     get edit_moderation_zone_url(123)
 140     assert_redirected_to login_path(:referer => edit_moderation_zone_path(123))
 141   end
 142
 143   test "edit, as normal user" do
 144     session_for(create(:user))
 145     moderation_zone = create(:moderation_zone, :ends_at => 1.year.from_now)
 146     get edit_moderation_zone_url(moderation_zone)
 147     assert_redirected_to "/403"
 148   end
 149
 150   test "edit, as moderator" do
 151     session_for(create(:moderator_user))
 152     moderation_zone = create(:moderation_zone, :ends_at => 1.year.from_now)
 153     get edit_moderation_zone_url(moderation_zone)
 154     assert_response :success
 155     assert_dom "option[selected]", :text => "1 year"
 156   end
 157
 158   test "update, unauthenticated" do
 159     patch(
 160       moderation_zone_url(123),
 161       :params => { :moderation_zone => {} }
 162     )
 163     assert_response :forbidden
 164   end
 165
 166   test "update, as normal user" do
 167     # This is an edge case: a normal user has a moderation zone to their name.
 168     # Perhaps they used to be a moderator, but no longer. The important
 169     # bit is that they shouldn't be able to update it any more.
 170     #
 171     # Instead of this we could just have a test for "normal user can't update"
 172     # with a simpler request (eg: with empty params) but, for the sake of
 173     # doing it properly, let's have everyting in place except for the only detail
 174     # that the user is not a moderator.
 175     creator = create(:user)
 176     moderation_zone = create(:moderation_zone, :ends_at => 1.week.from_now, :creator => creator)
 177     session_for(creator)
 178
 179     patch(
 180       moderation_zone_url(moderation_zone),
 181       :params => {
 182         :moderation_zone => {
 183           :name => moderation_zone.name,
 184           :reason => moderation_zone.reason,
 185           :zone => moderation_zone.zone,
 186           :period => 2.weeks.in_hours
 187         }
 188       }
 189     )
 190     assert_redirected_to "/403"
 191   end
 192
 193   test "update, as moderator" do
 194     creator = create(:moderator_user)
 195     moderation_zone = create(:moderation_zone, :ends_at => 1.week.from_now, :creator => creator)
 196     session_for(creator)
 197
 198     patch(
 199       moderation_zone_url(moderation_zone),
 200       :params => {
 201         :moderation_zone => {
 202           :name => moderation_zone.name,
 203           :reason => moderation_zone.reason,
 204           :zone => moderation_zone.zone,
 205           :period => 2.weeks.in_hours
 206         }
 207       }
 208     )
 209     assert_redirected_to moderation_zones_url
 210
 211     moderation_zone.reload
 212     assert_in_delta moderation_zone.ends_at, 2.weeks.from_now, 10.seconds
 213     assert_nil moderation_zone.revoker
 214   end
 215
 216   test "update, with errors" do
 217     creator = create(:moderator_user)
 218     moderation_zone = create(:moderation_zone, :ends_at => 1.week.from_now, :creator => creator)
 219     session_for(creator)
 220
 221     patch(
 222       moderation_zone_url(moderation_zone),
 223       :params => {
 224         :moderation_zone => {
 225           :name => moderation_zone.name,
 226           :reason => "",
 227           :zone => moderation_zone.zone,
 228           :period => 4.days.in_hours
 229         }
 230       }
 231     )
 232
 233     assert_response :unprocessable_content
 234     assert_dom "option[selected]", :text => "4 days"
 235   end
 236
 237   test "update to revoke" do
 238     revoker = create(:moderator_user)
 239     moderation_zone = create(:moderation_zone, :ends_at => 1.week.from_now)
 240     session_for(revoker)
 241
 242     patch(
 243       moderation_zone_url(moderation_zone),
 244       :params => {
 245         :moderation_zone => {
 246           :name => moderation_zone.name,
 247           :reason => moderation_zone.reason,
 248           :zone => moderation_zone.zone,
 249           :period => 0
 250         }
 251       }
 252     )
 253     assert_redirected_to moderation_zones_url
 254
 255     moderation_zone.reload
 256     assert_equal revoker, moderation_zone.revoker
 257   end
 258
 259   test "update, by non-creator, of inactive+unrevoked record" do
 260     updater = create(:moderator_user)
 261     moderation_zone = create(:moderation_zone, :reason => "Initial reason", :ends_at => 1.week.ago)
 262     session_for(updater)
 263
 264     patch(
 265       moderation_zone_url(moderation_zone),
 266       :params => {
 267         :moderation_zone => {
 268           :reason => "Updated reason"
 269         }
 270       }
 271     )
 272     assert_redirected_to moderation_zones_url
 273     assert_equal "Only the moderator who created this moderation zone can edit it.", flash[:error]
 274
 275     moderation_zone.reload
 276     assert_equal "Initial reason", moderation_zone.reason
 277   end
 278
 279   test "update, by creator, of inactive+revoked record" do
 280     creator = create(:moderator_user)
 281     moderation_zone = create(:moderation_zone, :reason => "Initial reason", :creator => creator, :ends_at => 1.week.ago)
 282     session_for(creator)
 283
 284     patch(
 285       moderation_zone_url(moderation_zone),
 286       :params => {
 287         :moderation_zone => {
 288           :reason => "Updated reason"
 289         }
 290       }
 291     )
 292
 293     assert_redirected_to moderation_zones_url
 294     assert_nil flash[:error]
 295
 296     moderation_zone.reload
 297     assert_equal "Updated reason", moderation_zone.reason
 298   end
 299
 300   test "update, by non-creator, of revoked record" do
 301     updater = create(:moderator_user)
 302     revoker = create(:moderator_user)
 303     moderation_zone = create(:moderation_zone, :reason => "Initial reason", :ends_at => 1.week.ago, :revoker => revoker)
 304     session_for(updater)
 305
 306     patch(
 307       moderation_zone_url(moderation_zone),
 308       :params => {
 309         :moderation_zone => {
 310           :reason => "Updated reason"
 311         }
 312       }
 313     )
 314     assert_redirected_to moderation_zones_url
 315     assert_equal "Only the moderators who created or revoked this moderation zone can edit it.", flash[:error]
 316
 317     moderation_zone.reload
 318     assert_equal "Initial reason", moderation_zone.reason
 319   end
 320
 321   test "update, by non-creator, of active record" do
 322     updater = create(:moderator_user)
 323     moderation_zone = create(:moderation_zone, :reason => "Initial reason", :ends_at => 1.week.from_now)
 324     session_for(updater)
 325
 326     patch(
 327       moderation_zone_url(moderation_zone),
 328       :params => {
 329         :moderation_zone => {
 330           :reason => "Updated reason",
 331           :period => 1.week.from_now
 332         }
 333       }
 334     )
 335     assert_redirected_to moderation_zones_url
 336     assert_equal "Only the moderator who created this moderation zone can edit it without revoking.", flash[:error]
 337
 338     moderation_zone.reload
 339     assert_equal "Initial reason", moderation_zone.reason
 340   end
 341
 342   test "update to reactivate" do
 343     creator = create(:moderator_user)
 344     moderation_zone = create(:moderation_zone, :creator => creator, :ends_at => 1.week.ago)
 345     session_for(creator)
 346
 347     patch(
 348       moderation_zone_url(moderation_zone),
 349       :params => {
 350         :moderation_zone => {
 351           :period => 1.week.from_now
 352         }
 353       }
 354     )
 355     assert_redirected_to moderation_zones_url
 356     assert_equal "This moderation zone is inactive and cannot be reactivated.", flash[:error]
 357
 358     moderation_zone.reload
 359     assert_not_predicate moderation_zone, :active?
 360   end
 361 end