auto_test 0.1.9.8.7 → 1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -6,17 +6,22 @@ require 'auto_test'
6
6
 
7
7
  describe "Application" do
8
8
  describe "error path reduction" do
9
+ # load fixtures
9
10
  if AutoTest::Test.use_fixtures? then
10
11
  fixtures(*AutoTest::Test.get_fixtures)
11
12
  end
12
13
  it "reduces the path to the error" do
14
+ # load test data
13
15
  load "#{Rails.root}/db/test_seeds.rb"
16
+ # set db clean strategy to transcation
14
17
  DatabaseCleaner.strategy = :transaction
18
+ # start the transaction
15
19
  DatabaseCleaner.start
16
20
  init_path
17
21
  init_sessions
18
22
  init_sessions_array
19
23
  number_of_sessions = AutoTest::Test.get_number_of_sessions
24
+ # instantiate sessions
20
25
  for i in 0..number_of_sessions-1 do
21
26
  sess = Capybara::Session.new(:rack_test,Rails.application)
22
27
  add_to_sessions_array sess
@@ -28,86 +33,97 @@ describe "Application" do
28
33
  user = Array.new(number_of_sessions)
29
34
  session_index = 0
30
35
  begin
31
- while line = paths.gets do
32
- lno = lno + 1
33
- if !line.chop!.end_with? "ID" then
34
- hash = Hash.new
35
- a = line.gsub!(/[{}\"]/,'').split(/\=\>/)
36
- session = get_sessions_array[a[0].split(":").first.to_i]
37
- session_index = get_sessions_array.index(session)
38
- if a[0].split(":").second == AutoTest::Authentication.get_login_path then
39
- begin
40
- # necesarry if user data has changed
41
- # might have to be rescued if the user doesn´t exist anymore.
42
- user[session_index] = user[session_index].class.find(user[session_index].id)
43
- rescue
44
- end
45
- session.visit AutoTest::Authentication.get_login_path
46
- hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = AutoTest::Authentication.get_login_button
47
- if AutoTest::Authentication.use_db_users then
48
- AutoTest::Authentication.get_login_attributes.each do |field|
49
- session.fill_in field[1], :with => user[session_index].send(field[0].to_sym)
50
- end
51
- else
52
- user_data = nil
53
- index = AutoTest::Authentication.get_login_names.index(AutoTest::Authentication.get_unique_login_attribute_name)
54
- user[session_index].class.find(:all).each do |u|
55
- AutoTest::Authentication.get_login_data.each do |d|
56
- if d[index] == u.send(AutoTest::Authentication.get_unique_login_attribute_name.to_sym) then
57
- user_data = AutoTest::Authentication.get_login_data[index]
58
- end
59
- end
36
+ #read the path, parse it and check if the error is reproducable
37
+ while line = paths.gets do
38
+ lno = lno + 1
39
+ if !line.chop!.end_with? "ID" then
40
+ hash = Hash.new
41
+ a = line.gsub!(/[{}\"]/,'').split(/\=\>/)
42
+ session = get_sessions_array[a[0].split(":").first.to_i]
43
+ session_index = get_sessions_array.index(session)
44
+ # login
45
+ if a[0].split(":").second == AutoTest::Authentication.get_login_path then
46
+ begin
47
+ # necesarry if user data has changed
48
+ # might have to be rescued if the user doesn´t exist anymore.
49
+ user[session_index] = user[session_index].class.find(user[session_index].id)
50
+ rescue
60
51
  end
61
- AutoTest::Authentication.get_login_attributes.each_with_index do |field, i|
62
- session.fill_in field[1], :with => user_data[i]
63
- end
64
- end
65
- session.click_button AutoTest::Authentication.get_login_button
66
- elsif a[1] == AutoTest::Authentication.get_logout_path then
67
- hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = AutoTest::Authentication.get_logout_path
68
- session.visit AutoTest::Authentication.get_logout_path
69
- elsif a[1][0] == "[" then
70
- texts = []
71
- inputs = a[1][1,a[1].size-2].split(/,/)
72
- i = 0
73
- while i < inputs.size do
74
- texts << inputs[i].strip
75
- texts << inputs[i+1].strip
76
- if inputs[i].strip.start_with? "radio___" then
77
- session.choose inputs[i + 1].strip
78
- elsif inputs[i].strip.start_with? "select___" then
79
- session.select inputs[i + 1].strip, :from => inputs[i].gsub("select___",'').strip
80
- elsif inputs[i].strip.start_with? "checkbox___" then
81
- session.check inputs[i].gsub("checkbox___",'').strip
52
+ session.visit AutoTest::Authentication.get_login_path
53
+ hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = AutoTest::Authentication.get_login_button
54
+ # depending on the kind the user is stored in the db, fill in the fields
55
+ if AutoTest::Authentication.use_db_users then
56
+ AutoTest::Authentication.get_login_attributes.each do |field|
57
+ session.fill_in field[1], :with => user[session_index].send(field[0].to_sym)
58
+ end
82
59
  else
83
- input = session.all('input').find{ |inp| inp[:name] == inputs[i].strip}
84
- input.set(inputs[i+1].strip)
60
+ user_data = nil
61
+ index = AutoTest::Authentication.get_login_names.index(AutoTest::Authentication.get_unique_login_attribute_name)
62
+ user[session_index].class.find(:all).each do |u|
63
+ AutoTest::Authentication.get_login_data.each do |d|
64
+ if d[index] == u.send(AutoTest::Authentication.get_unique_login_attribute_name.to_sym) then
65
+ user_data = AutoTest::Authentication.get_login_data[index]
66
+ end
67
+ end
68
+ end
69
+ AutoTest::Authentication.get_login_attributes.each_with_index do |field, i|
70
+ session.fill_in field[1], :with => user_data[i]
71
+ end
72
+ end
73
+ session.click_button AutoTest::Authentication.get_login_button
74
+ # logout
75
+ elsif a[1] == AutoTest::Authentication.get_logout_path then
76
+ hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = AutoTest::Authentication.get_logout_path
77
+ session.visit AutoTest::Authentication.get_logout_path
78
+ # fill in forms
79
+ elsif a[1][0] == "[" then
80
+ texts = []
81
+ inputs = a[1][1,a[1].size-2].split(/,/)
82
+ i = 0
83
+ while i < inputs.size do
84
+ texts << inputs[i].strip
85
+ texts << inputs[i+1].strip
86
+ if inputs[i].strip.start_with? "radio___" then
87
+ session.choose inputs[i + 1].strip
88
+ elsif inputs[i].strip.start_with? "select___" then
89
+ session.select inputs[i + 1].strip, :from => inputs[i].gsub("select___",'').strip
90
+ elsif inputs[i].strip.start_with? "checkbox___" then
91
+ session.check inputs[i].gsub("checkbox___",'').strip
92
+ else
93
+ input = session.all('input').find{ |inp| inp[:name] == inputs[i].strip}
94
+ input.set(inputs[i+1].strip)
95
+ end
96
+ i = i + 2
85
97
  end
86
- i = i + 2
98
+ hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = texts
99
+ session.all('input').find_all{ |i| i[:type] == "submit"}.first.click
100
+ else
101
+ # click link
102
+ link = a[1].split(/\+\+\+/)
103
+ href = link[0]
104
+ text = link[1]
105
+ link = session.all('a').find{ |l| l[:href] == href && l.text == text }
106
+ hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = link[:href].to_s + "+++" + link.text.to_s
107
+ link.click
87
108
  end
88
- hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = texts
89
- session.all('input').find_all{ |i| i[:type] == "submit"}.first.click
109
+ # save the parsed line as a hash
110
+ add_path(hash)
90
111
  else
91
- link = a[1].split(/\+\+\+/)
92
- href = link[0]
93
- text = link[1]
94
- link = session.all('a').find{ |l| l[:href] == href && l.text == text }
95
- hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = link[:href].to_s + "+++" + link.text.to_s
96
- link.click
97
- end
98
- add_path(hash)
99
- else
100
- add_path(line)
101
- line_parts = line.split(":")
102
- session_index = line_parts[0].to_i
103
- id = line_parts[1].to_i
104
- # get the Constant from the String, to find the right class
105
- user[session_index] = AutoTest::Authentication.user_class.find(id)
112
+ # save the parsed line as a String
113
+ add_path(line)
114
+ line_parts = line.split(":")
115
+ session_index = line_parts[0].to_i
116
+ id = line_parts[1].to_i
117
+ # find the right user
118
+ user[session_index] = AutoTest::Authentication.user_class.find(id)
119
+ end
106
120
  end
107
- end
121
+ # rescue from the exception
108
122
  rescue => e
123
+ # check if the right exception occurred and reduce the path
109
124
  if err_message == e.message.to_s.split(/:/,2).first then
110
125
  add_path(hash)
126
+ # step 1: jump to last user
111
127
  new_path = jump_to_last_user(path)
112
128
  init_enlarging_counter
113
129
  error_not_found = true
@@ -115,11 +131,14 @@ describe "Application" do
115
131
  while error_not_found do
116
132
  error_not_found = try_path(new_path)
117
133
  if error_not_found then
134
+ # in case of no or the wrong error enlarge the path and try again
118
135
  new_path = enlarge_path(path)
119
136
  end
120
137
  end
121
138
  last_path = new_path
139
+ # step 2: replace the users that are equal and therefore have larger parts between users
122
140
  replace_same_users!(last_path)
141
+ # count the ID lines in the path
123
142
  user_count = user_count(last_path)
124
143
  # test the path, getting divided
125
144
  for i in 1..user_count do
@@ -127,9 +146,12 @@ describe "Application" do
127
146
  index = nil
128
147
  path_still_changing = true
129
148
  last_index = nil
149
+ # as long as the error is found and the path still changes
130
150
  while !error_not_found && path_still_changing do
151
+ # delete parts of the path
131
152
  return_val = delete_links_half_way(last_path, index, i)
132
153
  index = return_val[1]
154
+ # check if the path was changed
133
155
  if index == last_index then
134
156
  path_still_changing = false
135
157
  else
@@ -137,7 +159,9 @@ describe "Application" do
137
159
  path_still_changing = true
138
160
  end
139
161
  next_path = return_val[0]
162
+ # try the path
140
163
  error_not_found = try_path(next_path)
164
+ # if the error isn´t found, add one action at a time and try again
141
165
  while error_not_found do
142
166
  return_val = delete_links_half_way(last_path, index, i)
143
167
  index = return_val[1]
@@ -150,9 +174,13 @@ describe "Application" do
150
174
  index = nil
151
175
  end
152
176
  end
177
+ # delete groups of links
153
178
  last_path = delete_groups(last_path)
179
+ # delete single links
154
180
  last_path = delete_single_links(last_path)
155
- delete_ids(last_path)
181
+ # delete unnecessary ids
182
+ delete_ids(last_path)
183
+ # save the reduced file
156
184
  f = File.new("#{Rails.root}/log/new_path.log", "w")
157
185
  f.puts last_path
158
186
  f.close
@@ -162,224 +190,12 @@ describe "Application" do
162
190
  end
163
191
  end
164
192
 
165
- def delete_links_without_input(new_path, number_of_links, session)
166
- next_path = []
167
- no_inputs = true
168
- tmp = []
169
- got_one = false
170
- done = false
171
- new_path.each do |n|
172
- done = false
173
- # check if the line is an ID
174
- if n.class == String then
175
- # check if it´s the right session
176
- if n.to_i == session then
177
- # add the line to the path
178
- next_path << n
179
- # save, that the part before was processed
180
- done = true
181
- # save, that the right session id has been found
182
- got_one = true
183
- else
184
- # for other session ids add the line to the tmp array
185
- tmp << n
186
- end
187
- else
188
- current_session = n.keys[0].split(":").first.to_i
189
- # if the right session id hasn´t been found, add the line to the path
190
- if current_session != session && !got_one then
191
- next_path << n
192
- # else add the line to the tmp array
193
- else
194
- tmp << n
195
- # check for input data for forms
196
- if n.values[0].class == Array && current_session == session then
197
- no_inputs = false
198
- end
199
- # if the part of the session to be deleted is finished,
200
- # has no inputs and is smaller or equal to the wanted number of links,
201
- # delete the links of the session, other links get added to the path
202
- if n.values[0] == AutoTest::Authentication.get_logout_path && no_inputs && current_session == session then
203
- if tmp.select{|x| x.class != String && x.keys[0].split(":").first.to_i == session}.size == number_of_links then
204
- tmp.delete_if{|x| x.class != String && x.keys[0].split(":").first.to_i == session}
205
- next_path << tmp
206
- tmp = []
207
- done = true
208
- got_one = false
209
- else
210
- next_path << tmp
211
- tmp = []
212
- done = true
213
- got_one = false
214
- end
215
- elsif n.values[0] == AutoTest::Authentication.get_logout_path && current_session == session then
216
- next_path << tmp
217
- tmp = []
218
- done = true
219
- no_inputs = true
220
- got_one = false
221
- end
222
- end
223
- end
224
- end
225
- if !done then
226
- next_path << tmp
227
- end
228
- return next_path.flatten
229
- end
230
-
231
- def delete_ids(new_path)
232
- for i in 0..get_sessions_array.size - 1 do
233
- found_session = false
234
- index_to_delete = nil
235
- new_path.each_with_index do |n, index|
236
- if n.class == String && n.to_i == i then
237
- index_to_delete = index
238
- if !found_session && index_to_delete != index then
239
- new_path.delete_at(index_to_delete)
240
- end
241
- found_session = false
242
- else
243
- if (n.class != String && n.keys[0].split(":").first.to_i == i) then
244
- found_session = true
245
- end
246
- end
247
- end
248
- if !found_session then
249
- new_path.delete_at(index_to_delete)
250
- end
251
- found_session = false
252
- end
253
- end
254
-
255
- def delete_groups(new_path)
256
- for i in 0..get_sessions_array.size - 1 do
257
- no_of_group = 1
258
- no_of_groups = 1
259
- tmp = []
260
- while no_of_group <= no_of_groups do
261
- count = 0
262
- no_of_groups = 0
263
- next_path = []
264
- new_path.each_with_index do |n,ind|
265
- if n.class != String then
266
- if n.keys[0].split(":").second == AutoTest::Authentication.get_login_path && n.keys[0].split(":").first.to_i == i then
267
- count = count + 1
268
- end
269
- if !(n.keys[0].split(":").first.to_i == i && count == no_of_group) then
270
- next_path << n
271
- else
272
- tmp << n
273
- end
274
- else
275
- next_path << n
276
- end
277
- end
278
- error_not_found = try_path(next_path)
279
- if error_not_found && tmp != [] then
280
- no_of_group = no_of_group + 1
281
- else
282
- new_path = next_path
283
- end
284
- new_path.each do |n|
285
- if n.class != String && n.keys[0].split(":").first.to_i == i && n.values[0] == AutoTest::Authentication.get_logout_path then
286
- no_of_groups = no_of_groups + 1
287
- end
288
- end
289
- tmp = []
290
- end
291
- end
292
- return new_path
293
- puts new_path
294
- end
295
-
296
- def delete_single_links(new_path)
297
- i = 0
298
- while i < new_path.size do
299
- if (new_path[i].class != String &&
300
- !(new_path[i].values.include? AutoTest::Authentication.get_logout_path) &&
301
- !(new_path[i].keys[0].include? AutoTest::Authentication.get_login_path)) then
302
- next_path = new_path[0..i-1]+new_path[i+1..new_path.size]
303
- error_not_found = try_path(next_path)
304
- if !error_not_found then
305
- new_path = next_path
306
- else
307
- i = i + 1
308
- end
309
- else
310
- i = i + 1
311
- end
312
- end
313
- return new_path
314
- end
315
-
316
- def delete_links_half_way(new_path, indx, user)
317
- next_path = []
318
- index = 0
319
- id = 0
320
- first_path = []
321
- middle_path = []
322
- while id <= user && index < new_path.size do
323
- if new_path[index].class == String then
324
- id = id + 1
325
- if id < user || new_path[index + 1].class == String then
326
- if new_path[index + 1].class == String then
327
- id = id - 1
328
- end
329
- first_path << new_path[index]
330
- index = index + 1
331
- else
332
- if id == user then
333
- middle_path << new_path[index]
334
- index = index + 1
335
- end
336
- end
337
- elsif id < user then
338
- first_path << new_path[index]
339
- index = index + 1
340
- else
341
- middle_path << new_path[index]
342
- index = index + 1
343
- end
344
- end
345
- if indx == nil then
346
- tmp = middle_path[0..middle_path.size/2]
347
- else
348
- tmp = middle_path[0..indx]
349
- end
350
- middle_path = tmp
351
- last_path = []
352
- for i in index..new_path.size-1 do
353
- last_path << new_path[i]
354
- end
355
- next_path = first_path + middle_path + last_path
356
- return [next_path, middle_path.size]
357
- end
358
-
359
- def replace_same_users!(new_path)
360
- users = Array.new(get_sessions_array.size)
361
- last_paths = Array.new(get_sessions_array.size)
362
- i = 0
363
- while i < new_path.size do
364
- if new_path[i].class == String then
365
- session = new_path[i].split(":").first.to_i
366
- if users[session] == new_path[i] then
367
- hash = Hash.new
368
- hash[last_paths[new_path[i].split(":").first.to_i]] = AutoTest::Authentication.get_logout_path
369
- new_path[i] = hash
370
- else
371
- users[session] = new_path[i]
372
- end
373
- else
374
- last_paths[new_path[i].keys[0].split(":").first.to_i] = new_path[i]
375
- end
376
- i = i + 1
377
- end
378
- end
379
-
193
+ # try the reduced path
380
194
  def try_path(path_to_try)
195
+ # clean db
381
196
  clean_and_seed_db
382
197
  lno = 0
198
+ # reinitialize all variables and sessions
383
199
  init_sessions
384
200
  init_sessions_array
385
201
  number_of_sessions = AutoTest::Test.get_number_of_sessions
@@ -398,6 +214,7 @@ def try_path(path_to_try)
398
214
  while lno < path_to_try.size do
399
215
  hash = Hash.new
400
216
  line = path_to_try[lno]
217
+ # parse the line from the path
401
218
  if line.class == String then
402
219
  session = get_sessions_array[line.split(":").first.to_i]
403
220
  else
@@ -407,7 +224,8 @@ def try_path(path_to_try)
407
224
  session_index = get_sessions_array.index(session)
408
225
  lno = lno + 1
409
226
  if line.class == Hash then
410
- if line.values[0] == "Anmelden" then
227
+ # login
228
+ if line.values[0] == AutoTest::Authentication.get_login_button then
411
229
  session.visit AutoTest::Authentication.get_login_path
412
230
  hash["#{session_index}:#{session.current_path}"] = AutoTest::Authentication.get_login_button
413
231
  if AutoTest::Authentication.use_db_users then
@@ -428,9 +246,11 @@ def try_path(path_to_try)
428
246
  end
429
247
  end
430
248
  session.click_button AutoTest::Authentication.get_login_button
249
+ # logout
431
250
  elsif line.values[0] == AutoTest::Authentication.get_logout_path then
432
251
  hash["#{session_index}:#{session.current_path}"] = AutoTest::Authentication.get_logout_path
433
252
  session.visit AutoTest::Authentication.get_logout_path
253
+ # fill in forms
434
254
  elsif line.values[0].class == Array then
435
255
  inputs = line.values[0]
436
256
  if !session.all('input').empty? then
@@ -457,6 +277,7 @@ def try_path(path_to_try)
457
277
  if session.current_path.delete("1-9") != session_path.delete("1-9") then
458
278
  session.visit session_path
459
279
  end
280
+ # find the right link
460
281
  link = line.values[0].split(/\+\+\+/)
461
282
  href = link[0].to_s
462
283
  text = link[1]
@@ -467,6 +288,9 @@ def try_path(path_to_try)
467
288
  links = session.all('a').select{ |l| (l[:href].to_s.delete("0-9") == href.delete("0-9")) && l.text == text}
468
289
  links_selected = links + []
469
290
  j = 1
291
+ # compare the href of the link to the ones before, to find the right one
292
+ # if the id was equal to teh last id before, it also has to be equal in the new link
293
+ # if it was different, it has to be different now as well
470
294
  compare_string = ""
471
295
  new_split = session_paths[session_index].split("/")
472
296
  old_split = old_session_paths[session_index].split("/")
@@ -500,6 +324,7 @@ def try_path(path_to_try)
500
324
  end
501
325
  end
502
326
  end
327
+ # check if links were found
503
328
  if links.size > 0 then
504
329
  if links_selected.size > 0 then
505
330
  link = links_selected[session_index % links_selected.size]
@@ -509,7 +334,9 @@ def try_path(path_to_try)
509
334
  old_session_paths[session_index] = href
510
335
  session_paths[session_index] = link[:href].to_s
511
336
  hash["#{session_index}:#{path}"] = "#{link[:href]}+++#{link.text}"
337
+ # click the link
512
338
  link.click
339
+ # if the link was still completely different from the original, visit the desired page
513
340
  next_path = session.current_path.delete("0-9")
514
341
  if next_path != root then
515
342
  session.visit path
@@ -518,6 +345,7 @@ def try_path(path_to_try)
518
345
  hash = path_to_try[lno - 1]
519
346
  end
520
347
  end
348
+ # update the line in the path
521
349
  path_to_try[lno-1].replace(hash)
522
350
  else
523
351
  # if there´s no authorization, no Strings will be saved in the path
@@ -528,6 +356,8 @@ def try_path(path_to_try)
528
356
  rescue
529
357
  index = lno + 1
530
358
  root_path = ""
359
+ # find the right user to continue
360
+ # the next path has to be correct, so login users and check the next path
531
361
  while root_path == "" && index < path_to_try.size do
532
362
  if path_to_try[index].class != String then
533
363
  if path_to_try[index].keys[0].split(":").first.to_i == session_index then
@@ -553,21 +383,234 @@ def try_path(path_to_try)
553
383
  end
554
384
  end
555
385
  rescue => e
386
+ # check for the right error message
556
387
  if err_message == e.message.to_s.split(/:/,2).first then
557
- #puts "Found Error again, go on..."
558
388
  error_not_found = false
559
389
  else
560
- f = File.new("#{Rails.root}/log/debugging.log", "w")
561
- f.puts path_to_try
562
- f.close
563
390
  error_not_found = true
564
391
  end
565
392
  return error_not_found
566
-
567
393
  end
568
394
  return error_not_found
569
395
  end
570
396
 
397
+
398
+ # delete the ids that are redundant
399
+ def delete_ids(new_path)
400
+ for i in 0..get_sessions_array.size - 1 do
401
+ found_session = false
402
+ index_to_delete = nil
403
+ # check if session ids are used in any action
404
+ new_path.each_with_index do |n, index|
405
+ if n.class == String && n.to_i == i then
406
+ index_to_delete = index
407
+ if !found_session && index_to_delete != index then
408
+ new_path.delete_at(index_to_delete)
409
+ end
410
+ found_session = false
411
+ else
412
+ if (n.class != String && n.keys[0].split(":").first.to_i == i) then
413
+ found_session = true
414
+ end
415
+ end
416
+ end
417
+ if !found_session then
418
+ new_path.delete_at(index_to_delete)
419
+ end
420
+ found_session = false
421
+ end
422
+ end
423
+
424
+ # delete groups of actions from the path
425
+ def delete_groups(new_path)
426
+ for i in 0..get_sessions_array.size - 1 do
427
+ no_of_group = 1
428
+ no_of_groups = 1
429
+ tmp = []
430
+ while no_of_group <= no_of_groups do
431
+ count = 0
432
+ no_of_groups = 0
433
+ next_path = []
434
+ new_path.each_with_index do |n,ind|
435
+ # find the right group to be deleted
436
+ if n.class != String then
437
+ if n.keys[0].split(":").second == AutoTest::Authentication.get_login_path && n.keys[0].split(":").first.to_i == i then
438
+ count = count + 1
439
+ end
440
+ if !(n.keys[0].split(":").first.to_i == i && count == no_of_group) then
441
+ next_path << n
442
+ else
443
+ tmp << n
444
+ end
445
+ else
446
+ next_path << n
447
+ end
448
+ end
449
+ # try the reduced path
450
+ error_not_found = try_path(next_path)
451
+ # if error was found, continue with reduced path and the same group number, otherwise
452
+ # continue with same path and incremented group number
453
+ if error_not_found && tmp != [] then
454
+ no_of_group = no_of_group + 1
455
+ else
456
+ new_path = next_path
457
+ end
458
+ # recount no of groups
459
+ new_path.each do |n|
460
+ if n.class != String && n.keys[0].split(":").first.to_i == i && n.values[0] == AutoTest::Authentication.get_logout_path then
461
+ no_of_groups = no_of_groups + 1
462
+ end
463
+ end
464
+ tmp = []
465
+ end
466
+ end
467
+ return new_path
468
+ puts new_path
469
+ end
470
+
471
+ # delete single links
472
+ def delete_single_links(new_path)
473
+ i = 0
474
+ while i < new_path.size do
475
+ # just delete actions other than login, logout or User id
476
+ if (new_path[i].class != String &&
477
+ !(new_path[i].values.include? AutoTest::Authentication.get_logout_path) &&
478
+ !(new_path[i].keys[0].include? AutoTest::Authentication.get_login_path)) then
479
+ next_path = new_path[0..i-1]+new_path[i+1..new_path.size]
480
+ # try the new path
481
+ error_not_found = try_path(next_path)
482
+ # if error was found, continue with reduced path, otherwise, with the same path
483
+ if !error_not_found then
484
+ new_path = next_path
485
+ else
486
+ i = i + 1
487
+ end
488
+ else
489
+ i = i + 1
490
+ end
491
+ end
492
+ return new_path
493
+ end
494
+
495
+ # delete links half way between to User Ids or add one action
496
+ def delete_links_half_way(new_path, indx, user)
497
+ next_path = []
498
+ index = 0
499
+ id = 0
500
+ first_path = []
501
+ middle_path = []
502
+ # find the right part of the path to process
503
+ while id <= user && index < new_path.size do
504
+ if new_path[index].class == String then
505
+ id = id + 1
506
+ if id < user || new_path[index + 1].class == String then
507
+ if new_path[index + 1].class == String then
508
+ id = id - 1
509
+ end
510
+ # get the first part of the path, that has to stay the same
511
+ first_path << new_path[index]
512
+ index = index + 1
513
+ else
514
+ # get the path to be reduced or added an action to
515
+ if id == user then
516
+ middle_path << new_path[index]
517
+ index = index + 1
518
+ end
519
+ end
520
+ elsif id < user then
521
+ first_path << new_path[index]
522
+ index = index + 1
523
+ else
524
+ middle_path << new_path[index]
525
+ index = index + 1
526
+ end
527
+ end
528
+ # check, if the path should be reduced or an action should be concatenated
529
+ if indx == nil then
530
+ tmp = middle_path[0..middle_path.size/2]
531
+ else
532
+ tmp = middle_path[0..indx]
533
+ end
534
+ middle_path = tmp
535
+ last_path = []
536
+ # get the rest of the path
537
+ for i in index..new_path.size-1 do
538
+ last_path << new_path[i]
539
+ end
540
+ # conc the reduced path with the rest of the path, that hasn´t been reduced
541
+ next_path = first_path + middle_path + last_path
542
+ return [next_path, middle_path.size]
543
+ end
544
+
545
+ # replace the Strings in the path with a logout action, that are equal to the last User ID
546
+ def replace_same_users!(new_path)
547
+ users = Array.new(get_sessions_array.size)
548
+ last_paths = Array.new(get_sessions_array.size)
549
+ i = 0
550
+ while i < new_path.size do
551
+ if new_path[i].class == String then
552
+ session = new_path[i].split(":").first.to_i
553
+ if users[session] == new_path[i] then
554
+ hash = Hash.new
555
+ hash[last_paths[new_path[i].split(":").first.to_i]] = AutoTest::Authentication.get_logout_path
556
+ new_path[i] = hash
557
+ else
558
+ users[session] = new_path[i]
559
+ end
560
+ else
561
+ last_paths[new_path[i].keys[0].split(":").first.to_i] = new_path[i]
562
+ end
563
+ i = i + 1
564
+ end
565
+ end
566
+
567
+ # create a new path that starts with the last user of the old path that produced
568
+ # the error
569
+ def jump_to_last_user(old_path)
570
+ # session of the last link that leads to the error
571
+ last_session = old_path[old_path.size-1].keys[0].split(":").first.to_i
572
+ new_path = []
573
+ tmp = []
574
+ old_path.each do |e|
575
+ # search the last user of the last session
576
+ if (e.class == String) && (e.end_with? "ID") && (e.to_i == last_session) then
577
+ tmp = []
578
+ tmp << e
579
+ end
580
+ if (e.class != String) then
581
+ tmp << e
582
+ end
583
+ end
584
+ new_path = tmp
585
+ return new_path
586
+ end
587
+
588
+ # depending on enlarging_counter add another part to the path
589
+ def enlarge_path(path_to_enlarge)
590
+ if enlarging_counter < max_enlarging_counter(path_to_enlarge)-1 then
591
+ inc_enlarging_counter
592
+ else
593
+ return path_to_enlarge
594
+ end
595
+ last_path = jump_to_last_user(path_to_enlarge)
596
+ additional_path = []
597
+ id_count = 0
598
+ index = 0
599
+ # add line by line until the next user is found
600
+ while id_count < enlarging_counter do
601
+ additional_path << path_to_enlarge[index]
602
+ index = index + 1
603
+ if path_to_enlarge[index].class == String && (path_to_enlarge[index].end_with? "ID") then
604
+ id_count = id_count + 1
605
+ end
606
+ end
607
+ return additional_path + last_path
608
+ end
609
+
610
+ ###########################################
611
+ ## helpers
612
+
613
+ # find the next path for the specified session
571
614
  def find_next_path(session, path_to_try, lno)
572
615
  root = ""
573
616
  stop = false
@@ -584,6 +627,7 @@ def find_next_path(session, path_to_try, lno)
584
627
  return root
585
628
  end
586
629
 
630
+ # find next user, that fits the path
587
631
  def find_next_user(root_path, session)
588
632
  index = 0
589
633
  u = 0
@@ -591,11 +635,13 @@ def find_next_user(root_path, session)
591
635
  while u < user_size do
592
636
  user = AutoTest::Authentication.user_class.find(:first, :conditions => "id > #{index}")
593
637
  index = user.id
638
+ # login the user
594
639
  session.visit AutoTest::Authentication.get_login_path
595
640
  AutoTest::Authentication.get_login_attributes.each do |la|
596
641
  session.fill_in la[1], :with => user.send(la[0].to_sym)
597
642
  end
598
643
  session.click_button AutoTest::Authentication.get_login_button
644
+ # check if the path is the right one
599
645
  if session.current_path == root_path then
600
646
  return user
601
647
  end
@@ -604,18 +650,17 @@ def find_next_user(root_path, session)
604
650
  return false
605
651
  end
606
652
 
653
+ # get the counter
607
654
  def enlarging_counter
608
655
  @counter
609
656
  end
610
657
 
658
+ # increment the counter
611
659
  def inc_enlarging_counter
612
660
  @counter = @counter + 1
613
661
  end
614
662
 
615
- def init_enlarging_counter
616
- @counter = 0
617
- end
618
-
663
+ # get the number of users
619
664
  def max_enlarging_counter(whole_path)
620
665
  count = 0
621
666
  whole_path.each do |e|
@@ -626,50 +671,7 @@ def max_enlarging_counter(whole_path)
626
671
  return count
627
672
  end
628
673
 
629
- # => could be optimized
630
- # depending on enlarging_counter add another part to the path
631
- def enlarge_path(path_to_enlarge)
632
- if enlarging_counter < max_enlarging_counter(path_to_enlarge)-1 then
633
- inc_enlarging_counter
634
- else
635
- return path_to_enlarge
636
- end
637
- last_path = jump_to_last_user(path_to_enlarge)
638
- additional_path = []
639
- id_count = 0
640
- index = 0
641
- while id_count < enlarging_counter do
642
- additional_path << path_to_enlarge[index]
643
- index = index + 1
644
- if path_to_enlarge[index].class == String && (path_to_enlarge[index].end_with? "ID") then
645
- id_count = id_count + 1
646
- end
647
- end
648
- return additional_path + last_path
649
- end
650
-
651
- # create a new path that starts with the last user of the old path that produced
652
- # the error
653
-
654
- def jump_to_last_user(old_path)
655
- # session of the last link that leads to the error
656
- last_session = old_path[old_path.size-1].keys[0].split(":").first.to_i
657
- new_path = []
658
- tmp = []
659
- old_path.each do |e|
660
- # search the last user of the last session
661
- if (e.class == String) && (e.end_with? "ID") && (e.to_i == last_session) then
662
- tmp = []
663
- tmp << e
664
- end
665
- if (e.class != String) then
666
- tmp << e
667
- end
668
- end
669
- new_path = tmp
670
- return new_path
671
- end
672
-
674
+ # count the user ids in the path
673
675
  def user_count(path_to_count)
674
676
  count = 0
675
677
  path_to_count.each do |e|
@@ -680,59 +682,72 @@ def user_count(path_to_count)
680
682
  return count
681
683
  end
682
684
 
683
- def init_sessions
684
- @sessions = Hash.new
685
- end
686
-
687
- def init_hash_sessions(key, value)
688
- @sessions["#{key}"] = value
689
- end
690
-
685
+ # set a session variable
691
686
  def sessions(index, key, value)
692
687
  @sessions["#{index}"]["#{key}"] = value
693
688
  end
694
689
 
690
+ # get session
695
691
  def get_sessions(i, key)
696
692
  @sessions["#{i}"]["#{key}"]
697
693
  end
698
694
 
695
+ # get the sessions array
699
696
  def get_sessions_array
700
697
  @sessions_array
701
698
  end
702
699
 
703
- def init_sessions_array
704
- @sessions_array = []
705
- end
706
-
700
+ # add a sesion
707
701
  def add_to_sessions_array(session)
708
702
  @sessions_array << session
709
703
  end
710
704
 
705
+ # clean the db
711
706
  def clean_and_seed_db
712
707
  DatabaseCleaner.clean
713
708
  DatabaseCleaner.start
714
- #load "#{Rails.root}/db/test_seeds.rb"
715
709
  end
716
710
 
711
+ # get the error message
712
+ def err_message
713
+ @err_message
714
+ end
715
+
716
+ # get the path
717
+ def path
718
+ @path
719
+ end
720
+
721
+ # add a value to the path
722
+ def add_path(value)
723
+ @path << value
724
+ end
725
+
726
+ ########################################
727
+ ## initializers
728
+
717
729
  def init_err_file
718
730
  err_file = File.new("#{Rails.root}/log/errors.log", "r")
719
731
  err_file.gets
720
732
  @err_message = err_file.gets.split(/:/,2).first
721
733
  end
722
734
 
723
- def err_message
724
- @err_message
735
+ def init_sessions
736
+ @sessions = Hash.new
725
737
  end
726
738
 
727
- def path
728
- @path
739
+ def init_hash_sessions(key, value)
740
+ @sessions["#{key}"] = value
741
+ end
742
+
743
+ def init_sessions_array
744
+ @sessions_array = []
729
745
  end
730
746
 
731
747
  def init_path
732
748
  @path = []
733
749
  end
734
750
 
735
- def add_path(value)
736
- @path << value
751
+ def init_enlarging_counter
752
+ @counter = 0
737
753
  end
738
-