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