wda_lib 0.0.2

data/lib/wda_lib/find_element.rb

@@ -0,0 +1,244 @@
+class WDA
+  module FindElement
+    ### Searching for elements
+
+    # Find element with given type and value, return first found element
+    # @param type [String, Symbol], value [Stirng]
+    # @return [Hash]
+    def find(type, value)
+      element = post('/element', { using: stringlize(type), value: value })
+      fail "Can't find #{value} with type #{type}" if element['status'] !=0 
+      Element.new self, element['value']
+    end
+
+    # Find all elements with given type and value, return in an Array
+    # @param type [String, Symbol], value [Stirng]
+    # @return [Array]
+    def finds(type, value)
+      elements = post('/elements', { using: stringlize(type), value: value })['value']
+      elements.map { |element| Element.new self, element }
+    end
+
+    # Find child element by given type and value, return first found element
+    # @param id [String] parent element id, type [String, Symbol], value [Stirng]
+    # @return [Object] found element
+    def find_subl_element(id, type, value)
+      element = post('/element/' + id + '/element', { using: type, value: value })
+      Element.new self, element['ELEMENT']
+    end
+
+    # Find children elements by given type and value, return elements array
+    # @param id [String] parent element id, type [String, Symbol], value [Stirng]
+    # @return [Array<Element>]
+    def find_subl_elements(id, type, value)
+      elements = post('/element/' + id + '/elements', { using: type, value: value })
+      elements.map { |element| Element.new self, element['ELEMENT'] }
+    end
+
+    # Search with given value (Complete value)
+    # @param value [String]
+    # @retrun [Hash]
+    def text(value)
+      find :link_text, "label=#{value}"
+    end
+
+    # Search with given value (Complete value)
+    # @param value [String]
+    # @return [Array]
+    def texts(value)
+      finds :link_text, "label=#{value}"
+    end
+
+    # Search with given partial value (partial link text)
+    # @param value [String]
+    # @retrun [Hash]
+    def partial_text(value)
+      find :partial_link_text, "label=#{value}"
+    end
+
+    # Search with given partial value (partial link text)
+    # @param value [String]
+    # @return [Array]
+    def partial_texts(value)
+      finds :partial_link_text, "label=#{value}"
+    end
+
+    # Search with class name
+    # @param class_name [String] XCUIElementType*, class name in XCUITest, ex: XCUIElementTypeButton
+    # @return [Array] contains all XCUIElementType* elements
+    def name(class_name)
+      finds :class_name, class_name
+    end
+
+    # Search with xpath
+    # @param value [String] 
+    # example: 
+    # "//XCUIElementTypeButton[@name='Share']", 
+    # "//XCUIElementTypeTextField[@value='Value']"
+    # @return [Array] contains all elements which match given xpath
+    def xpath(value)
+      finds :xpath, value
+    end
+
+    # Xpath search with element type, element attribute, element attribute value
+    # @param type [String], attribute [String], value [String] 
+    # example: 
+    # xpath('Button', 'name', 'Share') for "//XCUIElementTypeButton[@name='Share']"
+    # @return [Array] contains all elements which match given variables
+    def xpath_search(type, attribute, value)
+      finds :xpath, "//#{match(type)}[@#{attribute}='#{value}']"
+    end
+
+    # Search predicate string, return first found element
+    # @param value [String] 'isWDVisible=1'
+    # example: 'isWDAccessible=1', 'isWDEnabled=0'
+    # @return [Hash]
+    def predicate_text(predicate_value)
+      find :predicate_string, predicate_value 
+    end
+
+    # Search with predicate string
+    # @param value [String] 'isWDVisible=1'
+    # example: 'isWDAccessible=1', 'isWDEnabled=0', 'isWDAccessibilityContainer=1'
+    # @return [Array]
+    def predicate_texts(predicate_value)
+      finds :predicate_string, predicate_value 
+    end
+
+
+    # @return element's visible cells [Array]
+    def visible_cell(id)
+      get '/uiaElement/' + id + '/getVisibleCells'
+    end
+
+
+    # Find button by given index or value
+    # @param value [String, Integer] 
+    # If value is integer then return the button at that index
+    # If value is string then return the first button which contains given value
+    # @return [Button]
+    def button(value = 0)
+      if value.is_a? Numeric
+        finds(:xpath, "//XCUIElementTypeButton")[value]
+      else
+        find(:xpath, "//XCUIElementTypeButton[@name='#{value}']")
+      end
+    end 
+
+    # @return [Hash] All buttons
+    def buttons
+      finds(:xpath, "//XCUIElementTypeButton")
+    end
+
+    # Find the first Button
+    # @return [Hash] button
+    def first_button
+      finds(:xpath, "//XCUIElementTypeButton").first
+    end
+
+    # Find the last Button
+    # @return [Hash] button
+    def last_button
+      finds(:xpath, "//XCUIElementTypeButton").last
+    end
+
+    # Find textfield by given index or value
+    # @param value [String, Integer]
+    # If value is integer then return the textField at that index
+    # If value is string then return the first textField which contains given value
+    # @return [TextField]
+    def textfield(value = 0)
+      if value.is_a? Numeric
+        finds(:xpath, "//XCUIElementTypeTextField")[value]
+      else
+        find :xpath,  "//XCUIElementTypeTextField[@value='#{value}']"
+      end
+    end
+
+    # Find the all TextField.
+    # @return [Array]
+    def textfields
+      finds(:xpath, "//XCUIElementTypeTextField")
+    end
+
+    # Find the first TextField.
+    # @return [TextField]
+    def first_textfield
+      finds(:xpath, "//XCUIElementTypeTextField").first
+    end
+
+    # Find the last TextField.
+    # @return [TextField]
+    def first_textfield
+      finds(:xpath, "//XCUIElementTypeTextField").last
+    end
+
+    # Find secure_textfield by given index or value
+    # @param value [String, Integer] 
+    # If value is integer then return the secure_textField at that index
+    # If value is string then return the first secure_textField which contains given value
+    # @return [TextField]
+    def secure_textfield(value = 0)
+      if value.is_a? Numeric
+        finds(:xpath, "//XCUIElementTypeSecureTextField")[value]
+      else
+        find :xpath,  "//XCUIElementTypeSecureTextField[@value='#{value}']"
+      end
+    end
+
+    # Find the all SecureTextField.
+    # @return [Array]
+    def secure_textfields
+      finds(:xpath, "//XCUIElementTypeSecureTextField")
+    end
+
+    # Find StaticText by given index or value
+    # @param value [String, Integer]
+    # If value is integer then return the StaticText at that index
+    # If value is string then return the first StaticText which contains given value
+    # @return [TextField]
+    def statictext(value = 0)
+      if value.is_a? Numeric
+        finds(:xpath, "//XCUIElementTypeStaticText")[value]
+      else
+        find :xpath,  "//XCUIElementTypeStaticText[@value='#{value}']"
+      end
+    end
+
+    # Find the all StaticText.
+    # @return [Array]
+    def statictexts
+      finds(:xpath, "//XCUIElementTypeStaticText")
+    end
+
+    ########### This is calling selenium find_element* methods##########
+    # Find element with given type and value, return first found element
+    # @param args [*args]
+    # @return [Object]
+    def find_element(*args)
+      @driver.find_element(*args)
+    end
+
+    # Find elements with given type and value, return in an Array
+    # @param args [*args]
+    # @return [Array<Element>]
+    def find_elements(*args)
+      @driver.find_elements(*args)
+    end
+    ####################################################################
+
+    # Turn symbol to string, replace '_' to ' '
+    # @param instring [Symbol]
+    # @return [String]
+    def stringlize(instring)
+      if instring.is_a? Symbol
+        instring.to_s.gsub('_', ' ')
+      elsif instring.is_a? String
+        return instring
+      else 
+        fail 'Xpath searching type should be a String'
+      end
+    end
+  end
+end
+

