automation_object 0.0.4

data/lib/automation_object/screen/screen.rb

@@ -0,0 +1,209 @@
+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

data/lib/automation_object/screen/screen_hook_helpers.rb

@@ -0,0 +1,319 @@
+module AutomationObject
+  module ScreenHookHelpers
+    def hook_listener(args)
+      self.hook(args[:configuration], args[:created_window_handle])
+    end
+
+    def before_load
+      AutomationObject::Logger::add('Running Before Load Hook', [self.framework_location])
+
+      return unless self.configuration.has_key?('before_load')
+      unless self.configuration['before_load'].class == Hash
+        raise ArgumentError, "Expecting before_load in screen (#{self.screen_name}) to be a Hash"
+      end
+
+      self.hook(self.configuration['before_load'])
+    end
+
+    def hook(configuration, created_window_handle = false)
+      #Use each, allow for ordering of wait, change_screen in configuration
+      configuration.each { |key, value|
+        case key
+          when 'wait_for_new_window'
+            unless value == true
+              raise ArgumentError, "Only expecting the value of true for wait_for_new_window hook in screen (#{self.screen_name})"
+            end
+            created_window_handle = self.wait_for_new_window unless created_window_handle
+          when 'show_modal'
+            #Add modal to active modal, prevent multiple requests to do the same thing or error out
+            self.activate_modal(self.translate_string_to_class(value))
+          when 'close_window'
+            self.close_window(true) #Don't close the window, already closed
+          when 'change_screen'
+            screen_class_symbol = self.translate_string_to_class(value)
+            self.emit :change_screen, {
+                :screen_class_symbol => screen_class_symbol,
+                :created_window_handle => created_window_handle
+            }
+          when 'possible_screen_changes'
+            unless value.is_a?(Array)
+              raise ArgumentError, "Expected possible_screen_changes to be an Array in screen (#{self.screen_name})"
+            end
+
+            self.emit :possible_screen_changes, {
+                :possible_screens => value,
+                :created_window_handle => created_window_handle
+            }
+          when 'sleep'
+            sleep(value.to_f)
+          when 'wait_for_elements'
+            self.wait_for_elements(value)
+          when 'change_to_previous_screen'
+            self.emit :change_screen, {
+                :screen_class_symbol => self.framework_object.previous_screen_class,
+                :created_window_handle => created_window_handle
+            }
+          when 'close_modal'
+            self.active_modal = nil
+          when 'automatic_onload_modals'
+            self.automatic_onload_modals_hook(value)
+          when 'reset_screen'
+            self.reset_screen(true)
+          else
+            raise ArgumentError, "Hook requested (#{key}) is not implemented, found in screen #{self.screen_name}"
+        end
+      }
+    end
+
+    def automatic_onload_modals_hook(configuration)
+      return unless configuration.class == Array
+
+      configuration.each { |modal_configuration|
+        next unless modal_configuration.class == Hash
+        next unless modal_configuration.has_key?('modal_name')
+
+
+        if modal_configuration['number_of_checks']
+          number_of_checks = modal_configuration['number_of_checks'].to_i
+        else
+          number_of_checks = 10
+        end
+
+        number_of_checks.times do
+          modal_symbol = self.translate_string_to_class(modal_configuration['modal_name'])
+          if self.send(modal_symbol).live?
+            self.activate_modal(modal_symbol)
+            if modal_configuration['action'] == 'close'
+              self.close_modal(modal_symbol)
+            end
+            break
+          end
+
+          sleep(1)
+        end
+      }
+    end
+
+    def wait_for_new_window
+      loops = 0
+      max_loops = 30
+      loop_sleep = 1
+
+      stored_window_handles = self.framework_object.current_screen_hash.keys
+      new_window_handle = nil
+
+      until new_window_handle
+        loops = loops + 1
+        if loops > max_loops
+          raise "Max loop breached waiting for new window in screen #{self.screen_name}"
+        end
+
+        window_handles = self.framework_object.get_window_handles.clone
+        window_handle_difference = window_handles.length - stored_window_handles.length
+
+        #Still waiting for new window
+        if window_handle_difference == 0
+          sleep(loop_sleep)
+          next
+        end
+
+        window_handle_difference = window_handles - stored_window_handles
+
+        #Throw error if more than one extra window, not sure which one to use
+        if window_handle_difference.length > 1
+          raise "More than one window was opened on an element action, found in screen #{self.screen_name}"
+        end
+
+        new_window_handle = window_handle_difference.shift
+        break
+      end
+
+      return new_window_handle
+    end
+
+    def wait_for_elements(configuration)
+      unless configuration.class == Array
+        raise ArgumentError, "Expecting Array for wait_for_elements, got #{configuration.class} in screen #{self.screen_name}"
+      end
+
+      AutomationObject::Logger::add('Running Wait for Elements Hook', [self.framework_location])
+
+      configuration.each { |element_configuration|
+        unless element_configuration.class == Hash
+          raise ArgumentError, "Expecting wait_for_elements array to have Hash items got #{element_configuration.class} in screen #{self.screen_name}"
+        end
+
+        unless element_configuration.has_key?('element_name')
+          raise ArgumentError, "Expecting wait_for_elements array item hash to include the 'element_name' key in screen #{self.screen_name}"
+        end
+
+        element_name = element_configuration['element_name']
+        element_class_symbol = self.translate_string_to_class(element_name)
+        #Add exists? to requirements if it doesn't exist
+        unless element_configuration.has_key?('exists?')
+          unless self.send(element_class_symbol).configuration['multiple']
+            element_configuration['exists?'] = true
+          end
+        end
+
+        element_requirements = Hash.new
+        #Always put exists? at top if exists? is true
+        if element_configuration['exists?']
+          element_requirements['exists?'] = true
+          element_configuration.each { |key, value|
+            next if key == 'exists?' || key == 'element_name'
+            element_requirements[key] = value
+          }
+        else
+          element_configuration.each { |key, value|
+            next if key == 'element_name'
+            element_requirements[key] = value
+          }
+        end
+
+        self.wait_for_element(element_name, element_requirements)
+      }
+    end
+
+    def wait_for_element(element_name, element_requirements)
+      AutomationObject::Logger::add('Running Wait for Element Hook', [self.framework_location])
+
+      element_class_symbol = self.translate_string_to_class(element_name)
+
+      unless self.respond_to?(element_class_symbol)
+        raise "Element class was not defined correctly in screen class (#{self.screen_name}) for element (#{element_name})"
+      end
+
+      element_requirements.each { |requirement, requirement_value|
+        requirement_symbol = requirement.to_s.to_sym
+
+        unless self.send(element_class_symbol).respond_to?(requirement_symbol)
+          raise ArgumentError, "Element (#{element_name}) in screen (#{self.screen_name}) does not have the method (#{requirement_symbol})"
+        end
+
+        requirement_success = false
+
+        loops = 0
+        until requirement_success
+          if self.send(element_class_symbol).is_multiple?
+            self.send(element_class_symbol).load_elements
+          end
+
+          element_value = self.send(element_class_symbol).send(requirement)
+          requirement_success = (element_value == requirement_value)
+
+          AutomationObject::Logger::add("Waiting for element method #{requirement} got: #{element_value}, expecting: #{requirement_value}", [self.framework_location])
+
+          sleep(1) if loops > 0
+
+          if loops > 30
+            raise "Element (#{element_name}) in screen (#{self.screen_name}) breached max wait loops for #{requirement}"
+          end
+
+          loops += 1
+        end
+      }
+    end
+
+    def has_live_configuration?
+      return false unless self.configuration.class == Hash
+      return false unless self.configuration['live?'].class == Hash
+
+      configuration = self.configuration['live?']
+
+      elements_array = Array.new
+      elements_array.push(configuration['element']) if configuration['element'].class == Hash
+      elements_array += configuration['elements'] if configuration['elements'].class == Array
+
+      return false if elements_array.length == 0 #No elements to check
+
+      true
+    end
+
+    def live?
+      AutomationObject::Logger::add('Checking if screen is live?', [self.framework_location])
+
+      #Make sure live? configuration is setup correctly, return false if not
+      return false unless self.has_live_configuration?
+      configuration = self.configuration['live?']
+
+      self.hook(configuration['before']) if configuration['before'].class == Hash
+
+      elements_array = Array.new
+      elements_array.push(configuration['element']) if configuration['element'].class == Hash
+      elements_array += configuration['elements'] if configuration['elements'].class == Array
+
+      elements_array.each { |element_configuration|
+        next unless element_configuration.class == Hash
+        element_requirements = element_configuration.clone
+
+        #Add element_name since is name conflicts with the Element Class method name()
+        if element_requirements['element_name']
+          element_name = element_requirements['element_name']
+          element_requirements.delete('element_name')
+        else
+          element_name = element_requirements['name']
+          element_requirements.delete('name')
+        end
+
+        unless element_name
+          raise "Need to define element name in live? configuration for screen (#{self.screen_name})"
+        end
+
+        element_class_symbol = self.translate_string_to_class(element_name)
+
+        unless element_class_symbol
+          raise "Element class symbol was not defined internally in screen (#{self.screen_name}) for element (#{element_name})"
+        end
+
+        unless self.respond_to?(element_class_symbol)
+          raise "Element class was not defined correctly in screen class (#{self.screen_name}) for element (#{element_name})"
+        end
+
+        #Always put exists? at top if exists? is true
+        #only for AutomationObject::Element
+
+        if self.send(element_class_symbol).class.is_a?(AutomationObject::Element)
+          modified_requirements = Hash.new
+          exists = true
+          exists = element_requirements['exists?'] if element_requirements.has_key?('exists?')
+
+          modified_requirements['exists?'] = exists
+          element_requirements.each { |key, value|
+            next if key == 'exists?'
+            modified_requirements[key] = value
+          }
+        else
+          modified_requirements = element_requirements
+        end
+
+        modified_requirements.each { |requirement, value|
+          requirement_symbol = requirement.to_s.to_sym
+
+          unless self.send(element_class_symbol).respond_to?(requirement_symbol)
+            raise ArgumentError, "Element (#{element_name}) in screen (#{self.screen_name}) does not have the method (#{requirement_symbol})"
+          end
+
+          #If no element error thrown then return live? false
+          # instead of throwing it through the whole program
+          begin
+            success = (self.send(element_name).send(requirement_symbol) == value)
+          rescue Selenium::WebDriver::Error::NoSuchElementError
+            return false
+          end
+
+          unless success
+            self.reset_screen
+            return false
+          end
+        }
+      }
+
+      self.hook(configuration['after']) if configuration['after'].class == Hash
+
+      #Reset screen parts, except window handle
+      self.reset_screen(true)
+      true
+    end
+  end
+end

