polonium 0.1.0

data/lib/polonium/selenium_helper.rb

@@ -0,0 +1,5 @@
+# Expand the path to environment so that Ruby does not load it multiple times
+# File.expand_path can be removed if Ruby 1.9 is in use.
+if (Object.const_defined?(:ActiveRecord) && !ActiveRecord::Base.allow_concurrency)
+  raise "Since Selenium spawns an internal app server, we need ActiveRecord to be multi-threaded. Please set 'ActiveRecord::Base.allow_concurrency = true' in your environment file (e.g. test.rb)."
+end

data/lib/polonium/server_runner.rb

@@ -0,0 +1,33 @@
+module Polonium
+  class ServerRunner
+    attr_accessor :configuration, :thread_class
+    def initialize
+      @started = false
+    end
+
+    def start
+      @thread_class.start do
+        start_server
+      end
+      @started = true
+    end
+
+    def stop
+      stop_server
+      @started = false
+    end
+
+    def started?
+      @started
+    end
+
+    protected
+    def start_server
+      raise NotImplementedError.new("this is abstract!")
+    end
+
+    def stop_server
+      raise NotImplementedError.new("this is abstract!")
+    end
+  end
+end

data/lib/polonium/tasks/selenium_test_task.rb

@@ -0,0 +1,21 @@
+
+module Polonium
+  module Tasks
+    class PoloniumTestTask
+      attr_reader :rails_env, :rails_root
+
+      def initialize(rails_env = RAILS_ENV, rails_root = RAILS_ROOT)
+        @rails_env = rails_env
+        @rails_root = rails_root
+      end
+
+      def invoke(suite_relative_path = "test/selenium/selenium_suite")
+        rails_env.replace "test"
+        require "#{rails_root}/" + suite_relative_path
+
+        passed = Test::Unit::AutoRunner.run
+        raise "Test failures" unless passed
+      end
+    end
+  end
+end

data/lib/polonium/test_case.rb

@@ -0,0 +1,93 @@
+module Polonium
+  # The Test Case class that runs your Selenium tests.
+  # You are able to use all methods provided by Selenium::SeleneseInterpreter with some additions.
+  class TestCase < Test::Unit::TestCase
+    module ClassMethods
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(subclass)
+        # keep a list of all subclasses on the fly, so we can run them all later from the Runner
+        subclasses << subclass unless subclasses.include?(subclass)
+        super
+      end
+
+      def all_subclasses_as_suite(configuration)
+        suite = Test::Unit::TestSuite.new
+        all_descendant_classes.each do |test_case_class|
+          test_case_class.suite.tests.each do |test_case|
+            test_case.configuration = configuration
+            suite << test_case
+          end
+        end
+        suite
+      end
+
+      def all_descendant_classes
+        extract_subclasses(self)
+      end
+
+      def extract_subclasses(parent_class)
+        classes = []
+        parent_class.subclasses.each do |subclass|
+          classes << subclass
+          classes.push(*extract_subclasses(subclass))
+        end
+        classes
+      end
+
+      unless Object.const_defined?(:RAILS_ROOT)
+        attr_accessor :use_transactional_fixtures, :use_instantiated_fixtures
+      end
+    end
+    extend ClassMethods
+
+    self.use_transactional_fixtures = false
+    self.use_instantiated_fixtures  = true
+
+    include TestUnitDsl
+    def setup
+      #   set "setup_once" to true
+      #   to prevent fixtures from being re-loaded and data deleted from the DB.
+      #   this is handy if you want to generate a DB full of sample data
+      #   from the tests.  Make sure none of your selenium tests manually
+      #   reset data!
+      #TODO: make this configurable
+      setup_once = false
+
+      raise "Cannot use transactional fixtures if ActiveRecord concurrency is turned on (which is required for Selenium tests to work)." if self.class.use_transactional_fixtures
+      unless setup_once
+        ActiveRecord::Base.connection.update('SET FOREIGN_KEY_CHECKS = 0')
+        super
+        ActiveRecord::Base.connection.update('SET FOREIGN_KEY_CHECKS = 1')
+      else
+        unless InstanceMethods.const_defined?("ALREADY_SETUP_ONCE")
+          super
+          InstanceMethods.const_set("ALREADY_SETUP_ONCE", true)
+        end
+      end
+      @selenium_driver = configuration.driver
+    end
+
+    def teardown
+      selenium_driver.stop if should_stop_driver?
+      super
+      if @beginning
+        duration = (time_class.now - @beginning).to_f
+        puts "#{duration} seconds"
+      end
+    end
+
+    def selenium_test_case
+      @selenium_test_case ||= TestCase
+    end
+
+    def run(result, &block)
+      return if @method_name.nil? || @method_name.to_sym == :default_test
+      super
+    end
+  end
+end
+
+TestCase = Polonium::TestCase

