automation_object 0.0.4 → 0.5.0

data/lib/automation_object/blue_print/hash_adapter/custom_method.rb

@@ -0,0 +1,30 @@
+#Require parent class
+require_relative 'composite'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Custom method composite
+      class CustomMethod < Composite
+        #Validations
+        validates :element_method, instance_of: [String, Symbol], presence_of: true
+        validates :evaluate, instance_of: [String], presence_of: true
+
+        def element_method
+          element_method = self.hash[:element_method]
+
+          case element_method
+            when Symbol, String
+              return element_method.to_sym
+            else
+              return nil
+          end
+        end
+
+        def evaluate
+          return self.hash[:evaluate] ||= nil
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/element.rb

@@ -0,0 +1,34 @@
+#Require parent class
+require_relative 'composite'
+
+#Require child classes
+require_relative 'hook'
+require_relative 'custom_method'
+
+#Require helpers
+require_relative 'helpers/element_helper'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Element composite
+      class Element < Composite
+        include ElementHelper
+
+        before_create :method_hooks
+
+        #Relationships
+        has_one :load, interface: Hook
+        has_many :custom_methods, interface: CustomMethod
+
+        #Validations
+        validates :load, instance_of: Hash
+        validates :custom_methods, instance_of: Hash
+
+        validates :in_iframe, instance_of: String, element_presence_of: true
+        validates :css, instance_of: String, presence_of: {:unless_presence_of => :xpath}
+        validates :xpath, instance_of: String, presence_of: {:unless_presence_of => :css}
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/element_array.rb

@@ -0,0 +1,36 @@
+#Require parent class
+require_relative 'composite'
+
+#Require child classes
+require_relative 'hook'
+require_relative 'custom_method'
+
+#Require helpers
+require_relative 'helpers/element_helper'
+require_relative 'helpers/multiple_elements_helper'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Element array composite
+      class ElementArray < Composite
+        include ElementHelper
+        include MultipleElementsHelper
+
+        before_create :method_hooks
+
+        #Relationships
+        has_one :load, interface: Hook
+        has_many :custom_methods, interface: CustomMethod
+
+        #Validations
+        validates :load, instance_of: Hash
+        validates :custom_range, instance_of: [Hash, String]
+        validates :in_iframe, instance_of: String, element_presence_of: true
+        validates :custom_methods, instance_of: Hash
+        validates :css, instance_of: String, presence_of: {:unless_presence_of => :xpath}
+        validates :xpath, instance_of: String, presence_of: {:unless_presence_of => :css}
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/element_hash.rb

@@ -0,0 +1,43 @@
+#Require parent class
+require_relative 'composite'
+
+#Require child classes
+require_relative 'hook'
+require_relative 'custom_method'
+
+#Require helpers
+require_relative 'helpers/element_helper'
+require_relative 'helpers/multiple_elements_helper'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Element hash composite
+      class ElementHash < Composite
+        include ElementHelper
+        include MultipleElementsHelper
+
+        before_create :method_hooks
+
+        #Relationships
+        has_one :load, interface: Hook
+        has_many :custom_methods, interface: CustomMethod
+
+        #Validations
+        validates :load, instance_of: Hash
+
+        validates :define_elements_by, instance_of: [String, Symbol], presence_of: true
+        validates :custom_range, instance_of: [Hash, String]
+        validates :in_iframe, instance_of: String, element_presence_of: true
+        validates :custom_methods, instance_of: Hash
+        validates :css, instance_of: String, presence_of: {:unless_presence_of => :xpath}
+        validates :xpath, instance_of: String, presence_of: {:unless_presence_of => :css}
+
+        # @return [Symbol] element method to define element keys by
+        def define_elements_by
+          return self.hash[:define_elements_by].to_sym
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/element_helper.rb

