watir 6.5.0 → 6.6.0

data/lib/watir/wait.rb

@@ -37,7 +37,7 @@ module Watir
 
       def until(deprecated_timeout = nil, deprecated_message = nil, timeout: nil, message: nil, interval: nil, object: nil)
         if deprecated_message || deprecated_timeout
-          warn "Instead of passing arguments into Wait#until method, use keywords"
+          Watir.logger.deprecate "Using arguments for Wait#until", "keywords"
           timeout = deprecated_timeout
           message = deprecated_message
         end
@@ -63,7 +63,7 @@ module Watir
 
       def while(deprecated_timeout = nil, deprecated_message = nil, timeout: nil, message: nil, interval: nil, object: nil)
         if deprecated_message || deprecated_timeout
-          warn "Instead of passing arguments into Wait#while method, use keywords"
+          Watir.logger.deprecate "Using arguments for Wait#while", "keywords"
           timeout = deprecated_timeout
           message = deprecated_message
         end
@@ -117,7 +117,7 @@ module Watir
 
     def wait_until(deprecated_timeout = nil, deprecated_message = nil, timeout: nil, message: nil, interval: nil, &blk)
       if deprecated_message || deprecated_timeout
-        warn "Instead of passing arguments into #wait_until, use keywords"
+        Watir.logger.deprecate "Using arguments for #wait_until", "keywords"
         timeout = deprecated_timeout
         message = deprecated_message
       end
@@ -143,7 +143,7 @@ module Watir
 
     def wait_while(deprecated_timeout = nil, deprecated_message = nil, timeout: nil, message: nil, interval: nil, &blk)
       if deprecated_message || deprecated_timeout
-        warn "Instead of passing arguments into #wait_while method, use keywords"
+        Watir.logger.deprecate "Using arguments for #wait_while", "keywords"
         timeout = deprecated_timeout
         message = deprecated_message
       end
@@ -167,7 +167,7 @@ module Watir
 
     def wait_until_present(deprecated_timeout = nil, timeout: nil, interval: nil)
       if deprecated_timeout
-        warn "Instead of passing arguments into #wait_until_present method, use keywords"
+        Watir.logger.deprecate "Using arguments for #wait_until_present", "keywords"
         timeout = deprecated_timeout
       end
       wait_until(timeout: timeout, interval: interval, &:present?)
@@ -187,7 +187,7 @@ module Watir
 
     def wait_while_present(deprecated_timeout = nil, timeout: nil)
       if deprecated_timeout
-        warn "Instead of passing arguments into #wait_while_present method, use keywords"
+        Watir.logger.deprecate "Using arguments for #wait_while_present", "keywords"
         timeout = deprecated_timeout
       end
       wait_while(timeout: timeout) do

data/lib/watirspec.rb

@@ -77,7 +77,7 @@ module WatirSpec
       info << "#{caps.browser_name}"
       info << "#{caps.version}"
 
-      $stderr.puts "running watirspec against #{info.join ' '} using:\n#{WatirSpec.implementation.inspect_args}"
+      Watir.logger.warn "running watirspec against #{info.join ' '} using:\n#{WatirSpec.implementation.inspect_args}"
     rescue
       # ignored
     end

data/lib/watirspec/guards.rb

@@ -12,17 +12,17 @@ module WatirSpec
 
       def report
         gs = WatirSpec.implementation.matching_guards_in(guards)
-        print "\n\nWatirSpec guards for this implementation: "
+        str= "WatirSpec guards for this implementation: \n"
 
         if gs.empty?
-          puts "none."
+          "\tnone."
         else
-          puts
           gs.each do |guard|
             guard[:data][:file] = guard[:data][:file][/\/spec\/(.*):/, 1]
             guard_name = "#{guard[:name]}:".ljust(15)
-            puts " #{guard_name} #{guard[:data].inspect}"
+            str << " \t#{guard_name} #{guard[:data].inspect}"
           end
