stella 0.8.8.001 → 2.0.1.001

data/lib/stella/client.rb

@@ -1,444 +1,508 @@
-require "observer"
-require "nokogiri"
-require 'pp'
+
+require 'base64'
+require 'addressable/uri'
 
 Stella::Utils.require_vendor "httpclient", '2.1.5.2'
 
-module Stella
+require 'pp'
+
+class Stella
+  
   class Client
-    MAX_REDIRECTS = 5.freeze unless defined?(MAX_REDIRECTS)
-    
-    require 'stella/client/container'
+    unless defined?(SSL_CERT_PATH)
+      SSL_CERT_PATH = File.join(STELLA_LIB_HOME, '..', 'certs', 'stella-master.crt').freeze
+    end
     
     include Gibbler::Complex
-    include Observable
+    include HTTPClient::Timeout
     
     attr_reader :index
     attr_accessor :base_uri
     attr_accessor :proxy
     attr_accessor :created 
+    attr_reader :clientid
+    
+    gibbler :index, :opts, :base_uri, :proxy, :created
     
-    gibbler :opts, :index, :base_uri, :proxy, :nowait, :created
     @@client_index = 0
-    def initialize(base_uri=nil, opts={})
+    
+    # Options:
+    # 
+    # * :timeout (Integer) => 30
+    # * :ssl_verify_mode (Class) => nil (possible values: OpenSSL::SSL::VERIFY_NONE)
+    #
+    def initialize(opts={})
       @index = @@client_index += 1
-      @created = Time.now.to_f
-      opts = {
-        :nowait => false,
-        :withparam => false,
-        :withheader => false,
-        :notemplates => false,
-        :wait => 0, 
-        :timeout => nil
-      }.merge! opts
+      @created = Stella.now
       @opts = opts
-      @base_uri, @index = base_uri, index
-      #@cookie_file = File.new("cookies-#{index}", 'w')
+      @opts[:timeout] ||= 30
+      @base_uri, @index = opts[:base_uri] || opts['base_uri'], index
       @proxy = OpenStruct.new
+      @done = false
+      @session = Session.new @base_uri
+      @redirect_count = 0
+      @clientid = [@session.object_id, created, index, opts].digest
     end
-    def id
-      @id || self.digest
-    end
-    def execute(usecase, &stat_collector)
-#      Gibbler.enable_debug
-      # We need to make sure the digest cache has a value
-      @id = self.digest if self.digest_cache.nil?
-      Gibbler.disable_debug
-      http_client = create_http_client
-      stats = {}
-      container = Container.new(self.id, usecase)
-      counter = 0
-      usecase.requests.each do |req|
-        counter += 1
-        
-        container.reset_temp_vars
-        
-        stats ||= Benelux::Stats.new
-        update(:prepare_request, usecase, req, counter)
-        
-        begin
-          # This is for the values that were "set"
-          # in the part before the response body.
-          prepare_resources(container, req.resources)
+    
+    def exception 
+      @session.exception
+    end
+    
+    def execute usecase, &each_request
+      @session.http_client = create_http_client
+      tt = Benelux.current_track.timeline
+      usecase.requests.each_with_index do |rt,idx|
+        begin 
+          debug "request start (session: #{@session.object_id})"
+          @session.prepare_request usecase, rt 
           
-          params = prepare_params(container, req.params)
-          headers = prepare_headers(container, req.headers)
+          debug "#{@session.http_method} #{@session.uri} (#{rt.id.short})"
+          debug " #{@session.params.inspect}" unless @session.params.empty?
+          debug " #{@session.headers.inspect}" unless @session.headers.empty?
           
-          container.params, container.headers = params, headers
+          stella_id = [clientid, rt.id, @session.uri.to_s, @session.params, @session.headers, idx].digest
           
