bbc-selenium-webdriver 1.17.0

data/spec/unit/selenium/client/javascript_expression_builder_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Selenium::Client::JavascriptExpressionBuilder do
+  def builder(*args)
+    @builder ||= Selenium::Client::JavascriptExpressionBuilder.new(*args)
+  end
+
+  it "can append arbitrary text to builder" do
+    builder.append("hello").append(" world")
+    builder.script.should == "hello world"
+  end
+
+  it "returns the correct #no_pending_ajax_requests script for Prototype" do
+    builder = builder(:prototype)
+    builder.no_pending_ajax_requests.script.should == "selenium.browserbot.getCurrentWindow().Ajax.activeRequestCount == 0;"
+  end
+
+  it "returns the correct #no_pending_ajax_requests script for jQuery" do
+    builder = builder(:jquery)
+    builder.no_pending_ajax_requests.script.should == "selenium.browserbot.getCurrentWindow().jQuery.active == 0;"
+  end
+
+  it "returns the correct #no_pending_effects for Prototype" do
+    builder = builder(:prototype)
+    builder.no_pending_effects.script.should == "selenium.browserbot.getCurrentWindow().Effect.Queue.size() == 0;"
+  end
+
+  describe "#quote_escaped" do
+    it "returns a locator as is when it has no single quotes" do
+      builder.quote_escaped("the_locator").should == "the_locator"
+    end
+
+    it "escapes single quotes" do
+      builder.quote_escaped("//div[@id='demo-effect-appear']").should == "//div[@id=\\'demo-effect-appear\\']"
+    end
+
+    it "escapes backslashes" do
+      builder.quote_escaped("webratlink=evalregex:/Pastry Lovers \\(Organizer\\)/").should == "webratlink=evalregex:/Pastry Lovers \\\\(Organizer\\\\)/"
+    end
+  end
+
+  describe "#text_match" do
+    it "matches on entire string when pattern is a string" do
+      builder.text_match("some text").should == "element.innerHTML == 'some text'"
+    end
+
+    it "performs a regexp match when pattern is a regexp" do
+      builder.text_match(/some text/).should == "null != element.innerHTML.match(/some text/)"
+    end
+
+    it "escapes rexpexp when pattern is a regexp" do
+      builder.text_match(/some.*text/).should == "null != element.innerHTML.match(/some.*text/)"
+    end
+  end
+
+  describe "#find_element" do
+    it "adds a script to find an element" do
+      builder.find_element('a_locator').script.should =~ /element\s+=\s+selenium.browserbot.findElement\('a_locator'\);/m
+    end
+
+    it "should handle embedded evalregex locators" do
+      builder.find_element("webratlink=evalregex:/Pastry Lovers \\(Organizer\\)/").script.should =~ /element\s+=\s+selenium.browserbot.findElement\('webratlink=evalregex:\/Pastry Lovers \\\\\(Organizer\\\\\)\/'\);/m
+    end
+  end
+
+  describe "#javascript_framework_for" do
+    it "returns JavascriptFrameworks::Prototype when argument is :prototype" do
+      builder.javascript_framework_for(:prototype).should == Selenium::Client::JavascriptFrameworks::Prototype
+    end
+
+    it "returns JavascriptFrameworks::JQuery when argument is :jquery" do
+      builder.javascript_framework_for(:jquery).should == Selenium::Client::JavascriptFrameworks::JQuery
+    end
+
+    it "raises a Runtime for unsupported frameworks" do
+      lambda { builder.javascript_framework_for(:unsupported_framework) }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/unit/selenium/client/javascript_frameworks/jquery_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Selenium::Client::JavascriptFrameworks::JQuery do
+  
+  it "returns 'jQuery.active'" do
+    art = Selenium::Client::JavascriptFrameworks::JQuery.ajax_request_tracker
+    art.should == "jQuery.active"
+  end
+  
+end

