watir 6.19.1 → 7.0.0.beta1

data/.github/workflows/unit.yml

@@ -1,37 +0,0 @@
-name: Unit Tests
-
-on:
-  - push
-  - pull_request
-
-jobs:
-  unit-test:
-    name: Unit Tests
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ['2.5', '2.6', '2.7', '3.0']
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-      - run: bundle install
-      - uses: ./.github/actions/install-chrome
-      - run: Xvfb :99 &
-      - run: |
-          bundle exec rake spec:unit
-        env:
-          DISPLAY: :99
-
-  linter-test:
-    name: Rubocop Tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 2.5
-      - run: bundle install
-      - run: bundle exec rubocop

data/.github/workflows/windows.yml

@@ -1,39 +0,0 @@
-name: Windows Tests
-
-on:
-  - push
-  - pull_request
-
-jobs:
-  chrome-test:
-    name: Chrome Test
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        task: [ 'chrome' ]
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 2.5
-      - run: bundle install
-      - run: |
-          bundle exec rake spec:${{ matrix.task }}
-  firefox-test:
-    name: Firefox Test
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        task: [ 'firefox' ]
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 2.5
-      - run: bundle install
-      - run: |
-          bundle exec rake spec:${{ matrix.task }}
-
-

data/lib/watir/legacy_wait.rb

@@ -1,123 +0,0 @@
-require 'forwardable'
-
-# TODO: - remove this file for future release
-module Watir
-  class BaseDecorator
-    def initialize(element, timeout, message = nil)
-      @element = element
-      @timeout = timeout
-      @message = message
-    end
-
-    def respond_to_missing?(*args)
-      @element.respond_to?(*args) || super
-    end
-
-    def method_missing(method, *args, &block)
-      return super unless @element.respond_to?(method)
-
-      Wait.until(@timeout, @message) { wait_until }
-
-      @element.__send__(method, *args, &block)
-    end
-  end
-
-  #
-  # Wraps an Element so that any subsequent method calls are
-  # put on hold until the element is present (exists and is visible) on the page.
-  #
-
-  class WhenPresentDecorator < BaseDecorator
-    def present?
-      Wait.until(@timeout, @message) { wait_until }
-      true
-    rescue Wait::TimeoutError
-      false
-    end
-
-    private
-
-    def wait_until
-      @element.present?
-    end
-  end # WhenPresentDecorator
-
-  #
-  # Wraps an Element so that any subsequent method calls are
-  # put on hold until the element is enabled (exists and is enabled) on the page.
-  #
-
-  class WhenEnabledDecorator < BaseDecorator
-    private
-
-    def wait_until
-      @element.enabled?
-    end
-  end # WhenEnabledDecorator
-
-  #
-  # Convenience methods for things that eventually become present.
-  #
-  # Includers should implement a public #present? and a (possibly private) #selector_string method.
-  #
-
-  module EventuallyPresent
-    #
-    # Waits until the element is present.
-    #
-    # @example
-    #   browser.text_field(name: "new_user_first_name").when_present.click
-    #   browser.text_field(name: "new_user_first_name").when_present { |field| field.set "Watir" }
-    #   browser.text_field(name: "new_user_first_name").when_present(60).text
-    #
-    # @param [Integer] timeout seconds to wait before timing out
-    #
-    # @see Watir::Wait
-    # @see Watir::Element#present?
-    #
-
-    def when_present(timeout = nil)
-      msg = '#when_present'
-      repl_msg = '#wait_until_present if a wait is still needed'
-      Watir.logger.deprecate msg, repl_msg, ids: [:when_present]
-
-      timeout ||= Watir.default_timeout
-      message = "waiting for #{selector_string} to become present"
-
-      if block_given?
-        Wait.until(timeout, message) { present? }
-        yield self
-      else
-        WhenPresentDecorator.new(self, timeout, message)
-      end
-    end
-
-    #
-    # Waits until the element is enabled.
-    #
-    # @example
-    #   browser.button(name: "new_user_button_2").when_enabled.click
-    #
-    # @param [Integer] timeout seconds to wait before timing out
-    #
-    # @see Watir::Wait
-    # @see Watir::Element#enabled?
-    #
-
-    def when_enabled(timeout = nil)
-      msg = '#when_enabled'
-      repl_msg = 'wait_until(&:enabled?)'
-      Watir.logger.deprecate msg, repl_msg, ids: [:when_enabled]
-
-      timeout ||= Watir.default_timeout
-      message = "waiting for #{selector_string} to become enabled"
-
-      if block_given?
-        Wait.until(timeout, message) { enabled? }
-        yield self
-      else
-        WhenEnabledDecorator.new(self, timeout, message)
-      end
-    end
-  end # EventuallyPresent
-end # Watir

