browserstack-webdriver 0.0.1

data/spec/integration/selenium/webdriver/element_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Element" do
+
+  it "should click" do
+    driver.navigate.to url_for("formPage.html")
+    driver.find_element(:id, "imageButton").click
+  end
+
+  it "should submit" do
+    driver.navigate.to url_for("formPage.html")
+    driver.find_element(:id, "submitButton").submit
+  end
+
+  it "should send string keys" do
+    driver.navigate.to url_for("formPage.html")
+    driver.find_element(:id, "working").send_keys("foo", "bar")
+  end
+
+  not_compliant_on :browser => [:android, :iphone, :safari] do
+    it "should send key presses" do
+      driver.navigate.to url_for("javascriptPage.html")
+      key_reporter = driver.find_element(:id, 'keyReporter')
+
+      key_reporter.send_keys("Tet", :arrow_left, "s")
+      key_reporter.attribute('value').should == "Test"
+    end
+  end
+
+  not_compliant_on :browser => [:opera, :android, :iphone, :safari] do
+    it "should handle file uploads" do
+      driver.navigate.to url_for("formPage.html")
+
+      element = driver.find_element(:id, 'upload')
+      element.attribute('value').should be_empty
+
+      file = Tempfile.new('file-upload')
+      path = file.path
+      path.gsub!("/", "\\") if WebDriver::Platform.windows?
+
+      element.send_keys path
+
+      element.attribute('value').should include(File.basename(path))
+    end
+  end
+
+  it "should get attribute value" do
+    driver.navigate.to url_for("formPage.html")
+    driver.find_element(:id, "withText").attribute("rows").should == "5"
+  end
+
+  it "should return nil for non-existent attributes" do
+    driver.navigate.to url_for("formPage.html")
+    driver.find_element(:id, "withText").attribute("nonexistent").should be_nil
+  end
+
+  it "should clear" do
+    driver.navigate.to url_for("formPage.html")
+    driver.find_element(:id, "withText").clear
+  end
+
+  not_compliant_on :browser => :android do
+    it "should get and set selected" do
+      driver.navigate.to url_for("formPage.html")
+
+      cheese = driver.find_element(:id, "cheese")
+      peas   = driver.find_element(:id, "peas")
+
+      cheese.click
+
+      cheese.should be_selected
+      peas.should_not be_selected
+
+      peas.click
+
+      peas.should be_selected
+      cheese.should_not be_selected
+    end
+  end
+
+  it "should get enabled" do
+    driver.navigate.to url_for("formPage.html")
+    driver.find_element(:id, "notWorking").should_not be_enabled
+  end
+
+  it "should get text" do
+    driver.navigate.to url_for("xhtmlTest.html")
+    driver.find_element(:class, "header").text.should == "XHTML Might Be The Future"
+  end
+
+  it "should get displayed" do
+    driver.navigate.to url_for("xhtmlTest.html")
+    driver.find_element(:class, "header").should be_displayed
+  end
+
+  it "should get location" do
+    driver.navigate.to url_for("xhtmlTest.html")
+    loc = driver.find_element(:class, "header").location
+
+    loc.x.should >= 1
+    loc.y.should >= 1
+  end
+
+  not_compliant_on :browser => [:iphone] do
+    it "should get location once scrolled into view" do
+      driver.navigate.to url_for("javascriptPage.html")
+      loc = driver.find_element(:id, 'keyUp').location_once_scrolled_into_view
+
+      loc.x.should >= 1
+      loc.y.should >= 0 # can be 0 if scrolled to the top
+    end
+  end
+
+  it "should get size" do
+    driver.navigate.to url_for("xhtmlTest.html")
+    size = driver.find_element(:class, "header").size
+
+    size.width.should > 0
+    size.height.should > 0
+  end
+
+  compliant_on :driver => [:ie, :chrome] do # Firefox w/native events: issue 1771
+    it "should drag and drop" do
+      driver.navigate.to url_for("dragAndDropTest.html")
+
+      img1 = driver.find_element(:id, "test1")
+      img2 = driver.find_element(:id, "test2")
+
+      driver.action.drag_and_drop_by(img1, 100, 100).
+                    drag_and_drop(img2, img1).
+                    perform
+
+      img1.location.should == img2.location
+    end
+  end
+
+  not_compliant_on :browser => [:android] do # android returns 'green'
+    it "should get css property" do
+      driver.navigate.to url_for("javascriptPage.html")
+      element = driver.find_element(:id, "green-parent")
+
+      style1 = element.css_value("background-color")
+      style2 = element.style("background-color") # backwards compatibility
+
+      acceptable = ["rgb(0, 128, 0)", "#008000", 'rgba(0,128,0,1)', 'rgba(0, 128, 0, 1)']
+      acceptable.should include(style1, style2)
+    end
+  end
+
+  it "should know when two elements are equal" do
+    driver.navigate.to url_for("simpleTest.html")
+
+    body  = driver.find_element(:tag_name, 'body')
+    xbody = driver.find_element(:xpath, "//body")
+
+    body.should == xbody
+    body.should eql(xbody)
+  end
+
+  not_compliant_on :browser => :phantomjs do
+    it "should know when two elements are not equal" do
+      driver.navigate.to url_for("simpleTest.html")
+
+      elements = driver.find_elements(:tag_name, 'p')
+      p1 = elements.fetch(0)
+      p2 = elements.fetch(1)
+
+      p1.should_not == p2
+      p1.should_not eql(p2)
+    end
+  end
+
+  it "should return the same #hash for equal elements when found by Driver#find_element" do
+    driver.navigate.to url_for("simpleTest.html")
+
+    body  = driver.find_element(:tag_name, 'body')
+    xbody = driver.find_element(:xpath, "//body")
+
+    body.hash.should == xbody.hash
+  end
+
+  it "should return the same #hash for equal elements when found by Driver#find_elements" do
+    driver.navigate.to url_for("simpleTest.html")
+
+    body  = driver.find_elements(:tag_name, 'body').fetch(0)
+    xbody = driver.find_elements(:xpath, "//body").fetch(0)
+
+    body.hash.should == xbody.hash
+  end
+
+end