data/spec/unit/selenium/client/javascript_frameworks/prototype_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Selenium::Client::JavascriptFrameworks::Prototype do
+  
+  it "returns 'Ajax.activeRequestCount'" do
+    art = Selenium::Client::JavascriptFrameworks::Prototype.ajax_request_tracker
+    art.should == "Ajax.activeRequestCount"
+  end
+  
+end

data/spec/unit/selenium/client/protocol_spec.rb

@@ -0,0 +1,124 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Selenium::Client::Protocol do
+  class ProtocolClient
+    include Selenium::Client::Protocol
+  end
+  
+  let(:client) { ProtocolClient.new }
+
+  describe "#remote_control_command" do
+    it "returns the content of the HTTP response when the command succeeds" do
+      client.instance_variable_set :@default_timeout_in_seconds, 1
+      client.stub!(:http_request_for).with(:a_verb, :some_args).and_return(:the_request)
+      client.should_receive(:http_post).with(:the_request).and_return(["OK", "OK,the response"])
+      client.remote_control_command(:a_verb, :some_args).should == "the response"
+    end
+
+    it "raises a SeleniumCommandError when the command fails" do
+      client.instance_variable_set :@default_timeout_in_seconds, 1
+      client.stub!(:http_request_for).with(:a_verb, :some_args).and_return(:the_request)
+      client.should_receive(:http_post).with(:the_request).and_return(["ER", "ERROR,the error message"])
+      lambda { client.remote_control_command(:a_verb, :some_args) }.should raise_error(Selenium::Client::CommandError)
+    end
+
+    it "succeeds when given zero args" do
+      client.instance_variable_set :@default_timeout_in_seconds, 1
+      client.should_receive(:http_request_for).with(:a_verb, []).and_return(:the_request)
+      client.stub!(:http_post).with(:the_request).and_return(["OK", "OK,the response"])
+      client.remote_control_command(:a_verb)
+    end
+  end
+
+  describe "#string_command" do
+    it "returns the selenese command response" do
+      client.should_receive(:remote_control_command).with(:a_verb, :some_args).and_return("A String")
+      client.string_command(:a_verb, :some_args).should == "A String"
+    end
+
+    it "succeeds when given zero args" do
+      client.should_receive(:remote_control_command).with(:a_verb, [])
+      client.string_command:a_verb
+    end
+  end
+
+  describe "#get_string" do # private?
+    it "parses the command response as a CSV row" do
+      client.should_receive(:remote_control_command).with(:a_verb, :some_args).and_return("One,Two,Three")
+      client.string_array_command(:a_verb, :some_args).should == ["One", "Two", "Three"]
+    end
+
+    it "preserves spaces" do
+      client.should_receive(:remote_control_command).with(:a_verb, :some_args).and_return(" One , Two & Three ")
+      client.string_array_command(:a_verb, :some_args).should == [" One ", " Two & Three "]
+    end
+
+    it "ignores commas escaped with a backspace" do
+      client.should_receive(:remote_control_command).with(:a_verb, :some_args).and_return("One,Two\\,Three")
+      client.string_array_command(:a_verb, :some_args).should == ["One", "Two,Three"]
+    end
+  end
+
+  describe "parse_boolean_value" do
+    it "returns true when string is true" do
+      client.send(:parse_boolean_value, "true").should == true
+    end
+
+    it "returns false when string is false" do
+      client.send(:parse_boolean_value, "false").should == false
+    end
+
+    it "parse_boolean_value raise a ProtocolError when string is neither true nor false" do
+      lambda {
+        client.send(:parse_boolean_value, "unexpected")
+      }.should raise_error(Selenium::Client::ProtocolError, "Invalid Selenese boolean value that is neither 'true' nor 'false': got 'unexpected'")
+    end
+  end
+
+  describe "#boolean_command or #boolean_array_command" do
+    it "returns true when string_command returns 'true'" do
+      client.stub!(:string_command).with(:a_verb, :some_args).and_return("true")
+      client.boolean_command(:a_verb, :some_args).should == true
+    end
+
+    it "succeeds when given zero args" do
+      client.should_receive(:string_command).with(:a_verb, []).and_return("true")
+      client.boolean_command(:a_verb)
+    end
+
+    it "returns false when string_command returns 'false'" do
+      client.stub!(:string_command).with(:a_verb, :some_args).and_return("false")
+      client.boolean_command(:a_verb, :some_args).should == false
+    end
+
+    it "returns an array of evaluated boolean values" do
+      client.stub!(:string_array_command).with(:a_verb, :some_args).
+                                          and_return(["true", "false", "true", "true", "false"])
+
+      client.boolean_array_command(:a_verb, :some_args).should == [true, false, true, true, false]
+    end
+  end
+
+  describe "#http_request_for" do
+    it "returns cmd=verb for a verb" do
+      client.send(:http_request_for, "aCommand", []).should == "cmd=aCommand"
+    end
+
+    it "escapes the command" do
+      client.send(:http_request_for, "a Command & More", []).should == "cmd=a+Command+%26+More"
+    end
+
+    it "adds a session_id parameter when client has a current session id" do
+      client.stub!(:session_id).and_return(24)
+      client.send(:http_request_for, "aCommand", []).should == "cmd=aCommand&sessionId=24"
+    end
+
+    it "sets args as parameters whose key is their index" do
+      client.send(:http_request_for, "aCommand", [24, "foo", true]).should == "cmd=aCommand&1=24&2=foo&3=true"
+    end
+
+    it "escapes arg values" do
+      client.send(:http_request_for, "aCommand", [ "This & That" ]).should == "cmd=aCommand&1=This+%26+That"
+    end
+  end
+end

