automation_object 0.0.4 → 0.5.0

data/lib/automation_object/blue_print_validation/key_value_constants.rb

@@ -1,75 +0,0 @@
-module AutomationObject
-  module BluePrintValidation
-    module KeyValueConstants
-      ELEMENT_KEYS = ['length', 'exists?', 'click', 'visible?', 'invisible?',
-                      'id', 'href', 'scroll_to_view', 'x', 'y', 'width', 'height', 'drag_to_element',
-                      'get_element_center', 'name', 'value', 'type', 'clear', 'tag_name', 'text',
-                      'size', 'location', 'rel_location', 'send_keys', 'set_value', 'displayed?', 'selected?',
-                      'attribute', 'clear', 'attribute', 'click', 'css_value', 'displayed?', 'enabled?',
-                      'location', 'location_once_scrolled_into_view', 'ref', 'selected?', 'send_keys',
-                      'size', 'submit', 'tag_name', 'text', 'content']
-
-      HOOK_KEYS = ['live?', 'before_load', 'accept', 'dismiss', 'scroll_up', 'scroll_down', 'scroll_right', 'scroll_left']
-
-      BASE_PAIR_TYPES = {
-          'base_url' => String,
-          'default_screen' => String,
-          'throttle_element_interactions' => Hash,
-          'throttle_element_methods' => Hash,
-          'throttle_driver_methods' => Hash,
-          'screen_transition_sleep' => Numeric,
-          'views' => Hash,
-          'screens' => Hash
-      }
-
-      THROTTLE_ELEMENT_PAIR_TYPES = Hash[*ELEMENT_KEYS.collect { |v| [v, Numeric] }.flatten]
-
-      SCREEN_PAIR_TYPES = {
-          'modals' => Hash,
-          'included_views' => Array,
-          'automatic_screen_changes' => Array,
-          'elements' => Hash,
-          'element_groups' => Hash
-      }.merge(Hash[*HOOK_KEYS.collect { |v| [v, Hash] }.flatten])
-
-      MODAL_PAIR_TYPES = SCREEN_PAIR_TYPES
-
-      ELEMENT_PAIR_TYPES = {
-          'in_iframe' => String,
-          'css' => String,
-          'xpath' => String,
-          'multiple' => TrueClass,
-          'multiple_ios_fix' => TrueClass,
-          'define_elements_by' => String,
-          'custom_methods' => Hash,
-          'custom_range' => Hash,
-          'remove_duplicates' => String
-      }.merge(Hash[*ELEMENT_KEYS.collect { |v| [v, Hash] }.flatten])
-
-      ELEMENT_CUSTOM_METHOD_PAIR_TYPES = {
-          'element_method' => String,
-          'evaluate' => String
-      }
-
-      HOOK_PAIR_TYPES = {
-          'before' => Hash,
-          'after' => Hash,
-          'elements' => Array
-      }
-
-      HOOK_ACTION_PAIR_TYPES = {
-          'wait_for_new_window' => TrueClass,
-          'show_modal' => String,
-          'close_window' => TrueClass,
-          'change_screen' => String,
-          'sleep' => Numeric,
-          'wait_for_elements' => Array,
-          'change_to_previous_screen' => TrueClass,
-          'close_modal' => TrueClass,
-          'automatic_onload_modals' => Array,
-          'reset_screen' => TrueClass,
-          'possible_screen_changes' => Array
-      }
-    end
-  end
-end

data/lib/automation_object/blue_print_validation/modal_validation.rb

@@ -1,37 +0,0 @@
-module AutomationObject
-  module BluePrintValidation
-    module ModalValidation
-      include ScreenModalCommonMethods
-
-      def validate_modals
-        error_messages = Array.new
-
-        self.get_all_modals.each { |modal|
-          error_messages += self.validate_screen_modal(modal[:screen_name], modal[:modal_name], modal[:configuration])
-        }
-
-        return error_messages
-      end
-
-      def get_all_modals
-        modals = Array.new
-        return modals unless self.has_key?('screens')
-        return modals unless self['screens'].class == Hash
-
-        self['screens'].each { |screen_name, screen_configuration|
-          next unless screen_configuration.class == Hash
-          next unless screen_configuration.has_key?('modals')
-          next unless screen_configuration['modals'].class == Hash
-
-          screen_configuration['modals'].each { |modal_name, modal_configuration|
-            next if modal_configuration == nil
-            modal = {:screen_name => screen_name, :modal_name => modal_name, :configuration => modal_configuration}
-            modals.push(modal)
-          }
-        }
-
-        return modals
-      end
-    end
-  end
-end

data/lib/automation_object/blue_print_validation/screen_modal_common_methods.rb

