steam 0.0.2 → 0.0.3

data/README.textile

@@ -89,3 +89,10 @@ h2. Developers
 
 * "Sven Fuchs":http://github.com/svenfuchs
 * "Clemens Kofler"::http://github.com/clemens
+
+
+TODO
+
+* explain requirement to start/restart a test server
+* explain log levels
+

data/lib/steam.rb

@@ -9,6 +9,12 @@ module Steam
   autoload :Response,   'steam/response'
   autoload :Session,    'steam/session'
 
+  class ElementNotFound < StandardError
+    def initialize(*args)
+      super "could not find element: #{args.map { |arg| arg.inspect }.join(', ') }"
+    end
+  end
+
   class << self
     def config
       @@config ||= {
@@ -33,11 +39,26 @@ module Steam
         }
       }
     end
-  end
 
-  class ElementNotFound < StandardError
-    def initialize(*args)
-      super "could not find element: #{args.map { |arg| arg.inspect }.join(', ') }"
+    def save_and_open(url, response)
+      filename = "/tmp/steam/#{url.gsub(/[^\w\-\/]/, '_')}.html"
+      body = rewrite_assets(url, response.body)
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, "w") { |f| f.write body }
+      open_in_browser(filename)
+    end
+
+    def open_in_browser(filename)
+      require "launchy"
+      Launchy::Browser.run(filename)
+    rescue LoadError
+      warn "Sorry, you need to install launchy to open pages: `gem install launchy`"
+    end
+
+    def rewrite_assets(url, html)
+      url = url.gsub(URI.parse(url).path, '')
+      pattern = %r(<script [^>]*src=['"]+([^'"]*)|<link[^>]* href=['"]?([^'"]+))
+      html.gsub(pattern) { |path| path.gsub($1 || $2, "#{url}#{$1 || $2}") }
     end
   end
 end

data/lib/steam/browser.rb

@@ -2,17 +2,18 @@
 # Webdriver might be an interesting alternative.
 
 require 'core_ext/ruby/string/camelize'
+require 'locator'
 
 module Steam
   module Browser
     autoload :HtmlUnit, 'steam/browser/html_unit'
-    
+
     class << self
       def create(*args)
         options    = args.last.is_a?(Hash) ? args.pop : {}
         type       = args.shift if args.first.is_a?(Symbol)
         connection = args.pop
-        
+
         type ||= :html_unit
         type = const_get(type.to_s.camelize)
         type = type.const_get('Drb') if options[:daemon]

data/lib/steam/browser/html_unit.rb

@@ -17,27 +17,31 @@ module Steam
       autoload :Page,        'steam/browser/html_unit/page'
       autoload :WebResponse, 'steam/browser/html_unit/web_response'
 
-      include Actions # Matchers
+      include Actions
 
-      attr_accessor :client, :page, :connection, :request, :response
+      attr_accessor :client, :page, :request, :response
 
       def initialize(*args)
         @client = Client.new(*args)
       end
 
+      def connection
+        client.connection
+      end
+
       def close
         @client.closeAllWindows
       end
 
-      def request(url)
+      def get(url)
         call Request.env_for(url)
       end
-      alias :visit :request
+      alias :visit :get
 
       def call(env)
         respond_to do
           @request = Rack::Request.new(env)
-          client.request(@request.url)
+          client.get(@request.url)
         end.to_a
       end
 
@@ -60,7 +64,7 @@ module Steam
       end
 
       def within(*args, &block)
-        Locator.within(*args, &block)
+        Locator.within(response.body, *args, &block)
       end
 
       protected

data/lib/steam/browser/html_unit/actions.rb

@@ -59,7 +59,10 @@ module Steam
         
         # TODO implement a way to supply content_type
         def attach_file(element, path, options = {})
-          fill_in(element, options.merge(:with => path))
+          respond_to do
+            element = locate_in_browser(:file, element, options)
+            element.setValueAttribute(path)
+          end
         end
         
         def submit_form(element, options = {})

data/lib/steam/browser/html_unit/client.rb

@@ -19,7 +19,10 @@ module Steam
           def notify(message, origin); end
         end
 
+        attr_reader :connection
+
         def initialize(connection = nil, options = {})
+          @connection = connection
           options = Steam.config[:html_unit].merge(options)
 
           @java = WebClient.new(BrowserVersion.send(options[:browser_version]))
@@ -46,7 +49,7 @@ module Steam
           end
         end
 
-        def request(*args)
+        def get(*args)
           @java.getPage(*args) # TODO use WebRequestSettings
         end
 

data/lib/steam/session.rb

@@ -8,6 +8,10 @@ module Steam
   class Session
     autoload :Rails, 'steam/session/rails'
 
+    include Locator::Matcher
+    include Test::Unit::Assertions if defined?(Test::Unit)
+    # TODO include Rspec::Something if defined?(Rspec)
+
     attr_accessor :browser
 
     def initialize(browser = nil)

data/lib/steam/version.rb

@@ -1,3 +1,3 @@
 module Steam
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/test/browser/html_unit/actions_test.rb

@@ -5,16 +5,16 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
   include Steam, HtmlFakes
 
   def setup
-    @app = Steam::Connection::Mock.new
+    mock = Steam::Connection::Mock.new
     static = Steam::Connection::Static.new(:root => FIXTURES_PATH)
-    @browser = Steam::Browser::HtmlUnit.new(Rack::Cascade.new([static, @app]))
+    @browser = Steam::Browser::HtmlUnit.new(Rack::Cascade.new([static, mock]))
   end
 
   test "click_on clicks on an element" do
     perform :get, 'http://localhost:3000/', html
   
     assert_response_contains('LINK') do
-      @app.mock :get, 'http://localhost:3000/link', 'LINK'
+      mock :get, 'http://localhost:3000/link', 'LINK'
       @browser.click_on('link')
     end
   end
@@ -23,7 +23,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :text)
     
     assert_response_contains('FORM') do
-      @app.mock :get, 'http://localhost:3000/form?field=', 'FORM'
+      mock :get, 'http://localhost:3000/form?field=', 'FORM'
       @browser.click_on(:button, 'button')
     end
   end
@@ -32,7 +32,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html
   
     assert_response_contains('LINK') do
-      @app.mock :get, 'http://localhost:3000/link', 'LINK'
+      mock :get, 'http://localhost:3000/link', 'LINK'
       @browser.click_link('link')
     end
   end
@@ -41,7 +41,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :text)
   
     assert_response_contains('FORM') do
-      @app.mock :get, 'http://localhost:3000/form?field=', 'FORM'
+      mock :get, 'http://localhost:3000/form?field=', 'FORM'
       @browser.click_button('button')
     end
   end
@@ -50,7 +50,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :text)
   
     assert_response_contains('FIELD') do