-          uri = build_request_uri req.uri, params, container
-
-          if http_auth = req.http_auth || usecase.http_auth
-            # TODO: The first arg is domain and can include a URI path. 
-            #       Are there cases where this is important?
-            
-            domain = http_auth.domain
-            # When req.uri is a fully qualified URI, domain will be
-            # set to an incorrect value like, http://domain1/http://domain2. 
-            # So we parse it and if that fails we'll set it to the value given.
-            uri_tmp = URI.parse(req.uri).uri rescue req.uri
-            domain ||= '%s://%s:%d%s' % [uri.scheme, uri.host, uri.port, '/'] 
-            domain = container.instance_eval &domain if Proc === domain
-            Stella.ld "DOMAIN " << domain
-            user, pass = http_auth.user, http_auth.pass
-            user = container.instance_eval &user if Proc === user
-            pass = container.instance_eval &pass if Proc === pass
-            update(:authenticate, usecase, req, domain, user, pass)
-            http_client.set_auth(domain, user, pass)
-          end
+          Benelux.current_track.add_tags :request   => rt.id
+          Benelux.current_track.add_tags :stella_id => stella_id
           
-          if tout = req.timeout || usecase.timeout || @opts[:timeout]
-            http_client.receive_timeout = tout if tout > 0
-          end
-          Stella.ld "TIMEOUT " << http_client.receive_timeout.to_s
+          ## Useful for testing larger large request header
+          ## 50.times do |idx|
+          ##   headers["X-header-#{idx}"] = (1000 << 1000).to_s
+          ## end
           
-          raise NoHostDefined, req.uri if uri.host.nil? || uri.host.empty?
-          stella_id = [Time.now.to_f, self.id, req.id, params, headers, counter].digest
-        
-          Benelux.add_thread_tags :request => req.id
-          Benelux.add_thread_tags :retry => counter
-          Benelux.add_thread_tags :stella_id => stella_id
+          # Mis-behaving HTTP servers will fail w/o an Accept header
+          @session.headers["Accept"] ||= '*/*'
           
-          container.unique_id = stella_id
+          # if hard_timeout is nil this will do nothing
+          timeout(@opts[:hard_timeout], TimeoutError) do
+            @session.generate_request stella_id
+          end
+          res = @session.res
           
-          params['__stella'] = container.unique_id.short if @opts[:'withparam']
-          headers['X-Stella-ID'] = container.unique_id.short if @opts[:'withheader']
+          each_request.call(@session) unless each_request.nil?
           
-          meth = req.http_method.to_s.downcase
-          Stella.ld "#{req.http_method}: " << "#{req.uri} " << params.inspect
-        
-          ret, asset_duration = nil, 0
-        rescue => ex
-          update(:request_unhandled_exception, usecase, uri, req, params, ex)
-          Benelux.remove_thread_tags :status, :retry, :request, :stella_id
-          break
-        end
-        
-        
-        
-        begin
+          # Needs to happen before handle response incase it raises an exception
+          log = Stella::Log::HTTP.new Stella.now,  
+                   @session.http_method, @session.uri, @session.params, res.request.header.dump, 
+                   res.request.body.content, res.status, res.header.dump, res.body.content
           
-          send_request http_client, usecase, meth, uri, req, params, headers, container, counter
+          tt.add_count :requests, 1, :kind => :http
           
-          update(:receive_response, usecase, uri, req, params, headers, counter, container)
+          run_sleeper @opts[:wait]
           
-          Benelux.add_thread_tags :status => container.status
-          res = container.response
-          [
-            [:request_header_size, res.request.header.dump.size],
-            [:request_content_size, res.request.body.content.size],
-            [:response_headers_size, res.header.dump.size],
-            [:response_content_size, res.body.content.size]
-          ].each do |att|
-            Benelux.thread_timeline.add_count att[0], att[1]
+          if @session.response_handler?
+            @session.handle_response
+          elsif res.status >= 400
+            raise Stella::HTTPError.new(res.status)
+          elsif rt.follow && @session.redirect?
+            raise ForcedRedirect, @session.location
           end
+
+          tt.add_message log, :status => res.status, :kind => :http_log, :state => :nominal
           
+          @redirect_count = 0
           
-          ret = execute_response_handler container, req
+        rescue RepeatRequest => ex
+          debug " REPEAT REQUEST: #{@session.location}"
+          retry
           