@@ -1,119 +0,0 @@
-module AutomationObject
-  module BluePrintValidation
-    module ScreenModalCommonMethods
-      def validate_screen_modal(screen_name, modal_name = false, configuration)
-        error_messages = Array.new
-
-        if modal_name == false #Skip multiple errors
-          unless screen_name.is_a?(String)
-            error_message = "(screens) level key (#{screen_name}) is an invalid key type, expecting: ("
-            error_message << String.to_s
-            error_message << "), got: (#{screen_name.class.to_s})"
-            error_messages.push(FormattedErrors::format_message(error_message))
-          end
-        else
-          unless modal_name.is_a?(String)
-            error_message = "(screens/#{screen_name}/modals) level key (#{modal_name}) is an invalid key type, expecting: ("
-            error_message << String.to_s
-            error_message << "), got: (#{modal_name.class.to_s})"
-            error_messages.push(FormattedErrors::format_message(error_message))
-          end
-        end
-
-        return error_messages if configuration == nil
-
-        unless configuration.is_a?(Hash)
-          if modal_name == false
-            error_message = "(screens) level key (#{screen_name}) has an invalid value type, expecting: ("
-          else
-            error_message = "(screens/#{screen_name}/modals) level key (#{modal_name}) has an invalid value type, expecting: ("
-          end
-
-          error_message << Hash.to_s
-          error_message << "), got: (#{configuration.class.to_s})"
-          error_messages.push(FormattedErrors::format_message(error_message))
-
-          return error_messages
-        end
-
-        configuration.each { |sub_screen_key, sub_screen_value|
-          #Check if valid screen keys
-          unless KeyValueConstants::SCREEN_PAIR_TYPES.keys.include?(sub_screen_key)
-            if modal_name == false
-              error_message = "(screens) level key (#{screen_name}) sub key (#{sub_screen_key}) "
-            else
-              error_message = "(screens/#{screen_name}/modals) level key (#{modal_name}) sub key (#{sub_screen_key}) "
-            end
-
-            error_message << 'is not a valid key, available (screens) sub level keys ('
-            error_message << KeyValueConstants::SCREEN_PAIR_TYPES.keys.join(', ').to_s + ')'
-            error_messages.push(FormattedErrors::format_message(error_message))
-
-            next #skip if not a valid key since we are not going to check value
-          end
-
-          #Skip checking if nil, being nice
-          next if sub_screen_value == nil
-
-          #Check sub screen value
-          unless sub_screen_value.is_a?(KeyValueConstants::SCREEN_PAIR_TYPES[sub_screen_key])
-            if modal_name == false
-              error_message = "(screens) level key (#{screen_name}) sub key (#{sub_screen_key}) "
-            else
-              error_message = "(screens/#{screen_name}/modals) level key (#{screen_name}) sub key (#{sub_screen_key}) "
-            end
-
-            error_message << 'has an invalid value type, expected: ('
-            error_message << KeyValueConstants::SCREEN_PAIR_TYPES[sub_screen_key].to_s
-            error_message << "), got: (#{sub_screen_value.class.to_s})"
-            error_messages.push(FormattedErrors::format_message(error_message))
-
-            next #Skip any additional validation on this
-          end
-
-          #More complex validation
-          case sub_screen_key
-            when 'included_views'
-              sub_screen_value.each { |included_view|
-                unless self.view_exists?(included_view)
-                  if modal_name == false
-                    error_message = "(screens) level key (#{screen_name}) sub key (#{sub_screen_key}) "
-                  else
-                    error_message = "(screens/#{screen_name}/modals) level key (#{screen_name}) sub key (#{sub_screen_key}) "
-                  end
-
-                  error_message << "included_view (#{included_view}) does not exist. Available views ("
-                  error_message << self.get_views.join(', ')
-                  error_message << ')'
-                  error_messages.push(FormattedErrors::format_message(error_message))
-                end
-              }
-            when 'automatic_screen_changes'
-              sub_screen_value.each { |automatic_screen_change|
-                unless self.screen_exists?(automatic_screen_change)
-                  error_message = "(screens) level key (#{screen_name}) sub key (#{sub_screen_key}) "
-                  error_message << "screen (#{automatic_screen_change}) does not exist. Available screens ("
-                  error_message << self.get_screens.join(', ')
-                  error_message << ')'
-                  error_messages.push(FormattedErrors::format_message(error_message))
-
-                  next
-                end
-
-                unless self.screen_has_live?(automatic_screen_change)
-                  error_message = "(screens) level key (#{screen_name}) sub key (#{sub_screen_key}) "
-                  error_message << "screen (#{automatic_screen_change}) does not have live? configuration. "
-                  error_message << 'Automatic screen changes need to have associated live? configurations.'
-                  error_messages.push(FormattedErrors::format_message(error_message))
-
-                  next
-                end
-              }
-          end
-        }
-
-        return error_messages
-      end
-    end
-  end
-end

data/lib/automation_object/blue_print_validation/screen_validation.rb

@@ -1,21 +0,0 @@
-module AutomationObject
-  module BluePrintValidation
-    module ScreenValidation
-      include ScreenModalCommonMethods
-
-      def validate_screens
-        error_messages = Array.new
-        return error_messages unless self.has_key?('screens')
-        return error_messages unless self['screens'].class == Hash
-
-        error_messages = Array.new
-
-        self['screens'].each { |screen_name, screen_configuration|
-          error_messages += self.validate_screen_modal(screen_name, screen_configuration)
-        }
-
-        return error_messages
-      end
-    end
-  end
-end

data/lib/automation_object/blue_print_validation/validation_object.rb

@@ -1,32 +0,0 @@
-module AutomationObject
-  module BluePrintValidation
-    class ValidationObject < Hash
-      include CommonMethods
-      include BaseValidation
-      include ScreenValidation
-      include ModalValidation
-      include ElementValidation
-      include HookValidation
-
-      def initialize(blue_print_object)
-        #Figured on cloning the Hash Object, probably not needed
-        blue_print_object_cloned = blue_print_object.clone
-
-        blue_print_object_cloned.each { |key, value|
-          self[key] = value
-        }
-
-        error_messages = Array.new
-        error_messages += self.validate_base #BaseValidation Module
-        error_messages += self.validate_screens #ScreenValidation Module
-        error_messages += self.validate_modals
-        error_messages += self.validate_elements
-        error_messages += self.validate_hooks
-
-        if error_messages.length > 0
-          raise FormattedErrors::array_to_message(error_messages)
-        end
-      end
-    end
-  end
-end

data/lib/automation_object/driver/anonymous.rb

@@ -1,27 +0,0 @@
-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/element/element.rb

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