+          Watir.logger.warn str
         end
       end
     end # class << self

data/lib/watirspec/implementation.rb

@@ -8,6 +8,11 @@ module WatirSpec
       @guard_proc = nil
     end
 
+    def initialize_copy(orig)
+      super
+      @browser_args = Marshal.load( Marshal.dump(@browser_args))
+    end
+
     def browser_class
       @browser_class || raise("browser_class not set")
     end
@@ -30,11 +35,14 @@ module WatirSpec
     end
 
     def inspect_args
-      caps = browser_args.last.delete(:desired_capabilities).send(:capabilities)
-      string = "driver: #{browser_args.first}\n"
-      browser_args.last.each { |arg| string << "#{arg.inspect}\n" }
-      string << "capabilities:\n"
-      caps.each { |k, v| string << "\t#{k}: #{v}\n"}
+      hash = browser_args.last
+      desired_capabilities = hash.delete(:desired_capabilities)
+      caps = desired_capabilities.send(:capabilities)
+      string = "\tdriver: #{browser_args.first}\n"
+      hash.each { |arg| string << "#{arg.inspect}\n" }
+      string << "\tcapabilities:\n"
+      caps.each { |k, v| string << "\t\t#{k}: #{v}\n"}
+      hash[:desired_capabilities] = desired_capabilities
       string
     end
   end # Implementation

data/lib/watirspec/remote_server.rb

@@ -0,0 +1,38 @@
+module WatirSpec
+  class RemoteServer
+    attr_reader :server
+
+    def start(port = 4444)
+      require 'selenium/server'
+
+      @server ||= Selenium::Server.new(jar,
+                                       port: Selenium::WebDriver::PortProber.above(port),
+                                       log: !!$DEBUG,
+                                       background: true,
+                                       timeout: 60)
+      @server.start
+      at_exit { @server.stop }
+    end
+
+    private
+
+    def jar
+      if ENV['LOCAL_SELENIUM']
+        local = File.expand_path('../selenium/buck-out/gen/java/server/src/org/openqa/grid/selenium/selenium.jar')
+      end
+
+      if File.exist?(ENV['REMOTE_SERVER_BINARY'] || '')
+        ENV['REMOTE_SERVER_BINARY']
+      elsif ENV['LOCAL_SELENIUM'] && File.exists?(local)
+        local
+      elsif !Dir.glob('*selenium*.jar').empty?
+        Dir.glob('*selenium*.jar').first
+      else
+        Selenium::Server.download :latest
+      end
+    rescue SocketError
+      # not connected to internet
+      raise Watir::Exception::Error, "unable to find or download selenium-server-standalone jar"
+    end
+  end
+end

data/lib/watirspec/runner.rb

@@ -35,8 +35,8 @@ module WatirSpec
         config.include(BrowserHelper)
         config.include(MessagesHelper)
 
-        $browser = WatirSpec.new_browser
-        at_exit { $browser.close }
+        config.before(:suite) { $browser = WatirSpec.new_browser }
+        config.after(:suite) { $browser.close }
       end
     end
 

data/lib/watirspec/server.rb

@@ -54,7 +54,7 @@ module WatirSpec
 
         client.write(response(status, headers, body))
       rescue Errno::ECONNRESET
-        STDERR.puts 'Client reset connection, skipping.'
+        Watir.logger.warn 'Client reset connection, skipping.'
       ensure
         client.close
       end

data/spec/browser_spec.rb

@@ -3,19 +3,103 @@ require 'watirspec_helper'
 describe Watir::Browser do
 
   describe ".new" do