data/lib/wda_lib/orientation.rb

@@ -0,0 +1,21 @@
+class WDA
+  module Orientation
+    def orientation
+      get @base_url + '/orientation'
+    end
+
+    def set_orientation
+      post @base_url + '/orientation'
+    end
+
+    def get_rotation
+      get @base_url + '/rotation'
+    end
+
+    def set_rotation
+      post @base_url + '/rotation'
+    end
+  end
+end
+
+

data/lib/wda_lib/screenshot.rb

@@ -0,0 +1,24 @@
+require 'base64'
+
+
+class WDA
+  module Screenshot
+    # Take a screenshot and save to the given path. Format: png.
+    #
+    # Example: screenshot '/screenshot_folder/screenshot.png'
+    #
+    # @param path [String] the full path to save the png
+    # @return screenshot result [Hash]
+    def screenshot(path)
+      path.include?('.png')? path : path += '.png'
+      p response = get(@base_url + '/screenshot')
+      begin
+        File.open(path, 'wb') {|f| f.write Base64.decode64(response['value']) }
+      rescue IOError => e
+        raise "Fail to save to #{path}, error: #{e}"
+      end
+      p "Screenshot is saved to #{path}"
+      return { sessionId: response['sessionId'], status: response['status'] }  
+    end
+  end
+end