-      @app.mock :get, 'http://localhost:3000/form?field=text', 'FIELD'
+      mock :get, 'http://localhost:3000/form?field=text', 'FIELD'
       @browser.fill_in('field', :with => 'text')
       @browser.click_button('button')
     end
@@ -60,7 +60,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :textarea)
   
     assert_response_contains('TEXTAREA') do
-      @app.mock :get, 'http://localhost:3000/form?textarea=text', 'TEXTAREA'
+      mock :get, 'http://localhost:3000/form?textarea=text', 'TEXTAREA'
       @browser.fill_in('textarea', :with => 'text')
       @browser.click_button('button')
     end
@@ -70,7 +70,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :checkbox)
   
     assert_response_contains('CHECKED') do
-      @app.mock :get, 'http://localhost:3000/form?checkbox=1', 'CHECKED'
+      mock :get, 'http://localhost:3000/form?checkbox=1', 'CHECKED'
       @browser.check('checkbox')
       @browser.click_button('button')
     end
@@ -80,7 +80,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :checkbox)
   
     assert_response_contains('FORM') do
-      @app.mock :get, 'http://localhost:3000/form', 'FORM'
+      mock :get, 'http://localhost:3000/form', 'FORM'
       @browser.check('checkbox')
       @browser.uncheck('checkbox')
       @browser.click_button('button')
@@ -91,7 +91,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :radio)
   
     assert_response_contains('RADIO') do
-      @app.mock :get, 'http://localhost:3000/form?radio=radio', 'RADIO'
+      mock :get, 'http://localhost:3000/form?radio=radio', 'RADIO'
       @browser.choose('radio')
       @browser.click_button('button')
     end
@@ -101,7 +101,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :select)
   
     assert_response_contains('SELECT') do
-      @app.mock :get, 'http://localhost:3000/form?select=foo', 'SELECT'
+      mock :get, 'http://localhost:3000/form?select=foo', 'SELECT'
       @browser.select('foo', :from => 'select')
       @browser.click_button('button')
     end
