auto_test 0.0.7.4 → 0.0.7.5

data/lib/tasks/auto_test.task

@@ -0,0 +1,58 @@
+
+namespace :auto_test do
+  desc "starting the test"
+  task :test do
+    puts "Running auto_test..."
+    sh "rails server -e test -p 3002 -d"
+    sh "rspec lib/spec/requests/auto_spec.rb -o 'log/rspec.txt'" 
+    sh "rm 'log/rspec.txt'"
+    Rake::Task[:error_calc].invoke
+    Rake::Task[:stop].invoke
+  end
+
+  desc "calculating the errors"
+  task :error_calc do
+    err = File.read("log/errors.log")
+    if err.to_i > 0 then
+      puts "Do you want to see the error-path in firefox? Type yes/no:"
+      a = STDIN.gets.chomp
+      if a == "yes" then
+        Rake::Task[:reduce_errors].invoke
+      end
+    end
+  end
+  
+  desc "Reducing the error path"
+  task :reduce_errors do
+    puts "Reducing the error path, this could take a while..."
+    sh "rspec lib/spec/requests/error_reduction_spec.rb -o 'log/reduce_err.txt'"
+    sh "rm 'log/reduce_err.txt'"
+    Rake::Task[:start_action_path].invoke
+  end
+
+  desc "starting the simulation"
+  task :start_action_path do
+    # paths = File.new("lib/auto_test/log/new_path.log")
+    #   n = 0
+    #   while line = paths.gets do
+    #     n = n + 1
+    #   end
+    #   puts "Error path reduced.There are #{n} paths to be visited."
+    #   puts "Press Enter to see the path in Firefox! "
+    #   STDIN.gets
+    ruby 'lib/simulation.rb'
+  end
+
+
+  desc 'stopping rails'
+  task :stop do
+      begin
+        pid_file = 'tmp/pids/server.pid'
+        pid = File.read(pid_file).to_i
+        Process.kill 9, pid
+        File.delete pid_file
+      rescue
+      end
+  end
+
+end

data/lib/test.rb

