automation_object 0.0.4 → 0.5.0

data/lib/automation_object/framework/window_helpers.rb

@@ -1,181 +0,0 @@
-module AutomationObject
-  module FrameworkWindowHelpers
-    def get_window_handles
-      window_handles = Array.new
-      return window_handles unless self.is_browser?
-
-      unless self.is_mobile?
-        #Window handles for Selenium are simpler
-        return self.driver_object.window_handles
-      end
-
-      #Remove everything except the WEBVIEW
-      if self.driver_object.device_is_android?
-        window_handles = self.driver_object.window_handles
-      else
-        available_contexts = self.driver_object.available_contexts
-        available_contexts.each { |context|
-          window_handles.push(context) if context.match(/^WEBVIEW_\d+$/)
-        }
-      end
-
-      return window_handles
-    end
-
-    def get_current_window_handle
-      #Selenium
-      unless self.is_mobile?
-        return self.driver_object.window_handle
-      end
-
-      #Appium
-      if self.driver_object.device_is_android?
-        return self.driver_object.window_handle
-      else
-        return self.driver_object.current_context
-      end
-    end
-
-    def switch_to_window(window_handle)
-      unless self.is_mobile?
-        #Selenium
-        return self.driver_object.switch_to.window(window_handle)
-      end
-
-      #Appium
-      if self.driver_object.device_is_android?
-        return self.driver_object.switch_to.window(window_handle)
-      else
-        return self.driver_object.set_context(window_handle)
-      end
-    end
-
-    def check_closed_windows
-      window_handles = self.get_window_handles
-
-      self.current_screen_hash.each { |current_window_handle, current_screen_symbol|
-        next if window_handles.include?(current_window_handle)
-
-        #Delete current screen hash key
-        self.current_screen_hash.delete(current_window_handle)
-        self.reset_screen(current_screen_symbol)
-        self.previous_screen_hash.delete(current_window_handle)
-
-        if current_screen_symbol == self.current_screen_class
-          self.previous_screen_class = nil
-        end
-      }
-    end
-
-    def wait_for_window_load
-      AutomationObject::Logger::add('Waiting for window to load via document.readyState')
-      loops = 0
-
-      sleep(2)
-      until self.document_complete?
-        loops += 1
-
-        if loops > 30
-          break #Fuck it for now, just see what happens if we don't wait for this
-          raise Net::ReadTimeout, 'Error waiting too long for page to load'
-        end
-
-        sleep(3)
-      end
-    end
-
-    def document_complete?
-      AutomationObject::Logger::add('Running document_complete? command')
-      return self.driver_object.execute_script('return document.readyState;') == 'complete'
-    end
-
-    def wait_for_stable_body_size
-      AutomationObject::Logger::add('Going to wait for body element size to stabilize before continuing')
-      body_element_object = self.driver_object.find_element(:css, 'body')
-
-      begin
-        current_body_size = body_element_object.size
-      rescue Selenium::WebDriver::Error::StaleElementReferenceError, Errno::ECONNREFUSED
-        body_element_object = self.driver_object.find_element(:css, 'body')
-        current_body_size = body_element_object.size
-      end
-
-      previous_width = current_body_size[:width]
-      previous_height = current_body_size[:height]
-
-      sleep(2)
-
-      30.times do
-        sizes_string = "before: #{current_body_size[:width]}x#{current_body_size[:height]}"
-
-        begin
-          current_body_size = body_element_object.size
-        rescue Selenium::WebDriver::Error::StaleElementReferenceError, Errno::ECONNREFUSED
-          body_element_object = self.driver_object.find_element(:css, 'body')
-          current_body_size = body_element_object.size
-        end
-
-        if previous_width == current_body_size[:width] and previous_height == current_body_size[:height]
-          break
-        end
-
-        sizes_string << ", after: #{current_body_size[:width]}x#{current_body_size[:height]}"
-        AutomationObject::Logger::add("Running another loop for body size stabilization. #{sizes_string}")
-
-        previous_width = current_body_size[:width]
-        previous_height = current_body_size[:height]
-
-        sleep(2)
-      end
-    end
-
-    def set_window_size(x, y)
-      self.driver_object.manage.window.resize_to(x, y)
-    end
-
-    def close_window(screen_name, skip_close = false)
-      AutomationObject::Logger::add("Attempting to close window for screen #{screen_name}")
-
-      screen_class_symbol = self.translate_string_to_class(screen_name)
-      remove_current_handle = nil
-
-      self.current_screen_hash.each { |window_handle, current_screen_symbol|
-        next if current_screen_symbol != screen_class_symbol
-        remove_current_handle = window_handle
-
-        #Kill the thread
-        self.screen_monitor_thread.each { |key, thread|
-          next unless key == screen_class_symbol
-          break unless thread.class == Thread
-          Thread.kill(thread)
-
-          AutomationObject::Logger::add("Killed any threads belonging to window for screen #{screen_name}")
-          break
-        }
-
-        self.screen_monitor_thread[current_screen_symbol] = nil
-
-        #Close the window if needed
-        if skip_close == false
-          self.switch_to_window(window_handle)
-          self.driver_object.close
-        end
-
-        break
-      }
-
-      if remove_current_handle
-        self.current_screen_hash.delete(remove_current_handle)
-        self.screen_history_hash.delete(remove_current_handle)
-      end
-
-      self.current_screen_hash.each { |window_handle, current_screen_symbol|
-        self.switch_to_window(window_handle)
-        self.current_screen_class = current_screen_symbol
-        break
-      }
-
-      self.send(screen_class_symbol).reset_screen
-    end
-  end
-end