-    it "passes the args to Selenium" do
-      expect(Selenium::WebDriver).to receive(:for).with(:firefox, :foo).and_return(nil)
-      Watir::Browser.new(:firefox, :foo)
-    end
-
-    it "takes a Driver instance as argument" do
-      mock_driver = double(Selenium::WebDriver::Driver)
-      expect(Selenium::WebDriver::Driver).to receive(:===).with(mock_driver).and_return(true)
-      expect { Watir::Browser.new(mock_driver) }.to_not raise_error
-    end
-
-    it "raises ArgumentError for invalid args" do
-      expect { Watir::Browser.new(Object.new) }.to raise_error(ArgumentError)
+    not_compliant_on :remote do
+      context "with parameters" do
+        let(:url) {"http://localhost:4544/wd/hub/"}
+
+        before(:all) do
+          @original = WatirSpec.implementation.clone
+
+          require 'watirspec/remote_server'
+          WatirSpec::RemoteServer.new.start(4544)
+          browser.close
+        end
+
+        before(:each) do
+          @opts = WatirSpec.implementation.browser_args.last
+        end
+
+        after(:each) do
+          WatirSpec.implementation = @original.clone
+        end
+
+        after(:all) do
+          $browser = WatirSpec.new_browser
+        end
+
+        it "uses remote client based on provided url" do
+          @opts.merge!(url: url)
+          new_browser = WatirSpec.new_browser
+
+          server_url = new_browser.driver.instance_variable_get('@bridge').http.instance_variable_get('@server_url')
+          expect(server_url).to eq URI.parse(url)
+          new_browser.close
+        end
+
+        it "sets client timeout" do
+          @opts.merge!(url: url, open_timeout: 44, read_timeout: 47)
+          new_browser = WatirSpec.new_browser
+
+          http = new_browser.driver.instance_variable_get('@bridge').http
+
+          expect(http.open_timeout).to eq 44
+          expect(http.read_timeout).to eq 47
+          new_browser.close
+        end
+
+        it "accepts http_client" do
+          http_client = Selenium::WebDriver::Remote::Http::Default.new
+          @opts.merge!(url: url, http_client: http_client)
+          new_browser = WatirSpec.new_browser
+
+          expect(new_browser.driver.instance_variable_get('@bridge').http).to eq http_client
+          new_browser.close
+        end
+
+        compliant_on :firefox do
+          it "accepts Remote::Capabilities instance as :desired_capabilities" do
+            caps = Selenium::WebDriver::Remote::Capabilities.firefox(accept_insecure_certs: true)
+            @opts.merge!(url: url, desired_capabilities: caps)
+
+            expect { @new_browser = WatirSpec.new_browser }.to output.to_stderr
+
+            expect(@new_browser.driver.capabilities['acceptInsecureCerts']).to eq true
+            @new_browser.close
+          end
+        end
+
+        compliant_on :firefox do
+          it "accepts individual driver capabilities" do
+            @opts.merge!(accept_insecure_certs: true)
+            new_browser = WatirSpec.new_browser
+
+            expect(new_browser.driver.capabilities[:accept_insecure_certs]).to eq true
+            new_browser.close
+          end
+        end
+
+        compliant_on :chrome do
+          it "accepts browser options" do
+            @opts.merge!(options: {emulation: {userAgent: 'foo;bar'}})
+
+            new_browser = WatirSpec.new_browser
+
+            ua = new_browser.execute_script 'return window.navigator.userAgent'
+            expect(ua).to eq('foo;bar')
+            new_browser.close
+          end
+        end
+      end
+
+      it "takes a driver instance as argument" do
+        mock_driver = double(Selenium::WebDriver::Driver)
+        expect(Selenium::WebDriver::Driver).to receive(:===).with(mock_driver).and_return(true)
+        expect { Watir::Browser.new(mock_driver) }.to_not raise_error
+      end
+
+      it "raises ArgumentError for invalid args" do
+        expect { Watir::Browser.new(Object.new) }.to raise_error(ArgumentError)
+      end
     end
   end
 
@@ -67,11 +151,11 @@ describe Watir::Browser do
 
   bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1290814", :firefox do
     it "raises an error when trying to interact with a closed browser" do
-      b = WatirSpec.new_browser
-      b.goto WatirSpec.url_for "definition_lists.html"
-      b.close
+      browser.goto WatirSpec.url_for "definition_lists.html"
+      browser.close
 
