automation_object 0.0.4 → 0.5.0

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

@@ -0,0 +1,83 @@
+require 'nokogiri'
+require 'rest_client'
+
+require_relative 'session'
+require_relative 'element'
+require_relative 'helpers/driver_element_helper'
+
+module AutomationObject::Driver::NokogiriAdapter
+  #Driver proxy for Nokogiri(XML)
+  #Create driver interface that conforms to Driver port
+  #Works differently than Appium/Selenium, not a proxy, but creates the functionality of the driver
+  class Driver
+    include DriverElementHelper
+
+    attr_accessor :current_url
+
+    def initialize(*args)
+      @session = Session.new
+    end
+
+    def navigate
+      self
+    end
+
+    def to(url)
+      @session.get(url)
+    end
+
+    def back
+      @session.back
+    end
+
+    def quit
+      @session.quit
+    end
+
+    def close
+      @session.close
+    end
+
+    def current_url
+      @session.current_url
+    end
+
+    def window_handles
+      @session.window_handles
+    end
+
+    def window_handle
+      @session.window_handle
+    end
+
+    def window_handle=(handle_value)
+      @session.window_handle = handle_value
+    end
+
+    def new_window
+      @session.new_window
+    end
+
+    def xml
+      @session.xml
+    end
+
+    def title
+      title = ''
+      title_element = self.find_element(:xpath, '//title')
+      if title_element
+        title = title_element.text
+      end
+
+      return title
+    end
+
+    def get(url, params = {})
+      @session.get(url, params)
+    end
+
+    def post(url, params = {})
+      @session.post(url, params)
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require_relative 'form'
+
+module AutomationObject::Driver::NokogiriAdapter
+  #Element class for Nokogiri/XML
+  class Element < AutomationObject::Proxies::Proxy
+    def initialize(args)
+      @driver = args.fetch :driver
+      @subject = args.fetch :element
+    end
+
+    # @return [String] id of element
+    def id
+      @subject['id']
+    end
+
+    # @return [String] href of element
+    def href
+      @subject['href']
+    end
+
+    # @return [String] text of element
+    def text
+      @subject['content']
+    end
+
+    # @return [String] content of element
+    def content
+      @subject['content']
+    end
+
+    def attribute(key, value = nil)
+      @subject[key] = value if value
+      return @subject[key]
+    end
+
+    def click
+      url = self.href
+      if self.attribute('target') == '_blank'
+        @driver.new_window
+      end
+
+      @driver.get(url)
+    end
+
+    def send_keys(text)
+      @subject['value'] = text
+    end
+
+    def submit
+      form = find_form(@subject)
+      raise 'Unable to find form' unless form_element
+
+      @driver.send(form.request_method, form.params)
+    end
+
+    private
+
+    # @return [AutomationObject::Driver:NokogiriAdapter::Form]
+    def find_form(element)
+      return nil unless element
+
+      return AutomationObject::Driver::NokogiriAdapter::Form.new(element) if element.name == 'form'
+      return find_form(element.parent)
+    end
+  end
+end

data/lib/automation_object/driver/nokogiri_adapter/backup/form.rb

@@ -0,0 +1,29 @@
+module AutomationObject
+  module Driver
+    module NokogiriAdapter
+      class Form
+        # @param node [Nokogiri::XML::Node]
+        def initialize(node)
+          @node = node
+        end
+
+        # @return [Hash]
+        def params
+          params = {}
+
+          @node.traverse { |node|
+            next unless node.name == 'input'
+            params[node['name']] = node['value']
+          }
+
+          return params
+        end
+
+        # @return [Symbol]
+        def request_method
+          (@node['method'].upcase == 'GET') ? :get : :post
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/nokogiri_adapter/backup/helpers/driver_element_helper.rb

@@ -0,0 +1,52 @@
+require_relative '../error'
+
+module AutomationObject
+  module Driver
+    module NokogiriAdapter
+      module DriverElementHelper
+        # @param selector_type [Symbol] selector type, :css, :xpath, etc...
+        # @param selector_path [String] path to element
+        # @return [Element] element
+        def find_element(selector_type, selector_path)
+          elements = self.get_elements(selector_type, selector_path)
+          raise NoSuchElementError if elements.length == 0
+
+          return AutomationObject::Driver::NokogiriAdapter::Element.new(driver: self, element: elements.first)
+        end
+
+        # @param selector_type [Symbol] selector type, :css, :xpath, etc...
+        # @param selector_path [String] path to element
+        # @return [Array<Element>] elements
+        def find_elements(selector_type, selector_path)
+          elements = self.get_elements(selector_type, selector_path)
+          return elements.map { |element|
+            AutomationObject::Driver::NokogiriAdapter::Element.new(driver: self, element: element)
+          }
+        end
+
+        # @param selector_type [Symbol] selector type, :css, :xpath, etc...
+        # @param selector_path [String] path to element
+        # @return [Boolean] element exists?
+        def exists?(selector_type, selector_path)
+          elements = self.get_elements(selector_type, selector_path)
+          return (elements.length > 0) ? true : false
+        end
+
+        protected
+
+        def get_elements(selector_type, selector_path)
+          case selector_type
+            when :xpath
+              elements = self.xml.xpath(selector_path)
+            when :css
+              elements = self.xml.css(selector_path)
+            else
+              raise ArgumentError, "#{selector_type} selector type not implemented. Only :css, :xpath"
+          end
+
+          return elements
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/nokogiri_adapter/backup/session.rb

