simple_sauce 0.1.0 → 1.0.0.pre.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 459ade86f96fd32db8ec9a44670c1d25676790b0ad4ab5b1cc517831b7e4ccdc
-  data.tar.gz: eac33556eaa40e1d672f246a6cd59603662b5131280aa6030672d6f82a2de42d
+  metadata.gz: b6cabcc9d048c033cb89c6eb328e364c7a1f047c202453c89f5685e84e2a91f8
+  data.tar.gz: cb3e8f3fcca010f06dfbb09a576b71e1ed90a92305adda8fac58138ba530d942
 SHA512:
-  metadata.gz: 60b6e3ab41402f963e7f4a7085c7413a11788aa087b49a57d63f64bfe5c0945c74922f786aef84a1f298b37b3cd03125e8295222a1a244b338413568179d0cfb
-  data.tar.gz: a03a428ecff642195fc148f96a207f2106977dc909f26ed5576bbfcc923a8fb71a0a2ceeb6c16521884f8c6c97d21998123b0ddec7bc39194e2dbbf4b40ffeb2
+  metadata.gz: e86505a7b8ad04a1e6e0f3627f1e94082be58e09a01ff035177fcfd60cebf85cd6610424ca7b257b8ef103750dbb32dae30973cb1c82a2feb20b05173c864af1
+  data.tar.gz: 962d17eaba87c010b65308ddce0e7ad9f9d336074d752a2be97e1482a2e9abbd7cf9cb62b2ca65dc518c55d6bd1223a5f0a0e599348e433ebf27ee43e16328f0

data/.rubocop.yml

@@ -8,15 +8,28 @@ require:
 Layout/SpaceInsideHashLiteralBraces:
   EnforcedStyle: no_space
 
+Metrics/AbcSize:
+  Max: 22
+
 Metrics/BlockLength:
   Exclude:
     - "**/*_spec.rb"
 
+Metrics/CyclomaticComplexity:
+  Max: 7
+
+Metrics/PerceivedComplexity:
+  Max: 8
+
+Metrics/ClassLength:
+  Exclude:
+    - 'lib/simple_sauce/options.rb'
+
 Metrics/LineLength:
   Max: 120
 
 Metrics/MethodLength:
-  Max: 13
+  Max: 16
 
 Metrics/ModuleLength:
   CountComments: false

data/README.md