-      expect { b.dl(id: "experience-list").id }.to raise_error(Watir::Exception::Error, "browser was closed")
+      expect { browser.dl(id: "experience-list").id }.to raise_error(Watir::Exception::Error, "browser was closed")
+      $browser = WatirSpec.new_browser
     end
   end
 

data/spec/element_locator_spec.rb

@@ -303,7 +303,7 @@ describe Watir::Locators::Element::Locator do
       it "raises a TypeError if selector value is not a String, Regexp or Boolean" do
         num_type = RUBY_VERSION[/^\d+\.(\d+)/, 1].to_i >= 4 ? 'Integer' : 'Fixnum'
         expect { locate_one(tag_name: 123) }.to \
-        raise_error(TypeError, %[expected one of [Array, String, Regexp, TrueClass, FalseClass], got 123:#{num_type}])
+        raise_error(TypeError, %[expected one of [Array, String, Regexp, TrueClass, FalseClass, Symbol], got 123:#{num_type}])
       end
 
       it "raises a MissingWayOfFindingObjectException if the attribute is not valid" do

data/spec/element_spec.rb

@@ -45,7 +45,7 @@ describe Watir::Element do
     end
 
     it "raises UnknownObjectException if the element doesn't exist" do
-      expect { browser.element(name: "no_such_name").enabled? }.to raise_error(Watir::Exception::UnknownObjectException)
+      expect { browser.element(name: "no_such_name").enabled? }.to raise_unknown_object_exception
     end
   end
 

data/spec/logger_spec.rb

@@ -0,0 +1,46 @@
+require 'watirspec_helper'
+
+module Watir
+  describe Logger do
+    around do |example|
+      debug = $DEBUG
+      $DEBUG = false
+      example.call
+      $DEBUG = debug
+      Watir.instance_variable_set(:@logger, nil) # reset cache
+    end
+
+    it 'logs warnings by default' do
+      expect(Watir.logger.level).to eq(2)
+    end
+
+    it 'logs everything if $DEBUG is set to true' do
+      $DEBUG = true
+      expect(Watir.logger.level).to eq(0)
+    end
+
+    it 'allows to change level during execution' do
+      Watir.logger.level = :info
+      expect(Watir.logger.level).to eq(1)
+    end
+
+    it 'outputs to stdout by default' do
+      expect { Watir.logger.warn('message') }.to output(/WARN Watir message/).to_stdout
+    end
+
+    it 'allows to output to file' do
+      begin
+        Watir.logger.output = 'test.log'
+        Watir.logger.warn('message')
+        expect(File.read('test.log')).to include('WARN Watir message')
+      ensure
+        File.delete('test.log')
+      end
+    end
+
+    it 'allows to deprecate functionality' do
+      message = /WARN Watir \[DEPRECATION\] #old is deprecated\. Use #new instead\./
+      expect { Watir.logger.deprecate('#old', '#new') }.to output(message).to_stdout
+    end
+  end
+end

data/spec/watirspec/adjacent_spec.rb

@@ -21,6 +21,10 @@ describe "Adjacent Elements" do
       expect(browser.div(id: "first_sibling").parent(tag_name: :div)).to be_a Watir::Div
     end
 
+    it "accepts class_name argument" do
+      expect(browser.div(id: "first_sibling").parent(class_name: 'parent').id).to eq 'parent_span'
+    end
+
     it "accepts index and tag_name arguments" do
       expect(browser.div(id: "first_sibling").parent(tag_name: :div, index: 1).id).to eq 'grandparent'
       expect(browser.div(id: "first_sibling").parent(tag_name: :div, index: 1)).to be_a Watir::Div
@@ -51,11 +55,23 @@ describe "Adjacent Elements" do
       expect(browser.div(id: "first_sibling").following_sibling(tag_name: :div)).to be_a Watir::Div
     end
 
+    it "accepts class_name argument" do
+      expect(browser.div(id: "first_sibling").following_sibling(class_name: 'b').id).to eq 'second_sibling'
+    end
+
     it "accepts index and tag_name arguments" do
       expect(browser.div(id: "first_sibling").following_sibling(tag_name: :div, index: 1).id).to eq 'third_sibling'
       expect(browser.div(id: "first_sibling").following_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
     end
 
+    it "accepts text as Regexp" do
+      expect(browser.div(id: "first_sibling").following_sibling(text: /t/).id).to eq 'third_sibling'
+    end
+
+    it "accepts text as String" do
+      expect(browser.div(id: "first_sibling").following_sibling(text: 'text').id).to eq 'third_sibling'
+    end
+
     it "does not error when no next sibling of an index exists" do
       expect(browser.body.following_sibling(index: 1)).to_not exist
     end
@@ -75,6 +91,16 @@ describe "Adjacent Elements" do
       expect(browser.div(id: "second_sibling").following_siblings(tag_name: :div).size).to eq 1
       expect(browser.div(id: "second_sibling").following_siblings(tag_name: :div).first).to be_a Watir::Div
     end
+
+    it "accepts class_name argument" do
+      expect(browser.div(id: "second_sibling").following_siblings(class_name: 'b').size).to eq 1
+      expect(browser.div(id: "second_sibling").following_siblings(class_name: 'b').first).to be_a Watir::Div
+    end
+
+    it "accepts class_name argument for multiple classes" do
+      expect(browser.div(id: "second_sibling").following_siblings(class_name: ['a','b']).size).to eq 1
+      expect(browser.div(id: "second_sibling").following_siblings(class_name: ['a', 'b']).first).to be_a Watir::Div
+    end
   end
 
   describe "#previous_sibling" do
@@ -93,6 +119,10 @@ describe "Adjacent Elements" do
       expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :div)).to be_a Watir::Div
     end
 
+    it "accepts class_name argument" do
+      expect(browser.div(id: "third_sibling").previous_sibling(class_name: 'a').id).to eq 'between_siblings2'
+    end
+
     it "accepts index and tag_name arguments" do
       expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :div, index: 1).id).to eq 'first_sibling'
       expect(browser.div(id: "third_sibling").previous_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
@@ -117,6 +147,11 @@ describe "Adjacent Elements" do
       expect(browser.div(id: "second_sibling").previous_siblings(tag_name: :div).size).to eq 1
       expect(browser.div(id: "second_sibling").previous_siblings(tag_name: :div).first).to be_a Watir::Div
     end
+
+    it "accepts class_name argument" do
+      expect(browser.div(id: "second_sibling").previous_siblings(class_name: 'a').size).to eq 1
+      expect(browser.div(id: "second_sibling").previous_siblings(class_name: 'a').first.id).to eq 'between_siblings1'
+    end
   end
 
   describe "#child" do
@@ -135,6 +170,10 @@ describe "Adjacent Elements" do
       expect(browser.div(id: "parent").child(tag_name: :span)).to be_a Watir::Span
     end
 
+    it "accepts class_name argument" do
+      expect(browser.div(id: "parent").child(class_name: 'b').id).to eq 'second_sibling'
+    end
+
     it "accepts index and tag_name arguments" do
       expect(browser.div(id: "parent").child(tag_name: :div, index: 1).id).to eq 'second_sibling'
       expect(browser.div(id: "parent").child(tag_name: :div, index: 1)).to be_a Watir::Div
@@ -160,5 +199,11 @@ describe "Adjacent Elements" do
       expect(children.size).to eq 3
       expect(children.all? { |child| child.is_a? Watir::Div }).to eq true
     end
+
+    it "accepts a class_name argument" do
+      children = browser.div(id: "parent").children(class_name: 'b')
+      expect(children.size).to eq 2
+      expect(children.all? { |child| child.is_a? Watir::Div }).to eq true
+    end
   end
 end