steam 0.0.2

data/lib/steam/connection/net_http.rb

@@ -0,0 +1,42 @@
+# This connection proxies requests using open-uri. 
+#
+
+require 'net/http'
+require 'uri'
+
+Net::HTTPResponse.class_eval do
+  attr_reader :code # crap
+end
+
+module Steam
+  module Connection
+    class NetHttp
+      def call(env)
+        request  = Rack::Request.new(env)
+        response = send(request.request_method.downcase, request)
+        response = follow_redirect(response) if response.status.to_s[0, 1] == '3'
+        response.to_a
+      end
+      
+      def get(request)
+        url      = URI.parse(request.url)
+        response = Net::HTTP.start(url.host, url.port) { |http| http.get(url.path) }
+        Rack::Response.new(response.body, response.code, response.to_hash)
+      end
+      
+      def post(request)
+        url      = URI.parse(request.url)
+        params   = Rack::Utils.parse_query(Rack::Utils.build_nested_query(request.params))
+        response = Net::HTTP.post_form(url, params)
+        Rack::Response.new(response.body, response.code, response.to_hash)
+      end
+      
+      def follow_redirect(response)
+        location = response.headers['location'].join
+        env      = Steam::Request.env_for(location)
+        request  = Rack::Request.new(env)
+        get(request)
+      end
+    end
+  end
+end

data/lib/steam/connection/open_uri.rb

@@ -0,0 +1,24 @@
+# This connection proxies requests using open-uri. 
+#
+
+require 'open-uri'
+
+module Steam
+  module Connection
+    class OpenUri
+      def call(env)
+        request = Rack::Request.new(env)
+        Rack::Response.new(*open(request.url)).to_a
+      end
+      
+      def open(uri)
+        headers = {}
+        body = Kernel.open(uri) { |f| headers = f.meta; f.read }
+        [body, 200, headers]
+      rescue OpenURI::HTTPError => e
+        status = e.message.split(' ').first
+        ['', status, headers]
+      end
+    end
+  end
+end

data/lib/steam/connection/rails.rb

@@ -0,0 +1,20 @@
+module Steam
+  module Connection
+    class Rails
+      def initialize
+        @app = ActionController::Dispatcher.new
+      end
+      
+      def call(env)
+        status, headers, response = @app.call(env)
+        Rack::Response.new(response_body(response), status, headers).to_a
+      end
+      
+      def response_body(response)
+        body = ''
+        response.each { |part| body << part } # yuck
+        body
+      end
+    end
+  end
+end

data/lib/steam/connection/static.rb

@@ -0,0 +1,33 @@
+require 'rack/response'
+
+module Steam
+  module Connection
+    class Static < Rack::Static
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options[:urls] ||= %w(/images /javascripts /stylesheets)
+        app = args.pop
+        super(app || lambda { response_404 }, options)
+      end
+
+      def call(env)
+        status, headers, response = super
+
+        response = case response
+        when Rack::File
+          Rack::Response.new(::File.read(response.path), status, headers).to_a
+        when Array
+          Rack::Response.new(response.first, status, headers).to_a
+        else
+          [status, headers, response]
+        end
+
+        response
+      end
+
+      def response_404
+        Rack::Response.new('', 404).to_a
+      end
+    end
+  end
+end

data/lib/steam/java.rb

@@ -0,0 +1,74 @@
+require 'rjb'
+require 'core_ext/ruby/string/camelize'
+require 'core_ext/ruby/string/underscore'
+
+module Steam
+  module Java
+
+    # TODO replace this with http://github.com/sklemm/jrequire/blob/master/lib/java.rb
+
+    module AutoDefine
+      def const_set_nested(full_name, const)
+        name = pop_name(full_name)
+        if full_name.empty? && !const_defined?(name)
+          const_set(name, const)
+        else
+          const_set(name, Module.new { extend AutoDefine }) unless const_defined?(name)
+          const_get(name).const_set_nested(full_name, const) unless full_name.empty?
+        end
+      end
+
+      def pop_name(string)
+        name, *rest = string.split('::')
+        string.replace(rest.join('::'))
+        name
+      end
+    end
+    extend AutoDefine
+
+    class << self
+      def const_missing(name)
+        return init && const_get(name) unless @initialized
+        super
+      end
+
+      def import(signature, name = nil)
+        init unless @initialized
+        name = path_to_const_name(signature)
+        const_set_nested(name, Rjb::import(signature))
+      end
+
+      def path_to_const_name(path)
+        path.split('.').map { |token| token.underscore.camelize }.join('::').gsub('Java::', '')
+      end
+
+      def init
+        @initialized = true
+
+        import('java.net.URL')
+        import('java.lang.System')
+        import('java.util.Arrays')
+        import('java.util.ArrayList')
+        import('java.util.logging.Logger')
+        import('java.util.logging.Level')
+      end
+
+      def load_from(path)
+        paths = Dir["#{Steam.config[:html_unit][:java_path]}/*.jar"]
+        load(paths.join(':')) unless paths.empty?
+      end
+
+      def load(paths)
+        Rjb::load(paths, Steam.config[:java_load_params].to_a)
+      end
+
+      def logger(classifier)
+        Java::Util::Logging::Logger.getLogger(classifier)
+      end
+
+      def log_level(name)
+        Java::Util::Logging::Level.send(name.to_s.upcase)
+      end
+    end
+  end
+end

