seleniumrc 0.0.1

data/lib/seleniumrc/webrick_selenium_server_runner.rb

@@ -0,0 +1,33 @@
+module Seleniumrc
+  class WebrickSeleniumServerRunner < SeleniumServerRunner
+    attr_accessor :socket, :dispatch_servlet, :environment_path
+
+    protected
+    def start_server
+      @socket.do_not_reverse_lookup = true # patch for OS X
+
+      @server = @context.create_webrick_server
+      mount_parameters = {
+        :port            => @context.internal_app_server_port,
+        :ip              => @context.internal_app_server_host,
+        :environment     => @context.rails_env.dup,
+        :server_root     => @context.server_root,
+        :server_type     => WEBrick::SimpleServer,
+        :charset         => "UTF-8",
+        :mime_types      => WEBrick::HTTPUtils::DefaultMimeTypes,
+        :working_directory => File.expand_path(@context.rails_root.to_s)
+      }
+      @server.mount('/', @dispatch_servlet, mount_parameters)
+
+      trap("INT") { stop_server }
+
+      require @environment_path
+      require "dispatcher"
+      @server.start
+    end
+
+    def stop_server
+      @server.shutdown
+    end
+  end
+end

data/lib/seleniumrc.rb

@@ -0,0 +1,28 @@
+require 'socket'
+require 'logger'
+require "stringio"
+
+require "active_record"
+
+require 'net/http'
+require 'test/unit'
+require 'test/unit/testresult'
+
+require "selenium"
+require "seleniumrc/extensions/testrunnermediator"
+require "seleniumrc/extensions/selenium_driver"
+require "seleniumrc/app_server_checker"
+require "seleniumrc/selenium_server_runner"
+require "seleniumrc/mongrel_selenium_server_runner"
+require "seleniumrc/webrick_selenium_server_runner"
+require "seleniumrc/wait_for"
+require "seleniumrc/dsl/test_unit_dsl"
+require "seleniumrc/dsl/selenium_dsl"
+require "seleniumrc/selenium_context"
+require "seleniumrc/selenium_configuration"
+require "seleniumrc/selenium_page"
+require "seleniumrc/selenium_element"
+require "seleniumrc/selenium_test_case"
+require "seleniumrc/tasks/selenium_test_task"
+
+require 'webrick_server' if self.class.const_defined? :RAILS_ROOT

data/spec/seleniumrc/app_server_checker_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Seleniumrc
+describe AppServerChecker, "on local host" do
+  before(:each) do
+    @context = Seleniumrc::SeleniumContext.new
+    @host = "0.0.0.0"
+    @context.internal_app_server_host = @host
+    @port = 4000
+    @context.internal_app_server_port = @port
+    @app_server_checker = @context.create_app_server_checker
+    @mock_tcp_socket_class = 'mock_tcp_socket_class'
+    @app_server_checker.tcp_socket_class = @mock_tcp_socket_class
+    @expected_translated_local_host_address = "127.0.0.1"
+  end
+
+  it "returns true for is_server_started? if server is running" do
+    mock(@mock_tcp_socket_class).new(@expected_translated_local_host_address, @port)
+    @app_server_checker.is_server_started?.should == (true)
+  end
+
+  it "returns false for is_server_started? if server is NOT running" do
+    mock(@mock_tcp_socket_class).new.with(@expected_translated_local_host_address, @port) {raise SocketError}
+    @app_server_checker.is_server_started?.should == (false)
+  end
+end
+
+describe AppServerChecker, "on remote host" do
+  before(:each) do
+    @context = Seleniumrc::SeleniumContext.new
+    @host = "some-remote-host"
+    @context.internal_app_server_host = @host
+    @port = 4000
+    @context.internal_app_server_port = @port
+    @app_server_checker = @context.create_app_server_checker
+    @mock_tcp_socket_class = 'mock_tcp_socket_class'
+    @app_server_checker.tcp_socket_class = @mock_tcp_socket_class
+  end
+
+  it "returns true for is_server_started? if verify_remote_app_server_is_running_flag is false" do
+    @context.verify_remote_app_server_is_running = false
+    @app_server_checker.is_server_started?.should == (true)
+  end
+
+  it "returns true for is_server_started? if server is running" do
+    mock(@mock_tcp_socket_class).new.with(@host, @port)
+    @app_server_checker.is_server_started?.should == (true)
+  end
+
+  it "raises exception if server is NOT running and verify_remote_app_server_is_running_flag is true" do
+    @context.verify_remote_app_server_is_running = true
+    mock(@mock_tcp_socket_class).new.with(@host, @port) {raise SocketError}
+    lambda {@app_server_checker.is_server_started?}.should raise_error(RuntimeError)
+  end
+end
+end