@@ -52,7 +52,7 @@ sauce_options = SimpleSauce::Options.new(screen_resolution: '1080x720',
 selenium_options = Selenium::WebDriver::Remote::Capabilities.new(accept_insecure_certs: false,
                                                                  page_load_strategy: 'eager'}
 
-browser_options = Selenium::WebDriver::Firefox::Options.new(args: ['-foo'])
+browser_options = Selenium::WebDriver::Firefox::Options.new('args' => ['-foo'])
 ```
 
 ### Session class

data/lib/simple_sauce/options.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'selenium-webdriver'
+
 module SimpleSauce
   class Options
     class << self
@@ -8,40 +10,116 @@ module SimpleSauce
       end
     end
 
-    W3C = %i[browser_name platform_name browser_version].freeze
+    BROWSER_NAMES = {Selenium::WebDriver::Chrome::Options => 'chrome',
+                     Selenium::WebDriver::Edge::Options => 'MicrosoftEdge',
+                     Selenium::WebDriver::Firefox::Options => 'firefox',
+                     Selenium::WebDriver::IE::Options => 'internet explorer',
+                     Selenium::WebDriver::Safari::Options => 'safari'}.freeze
 
-    SAUCE = %i[access_key appium_version avoid_proxy build capture_html chromedriver_version command_timeout
-               crmuxdriver_version custom_data disable_popup_handler extended_debugging firefox_adapter_version
-               firefox_profile_url idle_timeout iedriver_version max_duration name parent_tunnel passed prerun
-               prevent_requeue priority proxy_host public record_logs record_screenshots record_video
-               restricted_public_info screen_resolution selenium_version source tags time_zone tunnel_identifier
-               username video_upload_on_pass capture_performance].freeze
+    W3C = %i[browser_name browser_version platform_name accept_insecure_certs page_load_strategy proxy
+             set_window_rect timeouts unhandled_prompt_behavior strict_file_interactability].freeze
 
-    def initialize(**opts)
-      @browser_name = 'chrome'
-      @platform_name = 'Windows 10'
-      @browser_version = 'latest'
+    SAUCE = %i[avoid_proxy build chromedriver_version command_timeout custom_data extended_debugging idle_timeout
+               iedriver_version max_duration name parent_tunnel prerun priority public record_logs record_screenshots
+               record_video screen_resolution selenium_version tags time_zone tunnel_identifier video_upload_on_pass
+               capture_performance].freeze
 
+    attr_accessor :browser_name, :browser_version, :platform_name, :accept_insecure_certs, :page_load_strategy, :proxy,
+                  :set_window_rect, :timeouts, :unhandled_prompt_behavior, :strict_file_interactability, :avoid_proxy,
+                  :build, :chromedriver_version, :command_timeout, :custom_data, :extended_debugging, :idle_timeout,
+                  :iedriver_version, :max_duration, :name, :parent_tunnel, :prerun, :priority, :public, :record_logs,
+                  :record_screenshots, :record_video, :screen_resolution, :selenium_version, :tags, :time_zone,
+                  :tunnel_identifier, :video_upload_on_pass, :capture_performance
+    attr_reader :selenium_options
+
+    def initialize(**opts)
+      parse_selenium_options(opts.delete(:selenium_options))
       create_variables(SAUCE + W3C, opts)
+      @build ||= build_name
+
+      @browser_name ||= selenium_options['browserName'] || 'chrome'
+      @platform_name ||= 'Windows 10'
+      @browser_version ||= 'latest'
     end
 
     def capabilities
-      caps = W3C.each_with_object({}) do |key, hash|
+      caps = selenium_options.dup
+      W3C.each do |key|
         value = send(key)
-        hash[self.class.camel_case(key)] = value if value
+        key = self.class.camel_case(key)
+        value = parse_w3c_key(key, value)
+        caps[key] = value unless value.nil?
       end
       caps['sauce:options'] = {}
       SAUCE.each do |key|
         value = send(key)
-        caps['sauce:options'][self.class.camel_case(key)] = value unless value.nil?
+        key = self.class.camel_case(key)
+        value = parse_sauce_key(key, value)
+        caps['sauce:options'][key] = value unless value.nil?
       end
       caps
     end
-
     alias as_json capabilities
 
+    def add_capabilities(opts)
+      opts.each do |key, value|
+        raise ArgumentError, "#{key} is not a valid parameter for Options class" unless respond_to?("#{key}=")
+
+        if value.is_a?(Hash)
+          value = value.each_with_object({}) do |(old_key, val), updated|
+            updated[old_key.to_sym] = val
+          end
+        end
+
+        send("#{key}=", value)
+      end
+    end
+
     private
 
+    def parse_w3c_key(key, value)
+      if key == 'proxy' && value
+        value.as_json
+      elsif key == 'timeouts' && value
+        value.each_with_object({}) do |(old_key, val), updated|
+          updated[self.class.camel_case(old_key)] = val
+        end
+      else
+        value
+      end
+    end
+
+    def parse_sauce_key(key, value)
+      if key == 'prerun' && value.is_a?(Hash)
+        value.each_with_object({}) do |(old_key, val), updated|
+          updated[self.class.camel_case(old_key)] = val
+        end
+      elsif key == 'customData' && value.is_a?(Hash)
+        value.each_with_object({}) do |(old_key, val), updated|
+          updated[self.class.camel_case(old_key)] = val
+        end
+      else
+        value
+      end
+    end
+
+    def parse_selenium_options(selenium_opts)
+      opts = Array(selenium_opts)
+
+      opts.each do |opt|
+        browser = BROWSER_NAMES[opt.class]
+        if browser
+          @browser_name = browser
+        else
+          W3C.each do |capability|
+            send("#{capability}=", opt[capability]) if opt[capability]
+          end
+        end
+      end
+
+      @selenium_options = opts.map(&:as_json).inject(:merge) || {}
+    end
+
     def create_variables(key, opts)
       key.each do |option|
         self.class.__send__(:attr_accessor, option)
@@ -53,5 +131,30 @@ module SimpleSauce
 
       raise ArgumentError, "#{opts.inspect} are not valid parameters for Options class"
     end
+
+    def build_name
+      # Jenkins
+      if ENV['BUILD_TAG']
+        "#{ENV['BUILD_NAME']}: #{ENV['BUILD_NUMBER']}"
+      # Bamboo
+      elsif ENV['bamboo_agentId']
+        "#{ENV['bamboo_shortJobName']}: #{ENV['bamboo_buildNumber']}"
+      # Travis
+      elsif ENV['TRAVIS_JOB_ID']
+        "#{ENV['TRAVIS_JOB_NAME']}: #{ENV['TRAVIS_JOB_NUMBER']}"
+      # CircleCI
+      elsif ENV['CIRCLE_JOB']
+        "#{ENV['CIRCLE_JOB']}: #{ENV['CIRCLE_BUILD_NUM']}"
+      # Gitlab
+      elsif ENV['CI']
+        "#{ENV['CI_JOB_NAME']}: #{ENV['CI_JOB_ID']}"
+      # Team City
+      elsif ENV['TEAMCITY_PROJECT_NAME']
+        "#{ENV['TEAMCITY_PROJECT_NAME']}: #{ENV['BUILD_NUMBER']}"
+      # Default
+      else
+        "Build Time - #{Time.now.to_i}"
+      end
+    end
   end
 end

data/lib/simple_sauce/session.rb

@@ -5,54 +5,51 @@ require 'selenium-webdriver'
 
 module SimpleSauce
   class Session
+    DATA_CENTERS = {US_WEST: 'ondemand.us-west-1.saucelabs.com',
+                    US_EAST: 'ondemand.us-east-1.saucelabs.com',
+                    EU_VDC: 'ondemand.eu-central-1.saucelabs.com'}.freeze
+
     attr_writer :username, :access_key, :url
     attr_reader :driver, :options, :data_center
 
-    def initialize(options = nil)
+    def initialize(options = nil, username: nil, access_key: nil, data_center: nil)
       @options = options || Options.new
-      raise unless [Array, Options].include?(@options.class)
 
-      self.data_center = :US_WEST
-      @username = ENV['SAUCE_USERNAME']
-      @access_key = ENV['SAUCE_ACCESS_KEY']
+      @username = username || ENV['SAUCE_USERNAME']
+      @access_key = access_key || ENV['SAUCE_ACCESS_KEY']
+      self.data_center = data_center || :US_WEST
     end
 
     def start
-      @driver = Selenium::WebDriver.for :remote, url: url, desired_capabilities: options.capabilities
+      raise ArgumentError, "needs username; use `ENV['SAUCE_USERNAME']` or `Session#username=`" unless @username
+      raise ArgumentError, "needs access_key; use `ENV['SAUCE_ACCESS_KEY']` or `Session#access_key=`" unless @access_key
+
+      @driver = Selenium::WebDriver.for :remote, to_selenium
     end
 
     def stop(result)
+      return if @driver.nil?
+
       SauceWhisk::Jobs.change_status(@driver.session_id, result)
       @driver.quit
     end
 
     def data_center=(data_center)
+      unless DATA_CENTERS.key?(data_center)
+        msg = "#{data_center} is an invalid data center; specify :US_WEST, :US_EAST or :EU_VDC"
+        raise ArgumentError, msg
+      end
+
+      SauceWhisk.data_center = data_center
       @data_center = data_center
-      @dc_url = case data_center
-                when :US_WEST
-                  'ondemand.saucelabs.com:443/wd/hub'
-                when :US_EAST
-                  'us-east-1.saucelabs.com:443/wd/hub'
-                when :EU_VDC
-                  'ondemand.eu-central-1.saucelabs.com:443/wd/hub'
-                else
-                  msg = "#{data_center} is an invalid data center; specify :US_WEST, :US_EAST or :EU_VDC"
-                  raise ::ArgumentError, msg
-                end
-      SauceWhisk.data_center = @data_center
     end
 
     def url
-      raise ArgumentError, "No user name was set; use `ENV['SAUCE_USERNAME']` or `Session#username=`" unless @username
-      unless @access_key
-        raise ArgumentError, "No access key was set; use `ENV['SAUCE_ACCESS_KEY']` or `Session#access_key=`"
-      end
-
-      @url ||= "https://#{@username}:#{@access_key}@#{@dc_url}"
+      @url ||= "https://#{@username}:#{@access_key}@#{DATA_CENTERS[data_center]}:443/wd/hub"
     end
 
     def to_selenium
-      {url: url, desired_capabilities: Array(@options).map(&:as_json).inject(:merge)}
+      {url: url, desired_capabilities: options.capabilities}
     end
   end
 end

data/lib/simple_sauce/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleSauce
-  VERSION = '0.1.0'
+  VERSION = '1.0.0.pre.alpha'
 end

data/simple_sauce.gemspec

@@ -27,7 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubocop-rspec', '~>1.32'
   spec.add_development_dependency 'webmock', '~> 3.5'
 
-  spec.add_runtime_dependency 'selenium-webdriver', '~> 3.0'
   spec.add_runtime_dependency 'sauce_whisk'
-
+  spec.add_runtime_dependency 'selenium-webdriver', '~> 3.142.0', '>= 3.142.7'
 end

data/spec/options.yml

@@ -0,0 +1,56 @@
+example_values:
+  browser_name: 'firefox'
+  browser_version: '123'
+  platform_name: 'Mac'
+  accept_insecure_certs: true
+  page_load_strategy: 'eager'
+  set_window_rect: true
+  unhandled_prompt_behavior: "accept"
+  strict_file_interactability: true
+  timeouts:
+    implicit: 1
+    page_load: 59
+    script: 29
+  avoid_proxy: true
+  build: 'Sample Build Name'
+  capture_performance: true
+  chromedriver_version: '71'
+  command_timeout: 2
+  custom_data:
+    foo: 'foo'
+    bar: 'bar'
+  extended_debugging: true
+  idle_timeout: 3
+  iedriver_version: '3.141.0'
+  max_duration: 300
+  name: 'Sample Test Name'
+  parent_tunnel: 'Mommy'
+  prerun:
+    executable: "http://url.to/your/executable.exe"
+    args:
+      - --silent
+      - -a
+      - -q
+    background: false
+    timeout: 120
+  priority: 0
+  public: 'team'
+  record_logs: false
+  record_screenshots: false
+  record_video: false
+  screen_resolution: '10x10'
+  selenium_version: '3.141.59'
+  tags:
+    - foo
+    - bar
+    - foobar
+  time_zone: 'San Francisco'
+  tunnel_identifier: 'tunnelname'
+  video_upload_on_pass: false
+
+invalid_option:
+  foo: "bar"
+  browser_name: "firefox"
+  browser_version: "70"
+  platform_name: "MacOS 10.12"
+  record_screenshots: false

data/spec/options_spec.rb

@@ -4,18 +4,28 @@ require 'spec_helper'
 
 module SimpleSauce
   describe Options do
+    before do
+      ENV['BUILD_TAG'] = ''
+      ENV['BUILD_NAME'] = 'TEMP BUILD'
+      ENV['BUILD_NUMBER'] = '11'
+    end
+
+    after { ENV.delete 'BUILD_TAG' }
+
     describe '#new' do
       let(:default_options) do
         {'browserName' => 'chrome',
          'browserVersion' => 'latest',
          'platformName' => 'Windows 10',
-         'sauce:options' => {}}
+         'sauce:options' => {'build' => 'TEMP BUILD: 11'}}
       end
 
       it 'uses latest Chrome version on Windows 10 by default' do