@@ -111,7 +111,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :hidden)
   
     assert_response_contains('SELECT') do
-      @app.mock :get, 'http://localhost:3000/form?hidden=foo', 'SELECT'
+      mock :get, 'http://localhost:3000/form?hidden=foo', 'SELECT'
       @browser.set_hidden_field('hidden', :to => 'foo')
       @browser.click_button('button')
     end
@@ -121,7 +121,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :file)
   
     assert_response_contains('FILE') do
-      @app.mock :get, 'http://localhost:3000/form?file=rails.png', 'FILE'
+      mock :get, 'http://localhost:3000/form?file=rails.png', 'FILE'
       @browser.attach_file('file', "#{TEST_ROOT}/fixtures/rails.png")
       @browser.click_button('button')
     end
@@ -131,7 +131,7 @@ class HtmlUnitActionsTest < Test::Unit::TestCase
     perform :get, 'http://localhost:3000/', html(:fields => :text)
   
     assert_response_contains('FORM') do
-      @app.mock :get, 'http://localhost:3000/form?field=', 'FORM'
+      mock :get, 'http://localhost:3000/form?field=', 'FORM'
       @browser.submit_form('form')
     end
   end

data/test/browser/html_unit/javascript_test.rb

@@ -5,9 +5,9 @@ class HtmlUnitJavascriptTest < Test::Unit::TestCase
   include Steam, HtmlFakes
 
   def setup
-    @app = Steam::Connection::Mock.new
+    @connection = Steam::Connection::Mock.new
     static = Steam::Connection::Static.new(:root => FIXTURES_PATH)
-    @browser = Steam::Browser::HtmlUnit.new(Rack::Cascade.new([static, @app]))
+    @browser = Steam::Browser::HtmlUnit.new(Rack::Cascade.new([static, @connection]))
   end
 
   test "jquery: div:not([id]) selector" do

data/test/browser/html_unit/rails_actions_test.rb

@@ -5,13 +5,12 @@ class HtmlUnitRailsActionsTest < Test::Unit::TestCase
   include Steam, HtmlFakes
 
   def setup
-    @app = Steam::Connection::Mock.new
-    static = Steam::Connection::Static.new(:root => FIXTURES_PATH)
-    @browser = Steam::Browser::HtmlUnit.new(Rack::Cascade.new([static, @app]))
+    connection = Steam::Connection::Mock.new
+    @browser = Steam::Browser::HtmlUnit.new(connection)
 
-    @app.mock :get, "http://localhost:3000/form?event_date(1i)=2009&event_date(2i)=11&event_date(3i)=7", 'DATE'
-    @app.mock :get, "http://localhost:3000/form?event_datetime(1i)=2009&event_datetime(2i)=11&event_datetime(3i)=7&event_datetime(4i)=19&event_datetime(5i)=0", 'DATETIME'
-    @app.mock :get, "http://localhost:3000/form?event_time(4i)=19&event_time(5i)=0", 'TIME'
+    mock :get, "http://localhost:3000/form?event_date(1i)=2009&event_date(2i)=11&event_date(3i)=7", 'DATE'
+    mock :get, "http://localhost:3000/form?event_datetime(1i)=2009&event_datetime(2i)=11&event_datetime(3i)=7&event_datetime(4i)=19&event_datetime(5i)=0", 'DATETIME'
+    mock :get, "http://localhost:3000/form?event_time(4i)=19&event_time(5i)=0", 'TIME'
   end
 
   def test_select_date

data/test/browser/html_unit_test.rb

@@ -3,61 +3,62 @@ require 'fixtures/html_fakes'
 require 'locator'
 
 module HtmlUnitTests
+  include Steam
+
   def init
-    @app = Steam::Connection::Mock.new
-    static = Steam::Connection::Static.new(:root => FIXTURES_PATH)
-    @browser = Steam::Browser::HtmlUnit.new(Rack::Cascade.new([static, @app]))
+    @connection = Connection::Mock.new
+    @browser = Browser::HtmlUnit.new(@connection)
     perform(:get, 'http://localhost:3000/', '<div id="foo"><div id="bar"><a id="buz" href="">bar!</a></div></div>')
   end
-  
+
   def locate(*args, &block)
     @browser.locate(*args, &block)
   end