data/lib/wda_lib/session.rb

@@ -0,0 +1,80 @@
+class WDA
+  module Session
+
+    # Get current status
+    # @return [Obj]
+    def status
+      @status = get(@base_url + '/status')
+      update_status(@status)
+    end
+
+    # Get current valid session
+    # @return [Session]
+    def session
+      response = get(@url)
+      if response['status'] != 0
+        if response['status'] == 10
+          response['value']
+          restart_session
+          response = get(@url)
+        elsif response['status'] == 1 || response['status'] == 6
+          @session_id = response['sessionId']
+          @url = @base_url + "/session/#{@session_id}"
+          response = get(@url)
+        end
+      else
+        @session_id = response['sessionId']
+        @caps[:desiredCapabilities][:session_id] = @session_id
+        @caps[:desiredCapabilities][:session_valid] = true
+        @url = @base_url + "/session/#{@session_id}"
+      end
+      response
+    end
+
+    # Post desiredCapabilities to wda server to create a session
+    # This is not realy needed since we can find and click app icon to start app
+    # @return [self]
+    def launch_app(app_name_or_id)
+      fail 'Either app name or bundle id should be given for launch app' if app_name_or_id.nil?
+      if app_name_or_id.include?('.')   # Given value is app's bundle id
+        @bundle_id = app_name_or_id
+        @session_id = nil      # Prepare to create new session 
+        @session_valid = false # Prepare to create new session 
+        capabilities
+        @driver = Selenium::WebDriver::Driver.for(:remote, :url => @base_url,  :desired_capabilities => @caps[:desiredCapabilities])
+        status
+      else 
+        app_name = app_name_or_id
+        # TODO find app icon with given app name, click it
+      end
+      self
+    end
+
+    # recreate a session
+    # @return [self]
+    def restart(app_name_or_id = nil)
+      quit
+      launch_app(app_name_or_id ||= @bundle_id )
+    end
+
+    # Exit current app by delete session with given session_id
+    # @params session_id [String]
+    # @return delete session response [Json]
+    def quit(session_id = nil)
+      (session_id.nil?)? sessionId = @session_id : sessionId = session_id
+      @base_url + '/session/' + sessionId
+      delete(@base_url + '/session/' + sessionId)
+    end
+
+    # Same as quit, but delete default @session_id
+    def x
+      quit
+    end
+
+    # Healthcheck
+    def healthcheck
+      response = get(@base_url + '/healthcheck')
+      update_status(response)
+    end
+  end
+end

data/lib/wda_lib/touch_id.rb

@@ -0,0 +1,15 @@
+class WDA
+  module TouchID
+
+    # Touch ID
+    # Match TouchID
+    def match_touchid
+      post(@base_url + '/simulator/touch_id', { match: 1 }.to_json)
+    end
+
+    # Do not match TouchID
+    def match_touchid
+      post(@base_url + '/Simulator/touch_id', { match: 0 }.to_json)
+    end
+  end
+end

data/lib/wda_lib/type.rb