data/lib/automation_object/hash.rb

@@ -1,6 +0,0 @@
-class ::Hash
-  def deep_merge(second)
-    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-    self.merge(second, &merger)
-  end
-end

data/lib/automation_object/hook_helpers.rb

@@ -1,27 +0,0 @@
-module AutomationObject
-  module HookHelpers
-    def do_hook_action(action, timing, created_window_handle = false)
-      self.before_mutex_lock if action == 'before'
-
-      #Return out if it doesn't meet the given requirements
-      return unless self.configuration.class == Hash
-      return unless self.configuration[action].class == Hash
-      return unless self.configuration[action][timing].class == Hash
-
-      hook_configuration = self.configuration[action][timing].clone
-      self.hook(hook_configuration, created_window_handle)
-
-      self.after_mutex_lock if action == 'after'
-    end
-
-    def before_mutex_lock
-      return unless Thread.current == Thread.main
-      self.framework_object.screen_monitor_mutex_object.lock
-    end
-
-    def after_mutex_lock
-      return unless Thread.current == Thread.main
-      self.framework_object.screen_monitor_mutex_object.unlock
-    end
-  end
-end

data/lib/automation_object/logger.rb

@@ -1,179 +0,0 @@
-module AutomationObject
-  class Logger
-    @@log = Array.new
-
-    @@output_message_caller_locations = false
-    @@output_driver_caller_locations = false
-    @@output_driver_element_caller_locations = false
-
-    def self.output_message_caller_locations
-      @@output_message_caller_locations
-    end
-
-    def self.output_message_caller_locations=(value)
-      @@output_message_caller_locations = value
-    end
-
-    def self.output_driver_caller_locations
-      @@output_driver_caller_locations
-    end
-
-    def self.output_driver_caller_locations=(value)
-      @@output_driver_caller_locations = value
-    end
-
-    def self.output_driver_element_caller_locations
-      @@output_driver_element_caller_locations
-    end
-
-    def self.output_driver_element_caller_locations=(value)
-      @@output_driver_element_caller_locations = value
-    end
-
-    def self.add(message, location = false)
-      called_locations = caller_locations
-      parsed_message = self::parse_message(message, called_locations, location)
-
-      @@log.push(parsed_message)
-
-      if AutomationObject::debug_mode
-        self::output_message(parsed_message)
-      end
-    end
-
-    def self.add_driver_message(total_time_taken, called_locations, method_symbol, *arguments, &block)
-      parsed_message = self::parse_driver_message(total_time_taken, called_locations, method_symbol, *arguments, &block)
-
-      @@log.push(parsed_message)
-
-      if AutomationObject::debug_mode
-        self::output_driver_message(parsed_message)
-      end
-    end
-
-    def self.add_driver_element_message(total_time_taken, called_locations, method_symbol, *arguments, &block)
-      parsed_message = self::parse_driver_element_message(total_time_taken, called_locations, method_symbol, *arguments, &block)
-
-      @@log.push(parsed_message)
-
-      if AutomationObject::debug_mode
-        self::output_driver_element_message(parsed_message)
-      end
-    end
-
-    def self.get_thread_message
-      return (Thread.main == Thread.current) ? 'main '.colorize(:black) : 'secondary '.colorize(:light_black)
-    end
-
-    def self.parse_message(message, called_locations, location)
-      parsed_message = Hash.new
-      parsed_message[:message] = message.to_s
-      parsed_message[:called_locations] = called_locations
-
-      #Add which thread this is under
-      parsed_message[:thread_name] = self::get_thread_message
-
-      parsed_message[:location] = 'framework_object'
-      return parsed_message unless location.is_a?(Array)
-
-      parsed_message[:location] << '.'
-      location.each { |part|
-        parsed_message[:location] << part.to_s + '.'
-      }
-      parsed_message[:location].gsub!(/\.$/, '')
-
-      return parsed_message
-    end
-
-    def self.parse_driver_message(total_time_taken, called_locations, method_symbol, *arguments, &block)
-      parsed_message = Hash.new
-      parsed_message[:driver_message] = true
-
-      #Add which thread this is under
-      parsed_message[:thread_name] = self::get_thread_message
-
-      parsed_message[:total_time_taken] = total_time_taken.round(4)
-      parsed_message[:method_called] = method_symbol.to_s
-      parsed_message[:called_locations] = called_locations
-
-      parsed_message[:arguments] = arguments.to_s
-      parsed_message[:arguments] = parsed_message[:arguments].to_s
-      return parsed_message
-    end
-
-    def self.parse_driver_element_message(total_time_taken, called_locations, method_symbol, *arguments, &block)
-      parsed_message = Hash.new
-      parsed_message[:driver_element_message] = true
-
-      #Add which thread this is under
-      parsed_message[:thread_name] = self::get_thread_message
-
-      parsed_message[:total_time_taken] = total_time_taken.round(4)
-      parsed_message[:method_called] = method_symbol.to_s
-      parsed_message[:called_locations] = called_locations
-      parsed_message[:arguments] = arguments.to_s
-
-      return parsed_message
-    end
-
-    def self.format_object_name(object_name)
-      return false unless object_name
-
-      return object_name.to_s.gsub(/_class$/, '')
-    end
-
-    def self.output_messages
-      @@log.each { |parsed_message|
-        self::output_message(parsed_message)
-      }
-    end
-
-    def self.output_message(parsed_message)
-      return self::output_driver_message(parsed_message) if parsed_message[:driver_message]
-      return self::output_driver_element_message(parsed_message) if parsed_message[:driver_element_message]
-
-      output_string = 'debug: '.colorize(:black)
-      output_string << "thread: ".colorize(:cyan)
-      output_string << parsed_message[:thread_name]
-      output_string << "location: ".colorize(:cyan)
-      output_string << "#{parsed_message[:location]} "
-      output_string << "message: ".colorize(:cyan)
-      output_string << "#{parsed_message[:message]} "
-
-      Kernel.puts output_string #Just in case you're running under Cucumber
-      if self.output_message_caller_locations
-        Kernel.ap parsed_message[:called_locations] if parsed_message[:called_locations]
-      end
-    end
-
-    def self.output_driver_message(parsed_message)
-      output_string = "driver call (#{parsed_message[:total_time_taken]} S): ".colorize(:light_black)
-      output_string << "thread: ".colorize(:cyan)
-      output_string << parsed_message[:thread_name]
-      output_string << "method: ".colorize(:cyan)
-      output_string << "#{parsed_message[:method_called]} "
-      output_string << "args: ".colorize(:cyan)
-      output_string << "#{parsed_message[:arguments]} "
-
-      Kernel.puts output_string #Just in case you're running under Cucumber
-      if self.output_driver_caller_locations
-        Kernel.ap parsed_message[:called_locations] if parsed_message[:called_locations]
-      end
-    end
-
-    def self.output_driver_element_message(parsed_message)
-      output_string = "driver element call (#{parsed_message[:total_time_taken]} S): ".colorize(:light_black)
-      output_string << "thread: ".colorize(:cyan)
-      output_string << parsed_message[:thread_name]
-      output_string << "method: ".colorize(:cyan)
-      output_string << "#{parsed_message[:method_called]} "
-      output_string << "args: ".colorize(:cyan)
-      output_string << "#{parsed_message[:arguments]} "
-
-      Kernel.puts output_string #Just in case you're running under Cucumber
-      if self.output_driver_element_caller_locations
-        Kernel.ap parsed_message[:called_locations] if parsed_message[:called_locations]
-      end
-    end
-  end
-end

