automation_object 0.0.4 → 0.5.0

data/lib/automation_object/driver/nokogiri_adapter/element.rb

@@ -0,0 +1,85 @@
+module AutomationObject
+  module Driver
+    module NokogiriAdapter
+      #Element for nokogiri
+      #Conforms to Element interface for an XML source using Nokogiri
+      class Element
+        # Set or Get attribute
+        # @param key [String] key of element
+        # @param value [String, nil] set value or leave blank
+        # @return [String, nil]
+        def attribute(key, value = nil)
+          self.adapter.attribute(key, value)
+        end
+
+        # @return [String] id of element
+        def id
+          self.adapter.id
+        end
+
+        # @return [String] href of element
+        def href
+          self.adapter.href
+        end
+
+        # Text of element
+        # @return [String, nil]
+        def text
+          self.adapter.text
+        end
+
+        # Type into an element
+        # @return [void]
+        def send_keys(string)
+          self.adapter.send_keys(string)
+        end
+
+        # Clear the element field
+        # @return [void]
+        def clear
+          self.adapter.clear
+        end
+
+        # @return [Boolean]
+        def visible?
+          self.adapter.visible?
+        end
+
+        # @return [Boolean]
+        def invisible?
+          self.adapter.invisible?
+        end
+
+        # Get the location
+        # @return [Point]
+        def location
+          self.adapter.location
+        end
+
+        # Get the size of an element
+        # @return [Dimension]
+        def size
+          self.adapter.size
+        end
+
+        # Perform a submit action on an element
+        # @return [void]
+        def submit
+          self.adapter.submit
+        end
+
+        # Scroll the element into view
+        # @return [void]
+        def scroll_into_view
+          self.adapter.scroll_into_view
+        end
+
+        # Perform a click action on the element
+        # @return [void]
+        def click
+          self.adapter.click
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/nokogiri_adapter/error.rb

@@ -0,0 +1,17 @@
+module AutomationObject
+  module Driver
+    #Emulate Selenium errors
+    #http://www.rubydoc.info/gems/selenium-webdriver/Selenium/WebDriver/Error
+    module NokogiriAdapter
+      #
+      class WebDriverError < StandardError;
+      end
+      class NoSuchElementError < WebDriverError;
+      end
+      class NoSuchWindowError < WebDriverError;
+      end
+      class NoSuchDocumentError < WebDriverError;
+      end
+    end
+  end
+end

data/lib/automation_object/driver/selenium_adapter/driver.rb

