polonium 0.1.1 → 0.2.0

data/spec/polonium/driver_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 module Polonium
-  describe Driver, :shared => true do
+  describe Driver do
     it_should_behave_like "Selenium"
     attr_reader :driver, :commands
     before do
@@ -15,90 +15,140 @@ module Polonium
     def sample_text
       "test text"
     end
-  end
 
-  describe Driver, "#initialize" do
-    it_should_behave_like "Polonium::Driver"
-    
-    it "initializes with defaults" do
-      driver.server_host.should == "localhost"
-      driver.server_port.should == 4444
-      driver.browser_start_command.should == "*iexplore"
-      driver.browser_url.should == "localhost:3000"
-      driver.timeout_in_milliseconds.should == 30000
-    end
+    describe "#initialize" do
+      it "initializes with defaults" do
+        driver.server_host.should == "localhost"
+        driver.server_port.should == 4444
+        driver.browser_start_command.should == "*iexplore"
+        driver.browser_url.should == "localhost:3000"
+        driver.timeout_in_milliseconds.should == 30000
+      end
 
-    it "should start" do
-      mock(driver).do_command.
-        with("getNewBrowserSession", ["*iexplore", "localhost:3000"]).returns("   12345")
+      it "should start" do
+        mock(driver).do_command.
+          with("getNewBrowserSession", ["*iexplore", "localhost:3000"]).returns("   12345")
 
-      driver.start
-      driver.instance_variable_get(:@session_id).should == "12345"
+        driver.start
+        driver.instance_variable_get(:@session_id).should == "12345"
+      end
     end
-  end
-
-  describe Driver, "#inner_html_js" do
-    it_should_behave_like "Polonium::Driver"
 
-    it "returns findElement command in js" do
-      driver.inner_html_js(sample_locator).should ==
-        %Q|this.page().findElement("#{sample_locator}").innerHTML|
+    describe "#inner_html_js" do
+      it "returns findElement command in js" do
+        driver.inner_html_js(sample_locator).should ==
+          %Q|this.page().findElement("#{sample_locator}").innerHTML|
+      end
     end
-  end
 
-  describe Driver, "#wait_for_element_to_contain" do
-    it_should_behave_like "Polonium::Driver"
+    describe "#open and #open_and_wait" do
+      it "opens page and waits for it to load" do
+        mock(driver).do_command("open", ["http://localhost:4000"])
+        mock(driver).do_command("waitForPageToLoad", [driver.default_timeout]) {result}
+        mock(driver).do_command("getTitle", []) {result("Some Title")}
 
-    it "when finding text within time limit, passes" do
-      is_element_present_results = [false, true]
-      mock(driver).do_command('isElementPresent', [sample_locator]).times(2) do
-        result(is_element_present_results.shift)
-      end
-      mock(driver).do_command('getEval', [driver.inner_html_js(sample_locator)]) do
-        result(sample_text)
+        driver.open("http://localhost:4000")
       end
 
-      driver.wait_for_element_to_contain(sample_locator, sample_text)
+      it "aliases #open_and_wait to #open" do
+        driver.method(:open_and_wait).should == driver.method(:open)
+      end
     end
 
-    it "when element not found in time, fails" do
-      mock(driver).do_command('isElementPresent', [sample_locator]).times(4) do
-        result(false)
+    describe "#type" do
+      it "types when element is present and types" do
+        is_element_present_results = [false, true]
+        mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+          result(is_element_present_results.shift)
+        end
+        mock(driver).do_command("type", ["id=foobar", "The Text"]) do
+          result()
+        end
+
+        driver.type "id=foobar", "The Text"
       end
 
-      proc do
-        driver.wait_for_element_to_contain(sample_locator, "")
-      end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 5 sec)")
-    end
+      it "fails when element is not present" do
+        mock(driver).do_command("isElementPresent", ["id=foobar"]).times(4) do
+          result(false)
+        end
+        dont_allow(driver).do_command("type", ["id=foobar", "The Text"])
 
