auto_test 0.0.7.4 → 0.0.7.5

data/lib/auto_test/railtie.rb

@@ -0,0 +1,9 @@
+require 'auto_test'
+require 'rails'
+module AutoTest
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'tasks/auto_test.task'
+    end
+  end
+end

data/lib/auto_test/version.rb

@@ -1,3 +1,3 @@
 module AutoTest
-  VERSION = "0.0.7.4"
+  VERSION = "0.0.7.5"
 end

data/lib/auto_test.rb

@@ -1,5 +1,4 @@
 require "auto_test/version"
-require "auto_test/railtie" if defined?(Rails)
 
 def logger 
   Rails.logger
@@ -7,6 +6,7 @@ end
 
 
 module AutoTest
+    require "lib/auto_test/railtie" if defined?(Rails)
     
     class << self
        attr_accessor :configuration

data/lib/dsl.rb

@@ -0,0 +1,91 @@
+#require 'spec_helper'
+require 'capybara/rspec'
+
+module AutoTest
+  module Dsl
+    module_function
+    
+    # set the links, that aren´t supposed to be clicked
+    # @*links List of two-element-arrays, first value link-text, second value link href
+    def links_to_exclude(*links)
+      Test.links_to_exclude(*links)
+    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)
+      Test.always_present(class_name, key, value)
+    end
+    
+    #set the maximal depth to which the links are clicked
+    def set_max_depth(value)
+      Test.set_max_depth(value)
+    end
+    
+    def set_unique_login_attribute_name(name)
+      User.set_unique_login_attribute_name(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)
+      Test.set_input(input, *values)
+    end
+    
+    # give data for logins, e.g. if the password for users is saved as salt and hash in
+    # the database
+    # the data has to be created in the test_seeds.rb file
+    def set_login_data(*data)
+      User.set_login_data(*data)
+    end
+    
+    def get_users_from_db(user_class_name, bool)
+      User.get_users_from_db(user_class_name, bool)
+    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)
+      Test.set_object_dependency(child, parent, attribute_name)
+    end
+    
+    def set_number_of_sessions(number)
+      Test.set_number_of_sessions(number)
+    end
+    
+    def set_max_number_of_session_links(no)
+      Test.set_max_number_of_session_links(no)
+    end
+
+
+    def set_no_auth
+      Test.set_no_auth
+    end
+    
+    # set the login path
+    def set_login_path(path)
+      User.set_login_path(path)
+    end
+    
+    # set the attribute_names and fields that are needed to login
+    # the argument is a list of pairs [attribute_name, field]
+    def set_login_attribute_names(names, fields)
+      User.set_login_attribute_names(names, fields)
+      User.set_login_fields(fields)
+      User.set_login_names(names)
+    end
+    
+    def set_logout_path(path)
+      User.set_logout_path(path)
+    end
+    
+    def stop_at_first_error(stop_at_first_error) 
+      Test.stop_at_first_error(stop_at_first_error) 
+    end
+    
+    def set_number_of_test_runs(number)
+      Test.set_number_of_test_runs(number)
+    end
+    
+  end
+  autoload :Test,       'auto_test/lib/auto_test/test'
+end

data/lib/error.rb

@@ -0,0 +1,53 @@
+#require 'spec_helper'
+require 'capybara/rspec'
+
+module AutoTest
+  module Error
+    module_function
+    # increment the errorcount in the first field of the array, 
+    # add error messages 
+    def inc_error(value)
+      if !get_error_messages.include? value then
+        @error[0] = @error[0] + 1
+        @error << value
+        if Test.stop_at_first_error? then
+          Test.stop!
+        end
+      end
+    end
+    
+    def print_errors
+      if get_error > 0 then
+        if get_error == 1 then
+          puts "There was 1 Error in this test:"
+          get_error_messages.each do |m|
+            puts m
+          end
+        else
+          puts "There were " + get_error.to_s + " Errors in this test:"
+          get_error_messages.each do |m|
+            puts m
+          end      
+        end
+      else
+        puts "There were no errors in this test"
+      end
+    end
+    
+    def get_error
+      @error[0]
+    end
+
+    def get_error_messages
+      @error[1..@error.size-1]
+    end
+    
+    def init_error
+      @error = [0]
+    end
+    
+  end
+  
+  autoload :Test,       'auto_test/lib/auto_test/test'
+  
+end