-        sauce_opts = SimpleSauce::Options.new
+        options = Options.new
 
-        expect(sauce_opts.capabilities).to eq(default_options)
+        expect(options.browser_name).to eq 'chrome'
+        expect(options.browser_version).to eq 'latest'
+        expect(options.platform_name).to eq 'Windows 10'
       end
 
       it 'accepts provided values for browser, browser version and platform name' do
@@ -28,51 +38,434 @@ module SimpleSauce
         expect(options.platform_name).to eq 'Mac'
       end
 
-      it 'accepts Sauce Lab specific settings' do
-        sauce_options = {max_duration: 1,
-                         command_timeout: 2,
-                         idle_timeout: 3,
-                         name: 'foo',
-                         build: 'bar',
-                         tags: %w[foo bar],
-                         parent_tunnel: 'bar',
-                         tunnel_identifier: 'foobar',
-                         screen_resolution: '10x10',
-                         time_zone: 'Foo',
-                         extended_debugging: true,
-                         capture_performance: true,
-                         record_video: false,
-                         video_upload_on_pass: false,
-                         record_screenshots: false,
-                         record_logs: false,
-                         username: 'foo',
-                         access_key: '1234',
-                         passed: true}
+      it 'accepts other w3c values' do
+        proxy = Selenium::WebDriver::Proxy.new(ssl: 'foo')
+        timeouts = {implicit: 1,
+                    page_load: 59,
+                    script: 29}
+        options = Options.new(accept_insecure_certs: true,
+                              page_load_strategy: 'eager',
+                              proxy: proxy,
+                              set_window_rect: true,
+                              unhandled_prompt_behavior: 'accept',
+                              strict_file_interactability: true,
+                              timeouts: timeouts)
+
+        expect(options.accept_insecure_certs).to eq true
+        expect(options.page_load_strategy).to eq 'eager'
+        expect(options.proxy).to eq proxy
+        expect(options.set_window_rect).to eq true
+        expect(options.unhandled_prompt_behavior).to eq 'accept'
+        expect(options.strict_file_interactability).to eq true
+        expect(options.timeouts).to eq timeouts
+      end
+
+      it 'accepts Sauce Labs specific settings' do
+        custom_data = {foo: 'foo',
+                       bar: 'bar'}
+        prerun = {executable: 'http://url.to/your/executable.exe',
+                  args: ['--silent', '-a', '-q'],
+                  background: false,
+                  timeout: 120}
+        tags = %w[foo bar foobar]
+        sauce_options = {
+          avoid_proxy: true,
+          build: 'Sample Build Name',
+          capture_performance: true,
+          chromedriver_version: '71',
+          command_timeout: 2,
+          custom_data: custom_data,
+          extended_debugging: true,
+          idle_timeout: 3,
+          iedriver_version: '3.141.0',
+          max_duration: 300,
+          name: 'Sample Test Name',
+          parent_tunnel: 'Mommy',
+          prerun: prerun,
+          priority: 0,
+          public: 'team',
+          record_logs: false,
+          record_screenshots: false,
+          record_video: false,
+          screen_resolution: '10x10',
+          selenium_version: '3.141.59',
+          tags: tags,
+          time_zone: 'San Francisco',
+          tunnel_identifier: 'tunnelname',
+          video_upload_on_pass: false
+        }
+
+        options = Options.new(**sauce_options)
+
+        expect(options.avoid_proxy).to eq true
+        expect(options.build).to eq 'Sample Build Name'
+        expect(options.capture_performance).to eq true
+        expect(options.chromedriver_version).to eq '71'
+        expect(options.command_timeout).to eq 2
+        expect(options.custom_data).to eq custom_data
+        expect(options.extended_debugging).to eq true
+        expect(options.idle_timeout).to eq 3
+        expect(options.iedriver_version).to eq '3.141.0'
+        expect(options.max_duration).to eq 300
+        expect(options.name).to eq 'Sample Test Name'
+        expect(options.parent_tunnel).to eq 'Mommy'
+        expect(options.prerun).to eq prerun
+        expect(options.priority).to eq 0
+        expect(options.public).to eq 'team'
+        expect(options.record_logs).to eq false
+        expect(options.record_screenshots).to eq false
+        expect(options.record_video).to eq false
+        expect(options.screen_resolution).to eq '10x10'
+        expect(options.selenium_version).to eq '3.141.59'
+        expect(options.tags).to eq tags
+        expect(options.time_zone).to eq 'San Francisco'
+        expect(options.tunnel_identifier).to eq 'tunnelname'
+        expect(options.video_upload_on_pass).to eq false
+      end
+
+      it 'accepts Selenium Capabilities and overrides default browser' do
+        caps = Selenium::WebDriver::Remote::Capabilities.firefox(accept_insecure_certs: true,
+                                                                 page_load_strategy: 'eager')
+        options = Options.new(selenium_options: caps)
+
+        expect(options.browser_name).to eq 'firefox'
+        expect(options.accept_insecure_certs).to eq true
+        expect(options.page_load_strategy).to eq 'eager'
+      end
+
+      it 'accepts Selenium Options and overrides default browser' do
+        browser_opts = Selenium::WebDriver::Firefox::Options.new(args: ['--foo'])
+        options = Options.new(selenium_options: browser_opts)
 