data/lib/steam/process.rb

@@ -0,0 +1,53 @@
+module Steam
+  class Process
+    attr_reader :pid, :path
+
+    def initialize(path = '/tmp')
+      @path = path
+      recall_pid
+    end
+
+    def pid?
+      !!pid
+    end
+
+    def running?
+      pid? && !!::Process.getpgid(pid)
+    rescue Errno::ESRCH
+      false
+    end
+
+    def fork(options)
+      @pid = Kernel.fork { yield }
+      write_pid
+      # Process.detach(pid) ?
+      at_exit { kill } unless options[:keep_alive]
+    end
+
+    def kill(signal = 'TERM')
+      ::Process.kill(Signal.list[signal], pid)
+      delete_pid
+      true
+    end
+
+    protected
+
+      def recall_pid
+        @pid = ::File.read(filename).to_i rescue nil
+        delete_pid if pid? && !running?
+      end
+
+      def write_pid
+        File.open(filename, 'w') { |f| f.write(pid) }
+      end
+
+      def delete_pid
+        File.delete(filename) rescue Errno::ENOENT
+        @pid = nil
+      end
+
+      def filename
+        "#{path}/steam.pid"
+      end
+  end
+end

data/lib/steam/request.rb

@@ -0,0 +1,49 @@
+# Extends a Rack::Request with convenience methods
+
+require 'uri'
+
+module Steam
+  class Request < Rack::Request
+    attr_accessor :method, :headers
+
+    DEFAULT_ENV = {
+      "rack.version"      => [0, 1],
+      "rack.input"        => StringIO.new,
+      "rack.errors"       => StringIO.new,
+      "rack.multithread"  => true,
+      "rack.multiprocess" => true,
+      "rack.run_once"     => false,
+    }
+
+    class << self
+      def env_for(uri = '', opts = {})
+        env   = DEFAULT_ENV.dup
+        uri   = URI.parse(uri)
+        input = opts[:input] || ''
+
+        env.merge!(
+          'REQUEST_METHOD'   => opts[:method] || 'GET',
+          'SERVER_NAME'      => Steam.config[:server_name],
+          'SERVER_PORT'      => Steam.config[:server_port],
+          'QUERY_STRING'     => uri.query.to_s,
+          'PATH_INFO'        => (!uri.path || uri.path.empty?) ? '/' : uri.path,
+          'rack.url_scheme'  => Steam.config[:url_scheme],
+          'SCRIPT_NAME'      => opts[:script_name] || '',
+          'rack.errors'      => StringIO.new,
+          'rack.input'       => input.is_a?(String) ? StringIO.new(input) : input,
+          'CONTENT_LENGTH'   => env['rack.input'].length.to_s,
+          'rack.test.scheme' => uri.scheme || 'http',
+          'rack.test.host'   => uri.host   || 'www.example.com',
+          'rack.test.port'   => uri.port,
+          'rack.test.cache_classes' => true
+        )
+        env
+      end
+    end
+
+    def initialize(method, uri, opts = {})
+      env = self.class.env_for(uri, opts.merge(:method => method))
+      super(env)
+    end
+  end
+end

data/lib/steam/response.rb