data/spec/integration/selenium/webdriver/error_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Selenium::WebDriver::Error do
+
+  it "should raise an appropriate error" do
+    driver.navigate.to url_for("xhtmlTest.html")
+
+    lambda {
+      driver.find_element(:id, "nonexistant")
+    }.should raise_error(WebDriver::Error::NoSuchElementError)
+  end
+
+  compliant_on :driver => [:remote, :firefox] do
+    it "should show stack trace information" do
+      driver.navigate.to url_for("xhtmlTest.html")
+
+      rescued = false
+      ex = nil
+
+      begin
+        driver.find_element(:id, "nonexistant")
+      rescue => ex
+        rescued = true
+      end
+
+      rescued.should be_true
+      ex.backtrace.first.should include("[remote server]")
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      describe Driver do
+        describe ".new" do
+          it "should take a Firefox::Profile instance as argument" do
+            begin
+              profile = Selenium::WebDriver::Firefox::Profile.new
+              driver = Selenium::WebDriver.for :firefox, :profile => profile
+            ensure
+              driver.quit if driver
+            end
+          end
+        end
+      end
+
+    end # Firefox
+  end # WebDriver
+end # Selenium
+

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

@@ -0,0 +1,141 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Firefox
+
+      describe Profile do
+        let(:profile) { Profile.new }
+
+        def read_generated_prefs(from = nil)
+          prof = from || profile()
+          dir = prof.layout_on_disk
+
+          File.read(File.join(dir, 'user.js'))
+        end
+
+        it "should set additional preferences" do
+          profile['foo.number'] = 123
+          profile['foo.boolean'] = true
+          profile['foo.string'] = "bar"
+
+          string = read_generated_prefs
+          string.should include('user_pref("foo.number", 123)')
+          string.should include('user_pref("foo.boolean", true)')
+          string.should include(%{user_pref("foo.string", "bar")})
+        end
+
+        it "should be serializable to JSON" do
+          profile['foo.boolean'] = true
+
+          new_profile = Profile.from_json(profile.to_json)
+          string = read_generated_prefs(new_profile)
+          string.should include('user_pref("foo.boolean", true)')
+        end
+
+        it "should not let user override defaults" do
+          profile['app.update.enabled'] = true
+
+          string = read_generated_prefs
+          string.should include('user_pref("app.update.enabled", false)')
+        end
+
+        it "should properly handle escaped characters" do
+          profile['foo'] = 'C:\\r\\n'
+
+          string = read_generated_prefs
+          string.should include('user_pref("foo", "C:\\\\r\\\\n");')
+        end
+
+        it "should let the user override some specific prefs" do
+          profile["browser.startup.page"] = "http://example.com"
+
+          string = read_generated_prefs
+          string.should include(%Q{user_pref("browser.startup.page", "http://example.com")})
+        end
+
+        it "should raise an error if the value given is not a string, number or boolean" do
+          lambda { profile['foo.bar'] = [] }.should raise_error(TypeError)
+        end
+
+        it "should raise an error if the value is already stringified" do
+          lambda { profile['foo.bar'] = '"stringified"' }.should raise_error(ArgumentError)
+        end
+
+        it "should enable secure SSL" do
+          profile.secure_ssl = true
+
+          string = read_generated_prefs
+          string.should include('user_pref("webdriver_accept_untrusted_certs", false)')
+        end
+
+        it "should disable secure SSL" do
+          profile.secure_ssl = false
+
+          string = read_generated_prefs
+          string.should include('user_pref("webdriver_accept_untrusted_certs", true)')
+        end
+
+        it "should change the setting for untrusted certificate issuer" do
+          profile.assume_untrusted_certificate_issuer = false
+
+          string = read_generated_prefs
+          string.should include('user_pref("webdriver_assume_untrusted_issuer", false)')
+        end
+
+        it "can configure a manual proxy" do
+          proxy = Proxy.new(
+            :http     => "foo:123",
+            :ftp      => "bar:234",
+            :ssl      => "baz:345",
+            :no_proxy => "localhost"
+          )
+
+          profile.proxy = proxy
+          string = read_generated_prefs
+
+          string.should include('user_pref("network.proxy.http", "foo")')
+          string.should include('user_pref("network.proxy.http_port", 123)')
+
+          string.should include('user_pref("network.proxy.ftp", "bar")')
+          string.should include('user_pref("network.proxy.ftp_port", 234)')
+
+          string.should include('user_pref("network.proxy.ssl", "baz")')
+          string.should include('user_pref("network.proxy.ssl_port", 345)')
+
+          string.should include('user_pref("network.proxy.no_proxies_on", "localhost")')
+          string.should include('user_pref("network.proxy.type", 1)')
+        end
+
+        it "can configure a PAC proxy" do
+          profile.proxy = Proxy.new(:pac => "http://foo/bar.pac")
+          string = read_generated_prefs
+
+          string.should include('user_pref("network.proxy.autoconfig_url", "http://foo/bar.pac")')
+          string.should include('user_pref("network.proxy.type", 2)')
+        end
+
+        it "can configure an auto-detected proxy" do
+          profile.proxy = Proxy.new(:auto_detect => true)
+          string = read_generated_prefs
+
+          string.should include('user_pref("network.proxy.type", 4)')
+        end
+
+        it "should be able to use the same profile more than once" do
+          profile['browser.startup.homepage'] = url_for("formPage.html")
+
+          begin
+            driver_one = WebDriver.for(:firefox, :profile => profile)
+            driver_two = WebDriver.for(:firefox, :profile => profile)
+          ensure
+            driver_one.quit if driver_one
+            driver_two.quit if driver_two
+          end
+        end
+
+      end
+    end # Firefox
+  end # WebDriver
+end # Selenium
+