-          asset_start = Time.now
-          container.assets.each do |uri|
-            Benelux.add_thread_tags :asset => uri
-            a = http_client.get uri
-            Stella.stdout.info3 "   FETCH ASSET: #{uri} #{a.status}"
-            Benelux.remove_thread_tags :asset
+        rescue ForcedRedirect => ex  
+          # TODO: warn when redirecting from https to http
+          debug " FOUND REDIRECT: #{@session.location}"
+          if @redirect_count < 10
+            @redirect_count += 1
+            @session.clear_previous_request
+            @session.redirect_uri = ex.location
+            retry
           end
-          asset_duration = Time.now - asset_start
-        rescue HTTPClient::ConnectTimeoutError, HTTPClient::SendTimeoutError,
-               Errno::ECONNRESET, HTTPClient::ReceiveTimeoutError => ex
-          update(:request_timeout, usecase, uri, req, params, headers, counter, container, http_client.receive_timeout)
-          Benelux.remove_thread_tags :status, :retry, :request, :stella_id
-          next
-        rescue => ex
-          update(:request_unhandled_exception, usecase, uri, req, params, ex)
-          Benelux.remove_thread_tags :status, :retry, :request, :stella_id
-          next
-        end
         
-        if (req.wait.is_a?(::Range) && req.wait.last > 0) ||
-           (Numeric === req.wait && req.wait > 0)
-          wait = req.wait
-        else
-          wait = @opts[:wait]
-        end
-         
-        run_sleeper(wait, asset_duration) unless nowait?
-
-        
-        # TODO: consider throw/catch
-        case ret.class.to_s
-        when "Stella::Client::Repeat"
-          update(:request_repeat, counter, ret.times+1, uri, container)
-          Benelux.remove_thread_tags :status
-          redo if counter <= ret.times
-        when "Stella::Client::Follow"
-          ret.uri ||= container.header['Location'].first
-          if counter > MAX_REDIRECTS
-            update(:max_redirects, counter-1, ret, uri, container)
-            break
-          else
-            req = ret.generate_request(req)
-            update(:follow_redirect, ret, uri, container)
-            Benelux.remove_thread_tags :status, :request
-            redo
+        rescue Errno::ETIMEDOUT, SocketError, 
+               HTTPClient::ConnectTimeoutError, 
+               HTTPClient::SendTimeoutError,
+               HTTPClient::ReceiveTimeoutError,
+               TimeoutError,
+               Errno::ECONNRESET => ex
+          debug "[#{ex.class}] #{ex.message}"
+          log = Stella::Log::HTTP.new Stella.now, @session.http_method, @session.uri, @session.params
+          if @session.res 
+            log.request_headers = @session.res.request.header.dump if @session.res.request 
+            log.request_body = @session.res.request.body.content if @session.res.request 
+            log.response_status = @session.res.status
+            log.response_headers = @session.res.header.dump if @session.res.content
+            log.response_body = @session.res.body.content if @session.res.body
           end
-        when "Stella::Client::Quit"
-          update(:usecase_quit, ret.message, uri, container)
-          Benelux.remove_thread_tags :status
+          log.msg = "#{ex.class} (#{@session.http_client.receive_timeout})"
+          tt.add_message log, :kind => :http_log, :state => :timeout
+          Benelux.current_track.remove_tags :status, :request, :stella_id
+          next
+          
+        rescue StellaError, StellaBehavior => ex
+          debug "[#{ex.class}] #{ex.message}"
+          log = Stella::Log::HTTP.new Stella.now, @session.http_method, @session.uri, @session.params
+          if @session.res 
+            log.request_headers = @session.res.request.header.dump if @session.res.request 
+            log.request_body = @session.res.request.body.content if @session.res.request 
+            log.response_status = @session.res.status
+            log.response_headers = @session.res.header.dump if @session.res.content
+            log.response_body = @session.res.body.content if @session.res.body
+          end
+          log.msg = ex.message
+          tt.add_message log, :status => log.response_status, :kind => :http_log, :state => :exception
+          Benelux.current_track.remove_tags :status, :request, :stella_id
+          @session.exception = ex
           break
-        when "Stella::Client::Fail"  
-          update(:request_fail, ret.message, uri, container)
-        when "Stella::Client::Error"  
-          update(:request_error, ret.message, uri, container)
-        end
         