@@ -0,0 +1,143 @@
+require_relative '../../proxies/proxy'
+require_relative '../helpers/selenium_driver_helper'
+
+require_relative '../element'
+require_relative 'element'
+
+module AutomationObject
+  module Driver
+    module SeleniumAdapter
+      #Driver proxy for Selenium
+      #Conform Selenium driver interface to what's expected of the Driver Port
+      class Driver < AutomationObject::Proxies::Proxy
+        DOC_COMPLETE_SLEEP = 1
+
+        include AutomationObject::Driver::SeleniumDriverHelper
+
+        # @param driver [Selenium::WebDriver::Driver] Selenium Web 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.navigate.to(url)
+        end
+
+        # Set timeout wait
+        # @param timeout [Integer] the timeout in seconds
+        # @return [void]
+        def set_wait(timeout = nil)
+          timeout = 0 unless timeout
+          @subject.manage.timeouts.implicit_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)
+          exists = false
+
+          begin
+            original_timeout = @subject.manage.timeouts.implicit_wait
+            @subject.manage.timeouts.implicit_wait = 0
+            element_objects = @subject.find_elements(selector_type, selector_path)
+            @subject.manage.timeouts.implicit_wait = original_timeout
+            if element_objects.length > 0
+              exists = true
+            end
+          rescue Exception => e
+          end
+
+          return exists
+        end
+
+        # @param selector_type [Symbol] selector type, :css, :xpath, etc...
+        # @param selector_path [String] path to element
+        # @return [Object] element
+        def find_element(selector_type, selector_path)
+          element = @subject.find_element(selector_type, selector_path)
+          #Wrap in 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 [Object] element
+        def find_elements(selector_type, selector_path)
+          elements = @subject.find_elements(selector_type, selector_path)
+
+          elements.map { |element|
+            AutomationObject::Driver::Element.new(Element.new(driver: self, element: element))
+          }
+        end
+
+        #Accept prompt either in browser or mobile
+        def accept_prompt
+          alert = @subject.switch_to.alert
+          alert.accept
+          @subject.switch_to.default_content
+        end
+
+        #Dismiss the prompt
+        def dismiss_prompt
+          alert = @subject.switch_to.alert
+          alert.dismiss
+          @subject.switch_to.default_content
+        end
+
+        # Check if browser, more useful for Appium but can be generic here
+        # @return [Boolean] whether or not browser is being used
+        def is_browser?
+          true
+        end
+
+        #Window Handles
+        # @return [Array<String>] array of window handle ids
+        def window_handles
+          @subject.window_handles
+        end
+
+        #Current window handle
+        # @return [String] handle id
+        def window_handle
+          @subject.window_handle
+        end
+
+        #Set current window handle to, will switch windows
+        # @param handle_value [String] window handle value
+        def window_handle=(handle_value)
+          @subject.switch_to.window(handle_value)
+        end
+
+        # Run script in browser to check if document in JS is complete
+        # @return [Boolean] document is complete
+        def document_complete?
+          return @subject.execute_script('return document.readyState;') == 'complete'
+        end
+
+        # Wait till the document is complete
+        # @return [void]
+        def document_complete_wait
+          30.times do
+            sleep(DOC_COMPLETE_SLEEP)
+            break if self.document_complete?
+          end
+        end
+
+        # @param script [String] JS to run
+        # @return [Object, nil]
+        def execute_script(script)
+          @subject.execute_script(script)
+        end
+
+        # Destroy the driver
+        def quit
+          @subject.quit
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/selenium_adapter/element.rb

@@ -0,0 +1,116 @@
+require_relative '../helpers/selenium_element_helper'
+
+module AutomationObject
+  module Driver
+    module SeleniumAdapter
+      #Element proxy for Selenium
+      #Conform Selenium element interface to what's expected of the Driver Port
+      class Element < AutomationObject::Proxies::Proxy
+        include AutomationObject::Driver::SeleniumElementHelper
+
+        def initialize(args)
+          @driver = args.fetch :driver
+          @subject = args.fetch :element
+        end
+
+        # Set or Get attribute
+        # @param key [String] key of element
+        # @param value [String, nil] set value or leave blank
+        # @return [String, nil]
+        def attribute(key, value = nil)
+          @subject.attribute(key, value)
+        end
+
+        # @return [String] id of element
+        def id
+          @subject.id
+        end
+
+        # @return [String] href of element
+        def href
+          @subject.attribute('href')
+        end
+
+        # Text of element
+        # @return [String, nil]
+        def text
+          @subject.text
+        end
+
+        # Type into an element
+        # @return [void]
+        def send_keys(string)
+          @subject.send_keys(string)
+        end
+
+        # Clear the element field
+        # @return [void]
+        def clear
+          @subject.clear
+        end
+
+        # @return [Boolean]
+        def visible?
+          @subject.displayed?
+        end
+
+        # @return [Boolean]
+        def invisible?
+          !@subject.displayed?
+        end
+
+        # Get the location
+        # @return [Point]
+        def location
+          @subject.location
+        end
+
+        # Get the size of an element
+        # @return [Dimension]
+        def size
+          @subject.size
+        end
+
+        # Perform a submit action on an element
+        # @return [void]
+        def submit
+          @subject.submit
+        end
+
+        # Scroll the element into view
+        # @return [void]
+        def scroll_into_view
+          @subject.location_once_scrolled_into_view
+
+          element_location = self.location
+          scroll_position = @driver.scroll_position
+
+          middle_y_bounds = scroll_position[:y] + @driver.inner_window_height/2
+
+          if middle_y_bounds > element_location.y
+            #Add
+            y_difference = middle_y_bounds - element_location.y
+            scroll_y_position = scroll_position[:y] - y_difference
+          else
+            #Subtract
+            y_difference = element_location.y - middle_y_bounds
+            scroll_y_position = scroll_position[:y] + y_difference
+          end
+
+          #Get the element to halfway
+          scroll_x_position = element_location.x.to_f
+
+          javascript_string = "return window.scroll(#{scroll_x_position}, #{scroll_y_position});"
+          @driver.execute_script(javascript_string)
+        end
+
+        # Perform a click action on the element
+        # @return [void]
+        def click
+          self.scroll_into_view
+          @subject.click
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/dsl.rb

