rb - firefox defaults to geckodriver

rb/lib/selenium/webdriver/firefox.rb

@@ -54,7 +54,7 @@ def self.driver_path=(path)
 
       def self.driver_path
         @driver_path ||= begin
-          path = Platform.find_binary('geckodriver*') || Platform.find_binary('wires*')
+          path = Platform.find_binary('geckodriver*')
           raise Error::WebDriverError, MISSING_TEXT unless path
           Platform.assert_executable path
 

rb/lib/selenium/webdriver/remote/bridge.rb

@@ -135,7 +135,7 @@ def get(url)
           execute :get, {}, {url: url}
         end
 
-        def capabilities
+        def session_capabilities
           Capabilities.json_create execute(:getCapabilities)
         end
 

rb/lib/selenium/webdriver/remote/capabilities.rb

@@ -84,7 +84,7 @@ def edge(opts = {})
           end
 
           def firefox(opts = {})
-            return W3CCapabilities.firefox(opts) if opts[:marionette]
+            return W3CCapabilities.firefox(opts) unless opts[:marionette] == false
 
             new({
               browser_name: 'firefox',

rb/lib/selenium/webdriver/remote/w3c_capabilities.rb

@@ -79,16 +79,13 @@ def firefox(opts = {})
             opts[:browser_version] = opts.delete :version
             opts[:platform_name] = opts.delete :platform
 
-            new({
-              browser_name: 'firefox',
-              marionette: true
-            }.merge(opts))
+            new({browser_name: 'firefox'}.merge(opts))
           end
 
           alias_method :ff, :firefox
 
           def w3c?(opts = {})
-            opts[:desired_capabilities].is_a?(W3CCapabilities) || opts[:marionette]
+            !opts[:desired_capabilities].is_a?(Capabilities)
           end
 
           #

rb/spec/integration/selenium/webdriver/firefox/driver_spec.rb

@@ -25,18 +25,30 @@ module Firefox
       compliant_on browser: :firefox do
         describe Driver do
           describe '.new' do
+            before do
+              @opt = {}
+              @opt[:url] = GlobalTestEnv.remote_server.webdriver_url if GlobalTestEnv.driver == :remote
+            end
+
             it 'takes a binary path as an argument' do
               pending "Set ENV['ALT_FIREFOX_BINARY'] to test this" unless ENV['ALT_FIREFOX_BINARY']
 
               begin
                 default_path = Firefox::Binary.path
 
-                driver1 = Selenium::WebDriver.for :firefox
+                caps1 = Remote::Capabilities.firefox(marionette: false)
+                @opt[:desired_capabilities] = caps1
+
+                driver1 = Selenium::WebDriver.for GlobalTestEnv.driver, @opt
                 default_version = driver1.capabilities[:version]
                 driver1.quit
 
-                caps = Remote::Capabilities.firefox(firefox_binary: ENV['ALT_FIREFOX_BINARY'])
-                driver2 = Selenium::WebDriver.for :firefox, desired_capabilities: caps
+                caps2 = Remote::Capabilities.firefox(
+                  firefox_binary: ENV['ALT_FIREFOX_BINARY'],
+                  marionette: false
+                )
+                @opt[:desired_capabilities] = caps2
+                driver2 = Selenium::WebDriver.for GlobalTestEnv.driver, @opt
 
                 expect(driver2.capabilities[:version]).to_not be == default_version
                 driver2.quit
@@ -45,16 +57,21 @@ module Firefox
               end
             end
 
-            it 'takes a Firefox::Profile instance as argument' do
-              begin
-                profile = Selenium::WebDriver::Firefox::Profile.new
-                driver = Selenium::WebDriver.for :firefox, profile: profile
-                stored_profile = driver.instance_variable_get('@bridge')
-                                       .instance_variable_get('@launcher')
-                                       .instance_variable_get('@profile')
-                expect(stored_profile).to be == profile
-              ensure
-                driver.quit if driver
+            not_compliant_on driver: :remote do
+              it 'takes a Firefox::Profile instance as argument' do
+                begin
+                  @opt[:desired_capabilities] = Remote::Capabilities.firefox(marionette: false)
+                  profile = Selenium::WebDriver::Firefox::Profile.new
+                  @opt[:profile] = profile
+                  driver2 = Selenium::WebDriver.for GlobalTestEnv.driver, @opt
+
+                  stored_profile = driver2.instance_variable_get('@bridge')
+                                          .instance_variable_get('@launcher')
+                                          .instance_variable_get('@profile')
+                  expect(stored_profile).to be == profile
+                ensure
+                  driver2.quit if driver2
+                end
               end
             end
           end

rb/spec/integration/selenium/webdriver/firefox/marionette_spec.rb

@@ -21,28 +21,30 @@
 
 module Selenium
   module WebDriver
-    describe Firefox do
-      def restart_remote_server
-        server = GlobalTestEnv.reset_remote_server
-        server.start
-        server.webdriver_url
-      end
+    compliant_on browser: :marionette do
+      describe Firefox do
+        def restart_remote_server
+          server = GlobalTestEnv.reset_remote_server
+          server.start
+          server.webdriver_url
+        end
 
-      before(:all) do
-        driver
-        quit_driver
-      end
+        before(:all) do
+          driver
+          quit_driver
+        end
 
-      before do
-        @opt = {}
-        @opt[:url] = restart_remote_server if GlobalTestEnv.driver == :remote
-      end
+        before(:each) do
+          @opt = {}
+          @opt[:url] = restart_remote_server if GlobalTestEnv.driver == :remote
+        end
 
-      compliant_on browser: :marionette do
         it 'creates default capabilities' do
+          driver_name = GlobalTestEnv.driver
+          driver_name = :firefox if driver_name == :marionette
+
           begin
-            @opt[:marionette] = true
-            driver1 = Selenium::WebDriver.for GlobalTestEnv.driver, @opt
+            driver1 = Selenium::WebDriver.for driver_name, @opt
             expect(driver1.capabilities.browser_version).to match(/^\d\d\./)
             expect(driver1.capabilities.platform_name).to_not be_nil
             expect(driver1.capabilities.platform_version).to_not be_nil
@@ -85,47 +87,26 @@ def restart_remote_server
             end
           end
         end
-      end
 
-      compliant_on browser: :marionette do
-        it 'Uses geckodriver when setting marionette option in capabilities' do
-          caps = Selenium::WebDriver::Remote::Capabilities.firefox(marionette: true)
-          @opt[:desired_capabilities] = caps
-          expect { @driver1 = Selenium::WebDriver.for GlobalTestEnv.driver, @opt }.to_not raise_exception
-          @driver1.quit
-        end
-
-        compliant_on browser: :marionette do
-          # This passes in isolation, but can not run in suite due to combination of
-          # https://bugzilla.mozilla.org/show_bug.cgi?id=1228107 & https://github.com/SeleniumHQ/selenium/issues/1150
-          it 'Uses Wires when setting marionette option in driver initialization' do
-            @opt[:marionette] = true
-            driver1 = Selenium::WebDriver.for GlobalTestEnv.driver, @opt
-
-            expect(driver1.capabilities[:browser_version]).to_not be_nil
-            driver1.quit
+        # https://github.com/mozilla/geckodriver/issues/58
+        not_compliant_on browser: :marionette do
+          context 'when shared example' do
+            it_behaves_like 'driver that can be started concurrently', :marionette
           end
         end
 
-        # test with firefox due to https://bugzilla.mozilla.org/show_bug.cgi?id=1228121
-        compliant_on browser: :firefox do
-          it 'Does not use geckodriver when marionette option is not set' do
+        # Test in isolation: https://bugzilla.mozilla.org/show_bug.cgi?id=1228121
+        not_compliant_on browser: :marionette do
+          it 'Does not use geckodriver when marionette option is set to false' do
+            caps = Remote::Capabilities.firefox(marionette: false)
+            @opt[:desired_capabilities] = caps
+
             driver1 = Selenium::WebDriver.for GlobalTestEnv.driver, @opt
 
             expect { driver1.capabilities.browser_version }.to raise_exception NoMethodError
             driver1.quit
           end
         end
-
-        compliant_on driver: :marionette do
-          # https://github.com/mozilla/geckodriver/issues/58
-          not_compliant_on driver: :marionette do
-            context 'when shared example' do
-              before { driver }
-              it_behaves_like 'driver that can be started concurrently', :marionette
-            end
-          end
-        end
       end
     end
   end # WebDriver

rb/spec/integration/selenium/webdriver/firefox/profile_spec.rb

@@ -145,8 +145,11 @@ def read_generated_prefs(from = nil)
             profile['browser.startup.homepage'] = url_for('formPage.html')
 
             begin
-              driver_one = WebDriver.for(:firefox, profile: profile)
-              driver_two = WebDriver.for(:firefox, profile: profile)
+              opt = {desired_capabilities: Remote::Capabilities.firefox(marionette: false),
+                     profile: profile}
+
+              driver_one = WebDriver.for(:firefox, opt.dup)
+              driver_two = WebDriver.for(:firefox, opt.dup)
             ensure
               driver_one.quit if driver_one
               driver_two.quit if driver_two

rb/spec/integration/selenium/webdriver/spec_support/shared_examples/concurrent_driver.rb

@@ -19,6 +19,9 @@
 
 shared_examples_for 'driver that can be started concurrently' do |browser_name|
   it 'is started sequentially' do
+    marionette = browser_name == :firefox ? {marionette: false} : {}
+    browser_name = :firefox if browser_name == :marionette
+
     expect do
       # start 5 drivers concurrently
       threads = []
@@ -27,13 +30,18 @@
       opt = {}
       if GlobalTestEnv.remote_server?
         opt[:url] = GlobalTestEnv.remote_server.webdriver_url
-        opt[:desired_capabilities] = WebDriver::Remote::Capabilities.send(browser_name)
       end
-      opt[:marionette] = true if browser_name == :marionette
+
+      caps = if browser_name == :firefox
+               WebDriver::Remote::Capabilities.firefox(marionette)
+             else
+               WebDriver::Remote::Capabilities.send(browser_name)
+             end
+      opt[:desired_capabilities] = caps
 
       5.times do
         threads << Thread.new do
-          drivers << Selenium::WebDriver.for(GlobalTestEnv.driver, opt)
+          drivers << Selenium::WebDriver.for(GlobalTestEnv.driver, opt.dup)
         end
       end
 

rb/spec/integration/selenium/webdriver/spec_support/test_environment.rb

@@ -133,12 +133,8 @@ def root
         private
 
         def create_driver
-          instance = if driver == :marionette
-                       create_firefox_driver(true)
-                     else
-                       method = "create_#{driver}_driver"
-                       defined?(method) ? send(method) : WebDriver::Driver.for(driver)
-                     end
+          method = "create_#{driver}_driver"
+          instance = defined?(method) ? send(method) : WebDriver::Driver.for(driver)
 
           @create_driver_error_count -= 1 unless @create_driver_error_count == 0
           instance
@@ -149,15 +145,15 @@ def create_driver
         end
 
         def remote_capabilities
-          if browser == :marionette
-            caps = WebDriver::Remote::Capabilities.firefox(marionette: true)
-          else
-            caps = WebDriver::Remote::Capabilities.send(browser)
+          opt = {}
+          browser_name = browser == :marionette ? :firefox : browser
+          opt[:marionette] = false if browser == :firefox
+
+          caps = WebDriver::Remote::Capabilities.send(browser_name, opt)
 
-            unless caps.is_a? WebDriver::Remote::W3CCapabilities
-              caps.javascript_enabled = true
-              caps.css_selectors_enabled = true
-            end
+          unless caps.is_a? WebDriver::Remote::W3CCapabilities
+            caps.javascript_enabled = true
+            caps.css_selectors_enabled = true
           end
 
           caps
@@ -187,16 +183,15 @@ def create_remote_driver
         end
 
         def create_firefox_driver(marionette = false)
-          opt = marionette ? {marionette: true} : {}
-          binary = ENV['FIREFOX_BINARY']
-          WebDriver::Firefox.path = binary if binary
+          opt = marionette ? {} : {marionette: false}
+          caps = WebDriver::Remote::Capabilities.firefox(opt)
+          WebDriver::Firefox.path = ENV['FIREFOX_BINARY'] if ENV['FIREFOX_BINARY']
 
-          WebDriver::Driver.for :firefox, opt
+          WebDriver::Driver.for :firefox, desired_capabilities: caps
         end
 
-        def create_edge_driver
-          caps = WebDriver::Remote::W3CCapabilities.edge
-          WebDriver.for :edge, desired_capabilities: caps
+        def create_marionette_driver
+          create_firefox_driver(true)
         end
 
         def create_chrome_driver

rb/spec/unit/selenium/webdriver/firefox/bridge_spec.rb

@@ -26,7 +26,7 @@ module Firefox
         let(:launcher) { double(Launcher, launch: nil, url: 'http://localhost:4444/wd/hub') }
         let(:resp) { {'sessionId' => 'foo', 'value' => @default_capabilities} }
         let(:http) { double(Remote::Http::Default, call: resp).as_null_object }
-        let(:caps) { {} }
+        let(:caps) { Remote::Capabilities.chrome }
 
         before do
           @default_capabilities = Remote::Capabilities.firefox.as_json

rb/spec/unit/selenium/webdriver/safari/bridge_spec.rb

@@ -23,7 +23,6 @@ module Selenium
   module WebDriver
     module Safari
       describe Bridge do
-        let(:caps)    { {} }
         let(:server)  { double(Server, receive: response).as_null_object }
         let(:browser) { double(Browser).as_null_object }
 
@@ -40,7 +39,6 @@ module Safari
         before do
           @default_capabilities = Remote::Capabilities.safari.as_json
 
-          allow(Remote::Capabilities).to receive(:safari).and_return(caps)
           allow(Server).to receive(:new).and_return(server)
           allow(Browser).to receive(:new).and_return(browser)
         end