data/spec/integration/selenium/webdriver/keyboard_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe Keyboard do
+
+      not_compliant_on :browser => [:chrome, :android, :iphone, :safari] do
+        it "sends keys to the active element" do
+          driver.navigate.to url_for("bodyTypingTest.html")
+
+          driver.keyboard.send_keys "ab"
+
+          text = driver.find_element(:id => "body_result").text.strip
+          text.should == "keypress keypress"
+
+          driver.find_element(:id => "result").text.strip.should be_empty
+        end
+
+        it "can send keys with shift pressed" do
+          driver.navigate.to url_for("javascriptPage.html")
+
+          event_input = driver.find_element(:id => "theworks")
+          keylogger   = driver.find_element(:id => "result")
+
+          driver.mouse.click event_input
+
+          driver.keyboard.press :shift
+          driver.keyboard.send_keys "ab"
+          driver.keyboard.release :shift
+
+          event_input.attribute(:value).should == "AB"
+          keylogger.text.strip.should =~ /^(focus )?keydown keydown keypress keyup keydown keypress keyup keyup$/
+        end
+
+        it "raises an ArgumentError if the pressed key is not a modifier key" do
+          lambda { driver.keyboard.press :return }.should raise_error(ArgumentError)
+        end
+
+        it "can press and release modifier keys" do
+          driver.navigate.to url_for("javascriptPage.html")
+
+          event_input = driver.find_element(:id => "theworks")
+          keylogger   = driver.find_element(:id => "result")
+
+          driver.mouse.click event_input
+
+          driver.keyboard.press :shift
+          keylogger.text.should =~ /keydown$/
+
+          driver.keyboard.release :shift
+          keylogger.text.should =~ /keyup$/
+        end
+      end
+
+    end # Keyboard
+  end # WebDriver
+end # Selenium

data/spec/integration/selenium/webdriver/location_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium::WebDriver::DriverExtensions
+  describe HasLocation do
+
+    let(:lat) { 40.714353  }
+    let(:lon) { -74.005973 }
+    let(:alt) { 0.056747   }
+
+    let(:location) {
+      Selenium::WebDriver::Location.new lat, lon, alt
+    }
+
+    compliant_on :browser => [:iphone, :android] do
+      it "can get and set location" do
+        driver.manage.timeouts.implicit_wait = 2
+        driver.navigate.to url_for("html5Page.html")
+
+        driver.location = location
+        loc = driver.location
+
+        loc.latitude.should be_within(0.000001).of(lat)
+        loc.longitude.should be_within(0.000001).of(lon)
+        loc.altitude.should be_within(0.000001).of(alt)
+      end
+    end
+
+  end
+end