watir 6.0.0.beta5 → 6.0.0

data/spec/watirspec/screenshot_spec.rb

@@ -0,0 +1,29 @@
+require "base64"
+require "watirspec_helper"
+
+describe "Watir::Screenshot" do
+  let(:png_header) { "\211PNG".force_encoding('ASCII-8BIT') }
+
+  describe '#png' do
+    it 'gets png representation of screenshot' do
+      expect(browser.screenshot.png[0..3]).to eq png_header
+    end
+  end
+
+  describe '#base64' do
+    it 'gets base64 representation of screenshot' do
+      image = browser.screenshot.base64
+      expect(Base64.decode64(image)[0..3]).to eq png_header
+    end
+  end
+
+  describe '#save' do
+    it 'saves screenshot to given file' do
+      path = "#{Dir.tmpdir}/test#{Time.now.to_i}.png"
+      expect(File).to_not exist(path)
+      browser.screenshot.save(path)
+      expect(File).to exist(path)
+      expect(File.open(path, "rb") { |io| io.read }[0..3]).to eq png_header
+    end
+  end
+end

data/spec/watirspec/wait_spec.rb

@@ -0,0 +1,304 @@
+require "watirspec_helper"
+
+not_compliant_on :safari do
+  describe Watir::Wait do
+    describe "#until" do
+      it "waits until the block returns true" do
+        Watir::Wait.until(timeout: 0.5) { @result = true }
+        expect(@result).to be true
+      end
+
+      it "executes block if timeout is zero" do
+        Watir::Wait.until(timeout: 0) { @result = true }
+        expect(@result).to be true
+      end
+
+      it "times out" do
+        expect { Watir::Wait.until(timeout: 0.5) { false } }.to raise_error(Watir::Wait::TimeoutError)
+      end
+
+      it "times out with a custom message" do
+        expect {
+          Watir::Wait.until(timeout: 0.5, message: "oops") { false }
+        }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
+      end
+
+      it "uses timer for waiting" do
+        timer = Watir::Wait.timer
+        expect(timer).to receive(:wait).with(0.5).and_call_original
+        Watir::Wait.until(timeout: 0.5) { true }
+      end
+
+      it "ordered pairs are deprecated" do
+        message = /Instead of passing arguments into Wait#until method, use keywords/
+        expect { Watir::Wait.until(0) { true } }.to output(message).to_stderr
+      end
+    end
+
+    describe "#while" do
+      it "waits while the block returns true" do
+        expect(Watir::Wait.while(timeout: 0.5) { false }).to be_nil
+      end
+
+      it "executes block if timeout is zero" do
+        expect(Watir::Wait.while(timeout: 0) { false }).to be_nil
+      end
+
+      it "times out" do
+        expect { Watir::Wait.while(timeout: 0.5) { true } }.to raise_error(Watir::Wait::TimeoutError)
+      end
+
+      it "times out with a custom message" do
+        expect {
+          Watir::Wait.while(timeout: 0.5, message: "oops") { true }
+        }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
+      end
+
+      it "uses timer for waiting" do
+        timer = Watir::Wait.timer
+        expect(timer).to receive(:wait).with(0.5).and_call_original
+        Watir::Wait.while(timeout: 0.5) { false }
+      end
+
+      it "ordered pairs are deprecated" do
+        message = /Instead of passing arguments into Wait#while method, use keywords/
+        expect { Watir::Wait.while(0) { false } }.to output(message).to_stderr
+      end
+    end
+
+    describe "#timer" do
+      it "returns default timer" do
+        expect(Watir::Wait.timer).to be_a(Watir::Wait::Timer)
+      end
+    end
+
+    describe "#timer=" do
+      after { Watir::Wait.timer = nil }
+
+      it "changes default timer" do
+        timer = Class.new
+        Watir::Wait.timer = timer
+        expect(Watir::Wait.timer).to eq(timer)
+      end
+    end
+  end
+
+  describe Watir::Element do
+    before do
+      browser.goto WatirSpec.url_for("wait.html")
+    end
+
+    # TODO: This is deprecated; remove in future version
+    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
+          message = /^timed out after 1 seconds, waiting for (\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\}) to become present$/
+          expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, message)
+        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
+    end
+
+    not_compliant_on :relaxed_locate do
+      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
+          message = /^timed out after 1 seconds, waiting for true condition on (\{:id=>"btn", :tag_name=>"button"\}|\{:tag_name=>"button", :id=>"btn"\})$/
+          expect { browser.button(id: 'btn').wait_until(timeout: 1, &:enabled?).click }.to raise_error(Watir::Wait::TimeoutError, 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
+    end
+
+    describe "#wait_until_present" do
+      it "it waits until the element appears" do
+        browser.a(id: 'show_bar').click
+        expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
+      end
+
+      it "times out if the element doesn't appear" do
+        message = /^timed out after 1 seconds, waiting for true condition on (\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\})$/
+        expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(Watir::Wait::TimeoutError, message)
+      end
+
+      it "ordered pairs are deprecated" do
+        browser.a(id: 'show_bar').click
+        message = /Instead of passing arguments into #wait_until_present method, use keywords/
+        expect { browser.div(id: 'bar').wait_until_present(5) }.to output(message).to_stderr
+      end
+    end
+
+    describe "#wait_while_present" do
+      it "waits until the element disappears" do
+        browser.a(id: 'hide_foo').click
+        expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to_not raise_exception
+      end
+
+      it "times out if the element doesn't disappear" do
+        message = /^timed out after 1 seconds, waiting for false condition on (\{:id=>"foo", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"foo"\})$/
+        expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(Watir::Wait::TimeoutError, message)
+      end
+
+      it "ordered pairs are deprecated" do
+        browser.a(id: 'hide_foo').click
+        message = /Instead of passing arguments into #wait_while_present method, use keywords/
+        expect { browser.div(id: 'foo').wait_while_present(5) }.to output(message).to_stderr
+      end
+    end
+
+    describe "#wait_until" do
+      it "returns element for additional actions" do
+        element = browser.div(id: 'foo')
+        expect(element.wait_until(&:exist?)).to eq element
+      end
+
+      it "accepts self in block" do
+        element = browser.div(id: 'bar')
+        browser.a(id: 'show_bar').click
+        expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
+      end
+
+      it "accepts any values in block" do
+        element = browser.div(id: 'bar')
+        expect { element.wait_until { true } }.to_not raise_exception
+      end
+
+      it "accepts just a timeout parameter" do
+        element = browser.div(id: 'bar')
+        expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
+      end
+
+      it "accepts just a message parameter" do
+        element = browser.div(id: 'bar')
+        expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
+      end
+    end
+
+    describe "#wait_while" do
+      it "returns element for additional actions" do
+        element = browser.div(id: 'foo')
+        browser.a(id: 'hide_foo').click
+        expect(element.wait_while(&:present?)).to eq element
+      end
+
+      it "accepts self in block" do
+        element = browser.div(id: 'foo')
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while { |el| el.text == 'foo' } }.to_not raise_exception
+      end
+
+      it "accepts any values in block" do
+        element = browser.div(id: 'foo')
+        expect { element.wait_while { false } }.to_not raise_exception
+      end
+
+      it "accepts just a timeout parameter" do
+        element = browser.div(id: 'foo')
+        expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
+      end
+
+      it "accepts just a message parameter" do
+        element = browser.div(id: 'foo')
+        expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
+      end
+    end
+  end
+
+  describe Watir do
+    describe "#default_timeout" do
+      before do
+        Watir.default_timeout = 1
+
+        browser.goto WatirSpec.url_for("wait.html")
+      end
+
+      after do
+        # Reset the default timeout
+        Watir.default_timeout = 30
+      end
+
+      context "when no timeout is specified" do
+        it "is used by Wait#until" do
+          expect {
+            Watir::Wait.until { false }
+          }.to raise_error(Watir::Wait::TimeoutError)
+        end
+
+        it "is used by Wait#while" do
+          expect {
+            Watir::Wait.while { true }
+          }.to raise_error(Watir::Wait::TimeoutError)
+        end
+
+        it "is used by Element#wait_until_present" do
+          expect {
+            browser.div(id: 'bar').wait_until_present
+          }.to raise_error(Watir::Wait::TimeoutError)
+        end
+
+        it "is used by Element#wait_while_present" do
+          expect {
+            browser.div(id: 'foo').wait_while_present
+          }.to raise_error(Watir::Wait::TimeoutError)
+        end
+      end
+    end
+  end
+end