-  
+
   def within(*args, &block)
     @browser.within(*args, &block)
   end
-  
+
   test 'locate with node type' do
     element = locate(:a)
     assert_equal 'a', element.name
   end
-  
+
   test 'locate with attributes' do
     element = locate(:id => 'buz')
     assert_equal 'a', element.name
   end
-  
+
   test 'locate with search text' do
     element = locate(:a, 'bar!')
     assert_equal 'a', element.name
   end
-  
+
   test 'locate with xpath' do
     element = locate(:xpath => '//div/div/a')
     assert_equal 'a', element.name
   end
-  
+
   test 'locate with css' do
     element = locate(:css => '#foo #bar a')
     assert_equal 'a', element.name
   end
-  
+
   test 'within with node type' do
     element = within(:div) { within(:div) { locate(:a) } }
     assert_equal 'a', element.name
   end
-  
+
   test 'within with attributes' do
     element = within(:id => 'foo') { within(:id => 'bar') { locate(:a) } }
     assert_equal 'a', element.name
   end
-  
+
   test 'within with xpath' do
     element = within('//div/div') { locate(:a) }
     assert_equal 'a', element.name
   end
-  
+
   test 'within with css' do
     element = within('#foo #bar') { locate(:a) }
     assert_equal 'a', element.name
@@ -82,16 +83,16 @@ class HtmlUnitWithNokogiriAdapterTest < Test::Unit::TestCase
   end
 end
 
-class HtmlUnitWithHtmlUnitAdapterTest < Test::Unit::TestCase
-  include Steam, HtmlUnitTests
-
-  def setup
-    @old_adapter, Locator::Dom.adapter = Locator::Dom.adapter, Locator::Dom::Htmlunit
-    init
-  end
-  
-  def teardown
-    Locator::Dom.adapter = @old_adapter
-  end
-end
+# class HtmlUnitWithHtmlUnitAdapterTest < Test::Unit::TestCase
+#   include Steam, HtmlUnitTests
+#
+#   def setup
+#     @old_adapter, Locator::Dom.adapter = Locator::Dom.adapter, Locator::Dom::Htmlunit
+#     init
+#   end
+#
+#   def teardown
+#     Locator::Dom.adapter = @old_adapter
+#   end
+# end
 

data/test/example/webrat_compat_steps_test.rb