@@ -0,0 +1,13 @@
+# Not sure about this. The only reason why this class is needed is that 
+# Rack::Response#body returns an Array of body parts while in Rails integration
+# tests response.body returns a String.
+
+require 'uri'
+
+module Steam
+  class Response < Rack::Response
+    def body
+      super.join
+    end
+  end
+end

data/lib/steam/session.rb

@@ -0,0 +1,30 @@
+# Conceptually a session is something different than a browser. E.g. a (test-)
+# session can be started (setting up test data etc.) and stopped (cleaning
+# stuff up etc.). Webrat and Capybara don't separate these concepts. So let's
+# keep them separate though from the beginning even though we don't implement
+# any such behavior so far.
+
+module Steam
+  class Session
+    autoload :Rails, 'steam/session/rails'
+
+    attr_accessor :browser
+
+    def initialize(browser = nil)
+      @browser = browser
+    end
+
+    def respond_to?(method)
+      browser.respond_to?(method) ? true : super
+    end
+
+    def method_missing(method, *args, &block)
+      return browser.send(method, *args, &block) # if browser.respond_to?(method)
+      super
+    end
+
+    def select(*args, &block) # because Class implements #select
+      browser.select(*args, &block)
+    end
+  end
+end

data/lib/steam/session/rails.rb

@@ -0,0 +1,33 @@
+module Steam
+  class Session
+    class Rails < Session
+      include ActionController
+
+      def initialize(browser = nil)
+        super
+
+        # install the named routes in this session instance.
+        klass = class << self; self; end
+        ActionController::Routing::Routes.install_helpers(klass)
+        klass.module_eval { public *Routing::Routes.named_routes.helpers }
+      end
+
+      # FIXME we only have access to the controller when Steam can run HtmlUnit
+      # and the app in one stack
+      def controller
+      end
+      
+      def url_for(options) 
+        controller ? controller.url_for(options) : generic_url_rewriter.rewrite(options)
+      end
+      
+      protected
+
+        # FIXME remove ActionController::Request dependency
+        def generic_url_rewriter 
+          env = Request.env_for(Steam.config[:request_url])
+          UrlRewriter.new(ActionController::Request.new(env), {})
+        end
+    end
+  end
+end

data/lib/steam/version.rb

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

data/test/all.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/**/*_test.rb'].each do |filename|
+  require filename unless filename.include?('_locator')
+end

data/test/browser/html_unit/actions_test.rb