data/lib/automation_object/screen/screen_modal_helpers.rb

@@ -0,0 +1,101 @@
+module AutomationObject
+  module ScreenModalHelpers
+    def add_modals(params, configuration)
+      return unless configuration.class == Hash
+
+      configuration.each { |modal_name, modal_configuration|
+        modal_class_symbol = self.translate_string_to_class(modal_name)
+
+        setter = "#{modal_class_symbol}="
+        self.class.send(:attr_accessor, modal_class_symbol) unless respond_to?(setter)
+
+        params[:blue_prints] = modal_configuration
+        send setter, Modal.new(modal_name, params)
+
+        #Add emit listeners and relay from this screen out
+        #Add Listeners
+        this = self
+        self.send(modal_class_symbol).on :change_screen do |args|
+          this.emit :change_screen, {
+              :screen_class_symbol => args[:screen_class_symbol],
+              :created_window_handle => args[:created_window_handle]
+          }
+        end
+
+        self.send(modal_class_symbol).on :close_window do |args|
+          this.emit :close_window, {
+              :screen_name => args[:screen_name],
+              :skip_close => args[:skip_close]
+          }
+        end
+      }
+    end
+
+    #Todo: modify show modal to be on all possible element methods, also add stuff for hide modal
+    def route_to_modal(modal_requested)
+      AutomationObject::Logger::add('Trying to route to modal', [self.framework_location])
+
+      use_element = nil
+      #Loop through all the elements and try to find "show_modal"
+      self.configuration['elements'] = Hash.new unless self.configuration['elements'].class == Hash
+      self.configuration['elements'].each { |element_name, element_configuration|
+        next unless element_configuration.class == Hash
+        next unless element_configuration['click'].class == Hash
+        next unless element_configuration['click']['after'].class == Hash
+        next unless element_configuration['click']['after']['show_modal']
+        next unless element_configuration['click']['after']['show_modal'].to_s == modal_requested.to_s
+
+        use_element = element_name
+      }
+
+      unless use_element
+        raise "Unable to route to modal #{modal_requested} in screen #{self.screen_name}, no element in screen has show modal for the requested modal"
+      end
+
+      #Send the click request
+      self.send(use_element).click
+    end
+
+    def activate_modal(modal_requested)
+      self.active_modal = modal_requested
+      self.send(modal_requested).before_load #Run before_load event
+    end
+
+    def close_modal(modal_symbol)
+      unless self.active_modal == modal_symbol
+        raise "Expecting modal #{modal_symbol} to be active when requesting to close the modal."
+      end
+
+      modal_configuration = self.send(modal_symbol).configuration
+
+      unless modal_configuration.class == Hash
+        raise "Expecting modal #{modal_symbol} to have a Hash configuration, got: #{modal_configuration.class}"
+      end
+
+      unless modal_configuration['elements'].class == Hash
+        raise "Expecting modal #{modal_symbol} -> elements to have a Hash configuration, got: #{modal_configuration['elements'].class}"
+      end
+
+      modal_elements = modal_configuration['elements']
+      modal_elements.each { |modal_element, element_value|
+        next unless element_value.class == Hash
+
+        element_value.each { |property_key, property_value|
+          next unless property_value.class == Hash
+          next unless property_value['after'].class == Hash
+
+          property_value['after'].each { |hook_key, hook_value|
+            next unless hook_key == 'close_modal'
+            next unless hook_value == true
+
+            self.send(modal_symbol).send(modal_element).send(property_key)
+            return
+          }
+        }
+      }
+
+      raise "Unable to close modal #{modal_symbol}, no elements found that would close the modal"
+
+    end
+  end
+end

data/lib/automation_object/screen/screen_prompt_helpers.rb

@@ -0,0 +1,21 @@
+module AutomationObject
+  module ScreenPromptHelpers
+    include AutomationObject::HookHelpers
+
+    def accept
+      AutomationObject::Logger::add('Accepting Alert Prompt', [self.framework_location])
+
+      self.do_hook_action('accept', 'before')
+      self.driver_object.accept_prompt
+      self.do_hook_action('accept', 'after')
+    end
+
+    def dismiss
+      AutomationObject::Logger::add('Dismissing Alert Prompt', [self.framework_location])
+
+      self.do_hook_action('dismiss', 'before')
+      self.driver_object.dismiss_prompt
+      self.do_hook_action('dismiss', 'after')
+    end
+  end
+end