data/spec/unit/selenium/client/selenium_helper_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Selenium::Client::SeleniumHelper do
+  class SeleniumHelperClass
+    include Selenium::Client::SeleniumHelper
+    attr_accessor :selenium
+  end
+  
+  let :object do 
+    @object ||= (
+      o = SeleniumHelperClass.new 
+      o.selenium = mock("selenium")
+     
+      o
+    )
+  end
+  
+  it "delegates open to @selenium" do
+    object.selenium.should_receive(:open).with(:the_url).and_return(:the_result)
+    
+    object.open(:the_url).should == :the_result
+  end
+
+  it "delegates type to @selenium" do
+    object.selenium.should_receive(:type).with(:the_locator, :the_value) \
+                   .and_return(:the_result)
+    
+    object.type(:the_locator, :the_value).should == :the_result
+  end
+
+  it "delegates select to @selenium" do
+    object.selenium.should_receive(:type).with(:the_input_locator, 
+                                        :the_option_locator) \
+                                  .and_return(:the_result)
+    
+    object.type(:the_input_locator, :the_option_locator).should == :the_result
+  end
+
+  it "delegates to any no-arg method defined on @selenium" do
+    object.selenium.should_receive(:a_noarg_method).with().and_return(:the_result)
+    
+    object.a_noarg_method.should == :the_result
+  end
+
+  it "delegates to any arg method defined on @selenium" do
+    object.selenium.should_receive(:a_method).with(:alpha, :beta)\
+                   .and_return(:the_result)
+    
+    object.a_method(:alpha, :beta).should == :the_result
+  end
+
+  it "calls default method_missing when a method is not defined on @selenium" do
+    lambda { object.a_method(:alpha, :beta) }.should raise_error(NoMethodError)
+  end
+
+end

data/spec/unit/selenium/client/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'selenium-client'
+require 'stringio'
+
+# for bamboo
+require 'ci/reporter/rspec'
+
+module SeleniumClientSpecHelper
+  def capture_stderr(&blk)
+    io = StringIO.new
+    orig, $stderr = $stderr, io
+
+    begin
+      yield
+    ensure
+      $stderr = orig
+    end
+
+    io.string
+  end
+end
+
+RSpec.configure do |config|
+  config.include(SeleniumClientSpecHelper)
+end

