watir 6.0.0.beta5 → 6.0.0

data/lib/watir/wait/timer.rb

@@ -2,6 +2,10 @@ module Watir
   module Wait
     class Timer
 
+      def initialize(timeout: nil)
+        @end_time = current_time + timeout if timeout
+      end
+
       #
       # Executes given block until it returns true or exceeds timeout.
       # @param [Fixnum] timeout
@@ -10,8 +14,31 @@ module Watir
       #
 
       def wait(timeout, &block)
-        end_time = ::Time.now + timeout
-        yield(block) until ::Time.now > end_time
+        end_time = @end_time || current_time + timeout
+        loop do
+          yield(block)
+          break if current_time > end_time
+        end
+      end
+
+      def reset!
+        @end_time = nil
+      end
+
+      def locked?
+        !@end_time.nil?
+      end
+
+      private
+
+      if defined?(Process::CLOCK_MONOTONIC)
+        def current_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      else
+        def current_time
+          Time.now.to_f
+        end
       end
 
     end # Timer

data/lib/watir/window.rb

@@ -1,6 +1,7 @@
 module Watir
   class Window
     include EventuallyPresent
+    include Waitable
 
     def initialize(driver, selector)
       @driver = driver
@@ -189,7 +190,7 @@ module Watir
     #
 
     def use(&blk)
-      assert_exists
+      wait_for_exists
       @driver.switch_to.window(handle, &blk)
       self
     end
@@ -240,5 +241,14 @@ module Watir
       false
     end
 
+    def wait_for_exists
+      return assert_exists unless Watir.relaxed_locate?
+      begin
+        wait_until(&:exists?)
+      rescue Wait::TimeoutError
+        raise Exception::NoMatchingWindowFoundException, @selector.inspect
+      end
+    end
+
   end # Window
 end # Watir

data/lib/watirspec.rb

@@ -0,0 +1,81 @@
+require "tmpdir"
+require 'watirspec/guards'
+require 'watirspec/implementation'
+require 'watirspec/runner'
+require 'watirspec/server'
+
+module WatirSpec
+  class << self
+    attr_accessor :browser_args, :unguarded, :implementation
+
+    def html
+      @html ||= File.expand_path("../../spec/watirspec/html", __FILE__)
+    end
+
+    def run!
+      WatirSpec::Runner.execute_if_necessary
+    end
+
+    def url_for(str)
+      File.join(host, str)
+    end
+
+    def host
+      @host ||= "http://#{Server.bind}:#{Server.port}"
+    end
+
+    def unguarded?
+      @unguarded ||= false
+    end
+
+    def implementation
+      @implementation ||= (
+        imp = WatirSpec::Implementation.new
+        yield imp if block_given?
+
+        imp
+      )
+    end
+
+    def implementation=(imp)
+      unless imp.is_a?(WatirSpec::Implementation)
+        raise TypeError, "expected WatirSpec::Implementation, got #{imp.class}"
+      end
+
+      @implementation = imp
+    end
+
+    def new_browser
+      klass = WatirSpec.implementation.browser_class
+      args = Array(WatirSpec.implementation.browser_args).map { |e| Hash === e ? e.dup : e }
+
+      instance = klass.new(*args)
+      print_browser_info_once(instance)
+
+      instance
+    end
+
+    private
+
+    def print_browser_info_once(instance)
+      return if defined?(@did_print_browser_info) && @did_print_browser_info
+      @did_print_browser_info = true
+
+      info = []
+      info << instance.class.name
+
+      if instance.respond_to?(:driver) && instance.driver.class.name == "Selenium::WebDriver::Driver"
+        info << "(webdriver)"
+        caps = instance.driver.capabilities
+
+        info << "#{caps.browser_name}"
+        info << "#{caps.version}"
+      end
+
+      $stderr.puts "running watirspec against #{info.join ' '} using args #{WatirSpec.implementation.browser_args.inspect}"
+    rescue
+      # ignored
+    end
+
+  end # class << WatirSpec
+end # WatirSpec

data/lib/watirspec/guards.rb