@@ -0,0 +1,33 @@
+module AutomationObject
+  #Dsl Port
+  module Dsl
+    extend self
+
+    # @return [AutomationObject::Dsl::Module]
+    def adapter
+      return @adapter if @adapter
+      self.adapter = :blue_print
+      @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
+
+      require_relative "dsl/#{adapter_name}"
+      @adapter = AutomationObject::Dsl.const_get("#{adapter_const}")
+    end
+
+    # Creates/returns composite and attaches the State to the composite
+    # @return [AutomationObject::Dsl::Models::Top]
+    def new(args={})
+      composite = self.adapter.build(args)
+      composite.state = args.fetch(:state)
+
+      return composite
+    end
+  end
+end

data/lib/automation_object/dsl/blue_print_adapter.rb

@@ -0,0 +1,16 @@
+require_relative 'blue_print_adapter/top'
+
+module AutomationObject
+  module Dsl
+    #BluePrint adapter for building DSL framework
+    #Follows similar pattern to BluePrint::HashAdapter composite
+    module BluePrintAdapter
+      # @param args [Hash] expects :blue_prints, :state
+      # @return [AutomationObject::Dsl::Models::Top]
+      def self.build(args={})
+        blue_print_adapter = Top.new(blue_prints: args.fetch(:blue_prints))
+        return blue_print_adapter.build
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/blue_print_adapter/composite.rb

@@ -0,0 +1,54 @@
+module AutomationObject
+  module Dsl
+    module BluePrintAdapter
+      #Base class for the DSL BluePrint adapter composite
+      #BluePrintAdapter uses the BluePrint composite to create the proxy/model composite in the DSL
+      class Composite
+        class << self;
+          attr_accessor :implemented_proxy
+        end
+
+        # @param args [Hash] arguments, expects :blue_prints
+        def initialize(args={})
+          @blue_prints = args.fetch :blue_prints
+        end
+
+        # Build and return the DSL composite
+        # @return [Object] composite for the given level
+        def build
+          proxy = self.class.implemented_proxy.new
+
+          self.class.has_many_relationships.each { |name, composite_class|
+            @blue_prints.send(name).each { |child_key, child_blue_prints|
+              child_composite = composite_class.new(blue_prints: child_blue_prints)
+              child_proxy = child_composite.build
+
+              type = name.to_s.gsub(/e?s$/, '').to_sym #Unpluralize
+              proxy.add(name: child_key, type: type, object: child_proxy)
+            }
+          }
+
+          return proxy
+        end
+
+        #Declare which proxy is being used by the given BluePrint::Adapter composite class
+        # @param proxy_class [Class] proxy class used by the given composite
+        def self.implements_proxy(proxy_class)
+          self.implemented_proxy = proxy_class
+        end
+
+        #Has many children relationship for the composite
+        # @param children_name [Symbol] name of the children, should be a BluePrint method
+        # @param args [Hash] additional arguments, expects interface
+        def self.has_many(children_name, args)
+          self.has_many_relationships[children_name] = args.fetch(:interface)
+        end
+
+        # @return [Hash] relationships for the composite
+        def self.has_many_relationships
+          @has_many_relationships ||= Hash.new
+        end
+      end
+    end
+  end
+end