automation_object 0.0.4 → 0.5.0

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

@@ -0,0 +1,52 @@
+#Require parent class
+require_relative 'composite'
+
+#Require child classes
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+require_relative 'hook'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Modal-level composite, ActiveRecord style composite implementation inheriting from Composite
+      class Modal < Composite
+        #Relationships
+        has_one :load, interface: Hook
+
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+
+        #Validations
+        validates_keys allowed_keys: [:load, :elements, :element_arrays, :element_hashes]
+
+        validates :load, instance_of: Hash
+        validates :elements, instance_of: Hash
+        validates :element_arrays, instance_of: Hash
+        validates :element_hashes, instance_of: Hash
+
+        # @return [Array<Symbol>] array of views this can has
+        def included_views
+          included_views_array = self.hash[:included_views] ||= Array.new
+          included_views_array.map { |view| view.to_sym }
+        end
+
+        #Method to take views and merge into this composite
+        def merge_views
+          top_hash = self.top.hash
+
+          return unless top_hash.is_a?(Hash)
+          return unless top_hash[:views].is_a?(Hash)
+          top_view_hash = top_hash[:views]
+
+          self.included_views.each { |included_view|
+            next unless top_view_hash[included_view].is_a?(Hash)
+            self.hash = self.hash.deep_merge(top_view_hash[included_view])
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+#Require parent class
+require_relative 'composite'
+
+#Require child classes
+require_relative 'automatic_onload_modal'
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+require_relative 'hook'
+require_relative 'modal'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Screen-level composite, ActiveRecord style composite implementation inheriting from Composite
+      class Screen < Composite
+        #Creation hooks
+        before_create :merge_views
+        before_create :automatic_onload_modals
+
+        #Relationships
+        has_one :load, interface: Hook
+        has_one :accept, interface: Hook
+        has_one :dismiss, interface: Hook
+
+        has_many :modals, interface: Modal
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+
+        #Validations
+        validates_keys allowed_keys: [:automatic_onload_modals, :automatic_screen_changes, :elements,
+                                      :element_arrays, :element_hashes, :included_views, :load, :modals]
+
+        validates :automatic_onload_modals, instance_of: Array, modal_presence_of: true
+        validates :automatic_screen_changes, instance_of: Array, screen_presence_of: true
+
+        validates :elements, instance_of: Hash
+        validates :element_arrays, instance_of: Hash
+        validates :element_hashes, instance_of: Hash
+
+        validates :included_views, instance_of: Array, view_presence_of: true
+
+        validates :load, instance_of: Hash
+        validates :accept, instance_of: Hash
+        validates :dismiss, instance_of: Hash
+
+        validates :modals, instance_of: Hash
+
+        # @return [Array<AutomaticOnloadModal>] array of AutomaticOnloadModal that are defined under the screen
+        def automatic_onload_modals
+          return @automatic_onload_modals if @automatic_onload_modals
+
+          children = self.hash[:automatic_onload_modals]
+          children = (children.is_a?(Array)) ? children : Array.new
+          @automatic_onload_modals = self.create_array_children(:automatic_onload_modals, children,
+                                                                {interface: AutomaticOnloadModal,
+                                                                 location: self.location + '[automatic_onload_modals]'})
+
+          return @automatic_onload_modals
+        end
+
+        # @return [Array<Symbol>] array of screens where screen can automatically change to
+        def automatic_screen_changes
+          screen_array = self.hash[:automatic_screen_changes] ||= Array.new
+          screen_array.map { |screen| screen.to_sym }
+        end
+
+        # @return [Array<Symbol>] array of views this can has
+        def included_views
+          included_views_array = self.hash[:included_views] ||= Array.new
+          included_views_array.map { |view| view.to_sym }
+        end
+
+        #Method to take views and merge into this composite
+        def merge_views
+          top_hash = self.top.hash
+
+          return unless top_hash.is_a?(Hash)
+          return unless top_hash[:views].is_a?(Hash)
+          top_view_hash = top_hash[:views]
+
+          self.included_views.each { |included_view|
+            next unless top_view_hash[included_view].is_a?(Hash)
+            self.hash = self.hash.deep_merge(top_view_hash[included_view])
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+#Require parent class
+require_relative 'composite'
+
+#Require child classes
+require_relative 'screen'
+require_relative 'view'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Top composite
+      class Top < Composite
+        #Relationships
+        has_many :screens, interface: Screen
+        has_many :views, interface: View
+
+        #Validations
+        validates_keys allowed_keys: [:base_url, :default_screen, :screen_transition_sleep, :screens,
+                                      :throttle_driver_methods, :throttle_element_methods, :views]
+
+        validates :base_url, instance_of: String
+        validates :default_screen, instance_of: [Symbol, String], screen_presence_of: true
+        validates :screen_transition_sleep, instance_of: Numeric
+        validates :screens, instance_of: Hash
+        validates :throttle_driver_methods, instance_of: Hash
+        validates :throttle_element_methods, instance_of: Hash
+        validates :views, instance_of: Hash
+
+        # @return [String, nil] base url to navigate to upon framework creation
+        def base_url
+          self.hash[:base_url] ||= nil
+        end
+
+        # @return [Symbol, nil] default screen to be set when framework is created
+        def default_screen
+          default_screen = self.hash[:default_screen]
+
+          case default_screen
+            when Symbol, String
+              return default_screen.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Numeric] sleep when transitioning screens
+        def screen_transition_sleep
+          self.hash[:screen_transition_sleep] ||= 0
+        end
+
+        # @return [Hash] driver methods to throttle
+        def throttle_driver_methods
+          self.hash[:throttle_driver_methods] ||= Hash.new
+        end
+
+        # @return [Hash] element methods to throttle
+        def throttle_element_methods
+          self.hash[:throttle_element_methods] ||= Hash.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+#Require parent class
+require_relative 'composite'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #View composite
+      class View < Composite
+        #Validations
+        validates_keys allowed_keys: [:automatic_onload_modals, :automatic_screen_changes, :elements, :element_arrays,
+                                      :element_groups, :element_hashes, :included_views, :load, :modals]
+
+        validates :automatic_onload_modals, instance_of: Array, modal_presence_of: true
+        validates :automatic_screen_changes, instance_of: Array, screen_presence_of: true
+
+        validates :elements, instance_of: Hash
+        validates :element_arrays, instance_of: Hash
+        validates :element_groups, instance_of: Hash
+        validates :element_hashes, instance_of: Hash
+
+        validates :included_views, instance_of: Array, view_presence_of: true
+
+        validates :load, instance_of: Hash
+
+        validates :modals, instance_of: Hash
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/helpers/file_helper.rb

@@ -0,0 +1,38 @@
+module AutomationObject::BluePrint
+  #Collect files in directory recursively and return Array
+  module FileHelper
+    # @param path [String] specified directory path for getting files underneath
+    # @returns [Array] list of file paths that exist recursively underneath a directory
+    def collect_files(path)
+      unless File.exists?(path)
+        raise "Expecting path to exist, got #{path}"
+      end
+
+      if File.directory?(path)
+        @file_array = Array.new
+        self.recursive_collection(path)
+      else
+        @file_array = [path]
+      end
+
+      @file_array
+    end
+
+    protected
+
+    # Use for recursive collection of files
+    # @param path [String] specified directory path for getting files underneath
+    def recursive_collection(path)
+      Dir.foreach(path) do |item|
+        next if item == '.' or item == '..'
+
+        file_path = File.join(path, "#{item}")
+        if File.directory?(file_path)
+          self.recursive_collection(file_path)
+        else
+          @file_array.push(file_path)
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/yaml_adapter.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+
+require_relative '../blue_print'
+require_relative 'hash_adapter'
+require_relative 'helpers/file_helper'
+
+module AutomationObject::BluePrint
+  #BluePrint YAML Adapter
+  module YamlAdapter
+    extend self
+    extend FileHelper
+
+    # @param path [String] path to YAML directory
+    # @return [AutomationObject::BluePrint::Composite::Top] Composite BluePrint Object
+    def build(path = '')
+      path = File.expand_path(path)
+
+      file_array = self.collect_files(path)
+      merged_yaml_hash = self.load_yaml_files(file_array)
+
+      return AutomationObject::BluePrint::HashAdapter.build(merged_yaml_hash)
+    end
+
+    # @param file_array [Array<String>] array of file paths to load
+    # @return [Hash] merged YAML Hash
+    def load_yaml_files(file_array)
+      merged_yaml_hash = Hash.new
+
+      file_array.each { |file_path|
+        next unless self.is_yaml_file?(file_path)
+
+        file_hash = YAML.load_file(file_path)
+
+        unless file_hash.is_a?(Hash)
+          raise "Expecting file #{file_path} to be a hash when loaded"
+        end
+
+        merged_yaml_hash = merged_yaml_hash.deep_merge(file_hash)
+      }
+
+      return merged_yaml_hash
+    end
+
+    # @param file_path [String] file path
+    # @return [Boolean] whether or not it is a YAML file
+    def is_yaml_file?(file_path)
+      return (file_path.match(/\.ya?ml$/)) ? true : false
+    end
+  end
+end

data/lib/automation_object/driver.rb

@@ -0,0 +1,44 @@
+require_relative 'helpers/string'
+
+require_relative 'proxies/throttle_proxy'
+require_relative 'proxies/mutex_proxy'
+
+require_relative 'driver/driver'
+
+#Adapters
+require_relative 'driver/appium_adapter/driver'
+require_relative 'driver/nokogiri_adapter/driver'
+require_relative 'driver/selenium_adapter/driver'
+
+module AutomationObject
+  #Driver Port
+  module Driver
+    extend self
+
+    def adapter
+      return @adapter if @adapter
+      self.adapter = :nokogiri
+      @adapter
+    end
+
+    # Sets adapter const will append _adapter if needed
+    # @param adapter_name [String] name of adapter wanted for composite creation
+    def adapter=(adapter_name)
+      adapter_name = adapter_name.to_s
+      adapter_name << '_adapter' unless adapter_name.match(/_adapter$/)
+      adapter_const = adapter_name.pascalize
+
+      @adapter = AutomationObject::Driver.const_get("#{adapter_const}")
+    end
+
+    # @param driver [Object] selenium or appium driver. default nil for Nokogiri
+    # @return [AutomationObject::Driver::Driver]
+    def new(driver = nil)
+      adapted_driver = Driver.new(self.adapter.new(driver))
+
+      #Add throttling and mutex proxies around adapter
+      return AutomationObject::Proxies::MutexProxy.new(
+                    AutomationObject::Proxies::ThrottleProxy.new(adapted_driver))
+    end
+  end
+end

data/lib/automation_object/driver/appium_adapter/driver.rb

@@ -0,0 +1,150 @@
+require 'appium_lib'
+
+require_relative '../../proxies/proxy'
+require_relative '../helpers/selenium_driver_helper'
+
+require_relative '../element'
+require_relative 'element'
+
+module AutomationObject
+  module Driver
+    module AppiumAdapter
+      #Driver proxy for Appium
+      #Conform Appium driver interface to what's expected of the Driver Port
+      class Driver < AutomationObject::Proxies::Proxy
+        include AutomationObject::Driver::SeleniumDriverHelper
+
+        # @param driver [Appium::Driver] Appium Driver
+        def initialize(driver)
+          @subject = driver
+        end
+
+        # Navigates current window to a given url
+        # @param url [String] navigate to the following url
+        # @return [void]
+        def get(url)
+          @subject.get(url)
+        end
+
+        # @param script [String] JS to run
+        # @return [Object, nil]
+        def execute_script(script)
+          @subject.execute_script(script)
+        end
+
+        #Set timeout wait
+        # @param timeout [Integer] the timeout in seconds
+        # @return [void]
+        def set_wait(timeout = nil)
+          @subject.set_wait(timeout)
+        end
+
+        # @param selector_type [Symbol] selector type (:css, :xpath, etc...)
+        # @param selector_path [String] path to element
+        # @return [Boolean] exists or not
+        def exists?(selector_type, selector_path)
+          return @subject.exists { @subject.find_element(selector_type, selector_path) }
+        end
+
+        # @param selector_type [Symbol] selector type, :css, :xpath, etc...
+        # @param selector_path [String] path to element
+        # @return [AutomationObject::Driver::Element] element
+        def find_element(selector_type, selector_path)
+          element = @subject.find_element(selector_type, selector_path)
+          #Wrap element in the adapter interface
+          return AutomationObject::Driver::Element.new(Element.new(driver: self, element: element))
+        end
+
+        # @param selector_type [Symbol] selector type, :css, :xpath, etc...
+        # @param selector_path [String] path to element
+        # @return [Array<AutomationObject::Driver::Element>] element
+        def find_elements(selector_type, selector_path)
+          elements = @subject.find_elements(selector_type, selector_path)
+
+          elements.map { |element|
+            #Wrap element in the adapter interface
+            AutomationObject::Driver::Element.new(Element.new(driver: self, element: element))
+          }
+        end
+
+        # @return [void]
+        def accept_prompt
+          @subject.alert_accept
+        end
+
+        # @return [void]
+        def dismiss_prompt
+          @subject.alert_dismiss
+        end
+
+        # @return [Boolean] whether or not browser is being used
+        def is_browser?
+          return @is_browser unless @is_browser == nil
+          @is_browser = false
+
+          #Now we need to check Appium's contexts to see if WEBVIEW is in available_contexts
+          available_contexts = @subject.available_contexts
+          available_contexts.each { |context|
+            if context.match(/^WEBVIEW_\d+$/)
+              @is_browser = true
+              break
+            end
+          }
+
+          return @is_browser
+        end
+
+        #Window Handles Override
+        # @return [Array<String>] array of window handles
+        def window_handles
+          if @subject.device_is_android? and self.is_browser?
+            window_handles = @subject.window_handles
+          else
+            return @subject.available_contexts unless self.is_browser?
+
+            window_handles = []
+            @subject.available_contexts.each { |context|
+              window_handles.push(context) if context.match(/^WEBVIEW_\d+$/)
+            }
+          end
+
+          return window_handles
+        end
+
+        #Get window handle override
+        # @return [String] current window handle
+        def window_handle
+          return @subject.current_context unless self.is_browser?
+
+          if @subject.device_is_android?
+            return @subject.window_handle
+          else
+            return @subject.current_context
+          end
+        end
+
+        #Set window handle override
+        # @param handle_value [String] window handle value
+        # @return [void]
+        def window_handle=(handle_value)
+          if @subject.device_is_android?
+            @subject.switch_to.window(handle_value)
+          else
+            @subject.set_context(handle_value)
+          end
+        end
+
+        # @return [Boolean] document is complete
+        def document_complete?
+          return true unless self.is_browser? #Skip for non-browser Appium sessions
+          return @subject.execute_script('return document.readyState;') == 'complete'
+        end
+
+        # @return [void]
+        def quit
+          @subject.driver_quit
+        end
+      end
+    end
+  end
+end