Class Stella::Session

# File lib/stella/client.rb, line 379
    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

# File lib/stella/client.rb, line 350
    def content_type? guess
      guess = Regexp.new guess unless Regexp === guess
      guess.match((res.header['Content-Type'] || []).first)
    end

# File lib/stella/client.rb, line 338
    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

# File lib/stella/client.rb, line 241
    def current_event
      @events.last
    end

# File lib/stella/client.rb, line 296
    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
      @doc.replace indifferent_params(@doc) if Hash === @doc
      @doc
    end

# File lib/stella/client.rb, line 391
    def error(msg=nil); raise RequestError.new(msg); end

# File lib/stella/client.rb, line 390
    def fail(msg=nil); raise UsecaseFail.new(msg); end

# File lib/stella/client.rb, line 359
    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

# File lib/stella/client.rb, line 393
    def follow(uri=nil,&blk); raise ForcedRedirect.new(uri,&blk); end

# File lib/stella/client.rb, line 316
    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
      @form
    end

# File lib/stella/client.rb, line 283
    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

# File lib/stella/client.rb, line 354
    def handle_response
      return unless response_handler?
      instance_exec(&find_response_handler(@res.status))
      @previous_doc = doc
    end

# File lib/stella/client.rb, line 289
    def location
      @location ||= Addressable::URI.parse(@res.header['location'].first || '')
      @location
    end

# File lib/stella/client.rb, line 246
    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
        build_uri @redirect_uri
      else
        build_uri @rt.uri
      end
      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

# File lib/stella/client.rb, line 389
    def quit(msg=nil); raise TestplanQuit.new(msg); end

# File lib/stella/client.rb, line 293
    def redirect?
      @res && (300..399).member?(@res.status)
    end

# File lib/stella/client.rb, line 392
    def repeat(t=1); raise RepeatRequest.new(t); end

# File lib/stella/client.rb, line 368
    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

# File lib/stella/client.rb, line 364
    def response_handler?
      status = (@res.status || 0).to_i
      !find_response_handler(status).nil?
    end

# File lib/stella/client.rb, line 384
    def status
      @res.status
    end

# File lib/stella/client.rb, line 388
    def wait(t); sleep t; end