rack-streaming-proxy 1.0.3 → 2.0.0

data/lib/rack/streaming_proxy/railtie.rb

@@ -0,0 +1,14 @@
+require 'rails/railtie'
+
+class Rack::StreamingProxy::Railtie < Rails::Railtie
+
+  config.streaming_proxy = ActiveSupport::OrderedOptions.new
+
+  config.after_initialize do
+    options = config.streaming_proxy
+    Rack::StreamingProxy::Proxy.logger             = options.logger             if options.logger
+    Rack::StreamingProxy::Proxy.log_verbosity      = options.log_verbosity      if options.log_verbosity
+    Rack::StreamingProxy::Proxy.num_retries_on_5xx = options.num_retries_on_5xx if options.num_retries_on_5xx
+    Rack::StreamingProxy::Proxy.raise_on_5xx       = options.raise_on_5xx       if options.raise_on_5xx
+  end
+end

data/lib/rack/streaming_proxy/request.rb

@@ -0,0 +1,65 @@
+require 'uri'
+require 'net/https'
+
+class Rack::StreamingProxy::Request
+
+  attr_reader :http_request
+
+  def initialize(destination_uri, current_request)
+    @destination_uri = URI.parse(destination_uri)
+    @http_request    = translate_request(current_request, @destination_uri)
+  end
+
+  def host
+    @destination_uri.host
+  end
+
+  def port
+    @destination_uri.port
+  end
+
+  def use_ssl?
+    @destination_uri.is_a? URI::HTTPS
+  end
+
+  def uri
+    @destination_uri.to_s
+  end
+
+private
+
+  def translate_request(current_request, uri)
+    method = current_request.request_method.downcase
+    method[0..0] = method[0..0].upcase
+
+    request = Net::HTTP.const_get(method).new("#{uri.path}#{"?" if uri.query}#{uri.query}")
+
+    if request.request_body_permitted? and current_request.body
+      request.body_stream    = current_request.body
+      request.content_length = current_request.content_length if current_request.content_length
+      request.content_type   = current_request.content_type   if current_request.content_type
+    end
+
+    log_headers :debug, 'Current Request Headers', current_request.env
+
+    current_headers = current_request.env.reject { |key, value| !(key.match /^HTTP_/) }
+    current_headers.each do |key, value|
+      fixed_name = key.sub(/^HTTP_/, '').gsub('_', '-')
+      request[fixed_name] = value unless fixed_name.downcase == 'host'
+    end
+    request['X-Forwarded-For'] = (current_request.env['X-Forwarded-For'].to_s.split(/, +/) + [current_request.env['REMOTE_ADDR']]).join(', ')
+
+    log_headers :debug, 'Proxy Request Headers:', request
+
+    request
+  end
+
+  def log_headers(level, title, headers)
+    Rack::StreamingProxy::Proxy.log level, "+-------------------------------------------------------------"
+    Rack::StreamingProxy::Proxy.log level, "| #{title}"
+    Rack::StreamingProxy::Proxy.log level, "+-------------------------------------------------------------"
+    headers.each { |key, value| Rack::StreamingProxy::Proxy.log level, "| #{key} = #{value.to_s}" }
+    Rack::StreamingProxy::Proxy.log level, "+-------------------------------------------------------------"
+  end
+
+end

data/lib/rack/streaming_proxy/response.rb

