summaryrefslogtreecommitdiff
path: root/help/test/functional/tickets_controller_test.rb
blob: 97e33088fadd0128d35f13931e47184e50351d40 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
require 'test_helper'

class TicketsControllerTest < ActionController::TestCase

  setup do
    @user = FactoryGirl.create :user
    @other_user = FactoryGirl.create :user
  end

  teardown do
    @user.destroy
    @other_user.destroy
  end

  test "should get index if logged in" do
    login
    get :index
    assert_response :success
    assert_not_nil assigns(:tickets)
  end

  test "no index if not logged in" do
    get :index
    assert_response :redirect
    assert_nil assigns(:tickets)
  end

  test "should get new" do
    get :new
    assert_equal Ticket, assigns(:ticket).class
    assert_response :success
  end

  test "unauthenticated tickets are visible" do
    ticket = find_record :ticket, :created_by => nil
    get :show, :id => ticket.id
    assert_response :success
  end

  test "user tickets are not visible without login" do
    ticket = find_record :ticket, :created_by => @user.id
    get :show, :id => ticket.id
    assert_response :redirect
    assert_redirected_to login_url
  end

  test "user tickets are visible to creator" do
    ticket = find_record :ticket, :created_by => @user.id
    login @user
    get :show, :id => ticket.id
    assert_response :success
  end

  test "user tickets are not visible to other user" do
    ticket = find_record :ticket, :created_by => @user.id
    login @other_user
    get :show, :id => ticket.id
    assert_response :redirect
    assert_redirected_to root_url
  end

  test "should create unauthenticated ticket" do
    params = {:title => "unauth ticket test title", :comments_attributes => {"0" => {"body" =>"body of test ticket"}}}

    assert_difference('Ticket.count') do
      post :create, :ticket => params
    end

    assert_response :redirect
    assert_nil assigns(:ticket).created_by

    assert_equal 1, assigns(:ticket).comments.count
    assert_nil assigns(:ticket).comments.first.posted_by
    assigns(:ticket).destroy # destroys without checking permission. is that okay?

  end

  test "should create authenticated ticket" do

    params = {:title => "auth ticket test title", :comments_attributes => {"0" => {"body" =>"body of test ticket"}}}

    login :email => Faker::Internet.user_name + '@' + APP_CONFIG[:domain]

    assert_difference('Ticket.count') do
      post :create, :ticket => params
    end

    assert_response :redirect

    assert_not_nil assigns(:ticket).created_by
    assert_equal assigns(:ticket).created_by, @current_user.id
    assert_equal assigns(:ticket).email, @current_user.email

    assert_equal 1, assigns(:ticket).comments.count
    assert_not_nil assigns(:ticket).comments.first.posted_by
    assert_equal assigns(:ticket).comments.first.posted_by, @current_user.id
    assigns(:ticket).destroy
  end

  test "add comment to unauthenticated ticket" do
    ticket = Ticket.find('stubtestticketid')
    ticket.created_by = nil # TODO: hacky, but this makes sure this ticket is an unauthenticated one
    ticket.save

    assert_difference('Ticket.find("stubtestticketid").comments.count') do
      put :update, :id => ticket.id,
        :ticket => {:comments_attributes => {"0" => {"body" =>"NEWER comment"}} }
    end

    assert_equal ticket, assigns(:ticket) # still same ticket, with different comments
    assert_not_equal ticket.comments, assigns(:ticket).comments # ticket == assigns(:ticket), but they have different comments (which we want)

  end


  test "add comment to own authenticated ticket" do

    login User.last
    ticket = Ticket.find('stubtestticketid')
    ticket.created_by = @current_user.id # TODO: hacky, but confirms it is their ticket
    ticket.save

    #they should be able to comment if it is their ticket:
    assert_difference('Ticket.find("stubtestticketid").comments.count') do
      put :update, :id => ticket.id,
        :ticket => {:comments_attributes => {"0" => {"body" =>"NEWER comment"}} }
    end
    assert_not_equal ticket.comments, assigns(:ticket).comments
    assert_not_nil assigns(:ticket).comments.last.posted_by
    assert_equal assigns(:ticket).comments.last.posted_by, @current_user.id

  end


  test "cannot comment if it is not your ticket" do

    login :is_admin? => false, :email => nil
    ticket = Ticket.first

    assert_not_nil User.first.id
    ticket.created_by = User.first.id
    ticket.save
    # they should *not* be able to comment if it is not their ticket
    put :update, :id => ticket.id, :ticket => {:comments_attributes => {"0" => {"body" =>"not allowed comment"}} }
    assert_response :redirect
    assert_access_denied

    assert_equal ticket.comments, assigns(:ticket).comments

  end


  test "admin add comment to authenticated ticket" do

    login :is_admin? => true

    ticket = Ticket.find('stubtestticketid')
    assert_not_nil User.last.id
    ticket.created_by = User.last.id # TODO: hacky, but confirms it somebody elses ticket:
    assert_not_equal User.last.id, @current_user.id
    ticket.save

    #admin should be able to comment:
    assert_difference('Ticket.find("stubtestticketid").comments.count') do
      put :update, :id => ticket.id,
        :ticket => {:comments_attributes => {"0" => {"body" =>"NEWER comment"}} }
    end
    assert_not_equal ticket.comments, assigns(:ticket).comments
    assert_not_nil assigns(:ticket).comments.last.posted_by
    assert_equal assigns(:ticket).comments.last.posted_by, @current_user.id

  end

  test "tickets by admin" do

    login :is_admin? => true, :email => nil

    get :index, {:admin_status => "all", :open_status => "open"}
    assert assigns(:all_tickets).count > 1

    # if we close one ticket, the admin should have 1 less open ticket
    assert_difference('assigns[:all_tickets].count', -1) do
      assigns(:tickets).first.close
      assigns(:tickets).first.save
      get :index, {:admin_status => "all", :open_status => "open"}
    end
  end


  test "admin_status mine vs all" do
    testticket = Ticket.create :title => 'temp testytest'
    login :is_admin? => true, :email => nil

    get :index, {:admin_status => "all", :open_status => "open"}
    assert assigns(:all_tickets).include?(testticket)
    get :index, {:admin_status => "mine", :open_status => "open"}
    assert !assigns(:all_tickets).include?(testticket)
  end

  test "commenting on a ticket adds to tickets that are mine" do
    testticket = Ticket.create :title => 'temp testytest'
    login :is_admin? => true, :email => nil

    get :index, {:admin_status => "mine", :open_status => "open"}
    assert_difference('assigns[:all_tickets].count') do
      put :update, :id => testticket.id, :ticket => {:comments_attributes => {"0" => {"body" =>"NEWER comment"}}}
      get :index, {:admin_status => "mine", :open_status => "open"}
    end

    assert assigns(:all_tickets).include?(assigns(:ticket))
    assert_not_nil assigns(:ticket).comments.last.posted_by
    assert_equal assigns(:ticket).comments.last.posted_by, @current_user.id

    assigns(:ticket).destroy
  end

  test "admin ticket ordering" do

    login :is_admin? => true, :email => nil
    get :index, {:admin_status => "all", :open_status => "open", :sort_order => 'created_at_desc'}

    # this will consider all tickets, not just those on first page
    first_tick = assigns(:all_tickets).all.first
    last_tick = assigns(:all_tickets).all.last
    assert first_tick.created_at > last_tick.created_at

    # and now reverse order:
    get :index, {:admin_status => "all", :open_status => "open", :sort_order => 'created_at_asc'}

    assert_equal first_tick, assigns(:all_tickets).last
    assert_equal last_tick, assigns(:all_tickets).first

    assert_not_equal first_tick, assigns(:all_tickets).first
    assert_not_equal last_tick, assigns(:all_tickets).last

  end

  test "tickets for regular user" do
    login
    ticket = FactoryGirl.create :ticket
    other_ticket = FactoryGirl.create :ticket

    put :update, :id => ticket.id,
      :ticket => {:comments_attributes => {"0" => {"body" =>"NEWER comment"}} }
    assert_not_nil assigns(:ticket).comments.last.posted_by
    assert_equal assigns(:ticket).comments.last.posted_by, @current_user.id

    get :index, {:open_status => "open"}
    assert assigns(:all_tickets).count > 0
    assert assigns(:all_tickets).include?(ticket)
    assert !assigns(:all_tickets).include?(other_ticket)

    # user should have one more ticket if a new tick gets a comment by this user
    assert_difference('assigns[:all_tickets].count') do
      put :update, :id => other_ticket.id, :ticket => {:comments_attributes => {"0" => {"body" =>"NEWER comment"}}}
      get :index, {:open_status => "open"}
    end
    assert assigns(:all_tickets).include?(other_ticket)

   # if we close one ticket, the user should have 1 less open ticket
    assert_difference('assigns[:all_tickets].count', -1) do
      other_ticket.reload
      other_ticket.close
      other_ticket.save
      get :index, {:open_status => "open"}
    end

    number_open_tickets = assigns(:all_tickets).count

    # look at closed tickets:
    get :index, {:open_status => "closed"}
    assert !assigns(:all_tickets).include?(ticket)
    assert assigns(:all_tickets).include?(other_ticket)
    number_closed_tickets = assigns(:all_tickets).count

    # all tickets should equal closed + open
    get :index, {:open_status => "all"}
    assert assigns(:all_tickets).include?(ticket)
    assert assigns(:all_tickets).include?(other_ticket)
    assert_equal assigns(:all_tickets).count, number_closed_tickets + number_open_tickets

  end

end