automation_object 0.0.4 → 0.5.0

data/lib/automation_object/screen/screen_hook_helpers.rb

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

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

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

data/lib/automation_object/screen/screen_window_helpers.rb

@@ -1,149 +0,0 @@
-module AutomationObject
-  module ScreenWindowHelpers
-    #in_iframe String, element_name that is the iframe
-    attr_accessor :in_iframe
-
-    def navigate_back
-      unless self.framework_object.screen_history_hash[self.window_handle].class == Array
-        raise ArgumentError, "Screen history hash doesn't contain window handle (#{self.window_handle}) for screen: #{self.screen_name}"
-      end
-
-      history_array = self.framework_object.screen_history_hash[self.window_handle]
-      unless history_array.length > 1
-        raise ArgumentError, 'Cannot navigate back in the current window, nothing to go back to'
-      end
-
-      #Remove last screen, which should be this one
-      history_array.pop
-      previous_screen_class = history_array.pop
-
-      self.driver_object.navigate.back
-
-      self.emit :change_screen, {
-          :screen_class_symbol => previous_screen_class
-      }
-    end
-
-    def close_window(skip_close = false)
-      self.emit :close_window, {
-          :screen_name => self.screen_name,
-          :skip_close => skip_close
-      }
-    end
-
-    def get_window_size
-      return self.driver_object.window_size if self.driver_object.respond_to?(:window_size)
-      return self.driver_object.manage.window.size
-    end
-
-    def set_window_size(x, y)
-      self.driver_object.manage.window.resize_to(x, y)
-    end
-
-    def set_window_location(x, y)
-      self.driver_object.manage.window.move_to(x, y)
-    end
-
-    def maximize_window
-      self.driver_object.manage.window.maximize
-    end
-
-    def current_url
-      return self.driver_object.current_url
-    end
-
-    def hide_keyboard(close_key = nil)
-      unless self.framework_object.is_mobile?
-        raise 'This is not implemented for Browsers'
-      end
-
-      self.driver_object.hide_keyboard(close_key)
-    end
-
-    def screenshot(path)
-      unless path.match(/\.png$/)
-        raise ArgumentError, 'Screenshot path must contain .png file extension'
-      end
-
-      return self.driver_object.screenshot(path)
-    end
-
-    def window_in_iframe?
-      return (self.in_iframe) ? true : false
-    end
-
-    def element_in_current_iframe?(element_name)
-      configuration = self.send(self.translate_string_to_class(element_name)).configuration
-
-      return false unless configuration.is_a?(Hash)
-      return false unless configuration.has_key?('in_iframe')
-
-      return (configuration['in_iframe'] == self.in_iframe)
-    end
-
-    def switch_to_default_content
-      return unless self.window_in_iframe?
-
-      AutomationObject::Logger::add('Switching from iframe to default content', {:screen_name => self.screen_name})
-
-      self.driver_object.switch_to.default_content
-      self.in_iframe = nil
-    end
-
-    def switch_to_iframe(element_name)
-      configuration = self.send(self.translate_string_to_class(element_name)).configuration
-      iframe_element_name = configuration['in_iframe']
-
-      unless iframe_element_name.class == String
-        raise ArgumentError, "Expected String for in_iframe property of element (#{element_name}), screen (#{self.screen_name})"
-      end
-
-      iframe_element_object = self.get_element_object(iframe_element_name)
-      iframe_element_object.scroll_to_view
-
-      AutomationObject::Logger::add('Switching from default content to iframe', [self.framework_location])
-      iframe_element_object.switch_to_iframe
-      self.in_iframe = iframe_element_name
-    end
-
-    def scroll_up
-      AutomationObject::Logger::add('Scrolling up', [self.framework_location])
-
-      self.do_hook_action('scroll_up', 'before')
-      driver_return = self.driver_object.execute_script('mobile: swipe', startX: 0.5, startY: 0.2, endX: 0.5, endY: 0.8, duration: 0.1)
-      self.do_hook_action('scroll_up', 'after')
-
-      return driver_return
-    end
-
-    def scroll_down
-      AutomationObject::Logger::add('Scrolling down', [self.framework_location])
-
-      self.do_hook_action('scroll_down', 'before')
-      driver_return = self.driver_object.execute_script('mobile: swipe', startX: 0.5, startY: 0.8, endX: 0.5, endY: 0.2, duration: 0.1)
-      self.do_hook_action('scroll_down', 'after')
-
-      return driver_return
-    end
-
-    def scroll_left
-      AutomationObject::Logger::add('Scrolling left', [self.framework_location])
-
-      self.do_hook_action('scroll_left', 'before')
-      driver_return = self.driver_object.execute_script('mobile: swipe', startX: 0.8, startY: 0.5, endX: 0.2, endY: 0.5, duration: 0.1)
-      self.do_hook_action('scroll_left', 'after')
-
-      return driver_return
-    end
-
-    def scroll_right
-      AutomationObject::Logger::add('Scrolling right', [self.framework_location])
-
-      self.do_hook_action('scroll_right', 'before')
-      driver_return = self.driver_object.execute_script('mobile: swipe', startX: 0.2, startY: 0.5, endX: 0.8, endY: 0.5, duration: 0.1)
-      self.do_hook_action('scroll_right', 'after')
-
-      return driver_return
-    end
-  end
-end