data/spec/unit/selenium/rake/task_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path("../../webdriver/spec_helper", __FILE__)
+require 'selenium/rake/server_task'
+
+describe Selenium::Rake::ServerTask do
+  let(:mock_server) { mock(Selenium::Server).as_null_object }
+
+  it "raises an error if no jar file is specified" do
+    lambda {
+      Selenium::Rake::ServerTask.new
+    }.should raise_error(Selenium::Rake::MissingJarFileError)
+  end
+
+  it "launches the server with default options" do
+    expected_opts = {
+      :port       => 4444,
+      :timeout    => 30,
+      :background => true,
+      :log        => true,
+    }
+
+    Selenium::Server.should_receive(:new).
+                     with("selenium-server.jar", expected_opts).
+                     and_return(mock_server)
+
+    task = Selenium::Rake::ServerTask.new { |t| t.jar = "selenium-server.jar" }
+
+    task.port.should == 4444
+    task.timeout.should == 30
+    task.background.should be_true
+    task.log.should be_true
+    task.opts.should == []
+  end
+
+  it "lets the user override the default options" do
+    expected_opts = {
+      :port       => 5555,
+      :timeout    => 120,
+      :background => false,
+      :log        => false,
+    }
+
+    Selenium::Server.should_receive(:new).
+                     with("selenium-server.jar", expected_opts).
+                     and_return(mock_server)
+
+    task = Selenium::Rake::ServerTask.new { |t|
+      t.jar        = "selenium-server.jar"
+      t.port       = 5555
+      t.timeout    = 120
+      t.background = false
+      t.log        = false
+
+      t.opts << "-some" << "args"
+    }
+
+    task.port.should == 5555
+    task.timeout.should == 120
+    task.background.should be_false
+    task.log.should be_false
+    task.opts.should == ["-some", "args"]
+  end
+
+  it "lets the user specify a version to use which it will automatically download" do
+    required_version = '10.2.0'
+    jar_file = "selenium-server-standalone-#{required_version}.jar"
+
+    Selenium::Server.should_receive(:new).
+                     with(jar_file, anything()).
+                     and_return(mock_server)
+
+    Selenium::Server.should_receive(:download).
+                     with(required_version).
+                     and_return(jar_file)
+
+    Selenium::Rake::ServerTask.new { |t| t.version = required_version }
+  end
+
+
+end