-        sauce_opts = SimpleSauce::Options.new(sauce_options)
+        expect(options.browser_name).to eq 'firefox'
+        expect(options.selenium_options['moz:firefoxOptions']).to eq('args' => ['--foo'])
+      end
 
-        expected_options =  default_options.merge('sauce:options' => {})
-        sauce_options.each  do |key, value|
-          expected_options['sauce:options'][SimpleSauce::Options.send(:camel_case, key.to_s)] = value
-        end
+      it 'accepts Selenium Capabilities and Options class instances' do
+        caps = Selenium::WebDriver::Remote::Capabilities.chrome(accept_insecure_certs: true,
+                                                                page_load_strategy: 'eager')
+        browser_opts = Selenium::WebDriver::Chrome::Options.new(args: ['--foo'])
+        options = Options.new(selenium_options: [caps, browser_opts])
 
-        expect(sauce_opts.capabilities).to eq(expected_options)
+        expect(options.page_load_strategy).to eq 'eager'
+        expect(options.accept_insecure_certs).to eq true
+        expect(options.selenium_options['goog:chromeOptions']).to eq('args' => ['--foo'])
+      end
+
+      it 'accepts W3C, Sauce, Browser Options and Capabilities at the same time' do
+        caps = Selenium::WebDriver::Remote::Capabilities.chrome(page_load_strategy: 'eager')
+        browser_opts = Selenium::WebDriver::Firefox::Options.new(args: ['--foo'])
+
+        options = Options.new(browser_version: '77',
+                              accept_insecure_certs: true,
+                              command_timeout: 2,
+                              time_zone: 'Alaska',
+                              selenium_options: [caps, browser_opts])
+
+        expect(options.browser_name).to eq 'firefox'
+        expect(options.browser_version).to eq '77'
+        expect(options.platform_name).to eq 'Windows 10'
+        expect(options.accept_insecure_certs).to eq true
+        expect(options.command_timeout).to eq 2
+        expect(options.time_zone).to eq 'Alaska'
+        expect(options.page_load_strategy).to eq 'eager'
+
+        expect(options.selenium_options['moz:firefoxOptions']).to eq('args' => ['--foo'])
+      end
+
+      it 'creates a default build value' do
+        options = Options.new
+        expect(options.build).to eq 'TEMP BUILD: 11'
       end
 
       it 'raises ArgumentError if parameter is not recognized as valid' do
