test/controllers/issues_controller_test.rb

   1 # frozen_string_literal: true
   2
   3 require "test_helper"
   4
   5 class IssuesControllerTest < ActionDispatch::IntegrationTest
   6   def test_index
   7     # Access issues list without login
   8     get issues_path
   9     assert_redirected_to login_path(:referer => issues_path)
  10
  11     # Access issues list as normal user
  12     session_for(create(:user))
  13     get issues_path
  14     assert_redirected_to :controller => :errors, :action => :forbidden
  15
  16     # Access issues list as administrator
  17     session_for(create(:administrator_user))
  18     get issues_path
  19     assert_response :success
  20
  21     # Access issues list as moderator
  22     session_for(create(:moderator_user))
  23     get issues_path
  24     assert_response :success
  25   end
  26
  27   def test_show_moderator
  28     target_user = create(:user)
  29     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "moderator")
  30
  31     # Access issue without login
  32     get issue_path(issue)
  33     assert_redirected_to login_path(:referer => issue_path(issue))
  34
  35     # Access issue as normal user
  36     session_for(create(:user))
  37     get issue_path(issue)
  38     assert_redirected_to :controller => :errors, :action => :forbidden
  39
  40     # Access issue as administrator
  41     session_for(create(:administrator_user))
  42     get issue_path(issue)
  43     assert_redirected_to :controller => :errors, :action => :not_found
  44
  45     # Access issue as moderator
  46     session_for(create(:moderator_user))
  47     get issue_path(issue)
  48     assert_response :success
  49   end
  50
  51   def test_show_administrator
  52     target_user = create(:user)
  53     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "administrator")
  54
  55     # Access issue without login
  56     get issue_path(issue)
  57     assert_redirected_to login_path(:referer => issue_path(issue))
  58
  59     # Access issue as normal user
  60     session_for(create(:user))
  61     get issue_path(issue)
  62     assert_redirected_to :controller => :errors, :action => :forbidden
  63
  64     # Access issue as moderator
  65     session_for(create(:moderator_user))
  66     get issue_path(issue)
  67     assert_redirected_to :controller => :errors, :action => :not_found
  68
  69     # Access issue as administrator
  70     session_for(create(:administrator_user))
  71     get issue_path(issue)
  72     assert_response :success
  73   end
  74
  75   def test_resolve_moderator
  76     target_user = create(:user)
  77     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "moderator")
  78
  79     # Resolve issue without login
  80     post resolve_issue_path(issue)
  81     assert_response :forbidden
  82
  83     # Resolve issue as normal user
  84     session_for(create(:user))
  85     post resolve_issue_path(issue)
  86     assert_redirected_to :controller => :errors, :action => :forbidden
  87
  88     # Resolve issue as administrator
  89     session_for(create(:administrator_user))
  90     post resolve_issue_path(issue)
  91     assert_redirected_to :controller => :errors, :action => :not_found
  92     assert_not_predicate issue.reload, :resolved?
  93
  94     # Resolve issue as moderator
  95     session_for(create(:moderator_user))
  96     post resolve_issue_path(issue)
  97     assert_response :redirect
  98     assert_predicate issue.reload, :resolved?
  99   end
 100
 101   def test_resolve_administrator
 102     target_user = create(:user)
 103     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "administrator")
 104
 105     # Resolve issue without login
 106     post resolve_issue_path(issue)
 107     assert_response :forbidden
 108
 109     # Resolve issue as normal user
 110     session_for(create(:user))
 111     post resolve_issue_path(issue)
 112     assert_redirected_to :controller => :errors, :action => :forbidden
 113
 114     # Resolve issue as moderator
 115     session_for(create(:moderator_user))
 116     post resolve_issue_path(issue)
 117     assert_redirected_to :controller => :errors, :action => :not_found
 118     assert_not_predicate issue.reload, :resolved?
 119
 120     # Resolve issue as administrator
 121     session_for(create(:administrator_user))
 122     post resolve_issue_path(issue)
 123     assert_response :redirect
 124     assert_predicate issue.reload, :resolved?
 125   end
 126
 127   def test_resolve_note_of_deleted_user
 128     target_user = create(:user)
 129     target_note = create(:note, :author => target_user)
 130     issue = create(:issue, :reportable => target_note, :reported_user => target_user, :assigned_role => "moderator")
 131     target_user.soft_destroy!
 132
 133     session_for(create(:moderator_user))
 134     post resolve_issue_path(issue)
 135     assert_redirected_to issue_path(issue)
 136     assert_predicate issue.reload, :resolved?
 137
 138     follow_redirect!
 139     assert_response :success
 140     assert_dom "a[href='#{note_url target_note}']"
 141
 142     get issues_path
 143     assert_response :success
 144     assert_dom "a[href='#{note_url target_note}']"
 145   end
 146
 147   def test_ignore_moderator
 148     target_user = create(:user)
 149     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "moderator")
 150
 151     # Ignore issue without login
 152     post ignore_issue_path(issue)
 153     assert_response :forbidden
 154
 155     # Ignore issue as normal user
 156     session_for(create(:user))
 157     post ignore_issue_path(issue)
 158     assert_redirected_to :controller => :errors, :action => :forbidden
 159
 160     # Ignore issue as administrator
 161     session_for(create(:administrator_user))
 162     post ignore_issue_path(issue)
 163     assert_redirected_to :controller => :errors, :action => :not_found
 164     assert_not_predicate issue.reload, :ignored?
 165
 166     # Ignore issue as moderator
 167     session_for(create(:moderator_user))
 168     post ignore_issue_path(issue)
 169     assert_response :redirect
 170     assert_predicate issue.reload, :ignored?
 171   end
 172
 173   def test_ignore_administrator
 174     target_user = create(:user)
 175     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "administrator")
 176
 177     # Ignore issue without login
 178     post ignore_issue_path(issue)
 179     assert_response :forbidden
 180
 181     # Ignore issue as normal user
 182     session_for(create(:user))
 183     post ignore_issue_path(issue)
 184     assert_redirected_to :controller => :errors, :action => :forbidden
 185
 186     # Ignore issue as moderator
 187     session_for(create(:moderator_user))
 188     post ignore_issue_path(issue)
 189     assert_redirected_to :controller => :errors, :action => :not_found
 190     assert_not_predicate issue.reload, :ignored?
 191
 192     # Ignore issue as administrator
 193     session_for(create(:administrator_user))
 194     post ignore_issue_path(issue)
 195     assert_response :redirect
 196     assert_predicate issue.reload, :ignored?
 197   end
 198
 199   def test_reopen_moderator
 200     target_user = create(:user)
 201     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "moderator")
 202
 203     issue.resolve!
 204
 205     # Reopen issue without login
 206     post reopen_issue_path(issue)
 207     assert_response :forbidden
 208
 209     # Reopen issue as normal user
 210     session_for(create(:user))
 211     post reopen_issue_path(issue)
 212     assert_redirected_to :controller => :errors, :action => :forbidden
 213
 214     # Reopen issue as administrator
 215     session_for(create(:administrator_user))
 216     post reopen_issue_path(issue)
 217     assert_redirected_to :controller => :errors, :action => :not_found
 218     assert_not_predicate issue.reload, :open?
 219
 220     # Reopen issue as moderator
 221     session_for(create(:moderator_user))
 222     post reopen_issue_path(issue)
 223     assert_response :redirect
 224     assert_predicate issue.reload, :open?
 225   end
 226
 227   def test_reopen_administrator
 228     target_user = create(:user)
 229     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "administrator")
 230
 231     issue.resolve!
 232
 233     # Reopen issue without login
 234     post reopen_issue_path(issue)
 235     assert_response :forbidden
 236
 237     # Reopen issue as normal user
 238     session_for(create(:user))
 239     post reopen_issue_path(issue)
 240     assert_redirected_to :controller => :errors, :action => :forbidden
 241
 242     # Reopen issue as moderator
 243     session_for(create(:moderator_user))
 244     post reopen_issue_path(issue)
 245     assert_redirected_to :controller => :errors, :action => :not_found
 246     assert_not_predicate issue.reload, :open?
 247
 248     # Reopen issue as administrator
 249     session_for(create(:administrator_user))
 250     post reopen_issue_path(issue)
 251     assert_response :redirect
 252     assert_predicate issue.reload, :open?
 253   end
 254 end