data/spec/seleniumrc/mongrel_selenium_server_runner_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+context "MongrelSeleniumServerRunner instance" do
+  setup do
+    @context = Seleniumrc::SeleniumContext.new
+  end
+
+  specify "starts server" do
+    runner = create_runner_for_start_server
+    stub(runner).initialize_server
+    @runner.start
+  end
+
+  specify "start_server initializes server" do
+    @runner = create_runner_for_start_server
+
+    mock(@mock_configurator).listener.yields(@mock_configurator)
+
+    stub(@runner).defaults.returns({:environment => ""})
+    fake_rails = Object.new
+
+    mock(@mock_configurator).rails.once.returns(fake_rails)
+    mock(@mock_configurator).uri.with("/", {:handler => fake_rails})
+    mock(@mock_configurator).load_plugins.once
+    @runner.start
+  end
+
+  def create_runner_for_start_server
+    @mock_configurator = mock_configurator = "mock_configurator"
+    stub(@context).create_mongrel_configurator.returns(mock_configurator)
+    @runner = @context.create_mongrel_runner
+
+    mock(@mock_configurator).run
+    stub(@mock_configurator).log
+    mock(@mock_configurator).join
+
+    mock_thread_class = "mock_thread_class"
+    @runner.thread_class = mock_thread_class
+    mock(mock_thread_class).start.yields
+    @runner
+  end
+end

data/spec/seleniumrc/selenese_interpreter_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Selenium
+describe SeleneseInterpreter do
+  it "initializes with defaults" do
+    @interpreter = Selenium::SeleneseInterpreter.new("localhost", 4444, "*iexplore", "localhost:3000")
+
+    @interpreter.server_host.should == "localhost"
+    @interpreter.server_port.should == 4444
+    @interpreter.browser_start_command.should == "*iexplore"
+    @interpreter.browser_url.should == "localhost:3000"
+    @interpreter.timeout_in_milliseconds.should == 30000
+  end
+
+  it "should start" do
+    @interpreter = Selenium::SeleneseInterpreter.new("localhost", 4444, "*iexplore", "localhost:3000")
+
+    mock(@interpreter).do_command.
+      with("getNewBrowserSession", ["*iexplore", "localhost:3000"]).returns("   12345")
+
+    @interpreter.start
+    @interpreter.instance_eval {@session_id}.should == "12345"
+  end
+end
+end

data/spec/seleniumrc/selenium_configuration_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Seleniumrc
+describe SeleniumConfiguration do
+  before(:each) do
+    SeleniumConfiguration.instance_eval {@context = nil}
+    @mock_context = SeleniumContext.new
+  end
+
+  it "should create a new context if it hasn't been called yet" do
+    mock(SeleniumContext).new.returns(@mock_context)
+    SeleniumConfiguration.instance.should == @mock_context
+  end
+
+  it "should reuse the existing context if it has been called.  So new/establish_environment should only be called once." do
+    mock(SeleniumContext).new.returns(@mock_context)
+    SeleniumConfiguration.instance.should == @mock_context
+    SeleniumConfiguration.instance.should == @mock_context
+  end
+end
+end

data/spec/seleniumrc/selenium_context_spec.rb