-        Benelux.remove_thread_tags :status
+        rescue Errno::ECONNREFUSED => ex
+          debug "[#{ex.class}] #{ex.message}"
+          log = Stella::Log::HTTP.new Stella.now, @session.http_method, @session.uri, @session.params
+          log.msg = "Connection refused"
+          tt.add_message log, :status => log.response_status, :kind => :http_log, :state => :exception
+          Benelux.current_track.remove_tags :status, :request, :stella_id
+          break
         
-        counter = 0 # reset
+        rescue OpenSSL::SSL::SSLError => ex
+          debug "[#{ex.class}] #{ex.message}"
+          log = Stella::Log::HTTP.new Stella.now, @session.http_method, @session.uri, @session.params
+          log.msg = ex.message
+          tt.add_message log, :status => log.response_status, :kind => :http_log, :state => :exception
+          Benelux.current_track.remove_tags :status, :request, :stella_id
+          break
+          
+        rescue => ex
+          Stella.le "[#{ex.class}] #{ex.message}", ex.backtrace
+          log = Stella::Log::HTTP.new Stella.now, @session.http_method, @session.uri, @session.params
+          log.msg = ex.message
+          tt.add_message log, :status => log.response_status, :kind => :http_log, :state => :fubar
+          Benelux.current_track.remove_tags :status, :request, :stella_id
+          break
+          
+        end
       end
-      Benelux.remove_thread_tags :retry, :request, :stella_id
-      stats
-    end
-    
-    def enable_nowait_mode; @opts[:'nowait'] = true; end
-    def disable_nowait_mode; @opts[:'nowait'] = false; end
-    def nowait?; @opts[:'nowait'] == true; end
       
-  private
-    # We use a method so we can time it with Benelux
-    def send_request(http_client, usecase, meth, uri, req, params, headers, container, counter)
-      if meth == "delete"
-        args = [meth, uri, headers]
-      else
-        args = [meth, uri, params, headers]
-      end
-      container.response = http_client.send(*args) # booya!
     end
     
-    def update(kind, *args)
-      changed and notify_observers(kind, self.id, *args)
+    def run_sleeper dur
+      return unless dur && dur > 0
+      dur = (rand * (dur.last-dur.first) + dur.first) if Range === dur
+      debug "sleep: #{dur}"
+      sleep dur
     end
-  
-    def run_sleeper(wait, already_waited=0)
-      return if (wait.is_a?(::Range) && wait.last == 0) || wait == 0
-      # The time it took to download the assets can
-      # be removed from the specified wait time.
-      if wait.is_a?(::Range)
-        ms = rand(wait.last * 1000).to_f 
-        ms = wait.first if ms < wait.first
-      else
-        ms = wait * 1000
-      end
-      Stella.stdout.info3 "   WAIT: #{ms}ms"
-      sec = ms / 1000
-      Stella.ld "WAIT ADJUSTED FROM %.1f TO: %.1f" % [sec, (sec - already_waited)]
-      sleep (sec - already_waited) if (sec - already_waited) > 0
+    
+    def debug(msg)
+      Stella.ld " #{clientid.short} #{msg}"
     end
     
     def create_http_client
-      opts = {
-        :proxy       => @proxy.uri || nil, # a tautology for clarity
-        :agent_name  => Stella.agent,
+      http_client = HTTPClient.new(
+        :agent_name  => @opts[:agent] || @opts['agent'] || Stella.agent,
         :from        => nil
-      }
-      http_client = HTTPClient.new opts
-      http_client.set_proxy_auth(@proxy.user, @proxy.pass) if @proxy.user
-      http_client.debug_dev = STDOUT if Stella.debug? && Stella.stdout.lev >= 3
+      )
+      #http_client.set_proxy_auth(@proxy.user, @proxy.pass) if @proxy.user
+      #http_client.debug_dev = STDOUT if Stella.debug?
       http_client.protocol_version = "HTTP/1.1"