-        expect { SimpleSauce::Options.new(foo: 'bar') }.to raise_exception(ArgumentError)
+        expect { Options.new(foo: 'bar') }.to raise_exception(ArgumentError)
+      end
+    end
+
+    describe '#accessors' do
+      it 'parses w3c values' do
+        proxy = Selenium::WebDriver::Proxy.new(ssl: 'foo')
+        timeouts = {implicit: 1,
+                    page_load: 59,
+                    script: 29}
+
+        options = Options.new
+
+        options.browser_name = 'firefox'
+        options.browser_version = '7'
+        options.platform_name = 'macOS 10.14'
+        options.accept_insecure_certs = true
+        options.page_load_strategy = 'eager'
+        options.proxy = proxy
+        options.set_window_rect = true
+        options.unhandled_prompt_behavior = 'accept'
+        options.strict_file_interactability = true
+        options.timeouts = timeouts
+        options.platform_name
+
+        expect(options.browser_name).to eq 'firefox'
+        expect(options.browser_version).to eq '7'
+        expect(options.platform_name).to eq 'macOS 10.14'
+        expect(options.accept_insecure_certs).to eq true
+        expect(options.page_load_strategy).to eq 'eager'
+        expect(options.proxy).to eq proxy
+        expect(options.set_window_rect).to eq true
+        expect(options.unhandled_prompt_behavior).to eq 'accept'
+        expect(options.strict_file_interactability).to eq true
+        expect(options.timeouts).to eq timeouts
+      end
+
+      it 'parses Sauce values' do
+        custom_data = {foo: 'foo',
+                       bar: 'bar'}
+        prerun = {executable: 'http://url.to/your/executable.exe',
+                  args: ['--silent', '-a', '-q'],
+                  background: false,
+                  timeout: 120}
+        tags = %w[foo bar foobar]
+
+        options = Options.new
+
+        options.avoid_proxy = true
+        options.build = 'Sample Build Name'
+        options.capture_performance = true
+        options.chromedriver_version = '71'
+        options.command_timeout = 2
+        options.custom_data = custom_data
+        options.extended_debugging = true
+        options.idle_timeout = 3
+        options.iedriver_version = '3.141.0'
+        options.max_duration = 300
+        options.name = 'Sample Test Name'
+        options.parent_tunnel = 'Mommy'
+        options.prerun = prerun
+        options.priority = 0
+        options.public = 'team'
+        options.record_logs = false
+        options.record_screenshots = false
+        options.record_video = false
+        options.screen_resolution = '10x10'
+        options.selenium_version = '3.141.59'
+        options.tags = tags
+        options.time_zone = 'San Francisco'
+        options.tunnel_identifier = 'tunnelname'
+        options.video_upload_on_pass = false
+
+        expect(options.avoid_proxy).to eq true
+        expect(options.build).to eq 'Sample Build Name'
+        expect(options.capture_performance).to eq true
+        expect(options.chromedriver_version).to eq '71'
+        expect(options.command_timeout).to eq 2
+        expect(options.custom_data).to eq custom_data
+        expect(options.extended_debugging).to eq true
+        expect(options.idle_timeout).to eq 3
+        expect(options.iedriver_version).to eq '3.141.0'
+        expect(options.max_duration).to eq 300
+        expect(options.name).to eq 'Sample Test Name'
+        expect(options.parent_tunnel).to eq 'Mommy'
+        expect(options.prerun).to eq prerun
+        expect(options.priority).to eq 0
+        expect(options.public).to eq 'team'
+        expect(options.record_logs).to eq false
+        expect(options.record_screenshots).to eq false
+        expect(options.record_video).to eq false
+        expect(options.screen_resolution).to eq '10x10'
+        expect(options.selenium_version).to eq '3.141.59'
+        expect(options.tags).to eq tags
+        expect(options.time_zone).to eq 'San Francisco'
+        expect(options.tunnel_identifier).to eq 'tunnelname'
+        expect(options.video_upload_on_pass).to eq false
       end
     end
 