@@ -0,0 +1,79 @@
+require 'rack/streaming_proxy/errors'
+
+class Rack::StreamingProxy::Response
+  include Rack::Utils # For HeaderHash
+
+  attr_reader :status, :headers
+  attr_accessor :client_http_version
+
+  def initialize(piper)
+    @piper = piper
+    @client_http_version = '1.1'
+    receive
+  end
+
+  # This method is called by Rack itself, to iterate over the proxied contents.
+  def each
+    if @body_permitted
+      term = "\r\n"
+
+      while chunk = read_from_destination
+        break if chunk == :done
+        if @chunked
+          size = bytesize(chunk)
+          next if size == 0
+          if @client_http_version >= '1.1'
+            yield [size.to_s(16), term, chunk, term].join
+          else
+            yield chunk
+          end
+        else
+          yield chunk
+        end
+      end
+
+      finish
+
+      if @chunked && @client_http_version >= '1.1'
+        yield ['0', term, '', term].join
+      end
+    end
+  end
+
+private
+
+  def receive
+    # The first item received from the child will either be an HTTP status code or an Exception.
+    @status = read_from_destination
+
+    if @status.nil? # This should never happen
+      Rack::StreamingProxy::Proxy.log :error, "Parent received unexpected nil status!"
+      finish
+      raise Rack::StreamingProxy::UnknownError
+    elsif @status.kind_of? Exception
+      e = @status
+      Rack::StreamingProxy::Proxy.log :error, "Parent received an Exception from Child: #{e.class}: #{e.message}"
+      finish
+      raise e
+    end
+
+    Rack::StreamingProxy::Proxy.log :debug, "Parent received: Status = #{@status}."
+    @body_permitted = read_from_destination
+    Rack::StreamingProxy::Proxy.log :debug, "Parent received: Reponse has body? = #{@body_permitted}."
+    @headers = HeaderHash.new(read_from_destination)
+    @chunked = (@headers['Transfer-Encoding'] == 'chunked')
+    finish unless @body_permitted # If there is a body, finish will be called inside each.
+  end
+
+  # parent needs to wait for the child, or it results in the child process becoming defunct, resulting in zombie processes!
+  # This is very important. See: http://siliconisland.ca/2013/04/26/beware-of-the-zombie-process-apocalypse/
+  def finish
+    Rack::StreamingProxy::Proxy.log :info, "Parent process #{Process.pid} waiting for child process #{@piper.pid} to exit."
+    @piper.wait
+  end
+
+  def read_from_destination
+    @piper.gets
+  end
+
+end

data/lib/rack/streaming_proxy/session.rb