-      http_client.ssl_config.verify_mode = ::OpenSSL::SSL::VERIFY_NONE
+      if @opts[:ssl_verify_mode]
+        http_client.ssl_config.verify_mode = @opts[:ssl_verify_mode]
+      end
+      
+      # See: http://ghouston.blogspot.com/2006/03/using-ssl-with-ruby-http-access2.html
+      begin 
+        http_client.ssl_config.clear_cert_store
+        http_client.ssl_config.set_trust_ca SSL_CERT_PATH
+      rescue => ex
+        Stella.li ex.class, ex.message
+        Stella.ld ex.backtrace
+      end
+      
+      http_client.connect_timeout = @opts[:timeout]
+      http_client.send_timeout = @opts[:timeout]
+      http_client.receive_timeout = @opts[:timeout]
       http_client
     end
     
-    def prepare_resources(container, resources)
-      h = prepare_runtime_hash container, resources
-      # p [container.client_id.shorter, h]
-      container.resources.merge! h
+    def done!
+      @done = true
     end
     
-    # Process resource values from the request object
-    def prepare_runtime_hash(container, hashobj, &extra)
-      newh = {}
-      #Stella.ld "PREPARE HEADERS: #{headers}"
-      hashobj.each_pair do |n,v|
-        unless @opts[:'notemplates']
-          v = container.parse_template v
+    def done?
+      @done == true
+    end
+    
+  end
+  
+  class Session
+    attr_reader :events, :response_handler, :res, :req, :rt, :vars, :previous_doc, :http_auth
+    attr_accessor :headers, :params, :base_uri, :http_client, :uri, :redirect_uri, :http_method, :exception
+    def initialize(base_uri=nil)
+      @base_uri = base_uri
+      @vars = indifferent_hash
+      @base_uri &&= Addressable::URI.parse(@base_uri) if String === @base_uri
+      @events = SelectableArray.new
+    end
+    def current_event
+      @events.last
+    end
+    alias_method :param, :params
+    alias_method :header, :headers
+    def prepare_request uc, rt
+      clear_previous_request
+      @rt = rt
+      @vars.merge! uc.class.session || {}
+      registered_classes = []
+      if uc.class.testplan
+        @vars.merge! uc.class.testplan.class.session || {} 
+        registered_classes = uc.class.testplan.class.registered_classes || []
+      end
+      registered_classes.push *(uc.class.registered_classes || [])
+      registered_classes.each do |klass| 
+        self.extend klass unless self.kind_of?(klass)
+      end
+      @http_method, @params, @headers = rt.http_method, rt.params, rt.headers
+      @http_auth = uc.http_auth
+      instance_exec(&rt.callback) unless rt.callback.nil?
+      @uri = if @redirect_uri
+        @params = {}
+        @headers = {}
+        @http_method = :get
+        if @redirect_uri.scheme
+          tmp = [@redirect_uri.scheme, '://', @redirect_uri.host].join
+          tmp << ":#{@redirect_uri.port}" unless [80,443].member?(@redirect_uri.port)
+          @base_uri = Addressable::URI.parse(tmp)
         end
-        v = extra.call(v) unless extra.nil?
-        newh[n] = v
+        build_uri @redirect_uri
+      else
+        build_uri @rt.uri
       end
-      newh
+      if !http_auth.nil? && !http_auth.empty?
+        Stella.ld " HTTP AUTH: #{http_auth.inspect}"
+        http_auth[:domain] ||= '%s://%s:%d%s' % [base_uri.scheme, base_uri.host, base_uri.port, '/'] 
+        http_client.set_auth http_auth[:domain], http_auth[:user], http_auth[:pass]
+        Stella.ld "   #{http_client.www_auth.inspect}"
+      end
+      @redirect_uri = nil  # one time deal
     end
