automation_object 0.0.4

data/lib/automation_object/driver/anonymous.rb

@@ -0,0 +1,27 @@
+module AutomationObject
+  module Driver
+    class Anonymous
+      def initialize(driver_object, object)
+        @driver_object = driver_object
+        @object = object
+      end
+
+      def respond_to?(method_symbol, include_private = false)
+        @driver_object.mutex_object.synchronize do
+          return @object.respond_to?(method_symbol, include_private)
+        end
+      end
+
+      def method_missing(method_symbol, *arguments, &block)
+        start_time = Time.new.to_f
+
+        @driver_object.mutex_object.synchronize do
+          object_return = @object.send(method_symbol, *arguments, &block)
+
+          total_time_taken = (Time.new.to_f-start_time)
+          return object_return
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/driver.rb

@@ -0,0 +1,281 @@
+#Thread Safe Execution Purposes
+module AutomationObject
+  module Driver
+    class Driver
+      @@anonymous_skip_classes = [TrueClass, FalseClass, String, Numeric, Array, Hash]
+      attr_accessor :mutex_object
+
+      attr_accessor :is_browser, :is_mobile, :supports_contexts
+
+      @@throttle_methods = {
+          'navigate' => 2,
+          'close' => 2,
+          'manage' => 1
+      }
+
+      @@minimum_speed = 0 #0.01 #Speed it up to see where faults may lay
+
+      @@implicit_wait_timeout = 30
+      @@script_timeout = 500
+      @@page_load_timeout = 500
+
+      def self.throttle_methods
+        @@throttle_methods
+      end
+
+      def self.throttle_methods=(value)
+        @@throttle_methods = value
+      end
+
+      def self.minimum_speed
+        @@minimum_speed
+      end
+
+      def self.minimum_speed=(value)
+        @@minimum_speed = value
+      end
+
+      def initialize(driver_object)
+        @driver_object = driver_object
+        self.mutex_object = Mutex.new
+
+        return if self.is_mobile?
+
+        self.mutex_object.synchronize do
+          @driver_object.manage.timeouts.implicit_wait = @@implicit_wait_timeout
+          @driver_object.manage.timeouts.script_timeout = @@script_timeout
+          @driver_object.manage.timeouts.page_load = @@page_load_timeout
+        end
+      end
+
+      def respond_to?(method_symbol, include_private = false)
+        self.mutex_object.synchronize do
+          return true if super
+          return @driver_object.respond_to?(method_symbol, include_private)
+        end
+      end
+
+      def method_missing(method_symbol, *arguments, &block)
+        anonymous_object = nil
+        start_time = Time.new.to_f
+
+        self.mutex_object.synchronize do
+          #For Appium because it's under driver method
+          if @driver_object.respond_to?(:driver) and not @driver_object.respond_to?(method_symbol)
+            driver_return = @driver_object.driver.send(method_symbol, *arguments, &block)
+          else
+            driver_return = @driver_object.send(method_symbol, *arguments, &block)
+          end
+
+          self.throttle_speed(method_symbol, start_time)
+
+          total_time_taken = (Time.new.to_f-start_time)
+          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, method_symbol, *arguments, &block)
+
+          @@anonymous_skip_classes.each { |skip_class|
+            if driver_return.is_a?(skip_class)
+              return driver_return
+            end
+          }
+
+          anonymous_object = AutomationObject::Driver::Anonymous.new(self, driver_return)
+        end
+
+        return anonymous_object
+      end
+
+      def exists?(selector_type, selector_path)
+        start_time = Time.new.to_f
+
+        self.mutex_object.synchronize do
+          if @driver_object.respond_to?(:exists) #Appium
+            exists = @driver_object.exists { @driver_object.find_element(selector_type, selector_path) }
+          else
+            begin
+              @driver_object.manage.timeouts.implicit_wait = 0
+              element_objects = @driver_object.find_elements(selector_type, selector_path)
+              @driver_object.manage.timeouts.implicit_wait = @@implicit_wait_timeout
+              if element_objects.length == 0
+                exists = false
+              else
+                exists = true
+              end
+            rescue
+              exists = false
+            end
+          end
+
+          self.throttle_speed(:exists?, start_time)
+
+          total_time_taken = (Time.new.to_f-start_time)
+          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :exists?, [selector_type, selector_path])
+
+          return exists
+        end
+      end
+
+      def find_element(selector_type, selector_path)
+        start_time = Time.new.to_f
+
+        self.mutex_object.synchronize do
+          element_object = @driver_object.find_element(selector_type, selector_path)
+
+          self.throttle_speed(:find_element, start_time)
+
+          total_time_taken = (Time.new.to_f-start_time)
+          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :find_element, [selector_type, selector_path])
+
+          return AutomationObject::Driver::Element.new(self, element_object)
+        end
+      end
+
+      def find_elements(selector_type, selector_path)
+        start_time = Time.new.to_f
+
+        self.mutex_object.synchronize do
+          element_objects = @driver_object.find_elements(selector_type, selector_path)
+
+          parsed_element_objects = Array.new
+          element_objects.each { |element_object|
+            parsed_element_objects.push(AutomationObject::Driver::Element.new(self, element_object))
+          }
+
+          self.throttle_speed(:find_elements, start_time)
+
+          total_time_taken = (Time.new.to_f-start_time)
+          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :find_elements, [selector_type, selector_path])
+
+          return parsed_element_objects
+        end
+      end
+
+      def throttle_speed(method_symbol, start_time)
+        method_string = method_symbol.to_s
+
+        throttle_time_minimum = @@minimum_speed
+        if @@throttle_methods.is_a?(Hash)
+          if @@throttle_methods.has_key?(method_string)
+            throttle_time_minimum = @@throttle_methods[method_string].to_f
+          end
+        end
+
+        time_difference = Time.new.to_f - start_time
+
+        if time_difference < throttle_time_minimum
+          sleep((throttle_time_minimum-time_difference))
+        end
+      end
+
+      def screenshot(path)
+        start_time = Time.new.to_f
+
+        if self.driver_object.respond_to?(:screenshot)
+          driver_return = self.driver_object.screenshot(path)
+        else
+          driver_return = self.driver_object.save_screenshot(path)
+        end
+
+        self.throttle_speed(:find_elements, start_time)
+
+        total_time_taken = (Time.new.to_f-start_time)
+        AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :screenshot, [path])
+
+        return driver_return
+      end
+
+      def accept_prompt
+        start_time = Time.new.to_f
+
+        if self.driver_object.respond_to?(:alert_accept)
+          self.driver_object.alert_accept
+        else
+          alert = self.driver_object.switch_to.alert
+          alert.accept
+        end
+
+        self.throttle_speed(:accept_prompt, start_time)
+        return nil
+      end
+
+      def dismiss_prompt
+        start_time = Time.new.to_f
+
+        begin
+          @driver_object.alert_dismiss
+        rescue NoMethodError
+          alert = @driver_object.switch_to.alert
+          alert.dismiss
+          @driver_object.switch_to.default_content
+        end
+
+        self.throttle_speed(:dismiss_prompt, start_time)
+        return nil
+      end
+
+      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 = nil
+        self.mutex_object.synchronize do
+          available_contexts = @driver_object.available_contexts
+        end
+        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.mutex_object.synchronize do
+            @driver_object.window_handles
+          end
+          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
+
+        self.mutex_object.synchronize do
+          begin
+            @driver_object.available_contexts
+            self.supports_contexts = true
+          rescue NoMethodError
+            self.supports_contexts = false
+          end
+        end
+
+        return self.supports_contexts
+      end
+    end
+  end
+end