data/lib/page.rb

@@ -0,0 +1,269 @@
+# encoding: utf-8
+
+#require 'spec_helper'
+
+require 'capybara/rspec'
+
+class Time
+  def self.random
+    year = Time.now.year
+    month = rand(12) + 1
+    day = (rand * 28).ceil
+    Time.local(year, month, day)
+  end
+end
+
+module AutoTest
+  module Page    
+    module_function
+
+    # click a link in a certain session
+    def run_session(i)
+      session = Test.get_sessions_array[i]
+      if !Test.stop? then  
+        if Test.no_auth || Test.get_sessions(i,"current_user") <= User.get_users.size then
+          if Test.get_sessions(i,"depth") <= Test.get_max_depth then
+            if Test.get_sessions(i,"iteration") <= Test.get_sessions(i,"iterations") then
+              begin
+                if Test.get_sessions(i, "current_depth") == 0 && !Test.no_auth then 
+                  User.login(Test.get_sessions(i,"user"),session)  
+                  Test.check_invariants
+                end
+                if Test.no_auth then
+                  session.visit "/"
+                end
+                if (Test.get_sessions(i,"current_depth") < Test.get_sessions(i,"depth")) then
+                  links = all_links(session)
+                  handle_excluded_links(links)
+                  if !links.empty? then
+                    Test.check_invariants
+                    path = session.current_path
+                    paths = Test.get_sessions(i,"paths")
+                    paths[path] = links.size
+                    Test.sessions(i, "paths", paths)
+                    random_link = links[rand(links.size)]
+                    if random_link[:href] != "#" then
+                      hash = Hash.new
+                      hash["#{i}:#{path}"] = random_link[:href]+"+++"+random_link.text
+                      Test.add_to_action_path hash
+                    end
+                    random_link.click
+                    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")
+                    Test.link_counter = Test.link_counter + 1
+                    Test.check_invariants
+                    handle_forms(session)
+                    Test.check_invariants
+                    Test.sessions(i, "current_depth", Test.get_sessions(i, "current_depth") + 1)
+                  end
+                else
+                  links = all_links(session)
+                  handle_excluded_links(links)
+                  if !links.empty? then 
+                    Test.sessions(i,"iterations", 0)
+                    Test.get_sessions(i,"paths").each do |key, value|
+                      Test.sessions(i,"iterations", Test.get_sessions(i, "iterations") + value)
+                    end
+                  end
+                  if !Test.no_auth then
+                    User.logout(session)
+                  end
+                  Test.sessions(i, "current_depth", 0)
+                  Test.sessions(i, "paths", Hash.new)
+                  Test.sessions(i, "iteration", Test.get_sessions(i, "iteration") + 1)
+                end
+              rescue => e                
+                if Test.stop_at_first_error? then Test.stop! end
+                message = e.message.to_s + "   :" + e.backtrace.first.to_s
+                Error.inc_error message
+              end                                       
+            else
+              Test.sessions(i, "iteration", 0)
+              Test.sessions(i, "iterations", 0)
+              Test.sessions(i, "depth", Test.get_sessions(i, "depth") + 1)
+              Test.sessions(i, "paths", Hash.new)
+            end           
+          else
+            if !Test.stop? && !Test.no_auth then
+              Test.users_logged_in = Test.users_logged_in + 1
+            end
+            if !Test.no_auth then
+              Test.sessions(i, "current_user", Test.get_sessions(i,"current_user")+1)
+              user = User.get_users[rand(User.get_users.size)]
+              Test.sessions(i, "user", user)
+              Test.add_to_action_path "#{i}:#{user.id}ID"
+            end
+            if Test.no_auth then
+              Test.ready(i)
+            end
+            Test.sessions(i, "depth", 0)
+            Test.sessions(i, "iterations", 0)
+          end
+        else
+          Test.ready(i)
+        end
+      end
+    end
+    
+
+
+    # fill in all inputs of type email, text or radio
+    # assuming there´s only one submit button on the page
+    # later maybe decide on random button
+    def fill_in_forms(session)
+      inputs = all_inputs(session)
+      button = all_submits(session)[rand(all_submits(session).size)]
+      selects = all_selects(session)
+      texts = []
+      selects.each do |s|
+        select_option(s[:id], texts, session)
+      end  
+      inputs.each do |i|
+        case i[:type]
+          when "email" then 
+            text = Faker::Internet.email
+            texts << i[:name]
+            texts << text
+            session.fill_in i[:id], :with => text
+          when "text" then
+            if i[:class] == "datePicker" then
+              text = Time.random.to_date
+              session.fill_in i[:id], :with => text
+              texts << i[:name]
+              texts << text.to_s
+            else
+              text = Faker::Name.name
+              session.fill_in i[:id], :with => text
+              texts << i[:name]
+              texts << text
+            end
+          when "radio" then
+            choose_radio(i[:name], texts, session)
+          when "checkbox" then  
+            choose_checkbox(i[:name], texts, session)
+          when "number" then
+            text = rand(100)
+            session.fill_in i[:id], :with => text
+            texts << i[:name]
+            texts << text.to_s
+        end
+        text = ""
+      end  
+      inputs_to_set = Test.get_inputs
+      if !inputs_to_set.empty? then
+        inputs.each do |i|
+          if inputs_to_set[i[:id]] != nil then
+            text = inputs_to_set[i[:id]][rand(inputs_to_set[i[:id]].size)]
+            session.fill_in i[:id], :with => text
+            texts << i[:name]
+            texts << text.to_s
+          end
+        end
+      end
+      hash = Hash.new
+      hash["#{Test.get_sessions_array.index(session)}:#{session.current_path}"] = texts
+      Test.add_to_action_path hash
+      session.click_button button.value
+      Test.link_counter = Test.link_counter + 1
+      
+      check_for_error_code(session)
+    end
+
+    # check for input fields and fill in the forms
+    # randomly decide, if inputs are filled in or links are clicked
+    def handle_forms(session)
+      if !all_submits(session).empty? then
+        if rand(2) == 1 then    
+          fill_in_forms(session)
+        end
+      end
+    end
+
+    # choose a random radiobutton
+    def choose_radio(name, input_texts, session)
+      radios = session.all('input').find_all{ |i|  i[:type] == "radio" && i[:name] == name}
+      choices = radios.collect{ |r| r[:value] }
+      i = rand(choices.length)
+      input_texts << "radio___" + name
+      input_texts << choices[i].to_s
+      session.choose choices[i]
+    end
+    
+    # choose a random checkbox
+    def choose_checkbox(name, input_texts, session)
+      checkboxes = session.all('input').find_all{ |i| i[:type] == "checkbox" && i[:name] == name  }
+      choices = checkboxes.collect{ |r| r[:value] }
+      i = rand(choices.length)
+      input_texts << "checkbox___" + name
+      input_texts << choices[i].to_s
+      session.check choices[i]
+    end
+
+    # select a random option from a select list
+    def select_option(id, input_texts, session)
+      options = session.find_by_id(id).all('option').collect{ |o| o.value }
+      i = rand(options.size)
+      input_texts << "select___"+id
+      input_texts << options[i].to_s
+      session.select options[i], :from => id
+    end
+
+    # if an alert pops up, randomly decide whether to accept or dismiss it
+    def handle_alert(session)
+      begin 
+        if rand(2) == 1 then
+          session.page.driver.browser.switch_to.alert.accept
+        else
+          session.page.driver.browser.switch_to.alert.dismiss
+        end
+      rescue
+      end
+    end
+
+    # check, if the page includes an html error code
+    # if present, add the error and print the message
+    def check_for_error_code(session)
+      if session.status_code >= 400 then
+        message = "ERROR : Response : #{page.status_code}"
+        Error.inc_error(message)
+        puts message
+      end
+    end
+    
+    # get all links on the current page
+    def all_links(session)
+      session.all('a')
+    end
+
+    # get all input forms
+    def all_inputs(session)
+      session.all('input')
+    end
+
+    # get all select-fields
+    def all_selects(session)
+      session.all('select')
+    end
+
+    # get all submit buttons
+    def all_submits(session)
+      session.all('input').find_all{ |i|  i[:type] == "submit"}  
+    end
+    
+    # delete the links, not to be clicked
+    def handle_excluded_links(links)
+      Test.get_links_to_exclude.each do |link|
+        links.delete(links.find{ |l| l.text == link[0] && l[:href] == link[1]})
+      end
+    end
+
+    # go back one page
+    def go_back
+       redirect_to :back
+    end
+    
+  end
+  
+   autoload :Test,       'auto_test/lib/auto_test/test'
+   autoload :User,       'auto_test/lib/auto_test/user'
+   autoload :Error,      'auto_test/lib/auto_test/error'
+end