-    alias_method :prepare_headers, :prepare_runtime_hash
-    alias_method :prepare_params, :prepare_runtime_hash
-    
-    # Testplan URIs can be relative or absolute. Either one can
-    # contain variables in the form <tt>:varname</tt>, as in:
-    #
-    #     http://example.com/product/:productid
-    # 
-    # This method creates a new URI object using the @base_uri
-    # if necessary and replaces all variables with literal values.
-    # If no replacement value can be found, the variable will remain. 
-    def build_request_uri(uri, params, container)
-      raise "Request given with no URI" if uri.nil?
-      newuri = uri.clone  # don't modify uri template
-      # We call uri.clone b/c we modify uri. 
-      uri.scan(/([:\$])([a-z_]+)/i) do |inst|
-        val = find_replacement_value(inst[1], params, container, base_uri)
-        Stella.ld "FOUND VAR: #{inst[0]}#{inst[1]} (value: #{val})"
-        re = Regexp.new "\\#{inst[0]}#{inst[1]}"
-        newuri.gsub! re, val.to_s unless val.nil?
+    def generate_request(event_id)
+      @res = http_client.send(@http_method.to_s.downcase, @uri, params, headers)
+      @req = @res.request
+      @events << event_id
+      @res
+    end
+    def location
+      @location ||= Addressable::URI.parse(@res.header['location'].first || '')
+      @location
+    end
+    def redirect?
+      @res && (300..399).member?(@res.status)
+    end
+    def doc
+      return @doc unless @doc.nil?
+      return nil if @res.content.nil? || @res.content.empty?
+      str = RUBY_VERSION >= "1.9.0" ? @res.content.force_encoding("UTF-8") : @res.content
+      # NOTE: It's important to parse the document on every 
+      # request because this container is available for the
+      # entire life of a usecase. 
+      @doc = case (@res.header['Content-Type'] || []).first
+      when /text\/html/
+        Nokogiri::HTML(str)
+      when /text\/xml/
+        Nokogiri::XML(str)
+      when /text\/yaml/
+        YAML.load(str)
+      when /application\/json/
+        Yajl::Parser.parse(str)
       end
-
-      uri = URI.parse(newuri)
-      
-      if uri.host.nil? && base_uri.nil?
-        Stella.abort!
-        raise NoHostDefined, uri
+      @doc.replace indifferent_params(@doc) if Hash === @doc
+      @doc
+    end
+    def form
+      return @form unless @form.nil?
+      return nil if doc.nil?
+      return nil unless content_type?('text/html')
+      @form = indifferent_hash
+      forms = doc.css('form')
+      forms.each_with_index do |html,idx|
+        name = html['id'] || html['name'] || html['class']
+        Stella.ld [:form, idx, name].inspect
+        form = indifferent_hash
+        # Store form attributes in keys prefixed with an underscore.
+        html.each { |att,val| form["_#{att}"] = val }
+        # Store input name and values in the form hash.
+        html.css('input').each do |input|
+          form[input['name']] = input['value']
+        end
+        # Store the form by the name and index in the document
+        @form[name] = @form[idx] = form
       end