@@ -0,0 +1,59 @@
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Helper module for Element composite classes
+      module ElementHelper
+        # @return [Array<Symbol, String>, nil] params as an array for driver find_element args
+        def selector_params
+          case
+            when self.hash[:xpath].is_a?(String)
+              [:xpath, self.hash[:xpath]]
+            when self.hash[:css].is_a?(String)
+              [:css, self.hash[:css]]
+            else
+              nil
+          end
+        end
+
+        # @return [Symbol, nil] element name of iframe element is in or nil if not
+        def in_iframe
+          case self.hash[:in_iframe]
+            when Symbol, String
+              self.hash[:in_iframe].to_sym
+            else
+              nil
+          end
+        end
+
+        # @return [Boolean] whether or not element is in iframe
+        def in_iframe?
+          (self.in_iframe) ? true : false
+        end
+
+        def method_hook?(name)
+          return self.method_hooks.has_key?(name)
+        end
+
+        # @return [Hash<Hook>] array of Hook that are defined under the element
+        def method_hooks
+          return @method_hooks if @method_hooks
+
+          children = {}
+          self.hash.each { |key, value|
+            #Skip possible keys that elements can have
+            #Otherwise should be a method hook
+            next if [:load, :custom_methods, :in_iframe, :css, :xpath, :define_elements_by, :custom_range].include?(key)
+            children[key] = value
+          }
+
+          @method_hooks = self.create_hash_children(children,
+                                                    {interface: Hook,
+                                                     location: self.location + '[hook]'})
+
+          return @method_hooks
+        end
+      end
+    end
+  end
+end
+

data/lib/automation_object/blue_print/hash_adapter/helpers/multiple_elements_helper.rb

@@ -0,0 +1,35 @@
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Helper module for multiple element composite classes
+      module MultipleElementsHelper
+        # @return [Range, nil] gives range for limiting multiple elements or nil
+        def custom_range
+          custom_range = self.hash[:custom_range]
+
+          case custom_range
+            when String
+              integer_array = custom_range.split('..').map { |number| Integer(number) }
+              return integer_array[0]..integer_array[1]
+            when Hash
+              return custom_range[:start].to_i..custom_range[:end].to_i
+          end
+
+          return nil
+        end
+
+        # @return [Symbol, nil] gives element method to remove duplicates on or nil
+        def remove_duplicates
+          remove_duplicates = self.hash[:remove_duplicates]
+
+          case remove_duplicates
+            when Symbol, String
+              return remove_duplicates.to_sym
+            else
+              return nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validation_error.rb

@@ -0,0 +1,26 @@
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #ValidatorError exception class
+      #Allows for multiple errors at one time to allow for better debugging
+      class ValidationError < Exception
+        attr_accessor :errors
+
+        # @param errors [Array, String] pass validation error(s) in, class can handle singular or multiple
+        def initialize(errors)
+          @errors = (errors.is_a?(Array)) ? errors : [errors]
+        end
+
+        # @return [String] returns full error message
+        def message
+          message = "\nBluePrint::HashAdapter composite validation failed for the following errors:\n"
+          @errors.each { |error|
+            message << "     - #{error}\n"
+          }
+
+          return message + "\n"
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validation_helper.rb

@@ -0,0 +1,99 @@
+#Require all the validators
+require_relative 'validators/validate_instance_of'
+require_relative 'validators/validate_allowed_keys'
+require_relative 'validators/validate_screen_presence_of'
+require_relative 'validators/validate_modal_presence_of'
+require_relative 'validators/validate_view_presence_of'
+require_relative 'validators/validate_element_presence_of'
+require_relative 'validators/validate_presence_of'
+
+require_relative '../../../helpers/string'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Validation helper for the composite structure, will allow Rails style validations on the composite
+      module ValidationHelper
+        attr_accessor :errors
+
+        # Give errors a default empty Array
+        # @return [Array<String>] errors messages
+        def errors
+          @errors ||= Array.new
+        end
+
+        # Give errors a default empty Array
+        # @params [Array<String>] error messages
+        # @return [Array<String>] error messages
+        def add_errors(errors)
+          self.errors += errors
+        end
+
+        # @return [Boolean] composite valid?
+        def valid?
+          return true if self.class.skip_validations
+
+         # ap self.class
+          #ap self.class.name
+          self.class.validations.collect do |validation|
+           # ap validation.class.name
+          end
+
+          self.class.validations.collect do |validation|
+            validation.validate(self)
+            unless validation.valid?
+              self.add_errors(validation.error_messages)
+            end
+          end
+
+          return self.errors.empty?
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        #Class level methods
+        module ClassMethods
+          def skip_validations=(boolean)
+            @skip_validations = boolean
+          end
+
+          def skip_validations
+            @skip_validations ||= false
+          end
+
+          # @param key [Symbol] hash key to test
+          # @param args [Hash] arguments for validation
+          # @return [nil]
+          def validates(key, args = {})
+            # ap self
+            # ap self.class.name
+            # ap key
+            # ap args
+
+
+            args.each { |validator_name, validation_args|
+              validator_name = 'Validate' + validator_name.to_s.pascalize
+              validator = Validators.const_get(validator_name)
+
+              self.validations.push(validator.new({:key => key, :args => validation_args}))
+            }
+          end
+
+          # @param args [Hash] arguments for validation
+          # @return [nil]
+          def validates_keys(args = {})
+            self.validations.push(Validators::ValidateAllowedKeys.new(args))
+          end
+
+          # @return [Array] list of Validators, default to empty list
+          def validations
+            @validations = [] unless @validations
+            return @validations
+          end
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate.rb