@@ -0,0 +1,115 @@
+require 'securerandom'
+require_relative 'error'
+
+module AutomationObject::Driver::NokogiriAdapter
+  #Class for creating/maintaining XML session
+  #Trying to replicate some functionality of Selenium like multiple windows, etc...
+  class Session
+    attr_accessor :window_handles, :window_handle, :current_url, :url_history
+
+    def initialize
+      self.create_session
+    end
+
+    def create_session
+      self.current_url = nil
+      self.url_history = {self.window_handle => Array.new}
+      self.window_handles = [self.window_handle]
+
+      @windows_xml = Hash.new
+
+      return nil
+    end
+
+    def new_window
+      self.window_handles.push(SecureRandom.hex(16))
+      self.url_history[self.window_handles.last] = Array.new
+      self.window_handle = self.window_handles.last
+    end
+
+    # @return [String] current window handle
+    def window_handle
+      @window_handle ||= SecureRandom.hex(16)
+    end
+
+    #Switch window handles
+    # @param handle_value [String] handle value of window to switch to
+    def window_handle=(handle_value)
+      unless self.window_handles.include?(handle_value)
+        raise NoSuchWindowError
+      end
+
+      #Array returns nil if length is 0, so no need for if
+      self.current_url = self.url_history[handle_value].last
+
+      @window_handle = handle_value
+    end
+
+    def xml(xml = nil)
+      @windows_xml[self.window_handle] = xml if xml
+
+      unless @windows_xml[self.window_handle]
+        raise NoSuchDocumentError
+      end
+
+      return @windows_xml[self.window_handle]
+    end
+
+    # Get url, will set xml to current window handle
+    # @param url [String] url to get xml for
+    # @return [Object] nokogiri object
+    def get(url, params = {})
+      request(:get, url, params)
+    end
+
+    # Post url, will set xml to current window handle
+    # @param url [String] url to get xml for
+    # @return [Object] nokogiri object
+    def post(url, params = {})
+      request(:post, url, params)
+    end
+
+    # Request url, will set xml to current window handle
+    # @param url [String] url to get xml for
+    # @return [Object] nokogiri object
+    def request(type, url, params)
+      if url.valid_url? == false and self.current_url == nil
+        raise ArgumentError, "Expecting get argument url to be a valid_url?, got #{url}"
+      elsif url.valid_url? == false and self.current_url
+        url = self.current_url.join_url(url)
+      end
+
+      client_resource = RestClient::Resource.new(url, :ssl_version => 'SSLv23_client')
+      response = client_resource.send(type)
+
+      self.current_url = url
+      self.url_history[self.window_handle].push(url)
+      self.xml(Nokogiri::HTML.parse(response))
+    end
+
+    def back
+      current_url_index = self.url_history[self.window_handle].index(self.current_url)
+      return if current_url_index == 0
+
+      self.url_history[self.window_handle].delete_at(current_url_index)
+      url = self.url_history[self.window_handle].delete_at(current_url_index - 1) #get will insert url anyways
+
+      self.get(url)
+    end
+
+    def close
+      #Just reset everything if only one "window" is open
+      return self.create_session if self.window_handles.length == 1
+
+      @windows_xml.delete(self.window_handle)
+      self.url_history.delete(self.window_handle)
+      self.window_handles.delete(self.window_handle)
+      self.window_handle = self.window_handles.first
+    end
+
+    #Just reset the session
+    def quit
+      self.create_session
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+require_relative '../element'
+require_relative 'element'
+
+module AutomationObject
+  module Driver
+    module NokogiriAdapter
+      #Driver for Nokogiri
+      #Conforms to interface and provides Selenium type functionality for XML only functionality
+      class Driver
+        # Navigates current window to a given url
+        # @param url [String] navigate to the following url
+        # @return [void]
+        def get(url)
+          self.adapter.get(url)
+        end
+
+        # Set timeout wait
+        # @param timeout [Integer] the timeout in seconds
+        # @return [void]
+        def set_wait(timeout = nil)
+          self.adapter.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)
+          self.adapter.exists?(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)
+          self.adapter.find_element(selector_type, selector_path)
+        end
+
+        # @param selector_type [Symbol] selector type, :css, :xpath, etc...
+        # @param selector_path [String] path to element
+        # @return [Array<AutomationObject::Driver::Element>] elements
+        def find_elements(selector_type, selector_path)
+          self.adapter.find_elements(selector_type, selector_path)
+        end
+
+        #Accept prompt either in browser or mobile
+        def accept_prompt
+          self.adapter.accept_prompt
+        end
+
+        #Dismiss the prompt
+        def dismiss_prompt
+          self.adapter.dismiss_prompt
+        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?
+          self.adapter.is_browser?
+        end
+
+        #Window Handles
+        # @return [Array<String>] array of window handle ids
+        def window_handles
+          self.adapter.window_handles
+        end
+
+        #Current window handle
+        # @return [String] handle id
+        def window_handle
+          self.adapter.window_handle
+        end
+
+        #Set current window handle to, will switch windows
+        # @param handle_value [String] window handle value
+        def window_handle=(handle_value)
+          self.adapter.window_handle(handle_value)
+        end
+
+        # Run script in browser to check if document in JS is complete
+        # @return [Boolean] document is complete
+        def document_complete?
+          self.adapter.document_complete?
+        end
+
+        # Wait till the document is complete
+        # @return [void]
+        def document_complete_wait
+          self.adapter.document_complete_wait
+        end
+
+        # @param script [String] JS to run
+        # @return [Object, nil]
+        def execute_script(script)
+          self.adapter.execute_script(script)
+        end
+
+        # Destroy the driver
+        def quit
+          self.adapter.quit
+        end
+      end
+    end
+  end
+end