-      
-      base_uri = URI.parse(self.base_uri || '')
-      uri.scheme = base_uri.scheme if uri.scheme.nil?
-      uri.host = base_uri.host if uri.host.nil?
-      uri.port = base_uri.port if uri.port.nil?
-      uri.port = 443 if uri.port == 80 && uri.scheme == "https"
-      
-      # Support for specifying default path prefix:
-      # $ stella verify -p plan.rb http://localhost/basicauth
-      if URI::Generic === base_uri && base_uri.path && uri != base_uri
-        if uri.path.nil? || uri.path.empty?
-          begin
-            uri.path = base_uri.path
-          rescue => ex
-            Stella.stdout.info "#{ex.class}: #{self.base_uri}"
-            exit
-          end
-        else
-          a = base_uri.path.gsub(/\/$/, '')
-          b = uri.path.gsub(/^\//, '')
-          uri.path = [a,b].join('/')
+      @form
+    end
+    alias_method :forms, :form
+    def cookie
+      return @cookie unless @cookie.nil?
+      return nil unless http_client.cookie_manager
+      return nil if http_client.cookie_manager.cookies.empty?
+      @cookie = indifferent_hash
+      http_client.cookie_manager.cookies.each do |c|
+        next unless c.match?(uri)
+        @cookie[c.name] = c.value
+      end
+      @cookie
+    end
+    alias_method :cookies, :cookie
+    def content_type? guess
+      guess = Regexp.new guess unless Regexp === guess
+      guess.match((res.header['Content-Type'] || []).first)
+    end
+    def handle_response
+      return unless response_handler?
+      instance_exec(&find_response_handler(@res.status))
+      @previous_doc = doc
+    end
+    def find_response_handler(status)
+      return if response_handler.nil?
+      key = response_handler.keys.select { |range| range.member?(status) }.first
+      response_handler[key] if key
+    end
+    def response_handler?
+      status = (@res.status || 0).to_i
+      !find_response_handler(status).nil?
+    end
+    def response_handler(range=nil, &blk)
+      @response_handler ||= {}
+      return @response_handler if range.nil? && blk.nil?
+      range = 0..999 if range.nil? || range.zero?
+      range = range.to_i..range.to_i unless Range === range
+      @response_handler[range] = blk unless blk.nil?
+      @response_handler[range]
+    end
+    alias_method :handler, :response_handler
+    alias_method :response, :response_handler
+    alias_method :session, :vars
+    def clear_previous_request
+      [:doc, :location, :res, :req, :rt, :params, :headers, :cookie, :form, :response_handler, :http_method, :exception].each do |n|
+        instance_variable_set :"@#{n}", nil
+      end
+    end
+    def status
+      @res.status
+    end
+    
+    def wait(t); sleep t; end
+    def quit(msg=nil); raise TestplanQuit.new(msg); end
+    def fail(msg=nil); raise UsecaseFail.new(msg); end
+    def error(msg=nil); raise RequestError.new(msg); end
+    def repeat(t=1); raise RepeatRequest.new(t); end
+    def follow(uri=nil,&blk); raise ForcedRedirect.new(uri,&blk); end
+    
+    private 
+    def build_uri(reqtempl)
+      uri = reqtempl.clone # need to clone b/c we modify uri in scan.
+      reqtempl.to_s.scan(/([:\$])([a-z_]+)/i) do |inst|
+        val = find_replacement_value(inst[1])
+        Stella.ld " FOUND VAR: #{inst[0]}#{inst[1]} (value: #{val})"
+        if val.nil?
+          raise Stella::UsecaseError, "no value for #{inst[0]}#{inst[1]} in '#{@rt.uri}'"
         end
+        re = Regexp.new "\\#{inst[0]}#{inst[1]}"
+        uri.gsub! re, val.to_s unless val.nil?
+      end
+      uri = Stella.canonical_uri(uri)
+      if base_uri
+        uri.scheme = base_uri.scheme
+        uri.host = base_uri.host if uri.host.to_s.empty?
+        uri.port = base_uri.port if uri.port.to_s.empty?
       end
-      
       uri
     end
-    
     # Testplan URIs can contain variables in the form <tt>:varname</tt>. 
     # This method looks at the request parameters and then at the 
     # usecase's resource hash for a replacement value. 
     # If not found, returns nil. 
-    def find_replacement_value(name, params, container, base_uri)
-      value = nil
-      #Stella.ld "REPLACE: #{name}"
-      #Stella.ld "PARAMS: #{params.inspect}"
-      #Stella.ld "IVARS: #{container.instance_variables}"
-      if name.to_sym == :HOSTNAME && !base_uri.nil?
-        value = base_uri.host 
-      elsif params.has_key?(name.to_sym)
-        value = params.delete name.to_sym
-      elsif container.resource?( name)
-        value = container.resource name
+    def find_replacement_value(name)
+      if @params.has_key?(name.to_sym)
+        @params.delete name.to_sym
+      elsif vars.has_key?(name.to_s) || vars.has_key?(name.to_s.to_sym)
+        vars[name.to_s] || vars[name.to_s.to_sym]
       elsif Stella::Testplan.global?(name)
         Stella::Testplan.global(name)
       end
-      value
-    end 
+    end
+    def indifferent_params(params)
+      if params.is_a?(Hash)
+        params = indifferent_hash.merge(params)
+        params.each do |key, value|
+          next unless value.is_a?(Hash) || value.is_a?(Array)
+          params[key] = indifferent_params(value)
+        end
+      elsif params.is_a?(Array)
+        params.collect! do |value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            indifferent_params(value)
+          else
+            value
+          end
+        end
+      end
+    end
+
+    # Creates a Hash with indifferent access.
+    def indifferent_hash
+      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+    end
+  end
+  
+  module Asserts
+    def assert_doc
+      fail 'No content' if doc.nil?
+    end
     
-    # Find the appropriate response handler by executing the
-    # HTTP response status against the configured handlers. 
-    # If several match, the first one is returned.
-    def find_response_handler(container, req)
-      handler = nil
-      req.response.each_pair do |regex,h|
-        Stella.ld "HANDLER REGEX: #{regex.to_s} (#{container.status})"
-        regex = /#{regex}/ unless regex.is_a? Regexp
-        handler = h and break if container.status.to_s =~ regex
+    def assert_keys expected_keys 
+      assert_doc
+      found_keys = doc.keys.uniq.sort
+      unless found_keys == expected_keys
+        quit "Doc keys mismatch (#{found_keys})"
       end
-      handler
     end
     
+    def assert_list key
+      assert_doc
+      fail "#{key} is empty" if doc[key].nil? || doc[key].empty?
+    end
     
-    def execute_response_handler(container, req)
-      ret = nil
-      handler = find_response_handler container, req
-      if handler.nil?
-        if container.status >= 400
-          update(:request_fail, "No handler", req.uri, container) 
-        end
-        return
-      end
-      begin
-        ret = container.instance_eval &handler
-        update(:execute_response_handler, req, container)
-      rescue => ex
-        update(:error_execute_response_handler, ex, req, container)
-        Stella.ld ex.message, ex.backtrace
+    def assert_object_keys key, expected_keys
+      assert_doc
+      found_keys = doc[key].collect { |obj| obj.keys }.flatten.uniq.sort
+      unless found_keys == expected_keys
+        quit "Doc keys mismatch (#{found_keys})"
       end
-      ret
     end
     
-    class ResponseError < Stella::Error
-      def initialize(k, m=nil)
-        @kind, @msg = k, m
-      end
-      def message
-        msg = "#{@kind}"
-        msg << ": #{@msg}" unless @msg.nil?
-        msg
+    def assert_object_values key, object_key, expected_values
+      expected_values = [expected_values] unless Array === expected_values
+      expected_values = expected_values.collect { |v| v.to_s }.sort
+      values_found = doc[key].collect { |obj| obj[object_key].to_s }
+      values_found.sort!
+      unless values_found.uniq == expected_values
+        quit "#{key} contains unexpected values for #{object_key}: #{values_found.uniq}"
       end
     end
     
-  end
-end
-
-
-class Stella::Client
-  
-  class ResponseModifier
-    attr_accessor :obj
-    def initialize(obj=nil)
-      @obj = obj
-    end 
-    alias_method :message, :obj
-    alias_method :message=, :obj=
-  end
-  class Repeat < ResponseModifier; 
-    alias_method :times, :obj
-    alias_method :times=, :obj=
-  end
-  #
-  # Automatically follow a Location header or you 
-  # can optionally specify the URI to load. 
-  # 
-  #     get '/' do
-  #       response 302 do
-  #         follow do 
-  #           header :'X-SOME-HEADER' => 'somevalue'
-  #         end
-  #       end
-  #     end
-  #
-  # The block is optional and accepts the same syntax as regular requests.
-  #
-  class Follow < ResponseModifier; 
-    alias_method :uri, :obj
-    alias_method :uri=, :obj=
-    attr_reader :definition
-    def initialize(obj=nil,&definition)
-      @obj, @definition = obj, definition
-    end
-    def generate_request(req)
-      n = Stella::Data::HTTP::Request.new :GET, self.uri, req.http_version, &definition
-      n.description = "#{req.description || 'Request'} (autofollow)"
-      n.http_auth = req.http_auth
-      n.response_handler = req.response_handler
-      n.autofollow!
-      n.freeze
-      n
+    def assert_form name
+      assert_doc
+      fail "No form called #{name}" unless form && form[name]
+    end
+    def assert_exists v
+      fail "Found nil value" if v.nil?
+      fail "Found empty value" if v.empty?
+    end
+    def assert_equals expected, found
+      fail "Expected: #{expected}; Found: #{found}" unless expected == found
+    end
+    def assert_matches regex, found
+      fail "Expected: #{regex}; Found: #{found}" unless regex.match(found)
+    end
+    alias_method :assert_match, :assert_matches
+    def assert_status expected
+      fail "Expected: #{expected}; Found: #{res.status}" unless res.status.to_i == expected.to_i
     end
   end
-  class Quit < ResponseModifier; end
-  class Fail < Quit; end
-  class Error < Quit; end
   
 end