@@ -0,0 +1,307 @@
+require File.expand_path('../../test_helper', __FILE__)
+# $: << File.expand_path("../../../lib", __FILE__)
+
+require 'cucumber'
+require 'steam'
+
+module PathTo
+  def path_to(page_name)
+    "http://localhost:3000/#{page_name}"
+  end
+end
+include PathTo
+
+connection = Steam::Connection::Mock.new
+$browser = Steam::Browser.create(connection)
+
+$step_mother = Cucumber::StepMother.new
+$step_mother.log = Logger.new(File.open('/dev/null', 'w'))
+steps_file = File.expand_path('../../../example/cucumber/webrat_compatible_steps.rb', __FILE__)
+$step_mother.load_code_file(steps_file)
+
+ruby = $step_mother.load_programming_language('rb')
+ruby.build_rb_world_factory([PathTo], lambda { Steam::Session.new($browser) })
+ruby.send(:create_world)
+ruby.send(:extend_world)
+
+class WebratCompatStepsTest < Test::Unit::TestCase
+  def setup
+    @browser = $browser
+  end
+  
+  def invoke(step)
+    $step_mother.invoke(step)
+  end
+  
+  def response
+    $browser.response
+  end
+  
+  def title
+    $browser.page.getTitleText
+  end
+  
+  def locate(*args)
+    $browser.locate(*args)
+  end
+
+  test 'I go to page' do
+    mock :get, path_to('foo'), 'FOO'
+    invoke 'I go to foo'
+    assert_match 'FOO', response.body
+  end
+
+  test 'I press "button"' do
+    perform :get, path_to('foo'), %(<input type="button" id="button" onclick="document.title='OK'">)
+    invoke 'I press "button"'
+    assert_match 'OK', title
+  end
+
+  test 'I click on "button"' do
+    perform :get, path_to('foo'), %(<input type="button" id="button" onclick="document.title='OK'">)
+    invoke 'I click on "button"'
+    assert_match 'OK', title
+  end
+
+  test 'I follow "link"' do
+    perform :get, path_to('foo'), %(<a href="javascript:document.title='OK'">link</a>)
+    invoke 'I follow "link"'
+    assert_match 'OK', title
+  end
+
+  test 'I follow "link" within "foo"' do
+    perform :get, path_to('foo'), %(<a>link</a><div id="foo"><a href="javascript:document.title='OK'">link</a></div>)
+    invoke 'I follow "link" within "#foo"'
+    assert_match 'OK', title
+  end
+
+  test 'I fill in "foo" with "OK"' do
+    perform :get, path_to('foo'), %(<input type="text" name="foo" value="bar">)
+    invoke 'I fill in "foo" with "OK"'
+    assert_match 'OK', locate(:input).attribute('value')
+  end
+
+  test 'I fill in "foo" for "OK"' do
+    perform :get, path_to('foo'), %(<input type="text" name="foo" value="bar">)
+    invoke 'I fill in "OK" for "foo"'
+    assert_match 'OK', locate(:input).attribute('value')
+  end
+
+  # TODO
+  # When /^(?:|I )fill in the following:$/ do |fields|
+  #   fields.rows_hash.each do |name, value|
+  #     When %{I fill in "#{name}" with "#{value}"}
+  #   end
+  # end
+
+  test 'I select "OK" from "foo"' do
+    perform :get, path_to('foo'), %(<select name="foo"><option>bar</option><option>OK</option></select>)
+    invoke 'I select "OK" from "foo"'
+    assert_equal 'OK', locate(:select).value
+  end
+
+  # TODO
+  # # When I select "December 25, 2008 10:00" as the date and time
+  # When /^(?:|I )select "([^\"]*)" as the date and time$/ do |time|
+  #   select_datetime(time)
+  # end
+  #
+  # When /^(?:|I )select "([^\"]*)" as the "([^\"]*)" date and time$/ do |datetime, select|
+  #   select_datetime(datetime, :from => select)
+  # end
+  # 
+  # # Note: Rail's default time helper provides 24-hour time-- not 12 hour time. Webrat
+  # # will convert the 2:20PM to 14:20 and then select it.
+  # When /^(?:|I )select "([^\"]*)" as the time$/ do |time|
+  #   select_time(time)
+  # end
+  # 
+  # # When I select "7:30AM" as the "Gym" time
+  # When /^(?:|I )select "([^\"]*)" as the "([^\"]*)" time$/ do |time, time_label|
+  #   select_time(time, :from => time_label)
+  # end
+  # 
+  # # When I select "February 20, 1981" as the date
+  # When /^(?:|I )select "([^\"]*)" as the date$/ do |date|
+  #   # reformat_date!(date)
+  #   select_date(date)
+  # end
+  # 
+  # # When I select "April 26, 1982" as the "Date of Birth" date
+  # When /^(?:|I )select "([^\"]*)" as the "([^\"]*)" date$/ do |date, date_label|
+  #   # reformat_date!(date)
+  #   select_date(date, :from => date_label)
+  # end
+
+  test 'I check "foo"' do
+    perform :get, path_to('foo'), %(<input type="checkbox" name="foo">)
+    invoke 'I check "foo"'
+    assert_equal 'checked', locate(:input, :type => 'checkbox').checked
+  end
+
+  test 'I uncheck "foo"' do
+    perform :get, path_to('foo'), %(<input type="checkbox" name="foo" checked="checked">)
+    invoke 'I uncheck "foo"'
+    assert_nil locate(:check_box).checked
+  end
+
+  test 'I choose "foo"' do
+    perform :get, path_to('foo'), %(<input type="radio" name="foo">)
+    invoke 'I choose "foo"'
+    assert_equal 'checked', locate(:radio_button).checked
+  end
+
+  test 'I attach the file at "path" to "foo"' do
+    perform :get, path_to('foo'), %(<input type="file" name="foo">)
+    invoke 'I attach the file at "path" to "foo"'
+    assert_equal 'path', locate(:file).value
+  end
+  
+  # I should see
+  
+  test 'I should see "foo" (passes)' do
+    perform :get, path_to('foo'), %(foo)
+    assert_passes { invoke 'I should see "foo"' }
+  end
+
+  test 'I should see "foo" (fails)' do
+    perform :get, path_to('foo'), %(bar)
+    assert_fails { invoke 'I should see "foo"' }
+  end
+  
+  test 'I should see /foo/ (passes)' do
+    perform :get, path_to('foo'), %(foo)
+    assert_passes { invoke 'I should see /foo/' }
+  end
+
+  test 'I should see /foo/ (fails)' do
+    perform :get, path_to('foo'), %(bar)
+    assert_fails { invoke 'I should see /foo/' }
+  end
+  
+  # I should not see
+  
+  test 'I should not see "foo" (passes)' do
+    perform :get, path_to('foo'), %(bar)
+    assert_passes { invoke 'I should not see "foo"' }
+  end
+
+  test 'I should not see "foo" (fails)' do
+    perform :get, path_to('foo'), %(foo)
+    assert_fails { invoke 'I should not see "foo"' }
+  end
+  
+  test 'I should not see /foo/ (passes)' do
+    perform :get, path_to('foo'), %(bar)
+    assert_passes { invoke 'I should not see /foo/' }
+  end
+
+  test 'I should not see /foo/ (fails)' do
+    perform :get, path_to('foo'), %(foo)
+    assert_fails { invoke 'I should not see /foo/' }
+  end
+  
+  # I should see within
+  
+  test 'I should see "bar" within "foo" (passes)' do
+    perform :get, path_to('foo'), %(<div id="foo"><span>bar</span></div>)
+    assert_passes { invoke 'I should see "bar" within "#foo"' }
+  end
+  
+  test 'I should see "bar" within "foo" (fails)' do
+    perform :get, path_to('foo'), %(<div id="foo"></div><span>bar</span>)
+    assert_fails { invoke 'I should see "bar" within "#foo"' }
+  end
+  
+  test 'I should see /bar/ within "foo" (passes)' do
+    perform :get, path_to('foo'), %(<div id="foo"><span>foobar</span></div>)
+    assert_passes { invoke 'I should see /bar/ within "#foo"' }
+  end
+  
+  test 'I should see /bar/ within "foo" (fails)' do
+    perform :get, path_to('foo'), %(<div id="foo"></div><span>foobar</span>)
+    assert_fails { invoke 'I should see /bar/ within "#foo"' }
+  end
+  
+  # I should not see within
+  
+  test 'I should not see "bar" within "foo" (passes)' do
+    perform :get, path_to('foo'), %(<div id="foo"></div><span>bar</span>)
+    assert_passes { invoke 'I should not see "bar" within "#foo"' }
+  end
+  
+  test 'I should not see "bar" within "foo" (fails)' do
+    perform :get, path_to('foo'), %(<div id="foo"><span>bar</span></div>)
+    assert_fails { invoke 'I should not see "bar" within "#foo"' }
+  end
+  
+  test 'I should not see /bar/ within "foo" (passes)' do
+    perform :get, path_to('foo'), %(<div id="foo"></div><span>bar</span>)
+    assert_passes { invoke 'I should not see /bar/ within "#foo"' }
+  end
+  
+  test 'I should not see /bar/ within "foo" (fails)' do
+    perform :get, path_to('foo'), %(<div id="foo"><span>foobar</span></div>)
+    assert_fails { invoke 'I should not see /bar/ within "#foo"' }
+  end
+  
+  # field should contain
+  
+  test 'the "foo" field should contain "bar" (passes)' do
+    perform :get, path_to('foo'), %(<input type="text" name="foo" value="bar">)
+    assert_passes { invoke 'the "foo" field should contain "bar"' }
+  end
+  
+  test 'the "foo" field should contain "bar" (fails)' do
+    perform :get, path_to('foo'), %(<input type="text" name="foo" value="foo">)
+    assert_fails { invoke 'the "foo" field should contain "bar"' }
+  end
+  
+  # field should not contain
+  
+  test 'the "foo" field should not contain "bar" (passes)' do
+    perform :get, path_to('foo'), %(<input type="text" name="foo" value="foo">)
+    assert_passes { invoke 'the "foo" field should not contain "bar"' }
+  end
+  
+  test 'the "foo" field should not contain "bar" (fails)' do
+    perform :get, path_to('foo'), %(<input type="text" name="foo" value="bar">)
+    assert_fails { invoke 'the "foo" field should not contain "bar"' }
+  end
+  
+  # checkbox should be checked
+  
+  test 'the "foo" checkbox should be checked (passes)' do
+    perform :get, path_to('foo'), %(<input type="checkbox" name="foo" checked="checked">)
+    assert_passes { invoke 'the "foo" checkbox should be checked' }
+  end
+  
+  test 'the "foo" checkbox should be checked (fails)' do
+    perform :get, path_to('foo'), %(<input type="checkbox" name="foo">)
+    assert_fails { invoke 'the "foo" checkbox should be checked' }
+  end
+  
+  # checkbox should not be checked
+  
+  test 'the "foo" checkbox should not be checked (passes)' do
+    perform :get, path_to('foo'), %(<input type="checkbox" name="foo">)
+    assert_passes { invoke 'the "foo" checkbox should not be checked' }
+  end
+  
+  test 'the "foo" checkbox should not be checked (fails)' do
+    perform :get, path_to('foo'), %(<input type="checkbox" name="foo" checked="checked">)
+    assert_fails { invoke 'the "foo" checkbox should not be checked' }
+  end
+  
+  # I should be on
+  
+  test 'I should be on foo (passes)' do
+    perform :get, path_to('foo'), ''
+    assert_passes { invoke 'I should be on foo' }
+  end
+  
+  test 'I should be on foo (fails)' do
+    perform :get, path_to('bar'), ''
+    assert_fails { invoke 'I should be on foo' }
+  end
+end

