automation_object 0.5.0 → 0.5.1

data/lib/automation_object/driver/helpers/selenium_driver_helper.rb

@@ -1,41 +0,0 @@
-module AutomationObject
-  module Driver
-    #Helper module for Selenium based drivers
-    #for use by SeleniumAdapter::Driver and AppiumAdapter::Driver
-    module SeleniumDriverHelper
-      # @return [Float] inner window height
-      def inner_window_height
-        @subject.execute_script('return window.innerHeight;').to_f
-      end
-
-      # @return [Hash] x,y scroll position
-      def scroll_position
-        position = OpenStruct.new
-
-        position.x = @subject.execute_script('var doc = document.documentElement; return (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);').to_f
-        position.y = @subject.execute_script('var doc = document.documentElement; return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);').to_f
-
-        return position
-      end
-
-      def scroll_position=(position)
-        @subject.execute_script("window.scroll(#{position[:x]},#{position[:y]});")
-      end
-
-      # @param window_dimension [Hash] :width, :height of window
-      def window_size=(window_dimension)
-        @subject.manage.window.resize_to(window_dimension[:width], window_dimension[:height])
-      end
-
-      # @return [Hash] :width, :height of window
-      def window_size
-        @subject.manage.window.size
-      end
-
-      #Maximize the current window
-      def maximize_window
-        @subject.manage.window.maximize
-      end
-    end
-  end
-end

data/lib/automation_object/driver/helpers/selenium_element_helper.rb

@@ -1,138 +0,0 @@
-module AutomationObject
-  module Driver
-    #Helper module for Selenium based elements
-    #for use by SeleniumAdapter::Element and AppiumAdapter::Element
-    module SeleniumElementHelper
-      # @return [Numeric] x position of element
-      def x
-        @subject.location.x
-      end
-
-      # @return [Numeric] y position of element
-      def y
-        @subject.location.y
-      end
-
-      # @return [Numeric] width of element
-      def width
-        @subject.size.width
-      end
-
-      # @return [Numeric] height of element
-      def height
-        @subject.size.height
-      end
-
-      # @return [Boolean] element visible
-      def visible?
-        @subject.displayed?
-      end
-
-      # @return [Boolean] element invisible
-      def invisible?
-        @subject.displayed? ? false : true
-      end
-
-      # @return [String] id of element
-      def id
-        @subject.attribute('id').to_s
-      end
-
-      # @return [String] href of element
-      def href
-        @subject.attribute('href').to_s
-      end
-
-      # @return [Boolean] content of element
-      def content
-        @subject.attribute('content').to_s
-      end
-
-      # @param key [String] attribute key to get or set
-      # @param value [Object] optional value to set the key as
-      # @return [Object] value of attribute
-      def attribute(key, value = false)
-        if value
-          script = "return arguments[0].#{key} = '#{value}'"
-          @driver.execute_script(script, @subject)
-        end
-
-        @subject.attribute(key)
-      end
-
-      # @return [Hash] :x, :y coordinates
-      def element_center
-        element_location = @subject.location
-        element_size = @subject.size
-
-        center = OpenStruct.new
-        center.x = (element_location.x.to_f + element_size.width.to_f/2).to_f
-        center.y = (element_location.y.to_f + element_size.height.to_f/2).to_f
-
-        return center
-      end
-
-      # @return [Hash] :x1, :x2, :y1, :y2 coordinates of a box
-      def box_coordinates
-        element_location = @subject.location
-        element_size = @subject.size
-
-        box_coordinates = OpenStruct.new
-        box_coordinates.x1 = element_location.x.to_f
-        box_coordinates.y1 = element_location.y.to_f
-        box_coordinates.x2 = element_location.x.to_f + element_size.width.to_f
-        box_coordinates.y2 = element_location.y.to_f + element_size.height.to_f
-
-        return box_coordinates
-      end
-
-      # @param second_element_object [Object] element to compare to
-      # @param collision_tolerance [Numeric] pixel tolerance of collisions
-      # @return [Boolean] element collides with other
-      def collides_with_element?(second_element_object, collision_tolerance = false)
-        box_one = self.box_coordinates
-        box_two = second_element_object.box_coordinates
-
-        collision_tolerance = 0 unless collision_tolerance.is_a?(Numeric)
-
-        if box_one.x2 > box_two.x1 and box_one.x1 < box_two.x2 and box_one.y2 > box_two.y1 and box_one.y1 < box_two.y2
-          if box_one.x2 > (box_two.x1 + collision_tolerance) and (box_one.x1 + collision_tolerance) < box_two.x2 and
-              box_one.y2 > (box_two.y1 + collision_tolerance) and (box_one.y1 + collision_tolerance) < box_two.y2
-            return true
-          else
-            return false
-          end
-        else
-          return false
-        end
-      end
-
-      #Hover over element
-      def hover
-        self.scroll_into_view
-        @driver.action.move_to(@subject).perform
-      end
-
-      #Helper method to switch to this element's iframe
-      def switch_to_iframe
-        @driver.switch_to.frame(self.iframe_switch_value)
-      end
-
-      #Helper method for getting the value to switch to
-      #If value doesn't exist then create one
-      # @return [String] iframe value to switch to
-      def iframe_switch_value
-        iframe_switch_value = self.attribute('id')
-        if iframe_switch_value.length == 0
-          iframe_switch_value = self.attribute('name')
-        end
-
-        unless iframe_switch_value
-          iframe_switch_value = self.attribute('name', SecureRandom.hex(16))
-        end
-
-        return iframe_switch_value
-      end
-    end
-  end
-end

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

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

@@ -1,66 +0,0 @@
-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/helpers/driver_element_helper.rb

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

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