data/lib/automation_object/driver/element.rb

@@ -0,0 +1,243 @@
+#Thread Safe Execution Purposes
+module AutomationObject
+  module Driver
+    class Element
+      @@throttle_methods = {
+          'click' => 2, #Slow down, browser given back before navigation is finished
+          #'location_once_scrolled_into_view' => 0.5 #Appeared where Firefox was failing, add a little more time
+      }
+      @@minimum_speed = 0 #0.01
+
+      @@scroll_into_view_methods = [:click, :tap, :hover, :send_keys]
+
+      def self.throttle_methods
+        @@throttle_methods
+      end
+
+      def self.throttle_methods=(value)
+        @@throttle_methods = value
+      end
+
+      def self.minimum_speed
+        @@minimum_speed
+      end
+
+      def self.minimum_speed=(value)
+        @@minimum_speed = value
+      end
+
+      def initialize(driver_object, element_object)
+        @driver_object = driver_object
+        @element_object = element_object
+      end
+
+      def respond_to?(method_symbol, include_private = false)
+        return true if super
+        return @element_object.respond_to?(method_symbol, include_private)
+      end
+
+      def method_missing(method_symbol, *arguments, &block)
+        if @@scroll_into_view_methods.include?(method_symbol)
+          self.scroll_into_view
+        end
+
+        @driver_object.mutex_object.synchronize do
+          start_time = Time.new.to_f
+          element_object_return = @element_object.send(method_symbol, *arguments, &block)
+
+          self.throttle_speed(method_symbol, start_time)
+
+          total_time_taken = (Time.new.to_f-start_time)
+          AutomationObject::Logger::add_driver_element_message(total_time_taken, caller_locations, method_symbol, *arguments, &block)
+
+          return element_object_return
+        end
+      end
+
+      def throttle_speed(method_symbol, start_time)
+        method_string = method_symbol.to_s
+
+        throttle_time_minimum = @@minimum_speed
+        if @@throttle_methods.is_a?(Hash)
+          if @@throttle_methods.has_key?(method_string)
+            throttle_time_minimum = @@throttle_methods[method_string].to_f
+          end
+        end
+
+        time_difference = Time.new.to_f - start_time
+
+        if time_difference < throttle_time_minimum
+          sleep((throttle_time_minimum-time_difference))
+        end
+      end
+
+      def collides_with_element?(second_element_object, collision_tolerance = false)
+        box_one = self.get_box_coordinates
+        box_two = second_element_object.get_box_coordinates
+
+        collision_tolerance = 0 unless collision_tolerance.is_a?(Numeric)
+
+        if box_one[:x2] > box_two[:x1] and box_one[:x1] < box_two[:x2] and box_one[:y2] > box_two[:y1] and box_one[:y1] < box_two[:y2]
+          if box_one[:x2] > (box_two[:x1] + collision_tolerance) and (box_one[:x1] + collision_tolerance) < box_two[:x2] and
+              box_one[:y2] > (box_two[:y1] + collision_tolerance) and (box_one[:y1] + collision_tolerance) < box_two[:y2]
+            return true
+          else
+            return false
+          end
+        else
+          return false
+        end
+      end
+
+      def get_box_coordinates
+        element_location = self.location
+        element_size = self.size
+
+        box_coordinates = Hash.new
+        box_coordinates[:x1] = element_location.x.to_f
+        box_coordinates[:y1] = element_location.y.to_f
+        box_coordinates[:x2] = element_location.x.to_f + element_size.width.to_f
+        box_coordinates[:y2] = element_location.y.to_f + element_size.height.to_f
+
+        return box_coordinates
+      end
+
+      def attribute(key, value = false)
+        @driver_object.mutex_object.synchronize do
+          return @element_object.attribute(key) unless value
+        end
+
+        script = "return arguments[0].#{key} = '#{value}'"
+        @driver_object.execute_script(script, @element_object)
+
+        @driver_object.mutex_object.synchronize do
+          return @element_object.attribute(key)
+        end
+      end
+
+      def switch_to_iframe
+        @driver_object.switch_to.frame(self.get_iframe_switch_value)
+      end
+
+      def get_iframe_switch_value
+        iframe_switch_value = self.attribute('id')
+        if iframe_switch_value.length == 0
+          iframe_switch_value = self.attribute('name')
+        end
+
+        unless iframe_switch_value
+          iframe_switch_value = self.attribute('name', SecureRandom.hex(16))
+        end
+
+        return iframe_switch_value
+      end
+
+      def get_element_center
+        element_location = self.location
+        element_size = self.size
+
+        center = Hash.new
+        center[:x] = (element_location.x.to_f + element_size.width.to_f/2).to_f
+        center[:y] = (element_location.y.to_f + element_size.height.to_f/2).to_f
+
+        return center
+      end
+
+      def x
+        return self.location.x
+      end
+
+      def y
+        return self.location.y
+      end
+
+      def width
+        return self.size.width
+      end
+
+      def height
+        return self.size.height
+      end
+
+      def hover
+        self.scroll_into_view
+        @driver_object.action.move_to(@element_object).perform
+      end
+
+      def visible?
+        return self.displayed?
+      end
+
+      def invisible?
+        return self.displayed? ? false : true
+      end
+
+      def id
+        return self.attribute('id').to_s
+      end
+
+      def href
+        return self.attribute('href').to_s
+      end
+
+      def content
+        return self.attribute('content').to_s
+      end
+
+      def scroll_into_view
+        return self.scroll_to_view
+      end
+
+      def scroll_to_view
+        self.location_once_scrolled_into_view
+
+        if @driver_object.is_mobile?
+          return unless @driver_object.is_browser?
+
+          element_center = self.get_element_center
+          window_height = @driver_object.execute_script('return window.innerHeight;').to_f
+          current_y_position = @driver_object.execute_script('var doc = document.documentElement; return (window.pageYOffset || doc.scrollTop)  - (doc.clientTop || 0);').to_f
+
+          if element_center[:y] < (window_height/2)
+            ideal_y_position = (current_y_position + element_center[:y] - (window_height.to_f / 2.0)).abs
+          else
+            ideal_y_position = (current_y_position - element_center[:y] + (window_height.to_f / 2.0)).abs
+          end
+
+          @driver_object.execute_script("window.scroll(#{element_center[:x].to_f},#{ideal_y_position});")
+          #Just in case in close to the top or bottom bounds of the window
+          element_location = self.location_once_scrolled_into_view
+
+          if element_location[:y] < 0
+            current_y_position = @driver_object.execute_script('var doc = document.documentElement; return (window.pageYOffset || doc.scrollTop)  - (doc.clientTop || 0);').to_f
+            scroll_y_position = current_y_position + element_location[:y]
+            @driver_object.execute_script("window.scroll(#{element_location[:x].to_f},#{scroll_y_position});")
+          end
+        else
+          element_location = self.location
+
+          window_height = @driver_object.execute_script('return window.innerHeight;').to_f
+          current_scroll_position = @driver_object.execute_script('var doc = document.documentElement; return (window.pageYOffset || doc.scrollTop)  - (doc.clientTop || 0);').to_f
+
+          middle_y_bounds = current_scroll_position + window_height/2
+
+          if middle_y_bounds > element_location.y
+            #Add
+            y_difference = middle_y_bounds - element_location.y
+            scroll_y_position = current_scroll_position - y_difference
+          else
+            #Subtract
+            y_difference = element_location.y - middle_y_bounds
+            scroll_y_position = current_scroll_position + y_difference
+          end
+
+          #Get the element to halfway
+          scroll_x_position = element_location.x.to_f
+
+          javascript_string = "return window.scroll(#{scroll_x_position}, #{scroll_y_position});"
+          @driver_object.execute_script(javascript_string)
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/element/element.rb

