automation_object 0.0.4

data/lib/automation_object/element/element_cell.rb

@@ -0,0 +1,126 @@
+module AutomationObject
+  class ElementCell
+    include EventEmitter
+
+    attr_accessor :framework_object, :screen_object, :driver_object, :configuration, :screen_name, :element_name,
+                  :sub_elements, :element_object
+
+    def initialize(params)
+      #Set params to properties
+      self.framework_object = params[:framework_object] || raise(ArgumentError, 'framework_object is required in params')
+      self.screen_object = params[:screen_object] || raise(ArgumentError, 'screen_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
+      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')
+      self.element_name = params[:element_name] || raise(ArgumentError, 'element_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, 'screen_object should be an Screen Object' unless self.screen_object.is_a? Screen
+      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
+      raise ArgumentError, 'element_name should be a String Object' unless self.element_name.is_a? String
+
+      self.sub_elements = Array.new
+
+      #Add Sub-Elements
+      return unless self.configuration['sub_elements'].is_a?(Hash)
+
+      self.configuration['sub_elements'].each { |sub_element_name, sub_element_configuration|
+        next unless sub_element_configuration.is_a?(Hash)
+        modified_element_configuration = self.combine_selector_path(self.configuration, sub_element_configuration)
+
+        element_class_name = self.translate_string_to_class(sub_element_name)
+        setter = "#{element_class_name}="
+        self.class.send(:attr_accessor, element_class_name) unless self.respond_to?(setter)
+
+        sub_element_object_options = {
+            :framework_object => self.framework_object,
+            :screen_object => self.screen_object,
+            :driver_object => self.driver_object,
+            :blue_prints => modified_element_configuration,
+            :screen_name => self.screen_name,
+            :element_name => element_name
+        }
+
+        send setter, AutomationObject::Element.new(sub_element_object_options)
+
+        this = self
+        self.send(element_class_name).on :hook do |args|
+          this.emit :hook, args
+        end
+
+        self.sub_elements.push(sub_element_name)
+      }
+
+      #Add Element Object
+      sub_element_object_options = {
+          :framework_object => self.framework_object,
+          :screen_object => self.screen_object,
+          :driver_object => self.driver_object,
+          :blue_prints => self.configuration,
+          :screen_name => self.screen_name,
+          :element_name => self.element_name,
+          :element_object => params[:element_object]
+      }
+
+      self.element_object = AutomationObject::Element.new(sub_element_object_options)
+      this = self
+      self.element_object.on :hook do |args|
+        this.emit :hook, args
+      end
+    end
+
+    def combine_selector_path(cell_configuration, sub_element_configuration)
+      modified_configuration = sub_element_configuration.clone
+      if cell_configuration['xpath']
+        sub_element_configuration.has_key?('xpath').should == true
+        modified_configuration['xpath'] = cell_configuration['xpath'] + sub_element_configuration['xpath']
+      elsif cell_configuration['css']
+        sub_element_configuration.has_key?('css').should == true
+        modified_configuration['css'] = cell_configuration['css'] + ' ' + sub_element_configuration['css']
+      else
+        raise 'Expecting either css or xpath for selector in element cell configuration'
+      end
+
+      return modified_configuration
+    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
+      return true if super.respond_to?(method_symbol, include_private)
+
+      #If not try element object
+      return self.element_object.respond_to?(method_symbol, include_private)
+    end
+
+    def element_respond_to?(method_symbol, include_private = false)
+      return self.element_object.respond_to?(method_symbol, include_private)
+    end
+
+    def method_missing(method_requested, *args, &block)
+      class_symbol = self.translate_string_to_class(method_requested)
+
+      if self.element_respond_to?(method_requested)
+        return self.element_object.send(method_requested, *args, &block)
+      end
+
+      if self.respond_to?(class_symbol)
+        return self.send(class_symbol, *args, &block)
+      end
+
+      raise "Element (#{method_requested}) is not defined in ElementCell object"
+    end
+  end
+end

data/lib/automation_object/element/element_group.rb

@@ -0,0 +1,33 @@
+module AutomationObject
+  class ElementGroup < Array
+    include AutomationObject::ElementsHelpers
+
+    def load_elements
+      elements_array = self.get_elements
+      elements_array.each_with_index { |element_object, index|
+        element_cell_configuration = self.get_individual_configuration(index, self.configuration)
+
+        group_cell_options = {
+            :framework_object => self.framework_object,
+            :screen_object => self.screen_object,
+            :driver_object => self.driver_object,
+            :blue_prints => element_cell_configuration,
+            :screen_name => self.screen_name,
+            :element_name => (self.element_name + "(#{index})"),
+            :element_object => element_object
+        }
+
+        element_cell_object = AutomationObject::ElementCell.new(group_cell_options)
+
+        self.push(element_cell_object)
+
+        this = self
+        element_cell_object.on :hook do |args|
+          this.emit :hook, args
+        end
+      }
+
+      self.elements_loaded = true
+    end
+  end
+end

data/lib/automation_object/element/element_hash.rb

@@ -0,0 +1,25 @@
+module AutomationObject
+  class ElementHash < Hash
+    include AutomationObject::ElementsHelpers
+
+    def load_elements
+      modified_elements_array = self.load_elements_global
+
+      modified_elements_array.each { |modified_element|
+        element_key = self.get_element_key(modified_element)
+        #Change element name so that it includes the hash index instead of the array index
+        modified_element.element_name = (self.element_name + "(#{element_key})")
+        self[element_key] = modified_element
+      }
+    end
+
+    def get_element_key(element_object)
+      element_method = self.configuration['define_elements_by'].to_sym
+      unless element_object.respond_to?(element_method)
+        raise ArgumentError, "Element object does not have method (#{element_method}), for ElementHash (#{self.element_name}) in Screen (#{self.screen_name})"
+      end
+
+      element_object.send(self.configuration['define_elements_by'])
+    end
+  end
+end

data/lib/automation_object/element/element_helpers.rb

@@ -0,0 +1,29 @@
+module AutomationObject
+  module ElementHelpers
+    def get_selector_params(configuration)
+      params = Hash.new
+      if configuration['xpath']
+        params[:selector_method] = :xpath
+        params[:selector] = configuration['xpath']
+      elsif configuration['css']
+        params[:selector_method] = :css
+        params[:selector] = configuration['css']
+      else
+        raise(ArgumentError, 'xPath and CSS are the only element selectors available')
+      end
+
+      params
+    end
+
+    def is_multiple?
+      return true if self.configuration['multiple'] == true
+      return false
+    end
+
+    def in_iframe?
+      return false unless configuration.is_a?(Hash)
+      return false unless configuration.has_key?('in_iframe')
+      return true if configuration['in_iframe']
+    end
+  end
+end

data/lib/automation_object/element/element_methods.rb

@@ -0,0 +1,134 @@
+#Provides wrapper for mutex safe executions on a single driver
+#Without results in pain in the ass errors involving IO interruptions with driver
+module AutomationObject
+  class ElementMethods
+    include AutomationObject::ElementHelpers
+
+    attr_accessor :parent_element_object, :driver_object,
+                  :framework_object,
+                  :element_object, :configuration,
+                  :screen_name, :element_name
+
+    def initialize(parent_element_object)
+      self.parent_element_object = parent_element_object
+      self.framework_object = self.parent_element_object.framework_object
+
+      self.screen_name = self.parent_element_object.screen_name
+      self.element_name = self.parent_element_object.element_name
+
+      self.driver_object = self.parent_element_object.driver_object
+      self.element_object = parent_element_object.element_object if parent_element_object.element_object
+      self.configuration = self.parent_element_object.configuration
+    end
+
+    def respond_to?(method_symbol, include_private = false)
+      return true if super
+
+      #Check custom_methods configuration, return true if it does have the key
+      if self.configuration['custom_methods'].class == Hash
+        if self.configuration['custom_methods'].has_key?(method_symbol.to_s)
+          return true
+        end
+      end
+
+      #Now we need to check the element
+      element_object = self.get_element
+      return element_object.respond_to?(method_symbol, include_private)
+    end
+
+    def method_missing(method_symbol, *arguments, &block)
+      unless element_object.respond_to?(method_symbol)
+        configuration = self.configuration
+        if configuration['custom_methods'].class == Hash
+          if configuration['custom_methods'].has_key?(method_symbol.to_s)
+            method_eval_configuration = configuration['custom_methods'][method_symbol.to_s]
+            return self.custom_evaluation(method_symbol.to_s, method_eval_configuration)
+          end
+        end
+      end
+
+      element_object = self.get_element
+      element_object.send(method_symbol, *arguments, &block)
+    end
+
+    def get_element
+      #Return element_object if already set
+      return self.element_object if self.element_object
+      #Get Element
+      self.find_element
+      self.element_object
+    end
+
+    def find_element
+      #Find element if not already set and set it to self
+      selector_params = self.get_selector_params(self.configuration)
+      #ap selector_params
+      self.element_object = self.driver_object.find_element(selector_params[:selector_method], selector_params[:selector])
+    end
+
+    def reset_element
+      if self.element_object
+        AutomationObject::Logger::add('Resetting element', [self.parent_element_object.framework_location])
+      end
+      self.element_object = nil
+    end
+
+    def exists?
+      selector_params = self.get_selector_params(self.configuration)
+      element_exists = self.driver_object.exists?(selector_params[:selector_method], selector_params[:selector])
+
+      self.reset_element unless element_exists
+      return element_exists
+    end
+
+    def custom_evaluation(custom_method_name, method_eval_configuration)
+      return nil if method_eval_configuration.class != Hash
+
+      unless method_eval_configuration['element_method']
+        raise ArgumentError, "element_method key is needed for the custom method #{custom_method_name}"
+      end
+
+      unless method_eval_configuration['evaluate']
+        raise ArgumentError, "evaluate key is needed for the custom method #{custom_method_name}"
+      end
+
+      element_method = method_eval_configuration['element_method'].to_sym
+
+      element_object = self.get_element
+      if self.respond_to?(element_method)
+        evaluation_value = self.send(element_method)
+      else
+        evaluation_value = element_object.send(element_method)
+      end
+
+      evaluation_script = "evaluation_value.#{method_eval_configuration['evaluate']}"
+
+      AutomationObject::Logger::add("Running custom evaluation method #{custom_method_name}", [self.parent_element_object.framework_location])
+
+      return eval(evaluation_script)
+    end
+
+    def drag_to_element(secondary_element)
+      if self.parent_element_object.driver_object.device_is_android?
+        raise 'This has not been implemented for Android services yet'
+      end
+
+      #Do this internally to avoid thread locking
+      secondary_element = self.parent_element_object.screen_object.send(secondary_element)
+
+      unless self.parent_element_object.framework_object.is_mobile?
+        return self.driver_object.drag_and_drop(self.get_element, secondary_element.get_element)
+      end
+
+      primary_center = self.get_element_center
+      secondary_center = secondary_element.get_element_center
+
+      location_string = "{x:#{primary_center[:x]}, y:#{primary_center[:y]}}, {x:#{secondary_center[:x]}, y:#{secondary_center[:y]}}"
+      ios_command = "UIATarget.localTarget().dragFromToForDuration(#{location_string}, 0.7);"
+
+      AutomationObject::Logger::add("Running drag command on element to element #{secondary_element}", [self.parent_element_object.framework_location])
+
+      self.driver_object.execute_script(ios_command)
+    end
+  end
+end

data/lib/automation_object/element/elements_helpers.rb

@@ -0,0 +1,204 @@
+module AutomationObject
+  module ElementsHelpers
+    include EventEmitter
+    include AutomationObject::ElementHelpers
+
+    attr_accessor :framework_object, :screen_object, :driver_object,
+                  :configuration,
+                  :screen_name, :element_name,
+                  :elements_loaded #Boolean
+
+    #Same initialize in both Array and Hash Classes
+    def initialize(params)
+      self.elements_loaded = false #Set to false as default
+
+      #Set params to properties
+      self.framework_object = params[:framework_object] || raise(ArgumentError, 'framework_object is required in params')
+      self.screen_object = params[:screen_object] || raise(ArgumentError, 'screen_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
+      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')
+      self.element_name = params[:element_name] || raise(ArgumentError, 'element_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, 'screen_object should be an Screen Object' unless self.screen_object.is_a? Screen
+      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
+      raise ArgumentError, 'element_name should be a String Object' unless self.element_name.is_a? String
+    end
+
+    def get_elements
+      #Deal with iFrames
+      if self.framework_object.is_browser?
+        if self.in_iframe?
+          self.screen_object.switch_to_iframe(self.element_name)
+        end
+      end
+
+      selector_params = self.get_selector_params(self.configuration)
+
+      if self.configuration['multiple_ios_fix'] and self.framework_object.is_mobile?
+        unless self.driver_object.device_is_android?
+          return self.get_elements_temp_ios_fix
+        end
+      end
+
+      elements_array = self.driver_object.find_elements(selector_params[:selector_method], selector_params[:selector])
+
+      return elements_array unless elements_array.is_a?(Array)
+      return elements_array if elements_array.length == 0
+
+      if self.configuration['remove_duplicates']
+        elements_array = self.remove_duplicates(elements_array, self.configuration['remove_duplicates'])
+      end
+
+      return elements_array if elements_array.length == 0
+
+      if self.configuration['custom_range']
+        elements_array = self.get_custom_range_elements(elements_array, self.configuration['custom_range'])
+      end
+
+      return elements_array
+    end
+
+    #Dump array into Hash so that we can skip already existing keys that return Hash values Array
+    def remove_duplicates(elements_array, element_method)
+      element_method = element_method.to_sym
+      elements_hash = Hash.new
+
+      elements_array.each { |element|
+        unless element.respond_to?(element_method)
+          raise "Expecting element to respond to method #{element_method} defined in remove_duplicates for #{self.screen_name}->#{self.element_name}"
+        end
+
+        element_value = element.send(element_method)
+
+        next if elements_hash.has_key?(element_value)
+        elements_hash[element.send(element_method)] = element
+      }
+
+      #Return the values array
+      return elements_hash.values
+    end
+
+    def get_custom_range_elements(elements_array, range_hash)
+      unless range_hash.is_a?(Hash)
+        raise "Expecting custom_range to be a Hash, got #{range_hash.class}. Defined in #{self.screen_name}->#{self.element_name}"
+      end
+
+      start_index = 0
+      if range_hash['start'].is_a?(Numeric)
+        start_index = range_hash['start'].to_i
+      end
+
+      end_index = 0
+      if range_hash['end'].is_a?(Numeric)
+        end_index = range_hash['end'].to_i
+      end
+
+      new_elements_array = Array.new
+      elements_array.each_with_index { |element, index|
+        element_index = index + 1 #Since elements start at 1
+        next if element_index < start_index
+
+        if end_index != 0
+          break if element_index > end_index
+        end
+
+        new_elements_array.push(element)
+      }
+
+      return new_elements_array
+    end
+
+    #Todo: remove when Appium is fixed for iOS Apps
+    #Multiple elements in iOS App is killing the whole thing
+    #Get around the problem by appending [index] to each using find_element til failure
+    def get_elements_temp_ios_fix
+      selector_params = self.get_selector_params(self.configuration)
+      #Get rid of any shit at the end, //blah/element[1] becomes //blah/element only for numeric indexes, going to add a numeric index
+
+      elements_array = Array.new
+
+      index = 1
+      find_element_failure = false
+      until find_element_failure
+        selector_params[:selector] = selector_params[:selector].gsub(/\[\d+\]$/, '')
+        selector_params[:selector] = selector_params[:selector] + "[#{index}]"
+
+        begin
+          if self.driver_object.exists?(selector_params[:selector_method], selector_params[:selector])
+            elements_array.push(self.driver_object.find_element(selector_params[:selector_method], selector_params[:selector]))
+          else
+            find_element_failure = true
+            break
+          end
+        rescue
+          find_element_failure = true
+          break
+        end
+
+        index += 1
+      end
+
+      return elements_array
+    end
+
+    #Cannot override module method, call this in Hash/Array and do specifics in
+    # load_elements of those classes
+    def load_elements_global
+      elements_array = self.get_elements
+
+      modified_elements_array = Array.new
+      elements_array.each_with_index do |element_object, index|
+        #Get params for individual element, given the index
+        element_configuration = self.get_individual_configuration(index, self.configuration)
+
+        element_object_options = {
+            :framework_object => self.framework_object,
+            :screen_object => self.screen_object,
+            :driver_object => self.driver_object,
+            :blue_prints => element_configuration,
+            :screen_name => self.screen_name,
+            :element_name => (self.element_name + "(#{index})"),
+            :element_object => element_object
+        }
+
+        new_element = AutomationObject::Element.new(element_object_options)
+
+        this = self
+        new_element.on :hook do |args|
+          this.emit :hook, args
+        end
+
+        modified_elements_array.push(new_element)
+      end
+
+      self.elements_loaded = true
+      return modified_elements_array
+    end
+
+    def get_individual_configuration(index, configuration)
+      element_configuration = configuration.clone
+      element_index = index + 1 #Elements start at one instead of zero, so add one
+
+      if element_configuration['xpath']
+        element_configuration['xpath'] = '(' + element_configuration['xpath'].to_s + ')' + "[position() = #{element_index}]"
+      elsif element_configuration['css']
+        element_configuration['css'] = element_configuration['css'].to_s + ":nth-of-type(#{element_index})"
+      else
+        raise(ArgumentError, 'xPath and CSS are the only element selectors available')
+      end
+
+      return element_configuration
+    end
+
+    def reset_elements
+      self.clear #Same method for both Hashes and Arrays
+      self.elements_loaded = false
+    end
+  end
+end

data/lib/automation_object/framework/events.rb

@@ -0,0 +1,8 @@
+module AutomationObject
+  module FrameworkEvents
+    def screen_change_emit(screen_class_symbol)
+      screen_name = self.translate_class_to_string(screen_class_symbol)
+      self.emit(:screen_change, screen_name)
+    end
+  end
+end

data/lib/automation_object/framework/helpers.rb

@@ -0,0 +1,101 @@
+module AutomationObject
+  module FrameworkHelpers
+    attr_accessor :is_mobile, :is_browser, :supports_contexts
+
+    def is_mobile?
+      if self.is_mobile == nil
+        self.is_mobile = self.supports_contexts?
+      end
+
+      return self.is_mobile
+    end
+
+    def is_browser?
+      unless self.is_browser == nil
+        return self.is_browser
+      end
+
+      #If Selenium the yeah we are using a browser
+      if self.supports_window_handles?
+        self.is_browser = true
+        return self.is_browser
+      end
+
+      #Now we need to check Appium's contexts to see if WEBVIEW is in available_contexts
+      available_contexts = self.driver_object.available_contexts
+      self.supports_contexts = true
+
+      available_contexts.each { |context|
+        if context.match(/^WEBVIEW_\d+$/)
+          self.is_browser = true
+          return self.is_browser
+        end
+      }
+
+      self.is_browser = false
+      return self.is_browser
+    end
+
+    #Selenium's use of window_handles
+    def supports_window_handles?
+      begin
+        self.driver_object.window_handles
+        return true
+      rescue NoMethodError, Selenium::WebDriver::Error::UnknownError
+        return false
+      end
+    end
+
+    #Appium's use of window_handles
+    def supports_contexts?
+      return self.supports_contexts if self.supports_contexts != nil
+
+      begin
+        self.driver_object.available_contexts
+        self.supports_contexts = true
+        return true
+      rescue NoMethodError
+        return false
+      end
+    end
+
+    def current_screen
+      current_screen_object = Object.new
+      current_screen_object.class.module_eval { attr_accessor :framework_object }
+      current_screen_object.framework_object = self
+
+      def current_screen_object.method_missing(method_symbol, *args, &block)
+        return self.framework_object.send(self.framework_object.get_current_screen).send(method_symbol, *args, &block)
+      end
+
+      current_screen_object
+    end
+
+    def get_current_screen
+      return self.translate_class_to_string(self.current_screen_class).to_sym
+    end
+
+    def kill_monitor_threads
+      begin
+        self.screen_monitor_thread.each_value { |thread|
+          Thread.kill(thread) if thread
+        }
+      rescue
+        # ignored
+      end
+    end
+
+    def quit
+      AutomationObject::Logger::add('Quitting the framework')
+      self.kill_monitor_threads
+
+      if self.driver_object.respond_to?(:quit)
+        self.driver_object.quit if self.driver_object.respond_to?(:quit)
+      elsif self.driver_object.respond_to?(:driver_quit)
+        self.driver_object.driver_quit if self.driver_object.respond_to?(:driver_quit)
+      else
+        raise 'Unable to find provided driver quit method'
+      end
+    end
+  end
+end