@@ -0,0 +1,58 @@
+module WatirSpec
+  module Guards
+
+    class << self
+      def guards
+        @guards ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def record(guard_name, impls, data)
+        guards[impls] << {name: guard_name, data: data}
+      end
+
+      def report
+        gs = WatirSpec.implementation.matching_guards_in(guards)
+        print "\n\nWatirSpec guards for this implementation: "
+
+        if gs.empty?
+         puts "none."
+        else
+          puts
+          gs.each do |guard|
+            puts "\t#{guard[:name].to_s.ljust(20)}: #{guard[:data].inspect}"
+          end
+        end
+      end
+    end # class << self
+
+    private
+
+    def deviates_on(*impls)
+      Guards.record :deviates, impls, file: caller.first
+      return yield if WatirSpec.unguarded?
+      yield if WatirSpec.implementation.matches_guard?(impls)
+    end
+
+    def not_compliant_on(*impls)
+      Guards.record :not_compliant, impls, file: caller.first
+      return yield if WatirSpec.unguarded?
+      yield unless WatirSpec.implementation.matches_guard?(impls)
+    end
+
+    def compliant_on(*impls)
+      Guards.record :compliant, impls, file: caller.first
+      return yield if WatirSpec.unguarded?
+      yield if WatirSpec.implementation.matches_guard?(impls)
+    end
+
+    def bug(key, *impls)
+      Guards.record :bug, impls, file: caller.first, key: key
+      return yield if WatirSpec.unguarded?
+      yield unless WatirSpec.implementation.matches_guard?(impls)
+    end
+  end
+end
+
+class Object
+  include WatirSpec::Guards
+end

data/lib/watirspec/implementation.rb

@@ -0,0 +1,33 @@
+module WatirSpec
+  class Implementation
+
+    attr_writer :name, :guard_proc, :browser_class
+    attr_accessor :browser_args
+
+    def initialize
+      @guard_proc = nil
+    end
+
+    def browser_class
+      @browser_class || raise("browser_class not set")
+    end
+
+    def name
+      @name || raise("implementation name not set")
+    end
+
+    def matches_guard?(args)
+      return @guard_proc.call(args) if @guard_proc
+
+      args.include? name
+    end
+
+    def matching_guards_in(guards)
+      result = []
+      guards.each { |args, data| data.each { |d| result << d } if matches_guard?(args) }
+
+      result
+    end
+
+  end # Implementation
+end # WatirSpec

data/lib/watirspec/rake_tasks.rb

@@ -0,0 +1,115 @@
+require 'rake/tasklib'
+
+module WatirSpec
+  class RakeTasks < Rake::TaskLib
+    def initialize
+      namespace :watirspec do
+        desc 'Initialize WatirSpec'
+        task :init do
+          init_watirspec
+          print_usage
+        end
+
+        desc 'List WatirSpec examples'
+        task :list do
+          print_specs
+        end
+
+        desc 'Run WatirSpec examples'
+        task :run, %i(spec line) do |_, args|
+          run(args)
+        end
+      end
+    end
+
+    private
+
+    def init_watirspec
+      Dir.mkdir('spec') unless Dir.exist?('spec')
+      return if File.exist?('spec/watirspec_helper.rb')
+
+      File.open('spec/watirspec_helper.rb', 'w') do |file|
+        file.write(watirspec_helper_template)
+      end
+    end
+
+    def print_specs
+      puts "The following spec files are present:\n\n"
+      spec_files.each do |file|
+        filename = file.sub("#{watirspec_path}/", '')
+        puts "  #{filename}"
+      end
+    end
+
+    def run(**args)
+      return if system(rspec_command(args))
+      exit $?.exitstatus || 1
+    end
+
+    def rspec_command(**args)
+      cmd = [rspec_binary]
+      if args[:spec]
+        spec_file = spec_files.find { |file| file == "#{watirspec_path}/#{args[:spec]}_spec.rb" }
+        spec_file << ":#{args[:line]}" if args[:line]
+        cmd << spec_file
+      else
+        cmd << spec_files
+      end
+
+      cmd.join(' ')
+    end
+
+    def spec_files
+      Dir.glob("#{watirspec_path}/**/*_spec.rb")
+    end
+
+    def rspec_binary
+      rspec_path = Bundler.rubygems.find_name('rspec-core').first.full_gem_path
+      "#{rspec_path}/exe/rspec"
+    end
+
+    def watirspec_path
+      watir_path = Bundler.rubygems.find_name('watir').first.full_gem_path
+      "#{watir_path}/spec/watirspec"
+    end
+
+    def watirspec_helper_template
+      <<-RUBY
+require 'watirspec'
+# require your gems
+
+WatirSpec.implementation do |watirspec|
+  # add WatirSpec implementation (see example below)
+  #
+  # watirspec.name = :watizzle
+  # watirspec.browser_class = Watir::Browser
+  # watirspec.browser_args = [:phantomjs, {}]
+  # watirspec.guard_proc = lambda do |args|
+  #   args.include?(:phantomjs)
+  # end
+end
+
+WatirSpec.run!
+      RUBY
+    end
+
+    def print_usage
+      p <<-EOS
+File spec/watirspec_helper.rb is successfully created!
+Please, check it and customize for your needs. Once done, you can start using WatirSpec.
+
+Run all WatirSpec examples:
+  $ bundle exec rake watirspec:run
+
+Run specific WatirSpec example:
+  $ bundle exec rake watirspec:run[elements/div]
+
+Run WatirSpec example on a custom line:
+  $ bundle exec rake watirspec:run[elements/div, 50]
+
+List all WatirSpec examples:
+  $ bundle exec rake watirspec:list
+      EOS
+    end
+  end
+end