data/lib/automation_object/object.rb

@@ -1,22 +0,0 @@
-class ::Object
-  def translate_string_to_class(name)
-    name_string = name.to_s.gsub('=', '')
-
-    if name_string.match(/_class$/)
-      class_string = name_string
-    else
-      class_string = name_string + '_class'
-    end
-
-    class_string.to_sym
-  end
-
-  def translate_class_to_string(class_symbol)
-    class_symbol.to_s.gsub(/_class$/, '')
-  end
-
-  def translate_class_to_symbol(class_symbol)
-    class_string = class_symbol.to_s.gsub(/_class$/, '')
-    return class_string.to_sym
-  end
-end

data/lib/automation_object/screen/modal.rb

@@ -1,8 +0,0 @@
-module AutomationObject
-  class Modal < Screen
-    def initialize(modal_name, params)
-      super(params)
-      self.framework_location = self.framework_location + ".#{modal_name}"
-    end
-  end
-end

data/lib/automation_object/screen/screen.rb

@@ -1,209 +0,0 @@
-module AutomationObject
-  class Screen
-    include EventEmitter
-
-    include AutomationObject::ScreenWindowHelpers
-    include AutomationObject::ScreenHookHelpers
-    include AutomationObject::ScreenPromptHelpers
-    include AutomationObject::ScreenModalHelpers
-
-    attr_accessor :framework_object, :driver_object,
-                  :configuration,
-                  :framework_location,
-                  :screen_name,
-                  :active_modal,
-                  :added_elements,
-                  :element_storage,
-                  :window_handle
-
-    def initialize(params)
-      self.added_elements = Array.new
-      self.element_storage = Hash.new
-      self.window_handle = nil
-
-      #Set params to properties
-      self.framework_object = params[:framework_object] || raise(ArgumentError, 'framework_object is required in params')
-      self.driver_object = params[:driver_object] || raise(ArgumentError, 'driver_object is required in params')
-      #Clone configuration, this will allow edit/deletes on different levels
-      params[:blue_prints] = Hash.new unless params[:blue_prints].class == Hash #Allow empty screen configs
-      self.configuration = params[:blue_prints].clone || raise(ArgumentError, 'configuration is required in params')
-
-      self.screen_name = params[:screen_name] || raise(ArgumentError, 'screen_name is required in params')
-
-      #Validate properties
-      raise ArgumentError, 'framework_object should be an Framework Object' unless self.framework_object.is_a? Framework
-      raise ArgumentError, 'configuration should be a Hash Object' unless self.configuration.is_a? Hash
-      raise ArgumentError, 'screen_name should be a String Object' unless self.screen_name.is_a? String
-
-      #Framework Location for Debugging
-      self.framework_location = self.screen_name
-
-      #Add Modals
-      self.add_modals(params, self.configuration['modals']) if self.configuration['modals'].is_a?(Hash)
-
-      #Add ElementGroups
-      self.add_element_groups(self.configuration['element_groups']) if self.configuration['element_groups'].is_a?(Hash)
-
-      #Add Elements
-      self.add_elements(self.configuration['elements']) if self.configuration['elements'].is_a?(Hash)
-    end
-
-    def respond_to?(method_symbol, include_private = false)
-      #Translate method in possible internal storage attribute
-      class_symbol = self.translate_string_to_class(method_symbol)
-      instance_symbol = class_symbol.to_s.gsub(/^@/, '')
-      instance_symbol = "@#{instance_symbol}".to_sym
-
-      self.instance_variables.each { |instance_variable|
-        return true if instance_variable == instance_symbol
-      }
-
-      #If not then do the super on the method_symbol
-      super.respond_to?(method_symbol, include_private)
-    end
-
-    def respond_to_element?(method_symbol, include_private = false)
-      element_symbol = self.translate_string_to_class(method_symbol)
-      instance_symbol = element_symbol.to_s.gsub(/^@/, '')
-      instance_symbol = "@#{instance_symbol}".to_sym
-
-      self.instance_variables.each { |instance_variable|
-        if instance_variable == instance_symbol
-          method_class = self.send(element_symbol).class
-          return ([Element, ElementHash, ElementArray, ElementGroup].include?(method_class))
-        end
-      }
-
-      return false
-    end
-
-    def method_missing(method_requested, *args, &block)
-      class_symbol = self.translate_string_to_class(method_requested)
-
-      unless self.respond_to?(class_symbol)
-        raise "Element or Modal (#{method_requested}) is not defined in screen object (#{self.screen_name})"
-      end
-
-      if self.window_in_iframe? and self.respond_to_element?(method_requested)
-        unless self.element_in_current_iframe?(method_requested)
-          self.switch_to_default_content
-        end
-      else
-        self.switch_to_default_content
-      end
-
-      #Preload elements for ElementHash/ElementArray
-      if self.send(class_symbol).class == ElementHash or self.send(class_symbol).class == ElementArray or self.send(class_symbol).class == ElementGroup
-        self.send(class_symbol).load_elements unless self.send(class_symbol).elements_loaded
-      end
-
-      #Load modal if needed
-      if self.send(class_symbol).class == Modal
-        #Skip opening the modal again if it's active
-        return self.send(class_symbol, *args, &block) if self.active_modal == class_symbol
-
-        #Try to make the modal active
-        self.route_to_modal(method_requested)
-      end
-
-      self.send(class_symbol, *args, &block)
-    end
-
-    def add_element_groups(configuration)
-      return unless configuration.is_a?(Hash)
-
-      configuration.each { |group_name, group_configuration|
-        group_class_name = self.translate_string_to_class(group_name)
-
-        setter = "#{group_class_name}="
-        self.class.send(:attr_accessor, group_class_name) unless self.respond_to?(setter)
-
-        group_object_options = {
-            :framework_object => self.framework_object,
-            :screen_object => self,
-            :driver_object => self.driver_object,
-            :blue_prints => group_configuration,
-            :screen_name => self.screen_name,
-            :element_name => group_name
-        }
-
-        send setter, AutomationObject::ElementGroup.new(group_object_options)
-
-        this = self
-        self.send(group_class_name).on :hook do |args|
-          this.hook_listener(args)
-        end
-      }
-    end
-
-    def add_elements(configuration)
-      return unless configuration.is_a?(Hash)
-
-      configuration.each { |element_name, element_configuration|
-        element_class_name = self.translate_string_to_class(element_name)
-
-        setter = "#{element_class_name}="
-        self.class.send(:attr_accessor, element_class_name) unless self.respond_to?(setter)
-
-        element_object_options = {
-            :framework_object => self.framework_object,
-            :screen_object => self,
-            :driver_object => self.driver_object,
-            :blue_prints => element_configuration,
-            :screen_name => self.screen_name,
-            :element_name => element_name
-        }
-
-        if element_configuration['multiple'] #Use element hash class for multiples
-          if element_configuration['define_elements_by']
-            send setter, AutomationObject::ElementHash.new(element_object_options)
-          else
-            send setter, AutomationObject::ElementArray.new(element_object_options)
-          end
-        else
-          send setter, AutomationObject::Element.new(element_object_options)
-        end
-
-        this = self
-        self.send(element_class_name).on :hook do |args|
-          this.hook_listener(args)
-        end
-
-        self.added_elements.push(element_class_name)
-      }
-    end
-
-    def reset_screen(skip_window_handle = false)
-      AutomationObject::Logger::add('Resetting screen', [self.framework_location])
-
-      self.switch_to_default_content
-
-      #Reset elements
-      self.added_elements.each { |added_element|
-        class_name = self.send(added_element).class.name
-        case class_name
-          when 'AutomationObject::ElementArray', 'AutomationObject::ElementHash', 'AutomationObject::ElementGroup'
-            self.send(added_element).reset_elements
-          when 'AutomationObject::Element'
-            self.send(added_element).reset_element
-        end
-      }
-
-      #Set active modal to nil
-      self.active_modal = nil
-      self.window_handle = nil unless skip_window_handle
-    end
-
-    def get_element_object(element_name)
-      unless self.respond_to?(element_name)
-        raise ArgumentError, "Element (#{element_name}) is not defined in the screen (#{self.screen_name})"
-      end
-
-      unless self.respond_to_element?(element_name)
-        raise ArgumentError, "Expected an element for iframe (#{element_name}) defined in screen (#{self.screen_name})"
-      end
-
-      return self.send(element_name)
-    end
-  end
-end