-    it "when text does not match in time, fails" do
-      is_element_present_results = [false, true, true, true]
-      stub(driver).do_command('isElementPresent', [sample_locator]) do
-        result(is_element_present_results.shift)
+        proc {
+          driver.type "id=foobar", "The Text"
+        }.should raise_error(Test::Unit::AssertionFailedError)
       end
-      stub(driver).do_command('getEval', [driver.inner_html_js(sample_locator)]) do
-        result(sample_text)
+    end
+
+    describe "#click" do
+      it "click when element is present and types" do
+        is_element_present_results = [false, true]
+        mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+          result(is_element_present_results.shift)
+        end
+        mock(driver).do_command("click", ["id=foobar"]) {result}
+
+        driver.click "id=foobar"
       end
 
-      proc do
-        driver.wait_for_element_to_contain(sample_locator, "wrong text", nil, 1)
-      end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 1 sec)")
+      it "fails when element is not present" do
+        is_element_present_results = [false, false, false, false]
+        mock(driver).do_command("isElementPresent", ["id=foobar"]).times(4) do
+          result(is_element_present_results.shift)
+        end
+        dont_allow(driver).do_command("click", [])
+
+        proc {
+          driver.click "id=foobar"
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
     end
-  end
 
-  describe Driver, "#open and #open_and_wait" do
-    it_should_behave_like "Polonium::Driver"
+    describe "#select" do
+      it "types when element is present and types" do
+        is_element_present_results = [false, true]
+        mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+          result is_element_present_results.shift
+        end
+        mock(driver).do_command("select", ["id=foobar", "value=3"]) {result}
 
-    it "opens page and waits for it to load" do
-      mock(driver).do_command("open", ["http://localhost:4000"])
-      mock(driver).do_command("waitForPageToLoad", [driver.default_timeout]) {result}
-      mock(driver).do_command("getTitle", []) {result("Some Title")}
+        driver.select "id=foobar", "value=3"
+      end
+
+      it "fails when element is not present" do
+        mock(driver).do_command("isElementPresent", ["id=foobar"]).times(4) do
+          result false
+        end
+        dont_allow(driver).do_command("select", ["id=foobar", "value=3"])
 
-      driver.open("http://localhost:4000")
+        proc {
+          driver.select "id=foobar", "value=3"
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
     end
 
-    it "aliases #open_and_wait to #open" do
-      driver.method(:open_and_wait).should == driver.method(:open)
+    describe "#click" do
+      it "click when element is present and types" do
+        is_element_present_results = [false, true]
+        mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+          result is_element_present_results.shift
+        end
+        mock(driver).do_command("click", ["id=foobar"]) {result}
+
+        driver.click "id=foobar"
+      end
+
+      it "fails when element is not present" do
+        is_element_present_results = [false, false, false, false]
+        mock(driver).is_element_present("id=foobar").times(4) do
+          is_element_present_results.shift
+        end
+        dont_allow(driver).do_command("click", ["id=foobar"])
+
+        proc {
+          driver.click "id=foobar"
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
     end
-  end  
+  end
 end

data/spec/polonium/element_spec.rb

@@ -109,7 +109,7 @@ module Polonium
 
     describe "#assert_value" do
       it "passes when element is present and value is expected value" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -121,7 +121,7 @@ module Polonium
       end
 
       it "fails when element is present and not expected value" do
-        mock(driver).is_element_present(element_locator) {true}
+        stub(driver).is_element_present(element_locator) {true}
         stub(driver).get_value(element_locator) {"jane"}
         proc do
           element.assert_value("joe")
@@ -149,14 +149,8 @@ module Polonium
     end
 
     describe "#assert_attribute" do
-      attr_reader :element_locator
-
-      before do
-        element_locator = "id=foobar"
-      end
-
       it "passes when element is present and value is expected value" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -186,13 +180,36 @@ module Polonium
       end
     end
 
+    describe "#assert_attribute_does_not_contain" do
+      it "passes when element is present and value does not contain the illegal value" do
+        stub(driver).is_element_present(element_locator) {true}
+        stub(driver).get_attribute("#{element_locator}@theattribute") { "jane" }
+        element.assert_attribute_does_not_contain('theattribute', "joe")
+      end
+
+      it "passes when element is present and value does contain the illegal value" do
+        stub(driver).is_element_present(element_locator) {true}
+        stub(driver).get_attribute("#{element_locator}@theattribute") { "jane" }
+        proc do
+          element.assert_attribute_does_not_contain('theattribute', "jane")
+        end.should raise_error(Test::Unit::AssertionFailedError)
+      end
+      
+      it "fails when element is not present" do
+        stub(driver).is_element_present(element_locator) {false}
+        proc do
+          element.assert_attribute_does_not_contain('theattribute', "jane")
+        end.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
+
     describe "#assert_selected" do
       before do
         @element_locator = "id=foobar"
       end
 
       it "passes when element is present and value is expected value" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -229,7 +246,7 @@ module Polonium
       end
 
       it "passes when element exists and is visible" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -262,7 +279,7 @@ module Polonium
       end
 
       it "passes when element exists and is not visible" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -295,7 +312,7 @@ module Polonium
       end
 
       it "passes when element is present and value is expected value" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -328,7 +345,7 @@ module Polonium
       end
 
       it "passes when element is present and value is expected value" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -361,7 +378,7 @@ module Polonium
       end
 
       it "passes when element is present and value is expected value" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(element_locator) do
           element_ticks.shift
         end.times(4)
@@ -400,7 +417,7 @@ module Polonium
 
       describe "when passed a String" do
         it "passes when element is present and the element contains text" do
-          element_ticks = [false, false, false, true]
+          element_ticks = [true, true, true, true]
           mock(driver).is_element_present(element_locator) do
             element_ticks.shift
           end.times(4)
@@ -422,7 +439,7 @@ module Polonium
 
       describe "when passed a Regexp" do
         it "passes when element is present and the element contains text that matches the regexp" do
-          element_ticks = [false, false, false, true]
+          element_ticks = [true, true, true, true]
           mock(driver).is_element_present(element_locator) do
             element_ticks.shift
           end.times(4)
@@ -467,7 +484,7 @@ module Polonium
 
       describe "when passed a String" do
         it "passes when element is present and the element does not contain text" do
-          element_ticks = [false, false, false, true]
+          element_ticks = [true, true, true, true]
           mock(driver).is_element_present(element_locator) do
             element_ticks.shift
           end.times(4)
@@ -489,7 +506,7 @@ module Polonium
 
       describe "when passed a Regexp" do
         it "passes when element is present and the element does not contain text that matches the Regexp" do
-          element_ticks = [false, false, false, true]
+          element_ticks = [true, true, true, true]
           mock(driver).is_element_present(element_locator) do
             element_ticks.shift
           end.times(4)
@@ -524,7 +541,7 @@ module Polonium
       end
 
       it "passes when element is present and value is expected value" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(@element_locator) do
           element_ticks.shift
         end.times(4)
@@ -558,7 +575,7 @@ module Polonium
       end
 
       it "passes when element is present and passed in text and Regexp matches are in order" do
-        element_ticks = [false, false, false, true]
+        element_ticks = [true, true, true, true]
         mock(driver).is_element_present(@element_locator) do
           element_ticks.shift
         end.times(4)
@@ -589,12 +606,40 @@ module Polonium
         end.should raise_error(Test::Unit::AssertionFailedError)
       end
     end
+    
+    describe "#assert_number_of_children" do
+      before do
+        @element_locator = "id=foobar"
+        @evaled_js = "this.page().findElement('#{@element_locator}').childNodes.length"
+      end
+      
+      it "passes when element is present and it contains the correct number of (direct) children" do
+        stub(driver).is_element_present(@element_locator) {true}
+        stub(driver).get_eval(@evaled_js) { 3 }
+        element.assert_number_of_children(3)
+      end
+
+      it "fails when element is present and it contains the wrong number of (direct) children" do
+        stub(driver).is_element_present(@element_locator) {true}
+        stub(driver).get_eval(@evaled_js) { 999 }
+        proc do
+          element.assert_number_of_children(3)
+        end.should raise_error(Test::Unit::AssertionFailedError)
+      end
+
+      it "fails when element is not present" do
+        stub(driver).is_element_present(@element_locator) {false}
+        proc do
+          element.assert_number_of_children 3
+        end.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
 
     describe "#method_missing" do
       it "delegates command to the driver" do
-        element.methods.should_not include('click')
-        mock(driver).click(@element_locator)
-        element.click
+        element.methods.should_not include('foobar')
+        mock(driver).foobar(@element_locator)
+        element.foobar
       end
     end
   end

data/spec/polonium/server_runners/external_server_runner_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+module Polonium
+  module ServerRunners
+    describe ExternalServerRunner do
+      attr_reader :configuration, :rails_env, :rails_root, :runner, :start_server_cmd, :stop_server_cmd
+      before do
+        @configuration = Configuration.new
+        @rails_env = configuration.rails_env = 'test'
+        @rails_root = configuration.rails_root = File.dirname(__FILE__)
+        @start_server_cmd = "cd #{rails_root}; script/server -e #{rails_env} -p #{configuration.internal_app_server_port} -c #{rails_root}"
+        @stop_server_cmd = "ps ax | grep 'script/server -e #{rails_env}' | sed /grep/d | awk '{print $1}' | xargs kill -9 2>/dev/null"
+
+        @runner = ExternalServerRunner.new(configuration)
+      end
+
+      describe "#start" do
+        it "stops the server, then starts an external rails server" do
+          mock(runner).system(stop_server_cmd).ordered
+          mock(runner).system(start_server_cmd).ordered
+          runner.start
+        end
+      end
+
+      describe "#stop" do
+        it "stops the server" do
+          mock(runner).system(stop_server_cmd).ordered
+          runner.stop
+        end
+      end
+    end
+  end
+end

data/spec/polonium/server_runners/mongrel_server_runner_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+module Polonium
+  module ServerRunners
+    describe MongrelServerRunner do
+      describe "#start_server" do
+        attr_reader :configuration
+        before do
+          @configuration = Configuration.new
+        end
+
+        it "initializes server and runs app_server_initialization callback" do
+          runner = MongrelServerRunner.new(configuration)
+
+          fake_rails = "fake rails"
+          mongrel_configurator = nil
+          mock.proxy(runner).create_mongrel_configurator do |mongrel_configurator|
+            mongrel_configurator = mongrel_configurator
+            stub(configuration).create_mongrel_configurator {mongrel_configurator}
+            mock(mongrel_configurator).run
+            stub(mongrel_configurator).log
+            mock(mongrel_configurator).join
+            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)
+            mongrel_configurator
+          end
+
+          callback_mongrel = nil
+          configuration.app_server_initialization = proc do |mongrel|
+            callback_mongrel = mongrel
+          end
+          stub(runner).defaults do
+            ; {:environment => ""};
+          end
+          mock(Thread).start.yields
+
+          runner.start
+          callback_mongrel.should == mongrel_configurator
+        end
+
+        describe "#create_mongrel_configurator" do
+          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__)
+
+            runner = MongrelServerRunner.new(configuration)
+            configurator = runner.send(: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
+      end
+    end
+  end
+end

data/spec/polonium/server_runners/server_runner_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+module Polonium
+  module ServerRunners
+    describe ServerRunner do
+      before(:each) do
+        @runner = ServerRunner.new(Configuration.new)
+        class << @runner
+          public :start_server, :stop_server
+        end
+      end
+
+      it "should initialize started? to be false" do
+        @runner.started?.should ==  false
+      end
+
+      it "start method should start new thread and set started" do
+        mock(@runner).start_server
+        stub(@runner).stop_server
+        @runner.start
+      end
+
+      it "stop method should set started? to false" do
+        def @runner.stop_server;
+        end
+        @runner.instance_eval {@started = true}
+        @runner.stop
+        @runner.started?.should ==  false
+      end
+
+      it "start_server method should raise a NotImplementedError by default" do
+        proc {@runner.start_server}.should raise_error(NotImplementedError)
+      end
+    end
+  end
+end

data/spec/polonium/server_runners/webrick_server_runner_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+module Polonium
+  module ServerRunners
+    describe WebrickServerRunner do
+      attr_reader :configuration, :mock_server
+      before(:each) do
+        Object.const_set(:RAILS_ROOT, "foobar")
+      end
+
+      after(:each) do
+        Object.instance_eval {remove_const :RAILS_ROOT}
+      end
+
+      it "start method should initialize the HttpServer with parameters" do
+        runner = create_runner_that_is_stubbed_so_start_method_works
+        runner.start
+      end
+
+      it "start method should mount and start the server" do
+        runner = create_runner_that_is_stubbed_so_start_method_works
+        runner.start
+      end
+
+      it "start method should require environment when rails_root is not set" do
+        runner = create_runner_that_is_stubbed_so_start_method_works
+        requires = []
+        stub(runner).require {|val| requires << val}
+
+        runner.start
+        requires.any? {|r| r =~ /\/config\/environment/}.should == true
+      end
+
+      it "start method should trap server.shutdown" do
+        runner = create_runner_that_is_stubbed_so_start_method_works
+
+        (
+        class << runner;
+          self;
+        end).class_eval {attr_reader :trap_signal_name}
+        def runner.trap(signal_name, &block)
+          @trap_signal_name = signal_name
+          block.call
+        end
+        mock(mock_server).shutdown
+
+        runner.start
+        runner.trap_signal_name.should == "INT"
+      end
+
+      it "should shutdown webrick server" do
+        runner = create_runner_that_is_stubbed_so_start_method_works
+        runner.start
+        mock(mock_server).shutdown
+        runner.stop
+      end
+
+      def create_runner_that_is_stubbed_so_start_method_works
+        configuration = Polonium::Configuration.new
+        runner = WebrickServerRunner.new(configuration)
+        class << runner;
+          public :start_server;
+        end
+
+        stub(runner).require
+
+        configuration.internal_app_server_port = 4000
+        configuration.internal_app_server_host = "localhost"
+        configuration.rails_env = "test"
+
+        @mock_server = "mock_server"
+        stub(WEBrick::HTTPServer).new {mock_server}
+
+        stub(mock_server).mount('/')
+        mock(mock_server) do |s|
+          s.mount(
+            '/',
+              DispatchServlet,
+              {
+                :port            => configuration.internal_app_server_port,
+                :ip              => configuration.internal_app_server_host,
+                :environment     => configuration.rails_env,
+                :server_root     => File.expand_path("#{configuration.rails_root}/public/"),
+                :server_type     => WEBrick::SimpleServer,
+                :charset         => "UTF-8",
+                :mime_types      => WEBrick::HTTPUtils::DefaultMimeTypes,
+                :working_directory => File.expand_path(configuration.rails_root.to_s)
+              }
+          )
+          s.start
+        end
+
+        mock(Thread).start.yields
+
+        return runner
+      end
+
+      describe "#create_webrick_server" do
+        it "creates webrick http server" do
+          configuration = Polonium::Configuration.new
+          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 => []
+          })
+          runner = WebrickServerRunner.new(configuration)
+          server = runner.send(:create_webrick_server)
+        end
+      end
+
+    end
+  end
+end