data/test/playground/dragdrop_behavior.rb

@@ -6,10 +6,10 @@ include Steam
 
 Steam.config[:html_unit][:java_path] = File.expand_path("../../lib/htmlunit-2.7/", __FILE__)
 
-@app = Connection::Mock.new
+@connection = Connection::Mock.new
 root = File.expand_path("../fixtures/public", __FILE__)
 static = Connection::Static.new(:root => root, :urls => %w(/ /javascripts /stylesheets))
-@browser = Browser::HtmlUnit.new(Rack::Cascade.new([static, @app]))
+@browser = Browser::HtmlUnit.new(Rack::Cascade.new([static, @connection]))
 
 def drag_to(target)
   @browser.page.executeJavaScript('$("#log").text("")')

data/test/playground/drb.rb

@@ -37,14 +37,14 @@ connection = nil
 url = 'http://localhost:3000'
 
 def request_without_drb(browser, url)
-  browser.request(url)
+  browser.get(url)
   browser.response
 end
 
 def request_with_drb(browser, url)
   DRb.start_service(Steam.config[:drb_uri], browser)
   drb = DRbObject.new(nil, Steam.config[:drb_uri])
-  drb.request(url)
+  drb.get(url)
   drb.response
 end
 

data/test/playground/thread_problem.rb