@@ -0,0 +1,91 @@
+class WDA
+  module Type
+    def match(type)
+      type = ('XCUIElementType'+type).downcase
+      types = [
+                "XCUIElementTypeAny",
+                "XCUIElementTypeOther",
+                "XCUIElementTypeApplication",
+                "XCUIElementTypeGroup",
+                "XCUIElementTypeWindow",
+                "XCUIElementTypeSheet",
+                "XCUIElementTypeDrawer",
+                "XCUIElementTypeAlert",
+                "XCUIElementTypeDialog",
+                "XCUIElementTypeButton",
+                "XCUIElementTypeRadioButton",
+                "XCUIElementTypeRadioGroup",
+                "XCUIElementTypeCheckBox",
+                "XCUIElementTypeDisclosureTriangle",
+                "XCUIElementTypePopUpButton",
+                "XCUIElementTypeComboBox",
+                "XCUIElementTypeMenuButton",
+                "XCUIElementTypeToolbarButton",
+                "XCUIElementTypePopover",
+                "XCUIElementTypeKeyboard",
+                "XCUIElementTypeKey",
+                "XCUIElementTypeNavigationBar",
+                "XCUIElementTypeTabBar",
+                "XCUIElementTypeTabGroup",
+                "XCUIElementTypeToolbar",
+                "XCUIElementTypeStatusBar",
+                "XCUIElementTypeTable",
+                "XCUIElementTypeTableRow",
+                "XCUIElementTypeTableColumn",
+                "XCUIElementTypeOutline",
+                "XCUIElementTypeOutlineRow",
+                "XCUIElementTypeBrowser",
+                "XCUIElementTypeCollectionView",
+                "XCUIElementTypeSlider",
+                "XCUIElementTypePageIndicator",
+                "XCUIElementTypeProgressIndicator",
+                "XCUIElementTypeActivityIndicator",
+                "XCUIElementTypeSegmentedControl",
+                "XCUIElementTypePicker",
+                "XCUIElementTypePickerWheel",
+                "XCUIElementTypeSwitch",
+                "XCUIElementTypeToggle",
+                "XCUIElementTypeLink",
+                "XCUIElementTypeImage",
+                "XCUIElementTypeIcon",
+                "XCUIElementTypeScrollBar",
+                "XCUIElementTypeSearchField",
+                "XCUIElementTypeScrollView",
+                "XCUIElementTypeStaticText",
+                "XCUIElementTypeTextField",
+                "XCUIElementTypeSecureTextField",
+                "XCUIElementTypeDatePicker",
+                "XCUIElementTypeTextView",
+                "XCUIElementTypeMenu",
+                "XCUIElementTypeMenuItem",
+                "XCUIElementTypeMenuBar",
+                "XCUIElementTypeMenuBarItem",
+                "XCUIElementTypeMap",
+                "XCUIElementTypeWebView",
+                "XCUIElementTypeIncrementArrow",
+                "XCUIElementTypeDecrementArrow",
+                "XCUIElementTypeTimeline",
+                "XCUIElementTypeRatingIndicator",
+                "XCUIElementTypeValueIndicator",
+                "XCUIElementTypeSplitGroup",
+                "XCUIElementTypeSplitter",
+                "XCUIElementTypeRelevanceIndicator",
+                "XCUIElementTypeColorWell",
+                "XCUIElementTypeHelpTag",
+                "XCUIElementTypeMatte",
+                "XCUIElementTypeDockItem",
+                "XCUIElementTypeRuler",
+                "XCUIElementTypeRulerMarker",
+                "XCUIElementTypeGrid",
+                "XCUIElementTypeLevelIndicator",
+                "XCUIElementTypeCell",
+                "XCUIElementTypeLayoutArea",
+                "XCUIElementTypeLayoutItem",
+                "XCUIElementTypeHandle",
+                "XCUIElementTypeStepper",
+                "XCUIElementTypeTab"
+              ]
+      types.select{|t|t.downcase == type.downcase}.first
+    end
+  end
+end

data/lib/wda_lib/version.rb

@@ -0,0 +1,3 @@
+class WDA
+  VERSION = '0.0.2'
+end

data/lib/wda_lib.rb

