auto_test 0.0.7.4 → 0.0.7.5

data/lib/spec/requests/error_reduction_spec.rb

@@ -0,0 +1,991 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'auto_test/lib/auto_test'
+# 
+# describe "Application" do
+#   
+#   describe "error path reduction" do
+#     it "reduces the path to the error" do
+#       load "#{Rails.root}/db/test_seeds.rb"  
+#       init_path
+#       init_user_inputs
+#       init_sessions
+#       init_sessions_array
+#       number_of_sessions = user_inputs("get_number_of_sessions").to_i
+#       for i in 0..number_of_sessions-1 do
+#         sess = Capybara::Session.new(:rack_test,Rails.application)
+#         add_to_sessions_array sess
+#         init_hash_sessions(i, Hash.new)
+#       end
+#       init_err_file
+#       lno = 0
+#       paths = File.new("lib/auto_test/log/paths.log")
+#       user = Array.new(3)
+#       session_index = 0
+#       begin
+#         puts "try_path 1"
+#         puts Time.now
+#       while line = paths.gets do
+#         lno = lno + 1
+#      #   puts lno
+#         if !line.chop!.end_with? "ID" then
+#           hash = Hash.new
+#           
+#             a = line.gsub!(/[{}\"]/,'').split(/\=\>/)
+#             session = get_sessions_array[a[0].split(":").first.to_i]
+#             session_index = get_sessions_array.index(session)
+#             if a[0].split(":").second == user_inputs("get_login_path") then
+#               begin
+#                 # necesarry if user data has changed
+#                 # might have to be rescued if the user doesn´t exist anymore. 
+#                 user[session_index] = user[session_index].class.find(user[session_index].id)
+#               rescue
+#               end
+#               session.visit user_inputs("get_login_path")
+#               hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = session.all('input').find_all{ |i|  i[:type] == "submit"}.first.value
+#               if user_inputs("use_db_users") then
+#                 user_inputs("get_login_attributes").each do |field|            
+#                   session.fill_in field[1], :with => user[session_index].send(field[0].to_sym)
+#                 end
+#               else
+#                 index = user_inputs("get_login_names").index(user_inputs("get_unique_login_attribute_name"))        
+#                 user[session_index].class.find(:all).each do |u|
+#                   user_inputs("get_login_data").each do |d|
+#                     if d[index] == u.send(user_inputs("get_unique_login_attribute_name").to_sym) then
+#                       user_data = user_inputs("get_login_data")[index]
+#                     end
+#                   end  
+#                 end
+#                 user_inputs("get_login_attributes").each_with_index do |field, i|
+#                   session.fill_in field[1], :with => user_data[i]
+#                 end
+#               end              
+#               session.all('input').find_all{ |i|  i[:type] == "submit"}.first.click
+#             elsif a[1] == user_inputs("get_logout_path") then
+#               hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = user_inputs("get_logout_path")
+#               session.visit user_inputs("get_logout_path")
+#             elsif a[1][0] == "[" then
+#               texts = []
+#               inputs = a[1][1,a[1].size-2].split(/,/)
+#               i = 0
+#               while i < inputs.size do
+#                 texts << inputs[i].strip
+#                 texts << inputs[i+1].strip
+#                 if inputs[i].strip.start_with? "radio___" then
+#                   session.choose inputs[i + 1].strip
+#                 elsif inputs[i].strip.start_with? "select___" then
+#                   session.select inputs[i + 1].strip, :from => inputs[i].gsub("select___",'').strip
+#                 else
+#                   input = session.all('input').find{ |inp|  inp[:name] == inputs[i].strip}
+#                   input.set(inputs[i+1].strip)
+#                 end
+#                 i = i + 2
+#               end
+#               hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = texts
+#               session.all('input').find_all{ |i|  i[:type] == "submit"}.first.click
+#             else
+#               link = a[1].split(/\+\+\+/)
+#               href = link[0]
+#               text = link[1]
+#               link = session.all('a').find{ |l| l[:href] == href && l.text == text  }
+#               hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = link[:href].to_s + "+++" + link.text.to_s
+#               link.click
+#             end
+#             add_path(hash)
+#        
+#         else
+#           add_path(line)
+#           line_parts = line.split(":")
+#           session_index = line_parts[0].to_i
+#           id = line_parts[1].to_i
+#           # get the Constant from the String, to find the right class
+#           user[session_index] = Kernel.const_get(user_inputs("user_class")).find(id)
+#         end 
+#       end 
+#          rescue => e
+#             if err_message == e.message.to_s.split(/:/,2).first then
+#            #   puts "Found error again!"
+#               add_path(hash)    
+#               last_path = path + []       
+#               puts Time.now
+# 
+#               puts "Replace"
+#               puts Time.now
+#               replace_same_users!(last_path)
+#               puts Time.now
+#               user_count = user_count(last_path)
+#               puts "Half"
+#               puts Time.now
+#               # test the path, getting divided
+#               for i in 1..user_count do
+#                 error_not_found = false
+#                 index = nil
+#                 path_still_changing = true
+#                 last_index = nil
+#                 while !error_not_found && path_still_changing do
+#                   return_val = delete_links_half_way(last_path, index, i)
+#                   index = return_val[1]
+#                   if index == last_index  then
+#                     path_still_changing = false
+#                   else
+#                     last_index = index
+#                     path_still_changing = true
+#                   end
+#                   next_path = return_val[0]
+#                   error_not_found = try_path(next_path)
+#                   while error_not_found do
+#                     return_val = delete_links_half_way(last_path, index, i)
+#                     index = return_val[1]
+#                     next_path = return_val[0]
+#                     error_not_found = try_path(next_path)
+#                   end
+#                   if !error_not_found then
+#                     last_path = next_path
+#                   end
+#                   index = nil
+#                 end
+#               end
+#               puts Time.now          
+#               
+#                 puts "Jump"
+#                 puts Time.now
+#                 new_path = jump_to_last_user(last_path)
+#                 init_enlarging_counter
+#                 error_not_found = true
+#                 # test the jump_to_last_user path
+#                 while error_not_found do
+#                   error_not_found = try_path(new_path)
+#                   if error_not_found then
+#                     new_path = enlarge_path(last_path)
+#                   end
+#                 end
+#                 puts Time.now
+#                 last_path = new_path
+#               
+#               
+#               puts "Delete Groups"
+#               puts Time.now              
+#               last_path = delete_groups(last_path)
+#               puts Time.now
+# 
+#               puts "Single"
+#               puts Time.now
+#               last_path = delete_single_links(last_path)
+#               puts Time.now
+#               puts "Delete IDs"
+#               puts Time.now
+#               delete_ids(last_path)              
+#               puts Time.now              
+#               f = File.new("lib/auto_test/log/new_path.log", "w")
+#               f.puts last_path
+#               f.close
+#             else 
+#               puts "Different error, stopping..."
+#               puts e
+#             end
+#           end
+#     end
+#   end
+# end
+# 
+
+
+
+describe "Application" do
+  
+  describe "error path reduction" do
+    it "reduces the path to the error" do
+      load "#{Rails.root}/db/test_seeds.rb"  
+      init_path
+      init_user_inputs
+      init_sessions
+      init_sessions_array
+      number_of_sessions = user_inputs("get_number_of_sessions").to_i
+      for i in 0..number_of_sessions-1 do
+        sess = Capybara::Session.new(:rack_test,Rails.application)
+        add_to_sessions_array sess
+        init_hash_sessions(i, Hash.new)
+      end
+      init_err_file
+      lno = 0
+      paths = File.new("lib/auto_test/log/paths.log")
+      user = Array.new(number_of_sessions)
+      session_index = 0
+      begin
+        puts "try_path 1"
+        puts Time.now
+      while line = paths.gets do
+        lno = lno + 1
+     #   puts lno
+        if !line.chop!.end_with? "ID" then
+          hash = Hash.new
+          
+            a = line.gsub!(/[{}\"]/,'').split(/\=\>/)
+            session = get_sessions_array[a[0].split(":").first.to_i]
+            session_index = get_sessions_array.index(session)
+            if a[0].split(":").second == user_inputs("get_login_path") then
+              begin
+                # necesarry if user data has changed
+                # might have to be rescued if the user doesn´t exist anymore. 
+                user[session_index] = user[session_index].class.find(user[session_index].id)
+              rescue
+              end
+              session.visit user_inputs("get_login_path")
+              hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = session.all('input').find_all{ |i|  i[:type] == "submit"}.first.value
+              if user_inputs("use_db_users") then
+                user_inputs("get_login_attributes").each do |field|            
+                  session.fill_in field[1], :with => user[session_index].send(field[0].to_sym)
+                end
+              else
+                index = user_inputs("get_login_names").index(user_inputs("get_unique_login_attribute_name"))        
+                user[session_index].class.find(:all).each do |u|
+                  user_inputs("get_login_data").each do |d|
+                    if d[index] == u.send(user_inputs("get_unique_login_attribute_name").to_sym) then
+                      user_data = user_inputs("get_login_data")[index]
+                    end
+                  end  
+                end
+                user_inputs("get_login_attributes").each_with_index do |field, i|
+                  session.fill_in field[1], :with => user_data[i]
+                end
+              end              
+              session.all('input').find_all{ |i|  i[:type] == "submit"}.first.click
+            elsif a[1] == user_inputs("get_logout_path") then
+              hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = user_inputs("get_logout_path")
+              session.visit user_inputs("get_logout_path")
+            elsif a[1][0] == "[" then
+              texts = []
+              inputs = a[1][1,a[1].size-2].split(/,/)
+              i = 0
+              while i < inputs.size do
+                texts << inputs[i].strip
+                texts << inputs[i+1].strip
+                if inputs[i].strip.start_with? "radio___" then
+                  session.choose inputs[i + 1].strip
+                elsif inputs[i].strip.start_with? "select___" then
+                  session.select inputs[i + 1].strip, :from => inputs[i].gsub("select___",'').strip
+                elsif inputs[i].strip.start_with? "checkbox___" then  
+                  session.check inputs[i + 1].strip
+                else
+                  input = session.all('input').find{ |inp|  inp[:name] == inputs[i].strip}
+                  input.set(inputs[i+1].strip)
+                end
+                i = i + 2
+              end
+              hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = texts
+              session.all('input').find_all{ |i|  i[:type] == "submit"}.first.click
+            else
+              link = a[1].split(/\+\+\+/)
+              href = link[0]
+              text = link[1]
+              link = session.all('a').find{ |l| l[:href] == href && l.text == text  }
+              hash["#{get_sessions_array.index(session)}:#{session.current_path}"] = link[:href].to_s + "+++" + link.text.to_s
+              link.click
+            end
+            add_path(hash)
+       
+        else
+          add_path(line)
+          line_parts = line.split(":")
+          session_index = line_parts[0].to_i
+          id = line_parts[1].to_i
+          # get the Constant from the String, to find the right class
+          user[session_index] = Kernel.const_get(user_inputs("user_class")).find(id)
+        end 
+      end 
+         rescue => e
+            if err_message == e.message.to_s.split(/:/,2).first then
+           #   puts "Found error again!"
+              add_path(hash)           
+              puts Time.now
+              puts "Jump"
+              puts Time.now
+              new_path = jump_to_last_user(path)
+             init_enlarging_counter
+             error_not_found = true
+             # test the jump_to_last_user path
+             while error_not_found do
+               error_not_found = try_path(new_path)
+               if error_not_found then
+                 new_path = enlarge_path(path)
+               end
+             end
+             puts Time.now
+              last_path = new_path
+   
+              puts "Replace"
+              puts Time.now
+              replace_same_users!(last_path)
+              puts Time.now
+              user_count = user_count(last_path)
+              puts "Half"
+              puts Time.now
+              # test the path, getting divided
+              for i in 1..user_count do
+                error_not_found = false
+                index = nil
+                path_still_changing = true
+                last_index = nil
+                while !error_not_found && path_still_changing do
+                  return_val = delete_links_half_way(last_path, index, i)
+                  index = return_val[1]
+                  if index == last_index  then
+                    path_still_changing = false
+                  else
+                    last_index = index
+                    path_still_changing = true
+                  end
+                  next_path = return_val[0]
+                  error_not_found = try_path(next_path)
+                  while error_not_found do
+                    return_val = delete_links_half_way(last_path, index, i)
+                    index = return_val[1]
+                    next_path = return_val[0]
+                    error_not_found = try_path(next_path)
+                  end
+                  if !error_not_found then
+                    last_path = next_path
+                  end
+                  index = nil
+                end
+              end
+              puts Time.now          
+              
+              puts "Delete Groups"
+              puts Time.now              
+              last_path = delete_groups(last_path)
+              puts Time.now
+
+              puts "Single"
+              puts Time.now
+              last_path = delete_single_links(last_path)
+              puts Time.now
+              puts "Delete IDs"
+              puts Time.now
+              delete_ids(last_path)              
+              puts Time.now              
+              f = File.new("lib/auto_test/log/new_path.log", "w")
+              f.puts last_path
+              f.close
+            else 
+              puts "Different error, stopping..."
+              puts e
+            end
+          end
+    end
+  end
+end
+def delete_links_without_input(new_path, number_of_links, session)
+  next_path = []
+  no_inputs = true 
+  tmp = []
+  got_one = false
+  done = false
+  new_path.each do |n|
+    done = false
+    # check if the line is an ID
+    if n.class == String then
+      # check if it´s the right session
+      if n.to_i == session then
+        # add the line to the path
+        next_path << n
+        # save, that the part before was processed
+        done = true
+        # save, that the right session id has been found
+        got_one = true
+      else 
+        # for other session ids add the line to the tmp array
+        tmp << n 
+      end
+    else 
+      current_session = n.keys[0].split(":").first.to_i
+      # if the right session id hasn´t been found, add the line to the path
+      if current_session != session && !got_one then
+        next_path << n
+      # else add the line to the tmp array
+      else
+        tmp << n
+        # check for input data for forms
+        if n.values[0].class == Array && current_session == session then
+          no_inputs = false
+        end
+        # if the part of the session to be deleted is finished, 
+        # has no inputs and is smaller or equal to the wanted number of links,
+        # delete the links of the session, other links get added to the path
+        if n.values[0] == user_inputs("get_logout_path") && no_inputs && current_session == session then
+          if tmp.select{|x| x.class != String && x.keys[0].split(":").first.to_i == session}.size == number_of_links then
+            tmp.delete_if{|x| x.class != String && x.keys[0].split(":").first.to_i == session}
+            next_path << tmp
+            tmp = []
+            done = true
+            got_one = false 
+          else
+            next_path << tmp
+            tmp = []
+            done = true
+            got_one = false
+          end
+        elsif n.values[0] == user_inputs("get_logout_path") && current_session == session then
+          next_path << tmp
+          tmp = []
+          done = true
+          no_inputs = true
+          got_one = false
+        end
+      end  
+    end
+  end
+  if !done then 
+    next_path << tmp
+  end
+  return next_path.flatten
+end
+
+
+def delete_ids(new_path)
+  for i in 0..get_sessions_array.size - 1 do
+    found_session = false
+    index_to_delete = nil
+    new_path.each_with_index do |n, index|
+      if n.class == String && n.to_i == i then
+        index_to_delete = index
+        if !found_session && index_to_delete != index then 
+          new_path.delete_at(index_to_delete)
+        end
+        found_session = false
+      else
+        if (n.class != String && n.keys[0].split(":").first.to_i == i) then
+          found_session = true
+        end
+      end
+    end
+    if !found_session then 
+      new_path.delete_at(index_to_delete)
+    end
+    found_session = false
+  end
+end
+
+def delete_groups(new_path)
+  for i in 0..get_sessions_array.size - 1 do
+    no_of_group = 1
+    no_of_groups = 1
+    tmp = []
+    while no_of_group <= no_of_groups do
+      count = 0
+      no_of_groups = 0
+      next_path = []
+      new_path.each_with_index do |n,ind|
+        if n.class != String then
+          if n.keys[0].split(":").second == user_inputs("get_login_path") && n.keys[0].split(":").first.to_i == i then
+            count = count + 1
+          end
+          if !(n.keys[0].split(":").first.to_i == i && count == no_of_group) then
+            next_path << n
+          else
+            tmp << n
+          end
+        else
+          next_path << n
+        end
+      end
+      error_not_found = try_path(next_path)
+      if error_not_found && tmp != [] then
+        no_of_group = no_of_group + 1
+      else 
+        new_path = next_path
+      end
+      new_path.each do |n|
+        if n.class != String && n.keys[0].split(":").first.to_i == i && n.values[0] == user_inputs("get_logout_path") then
+          no_of_groups = no_of_groups + 1
+        end
+      end
+      tmp = []
+    end
+  end
+  return new_path
+  puts new_path
+end
+
+def delete_single_links(new_path)
+  i = 0
+  while i < new_path.size do
+    if (new_path[i].class != String && 
+      !(new_path[i].values.include? user_inputs("get_logout_path")) && 
+      !(new_path[i].keys[0].include? user_inputs("get_login_path"))) then
+        next_path = new_path[0..i-1]+new_path[i+1..new_path.size]
+        error_not_found = try_path(next_path)
+        if !error_not_found then
+          new_path = next_path
+        else
+          i = i + 1
+        end
+    else
+      i = i + 1
+    end
+  end
+  return new_path
+end
+
+def delete_links_half_way(new_path, indx, user)
+  next_path = []
+  index = 0
+  id = 0
+  first_path = []
+  middle_path = []
+  while id <= user && index < new_path.size do
+    if new_path[index].class == String then
+      id = id + 1
+      if id < user || new_path[index + 1].class == String then
+        if new_path[index + 1].class == String then
+          id = id - 1
+        end
+        first_path << new_path[index]
+        index = index + 1
+      else
+        if id == user then
+          middle_path << new_path[index]
+          index = index + 1
+        end
+      end
+    elsif id < user then 
+      first_path << new_path[index]
+      index = index + 1
+    else
+      middle_path << new_path[index]
+      index = index + 1
+    end
+  end
+  if indx == nil then
+    tmp = middle_path[0..middle_path.size/2]
+  else
+    tmp = middle_path[0..indx]
+  end
+  middle_path = tmp
+  last_path = []
+  for i in index..new_path.size-1 do
+    last_path << new_path[i]
+  end 
+  next_path = first_path + middle_path + last_path
+  return [next_path, middle_path.size]
+end
+
+def replace_same_users!(new_path)
+  users = Array.new(get_sessions_array.size)
+  last_paths = Array.new(get_sessions_array.size)
+  i = 0 
+  while i < new_path.size do
+    if new_path[i].class == String then
+      session = new_path[i].split(":").first.to_i 
+      if users[session] == new_path[i] then
+        hash = Hash.new
+        hash[last_paths[new_path[i].split(":").first.to_i]] = user_inputs("get_logout_path")
+        new_path[i] = hash
+      else 
+        users[session] = new_path[i]
+      end
+    else 
+      last_paths[new_path[i].keys[0].split(":").first.to_i] = new_path[i]
+    end
+    i = i + 1
+  end 
+end
+
+def try_path(path_to_try)
+  clean_and_seed_db
+  lno = 0
+  init_sessions
+  init_sessions_array
+  number_of_sessions = user_inputs("get_number_of_sessions").to_i
+  for i in 0..number_of_sessions-1 do
+    sess = Capybara::Session.new(:rack_test,Rails.application)
+    add_to_sessions_array sess
+    init_hash_sessions(i, Hash.new)
+  end
+  user = Array.new(number_of_sessions)
+  session_paths = Array.new(number_of_sessions, "")
+  old_session_paths = Array.new(number_of_sessions, "")
+  session_index = 0
+  error_not_found = true
+  begin    
+    lno = 0
+   # puts lno
+    while lno < path_to_try.size do
+      hash = Hash.new
+      line = path_to_try[lno]
+      if line.class == String then
+        session = get_sessions_array[line.split(":").first.to_i]
+      else
+        session = get_sessions_array[line.keys[0].split(":").first.to_i]
+        session_path = line.keys[0].split(":").second
+      end
+      session_index = get_sessions_array.index(session)
+      lno = lno + 1
+     # puts lno
+      if line.class == Hash then
+        if line.values[0] == "Anmelden" then
+          session.visit user_inputs("get_login_path")
+          hash["#{session_index}:#{session.current_path}"] = session.all('input').find_all{ |i|  i[:type] == "submit"}.first.value
+          if user_inputs("use_db_users") then
+            user_inputs("get_login_attributes").each do |field|            
+              session.fill_in field[1], :with => user[session_index].send(field[0].to_sym)
+            end
+          else
+            index = user_inputs("get_login_names").index(user_inputs("get_unique_login_attribute_name"))        
+            user[session_index].class.find(:all).each do |u|
+              user_inputs("get_login_data").each do |d|
+                if d[index] == u.send(user_inputs("get_unique_login_attribute_name").to_sym) then
+                  user_data = user_inputs("get_login_data")[index]
+                end
+              end  
+            end
+            user_inputs("get_login_attributes").each_with_index do |field, i|
+              session.fill_in field[1], :with => user_data[i]
+            end
+          end
+          session.all('input').find_all{ |i|  i[:type] == "submit"}.first.click  
+        elsif line.values[0] == user_inputs("get_logout_path") then
+          hash["#{session_index}:#{session.current_path}"] = user_inputs("get_logout_path")
+          session.visit user_inputs("get_logout_path")
+        elsif line.values[0].class == Array then  
+          inputs = line.values[0]
+          if !session.all('input').empty? then
+            i = 0
+            while i < inputs.size do
+              if inputs[i].strip.start_with? "radio___" then
+                session.choose inputs[i + 1].strip
+              elsif inputs[i].strip.start_with? "select___" then
+                session.select inputs[i + 1].strip, :from => inputs[i].gsub("select___",'').strip
+              elsif inputs[i].strip.start_with? "checkbox___" then  
+                session.check inputs[i + 1].strip
+              else
+                input = session.all('input').find{ |inp|  inp[:name] == inputs[i].strip}
+                input.set(inputs[i+1].strip)
+              end
+              i = i + 2
+            end 
+            hash["#{session_index}:#{session.current_path}"] = path_to_try[lno - 1].values[0]
+            session.all('input').find_all{ |i|  i[:type] == "submit"}.first.click
+          else 
+            hash = path_to_try[lno-1]
+          end
+        else
+          if session.current_path.delete("1-9") != session_path.delete("1-9") then
+            session.visit session_path
+          end
+          link = line.values[0].split(/\+\+\+/)
+          href = link[0].to_s
+          text = link[1]
+          path = session.current_path
+          root = find_next_path(session_index, path_to_try, lno)
+          old_p = href.split("/")
+           # => check for ids in string
+          links = session.all('a').select{ |l| (l[:href].to_s.delete("0-9") == href.delete("0-9")) && l.text == text}
+          links_selected = links + []
+          j = 1
+          compare_string = ""
+          new_split = session_paths[session_index].split("/")
+          old_split = old_session_paths[session_index].split("/")
+          while old_p[j] == old_split[j] && old_p[j] != nil do
+            if new_split[j] != nil then
+              compare_string << ("/" + new_split[j])
+              if old_p[j].to_i.to_s == old_p[j] then
+                links_selected = links_selected.select{ |l| 
+                  l[:href].to_s[0..compare_string.size-1] ==  compare_string }
+              end
+            end
+            j = j + 1
+          end
+          for i in 0..get_sessions_array.size - 1 do
+            compare_string = ""
+            if i != session_index then
+              old_sess_p = old_session_paths[i].split("/")
+              new_sess_p = session_paths[i].split("/")
+              j = 1
+              while old_p[j] == old_sess_p[j] && old_p[j] != nil do
+                compare_string << "/" + new_sess_p[j] 
+                j = j + 1
+              end
+             links_selected = links_selected.select{ |l| l[:href].start_with? compare_string  }
+             if new_sess_p[j] != nil then
+                compare_string << ("/" + new_sess_p[j] )
+              end
+              # if the string is an id
+              if old_p[j].to_i.to_s == old_p[j] && new_sess_p[j] != nil && new_sess_p[j].to_i.to_s == new_sess_p[j] then
+                links_selected = links_selected.select{ |l| !(l[:href].start_with? compare_string) }
+              end
+            end
+          end
+          if links.size > 0 then
+            if links_selected.size > 0 then
+              link = links_selected[session_index % links_selected.size]
+            else
+              link = links[session_index % links.size]
+            end
+            old_session_paths[session_index] = href
+            session_paths[session_index] = link[:href].to_s
+            hash["#{session_index}:#{path}"] = "#{link[:href]}+++#{link.text}"
+            link.click
+            next_path = session.current_path.delete("0-9")
+            if next_path != root then
+              session.visit path
+            end
+          else
+            hash = path_to_try[lno - 1]
+          end
+        end
+        path_to_try[lno-1].replace(hash)  
+      else
+        # if there´s no authorization, no Strings will be saved in the path
+        if user_inputs("use_db_users") then 
+          id = line.split(":").second.to_i
+          begin 
+            user[session_index] = Kernel.const_get(user_inputs("user_class")).find(id) 
+          rescue
+            index = lno + 1
+            root_path = ""
+            while root_path == "" && index < path_to_try.size do
+               if path_to_try[index].class != String then
+                if path_to_try[index].keys[0].split(":").first.to_i == session_index then
+                  if path_to_try[index].keys[0].split(":").second != user_inputs("get_login_path") then
+                    root_path = path_to_try[index].keys[0].split(":").second
+                  end
+                end
+                index = index + 1
+              else 
+                index = index + 1
+              end
+            end
+            user[session_index] = find_next_user(root_path, session)
+          end
+        else
+          user[session_index] = Kernel.const_get(user_inputs("user_class")).find(id) 
+        end
+        if user[session_index] == false then 
+          return error_not_found
+        else
+          path_to_try[lno - 1] = "#{session_index}:#{user[session_index].id}ID"
+        end
+      end
+    end  
+   rescue => e
+     if err_message == e.message.to_s.split(/:/,2).first then
+       #puts "Found Error again, go on..."
+       error_not_found = false
+     else 
+       f = File.new("lib/auto_test/log/debugging.log", "w")
+       f.puts path_to_try
+       f.close
+   #    puts "Different Error:" + e.message.to_s
+    #   puts lno
+  #  puts line
+       error_not_found = true
+     end
+     return error_not_found
+  
+   end
+  return error_not_found
+end
+
+def find_next_path(session, path_to_try, lno)
+  root = ""
+  stop = false
+  while lno < path_to_try.size && !stop do
+    line = path_to_try[lno]
+    if line.class != String && line.keys[0].split(":").first.to_i == session then
+      root = line.keys[0].split(":").second.delete("0-9")
+      stop = true
+    elsif line.class == String && line.split(":").first.to_i == session then
+      stop = true
+    end
+    lno = lno + 1
+  end
+  return root
+end
+
+def find_next_user(root_path, session)
+  index = 0
+  u = 0
+  user_size = Kernel.const_get(user_inputs("user_class")).find(:all).size
+  while u < user_size do
+    user = Kernel.const_get(user_inputs("user_class")).find(:first, :conditions => "id > #{index}")
+    index = user.id
+    session.visit user_inputs("get_login_path")
+    user_inputs("get_login_attributes").each do |la|
+      session.fill_in la[1], :with => user.send(la[0].to_sym)
+    end
+    session.all('input').find_all{ |i|  i[:type] == "submit"}.first.click
+    if session.current_path == root_path then
+      return user
+    end
+    u = u + 1
+  end 
+  return false
+end
+
+def enlarging_counter
+  @counter 
+end
+
+def inc_enlarging_counter
+  @counter = @counter + 1
+end
+
+def init_enlarging_counter
+  @counter = 0
+end
+
+def max_enlarging_counter(whole_path)
+  count = 0
+  whole_path.each do |e|
+    if e.class == String && (e.end_with? "ID") then
+      count = count + 1
+    end
+  end
+  return count
+end
+
+# => could be optimized
+# depending on enlarging_counter add another part to the path
+def enlarge_path(path_to_enlarge)
+  if enlarging_counter < max_enlarging_counter(path_to_enlarge)-1 then
+    inc_enlarging_counter
+  else
+    return path_to_enlarge
+  end
+  last_path = jump_to_last_user(path_to_enlarge)
+  additional_path = []
+  id_count = 0
+  index = 0
+  while id_count < enlarging_counter do
+    additional_path << path_to_enlarge[index]
+    index = index + 1
+    if path_to_enlarge[index].class == String && (path_to_enlarge[index].end_with? "ID") then
+      id_count = id_count + 1
+    end
+  end
+  return additional_path + last_path
+end
+
+# create a new path that starts with the last user of the old path that produced
+# the error
+
+def jump_to_last_user(old_path)
+  # session of the last link that leads to the error
+  last_session = old_path[old_path.size-1].keys[0].split(":").first.to_i
+  new_path = []
+  tmp = []
+  old_path.each do |e|
+    # search the last user of the last session
+    if (e.class == String) && (e.end_with? "ID") && (e.to_i == last_session) then
+      tmp = []
+      tmp << e
+    end
+    if (e.class != String) then
+      tmp << e
+    end
+  end
+  new_path = tmp
+  return new_path
+end
+
+def user_count(path_to_count)
+  count = 0
+  path_to_count.each do |e|
+    if e.class == String then
+      count = count + 1
+    end
+  end
+  return count
+end
+
+def init_sessions
+  @sessions = Hash.new
+end
+
+def init_hash_sessions(key, value)
+  @sessions["#{key}"] = value
+end
+
+def sessions(index, key, value)
+  @sessions["#{index}"]["#{key}"] = value
+end
+
+def get_sessions(i, key)
+  @sessions["#{i}"]["#{key}"]
+end
+
+def get_sessions_array
+  @sessions_array
+end
+
+def init_sessions_array 
+  @sessions_array = []
+end
+
+def add_to_sessions_array(session)
+  @sessions_array << session
+end
+
+def clean_and_seed_db
+  DatabaseCleaner.strategy = :truncation
+  DatabaseCleaner.start
+  DatabaseCleaner.clean
+  load "#{Rails.root}/db/test_seeds.rb"
+end
+
+def init_err_file
+  err_file = File.new("lib/auto_test/log/errors.log", "r")
+  err_file.gets
+  @err_message = err_file.gets.split(/:/,2).first
+end
+
+def err_message
+  @err_message
+end
+
+def init_user_inputs
+  @user_inputs = Hash.new
+  file = File.new("lib/auto_test/log/user_input.log", "r")
+  while line = file.gets do
+    b = line.split(/:/,2)
+    @user_inputs["#{b[0].strip}"] = b[1].chop
+  end
+  @user_inputs.each do |k,v|
+    if v.start_with? "[" then
+      x = v.split("],[")
+      result = []
+      x.each do |i|
+        result << i.delete("[]\"").split(",")
+      end
+      result.each do |r|
+        if r.class == String then
+          r.strip!
+        else
+          r.each do |s|
+            s.strip!
+          end
+        end
+      end
+      @user_inputs[k] = result
+    end
+  end
+end
+
+def user_inputs(key)
+  @user_inputs[key]
+end
+
+def path
+  @path
+end
+
+def init_path
+  @path = []
+end
+
+def add_path(value)
+  @path << value
+end
+