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     target_user.soft_destroy!
 131
 132     issue = create(:issue, :reportable => target_note, :reported_user => target_user, :assigned_role => "moderator")
 133
 134     session_for(create(:moderator_user))
 135     post resolve_issue_path(issue)
 136     assert_redirected_to issue_path(issue)
 137     assert_predicate issue.reload, :resolved?
 138
 139     follow_redirect!
 140     assert_response :success
 141     assert_dom "a[href='#{note_url target_note}']"
 142
 143     get issues_path
 144     assert_response :success
 145     assert_dom "a[href='#{note_url target_note}']"
 146   end
 147
 148   def test_ignore_moderator
 149     target_user = create(:user)
 150     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "moderator")
 151
 152     # Ignore issue without login
 153     post ignore_issue_path(issue)
 154     assert_response :forbidden
 155
 156     # Ignore issue as normal user
 157     session_for(create(:user))
 158     post ignore_issue_path(issue)
 159     assert_redirected_to :controller => :errors, :action => :forbidden
 160
 161     # Ignore issue as administrator
 162     session_for(create(:administrator_user))
 163     post ignore_issue_path(issue)
 164     assert_redirected_to :controller => :errors, :action => :not_found
 165     assert_not_predicate issue.reload, :ignored?
 166
 167     # Ignore issue as moderator
 168     session_for(create(:moderator_user))
 169     post ignore_issue_path(issue)
 170     assert_response :redirect
 171     assert_predicate issue.reload, :ignored?
 172   end
 173
 174   def test_ignore_administrator
 175     target_user = create(:user)
 176     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "administrator")
 177
 178     # Ignore issue without login
 179     post ignore_issue_path(issue)
 180     assert_response :forbidden
 181
 182     # Ignore issue as normal user
 183     session_for(create(:user))
 184     post ignore_issue_path(issue)
 185     assert_redirected_to :controller => :errors, :action => :forbidden
 186
 187     # Ignore issue as moderator
 188     session_for(create(:moderator_user))
 189     post ignore_issue_path(issue)
 190     assert_redirected_to :controller => :errors, :action => :not_found
 191     assert_not_predicate issue.reload, :ignored?
 192
 193     # Ignore issue as administrator
 194     session_for(create(:administrator_user))
 195     post ignore_issue_path(issue)
 196     assert_response :redirect
 197     assert_predicate issue.reload, :ignored?
 198   end
 199
 200   def test_reopen_moderator
 201     target_user = create(:user)
 202     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "moderator")
 203
 204     issue.resolve!
 205
 206     # Reopen issue without login
 207     post reopen_issue_path(issue)
 208     assert_response :forbidden
 209
 210     # Reopen issue as normal user
 211     session_for(create(:user))
 212     post reopen_issue_path(issue)
 213     assert_redirected_to :controller => :errors, :action => :forbidden
 214
 215     # Reopen issue as administrator
 216     session_for(create(:administrator_user))
 217     post reopen_issue_path(issue)
 218     assert_redirected_to :controller => :errors, :action => :not_found
 219     assert_not_predicate issue.reload, :open?
 220
 221     # Reopen issue as moderator
 222     session_for(create(:moderator_user))
 223     post reopen_issue_path(issue)
 224     assert_response :redirect
 225     assert_predicate issue.reload, :open?
 226   end
 227
 228   def test_reopen_administrator
 229     target_user = create(:user)
 230     issue = create(:issue, :reportable => target_user, :reported_user => target_user, :assigned_role => "administrator")
 231
 232     issue.resolve!
 233
 234     # Reopen issue without login
 235     post reopen_issue_path(issue)
 236     assert_response :forbidden
 237
 238     # Reopen issue as normal user
 239     session_for(create(:user))
 240     post reopen_issue_path(issue)
 241     assert_redirected_to :controller => :errors, :action => :forbidden
 242
 243     # Reopen issue as moderator
 244     session_for(create(:moderator_user))
 245     post reopen_issue_path(issue)
 246     assert_redirected_to :controller => :errors, :action => :not_found
 247     assert_not_predicate issue.reload, :open?
 248
 249     # Reopen issue as administrator
 250     session_for(create(:administrator_user))
 251     post reopen_issue_path(issue)
 252     assert_response :redirect
 253     assert_predicate issue.reload, :open?
 254   end
 255 end