data/lib/watirspec/runner.rb

@@ -0,0 +1,53 @@
+module WatirSpec
+  module Runner
+
+    module BrowserHelper
+      def browser
+        $browser
+      end
+    end
+
+    module MessagesHelper
+      def messages
+        browser.div(id: 'messages').divs.map(&:text)
+      end
+    end
+
+    module_function
+
+    def execute
+      start_server
+      configure
+      add_guard_hook
+
+      @executed = true
+    end
+
+    def execute_if_necessary
+      execute unless @executed
+    end
+
+    def configure
+      Thread.abort_on_exception = true
+      return unless defined?(RSpec)
+
+      RSpec.configure do |config|
+        config.include(BrowserHelper)
+        config.include(MessagesHelper)
+
+        $browser = WatirSpec.new_browser
+        at_exit { $browser.close }
+      end
+    end
+
+    def start_server
+      WatirSpec::Server.run!
+    end
+
+    def add_guard_hook
+      return if WatirSpec.unguarded?
+      at_exit { WatirSpec::Guards.report }
+    end
+
+  end # SpecHelper
+end # WatirSpec

data/lib/watirspec/server.rb

@@ -0,0 +1,99 @@
+require 'socket'
+require 'watirspec/server/app'
+
+module WatirSpec
+  class Server
+    class << self
+      def run!
+        return if running?
+        Thread.new do
+          run_server
+          wait_for_connection
+        end
+      end
+
+      def port
+        @port ||= Selenium::WebDriver::PortProber.above(8180)
+      end
+
+      def bind
+        @bind ||= Selenium::WebDriver::Platform.windows? ? '127.0.0.1' : '0.0.0.0'
+      end
+
+      private
+
+      def running?
+        @running
+      end
+
+      def run_server
+        server = TCPServer.new(bind, port)
+        @running = true
+        loop do
+          Thread.start(server.accept) { |client| accept_client(client) }
+        end
+      end
+
+      def wait_for_connection
+        socket_poller = Selenium::WebDriver::SocketPoller.new(bind, port, 30)
+        return if socket_poller.connected?
+        raise 'Cannot start WatirSpec server.'
+      end
+
+      def app
+        @app ||= App.new
+      end
+
+      def accept_client(client)
+        start_line = client.gets
+        return unless start_line
+
+        _, path = start_line.split
+        status, headers, body = app.response(path, read_body(client))
+        headers = prepare_headers(headers, body)
+
+        client.write(response(status, headers, body))
+      rescue Errno::ECONNRESET
+        STDERR.puts 'Client reset connection, skipping.'
+      ensure
+        client.close
+      end
+
+      def read_body(client)
+        request_headers = read_headers(client)
+        client.read(request_headers['Content-Length'].to_i)
+      end
+
+      def read_headers(client)
+        headers = {}
+        while (line = client.gets.split(' ', 2))
+          break if line[0] == ''
+          headers[line[0].chop] = line[1].strip
+        end
+
+        headers
+      end
+
+      def prepare_headers(headers, body)
+        headers = default_headers.merge(headers)
+        headers['Content-Length'] = body.size.to_s
+        headers.to_a.map { |array| array.join(': ') }
+      end
+
+      def default_headers
+        {
+          'Cache-Control' => 'no-cache',
+          'Connection' => 'close',
+          'Content-Type' => 'text/html; charset=UTF-8',
+          'Server' => 'watirspec'
+        }
+      end
+
+      def response(status, headers, body)
+        response = ["HTTP/1.1 #{status}"] + headers
+        response = response.join("\r\n")
+        response << "\r\n\r\n#{body}\r\n"
+      end
+    end # class << Server
+  end # Server
+end # WatirSpec