@@ -0,0 +1,362 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Seleniumrc
+describe SeleniumContext do
+  before(:each) do
+    @context = Seleniumrc::SeleniumContext.new
+    @old_rails_root = RAILS_ROOT if Object.const_defined? :RAILS_ROOT
+    silence_warnings { Object.const_set :RAILS_ROOT, "foobar" }
+    require 'webrick_server'
+  end
+
+  after(:each) do
+    if @old_rails_root
+      silence_warnings { Object.const_set :RAILS_ROOT, @old_rails_root }
+    else
+      Object.instance_eval {remove_const :RAILS_ROOT}
+    end
+  end
+
+  it "registers and notifies before_suite callbacks" do
+    proc1_called = false
+    proc1 = lambda {proc1_called = true}
+    proc2_called = false
+    proc2 = lambda {proc2_called = true}
+
+    @context.before_suite(&proc1)
+    @context.before_suite(&proc2)
+    @context.notify_before_suite
+    proc1_called.should == true
+    proc2_called.should == true
+  end
+
+  it "registers and notifies after_selenese_interpreter_started callbacks" do
+    proc1_args = nil
+    proc1 = lambda {|*args| proc1_args = args}
+    proc2_args = nil
+    proc2 = lambda {|*args| proc2_args = args}
+
+    @context.after_selenese_interpreter_started(&proc1)
+    @context.after_selenese_interpreter_started(&proc2)
+
+    expected_interpreter = Object.new
+    @context.notify_after_selenese_interpreter_started(expected_interpreter)
+    proc1_args.should == [expected_interpreter]
+    proc2_args.should == [expected_interpreter]
+  end
+
+  it "creates app server checker" do
+    app_server_checker = @context.create_app_server_checker
+    app_server_checker.context.should == @context
+    app_server_checker.tcp_socket_class.should == TCPSocket
+  end
+
+  it "defaults to true for verify_remote_app_server_is_running" do
+    @context.verify_remote_app_server_is_running.should ==  true
+  end
+
+  it "creates a Selenese interpreter and notify listeners" do
+    @context.selenium_server_host = "selenium_server_host.com"
+    @context.selenium_server_port = 80
+    @context.current_browser = "iexplore"
+    @context.external_app_server_host = "browser_host.com"
+    @context.external_app_server_port = 80
+
+    interpreter = @context.create_interpreter
+    interpreter.server_host.should == "selenium_server_host.com"
+    interpreter.server_port.should == 80
+    interpreter.browser_start_command.should == "*iexplore"
+    interpreter.browser_url.should == "http://browser_host.com:80"
+  end
+
+  it "creates, initializes. and notifies listeners for a Selenese interpreter " do
+    passed_interpreter = nil
+    @context.after_selenese_interpreter_started {|interpreter| passed_interpreter = interpreter}
+
+    stub_interpreter = Object.new
+    start_called = false
+    stub(stub_interpreter).start.returns {start_called = true}
+    stub(@context).create_interpreter.returns {stub_interpreter}
+    interpreter = @context.create_and_initialize_interpreter
+    interpreter.should == stub_interpreter
+    passed_interpreter.should == interpreter
+    start_called.should == true
+  end
+
+  it "creates a Webrick Server Runner" do
+    @context.selenium_server_port = 4000
+    @context.selenium_server_host = "localhost"
+    dir = File.dirname(__FILE__)
+    @context.rails_root = dir
+    @context.rails_env = "test"
+
+    runner = @context.create_webrick_runner
+    runner.should be_an_instance_of(Seleniumrc::WebrickSeleniumServerRunner)
+    runner.context.should == @context
+    runner.thread_class.should == Thread
+    runner.socket.should == Socket
+    runner.dispatch_servlet.should == DispatchServlet
+    runner.environment_path.should == File.expand_path("#{dir}/config/environment")
+  end
+
+  it "creates webrick http server" do
+    @context.internal_app_server_port = 4000
+    @context.internal_app_server_host = "localhost"
+
+    mock_logger = "logger"
+    mock(@context).new_logger.returns(mock_logger)
+    mock(WEBrick::HTTPServer).new.with({
+      :Port => 4000,
+      :BindAddress => "localhost",
+      :ServerType  => WEBrick::SimpleServer,
+      :MimeTypes => WEBrick::HTTPUtils::DefaultMimeTypes,
+      :Logger => mock_logger,
+      :AccessLog => []
+    })
+    server = @context.create_webrick_server
+  end
+
+  it "creates Mongrel Server Runner" do
+   server = @context.create_mongrel_runner
+   server.should be_instance_of(Seleniumrc::MongrelSeleniumServerRunner)
+   server.context.should == @context
+   server.thread_class.should == Thread
+  end
+
+  it "creates Mongrel configurator" do
+    @context.internal_app_server_host = "localhost"
+    @context.internal_app_server_port = 4000
+    @context.rails_env = "test"
+    @context.rails_root = File.dirname(__FILE__)
+
+    configurator = @context.create_mongrel_configurator
+    configurator.defaults[:host].should == "localhost"
+    configurator.defaults[:port].should == 4000
+    configurator.defaults[:cwd].should == @context.rails_root
+    configurator.defaults[:log_file].should == "#{@context.rails_root}/log/mongrel.log"
+    configurator.defaults[:pid_file].should == "#{@context.rails_root}/log/mongrel.pid"
+    configurator.defaults[:environment].should == "test"
+    configurator.defaults[:docroot].should == "public"
+    configurator.defaults[:mime_map].should be_nil
+    configurator.defaults[:daemon].should == false
+    configurator.defaults[:debug].should == false
+    configurator.defaults[:includes].should == ["mongrel"]
+    configurator.defaults[:config_script].should be_nil
+  end
+end
+
+context SeleniumConfiguration, "#establish_environment" do
+  before(:each) do
+    Seleniumrc::SeleniumConfiguration.instance_eval {@context = nil}
+    @configuration = Seleniumrc::SeleniumConfiguration.instance
+    @context = @configuration
+  end
+
+  it "establish_environment__webrick_host" do
+    should_establish_environment( 'internal_app_server_host', '192.168.10.1', :internal_app_server_host )
+  end
+
+  it "initializes webrick_port" do
+    should_establish_environment( 'internal_app_server_port', 1337, :internal_app_server_port )
+  end
+
+  it "initializes internal_app_server_port" do
+    should_establish_environment( 'external_app_server_port', 1337, :external_app_server_port )
+  end
+
+  it "initializes internal_app_server_host" do
+    should_establish_environment( 'external_app_server_host', 'sammich.com', :external_app_server_host)
+  end
+
+  it "initializes selenium_server_host" do
+    should_establish_environment( 'selenium_server_host', 'sammich.com')
+  end
+
+  it "initializes selenium_server_host" do
+    should_establish_environment( 'selenium_server_port', 1337)
+  end
+
+  it "initializes app_server_engine" do
+    should_establish_environment( 'app_server_engine', :webrick, :app_server_engine)
+  end
+
+  it "initializes browsers" do
+    @context.env = stub_env
+    env_var = "browsers"
+    expected_value = 'konqueror'
+    stub_env[env_var] = expected_value
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    @configuration.browsers.should == [expected_value]
+  end
+
+  it "initializes keep_browser_open_on_failure" do
+    @context.env = stub_env
+    env_var = 'keep_browser_open_on_failure'
+    stub_env[env_var] = 'false'
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    @configuration.send(env_var).should == false
+    @configuration.send(env_var).should == false
+
+    stub_env[env_var] = 'true'
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    @configuration.send(env_var).should == true
+    @configuration.send(env_var).should == true
+
+    stub_env[env_var] = 'blah'
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    @configuration.send(env_var).should == true
+    @configuration.send(env_var).should == true
+  end
+
+  it "initializes verify_remote_app_server_is_running" do
+    @context.env = stub_env
+    env_var = 'verify_remote_app_server_is_running'
+    stub_env[env_var] = 'false'
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    @configuration.send(env_var).should == false
+    @configuration.send(env_var).should == false
+
+    stub_env[env_var] = 'true'
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    @configuration.send(env_var).should == true
+    @configuration.send(env_var).should == true
+
+    stub_env[env_var] = 'blah'
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    @configuration.send(env_var).should == true
+    @configuration.send(env_var).should == true
+  end
+
+  it "internal_app_server_host" do
+    should_lazily_load @configuration, :internal_app_server_host, "0.0.0.0"
+  end
+
+  it "internal_app_server_port" do
+    should_lazily_load @configuration, :internal_app_server_port, 4000
+  end
+
+  it "external_app_server_host" do
+    should_lazily_load @configuration, :external_app_server_host, "localhost"
+  end
+
+  it "external_app_server_port" do
+    should_lazily_load @configuration, :external_app_server_port, 4000
+  end
+
+  it "browsers__lazy_loaded" do
+    should_lazily_load @configuration, :browsers, [Seleniumrc::SeleniumConfiguration::FIREFOX]
+  end
+
+  it "keep_browser_open_on_failure" do
+    should_lazily_load @configuration, :keep_browser_open_on_failure, true
+  end
+
+  it "formatted_browser" do
+    @configuration.current_browser = Seleniumrc::SeleniumConfiguration::IEXPLORE
+    @configuration.formatted_browser.should == "*iexplore"
+  end
+
+  it "browser_url" do
+    @configuration.external_app_server_host = "test.com"
+    @configuration.external_app_server_port = 101
+    @configuration.browser_url.should == "http://test.com:101"
+  end
+
+  it "run_each_browser_within_the_browsers" do
+    expected_browsers = ["iexplore", "firefox", "custom"]
+    @configuration.browsers = expected_browsers
+
+    index = 0
+    @configuration.run_each_browser do
+      @configuration.current_browser.should == expected_browsers[index]
+      index += 1
+    end
+  end
+
+  it "selenese_interpreter__when_in_test_browser_mode__should_be_nil" do
+    @configuration.test_browser_mode!
+    @configuration.selenese_interpreter.should be_nil
+  end
+
+  protected
+  def should_establish_environment( env_var, expected_value, method_name=nil )
+    method_name = env_var unless method_name
+    @context.env = stub_env
+    stub_env[env_var] = expected_value
+    Seleniumrc::SeleniumConfiguration.send :establish_environment
+    Seleniumrc::SeleniumConfiguration.instance.send(method_name).should == expected_value
+  end
+
+  def stub_env
+    @stub_env ||= {}
+  end
+
+  def should_lazily_load(object, method_name, default_value)
+    object.send(method_name).should == default_value
+    test_object = Object.new
+    object.send(method_name.to_s + "=", test_object)
+    object.send(method_name).should == test_object
+  end
+
+end
+
+describe SeleniumContext, "#stop_interpreter_if_necessary" do
+  before(:each) do
+    @context = Seleniumrc::SeleniumContext.new
+  end
+  
+  it "when suite passes, should stop interpreter" do
+    mock_interpreter = "mock_interpreter"
+    mock(mock_interpreter).stop.once
+    @context.interpreter = mock_interpreter
+
+    @context.stop_interpreter_if_necessary true
+  end
+
+  it "when suite fails and keep browser open on failure, should not stop interpreter" do
+    mock_interpreter = "mock_interpreter"
+    mock(mock_interpreter).stop.never
+    @context.interpreter = mock_interpreter
+    @context.keep_browser_open_on_failure = true
+
+    @context.stop_interpreter_if_necessary false
+  end
+
+  it "when suite fails and not keep browser open on failure, should stop interpreter" do
+    mock_interpreter = "mock_interpreter"
+    mock(mock_interpreter).stop
+    @context.interpreter = mock_interpreter
+    @context.keep_browser_open_on_failure = false
+
+    @context.stop_interpreter_if_necessary false
+  end
+
+end
+
+describe SeleniumContext, "#create_server_runner where application server engine is mongrel" do
+  it "creates a mongrel server runner" do
+    context = Seleniumrc::SeleniumContext.new
+    context.app_server_engine = :mongrel
+    runner = context.create_server_runner
+    runner.should be_instance_of(MongrelSeleniumServerRunner)
+  end
+end
+
+context SeleniumContext, "#create_server_runner where application server engine is webrick" do
+  before do
+    Object.const_set :RAILS_ROOT, "foobar"
+    require 'webrick_server'
+  end
+
+  after do
+    Object.instance_eval {remove_const :RAILS_ROOT}
+  end
+
+  it "creates a webrick server runner" do
+    context = Seleniumrc::SeleniumContext.new
+    context.app_server_engine = :webrick
+    runner = context.create_server_runner
+    runner.should be_instance_of(WebrickSeleniumServerRunner)
+  end
+end
+end