data/spec/unit/container_spec.rb

@@ -1,35 +0,0 @@
-require_relative 'unit_helper'
-
-describe Watir::Container do
-  before { @container = Object.new.extend(Watir::Container) }
-
-  describe '#extract_selector' do
-    before do
-      def @container.public_extract_selector(*args)
-        extract_selector(*args)
-      end
-    end
-
-    it 'converts 2-arg selector into a hash' do
-      expect {
-        expect(@container.public_extract_selector([:how, 'what'])).to eq Hash[how: 'what']
-      }.to have_deprecated_selector_parameters
-    end
-
-    it 'returns the hash given' do
-      expect(@container.public_extract_selector([{how: 'what'}])).to eq Hash[how: 'what']
-    end
-
-    it 'returns an empty hash if given no args' do
-      expect(@container.public_extract_selector([])).to eq Hash[]
-    end
-
-    it 'raises ArgumentError if given 1 arg which is not a Hash' do
-      expect { @container.public_extract_selector([:how]) }.to raise_error(ArgumentError)
-    end
-
-    it 'raises ArgumentError if given > 2 args' do
-      expect { @container.public_extract_selector([:how, 'what', 'value']) }.to raise_error(ArgumentError)
-    end
-  end
-end

data/spec/watirspec/legacy_wait_spec.rb