data/lib/simulation.rb

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path("../../../../../config/environment", __FILE__)  
+require "watir-webdriver"
+
+def login(login_attributes, browser, user)
+  if user_inputs("use_db_users") then
+    user_inputs("get_login_attributes").each do |field|
+      browser.text_field(:label => field[1]).set user.send(field[0].to_sym) 
+    end
+    sleep 1
+  else
+    index = user_inputs("get_login_names").index(user_inputs("get_unique_login_attribute_name"))        
+    user.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|
+      browser.text_field(:label => field[1]).set user_data[i]
+    end
+  end              
+  sleep 2
+  browser.button(:type => 'submit').click
+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 get_sessions_array
+  @sessions_array
+end
+
+def init_sessions_array 
+  @sessions_array = []
+end
+
+def add_to_sessions_array(i,session)
+  @sessions_array[i] = session
+end
+
+def path
+  @path
+end
+
+def init_path
+  @path = []
+end
+
+def add_path(value)
+  @path << value
+end
+
+def search_sessions
+  path_to_search = File.new("lib/auto_test/log/new_path.log")
+  sessions = Array.new
+  while line = path_to_search.gets do
+    line.gsub!(/[{}\"]/,'')
+    if line.class == String then
+      session = line.split(":").first.to_i
+    else
+      session = line.gsub!(/[{}\"]/,'').split(":").first.to_i
+    end  
+    if !(sessions.include? session) then
+      sessions << session
+    end
+  end
+  return sessions
+end
+
+
+load "#{Rails.root}/db/test_seeds.rb"
+init_path
+init_sessions_array
+init_user_inputs
+puts "Firefox is getting started..."
+paths = File.new("lib/auto_test/log/new_path.log")
+home = "localhost:3002"
+sessions = search_sessions
+number_of_sessions = sessions.size
+user = Array.new(user_inputs("get_number_of_sessions").to_i)
+for i in 0..number_of_sessions-1 do
+  browser = Watir::Browser.new :ff
+  add_to_sessions_array(sessions[i], browser)
+end
+while line = paths.gets do
+  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)
+    session.windows.first.use
+    if a[0].split(":").second == user_inputs("get_login_path") then
+      session.goto home + user_inputs("get_login_path")
+      hash["#{a[0]}"] = a[1]
+      login(user_inputs("get_login_attributes"), session, user[session_index].class.find(user[session_index].id))
+    elsif a[1] == user_inputs("get_logout_path") then
+      hash["#{a[0]}"] = user_inputs("get_logout_path")
+      session.goto home + 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.radio(:name => inputs[i].gsub("radio___",'').strip,:value=> inputs[i + 1].strip).set
+        elsif inputs[i].strip.start_with? "select___" then
+          session.select_list(:id => inputs[i].gsub("select___",'').strip).select(inputs[i + 1].strip)
+        elsif inputs[i].strip.start_with? "checkbox___" then
+          session.checkbox(:name => inputs[i].gsub("checkbox___",'').strip, :value => inputs[i + 1].strip).set
+        else
+          session.text_field(:name => inputs[i].strip).flash
+          session.text_field(:name => inputs[i].strip).set inputs[i+1].strip
+        end
+        i = i + 2
+      end
+      hash["#{a[0]}"] = texts
+      session.button(:type => "submit").click
+    else
+      link = a[1].split(/\+\+\+/)
+      href = link[0]
+      text = link[1]
+      session.a(:href => href, :text => text).flash
+      session.a(:href => href, :text => text).click
+      begin
+        session.driver.switch_to.alert.accept
+      rescue
+      end
+      hash["#{a[0]}"] = a[1]
+    end
+    add_path(hash)
+    sleep 2
+  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

data/lib/spec/requests/auto_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+# has to be run independently from other tests, 
+# run without cleaning the db between single tests
+# see spec_helper for db-cleaner
+require 'spec_helper'
+require 'auto_test/lib/auto_test'
+
+
+describe "Application" do
+  
+  describe "auto_test" do
+    it "does test the application automatically" do
+      load "#{Rails.root}/db/test_seeds.rb"
+      t = AutoTest::TestStarter.new
+      t.test      
+    end
+  end
+
+end
+