@@ -0,0 +1,145 @@
+module AutomationObject
+  class Element
+    include EventEmitter
+    include AutomationObject::ElementHelpers
+
+    WINDOW_CHECK_ON_METHOD = [:click, :drag_to_element]
+    SCROLL_TO_VIEW_ON_METHOD = [:click, :drag_to_element, :send_keys]
+
+    attr_accessor :framework_object, :driver_object,
+                  :framework_location,
+                  :screen_object, :element_object,
+                  :screen_name, :element_name,
+                  :element_methods_object
+
+    attr_accessor :configuration
+
+    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, 'elements_name is required in params')
+
+      #Set element object if requested
+      self.element_object = params[:element_object] if params[:element_object]
+
+      #Validate properties
+      raise ArgumentError, 'framework_object should be an Automation 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, 'elements_name should be a String Object' unless self.element_name.is_a? String
+
+      #This can stay alive, will reset object internally when issued to this class
+      #ElementMethod Object will have the available methods for elements, while
+      #allowing for thread locking on this level
+      #Pass self into it, so it can hit above levels without much issue
+      self.element_methods_object = ElementMethods.new(self)
+
+      self.framework_location = self.screen_object.framework_location + ".#{self.element_name}"
+    end
+
+    def respond_to?(method_symbol, include_private = false)
+      #If this Element class has the method then return true
+      return true if super
+
+      #Check ElementMethods respond_to?, need to wrap in driver mutex object
+      return self.element_methods_object.respond_to?(method_symbol, include_private)
+    end
+
+    #Avoid deadlocking on resets
+    def reset_element
+      self.element_methods_object.reset_element
+    end
+
+    def check_new_window?(method_symbol)
+      return false unless self.framework_object.is_browser?
+      WINDOW_CHECK_ON_METHOD.include?(method_symbol)
+    end
+
+    def scroll_to_view?(method_symbol)
+      return false unless self.framework_object.is_browser?
+      SCROLL_TO_VIEW_ON_METHOD.include?(method_symbol)
+    end
+
+    def method_missing(method_symbol, *arguments, &block)
+      method_string = method_symbol.to_s
+      created_window_handle = false
+      em_object_return = nil
+
+      AutomationObject::Logger::add("Calling method #{method_symbol} on element", [self.framework_location])
+
+      #Run any before hooks
+      self.hook(method_string, 'before')
+
+      #Deal with iFrames
+      if self.framework_object.is_browser?
+        if self.in_iframe?
+          self.screen_object.switch_to_iframe(self.element_name)
+        end
+      end
+
+      #Check for difference in window handles if needed
+      if self.check_new_window?(method_symbol)
+        before_window_handles = self.framework_object.get_window_handles
+      end
+
+
+      begin
+        #Use automation object level mutex object which will lock any element operations will complete
+        begin
+          AutomationObject::Logger::add("Executing method #{method_symbol} on element", [self.framework_location])
+          em_object_return = self.element_methods_object.send(method_symbol, *arguments, &block)
+        rescue Selenium::WebDriver::Error::ElementNotVisibleError, Selenium::WebDriver::Error::UnknownError => e
+          raise e
+        rescue Selenium::WebDriver::Error::StaleElementReferenceError
+          sleep(2)
+          AutomationObject::Logger::add("Stale element error, retrying method #{method_symbol} on element", [self.framework_location])
+          em_object_return = self.element_methods_object.send(method_symbol, *arguments, &block)
+        rescue Selenium::WebDriver::Error::InvalidElementStateError
+          sleep(2)
+          AutomationObject::Logger::add("Invalid element state error, retrying method #{method_symbol} on element", [self.framework_location])
+          self.element_methods_object.find_element
+          em_object_return = self.element_methods_object.send(method_symbol, *arguments, &block)
+        end
+      rescue
+        raise $!, "#{self.framework_location} #{$!}", $!.backtrace
+      end
+
+      if self.check_new_window?(method_symbol)
+        after_window_handles = self.framework_object.get_window_handles
+        window_handle_difference = after_window_handles - before_window_handles
+        if window_handle_difference.length > 1
+          raise "Click on element (#{self.element_name}) in screen (#{self.screen_name}) has opened more than one window."
+        end
+        created_window_handle = window_handle_difference.shift
+      end
+
+      self.hook(method_string, 'after', created_window_handle)
+      return em_object_return
+    end
+
+    def hook(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.emit :hook, {
+          :configuration => hook_configuration,
+          :created_window_handle => created_window_handle
+      }
+
+      self.after_mutex_lock if action == 'after'
+    end
+  end
+end

data/lib/automation_object/element/element_array.rb

@@ -0,0 +1,12 @@
+module AutomationObject
+  class ElementArray < Array
+    include AutomationObject::ElementsHelpers
+
+    def load_elements
+      modified_elements_array = self.load_elements_global
+      modified_elements_array.each { |modified_element|
+        self.push(modified_element)
+      }
+    end
+  end
+end