@@ -0,0 +1,111 @@
+Dir[File.dirname(__FILE__) + '/wda_lib/*.rb'].each {|file| require file }
+require 'json'
+require 'httparty'
+require 'selenium-webdriver'
+Dir[File.dirname(__FILE__) + '/selenium_patch/*.rb'].each {|file| require_relative file }
+
+
+class WDA
+
+  include HTTParty
+  headers 'Content-Type' => 'application/json'
+  # extend Forwardable
+  # def_delegators :@driver, :find_element, :find_elements, :action, :touch, :element_scroll
+  # def_delegator :@driver, :get, :get_url
+
+  include ::WDA::Alert
+  include ::WDA::Custome
+  include ::WDA::Debug
+  include ::WDA::FindElement
+  include ::WDA::Orientation
+  include ::WDA::Screenshot
+  include ::WDA::Session
+  include ::WDA::TouchID
+  include ::WDA::Type
+
+  Point     = Struct.new(:x, :y)
+  Dimension = Struct.new(:width, :height)
+
+  attr_accessor :session_id, :http, :bundle_id, :caps, :device, :driver
+  attr_reader :base_url, :server_host, :server_port, :url, :window_w, :window_h
+
+  # Get base_url from XCTRunner logs: ServerURLHere->http://x.x.x.x:8100<-ServerURLHere
+  # Default base_url 'http://localhost:8100' for running XCTRunner on simulator
+  BASE_URL = 'http://localhost:8100'
+
+  # Create a new client
+  # 
+  # ```ruby
+  # require 'rubygems'
+  # require 'wda_lib'
+  # 
+  # Start wda client
+  # opts = { caps: { bundleId: @bundle_id }, device_url: 'http://x.x.x.x:8100' }
+  # WDA.new(opts).start_session
+  def initialize(opts = {})
+    # fail 'opts should be a hash' unless opts.is_a? Hash
+    # fail 'bundleId should be provided' if opts[:bundleId].nil?
+    url = opts[:device_url] || BASE_URL
+    parsed_url = URI.parse(url)
+    @base_url = parsed_url.scheme + '://' + parsed_url.host + ':' + parsed_url.port.to_s
+    @url = @base_url
+    @server_host = parsed_url.host
+    @server_port = parsed_url.port
+    status
+    capabilities(opts)
+    @driver = Selenium::WebDriver::Driver.for(:remote, :url => @base_url,  :desired_capabilities => @caps[:desiredCapabilities])
+  end
+
+  # Build desired_capabilities with options
+  # @param opts [Hash]
+  # @return attribute caps [Hash]
+  def capabilities(opts = {})
+    @bundle_id = opts[:bundleId] if !opts[:bundleId].nil?
+    selenium_capabilities = Selenium::WebDriver::Remote::W3CCapabilities.new( 
+                              browser_name: 'iphone', 
+                              platform_name: @platform_name, 
+                              platform_version: @platform_version,
+                              session_id: @session_id,
+                              session_valid: @session_valid,
+                              bundleId: @bundle_id
+                            )
+    @caps = { desiredCapabilities: selenium_capabilities }
+  end
+
+  # Update current running sessionId to @session_id
+  # @param session_response [object] : http GET session response body
+  # @return session_reponse [object]
+  def update_status(status_response)
+    @session_id = status_response['sessionId']
+    @session_valid = true
+    @session_id = status_response['sessionId']
+    @platform_name = status_response['value']['os']['name']
+    @platform_version = status_response['value']['os']['version']
+    @url = @base_url + "/session/#{@session_id}"
+    capabilities
+    status_response
+  end
+
+  # HTTP methods for dealing with all supported motheds in FB WDA
+  # I don't like to write such pieces of code, it removes all query params and headers,
+  # But as FB WDA is doing like this, this can simplify codes
+  def get(path)
+    if URI.parse(path).absolute?
+      WDA.get(path)
+    else
+      WDA.get(@url + path)
+    end
+  end
+
+  def post(path, body = nil)
+    if URI.parse(path).absolute?
+      WDA.post(path, body: body.to_json)
+    else
+      WDA.post(@url + path, body: body.to_json)
+    end
+  end
+
+  def delete(path)
+    WDA.delete(path)
+  end
+end

data/wda_lib.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wda_lib/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'wda_lib'
+  s.version     = WDA::VERSION
+  s.authors     = ["MIN Yi"]
+  s.email       = 'minsparky@gmail.com'
+
+  s.summary     = "A simple ruby lib of binding methods for WebDriverAgent"
+  s.description = "A simple ruby lib of binding methods for WebDriverAgent"
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.homepage    =
+    'http://rubygems.org/gems/wda_lib'
+  s.license       = 'MIT'
+
+  s.add_development_dependency "bundler", "~> 1.12"
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "httparty"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "selenium-webdriver", "~> 3.0.0.beta3.1"
+end