@@ -0,0 +1,119 @@
+require 'uri'
+require 'net/https'
+require 'servolux'
+require 'rack/streaming_proxy/errors'
+
+class Rack::StreamingProxy::Session
+
+  def initialize(request)
+    @request = request
+  end
+
+  # Returns a Rack::StreamingProxy::Response
+  def start
+    @piper = Servolux::Piper.new 'r', timeout: 30
+    @piper.child  { child }
+    @piper.parent { parent }
+  end
+
+private
+
+  def child
+    begin
+      Rack::StreamingProxy::Proxy.log :debug, "Child starting request to #{@request.uri}"
+      perform_request
+
+    rescue Exception => e
+      # Rescue all exceptions to help with development and debugging, as otherwise when exceptions
+      # occur the child process doesn't crash the parent process. Normally rescuing from Exception is a bad idea,
+      # but it's the only way to get a stacktrace here for all exceptions including SyntaxError etc,
+      # and we are simply passing it on so catastrophic exceptions will still be raised up the chain.
+      Rack::StreamingProxy::Proxy.log :debug, "Child process #{Process.pid} passing on #{e.class}: #{e.message}"
+      @piper.puts e # Pass on the exception to the parent.
+
+    ensure
+      Rack::StreamingProxy::Proxy.log :debug, "Child process #{Process.pid} closing connection."
+      @piper.close
+
+      Rack::StreamingProxy::Proxy.log :info, "Child process #{Process.pid} exiting."
+      exit!(0) # child needs to exit, always.
+    end
+  end
+
+  def parent
+    Rack::StreamingProxy::Proxy.log :info, "Parent process #{Process.pid} forked a child process #{@piper.pid}."
+
+    response = Rack::StreamingProxy::Response.new(@piper)
+    return response
+  end
+
+  def perform_request
+    http_session = Net::HTTP.new(@request.host, @request.port)
+    http_session.use_ssl = @request.use_ssl?
+
+    http_session.start do |session|
+      # Retry the request up to self.class.num_retries_on_5xx times if a 5xx is experienced.
+      # This is because some 500/503 errors resolve themselves quickly, might as well give it a chance.
+      # do...while loop as suggested by Matz: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745
+      retries = 1
+      stop = false
+      loop do
+        session.request(@request.http_request) do |response|
+          # At this point the headers and status are available, but the body has not yet been read.
+          Rack::StreamingProxy::Proxy.log :debug, "Child got response: #{response.class.name}"
+
+          if response.class <= Net::HTTPServerError # Includes Net::HTTPServiceUnavailable, Net::HTTPInternalServerError
+            if retries <= Rack::StreamingProxy::Proxy.num_retries_on_5xx
+              Rack::StreamingProxy::Proxy.log :info, "Child got #{response.code}, retrying (Retry ##{retries})"
+              sleep 1
+              retries += 1
+              next
+            end
+          end
+          stop = true
+
+          Rack::StreamingProxy::Proxy.log :debug, "Child process #{Process.pid} returning Status = #{response.code}."
+
+          process_response(response)
+        end
+
+        break if stop
+      end
+    end
+  end
+
+  def process_response(response)
+
+    # Raise an exception if the raise_on_5xx config is set, and the response is a 5xx.
+    # Otherwise continue and put the error body in the pipe. (e.g. Apache error page, for example)
+    if response.class <= Net::HTTPServerError && Rack::StreamingProxy::Proxy.raise_on_5xx
+      raise Rack::StreamingProxy::HttpServerError.new "Got a #{response.class.name} (#{response.code}) response while proxying to #{@request.uri}"
+    end
+
+    # Put the response in the parent's pipe.
+    @piper.puts response.code
+    @piper.puts response.class.body_permitted?
+
+    # Could potentially use a one-liner here:
+    # @piper.puts Hash[response.to_hash.map { |key, value| [key, value.join(', ')] } ]
+    # But the following three lines seem to be more readable.
+    # Watch out: response.to_hash and response.each_header returns in different formats!
+    # to_hash requires the values to be joined with a comma.
+    headers = {}
+    response.each_header { |key, value| headers[key] = value }
+    log_headers :debug, 'Proxy Response Headers:', headers
+    @piper.puts headers
+
+    response.read_body { |chunk| @piper.puts chunk }
+    @piper.puts :done
+  end
+
+  def log_headers(level, title, headers)
+    Rack::StreamingProxy::Proxy.log level, "+-------------------------------------------------------------"
+    Rack::StreamingProxy::Proxy.log level, "| #{title}"
+    Rack::StreamingProxy::Proxy.log level, "+-------------------------------------------------------------"
+    headers.each { |key, value| Rack::StreamingProxy::Proxy.log level, "| #{key} = #{value.to_s}" }
+    Rack::StreamingProxy::Proxy.log level, "+-------------------------------------------------------------"
+  end
+
+end

data/lib/rack/streaming_proxy/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module StreamingProxy
+    VERSION = "2.0.0"
+  end
+end