data/lib/polonium/wait_for.rb

@@ -0,0 +1,40 @@
+module Polonium
+  module WaitFor
+    Context = Struct.new(:message)
+    # Poll continuously for the return value of the block to be true. You can use this to assert that a client side
+    # or server side condition was met.
+    #   wait_for do
+    #     User.count == 5
+    #   end
+    def wait_for(params={})
+      timeout = params[:timeout] || default_wait_for_time
+      message = params[:message] || "Timeout exceeded"
+      configuration = Context.new(message)
+      begin_time = time_class.now
+      while (time_class.now - begin_time) < timeout
+        return if yield(configuration)
+        sleep 0.25
+      end
+      flunk(configuration.message + " (after #{timeout} sec)")
+      true
+    end
+
+    def default_wait_for_time
+      5
+    end
+
+    def time_class
+      Time
+    end
+
+    # The default Selenium Core client side timeout.
+    def default_timeout
+      @default_timeout ||= 20000
+    end
+    attr_writer :default_timeout
+
+    def flunk(message)
+      raise Test::Unit::AssertionFailedError, message
+    end
+  end
+end

data/lib/polonium/webrick_selenium_server_runner.rb

@@ -0,0 +1,33 @@
+module Polonium
+  class WebrickSeleniumServerRunner < ServerRunner
+    attr_accessor :socket, :dispatch_servlet, :environment_path, :server
+
+    protected
+    def start_server
+      socket.do_not_reverse_lookup = true # patch for OS X
+
+      @server = configuration.create_webrick_server
+      mount_parameters = {
+        :port            => configuration.internal_app_server_port,
+        :ip              => configuration.internal_app_server_host,
+        :environment     => configuration.rails_env.dup,
+        :server_root     => configuration.server_root,
+        :server_type     => WEBrick::SimpleServer,
+        :charset         => "UTF-8",
+        :mime_types      => WEBrick::HTTPUtils::DefaultMimeTypes,
+        :working_directory => File.expand_path(configuration.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/spec/polonium/extensions/module_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Module do
+  describe "#deprecate" do
+    it "creates a method that calls another method with a deprecation warning" do
+      klass = Class.new do
+        def car
+          :beep
+        end
+        deprecate :horse, :car
+      end
+      obj = klass.new
+      mock(obj).warn("horse is deprecated. Use car instead.")
+      obj.horse.should == :beep
+    end
+
+    it "proxies arguments to the new method" do
+      klass = Class.new do
+        def car(name, location='here')
+          "You have a #{name} located at #{location}"
+        end
+        deprecate :horse, :car
+      end
+      obj = klass.new
+      mock(obj).warn("horse is deprecated. Use car instead.")
+      obj.horse('mustang').should == "You have a mustang located at here"
+    end
+  end
+end

data/spec/polonium/extensions/testrunnermediator_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Test::Unit::UI::TestRunnerMediator do
+  attr_reader :driver
+  before do
+    @driver = Polonium::Configuration.instance
+  end
+
+  it "start the server runner before suite and stops it after the suite" do
+    suite = Test::Unit::TestSuite.new
+    mediator = Test::Unit::UI::TestRunnerMediator.new(suite)
+
+    runner = driver.create_server_runner
+    mock(driver).create_server_runner {runner}
+    mock(runner).stop
+    mock(driver).stop_driver_if_necessary(true)
+    mediator.run_suite
+  end
+end

data/spec/polonium/mongrel_selenium_server_runner_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Polonium
+  describe MongrelSeleniumServerRunner, "#start_server" do
+    attr_reader :configuration
+    before do
+      @configuration = Configuration.new
+    end
+
+    it "initializes server and runs app_server_initialization callback" do
+      mongrel_configurator = configuration.create_mongrel_configurator
+      stub(configuration).create_mongrel_configurator {mongrel_configurator}
+      mock(mongrel_configurator).run
+      stub(mongrel_configurator).log
+      mock(mongrel_configurator).join
+      fake_rails = "fake rails"
+      mock(mongrel_configurator).rails {fake_rails}
+      mock(mongrel_configurator).uri("/", {:handler => fake_rails})
+      mock(mongrel_configurator).load_plugins
+      mock(mongrel_configurator).listener.yields(mongrel_configurator)
+
+      callback_mongrel = nil
+      configuration.app_server_initialization = proc do |mongrel|
+        callback_mongrel = mongrel
+      end
+      runner = configuration.create_mongrel_runner
+      stub(runner).defaults do; {:environment => ""}; end
+      runner.thread_class = mock_thread_class = "mock_thread_class"
+      mock(mock_thread_class).start.yields
+
+      runner.start
+      callback_mongrel.should == mongrel_configurator
+    end
+  end
+end

data/spec/polonium/selenium_configuration_spec.rb

@@ -0,0 +1,359 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Polonium
+  describe Configuration, ".instance" do
+    attr_reader :configuration
+    before(:each) do
+      Configuration.instance = nil
+      @configuration = Configuration.new
+    end
+
+    it "should create a new Configuration if it hasn't been called yet" do
+      mock(Configuration).new.returns(configuration)
+      Configuration.instance.should == configuration
+    end
+
+    it "should reuse the existing Configuration if it has been called.  So new/establish_environment should only be called once." do
+      Configuration.instance.should_not be_nil
+      dont_allow(Configuration).new
+    end
+  end
+
+  describe Configuration do
+    attr_reader :configuration
+    before(:each) do
+      @configuration = Configuration.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 after_driver_started callbacks" do
+      proc1_args = nil
+      proc1 = lambda {|*args| proc1_args = args}
+      proc2_args = nil
+      proc2 = lambda {|*args| proc2_args = args}
+
+      configuration.after_driver_started(&proc1)
+      configuration.after_driver_started(&proc2)
+
+      expected_driver = Object.new
+      configuration.notify_after_driver_started(expected_driver)
+      proc1_args.should == [expected_driver]
+      proc2_args.should == [expected_driver]
+    end
+
+    it "defaults to true for verify_remote_app_server_is_running" do
+      configuration.verify_remote_app_server_is_running.should ==  true
+    end
+
+    it "defaults app_server_initialization to a Proc" do
+      configuration.app_server_initialization.should be_instance_of(Proc)
+    end
+
+    it "creates a Selenese driver and notify listeners" do
+      configuration.selenium_server_host = "selenium_server_host.com"
+      configuration.selenium_server_port = 80
+      configuration.browser = "iexplore"
+      configuration.external_app_server_host = "browser_host.com"
+      configuration.external_app_server_port = 80
+
+      driver = configuration.create_driver
+      driver.server_host.should == "selenium_server_host.com"
+      driver.server_port.should == 80
+      driver.browser_start_command.should == "*iexplore"
+      driver.browser_url.should == "http://browser_host.com:80"
+    end
+
+    it "creates, initializes. and notifies listeners for a Selenese driver " do
+      passed_driver = nil
+      configuration.after_driver_started {|driver| passed_driver = driver}
+
+      stub_driver = Object.new
+      start_called = false
+      stub(stub_driver).start.returns {start_called = true}
+      stub(configuration).create_driver.returns {stub_driver}
+      driver = configuration.create_and_initialize_driver
+      driver.should == stub_driver
+      passed_driver.should == driver
+      start_called.should == true
+    end
+
+    it "creates a Webrick Server Runner" do
+      configuration.selenium_server_port = 4000
+      configuration.selenium_server_host = "localhost"
+      dir = File.dirname(__FILE__)
+      configuration.rails_root = dir
+      configuration.rails_env = "test"
+
+      runner = configuration.create_webrick_runner
+      runner.should be_an_instance_of(WebrickSeleniumServerRunner)
+      runner.configuration.should == configuration
+      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
+      configuration.internal_app_server_port = 4000
+      configuration.internal_app_server_host = "localhost"
+
+      mock_logger = "logger"
+      mock(configuration).new_logger {mock_logger}
+      mock(WEBrick::HTTPServer).new({
+        :Port => 4000,
+        :BindAddress => "localhost",
+        :ServerType  => WEBrick::SimpleServer,
+        :MimeTypes => WEBrick::HTTPUtils::DefaultMimeTypes,
+        :Logger => mock_logger,
+        :AccessLog => []
+      })
+      server = configuration.create_webrick_server
+    end
+
+    it "creates Mongrel Server Runner" do
+      server = configuration.create_mongrel_runner
+      server.should be_instance_of(MongrelSeleniumServerRunner)
+      server.configuration.should == configuration
+      server.thread_class.should == Thread
+    end
+
+    it "creates Mongrel configurator" do
+      configuration.internal_app_server_host = "localhost"
+      configuration.internal_app_server_port = 4000
+      configuration.rails_env = "test"
+      configuration.rails_root = rails_root = File.dirname(__FILE__)
+
+      configurator = configuration.create_mongrel_configurator
+      configurator.defaults[:host].should == "localhost"
+      configurator.defaults[:port].should == 4000
+      configurator.defaults[:cwd].should == configuration.rails_root
+      configurator.defaults[:log_file].should == "#{configuration.rails_root}/log/mongrel.log"
+      configurator.defaults[:pid_file].should == "#{configuration.rails_root}/log/mongrel.pid"
+      configurator.defaults[:environment].should == "test"
+      configurator.defaults[:docroot].should == "#{rails_root}/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
+
+  describe Configuration, "#establish_environment" do
+    attr_reader :configuration
+    before(:each) do
+      @old_configuration = Configuration.instance
+      Configuration.instance = nil
+      @configuration = Configuration.instance
+      configuration = @configuration
+    end
+
+    after(:each) do
+      Configuration.instance = @old_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 browser" do
+      configuration.env = stub_env
+      stub_env['browser'] = 'konqueror'
+      Configuration.__send__(:establish_environment)
+      configuration.browser.should == 'konqueror'
+    end
+
+    it "initializes keep_browser_open_on_failure" do
+      configuration.env = stub_env
+      env_var = 'keep_browser_open_on_failure'
+      stub_env[env_var] = 'false'
+      Configuration.send :establish_environment
+      configuration.send(env_var).should == false
+      configuration.send(env_var).should == false
+
+      stub_env[env_var] = 'true'
+      Configuration.send :establish_environment
+      configuration.send(env_var).should == true
+      configuration.send(env_var).should == true
+
+      stub_env[env_var] = 'blah'
+      Configuration.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
+      configuration.env = stub_env
+      env_var = 'verify_remote_app_server_is_running'
+      stub_env[env_var] = 'false'
+      Configuration.send :establish_environment
+      configuration.send(env_var).should == false
+      configuration.send(env_var).should == false
+
+      stub_env[env_var] = 'true'
+      Configuration.send :establish_environment
+      configuration.send(env_var).should == true
+      configuration.send(env_var).should == true
+
+      stub_env[env_var] = 'blah'
+      Configuration.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, :browser, Configuration::FIREFOX
+    end
+
+    it "keep_browser_open_on_failure" do
+      should_lazily_load configuration, :keep_browser_open_on_failure, false
+    end
+
+    it "formatted_browser" do
+      configuration.browser = Configuration::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 "driver__when_in_test_browser_mode__should_be_nil" do
+      configuration.test_browser_mode
+      configuration.driver.should be_nil
+    end
+
+    protected
+    def should_establish_environment(env_var, expected_value, method_name=nil )
+      method_name = env_var unless method_name
+      configuration.env = stub_env
+      stub_env[env_var] = expected_value
+      Configuration.send :establish_environment
+      Configuration.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}=", test_object)
+      object.send(method_name).should == test_object
+    end
+  end
+
+  describe Configuration, "#stop_driver_if_necessary" do
+    attr_reader :configuration
+    before(:each) do
+      @configuration = Configuration.new
+    end
+
+    it "when suite passes, should stop driver" do
+      driver = ::Polonium::Driver.new('http://test.host', 4000, "*firefox", 'http://test.host')
+      mock(driver).stop.once
+      configuration.driver = driver
+
+      configuration.stop_driver_if_necessary true
+    end
+
+    it "when suite fails and keep browser open on failure, should not stop driver" do
+      driver = ::Polonium::Driver.new('http://test.host', 4000, "*firefox", 'http://test.host')
+      mock(driver).stop.never
+      configuration.driver = driver
+      configuration.keep_browser_open_on_failure = true
+
+      configuration.stop_driver_if_necessary false
+    end
+
+    it "when suite fails and not keep browser open on failure, should stop driver" do
+      driver = ::Polonium::Driver.new('http://test.host', 4000, "*firefox", 'http://test.host')
+      mock(driver).stop
+      configuration.driver = driver
+      configuration.keep_browser_open_on_failure = false
+
+      configuration.stop_driver_if_necessary false
+    end
+
+  end
+
+  describe Configuration, "#create_server_runner where application server engine is mongrel" do
+    it "creates a mongrel server runner" do
+      configuration = Configuration.new
+      configuration.app_server_engine = :mongrel
+      runner = configuration.create_server_runner
+      runner.should be_instance_of(MongrelSeleniumServerRunner)
+    end
+  end
+
+  describe Configuration, "#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
+      configuration = Configuration.new
+      configuration.app_server_engine = :webrick
+      runner = configuration.create_server_runner
+      runner.should be_instance_of(WebrickSeleniumServerRunner)
+    end
+  end
+end