test/controllers/issues_controller_test.rb

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