@@ -52,6 +52,6 @@ puts page.getTitleText
 # browser = Browser::HtmlUnit.new(mock)
 # # client.setWebConnection(Rjb::bind(connection, 'com.gargoylesoftware.htmlunit.WebConnection'))
 # 
-# response = browser.request('http://localhost:3000/').last
+# response = browser.get('http://localhost:3000/').last
 # puts browser.page.asXml
 

data/test/process_test.rb

@@ -20,12 +20,12 @@ class ProcessTest < Test::Unit::TestCase
   end
 
   test "new instance recalls an existing pid" do
-    write_pid(1234)
-    assert_equal 1234, Process.new.pid
+    write_pid(::Process.pid)
+    assert_equal ::Process.pid, Process.new.pid
   end
 
   test "pid? returns true if pid was recalled" do
-    write_pid(1234)
+    write_pid(::Process.pid)
     assert_equal true, Process.new.pid?
   end
 

data/test/session_test.rb

@@ -1,15 +1,40 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+require File.expand_path('../test_helper', __FILE__)
 
 class SessionTest < Test::Unit::TestCase
   include Steam
 
   def setup
-    connection = Connection::Mock.new
-    browser = Browser::HtmlUnit.new(connection)
-    @session = Session.new(browser)
+    @browser = Browser::HtmlUnit.new(Connection::Mock.new)
+    @session = Session.new(@browser)
+
+    perform(:get, 'http://localhost:3000/', '<div id="foo"><div id="bar"><a id="buz" href="">bar!</a></div></div>')
+  end
+
+  test 'session responds to browser methods' do
+    assert @session.respond_to?(:response)
+  end
+
+  test 'assert_contain' do
+    @session.assert_contain(@session.response.body, 'bar!')
+  end
+
+  test 'assert_not_contain' do
+    @session.assert_not_contain(@session.response.body, 'bar!!')
+  end
+
+  test 'assert_have_tag' do
+    @session.assert_have_tag(@session.response.body, :a, 'bar!', :id => 'buz')
+  end
+
+  test 'assert_have_no_tag' do
+    @session.assert_have_no_tag(@session.response.body, :a, 'bar!', :class => 'buz')
+  end
+
+  test 'assert_have_xpath' do
+    @session.assert_have_xpath(@session.response.body, '//div/a[@id="buz"]')
   end
 