data/spec/unit/selenium/server_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path('../webdriver/spec_helper', __FILE__)
+require 'selenium/server'
+
+describe Selenium::Server do
+  let(:mock_process) { mock(ChildProcess).as_null_object }
+  let(:mock_poller)  { mock("SocketPoller", :connected? => true, :closed? => true)}
+
+  it "raises an error if the jar file does not exist" do
+    lambda {
+      Selenium::Server.new("doesnt-exist.jar")
+    }.should raise_error(Errno::ENOENT)
+  end
+
+  it "uses the given jar file and port" do
+    File.should_receive(:exist?).with("selenium-server-test.jar").and_return(true)
+
+    ChildProcess.should_receive(:build).
+                 with("java", "-jar", "selenium-server-test.jar", "-port", "1234").
+                 and_return(mock_process)
+
+    server = Selenium::Server.new("selenium-server-test.jar", :port => 1234, :background => true)
+    server.stub!(:socket).and_return(mock_poller)
+
+    server.start
+  end
+
+  it "waits for the server process by default" do
+    File.should_receive(:exist?).with("selenium-server-test.jar").and_return(true)
+
+    ChildProcess.should_receive(:build).
+                 with("java", "-jar", "selenium-server-test.jar", "-port", "4444").
+                 and_return(mock_process)
+
+    server = Selenium::Server.new("selenium-server-test.jar")
+    server.stub!(:socket).and_return(mock_poller)
+
+    mock_process.should_receive(:wait)
+    server.start
+  end
+
+  it "adds additional args" do
+    File.should_receive(:exist?).with("selenium-server-test.jar").and_return(true)
+
+    ChildProcess.should_receive(:build).
+                 with("java", "-jar", "selenium-server-test.jar", "-port", "4444", "foo", "bar").
+                 and_return(mock_process)
+
+    server = Selenium::Server.new("selenium-server-test.jar", :background => true)
+    server.stub!(:socket).and_return(mock_poller)
+
+    server << ["foo", "bar"]
+
+    server.start
+  end
+
+  it "downloads the specified version from the selenium site" do
+    required_version = '10.2.0'
+    expected_download_file_name = "selenium-server-standalone-#{required_version}.jar"
+
+    stub_request(:get, "http://selenium.googlecode.com/files/#{expected_download_file_name}").to_return(:body => "this is pretending to be a jar file for testing purposes")
+
+    begin
+      actual_download_file_name = Selenium::Server.download(required_version)
+      actual_download_file_name.should == expected_download_file_name
+      File.should exist(expected_download_file_name)
+    ensure
+      FileUtils.rm_rf expected_download_file_name
+    end
+  end
+
+  it "gets a server instance and downloads the specified version" do
+    required_version = '10.4.0'
+    expected_download_file_name = "selenium-server-standalone-#{required_version}.jar"
+    expected_options = {:port => 5555}
+    fake_server = Object.new
+
+    Selenium::Server.should_receive(:download).with(required_version).and_return(expected_download_file_name)
+    Selenium::Server.should_receive(:new).with(expected_download_file_name, expected_options).and_return(fake_server)
+    server = Selenium::Server.get required_version, expected_options
+    server.should == fake_server
+  end
+
+  it "automatically repairs http_proxy settings that do not start with http://" do
+    ENV['http_proxy'] = 'proxy.com'
+    Selenium::Server.net_http.proxy_address.should == 'proxy.com'
+  end
+
+  it "only downloads a jar if it is not present in the current directory" do
+    required_version = '10.2.0'
+    expected_download_file_name = "selenium-server-standalone-#{required_version}.jar"
+
+    File.should_receive(:exists?).with(expected_download_file_name).and_return true
+
+    Selenium::Server.download required_version
+  end
+
+  it "should know what the latest version available is" do
+    latest_version = '10.2.0'
+    stub_request(:get, "http://code.google.com/p/selenium/downloads/list").to_return(:body => "web page containing jar selenium-server-standalone-#{latest_version}.jar")
+
+    Selenium::Server.latest.should == latest_version
+  end
+
+  it "should download the latest version if that has been specified" do
+    required_version = '10.6.0'
+    expected_download_file_name = "selenium-server-standalone-#{required_version}.jar"
+
+    Selenium::Server.should_receive(:latest).and_return required_version
+    stub_request(:get, "http://selenium.googlecode.com/files/#{expected_download_file_name}").to_return(:body => "this is pretending to be a jar file for testing purposes")
+
+    begin
+      actual_download_file_name = Selenium::Server.download(:latest)
+      actual_download_file_name.should == expected_download_file_name
+      File.should exist(expected_download_file_name)
+    ensure
+      FileUtils.rm_rf expected_download_file_name
+    end
+  end
+
+  it "raises Selenium::Server::Error if the server is not launched within the timeout" do
+    File.should_receive(:exist?).with("selenium-server-test.jar").and_return(true)
+
+    poller = mock('SocketPoller')
+    poller.should_receive(:connected?).and_return(false)
+
+    server = Selenium::Server.new("selenium-server-test.jar", :background => true)
+    server.stub!(:socket).and_return(poller)
+
+    lambda { server.start }.should raise_error(Selenium::Server::Error)
+  end
+end