@@ -0,0 +1,380 @@
+require 'capybara/rspec'
+#require 'watir-webdriver'
+module AutoTest
+  module Test   
+    module_function
+  
+    # initialize all variables
+    def initialize_test
+      User.init_users
+      User.init_login_data
+      init_action_path
+      init_depth
+      init_inputs
+      init_always_present
+      Error.init_error
+      init_object_dependencies
+      init_stop_at_first_error
+      init_stop
+      init_auth
+      init_number_of_test_runs
+    end
+    
+    def init_number_of_test_runs
+      @@runs = 1
+    end
+    
+    def init_stop_at_first_error
+      @@stop_at_first_error = false
+    end
+     
+    def init_stop
+      @@stop = false
+    end
+
+    # initialize the depth of link search with 0
+    def init_depth
+     @@depth = 0
+    end
+    
+    def init_auth 
+      @@no_auth = false
+    end
+     
+    def init_action_path
+     @@action_paths = []
+    end
+    
+    # initialize dependency array
+    def init_object_dependencies
+     @@dependencies = []
+    end
+    
+    def init_always_present
+     @@always_present = []
+    end
+
+    def init_inputs
+     @@inputs = Hash.new
+    end
+     
+    
+    def check_invariants
+      get_always_present.each do |present|
+        if present[0].find(:first, :conditions => "#{present[1]} = '#{present[2]}'") == nil then
+          if stop_at_first_error? then stop! end
+          logger.info "*"*100
+          message = "ERROR  :   Invariant always_present : 
+                class '#{present[0]}' attribute '#{present[1]}' value '#{present[2]}' was deleted"
+          logger.error message
+          logger.info "*"*100
+          Error.inc_error(message)   
+        end
+      end
+      get_object_dependencies.each do |dependency|
+        children = dependency[0].find(:all)
+        children.each do |child|
+          begin
+            dependency[1].find(child.send(dependency[2].to_sym))
+          rescue
+            if stop_at_first_error? then stop! end
+            logger.info "*"*100
+            message = "ERROR  :   Invariant object_dependencies : 
+                  no '#{dependency[1]}' for #{dependency[0]} #{child.id}"
+            logger.error message
+            logger.info "*"*100
+            Error.inc_error(message)   
+          end
+        end
+      end
+    end
+    
+    def set_number_of_test_runs(number)
+      @@runs = number
+    end
+
+    def get_number_of_test_runs
+      @@runs 
+    end
+
+    def stop_at_first_error(stop_at_first_error) 
+      @@stop_at_first_error = stop_at_first_error
+    end
+
+    def stop_at_first_error?
+      @@stop_at_first_error
+    end
+
+    def stop?
+      @@stop
+    end
+    
+    def stop!
+      @@stop = true
+    end
+
+    #incremtent the depth
+    def inc_depth
+      @@depth = @@depth + 1
+    end
+
+    def get_depth
+      @@depth
+    end
+
+    def set_max_depth(value)
+      @@max_depth = value
+    end
+
+    def get_max_depth
+      @@max_depth
+    end
+
+
+    # get object dependencies
+    def get_object_dependencies
+      @@dependencies 
+    end
+
+    # for all objects of class child, there has to be one object of class parent
+    # attribute_name is the column that joins the two tables
+    def set_object_dependency(child, parent, attribute_name)
+      @@dependencies << [child, parent, attribute_name]
+    end
+
+    # for the name or part of the name of an input field, decide, which values to use
+    # if not set, random values matching the input type are used
+    def set_input(input, *values)
+      @@inputs.store(input, values)
+    end
+    
+    def get_inputs
+      @@inputs
+    end
+    
+    def set_number_of_sessions(number)
+      @@number_of_sessions = number
+    end
+    
+    def get_number_of_sessions
+      @@number_of_sessions
+    end
+
+    # add an array of the classname, key and value of the object to be checked every cycle
+    def always_present(class_name, key, value)
+      @@always_present << [class_name, key, value]
+    end
+
+    def get_always_present
+      @@always_present
+    end
+
+    def get_links_to_exclude
+      @@links
+    end
+
+    # list of links that will not be clicked during the test
+    def links_to_exclude(*links)
+      @@links = links
+    end
+        
+    def paths=(value)
+      @paths = value
+    end
+    
+    def paths
+      @paths
+    end
+  
+    def iterations
+      @iterations
+    end
+    
+    def iterations=(value)
+      @iterations = value
+    end
+    
+    def link_counter
+      @link_counter 
+    end
+    def link_counter=(value)
+      @link_counter = value
+    end
+    
+    def run=(value)
+      @run = value
+    end
+    
+    def run
+      @run
+    end
+    
+    def action_path
+      @@action_paths
+    end
+    
+    def no_auth
+      @@no_auth
+    end
+    
+    def set_no_auth
+      @@no_auth = true
+    end
+         
+    def add_to_action_path(hash)
+      @@action_paths << hash
+    end
+    
+    def users_logged_in
+      @users_logged_in
+    end
+    
+    def init_ready
+      @ready = Array.new(Test.get_number_of_sessions)
+    end
+    
+    def ready(i)
+      @ready[i-1] = true
+    end
+    
+    def ready?
+      count = 0
+      for i in 0..@ready.size-1 do
+        if @ready[i] == true then
+          count = count + 1
+        end
+      end
+      if count == @ready.size then
+        return true
+      else 
+        return false
+      end
+    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 users_logged_in=(value)
+      @users_logged_in = value
+    end
+    
+    def set_max_number_of_session_links(no)
+      @@no_session_links = no
+    end
+    
+    def get_max_number_of_session_links
+      @@no_session_links
+    end
+    
+    
+    def write_user_input_to_file
+      f = File.new("lib/auto_test/log/user_input.log", "w")
+      if Test.no_auth then
+        f.puts("get_number_of_test_runs:#{get_number_of_test_runs}
+        get_number_of_sessions:#{get_number_of_sessions}")
+      else
+        f.puts("get_number_of_test_runs:#{get_number_of_test_runs}
+        get_login_path:#{User.get_login_path}
+        get_logout_path:#{User.get_logout_path}
+        get_login_attributes:#{User.get_login_attributes}
+        get_number_of_sessions:#{get_number_of_sessions}
+        get_login_data:#{User.get_login_data}
+        get_login_names:#{User.get_login_names}
+        get_unique_login_attribute_name:#{User.get_unique_login_attribute_name}
+        use_db_users:#{User.use_db_users}
+        user_class:#{User.user_class}")
+      end
+      f.close
+    end
+    
+  end
+  
+  class TestStarter 
+    # method to start the test and handle errors
+    def test
+      Test.write_user_input_to_file
+      for j in 1..Test.get_number_of_test_runs do
+        Test.run = j
+        if !Test.stop?
+          number_of_sessions = Test.get_number_of_sessions
+          Test.init_sessions_array
+          Test.init_sessions
+          Test.init_ready
+          for i in 0..number_of_sessions-1 do
+            sess = Capybara::Session.new(:rack_test,Rails.application)
+            Test.add_to_sessions_array sess
+            Test.init_hash_sessions(i, Hash.new)
+            Test.sessions(i,"depth", 0)
+            Test.sessions(i,"iterations", 0)
+            if !Test.no_auth then
+              user = User.get_users[rand(User.get_users.size)]
+              Test.sessions(i,"user", user) 
+              Test.add_to_action_path "#{i}:#{user.id}ID"
+              Test.sessions(i,"current_user", 0) 
+            end
+            Test.sessions(i,"ready", false) 
+            Test.sessions(i,"iteration", 0) 
+            Test.sessions(i,"current_depth", 0) 
+            Test.sessions(i,"paths", Hash.new)
+          end
+          Error.init_error
+          puts
+          Test.link_counter = 0
+          Test.users_logged_in = 1
+          if Test.no_auth then
+            Test.users_logged_in = 0
+          end
+          STDOUT.write("\r#{Test.run}. run: \t#{Test.link_counter} links clicked, \t#{Test.users_logged_in} users logged in, \t#{Error.get_error} Errors")
+          while !Test.stop? && !Test.ready? do
+            session = rand(number_of_sessions)
+            for i in 0..rand(Test.get_max_number_of_session_links) do
+              Page.run_session(session)
+            end
+          end
+        end
+      end
+      Test.check_invariants
+      if !Test.stop? then Test.users_logged_in = Test.users_logged_in + 1 end
+      f = File.new("lib/auto_test/log/paths.log", "w")
+      f.puts(Test.action_path)
+      f.close
+      puts
+      Error.print_errors
+      if Error.get_error > 0 then
+        f = File.new("lib/auto_test/log/errors.log", "w")
+        f.puts(Error.get_error)
+        f.puts(Error.get_error_messages)
+        f.close
+      end
+    end
+  end
+  
+  autoload :User,       'auto_test/lib/auto_test/user'
+  autoload :Error,      'auto_test/lib/auto_test/error'
+  
+end

data/lib/user.rb

@@ -0,0 +1,179 @@
+#require 'spec_helper'
+require 'capybara/rspec'
+
+module AutoTest
+  module User
+    module_function
+    
+    # initialize the @users array
+    def init_users
+      @users = []
+      @db_users = [false, nil]
+    end
+
+
+    def set_logout_path(path)
+      @logout = path
+    end
+    
+    def get_logout_path
+      @logout
+    end
+
+    # set the attribute_names and fields that are needed to login
+    # the argument are two arrays, the first are the database names of the attribute
+    # the second are the belonging field names
+    def set_login_attribute_names(names, fields)
+      @login_attributes = names.zip fields
+    end
+
+    # return the login attributes
+    def get_login_attributes
+      @login_attributes
+    end
+
+    # get the login path
+    def get_login_path
+      @login
+    end
+
+    # set the login path
+    def set_login_path(path)
+      @login = path
+    end
+
+   
+    def init_login_data
+      @data = []
+    end
+    
+    def get_login_data
+      @data
+    end
+    
+    def set_login_data(*data)
+      data.each do |d|
+        @data << d
+      end
+      
+    end
+
+    def get_users_from_db(user_class_name, bool)
+      @users = user_class_name.find(:all)
+      if bool then
+        @db_users = [true, user_class_name]
+      else 
+        @db_users = [false, user_class_name]
+      end
+    end
+  
+    def set_login_names(names)
+      @names = names
+    end
+    
+    def get_login_names
+      @names
+    end
+    
+    
+    def set_login_fields(fields)
+      @fields = fields
+    end
+    
+    def get_login_fields
+      @fields
+    end
+    
+    def set_unique_login_attribute_name(name)
+      @unique_login = name
+    end
+    
+    def get_unique_login_attribute_name 
+      @unique_login
+    end
+    
+    def use_db_users
+      @db_users[0]
+    end
+    
+    def user_class
+      @db_users[1]
+    end
+
+    # return the users
+    def get_users
+      if @db_users[0] then
+        @users = @db_users[1].find(:all)
+      else 
+        index = get_login_names.index(get_unique_login_attribute_name)   
+        @users = []     
+        @db_users[1].find(:all).each do |u|
+          get_login_data.each do |d|
+            if d[index] == u.send(get_unique_login_attribute_name.to_sym) then
+              @users << u
+            end
+          end
+        end
+      end
+    end
+  
+    def set_user_data(value)
+      @user_data = value
+    end
+    
+    def get_user_data
+      @user_data
+    end
+  
+  
+    def logout(session)
+      begin
+        hash = Hash.new
+        hash["#{Test.get_sessions_array.index(session)}:#{session.current_path}"] = get_logout_path
+        Test.add_to_action_path hash
+        session.visit get_logout_path
+        Page.check_for_error_code(session)
+      rescue => e
+      end
+    end
+      
+    # login a user
+    def login(user, session)
+      begin
+        session.visit get_login_path
+        user = user.class.find(user.id)
+        hash = Hash.new
+        hash["#{Test.get_sessions_array.index(session)}:#{session.current_path}"] = Page.all_submits(session).first.value
+        Test.add_to_action_path hash
+        Page.check_for_error_code(session)
+        index = get_login_names.index(get_unique_login_attribute_name)        
+        @db_users[1].find(:all).each do |u|
+          get_login_data.each do |d|
+            if d[index] == u.send(get_unique_login_attribute_name.to_sym) then
+              set_user_data(get_login_data[index])
+            end
+          end  
+        end
+        if @db_users[0] then
+          get_login_attributes.each do |field|            
+            session.fill_in field[1], :with => user.send(field[0].to_sym)
+          end
+        else
+          get_login_attributes.each_with_index do |field, i|
+            session.fill_in field[1], :with => get_user_data[i]
+          end
+        end
+        session.click_button Page.all_submits(session).first.value
+        
+        Page.check_for_error_code(session)
+      rescue (ActiveRecord::RecordNotFound)
+        Test.sessions(Test.get_sessions_array.index(session), "depth", Test.get_max_depth+1)
+        Test.sessions(Test.get_sessions_array.index(session), "current_depth", Test.get_sessions(Test.get_sessions_array.index(session), "depth"))
+      end  
+            
+    end
+  end
+  autoload :Test,       'auto_test/lib/auto_test/test' 
+  autoload :Page,       'auto_test/lib/auto_test/page'
+    
+end

metadata

@@ -2,7 +2,7 @@
 name: auto_test
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.7.4
+  version: 0.0.7.5
 platform: ruby
 authors: 
 - Maike Hargens
@@ -95,7 +95,17 @@ files:
 - Rakefile
 - auto_test.gemspec
 - lib/auto_test.rb
+- lib/auto_test/railtie.rb
 - lib/auto_test/version.rb
+- lib/dsl.rb
+- lib/error.rb
+- lib/page.rb
+- lib/simulation.rb
+- lib/spec/requests/auto_spec.rb
+- lib/spec/requests/error_reduction_spec.rb
+- lib/tasks/auto_test.task
+- lib/test.rb
+- lib/user.rb
 homepage: 
 licenses: []