-    it 'uses accessor' do
-      sauce_opts = SimpleSauce::Options.new
-      sauce_opts.browser_name = 'firefox'
-      sauce_opts.idle_timeout = 3
+    describe '#add_capabilities' do
+      it 'loads options from configuration' do
+        timeouts = {implicit: 1,
+                    page_load: 59,
+                    script: 29}
+        custom_data = {foo: 'foo',
+                       bar: 'bar'}
+        prerun = {executable: 'http://url.to/your/executable.exe',
+                  args: ['--silent', '-a', '-q'],
+                  background: false,
+                  timeout: 120}
+        tags = %w[foo bar foobar]
+
+        options = Options.new
+        yaml = YAML.load_file('spec/options.yml')
+        options.add_capabilities(yaml['example_values'])
+
+        expect(options.browser_name).to eq 'firefox'
+        expect(options.browser_version).to eq '123'
+        expect(options.platform_name).to eq 'Mac'
+        expect(options.accept_insecure_certs).to eq true
+        expect(options.page_load_strategy).to eq 'eager'
+        expect(options.set_window_rect).to eq true
+        expect(options.unhandled_prompt_behavior).to eq 'accept'
+        expect(options.strict_file_interactability).to eq true
+        expect(options.timeouts).to eq timeouts
+        expect(options.avoid_proxy).to eq true
+        expect(options.build).to eq 'Sample Build Name'
+        expect(options.capture_performance).to eq true
+        expect(options.chromedriver_version).to eq '71'
+        expect(options.command_timeout).to eq 2
+        expect(options.custom_data).to eq custom_data
+        expect(options.extended_debugging).to eq true
+        expect(options.idle_timeout).to eq 3
+        expect(options.iedriver_version).to eq '3.141.0'
+        expect(options.max_duration).to eq 300
+        expect(options.name).to eq 'Sample Test Name'
+        expect(options.parent_tunnel).to eq 'Mommy'
+        expect(options.prerun).to eq prerun
+        expect(options.priority).to eq 0
+        expect(options.public).to eq 'team'
+        expect(options.record_logs).to eq false
+        expect(options.record_screenshots).to eq false
+        expect(options.record_video).to eq false
+        expect(options.screen_resolution).to eq '10x10'
+        expect(options.selenium_version).to eq '3.141.59'
+        expect(options.tags).to eq tags
+        expect(options.time_zone).to eq 'San Francisco'
+        expect(options.tunnel_identifier).to eq 'tunnelname'
+        expect(options.video_upload_on_pass).to eq false
+      end
+
+      it 'raises exception if value not recognized' do
+        options = Options.new
+        yaml = YAML.load_file('spec/options.yml')
+
+        msg = 'foo is not a valid parameter for Options class'
+        expect { options.add_capabilities(yaml['invalid_option']) }.to raise_exception(ArgumentError, msg)
+      end
+    end
+
+    describe '#capabilities' do
+      it 'correctly generates capabilities for w3c values' do
+        proxy = Selenium::WebDriver::Proxy.new(ssl: 'foo')
+        timeouts = {implicit: 1,
+                    page_load: 59,
+                    script: 29}
+
+        options = Options.new(browser_name: 'firefox',
+                              platform_name: 'Mac',
+                              accept_insecure_certs: true,
+                              page_load_strategy: 'eager',
+                              proxy: proxy,
+                              set_window_rect: true,
+                              unhandled_prompt_behavior: 'accept',
+                              strict_file_interactability: true,
+                              timeouts: timeouts)
+
+        expect(options.capabilities).to eq('browserName' => 'firefox',
+                                           'browserVersion' => 'latest',
+                                           'platformName' => 'Mac',
+                                           'acceptInsecureCerts' => true,
+                                           'pageLoadStrategy' => 'eager',
+                                           'proxy' => {'proxyType' => 'MANUAL', 'sslProxy' => 'foo'},
+                                           'setWindowRect' => true,
+                                           'unhandledPromptBehavior' => 'accept',
+                                           'strictFileInteractability' => true,
+                                           'timeouts' => {'implicit' => 1,
+                                                          'pageLoad' => 59,
+                                                          'script' => 29},
+                                           'sauce:options' => {'build' => 'TEMP BUILD: 11'})
+      end
 
-      expect(sauce_opts.capabilities).to eq('browserName' => 'firefox',
-                                            'browserVersion' => 'latest',
-                                            'platformName' => 'Windows 10',
-                                            'sauce:options' => {'idleTimeout' => 3})
+      it 'correctly generates capabilities for sauce values' do
+        custom_data = {foo: 'foo',
+                       bar: 'bar'}
+        prerun = {'executable': 'http://url.to/your/executable.exe',
+                  args: ['--silent', '-a', '-q'],
+                  background: false,
+                  timeout: 120}
+        tags = %w[foo bar foobar]
+        sauce_options = {avoid_proxy: true,
+                         build: 'Sample Build Name',
+                         capture_performance: true,
+                         chromedriver_version: '71',
+                         command_timeout: 2,
+                         custom_data: custom_data,
+                         extended_debugging: true,
+                         idle_timeout: 3,
+                         iedriver_version: '3.141.0',
+                         max_duration: 300,
+                         name: 'Sample Test Name',
+                         parent_tunnel: 'Mommy',
+                         prerun: prerun,
+                         priority: 0,
+                         public: 'team',
+                         record_logs: false,
+                         record_screenshots: false,
+                         record_video: false,
+                         screen_resolution: '10x10',
+                         selenium_version: '3.141.59',
+                         tags: tags,
+                         time_zone: 'San Francisco',
+                         tunnel_identifier: 'tunnelname',
+                         video_upload_on_pass: false}
+
+        options = Options.new(**sauce_options)
+
+        prerun_caps = {'executable' => 'http://url.to/your/executable.exe',
+                       'args' => ['--silent', '-a', '-q'],
+                       'background' => false,
+                       'timeout' => 120}
+
+        expect(options.capabilities).to eq('browserName' => 'chrome',
+                                           'browserVersion' => 'latest',
+                                           'platformName' => 'Windows 10',
+                                           'sauce:options' => {'build' => 'Sample Build Name',
+                                                               'avoidProxy' => true,
+                                                               'capturePerformance' => true,
+                                                               'chromedriverVersion' => '71',
+                                                               'commandTimeout' => 2,
+                                                               'customData' => {'foo' => 'foo',
+                                                                                'bar' => 'bar'},
+                                                               'extendedDebugging' => true,
+                                                               'idleTimeout' => 3,
+                                                               'iedriverVersion' => '3.141.0',
+                                                               'maxDuration' => 300,
+                                                               'name' => 'Sample Test Name',
+                                                               'parentTunnel' => 'Mommy',
+                                                               'prerun' => prerun_caps,
+                                                               'priority' => 0,
+                                                               'public' => 'team',
+                                                               'recordLogs' => false,
+                                                               'recordScreenshots' => false,
+                                                               'recordVideo' => false,
+                                                               'screenResolution' => '10x10',
+                                                               'seleniumVersion' => '3.141.59',
+                                                               'tags' => %w[foo bar foobar],
+                                                               'timeZone' => 'San Francisco',
+                                                               'tunnelIdentifier' => 'tunnelname',
+                                                               'videoUploadOnPass' => false})
+      end
+
+      it 'correctly generates capabilities for selenium object values' do
+        caps = Selenium::WebDriver::Remote::Capabilities.chrome(accept_insecure_certs: true,
+                                                                page_load_strategy: 'eager')
+        browser_opts = Selenium::WebDriver::Chrome::Options.new(args: ['--foo'])
+        options = Options.new(selenium_options: [caps, browser_opts])
+
+        jwp_defaults = {'cssSelectorsEnabled' => true,
+                        'javascriptEnabled' => true,
+                        'nativeEvents' => false,
+                        'platform' => 'ANY',
+                        'rotatable' => false,
+                        'takesScreenshot' => false,
+                        'version' => ''}
+
+        expected_caps = {'browserName' => 'chrome',
+                         'browserVersion' => 'latest',
+                         'platformName' => 'Windows 10',
+                         'acceptInsecureCerts' => true,
+                         'pageLoadStrategy' => 'eager',
+                         'sauce:options' => {'build' => 'TEMP BUILD: 11'},
+                         'goog:chromeOptions' => {'args' => ['--foo']}}
+
+        expect(options.capabilities).to eq(jwp_defaults.merge(expected_caps))
+      end
     end
   end
 end