@@ -0,0 +1,183 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'fixtures/html_fakes'
+
+class HtmlUnitActionsTest < 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]))
+  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'
+      @browser.click_on('link')
+    end
+  end
+
+  test "click_on clicks a button" do 
+    perform :get, 'http://localhost:3000/', html(:fields => :text)
+    
+    assert_response_contains('FORM') do
+      @app.mock :get, 'http://localhost:3000/form?field=', 'FORM'
+      @browser.click_on(:button, 'button')
+    end
+  end
+  
+  test "click_link clicks a link" do 
+    perform :get, 'http://localhost:3000/', html
+  
+    assert_response_contains('LINK') do
+      @app.mock :get, 'http://localhost:3000/link', 'LINK'
+      @browser.click_link('link')
+    end
+  end
+  
+  test "click_button clicks a button" do
+    perform :get, 'http://localhost:3000/', html(:fields => :text)
+  
+    assert_response_contains('FORM') do
+      @app.mock :get, 'http://localhost:3000/form?field=', 'FORM'
+      @browser.click_button('button')
+    end
+  end
+  
+  test "fill_in fills in a text input" do
+    perform :get, 'http://localhost:3000/', html(:fields => :text)
+  
+    assert_response_contains('FIELD') do
+      @app.mock :get, 'http://localhost:3000/form?field=text', 'FIELD'
+      @browser.fill_in('field', :with => 'text')
+      @browser.click_button('button')
+    end
+  end
+  
+  test "fill_in fills in a textarea" do
+    perform :get, 'http://localhost:3000/', html(:fields => :textarea)
+  
+    assert_response_contains('TEXTAREA') do
+      @app.mock :get, 'http://localhost:3000/form?textarea=text', 'TEXTAREA'
+      @browser.fill_in('textarea', :with => 'text')
+      @browser.click_button('button')
+    end
+  end
+  
+  test "check checks a checkbox" do
+    perform :get, 'http://localhost:3000/', html(:fields => :checkbox)
+  
+    assert_response_contains('CHECKED') do
+      @app.mock :get, 'http://localhost:3000/form?checkbox=1', 'CHECKED'
+      @browser.check('checkbox')
+      @browser.click_button('button')
+    end
+  end
+  
+  test "uncheck unchecks a checkbox" do
+    perform :get, 'http://localhost:3000/', html(:fields => :checkbox)
+  
+    assert_response_contains('FORM') do
+      @app.mock :get, 'http://localhost:3000/form', 'FORM'
+      @browser.check('checkbox')
+      @browser.uncheck('checkbox')
+      @browser.click_button('button')
+    end
+  end
+  
+  test "choose activates a radio button" do
+    perform :get, 'http://localhost:3000/', html(:fields => :radio)
+  
+    assert_response_contains('RADIO') do
+      @app.mock :get, 'http://localhost:3000/form?radio=radio', 'RADIO'
+      @browser.choose('radio')
+      @browser.click_button('button')
+    end
+  end
+  
+  test "select selects an option from a select box" do
+    perform :get, 'http://localhost:3000/', html(:fields => :select)
+  
+    assert_response_contains('SELECT') do
+      @app.mock :get, 'http://localhost:3000/form?select=foo', 'SELECT'
+      @browser.select('foo', :from => 'select')
+      @browser.click_button('button')
+    end
+  end
+  
+  test "set_hidden_field sets a value to a hidden field" do
+    perform :get, 'http://localhost:3000/', html(:fields => :hidden)
+  
+    assert_response_contains('SELECT') do
+      @app.mock :get, 'http://localhost:3000/form?hidden=foo', 'SELECT'
+      @browser.set_hidden_field('hidden', :to => 'foo')
+      @browser.click_button('button')
+    end
+  end
+  
+  test "attach_file sets a filename to a file field" do
+    perform :get, 'http://localhost:3000/', html(:fields => :file)
+  
+    assert_response_contains('FILE') do
+      @app.mock :get, 'http://localhost:3000/form?file=rails.png', 'FILE'
+      @browser.attach_file('file', "#{TEST_ROOT}/fixtures/rails.png")
+      @browser.click_button('button')
+    end
+  end
+  
+  test "submit_form submits a form" do
+    perform :get, 'http://localhost:3000/', html(:fields => :text)
+  
+    assert_response_contains('FORM') do
+      @app.mock :get, 'http://localhost:3000/form?field=', 'FORM'
+      @browser.submit_form('form')
+    end
+  end
+  
+  test "drag drags an draggable and drop drops the draggable onto a droppable" do
+    perform :get, 'http://localhost:3000/', html(:scripts => [:jquery, :jquery_ui, :drag])
+  
+    @browser.drag('link')
+    @browser.drop('form')
+    assert_equal 'DROPPED!', @browser.page.getTitleText
+  end
+  
+  test "drag_and_drop drags a draggable and drops it onto a droppable" do
+    perform :get, 'http://localhost:3000/', html(:scripts => [:jquery, :jquery_ui, :drag])
+  
+    @browser.drag_and_drop('link', :to => 'form')
+    assert_equal 'DROPPED!', @browser.page.getTitleText
+  end
+  
+  test "hover triggers a mouseOver event on an element" do
+    perform :get, 'http://localhost:3000/', html(:scripts => [:jquery, :jquery_ui, :hover])
+  
+    @browser.hover('paragraph')
+    assert_equal 'HOVERED!', @browser.page.getTitleText
+  end
+  
+  test "focus triggers a focus event on an element" do
+    perform :get, 'http://localhost:3000/', html(:fields => :text, :scripts => [:jquery, :jquery_ui, :focus])
+  
+    @browser.focus('field')
+    assert_equal 'FOCUSED!', @browser.page.getTitleText
+  end
+  
+  test "blur triggers a blur event on an element" do
+    perform :get, 'http://localhost:3000/', html(:fields => :text, :scripts => [:jquery, :jquery_ui, :blur])
+  
+    @browser.focus('field')
+    @browser.blur('field')
+    assert_equal 'BLURRED!', @browser.page.getTitleText
+  end
+  
+  test "double_click doubleclicks an element" do
+    perform :get, 'http://localhost:3000/', html(:scripts => [:jquery, :jquery_ui, :double_click])
+  
+    @browser.double_click('paragraph')
+    assert_equal 'DOUBLE CLICKED!', @browser.page.getTitleText
+  end
+  
+end