saucelabs 0.5

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/ChangeLog

@@ -0,0 +1 @@
+=== Version 0.2

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+
+gem 'rake'
+gem 'saucelabs'
+gem 'selenium-webdriver'
+gem 'watir-webdriver'
+gem 'net-http-persistent'
+
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, :all_on_start => true, :cmd => 'rspec --color --format Fuubar' do
+  watch(%r{^spec/*/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Pradeep K. Macharla
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,258 @@
+# SauceLabs
+
+saucelabs gem is written in simple ruby so as to be able to set the desired capabilities and browser options for selenium/watir grid execution
+and also be able to dynamically set the browser choice through an environment variable and execute the same scripts across browsers.The gem was
+initially written to help connect to saucelabs, however the current version support local execution, selenium grid execution and execution against
+Sauce Labs cloud environment. Please bear in mind that to execute against Sauce Labs cloud, you would require to register and get a username, password
+to access Sauce Labs on their [website] (http://www.saucelabs.com)
+Also platform and device parameters in the desired capabilities object when creating a connection to
+Sauce Labs. It can also be used to create a connection to local browser instance in addition to Sauce Labs
+The gem has been tested on MRI ruby and JRuby. Please report any issues and I will try my best to fix asap.  
+
+##Pre-Requisites
+If you are planning to use a Selenium GRID or connect to Sauce Labs, it is assumed that you have an understanding on the Selenium GRID connection parameters. Sauce Labs works as a large Selenium GRID with username and password auth.
+
+## Background
+
+saucelabs gem is intended to be able to extract 4 main parameters viz. browser, version, platform and device
+that gets set in the desired capabilities object. The gem creation got inspired by the below blog post
+http://seleniumframework.wordpress.com/2014/05/18/pattern-for-running-multiple-cucumber-projects-on-ci-server/
+Though the gem name is saucelabs , it can be used to create browser instances locally and against any selenium grid.
+
+## Local Execution
+
+````ruby
+require 'saucelabs'
+SauceLabs.watir_browser(browser = :firefox, browser_options = {})
+# or
+require 'saucelabs'
+SauceLabs.selenium_driver(browser = :firefox, browser_options = {})
+````
+The methods use firefox as default browser and browser_options as optional parameter. You can specify other browsers
+by the following:  
+
+````ruby
+SauceLabs.watir_browser(browser = :chrome, browser_options = {})
+# or
+SauceLabs.selenium_driver(browser = :chrome, browser_options = {})
+````
+
+## Executing against local selenium grid
+It is assumed that you have started the grid as per the page [Grid 2] (http://code.google.com/p/selenium/wiki/Grid2)
+
+Another example of being able to use chrome 35 on Windows8 platform  
+
+````ruby
+SauceLabs.watir_browser(browser = :'chrome35|windows8', browser_options = {:url => 'http://localhost:4444/wd/hub'})
+# or
+SauceLabs.selenium_driver(browser = :'chrome35|windows8', browser_options = {:url => 'http://localhost:4444/wd/hub'})
+````
+
+## Executing against Sauce Labs
+
+Uses chrome 35 on Windows8 platform  
+
+````ruby
+SauceLabs.watir_browser(browser = :'chrome35|windows8', browser_options = {:url => 'http://username:password@ip:port/wd/hub'})
+# or
+SauceLabs.selenium_driver(browser = :'chrome35|windows8', browser_options = {:url => 'http://username:password@ip:port/wd/hub'})
+````
+
+## More ways and parameters (using conf)
+
+Another example of being able to use chrome 35 on Windows8 platform (The :url can also be set using SauceLabs.conf, see below)  
+
+````ruby
+SauceLabs.watir_browser(browser = :'chrome35|windows8', browser_options = {})
+# or
+SauceLabs.selenium_driver(browser = :'chrome35|windows8', browser_options = {})
+````
+
+
+Yet Another example of being able to use chrome on mac platform and Android device (The :url needs to be set using SauceLabs.conf, see below)  
+
+````ruby
+SauceLabs.watir_browser(browser = :'chrome|linux|android', browser_options = {})
+# or
+SauceLabs.selenium_driver(browser = :'chrome|linux|android', browser_options = {})
+````
+
+Yet Another example of being able to use safari on mac platform and iphone device (The :url needs to be set using SauceLabs.conf, see below)  
+
+````ruby
+SauceLabs.watir_browser(browser = :'chrome|linux|iphone', browser_options = {})
+# or
+SauceLabs.selenium_driver(browser = :'chrome|linux|iphone', browser_options = {})
+````
+
+A simple ruby code example with watir and executing locally:
+
+````ruby
+require 'saucelabs'
+include SauceLabs
+
+ENV['BROWSER'] = "chrome"
+@browser = SauceLabs.watir_browser
+@browser.goto "http://www.google.com"
+@browser.quit
+````
+
+A simple ruby code example with selenium and executing locally:
+
+````ruby
+require 'saucelabs'
+include SauceLabs
+
+ENV['BROWSER'] = "chrome"
+@browser = SauceLabs.selenium_driver
+@browser.navigate.to "http://www.google.com"
+@browser.quit
+````
+
+A simple ruby code example with watir and executes against saucelabs:
+
+````ruby
+require 'saucelabs'
+include SauceLabs
+
+@browser = SauceLabs.watir_browser(:'chrome35|windows8', {:url => 'http://username:password@ip:port/wd/hub'})
+@browser.goto "http://www.google.com"
+@browser.quit
+````
+
+A simple ruby code example with watir and executes against local selenium grid:
+It is assumed that you have started the grid as per the page [Grid 2] (http://code.google.com/p/selenium/wiki/Grid2)
+
+````ruby
+require 'saucelabs'
+include SauceLabs
+
+@browser = SauceLabs.watir_browser(:'chrome35|windows8', {:url => 'http://localhost:4444/wd/hub'})
+@browser.goto "http://www.google.com"
+@browser.quit
+````
+
+
+### Set BROWSER environment variable
+
+In the above section, we have seen that it is very easy to set browser as a symbol
+to the methods watir_browser and selenium_driver. However we would most likely want to dynamically set
+the browser value. saucelabs reads from an environment variable 'BROWSER'. The following examples would help
+understand the patterns. We can either use cucumber.yml file or set it on the command line as per your choice
+
+````yml
+default: BROWSER=firefox --format pretty --color
+chrome: BROWSER=chrome --format pretty --color
+ie: BROWSER=ie --format pretty --color
+````
+
+Execution from command line is simple too:
+
+````
+cucumber BROWSER=chrome features
+````
+
+The string pattern that is followed by this gem is as follows (Observer the '|' delimiter):
+
+
+````
+chrome36|win81
+safari|linux|iphone
+chrome|linux|android
+````
+
+Hence the following also applies:
+
+````yml
+default: BROWSER=chrome36|win81 --format pretty --color
+safari_mac: BROWSER=safari|linux|iphone --format pretty --color
+chrome_android: BROWSER=chrome|linux|android --format pretty --color
+````
+
+
+
+The first part determines the browser and its version  
+The second part determines the platform value that is set in capabilities object  
+The third part (used only for mobile device testing) determines the device  
+
+
+
+The following table is a mapping of all the platforms available on Sauce Labs website
+
+| platform | description |
+| --- | --- |
+| windowsxp | Windows XP |
+| osx109 | OS X 10.9 |
+| osx106 | OS X 10.6 |
+| osx108 | OS X 10.8 |
+| linux | Linux |
+| windows81 | Windows 8.1 |
+| windows8 | Windows 8 |
+| windows7 | Windows 7 |
+
+The platform values can also be obtained from https://saucelabs.com/platforms
+
+Additional platforms that are NOT on saucelabs however added to this gem to support selenium grid platforms
+
+| platform | description |
+| --- | --- |
+| xp | XP|
+| any | ANY |
+| mac | MAC |
+| unix | UNIX |
+| vista | VISTA |
+| windows | WINDOWS |
+
+
+
+The following table is a mapping of all the devices available on Sauce Labs website
+
+| device | description |
+| --- | --- |
+| iphone | iPhone |
+| android | Android |
+
+
+### Setting parameters using a block
+
+We can also set parameters like sauce url, http_persistent and browser options. Below are some examples:
+
+
+````ruby
+SauceLabs.conf do | conf|
+  conf.url = 'http://username:password@ip:port/wd/hub' #Saucelabs connection url
+  conf.persistent_http = true
+  conf.browser_options = { :switches => %w[--disable-extensions],:chromeOptions => {"args" => ["test-type" ]}}
+end
+````
+
+## Documentation
+
+You can view the RDocs for this project [here] (http://rubydoc.info/github/machzqcq/saucelabs/master/frames).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'saucelabs'
+
+And then execute:
+
+    $ bundle install/update
+
+Require the module:
+
+    require 'saucelabs'
+
+Or install it yourself as:
+
+    $ gem install saucelabs
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc 'Run iOS tests'
+task :ios do
+  Dir.chdir 'ios'
+  exec 'rspec'
+end
+ 
+desc 'Run Android tests'
+task :android do
+  Dir.chdir 'android'
+  exec 'rspec'
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: --no-source --color --format pretty

data/features/Example.feature

@@ -0,0 +1,7 @@
+Feature: Using saucelabs gem to invoke a local browser instance
+  Scenario: launch chrome browser locally
+    When I invoke chrome browser
+    Then I hit google website
+  Scenario: launch chrome browser locally using environment variable
+    When I invoke chrome browser and set environment variable
+    Then I hit google website

data/features/step_definitions/my_steps.rb

@@ -0,0 +1,14 @@
+require 'saucelabs'
+
+When(/^I invoke chrome browser$/) do
+  @browser = SauceLabs.selenium_driver(browser= :chrome)
+end
+
+Then(/^I hit google website$/) do
+ @browser.navigate.to "http://www.google.com"
+end
+
+When(/^I invoke chrome browser and set environment variable$/) do
+  ENV['BROWSER']= "chrome"
+  @browser = SauceLabs.selenium_driver
+end

data/features/support/android/appium.txt

@@ -0,0 +1 @@
+Android appium

data/features/support/ios/appium.txt

@@ -0,0 +1 @@
+Support for appium.txt

data/lib/saucelabs.rb

@@ -0,0 +1,53 @@
+require 'saucelabs/sauce_browser_factory'
+require 'saucelabs/parsed_values'
+
+module SauceLabs
+  #attr_accessor :factory
+
+  #
+  # Creates a watir browser session and returns the browser object
+  #
+  # @example
+  # SauceLabs.watir_browser(browser = :chrome, browser_options = {})
+  # @param  [String] the browser string passed into the method
+  # @param [Hash] the optional hash to specify browser options
+  # @return [Object] browser session
+  #
+
+  def self.watir_browser(browser = :firefox, browser_options={})
+    factory.watir_browser(browser,browser_options)
+  end
+
+  #
+  # Creates a Selenium driver session and returns the driver object
+  #
+  # @example
+  # SauceLabs.selenium_driver(browser = :chrome, browser_options = {})
+  # @param  [String] the browser string passed into the method
+  # @param [Hash] the optional hash to specify browser options
+  # @return [Object] browser session
+  #
+
+  def self.selenium_driver(browser = :firefox, browser_options={})
+    factory.selenium_driver(browser,browser_options)
+  end
+  
+  #
+  # Yields to Factory object if parameters are set using conf
+  #
+  # @return [Object] browser session
+  #
+
+  def self.conf
+    yield factory
+  end
+
+  private
+
+  def self.factory
+    @factory ||= SauceBrowserFactory.new
+  end
+
+  
+
+end

data/lib/saucelabs/parsed_values.rb

@@ -0,0 +1,129 @@
+module SauceLabs
+  module ParsedValues
+
+    #
+    # Extracts browser, version, platform, device from the browser string
+    #
+    # @example
+    #   extract_values_from(:'safari5|linux|iphone') will extract
+    # browser = safari
+    # version=5
+    # platform=Linux
+    # device=iPhone
+    #
+    # @param  [String] the browser string passed into the method
+    # @return [String,String,String,String] browser, version, platform and device
+    #
+    def extract_values_from(browser_string)
+      browser = extract_browser(browser_string).to_sym
+      version = extract_version(browser_string)
+      platform = extract_platform(browser_string)
+      device = extract_device(browser_string)
+      return browser,version,platform,device
+    end
+
+    private
+
+    #
+    # Extracts browser from browser string
+    #
+    # @example
+    #   extract_browser(:'safari5|linux|iphone') will extract
+    # browser = safari
+    #
+    # @param  [String] the browser string passed into the method
+    # @return [String] the browser value
+    #
+    def extract_browser(value)
+      browser = value.to_s.split(/\d+/)[0]
+      browser = browser.to_s.split('|')[0] if browser.to_s.include? '|'
+      browser
+    end
+
+    #
+    # Extracts version from browser string
+    #
+    # @example
+    #   extract_version(:'safari5|linux|iphone') will extract
+    # browser = safari
+    #
+    # @param  [String] the browser string passed into the method
+    # @return [String] the version value
+    #
+    def extract_version(value)
+      value = value.to_s.split('|')[0] if value.to_s.include? '|'
+      regexp_to_match = /\d{1,}/
+      if (not regexp_to_match.match(value).nil?)
+        version = regexp_to_match.match(value)[0]
+      else
+        version = ''
+      end
+      version
+    end
+
+    #
+    # Extracts platform from browser string
+    #
+    # @example
+    #   extract_platform(:'safari5|linux|iphone') will extract
+    # browser = safari
+    #
+    # @param  [String] the browser string passed into the method
+    # @return [String] the platform value
+    #
+    def extract_platform(value)
+      platform = value.to_s.split('|')[1] if value.to_s.include? '|'
+      sauce_platforms
+      @sauce_platforms[platform] if not platform.nil?
+    end
+
+    #
+    # Extracts device from browser string
+    #
+    # @example
+    #   extract_device(:'safari5|linux|iphone') will extract
+    # browser = safari
+    #
+    # @param  [String] the browser string passed into the method
+    # @return [String] the device value
+    #
+
+    def extract_device(value)
+      device = value.to_s.split('|')[2] if value.to_s.include? '|'
+      sauce_devices
+      @sauce_devices[device] if not device.nil?
+    end
+
+    #
+    # Defines the platforms available on Sauce Labs as a Hash
+
+    def sauce_platforms
+      @sauce_platforms = Hash.new
+      @sauce_platforms["windowsxp"] = "Windows XP"
+      @sauce_platforms["osx109"] = "OS X 10.9"
+      @sauce_platforms["osx106"] = "OS X 10.6"
+      @sauce_platforms["osx108"] = "OS X 10.8"
+      @sauce_platforms["linux"] = "Linux"
+      @sauce_platforms["windows81"] = "Windows 8.1"
+      @sauce_platforms["windows8"] = "Windows 8"
+      @sauce_platforms["windows7"] = "Windows 7"
+      @sauce_platforms["any"] = "ANY"
+      @sauce_platforms["mac"] = "MAC"
+      @sauce_platforms["unix"] = "UNIX"
+      @sauce_platforms["vista"] = "VISTA"
+      @sauce_platforms["windows"] = "WINDOWS"
+      @sauce_platforms["xp"] = "XP"
+    end
+
+    #
+    # Defines the devices available on Sauce Labs as a Hash
+
+
+    def sauce_devices
+      @sauce_devices = Hash.new
+      @sauce_devices["iphone"] = "iPhone"
+      @sauce_devices["android"] = "Android"
+    end
+
+  end
+end

data/lib/saucelabs/sauce_api.rb

@@ -0,0 +1,29 @@
+require "net/http"
+require "net/https"
+
+module SauceLabs
+  module RestApiBuilder
+  
+  def post(body)
+  
+  end
+  
+  def puts(body)
+  
+  end
+  
+  def get(url)
+  
+  end
+  
+  def delete(url)
+  
+  end
+  
+  def sauce_credentials
+    
+  end
+  
+  
+  end
+end

data/lib/saucelabs/sauce_browser_factory.rb

@@ -0,0 +1,122 @@
+require_relative 'parsed_values'
+require 'selenium-webdriver'
+require 'watir-webdriver'
+
+module SauceLabs
+  #
+  # This class has the code necessary to create an instance of browser after making a connection to saucelabs.
+  # This class can also be used to create browser instance for local connections
+  #
+  class SauceBrowserFactory
+    include ParsedValues
+
+    attr_accessor :url,:options,:persistent_http
+
+    #
+    # Creates a watir browser session and returns the browser object
+    #
+    # @example
+    # SauceLabs.watir_browser(browser = :chrome, browser_options = {})
+    # @param  [String] the browser string passed into the method
+    # @param [Hash] the optional hash to specify browser options
+    # @return [Object] browser session
+    #
+
+    def watir_browser(browser,browser_options)
+      target,options = browser_caps(browser,browser_options)
+      create_watir_browser(target,options)
+    end
+
+    #
+    # Creates a Selenium driver session and returns the driver object
+    #
+    # @example
+    # SauceLabs.selenium_driver(browser = :chrome, browser_options = {})
+    # @param  [String] the browser string passed into the method
+    # @param [Hash] the optional hash to specify browser options
+    # @return [Object] browser session
+    #
+
+    def selenium_driver(browser,browser_options)
+      target,options = browser_caps(browser,browser_options)
+      create_selenium_driver(target,options)
+    end
+    
+    
+    #def capybara_driver(browser,browser_options)
+      #Capybara.register_driver :selenium do |app|
+          #Capybara::Selenium::Driver.new(app, :browser => browser)
+      #end
+      #Capybara.default_driver = :selenium
+      #target,options = browser_caps(browser,browser_options)
+      #create_selenium_driver(target,options)
+    #end
+
+    private
+
+    def create_watir_browser(target,options)
+      if options.empty?
+        Watir::Browser.new target
+      else
+        Watir::Browser.new target,options
+      end
+    end
+
+    def create_selenium_driver(target,options)
+      if options.empty?
+        Selenium::WebDriver.for target
+      else
+        Selenium::WebDriver.for target,options
+      end
+    end
+
+    #
+    # Returns the target and options including the capabilities
+    #
+    # @param  [String] the browser string passed into the method
+    # @param [Hash] the optional hash to specify browser options
+    # @return [Symbol,Hash] browser as symbol and options as Hash
+    #
+
+    def browser_caps(browser,browser_options)
+      target = (browser.to_sym if ENV['BROWSER'].nil? or ENV['browser'].empty?) || (ENV['BROWSER'].to_sym)
+      browser,version,platform,device = extract_values_from(target)
+      options = {}
+      options.merge! browser_options
+      caps = capabilities(browser,version,platform,device)
+      options[:url] = url if url
+      if options.include? :url
+        browser = :remote
+        options[:desired_capabilities] = caps
+      end
+      options[:http_client] = http_client if persistent_http or options.delete(:persistent_http)
+      return browser,options
+    end
+
+
+    def capabilities(browser, version, platform,device={})
+      capabilities = Selenium::WebDriver::Remote::Capabilities.send browser
+      capabilities.version = version unless version.nil? or version.empty?
+      capabilities.platform = platform unless platform.nil? or platform.empty?
+      capabilities.device = device unless device.nil? or device.empty?
+      capabilities
+    end
+
+    #
+    # Returns a persistent http connection object
+    #
+    # @return [Object] Persistent http connection object
+    #
+
+    def http_client
+     client = Selenium::WebDriver::Remote::Http::Persistent.new
+     #client.proxy_uri="http://abc"
+     #client.read_timeout = 180
+     #client.socket_options = {}
+     client
+    end
+
+
+  end
+
+end

data/saucelabs.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "saucelabs"
+  spec.version       = "0.5"
+  spec.authors       = ["Pradeep K. Macharla"]
+  spec.email         = ["pradeep@seleniumframework.com"]
+  spec.summary       = %q{Access saucelabs, selenium grid or local browser instance using simple ruby.}
+  spec.description   = %q{Access saucelabs by passing browser, version, platform and device information}
+  spec.homepage      = "https://github.com/machzqcq/saucelabs"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'watir-webdriver', '>= 0.6.9'
+  spec.add_dependency 'selenium-webdriver'
+  spec.add_dependency 'net-http-persistent'
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/lib/parsed_values_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+class TestParsedValues
+  include SauceLabs::ParsedValues
+end
+
+
+describe SauceLabs::ParsedValues do
+
+  let(:parsed_values) { TestParsedValues.new }
+
+  it "should extract browser name" do
+    browser, version, platform,device = parsed_values.extract_values_from(:chrome)
+    expect(browser).to eql :chrome
+  end
+
+  it "should extract browser name if browser and version are specified" do
+    browser, version, platform,device = parsed_values.extract_values_from(:chrome35)
+    expect(browser).to eql :chrome
+  end
+
+  it "should extract version if version is specified along with browser" do
+    browser,version,platform,device = parsed_values.extract_values_from(:chrome35)
+    expect(version).to eql '35'
+  end
+
+  it "should extract platform if platform is specified along with browser" do
+    browser, version, platform,device = parsed_values.extract_values_from(:'chrome35|windows81')
+    expect(platform).to eql 'Windows 8.1'
+  end
+
+  it "should extract iphone device if iphone is specified along with platform and browser" do
+    browser, version, platform,device = parsed_values.extract_values_from(:'chrome35|windows81|iphone')
+    expect(device).to eql 'iPhone'
+  end
+
+  it "should extract android device if android is specified along with platform and browser" do
+    browser, version, platform,device = parsed_values.extract_values_from(:'chrome35|windows81|android')
+    expect(device).to eql 'Android'
+  end
+
+  it "should report platform nil if platform is not defined in sauce_platforms" do
+    browser, version, platform,device = parsed_values.extract_values_from(:'chrome35|windows82|android')
+    expect(platform).to be_nil
+  end
+
+  it "should report device nil if device is not defined in sauce_devices" do
+    browser, version, platform,device = parsed_values.extract_values_from(:'chrome35|windows82|xyz')
+    expect(device).to be_nil
+  end
+
+end

data/spec/lib/sauce_browser_factory_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'selenium/webdriver/remote/http/persistent'
+
+describe SauceLabs do
+
+  let(:watir_browser) { Watir::Browser }
+
+  context "Create Watir browser" do
+    it "should create a firefox instance if none specified" do
+      expect(watir_browser).to receive(:new).with(:firefox)
+      SauceLabs.watir_browser
+    end
+
+    it "should create a chrome instance if chrome specified" do
+      expect(watir_browser).to receive(:new).with(:chrome)
+      SauceLabs.watir_browser(:chrome)
+    end
+
+    it "should create a ie instance if ie specified" do
+      expect(watir_browser).to receive(:new).with(:ie)
+      SauceLabs.watir_browser(:ie)
+    end
+  end
+
+  context "Create Selenium driver" do
+    let(:selenium_driver) { Selenium::WebDriver }
+
+    it "should create a firefox instance if non specified" do
+      expect(selenium_driver).to receive(:for).with(:firefox)
+      SauceLabs.selenium_driver
+    end
+
+    it "should create a chrome instance if chrome specified" do
+      expect(selenium_driver).to receive(:for).with(:chrome)
+      SauceLabs.selenium_driver(:chrome)
+    end
+
+    it "should create a ie instance if ie specified" do
+      expect(selenium_driver).to receive(:for).with(:ie)
+      SauceLabs.selenium_driver(:ie)
+    end
+  end
+
+
+  context "Using an environment variable BROWSER" do
+    it "uses ENV['BROWSER'] if available" do
+      ENV['BROWSER'] = 'chrome'
+      expect(watir_browser).to receive(:new).with(:chrome)
+      SauceLabs.watir_browser
+      ENV.delete 'BROWSER'
+    end
+
+    it "should provide option to use http client for watir" do
+      client = double('http_client')
+      expect(Selenium::WebDriver::Remote::Http::Persistent).to receive(:new).and_return(client)
+      expect(watir_browser).to receive(:new).with(:firefox, http_client: client)
+      SauceLabs.watir_browser(:firefox, persistent_http: true)
+    end
+
+    it "should provide option to use http_client via conf" do
+      SauceLabs.conf do |conf|
+        conf.persistent_http = true
+      end
+      client = double('http_client')
+      expect(Selenium::WebDriver::Remote::Http::Persistent).to receive(:new).and_return(client)
+      expect(watir_browser).to receive(:new).with(:firefox, http_client: client)
+      SauceLabs.watir_browser(:firefox)
+      SauceLabs.conf do |conf|
+        conf.persistent_http = nil
+      end
+    end
+
+    it "should provide to use sauce labs url using conf" do
+      SauceLabs.conf do |conf|
+        conf.url = 'http://username:password@ip:port/wd/hub'
+      end
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser(:firefox)
+      SauceLabs.conf do |conf|
+        conf.url = nil
+      end
+    end
+  end
+  context "can pass browser options" do
+    it "should provide to be able to pass firefox browser options" do
+      SauceLabs.conf do |conf|
+        conf.options = {options: 'blah'}
+      end
+      expect(watir_browser).to receive(:new).with(:firefox)
+      SauceLabs.watir_browser(:firefox)
+      SauceLabs.conf do |conf|
+        conf.options = nil
+      end
+    end
+
+    it "should provide to be able to pass chrome browser options" do
+      SauceLabs.conf do |conf|
+        conf.options = {options: 'blah'}
+      end
+      expect(watir_browser).to receive(:new).with(:chrome)
+      SauceLabs.watir_browser(:chrome)
+      SauceLabs.conf do |conf|
+        conf.options = nil
+      end
+    end
+
+    it "should provide to be able to pass ie browser options" do
+      SauceLabs.conf do |conf|
+        conf.options = {options: 'blah'}
+      end
+      expect(watir_browser).to receive(:new).with(:ie)
+      SauceLabs.watir_browser(:ie)
+      SauceLabs.conf do |conf|
+        conf.options = nil
+      end
+    end
+  end
+
+
+ end

data/spec/lib/saucelabs_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+describe "Example browser, platform and device combinations" do
+
+  let(:watir_browser) { Watir::Browser }
+  let(:selenium_driver) { Selenium::WebDriver}
+  let(:capabilities) { Selenium::WebDriver::Remote::Capabilities }
+  let(:desired_capabilities) { double('capabilities') }
+
+  context "Firefox" do
+
+    before(:each) do
+      allow(capabilities).to receive(:firefox).and_return(desired_capabilities)
+    end
+
+    it "allows Firefox with no version specified" do
+      expect(watir_browser).to receive(:new).with(:firefox)
+      SauceLabs.watir_browser :firefox
+    end
+
+    it "allows Firefox 3" do
+      expect(desired_capabilities).to receive(:version=).with('3')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :firefox3, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Firefox 6" do
+      expect(desired_capabilities).to receive(:version=).with('6')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :firefox6, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Firefox 10" do
+      expect(desired_capabilities).to receive(:version=).with('10')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :firefox10, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Firefox 25" do
+      expect(desired_capabilities).to receive(:version=).with('25')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :firefox25, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Firefox 28" do
+      expect(desired_capabilities).to receive(:version=).with('28')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :firefox28, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Firefox 29" do
+      expect(desired_capabilities).to receive(:version=).with('29')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :firefox29, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Firefox 30" do
+      expect(desired_capabilities).to receive(:version=).with('30')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :firefox30, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+  end
+
+  context "Chrome" do
+
+    before(:each) do
+      allow(capabilities).to receive(:chrome).and_return(desired_capabilities)
+    end
+
+    it "allows Chrome with no version specified" do
+      expect(watir_browser).to receive(:new).with(:chrome)
+      SauceLabs.watir_browser :chrome
+    end
+
+    it "allows Chrome 26" do
+      expect(desired_capabilities).to receive(:version=).with('26')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :chrome26, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Chrome 27" do
+      expect(desired_capabilities).to receive(:version=).with('27')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :chrome27, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Chrome 28" do
+      expect(desired_capabilities).to receive(:version=).with('28')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :chrome28, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Chrome 29" do
+      expect(desired_capabilities).to receive(:version=).with('29')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :chrome29, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Chrome 30" do
+      expect(desired_capabilities).to receive(:version=).with('30')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :chrome30, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Chrome 32" do
+      expect(desired_capabilities).to receive(:version=).with('32')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :chrome32, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "allows Chrome 36" do
+      expect(desired_capabilities).to receive(:version=).with('36')
+      expect(watir_browser).to receive(:new).with(:remote, url: 'http://username:password@ip:port/wd/hub', desired_capabilities: anything())
+      SauceLabs.watir_browser :chrome36, url: 'http://username:password@ip:port/wd/hub'
+    end
+
+end
+    context "Platforms Windows" do
+      before(:each) do
+        allow(capabilities).to receive(:chrome).and_return(desired_capabilities)
+      end
+
+      it "extracts Windows XP" do
+        expect(desired_capabilities).to receive(:version=).with('26')
+        expect(desired_capabilities).to receive(:platform=).with('Windows XP')
+        expect(watir_browser).to receive(:new)
+        SauceLabs.watir_browser :'chrome26|windowsxp', url: 'http://username:password@ip:port/wd/hub'
+      end
+
+      it "extracts Windows 8.1" do
+        expect(desired_capabilities).to receive(:version=).with('35')
+        expect(desired_capabilities).to receive(:platform=).with('Windows 8.1')
+        expect(watir_browser).to receive(:new)
+        SauceLabs.watir_browser :'chrome35|windows81', url: 'http://username:password@ip:port/wd/hub'
+      end
+
+      it "extracts Windows 7" do
+        expect(desired_capabilities).to receive(:version=).with('33')
+        expect(desired_capabilities).to receive(:platform=).with('Windows 7')
+        expect(watir_browser).to receive(:new)
+        SauceLabs.watir_browser :'chrome33|windows7', url: 'http://username:password@ip:port/wd/hub'
+      end
+
+      it "extracts Windows 8" do
+        expect(desired_capabilities).to receive(:version=).with('36')
+        expect(desired_capabilities).to receive(:platform=).with('Windows 8')
+        expect(watir_browser).to receive(:new)
+        SauceLabs.watir_browser :'chrome36|windows8', url: 'http://username:password@ip:port/wd/hub'
+      end
+    end
+
+
+  context "Platforms OS X" do
+    before(:each) do
+      allow(capabilities).to receive(:safari).and_return(desired_capabilities)
+    end
+
+    it "extracts OS X 10.9" do
+      expect(desired_capabilities).to receive(:version=).with('7')
+      expect(desired_capabilities).to receive(:platform=).with('OS X 10.9')
+      expect(watir_browser).to receive(:new)
+      SauceLabs.watir_browser :'safari7|osx109', url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "extracts OS X 10.6" do
+      expect(desired_capabilities).to receive(:version=).with('6')
+      expect(desired_capabilities).to receive(:platform=).with('OS X 10.6')
+      expect(watir_browser).to receive(:new)
+      SauceLabs.watir_browser :'safari6|osx106', url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "extracts OS X 10.8" do
+      expect(desired_capabilities).to receive(:version=).with('5')
+      expect(desired_capabilities).to receive(:platform=).with('OS X 10.8')
+      expect(watir_browser).to receive(:new)
+      SauceLabs.watir_browser :'safari5|osx108', url: 'http://username:password@ip:port/wd/hub'
+    end
+
+end
+
+  context "Platforms Linux" do
+    before(:each) do
+      allow(capabilities).to receive(:chrome).and_return(desired_capabilities)
+    end
+
+    it "extracts Linux" do
+      expect(desired_capabilities).to receive(:version=).with('36')
+      expect(desired_capabilities).to receive(:platform=).with('Linux')
+      expect(watir_browser).to receive(:new)
+      SauceLabs.watir_browser :'chrome36|linux', url: 'http://username:password@ip:port/wd/hub'
+    end
+  end
+
+  context "Extract device" do
+      it "extracts iPhone" do
+      allow(capabilities).to receive(:chrome).and_return(desired_capabilities)
+      expect(desired_capabilities).to receive(:platform=).with('Linux')
+      expect(desired_capabilities).to receive(:device=).with('iPhone')
+      expect(watir_browser).to receive(:new)
+      SauceLabs.watir_browser :'chrome|linux|iphone', url: 'http://username:password@ip:port/wd/hub'
+    end
+
+    it "extracts Android" do
+      allow(capabilities).to receive(:chrome).and_return(desired_capabilities)
+      expect(desired_capabilities).to receive(:platform=).with('Linux')
+      expect(desired_capabilities).to receive(:device=).with('Android')
+      expect(selenium_driver).to receive(:for)
+      SauceLabs.selenium_driver :'chrome|linux|android', url: 'http://username:password@ip:port/wd/hub'
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'saucelabs'
+require 'selenium-webdriver'
+require 'watir-webdriver'

data/travis.yml

@@ -0,0 +1,3 @@
+language: jruby
+rvm:
+  - 1.7.10

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: saucelabs
+version: !ruby/object:Gem::Version
+  version: '0.5'
+  prerelease:
+platform: ruby
+authors:
+- Pradeep K. Macharla
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: watir-webdriver
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.9
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.9
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :development
+description: Access saucelabs by passing browser, version, platform and device information
+email:
+- pradeep@seleniumframework.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- ChangeLog
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cucumber.yml
+- features/Example.feature
+- features/step_definitions/my_steps.rb
+- features/support/android/appium.txt
+- features/support/ios/appium.txt
+- lib/saucelabs.rb
+- lib/saucelabs/parsed_values.rb
+- lib/saucelabs/sauce_api.rb
+- lib/saucelabs/sauce_browser_factory.rb
+- saucelabs.gemspec
+- spec/lib/parsed_values_spec.rb
+- spec/lib/sauce_browser_factory_spec.rb
+- spec/lib/saucelabs_spec.rb
+- spec/spec_helper.rb
+- travis.yml
+homepage: https://github.com/machzqcq/saucelabs
+licenses:
+- MIT
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Access saucelabs, selenium grid or local browser instance using simple ruby.
+test_files:
+- features/Example.feature
+- features/step_definitions/my_steps.rb
+- features/support/android/appium.txt
+- features/support/ios/appium.txt
+- spec/lib/parsed_values_spec.rb
+- spec/lib/sauce_browser_factory_spec.rb
+- spec/lib/saucelabs_spec.rb
+- spec/spec_helper.rb