data/spec/session_spec.rb

@@ -12,37 +12,43 @@ module SimpleSauce
     end
     let(:default_capabilities) do
       {browserName: 'chrome',
-       platformName: 'Windows 10',
        browserVersion: 'latest',
-       'sauce:options': {}}
+       platformName: 'Windows 10',
+       'sauce:options': {build: 'TEMP BUILD: 11'}}
     end
 
     def expect_request(body: nil, endpoint: nil)
       body = (body || {desiredCapabilities: default_capabilities,
                        capabilities: {firstMatch: [default_capabilities]}}).to_json
-      endpoint ||= 'https://ondemand.saucelabs.com/wd/hub/session'
+      endpoint ||= 'https://ondemand.us-west-1.saucelabs.com/wd/hub/session'
       stub_request(:post, endpoint).with(body: body).to_return(valid_response)
     end
 
     before do
+      ENV['BUILD_TAG'] = ''
+      ENV['BUILD_NAME'] = 'TEMP BUILD'
+      ENV['BUILD_NUMBER'] = '11'
       ENV['SAUCE_USERNAME'] = 'foo'
       ENV['SAUCE_ACCESS_KEY'] = '123'
     end
 
     after do
+      ENV.delete 'BUILD_TAG'
+      ENV.delete 'BUILD_NAME'
+      ENV.delete 'BUILD_NUMBER'
       ENV.delete 'SAUCE_USERNAME'
       ENV.delete 'SAUCE_ACCESS_KEY'
     end
 
     describe '#new' do
-      it 'uses latest Chrome version and Windows 10 by default' do
-        session = SimpleSauce::Session.new
+      it 'creates default Options instance if none is provided' do
+        session = Session.new
 
-        expected_results = {url: 'https://foo:123@ondemand.saucelabs.com:443/wd/hub',
+        expected_results = {url: 'https://foo:123@ondemand.us-west-1.saucelabs.com:443/wd/hub',
                             desired_capabilities: {'browserName' => 'chrome',
                                                    'browserVersion' => 'latest',
                                                    'platformName' => 'Windows 10',
-                                                   'sauce:options' => {}}}
+                                                   'sauce:options' => {'build' => 'TEMP BUILD: 11'}}}
         expect(session.to_selenium).to eq expected_results
       end
 
@@ -50,58 +56,37 @@ module SimpleSauce
         sauce_opts = Options.new(browser_version: '123',
                                  platform_name: 'Mac',
                                  idle_timeout: 4)
-        session = SimpleSauce::Session.new(sauce_opts)
+        session = Session.new(sauce_opts)
 
-        expected_results = {url: 'https://foo:123@ondemand.saucelabs.com:443/wd/hub',
+        expected_results = {url: 'https://foo:123@ondemand.us-west-1.saucelabs.com:443/wd/hub',
                             desired_capabilities: {'browserName' => 'chrome',
                                                    'browserVersion' => '123',
                                                    'platformName' => 'Mac',
-                                                   'sauce:options' => {'idleTimeout' => 4}}}
+                                                   'sauce:options' => {'idleTimeout' => 4,
+                                                                       'build' => 'TEMP BUILD: 11'}}}
         expect(session.to_selenium).to eq expected_results
       end
 