-  def test_session_responds_to_browser_methods
-    assert @session.respond_to?(:call)
+  test 'assert_have_no_xpath' do
+    @session.assert_have_no_xpath(@session.response.body, '//div/a[@class="buz"]')
   end
 end

data/test/test_helper.rb

@@ -42,8 +42,14 @@ end
 class Test::Unit::TestCase
   include TestMethod
 
+  def mock(method, url, response)
+    connection = @browser.connection
+    connection = connection.apps.last if connection.is_a?(Rack::Cascade)
+    connection.mock(method, url, response)
+  end
+
   def perform(method, url, response)
-    @app.mock(method, url, response)
+    mock(method, url, response)
     @status, @headers, @response = @browser.call(Steam::Request.env_for(url))
   end
 
@@ -53,4 +59,22 @@ class Test::Unit::TestCase
     assert_equal 200, response.status
     assert_match %r(<#{tag_name}>\s*#{text}\s*<\/#{tag_name}>), response.body
   end
+
+  def assert_passes
+    begin
+      yield
+    rescue Test::Unit::AssertionFailedError => e
+    ensure
+      assert_nil e
+    end
+  end
+
+  def assert_fails
+    begin
+      yield
+    rescue Test::Unit::AssertionFailedError => e
+    ensure
+      assert_not_nil e
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: steam
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-21 00:00:00 +01:00
+date: 2010-02-28 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,7 +61,6 @@ files:
 - lib/steam/browser/html_unit/client.rb
 - lib/steam/browser/html_unit/connection.rb
 - lib/steam/browser/html_unit/drb.rb
-- lib/steam/browser/html_unit/matchers.rb
 - lib/steam/browser/html_unit/page.rb
 - lib/steam/browser/html_unit/web_response.rb
 - lib/steam/connection.rb
@@ -115,6 +114,7 @@ test_files:
 - test/connection/mock_test.rb
 - test/connection/rails_test.rb
 - test/connection/static_test.rb
+- test/example/webrat_compat_steps_test.rb
 - test/fixtures/html_fakes.rb
 - test/java_test.rb
 - test/playground/connection.rb

data/lib/steam/browser/html_unit/matchers.rb

@@ -1,57 +0,0 @@
-# module Steam
-#   module HtmlUnit
-#     module Matchers
-#       class HasContent #:nodoc:
-#         def initialize(content)
-#           @content = content
-#         end
-# 
-#         def matches?(target)
-#           @target = target
-#           !!@target.locate_element(@content)
-#         end
-# 
-#         def failure_message
-#           "expected the following element's content to #{content_message}:\n#{squeeze_space(@target.page.body)}"
-#         end
-# 
-#         def negative_failure_message
-#           "expected the following element's content to not #{content_message}:\n#{squeeze_space(@target.page.body)}"
-#         end
-# 
-#         def squeeze_space(inner_text)
-#           (inner_text || '').gsub(/^\s*$/, "").squeeze("\n")
-#         end
-# 
-#         def content_message
-#           case @content
-#           when String
-#             "include \"#{@content}\""
-#           when Regexp
-#             "match #{@content.inspect}"
-#           end
-#         end
-#       end
-# 
-#       # Matches the contents of an HTML document with
-#       # whatever string is supplied
-#       def contain(content)
-#         HasContent.new(content)
-#       end
-# 
-#       # Asserts that the body of the response contain
-#       # the supplied string or regexp
-#       def assert_contain(content)
-#         hc = HasContent.new(content)
-#         assert hc.matches?(response.body), hc.failure_message
-#       end
-# 
-#       # Asserts that the body of the response
-#       # does not contain the supplied string or regepx
-#       def assert_not_contain(content)
-#         hc = HasContent.new(content)
-#         assert !hc.matches?(response.body), hc.negative_failure_message
-#       end
-#     end
-#   end
-# end