data/rack-streaming-proxy.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/streaming_proxy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rack-streaming-proxy'
+  spec.version       = Rack::StreamingProxy::VERSION
+  spec.authors       = ['Fred Ngo', 'Nathan Witmer']
+  spec.email         = ['fredngo@gmail.com', 'nwitmer@gmail.com']
+  spec.description   = %q{Streaming proxy for Rack, the rainbows to Rack::Proxy's unicorn.}
+  spec.summary       = %q{Streaming proxy for Rack, the rainbows to Rack::Proxy's unicorn.}
+  spec.homepage      = 'http://github.com/fredngo/rack-streaming-proxy'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency     'rack',     '>= 1.4'
+  spec.add_runtime_dependency     'servolux', '~> 0.10'
+
+  # test
+  spec.add_development_dependency 'bundler',  '>= 1.3'
+  spec.add_development_dependency 'rake',     '>= 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'unicorn'
+
+  # debug
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-nav'
+end

data/spec/app.ru

@@ -31,7 +31,7 @@ end
 use Rack::ContentLength
 
 map "/" do
-  run lambda { |env| [200, {"Content-Type" => "text/plain"}, "ALL GOOD"] }
+  run lambda { |env| [200, {"Content-Type" => "text/plain"}, ["ALL GOOD"]] }
 end
 
 map "/stream" do
@@ -50,6 +50,6 @@ map "/env" do
 end
 
 map "/boom" do
-  run lambda { |env| [500, {"Content-Type" => "text/plain"}, "kaboom!"] }
+  run lambda { |env| [500, {"Content-Type" => "text/plain"}, ["kaboom!"]] }
 end
 

data/spec/proxy.ru

@@ -1,9 +1,9 @@
 require File.expand_path(
   File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
 
-use Rack::Lint
+ENV['RACK_ENV'] = 'none' # 'development' automatically use Rack::Lint and results in errors with unicorn
 # use Rack::CommonLogger
-use Rack::StreamingProxy do |req|
+use Rack::StreamingProxy::Proxy do |req|
   "http://localhost:4321#{req.path}"
 end
-run lambda { |env| [200, {}, "should never get here..."]}
+run lambda { |env| [200, {}, ["should never get here..."]]}

data/spec/spec_helper.rb

@@ -1,8 +1,9 @@
-require File.expand_path(
-  File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
+require File.expand_path( File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
 
 require "rack/test"
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
 end
-

data/spec/streaming_proxy_spec.rb

@@ -1,15 +1,85 @@
+require 'yaml'
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
-describe Rack::StreamingProxy do
-  include Rack::Test::Methods
+APP_PORT = 4321 # hardcoded in proxy.ru as well!
+PROXY_PORT = 4322
 
-  APP_PORT = 4321 # hardcoded in proxy.ru as well!
-  PROXY_PORT = 4322
+shared_examples "rack-streaming-proxy" do
+  it "passes through to the rest of the stack if block returns false" do
+    get "/not_proxied"
+    last_response.should be_ok
+    last_response.body.should == "not proxied"
+  end
+
+  it "proxies a request back to the app server" do
+    get "/", {}, rack_env
+    last_response.should be_ok
+    last_response.body.should == "ALL GOOD"
+    # Expect a Content-Length header field which the origin server sent is 
+    # not deleted by streaming-proxy.
+    last_response.headers["Content-Length"].should eq '8'
+  end
+
+  it "handles POST, PUT, and DELETE methods" do
+    post "/env", {}, rack_env
+    last_response.should be_ok
+    last_response.body.should =~ /REQUEST_METHOD: POST/
+    put "/env", {}, rack_env
+    last_response.should be_ok
+    last_response.body.should =~ /REQUEST_METHOD: PUT/
+    delete "/env", {}, rack_env
+    last_response.should be_ok
+    last_response.body.should =~ /REQUEST_METHOD: DELETE/
+  end
+
+  it "sets a X-Forwarded-For header" do
+    post "/env", {}, rack_env
+    last_response.should =~ /HTTP_X_FORWARDED_FOR: 127.0.0.1/
+  end
+
+  it "preserves the post body" do
+    post "/env", {"foo" => "bar"}, rack_env
+    last_response.body.should =~ /rack.request.form_vars: foo=bar/
+  end
+
+  it "raises a Rack::Proxy::StreamingProxy error when something goes wrong" do
+    Rack::StreamingProxy::Request.should_receive(:new).and_raise(RuntimeError.new("kaboom"))
+    lambda { get "/" }.should raise_error(RuntimeError, /kaboom/i)
+  end
+
+  it "does not raise a Rack::Proxy error if the app itself raises something" do
+    lambda { get "/not_proxied/boom" }.should raise_error(RuntimeError, /app error/)
+  end
+
+  it "preserves cookies" do
+    set_cookie "foo"
+    post "/env", {}, rack_env
+    YAML::load(last_response.body)["HTTP_COOKIE"].should == "foo"
+  end
+
+  it "preserves authentication info" do
+    basic_authorize "admin", "secret"
+    post "/env", {}, rack_env
+    YAML::load(last_response.body)["HTTP_AUTHORIZATION"].should == "Basic YWRtaW46c2VjcmV0"
+  end
+
+  it "preserves arbitrary headers" do
+    get "/env", {}, rack_env.merge("HTTP_X_FOOHEADER" => "Bar")
+    YAML::load(last_response.body)["HTTP_X_FOOHEADER"].should == "Bar"
+  end
+end
+
+describe Rack::StreamingProxy::Proxy do
+  include Rack::Test::Methods
 
   def app
     @app ||= Rack::Builder.new do
       use Rack::Lint
-      use Rack::StreamingProxy do |req|
+      use Rack::StreamingProxy::Proxy do |req|
+        # STDERR.puts "== incoming request env =="
+        # STDERR.puts req.env
+        # STDERR.puts "=^ incoming request env ^="
+        # STDERR.puts
         unless req.path.start_with?("/not_proxied")
           url = "http://localhost:#{APP_PORT}#{req.path}"
           url << "?#{req.query_string}" unless req.query_string.empty?
@@ -19,13 +89,13 @@ describe Rack::StreamingProxy do
       end
       run lambda { |env|
         raise "app error" if env["PATH_INFO"] =~ /boom/
-        [200, {"Content-Type" => "text/plain"}, "not proxied"]
+        [200, {"Content-Type" => "text/plain"}, ["not proxied"]]
       }
     end
   end
 
   before(:all) do
-    app_path = Rack::StreamingProxy.path("spec", "app.ru")
+    app_path = File.join(File.dirname(__FILE__), %w[app.ru])
     @app_server = Servolux::Child.new(
       # :command => "thin -R #{app_path} -p #{APP_PORT} start", # buffers!
       :command => "rackup #{app_path} -p #{APP_PORT}",
@@ -45,10 +115,76 @@ describe Rack::StreamingProxy do
     puts "----- app server is stopped -----"
   end
 
+  context 'client requests with HTTP/1.0' do
+    let(:rack_env) { {'HTTP_VERSION' => 'HTTP/1.0'} }
+    it_behaves_like 'rack-streaming-proxy'
+    it "does not use chunked encoding when the app server send chunked body" do
+      get "/stream", {}, rack_env
+      last_response.should be_ok
+      # Expect a Transfer-Encoding header is deleted by rack-streaming-proxy
+      last_response.headers["Transfer-Encoding"].should be_nil
+      # I expected a Content-Length header which the origin server sent was deleted,
+      # But the following test failed against my expectation. The reason is 
+      # that a Content-Length header was added in creating Rack::MockResponse 
+      # instance. So I gave up writing this test right now.
+      #
+      # last_response.headers["Content-Length"].should be_nil
+      #
+      last_response.body.should == <<-EOS
+~~~~~ 0 ~~~~~
+~~~~~ 1 ~~~~~
+~~~~~ 2 ~~~~~
+~~~~~ 3 ~~~~~
+~~~~~ 4 ~~~~~
+      EOS
+    end
+  end
+
+  context 'client requests with HTTP/1.1' do
+    let(:rack_env) { {'HTTP_VERSION' => 'HTTP/1.1'} }
+    it_behaves_like 'rack-streaming-proxy'
+    it "uses chunked encoding when the app server send chunked body" do
+      get "/stream", {}, rack_env
+      last_response.should be_ok
+      last_response.headers["Transfer-Encoding"].should == 'chunked'
+      last_response.headers["Content-Length"].should be_nil
+      last_response.body.should =~ /^e\r\n~~~~~ 0 ~~~~~\n\r\n/
+    end
+  end
+
+end
+
+describe Rack::StreamingProxy::Proxy do
+  include Rack::Test::Methods
+
+  attr_reader :app
+
+  before(:all) do
+    app_path = File.join(File.dirname(__FILE__), %w[app.ru])
+    @app_server = Servolux::Child.new(
+      # :command => "thin -R #{app_path} -p #{APP_PORT} start", # buffers!
+      # :command => "rackup #{app_path} -p #{APP_PORT}", # webrick adds content-length, it should be wrong
+      :command => "unicorn #{app_path} -p #{APP_PORT} -E none",
+      :timeout => 30, # all specs should take <30 sec to run
+      :suspend => 0.25
+    )
+    puts "----- starting app server -----"
+    @app_server.start
+    sleep 2 # give it a sec
+    puts "----- started app server -----"
+  end
+
+  after(:all) do
+    puts "----- shutting down app server -----"
+    @app_server.stop
+    @app_server.wait
+    puts "----- app server is stopped -----"
+  end
+
   def with_proxy_server
-    proxy_path = Rack::StreamingProxy.path("spec", "proxy.ru")
+    proxy_path = File.join(File.dirname(__FILE__), %w[proxy.ru])
     @proxy_server = Servolux::Child.new(
-      :command => "rackup #{proxy_path} -p #{PROXY_PORT}",
+      :command => "unicorn #{proxy_path} -p #{PROXY_PORT} -E none",
       :timeout => 10,
       :suspend => 0.25
     )
@@ -64,26 +200,8 @@ describe Rack::StreamingProxy do
     puts "----- proxy server is stopped -----"
   end
 
-  it "passes through to the rest of the stack if block returns false" do
-    get "/not_proxied"
-    last_response.should be_ok
-    last_response.body.should == "not proxied"
-  end
-
-  it "proxies a request back to the app server" do
-    get "/"
-    last_response.should be_ok
-    last_response.body.should == "ALL GOOD"
-  end
-
-  it "uses chunked encoding when the app server send data that way" do
-    get "/stream"
-    last_response.should be_ok
-    last_response.headers["Transfer-Encoding"].should == "chunked"
-    last_response.body.should =~ /^e\r\n~~~~~ 0 ~~~~~\n\r\n/
-  end
-
   # this is the most critical spec: it makes sure things are actually streamed, not buffered
+  # MEMO: only unicorn worked. webrick, thin, and puma did not progressively stream
   it "streams data from the app server to the client" do
     @app = Rack::Builder.new do
       use Rack::Lint
@@ -105,55 +223,8 @@ describe Rack::StreamingProxy do
       last_response.should be_ok
       times = last_response.body.split("\n").map {|l| l.to_i}
       unless (times.last - times.first) >= 2
-        violated "expected receive time of first chunk to be at least " +
-          "two seconds before the last chunk"
+        fail "expected receive time of first chunk to be at least two seconds before the last chunk, but the times were: #{times.join(', ')}"
       end
     end
-
-  end
-
-  it "handles POST, PUT, and DELETE methods" do
-    post "/env"
-    last_response.should be_ok
-    last_response.body.should =~ /REQUEST_METHOD: POST/
-    put "/env"
-    last_response.should be_ok
-    last_response.body.should =~ /REQUEST_METHOD: PUT/
-    delete "/env"
-    last_response.should be_ok
-    last_response.body.should =~ /REQUEST_METHOD: DELETE/
-  end
-
-  it "sets a X-Forwarded-For header" do
-    post "/env"
-    last_response.should =~ /HTTP_X_FORWARDED_FOR: 127.0.0.1/
-  end
-
-  it "preserves the post body" do
-    post "/env", "foo" => "bar"
-    last_response.body.should =~ /rack.request.form_vars: foo=bar/
-  end
-
-  it "raises a Rack::Proxy::StreamingProxy error when something goes wrong" do
-    Rack::StreamingProxy::ProxyRequest.should_receive(:new).and_raise(RuntimeError.new("kaboom"))
-    lambda { get "/" }.should raise_error(Rack::StreamingProxy::Error, /proxy error.*kaboom/i)
-  end
-
-  it "does not raise a Rack::Proxy error if the app itself raises something" do
-    lambda { get "/not_proxied/boom" }.should raise_error(RuntimeError, /app error/)
-  end
-
-  it "preserves cookies" do
-    set_cookie "foo"
-    post "/env"
-    YAML.load(last_response.body)["HTTP_COOKIE"].should == "foo"
-  end
-
-  it "preserves authentication info" do
-    basic_authorize "admin", "secret"
-    post "/env"
-    YAML.load(last_response.body)["HTTP_AUTHORIZATION"].should == "Basic YWRtaW46c2VjcmV0\n"
   end
-
 end
-