-      it 'uses provided Options with Selenium Capabilities and Options classes' do
-        sauce_options = {idle_timeout: 4,
-                         browser_name: 'Firefox',
-                         platform_name: 'Mac OS'}
-
-        se_options = {accept_insecure_certs: false,
-                      page_load_strategy: 'eager'}
-
-        browser_options = {args: ['-foo']}
-
-        sauce_opts = SimpleSauce::Options.new(sauce_options)
-        se_opts = Selenium::WebDriver::Remote::Capabilities.firefox(se_options)
-        browser_opts = Selenium::WebDriver::Firefox::Options.new(browser_options)
-
-        session = SimpleSauce::Session.new([sauce_opts, se_opts, browser_opts])
-
-        expected_capabilities = {'browserName' => 'firefox',
-                                 'platformName' => 'Mac OS',
-                                 'browserVersion' => 'latest',
-                                 'acceptInsecureCerts' => false,
-                                 'pageLoadStrategy' => 'eager',
-                                 'moz:firefoxOptions' => {args: ['-foo']},
-                                 'sauce:options' => {'idleTimeout' => 4}}
-
-        oss_capabilities = {'cssSelectorsEnabled' => false,
-                            'javascriptEnabled' => false,
-                            'marionette' => true,
-                            'nativeEvents' => false,
-                            'platform' => 'ANY',
-                            'rotatable' => false,
-                            'takesScreenshot' => false,
-                            'timeouts' => {},
-                            'version' => ''}
-
-        expected_results = {url: 'https://foo:123@ondemand.saucelabs.com:443/wd/hub',
-                            desired_capabilities: expected_capabilities.merge(oss_capabilities)}
+      it 'defaults to US West data Center' do
+        session = Session.new
+        expect(session.data_center).to eq :US_WEST
+      end
+
+      it 'uses provided Data Center, Username, Access Key' do
+        session = Session.new(data_center: :EU_VDC,
+                              username: 'bar',
+                              access_key: '321')
+
+        expected_results = {url: 'https://bar:321@ondemand.eu-central-1.saucelabs.com:443/wd/hub',
+                            desired_capabilities: {'browserName' => 'chrome',
+                                                   'browserVersion' => 'latest',
+                                                   'platformName' => 'Windows 10',
+                                                   'sauce:options' => {'build' => 'TEMP BUILD: 11'}}}
         expect(session.to_selenium).to eq expected_results
       end
 
-      it 'defaults to US West data Center' do
-        session = SimpleSauce::Session.new
-        expect(session.data_center).to eq :US_WEST
+      it 'raises exception if data center is invalid' do
+        expect { Session.new(data_center: :FOO) }.to raise_exception(ArgumentError)
       end
     end
 
@@ -109,20 +94,20 @@ module SimpleSauce
       it 'starts the session and returns Selenium Driver instance' do
         expect_request
 
-        driver = SimpleSauce::Session.new.start
+        driver = Session.new.start
         expect(driver).to be_a Selenium::WebDriver::Driver
       end
 
       it 'raises exception if no username set' do
         ENV.delete('SAUCE_USERNAME')
 
-        expect { SimpleSauce::Session.new.start }.to raise_exception(ArgumentError)
+        expect { Session.new.start }.to raise_exception(ArgumentError)
       end
 
       it 'raises exception if no access key set' do
         ENV.delete('SAUCE_ACCESS_KEY')
 
-        expect { SimpleSauce::Session.new.start }.to raise_exception(ArgumentError)
+        expect { Session.new.start }.to raise_exception(ArgumentError)
       end
     end
 
@@ -133,8 +118,7 @@ module SimpleSauce
         allow(driver).to receive :quit
         allow(SauceWhisk::Jobs).to receive(:change_status).with('1234', true)
 
-        session = SimpleSauce::Session.new
-
+        session = Session.new
         session.start
         session.stop(true)
 
@@ -145,14 +129,14 @@ module SimpleSauce
 
     describe '#data_center=' do
       it 'overrides default value for data center' do
-        session = SimpleSauce::Session.new
+        session = Session.new
         session.data_center = :US_EAST
 
-        expect(session.url).to eq('https://foo:123@us-east-1.saucelabs.com:443/wd/hub')
+        expect(session.url).to eq('https://foo:123@ondemand.us-east-1.saucelabs.com:443/wd/hub')
       end
 
       it 'raises exception if data center is invalid' do
-        session = SimpleSauce::Session.new
+        session = Session.new
 
         expect { session.data_center = :FOO }.to raise_exception(ArgumentError)
       end
@@ -160,19 +144,33 @@ module SimpleSauce
 
     describe '#username=' do
       it 'accepts provided username' do
-        session = SimpleSauce::Session.new
+        session = Session.new
         session.username = 'name'
 
-        expect(session.url).to eq('https://name:123@ondemand.saucelabs.com:443/wd/hub')
+        expect(session.url).to eq('https://name:123@ondemand.us-west-1.saucelabs.com:443/wd/hub')
       end
     end
 
     describe '#access_key=' do
       it 'accepts provided access key' do
-        session = SimpleSauce::Session.new
+        session = Session.new
         session.access_key = '456'
 
-        expect(session.url).to eq('https://foo:456@ondemand.saucelabs.com:443/wd/hub')
+        expect(session.url).to eq('https://foo:456@ondemand.us-west-1.saucelabs.com:443/wd/hub')
+      end
+    end
+
+    describe '#url=' do
+      it 'allows user to override default URL' do
+        session = Session.new
+        session.url = 'https://bar:321@mycustomurl/foo/wd/hub:8080'
+
+        expected_results = {url: 'https://bar:321@mycustomurl/foo/wd/hub:8080',
+                            desired_capabilities: {'browserName' => 'chrome',
+                                                   'browserVersion' => 'latest',
+                                                   'platformName' => 'Windows 10',
+                                                   'sauce:options' => {'build' => 'TEMP BUILD: 11'}}}
+        expect(session.to_selenium).to eq expected_results
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_sauce
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0.pre.alpha
 platform: ruby
 authors:
 - Titus Fortner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-06 00:00:00.000000000 Z
+date: 2020-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -109,33 +109,39 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.5'
 - !ruby/object:Gem::Dependency
-  name: selenium-webdriver
+  name: sauce_whisk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sauce_whisk
+  name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.142.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.142.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.142.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.142.7
 description: Reduces complexity in user code for running Selenium tests on Sauce Labs
 email:
 - titusfortner@gmail.com
@@ -156,6 +162,7 @@ files:
 - lib/simple_sauce/session.rb
 - lib/simple_sauce/version.rb
 - simple_sauce.gemspec
+- spec/options.yml
 - spec/options_spec.rb
 - spec/session_spec.rb
 - spec/spec_helper.rb
@@ -174,15 +181,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Simple interface for interacting with Sauce Labs.
 test_files:
+- spec/options.yml
 - spec/options_spec.rb
 - spec/session_spec.rb
 - spec/spec_helper.rb