@@ -1,216 +0,0 @@
-require 'watirspec_helper'
-
-describe Watir::Element do
-  before do
-    browser.goto WatirSpec.url_for('wait.html')
-  end
-
-  compliant_on :relaxed_locate do
-    describe '#wait_until_present' do
-      it 'waits until the element appears' do
-        browser.a(id: 'show_bar').click
-        expect {
-          expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
-        }.to have_deprecated_wait_until_present
-      end
-
-      bug 'Safari does not recognize date type', :safari do
-        it 'waits until the element re-appears' do
-          browser.link(id: 'readd_bar').click
-          expect {
-            expect { browser.div(id: 'bar').wait_until_present }.to_not raise_exception
-          }.to have_deprecated_wait_until_present
-        end
-      end
-
-      it "times out if the element doesn't appear" do
-        inspected = '#<Watir::Div: located: true; {:id=>"bar", :tag_name=>"div"}>'
-        error = Watir::Wait::TimeoutError
-        message = "timed out after 1 seconds, waiting for #{inspected} to become present"
-
-        expect {
-          expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(error, message)
-        }.to have_deprecated_wait_until_present
-      end
-
-      it 'uses provided interval' do
-        element = browser.div(id: 'bar')
-        expect(element).to receive(:present?).twice
-
-        expect {
-          expect { element.wait_until_present(timeout: 0.4, interval: 0.2) }.to raise_timeout_exception
-        }.to have_deprecated_wait_until_present
-      end
-    end
-
-    describe '#wait_while_present' do
-      it 'waits until the element disappears' do
-        browser.a(id: 'hide_foo').click
-        expect {
-          expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
-        }.to have_deprecated_wait_while_present
-      end
-
-      it "times out if the element doesn't disappear" do
-        error = Watir::Wait::TimeoutError
-        inspected = '#<Watir::Div: located: true; {:id=>"foo", :tag_name=>"div"}>'
-        message = "timed out after 1 seconds, waiting for #{inspected} not to be present"
-        expect {
-          expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(error, message)
-        }.to have_deprecated_wait_while_present
-      end
-
-      it 'uses provided interval' do
-        error = Watir::Wait::TimeoutError
-        element = browser.div(id: 'foo')
-        expect(element).to receive(:present?).and_return(true).twice
-
-        expect {
-          expect { element.wait_while_present(timeout: 0.4, interval: 0.2) }.to raise_error(error)
-        }.to have_deprecated_wait_while_present
-      end
-
-      it 'does not error when element goes stale' do
-        element = browser.div(id: 'foo').locate
-
-        allow(element).to receive(:stale?).and_return(false, true)
-
-        browser.a(id: 'hide_foo').click
-        expect {
-          expect { element.wait_while_present(timeout: 2) }.to_not raise_exception
-        }.to have_deprecated_wait_while_present
-      end
-
-      it 'waits until the selector no longer matches' do
-        element = browser.link(name: 'add_select').wait_until(&:exists?)
-        browser.link(id: 'change_select').click
-        expect {
-          expect { element.wait_while_present }.not_to raise_error
-        }.to have_deprecated_wait_while_present
-      end
-    end
-  end
-
-  not_compliant_on :relaxed_locate do
-    describe '#when_present' do
-      it 'invokes subsequent method calls when the element becomes present' do
-        browser.a(id: 'show_bar').click
-
-        bar = browser.div(id: 'bar')
-        bar.when_present(2).click
-        expect(bar.text).to eq 'changed'
-      end
-
-      it 'times out when given a block' do
-        expect { browser.div(id: 'bar').when_present(1) {} }.to raise_error(Watir::Wait::TimeoutError)
-      end
-
-      it 'times out when not given a block' do
-        locator = '(\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\})'
-        msg = /^timed out after 1 seconds, waiting for #{locator} to become present$/
-        expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, msg)
-      end
-
-      it 'responds to Element methods' do
-        decorator = browser.div.when_present
-
-        expect(decorator).to respond_to(:exist?)
-        expect(decorator).to respond_to(:present?)
-        expect(decorator).to respond_to(:click)
-      end
-
-      it 'delegates present? to element' do
-        Object.class_eval do
-          def present?
-            false
-          end
-        end
-        element = browser.a(id: 'show_bar').when_present(1)
-        expect(element).to be_present
-      end
-
-      it 'processes before calling present?' do
-        browser.a(id: 'show_bar').click
-        expect(browser.div(id: 'bar').when_present.present?).to be true
-      end
-    end
-
-    describe '#wait_until &:enabled?' do
-      it 'invokes subsequent method calls when the element becomes enabled' do
-        browser.a(id: 'enable_btn').click
-
-        btn = browser.button(id: 'btn')
-        btn.wait_until(timeout: 2, &:enabled?).click
-        Watir::Wait.while { btn.enabled? }
-        expect(btn.disabled?).to be true
-      end
-
-      it 'times out' do
-        error = Watir::Wait::TimeoutError
-        inspected = '#<Watir::Button: located: true; {:id=>"btn", :tag_name=>"button"}>'
-        message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
-        element = browser.button(id: 'btn')
-        expect { element.wait_until(timeout: 1, &:enabled?).click }.to raise_error(error, message)
-      end
-
-      it 'responds to Element methods' do
-        element = browser.button.wait_until { true }
-
-        expect(element).to respond_to(:exist?)
-        expect(element).to respond_to(:present?)
-        expect(element).to respond_to(:click)
-      end
-
-      it 'can be chained with #wait_until &:present?' do
-        browser.a(id: 'show_and_enable_btn').click
-        browser.button(id: 'btn2').wait_until(&:present?).wait_until(&:enabled?).click
-
-        expect(browser.button(id: 'btn2')).to exist
-        expect(browser.button(id: 'btn2')).to be_enabled
-      end
-    end
-
-    context 'when acting on an element that is never present' do
-      it 'raises exception immediately' do
-        element = browser.link(id: 'not_there')
-        start_time = ::Time.now
-        expect { element.click }.to raise_exception(Watir::Exception::UnknownObjectException)
-        expect(::Time.now - start_time).to be < 1
-      end
-    end
-
-    context 'when acting on an element that eventually becomes present' do
-      it 'raises exception immediately' do
-        start_time = ::Time.now
-        browser.a(id: 'show_bar').click
-
-        expect { browser.div(id: 'bar').click }.to raise_unknown_object_exception
-
-        expect(::Time.now - start_time).to be < 1
-      end
-    end
-  end
-end
-
-describe Watir::Window do
-  not_compliant_on :relaxed_locate do
-    describe '#wait_until &:present?' do
-      before do
-        browser.goto WatirSpec.url_for('window_switching.html')
-        browser.a(id: 'open').click
-        Watir::Wait.until { browser.windows.size == 2 }
-      end
-
-      after do
-        browser.original_window.use
-        browser.windows.reject(&:current?).each(&:close)
-      end
-
-      it 'times out waiting for a non-present window' do
-        expect {
-          browser.window(title: 'noop').wait_until(timeout: 0.5, &:present?)
-        }.to raise_error(Watir::Wait::TimeoutError)
-      end
-    end
-  end
-end