data/spec/watirspec/window_switching_spec.rb

@@ -0,0 +1,411 @@
+require "watirspec_helper"
+
+not_compliant_on :safari do
+  describe "Browser" do
+    before do
+      url = WatirSpec.url_for("window_switching.html")
+      browser.goto url
+      browser.a(id: "open").click
+      Watir::Wait.until { browser.windows.size == 2 }
+    end
+
+    after do
+      browser.window(index: 0).use
+      browser.windows[1..-1].each(&:close)
+    end
+
+    describe "#windows" do
+      it "returns an array of window handles" do
+        wins = browser.windows
+        expect(wins).to_not be_empty
+        wins.each { |win| expect(win).to be_kind_of(Watir::Window) }
+      end
+
+      it "only returns windows matching the given selector" do
+        expect(browser.windows(title: "closeable window").size).to eq 1
+      end
+
+      it "raises ArgumentError if the selector is invalid" do
+        expect { browser.windows(name: "foo") }.to raise_error(ArgumentError)
+      end
+
+      it "returns an empty array if no window matches the selector" do
+        expect(browser.windows(title: "noop")).to eq []
+      end
+    end
+
+    describe "#window" do
+      it "finds window by :url" do
+        w = browser.window(url: /closeable\.html/).use
+        expect(w).to be_kind_of(Watir::Window)
+      end
+
+      it "finds window by :title" do
+        w = browser.window(title: "closeable window").use
+        expect(w).to be_kind_of(Watir::Window)
+      end
+
+      it "finds window by :index" do
+        w = browser.window(index: 1).use
+        expect(w).to be_kind_of(Watir::Window)
+      end
+
+      it "should not find incorrect handle" do
+        expect(browser.window(handle: 'bar')).to_not be_present
+      end
+
+      it "returns the current window if no argument is given" do
+        expect(browser.window.url).to match(/window_switching\.html/)
+      end
+
+      it "stores the reference to a window when no argument is given" do
+        original_window = browser.window
+        browser.window(index: 1).use
+        expect(original_window.url).to match(/window_switching\.html/)
+      end
+
+      bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+        it "it executes the given block in the window" do
+          browser.window(title: "closeable window") do
+            link = browser.a(id: "close")
+            expect(link).to exist
+            link.click
+          end.wait_while_present
+
+          expect(browser.windows.size).to eq 1
+        end
+      end
+
+      it "raises ArgumentError if the selector is invalid" do
+        expect { browser.window(name: "foo") }.to raise_error(ArgumentError)
+      end
+
+      it "raises a NoMatchingWindowFoundException error if no window matches the selector" do
+        expect { browser.window(title: "noop").use }.to raise_no_matching_window_exception
+      end
+
+      it "raises a NoMatchingWindowFoundException error if there's no window at the given index" do
+        expect { browser.window(index: 100).use }.to raise_no_matching_window_exception
+      end
+
+      it "raises NoMatchingWindowFoundException error when attempting to use a window with an incorrect handle" do
+        expect { browser.window(handle: 'bar').use }.to raise_no_matching_window_exception
+      end
+    end
+  end
+
+  describe "Window" do
+    context 'multiple windows' 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.window(index: 0).use
+        browser.windows[1..-1].each(&:close)
+      end
+
+      bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1280517", :firefox do
+        describe "#close" do
+          it "closes a window" do
+            browser.a(id: "open").click
+            Watir::Wait.until { browser.windows.size == 3 }
+
+            browser.window(title: "closeable window").close
+            expect(browser.windows.size).to eq 2
+          end
+
+          it "closes the current window" do
+            browser.a(id: "open").click
+            Watir::Wait.until { browser.windows.size == 3 }
+
+            window = browser.window(title: "closeable window").use
+            window.close
+            expect(browser.windows.size).to eq 2
+          end
+        end
+      end
+
+      describe "#use" do
+        it "switches to the window" do
+          browser.window(title: "closeable window").use
+          expect(browser.title).to eq "closeable window"
+        end
+      end
+
+      describe "#current?" do
+        it "returns true if it is the current window" do
+          expect(browser.window(title: browser.title)).to be_current
+        end
+
+        it "returns false if it is not the current window" do
+          expect(browser.window(title: "closeable window")).to_not be_current
+        end
+      end
+
+      describe "#title" do
+        it "returns the title of the window" do
+          titles = browser.windows.map(&:title)
+          expect(titles.size).to eq 2
+
+          expect(titles.sort).to eq ["window switching", "closeable window"].sort
+        end
+
+        it "does not change the current window" do
+          expect(browser.title).to eq "window switching"
+          expect(browser.windows.find { |w| w.title == "closeable window" }).to_not be_nil
+          expect(browser.title).to eq "window switching"
+        end
+      end
+
+      describe "#url" do
+        it "returns the url of the window" do
+          expect(browser.windows.select { |w| w.url =~ (/window_switching\.html/) }.size).to eq 1
+          expect(browser.windows.select { |w| w.url =~ (/closeable\.html$/) }.size).to eq 1
+        end
+
+        it "does not change the current window" do
+          expect(browser.url).to match(/window_switching\.html/)
+          expect(browser.windows.find { |w| w.url =~ (/closeable\.html/) }).to_not be_nil
+          expect(browser.url).to match(/window_switching/)
+        end
+      end
+
+      describe "#eql?" do
+        it "knows when two windows are equal" do
+          expect(browser.window).to eq browser.window(index: 0)
+        end
+
+        it "knows when two windows are not equal" do
+          win1 = browser.window(index: 0)
+          win2 = browser.window(index: 1)
+
+          expect(win1).to_not eq win2
+        end
+      end
+
+      not_compliant_on :relaxed_locate do
+        describe "#wait_until &:present?" do
+          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
+
+    context "with a closed window" 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.window(index: 0).use
+        browser.windows[1..-1].each(&:close)
+      end
+
+      bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+        describe "#exists?" do
+          it "returns false if previously referenced window is closed" do
+            window = browser.window(title: "closeable window")
+            window.use
+            browser.a(id: "close").click
+            Watir::Wait.until { browser.windows.size == 1 }
+            expect(window).to_not be_present
+          end
+
+          it "returns false if closed window is referenced" do
+            browser.window(title: "closeable window").use
+            browser.a(id: "close").click
+            Watir::Wait.until { browser.windows.size == 1 }
+            expect(browser.window).to_not be_present
+          end
+        end
+      end
+
+      describe "#current?" do
+        it "returns false if the referenced window is closed" do
+          original_window = browser.window
+          browser.window(title: "closeable window").use
+          original_window.close
+          expect(original_window).to_not be_current
+        end
+      end
+
+      describe "#eql?" do
+        it "should return false when checking equivalence to a closed window" do
+          original_window = browser.window
+          other_window = browser.window(index: 1)
+          other_window.use
+          original_window.close
+          expect(other_window == original_window).to be false
+        end
+      end
+
+      describe "#use" do
+        bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+          it "raises NoMatchingWindowFoundException error when attempting to use a referenced window that is closed" do
+            original_window = browser.window
+            browser.window(index: 1).use
+            original_window.close
+            expect { original_window.use }.to raise_no_matching_window_exception
+          end
+
+          bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+            it "raises NoMatchingWindowFoundException error when attempting to use the current window if it is closed" do
+              browser.window(title: "closeable window").use
+              browser.a(id: "close").click
+              Watir::Wait.until { browser.windows.size == 1 }
+              expect { browser.window.use }.to raise_no_matching_window_exception
+            end
+          end
+        end
+      end
+    end
+
+    bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+      context "with current window closed" do
+        before do
+          browser.goto WatirSpec.url_for("window_switching.html")
+          browser.a(id: "open").click
+          Watir::Wait.until { browser.windows.size == 2 }
+          browser.window(title: "closeable window").use
+          browser.a(id: "close").click
+          Watir::Wait.until { browser.windows.size == 1 }
+        end
+
+        after do
+          browser.window(index: 0).use
+          browser.windows[1..-1].each(&:close)
+        end
+
+        describe "#present?" do
+          it "should find window by index" do
+            expect(browser.window(index: 0)).to be_present
+          end
+
+          it "should find window by url" do
+            expect(browser.window(url: /window_switching\.html/)).to be_present
+          end
+
+          it "should find window by title" do
+            expect(browser.window(title: "window switching")).to be_present
+          end
+        end
+
+        describe "#use" do
+
+          context "switching windows without blocks" do
+            it "by index" do
+              browser.window(index: 0).use
+              expect(browser.title).to be == "window switching"
+            end
+
+            it "by url" do
+              browser.window(url: /window_switching\.html/).use
+              expect(browser.title).to be == "window switching"
+            end
+
+            it "by title" do
+              browser.window(title: "window switching").use
+              expect(browser.url).to match(/window_switching\.html/)
+            end
+          end
+
+          context "Switching windows with blocks" do
+            it "by index" do
+              browser.window(index: 0).use { expect(browser.title).to be == "window switching" }
+            end
+
+            it "by url" do
+              browser.window(url: /window_switching\.html/).use { expect(browser.title).to be == "window switching" }
+            end
+
+            it "by title" do
+              browser.window(title: "window switching").use { expect(browser.url).to match(/window_switching\.html/) }
+            end
+          end
+
+        end
+      end
+    end
+
+    context "manipulating size and position" do
+      before do
+        browser.goto WatirSpec.url_for("window_switching.html")
+      end
+
+      compliant_on :ff_legacy, :chrome do
+        it "should get the size of the current window" do
+          size = browser.window.size
+
+          expect(size.width).to be > 0
+          expect(size.height).to be > 0
+        end
+
+        it "should get the position of the current window" do
+          pos = browser.window.position
+
+          expect(pos.x).to be >= 0
+          expect(pos.y).to be >= 0
+        end
+      end
+
+      bug "https://github.com/SeleniumHQ/selenium/issues/2856", %i(remote firefox) do
+        it "should resize the window" do
+          initial_size = browser.window.size
+          browser.window.resize_to(
+            initial_size.width - 20,
+            initial_size.height - 20
+          )
+
+          new_size = browser.window.size
+
+          expect(new_size.width).to eq initial_size.width - 20
+          expect(new_size.height).to eq initial_size.height - 20
+        end
+      end
+
+      not_compliant_on :firefox do
+        bug "https://github.com/detro/ghostdriver/issues/466", :phantomjs do
+          it "should move the window" do
+            initial_pos = browser.window.position
+
+            browser.window.move_to(
+              initial_pos.x + 2,
+              initial_pos.y + 2
+            )
+
+            new_pos = browser.window.position
+            expect(new_pos.x).to eq initial_pos.x + 2
+            expect(new_pos.y).to eq initial_pos.y + 2
+          end
+        end
+      end
+
+      compliant_on :window_manager do
+        bug "https://github.com/SeleniumHQ/selenium/issues/2856", %i(remote firefox) do
+          it "should maximize the window" do
+            initial_size = browser.window.size
+            browser.window.resize_to(
+                initial_size.width,
+                initial_size.height - 20
+            )
+
+            browser.window.maximize
+            browser.wait_until { browser.window.size != initial_size }
+
+            new_size = browser.window.size
+            expect(new_size.width).to be >= initial_size.width
+            expect(new_size.height).to be > (initial_size.height - 20)
+          end
+        end
+      end
+    end
+  end
+end