@@ -0,0 +1,23 @@
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      module Validators
+        #Super-class for validators, contains base functionality
+        #Sub-classes must implement validate for the composite
+        class Validate
+          attr_accessor :error_messages
+
+          # @return [Array<String>] array of error messages, default empty array
+          def error_messages
+            @error_messages ||= Array.new
+          end
+
+          # @return [Boolean] whether or not validation passed or failed
+          def valid?
+            return (self.error_messages.length == 0) ? true : false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_allowed_keys.rb

@@ -0,0 +1,31 @@
+require_relative 'validate'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      module Validators
+        #Validator that tests the composite hash for bad keys
+        class ValidateAllowedKeys < Validate
+          # @param args [Hash] arguments for the validation class
+          def initialize(args)
+            @allowed_keys = args.fetch :allowed_keys
+          end
+
+          # Validates the composite object and throws errors on failure
+          # @param composite_object [Object] Composite object to be tested.
+          # @return [nil] no return on exceptions on failure
+          def validate(composite_object)
+            #Get the hash from the composite object
+            target_hash = composite_object.hash
+
+            target_hash.each_key { |key|
+              unless @allowed_keys.include?(key)
+                self.error_messages.push("Invalid Key: #{key}, at: #{composite_object.location}. Allowed keys: #{@allowed_keys}.")
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_element_presence_of.rb

@@ -0,0 +1,55 @@
+require_relative 'validate'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      module Validators
+        #Validator that tests that a element is defined when it is called elsewhere through a hook
+        class ValidateElementPresenceOf < Validate
+          # @param args [Hash] arguments for the validation class
+          def initialize(args)
+            @key = args.fetch :key
+          end
+
+          # Validates the composite object and throws errors on failure
+          # @param composite_object [Object] Composite object to be tested.
+          # @return [nil] no return on exceptions on failure
+          def validate(composite_object)
+            #Get the hash value from the composite object
+            target_value = composite_object.hash[@key]
+
+            return unless target_value
+
+            target_values = (target_value.is_a?(Array)) ? target_value : [target_value]
+
+            valid_elements = self.find_elements(composite_object)
+
+            target_values.each { |element|
+              element = element.to_sym
+              next if valid_elements.include?(element)
+
+              error_message = "Invalid Element: #{element}, at: #{composite_object.location}[#{@key}]."
+              error_message << " Valid Elements(s): #{valid_elements}"
+              self.error_messages.push(error_message)
+            }
+          end
+
+          #Traverses up a composite tree to find :elements in a hash
+          # @param composite_object [Object] composite object to traverse up
+          # @return [Array<Symbol>] array of element names
+          def find_elements(composite_object)
+            #Using the hash instead of the method because lower nodes will get validated
+            #before composite is finished building
+            if composite_object.hash[:elements].is_a?(Hash)
+              return composite_object.hash[:elements].keys #Should be Hash with element names as the keys
+            elsif composite_object.parent
+              return self.find_elements(composite_object.parent)
+            end
+
+            return []
+          end
+        end
+      end
+    end
+  end
+end