z-http-request 0.1.0

data/spec/digest_auth_spec.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+$: << 'lib' << '../lib'
+
+require 'z-http/middleware/digest_auth'
+
+describe 'Digest Auth Authentication header generation' do
+  before :each do
+    @reference_header = 'Digest username="digest_username", realm="DigestAuth_REALM", algorithm=MD5, uri="/", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", response="96829962ffc31fa2852f86dc7f9f609b", opaque="BzdNK3gsJ2ixTrBJ"'
+  end
+
+  it 'should generate the correct header'  do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username',
+      password: 'digest_password'
+    }
+
+    middleware = ZMachine::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should == @reference_header
+  end
+
+  it 'should not generate the same header for a different user' do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username_2',
+      password: 'digest_password'
+    }
+
+    middleware = ZMachine::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should_not == @reference_header
+  end
+
+  it 'should not generate the same header if the nounce changes' do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg6", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username_2',
+      password: 'digest_password'
+    }
+
+    middleware = ZMachine::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should_not == @reference_header
+  end
+
+end

data/spec/dns_spec.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+describe ZMachine::HttpRequest do
+
+  it "should fail gracefully on an invalid host in Location header" do
+    ZMachine.run {
+      http = ZMachine::HttpRequest.new('http://127.0.0.1:8090/redirect/badhost', :connect_timeout => 0.1).get :redirects => 1
+      http.callback { failed(http) }
+      http.errback {
+        http.error.should match('unable to resolve server address')
+        ZMachine.stop
+      }
+    }
+  end
+
+  # BB: 127.1.1.1 actually loops back, and if you have some process listening
+  # on port 80 this spec fails *facepalm*
+  # also this does not check any DNS timeout, but a connect timeout ...
+  it "should fail GET on DNS timeout" do
+    ZMachine.run {
+      ZMachine.heartbeat_interval = 0.1
+      http = ZMachine::HttpRequest.new('http://127.1.1.1:1/', :connect_timeout => 0.1).get
+      http.callback { failed(http) }
+      http.errback {
+        http.response_header.status.should == 0
+        ZMachine.stop
+      }
+    }
+  end
+
+  it "should fail GET on invalid host" do
+    ZMachine.run {
+      ZMachine.heartbeat_interval = 0.1
+      http = ZMachine::HttpRequest.new('http://somethinglocal/', :connect_timeout => 0.1).get
+      http.callback { failed(http) }
+      http.errback {
+        http.error.should match(/unable to resolve server address/)
+        http.response_header.status.should == 0
+        ZMachine.stop
+      }
+    }
+  end
+
+end

data/spec/encoding_spec.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+require 'helper'
+
+describe ZMachine::HttpEncoding do
+  include ZMachine::HttpEncoding
+
+  it "should transform a basic hash into HTTP POST Params" do
+    form_encode_body({:a => "alpha", :b => "beta"}).should == "a=alpha&b=beta"
+  end
+
+  it "should transform a more complex hash into HTTP POST Params" do
+    form_encode_body({:a => "a", :b => ["c", "d", "e"]}).should == "a=a&b[0]=c&b[1]=d&b[2]=e"
+  end
+
+  it "should transform a very complex hash into HTTP POST Params" do
+    params = form_encode_body({:a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]})
+    # 1.8.7 does not have ordered hashes.
+    params.split(/&/).sort.join('&').should == "a=a&b[0][c]=c&b[0][d]=d&b[1][e]=e&b[1][f]=f"
+  end
+
+  it "should escape values" do
+    params = form_encode_body({:stuff => 'string&string'})
+    params.should == "stuff=string%26string"
+  end
+
+  it "should escape keys" do
+    params = form_encode_body({'bad&str'=> {'key&key' => [:a, :b]}})
+    params.should == 'bad%26str[key%26key][0]=a&bad%26str[key%26key][1]=b'
+  end
+
+  it "should escape keys and values" do
+    params = form_encode_body({'bad&str'=> {'key&key' => ['bad+&stuff', '[test]']}})
+    params.should == "bad%26str[key%26key][0]=bad%2B%26stuff&bad%26str[key%26key][1]=%5Btest%5D"
+  end
+
+  it "should not issue warnings on non-ASCII encodings" do
+    # I don't know how to check for ruby warnings.
+    params = escape('valö')
+    params = escape('valö'.encode('ISO-8859-15'))
+  end
+
+  # xit "should be fast on long string escapes" do
+  #   s = Time.now
+  #   5000.times { |n| form_encode_body({:a => "{a:'b', d:'f', g:['a','b']}"*50}) }
+  #   (Time.now - s).should satisfy { |t| t < 1.5 }
+  # end
+
+end

data/spec/external_spec.rb

@@ -0,0 +1,150 @@
+require 'helper'
+
+requires_connection do
+
+  describe ZMachine::HttpRequest do
+
+    it "should follow redirects on HEAD method (external)" do
+      ZMachine.run {
+        http = ZMachine::HttpRequest.new('http://www.google.com/').head :redirects => 1
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          ZMachine.stop
+        }
+      }
+    end
+
+    it "should follow redirect to https and initiate the handshake" do
+      ZMachine.run {
+        http = ZMachine::HttpRequest.new('http://github.com/').get :redirects => 5
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          ZMachine.stop
+        }
+      }
+    end
+
+    it "should perform a streaming GET" do
+      ZMachine.run {
+
+        # digg.com uses chunked encoding
+        http = ZMachine::HttpRequest.new('http://www.httpwatch.com/httpgallery/chunked/').get
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          ZMachine.stop
+        }
+      }
+    end
+
+    it "should handle a 100 continue" do
+      ZMachine.run {
+        # 8.2.3 Use of the 100 (Continue) Status - http://www.ietf.org/rfc/rfc2616.txt
+        #
+        # An origin server SHOULD NOT send a 100 (Continue) response if
+        # the request message does not include an Expect request-header
+        # field with the "100-continue" expectation, and MUST NOT send a
+        # 100 (Continue) response if such a request comes from an HTTP/1.0
+        # (or earlier) client. There is an exception to this rule: for
+        # compatibility with RFC 2068, a server MAY send a 100 (Continue)
+        # status in response to an HTTP/1.1 PUT or POST request that does
+        # not include an Expect request-header field with the "100-
+        # continue" expectation. This exception, the purpose of which is
+        # to minimize any client processing delays associated with an
+        # undeclared wait for 100 (Continue) status, applies only to
+        # HTTP/1.1 requests, and not to requests with any other HTTP-
+        # version value.
+        #
+        # 10.1.1: 100 Continue - http://www.ietf.org/rfc/rfc2068.txt
+        # The client may continue with its request. This interim response is
+        # used to inform the client that the initial part of the request has
+        # been received and has not yet been rejected by the server. The client
+        # SHOULD continue by sending the remainder of the request or, if the
+        # request has already been completed, ignore this response. The server
+        # MUST send a final response after the request has been completed.
+
+        url = 'http://ws.serviceobjects.com/lv/LeadValidation.asmx/ValidateLead_V2'
+        http = ZMachine::HttpRequest.new(url).post :body => {:name => :test}
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 500
+          http.response.should match('Missing')
+          ZMachine.stop
+        }
+      }
+    end
+
+    it "should detect deflate encoding" do
+      pending "need an endpoint which supports deflate.. MSN is no longer"
+      ZMachine.run {
+
+        options = {:head => {"accept-encoding" => "deflate"}, :redirects => 5}
+        http = ZMachine::HttpRequest.new('http://www.msn.com').get options
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "deflate"
+
+          ZMachine.stop
+        }
+      }
+    end
+
+    it "should stream chunked gzipped data" do
+      ZMachine.run {
+        options = {:head => {"accept-encoding" => "gzip"}}
+        # GitHub sends chunked gzip, time for a little Inception ;)
+        http = ZMachine::HttpRequest.new('https://github.com/igrigorik/z-http-request/commits/master').get options
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "gzip"
+          http.response.should == ''
+
+          ZMachine.stop
+        }
+
+        body = ''
+        http.stream do |chunk|
+          body << chunk
+        end
+      }
+    end
+
+    context "keepalive" do
+      it "should default to non-keepalive" do
+        ZMachine.run {
+          headers = {'If-Modified-Since' => 'Thu, 05 Aug 2010 22:54:44 GMT'}
+          http = ZMachine::HttpRequest.new('http://www.google.com/images/logos/ps_logo2.png').get :head => headers
+
+          http.errback { fail }
+          start = Time.now.to_i
+          http.callback {
+            (Time.now.to_i - start).should be_within(2).of(0)
+            ZMachine.stop
+          }
+        }
+      end
+
+      it "should work with keep-alive servers" do
+        ZMachine.run {
+          http = ZMachine::HttpRequest.new('http://mexicodiario.com/touch.public.json.php').get :keepalive => true
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            ZMachine.stop
+          }
+        }
+      end
+    end
+
+  end
+end

data/spec/fixtures/google.ca

@@ -0,0 +1,16 @@
+HTTP/1.1 301 Moved Permanently
+Location: http://www.google.ca/
+Content-Type: text/html; charset=UTF-8
+Date: Sun, 09 Jan 2011 02:51:43 GMT
+Expires: Tue, 08 Feb 2011 02:51:43 GMT
+Cache-Control: public, max-age=2592000
+Server: gws
+Content-Length: 218
+X-XSS-Protection: 1; mode=block
+
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+<TITLE>301 Moved</TITLE></HEAD><BODY>
+<H1>301 Moved</H1>
+The document has moved
+<A HREF="http://www.google.ca/">here</A>.
+</BODY></HTML>

data/spec/gzip_spec.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+describe ZMachine::HttpDecoders::GZip do
+
+  let(:compressed) {
+    compressed = ["1f8b08089668a6500003686900cbc8e402007a7a6fed03000000"].pack("H*")
+  }
+
+  it "should extract the stream of a vanilla gzip" do
+    header = ZMachine::HttpDecoders::GZipHeader.new
+    stream = header.extract_stream(compressed)
+
+    stream.unpack("H*")[0].should eq("cbc8e402007a7a6fed03000000")
+  end
+
+  it "should decompress a vanilla gzip" do
+    decompressed = ""
+
+    gz = ZMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    gz << compressed
+    gz.finalize!
+
+    decompressed.should eq("hi\n")
+  end
+
+  it "should decompress a vanilla gzip file byte by byte" do
+    decompressed = ""
+
+    gz = ZMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    compressed.each_char do |byte|
+      gz << byte
+    end
+
+    gz.finalize!
+
+    decompressed.should eq("hi\n")
+  end
+
+  it "should decompress a large file" do
+    decompressed = ""
+
+    gz = ZMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    gz << File.read(File.dirname(__FILE__) + "/fixtures/gzip-sample.gz")
+
+    gz.finalize!
+
+    decompressed.size.should eq(32907)
+  end
+
+  it "should fail with a DecoderError if not a gzip file" do
+    not_a_gzip = ["1f8c08089668a650000"].pack("H*")
+    header = ZMachine::HttpDecoders::GZipHeader.new
+
+    lambda {
+      header.extract_stream(not_a_gzip)
+    }.should raise_exception(ZMachine::HttpDecoders::DecoderError)
+  end
+
+end

data/spec/helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'puma'
+require 'z-http'
+require 'multi_json'
+
+require 'stallion'
+require 'stub_server'
+
+def failed(http = nil)
+  ZMachine.stop
+  http ? fail(http.error) : fail
+end
+
+def requires_connection(&blk)
+  blk.call if system('ping -t1 -c1 google.com 2>&1 > /dev/null')
+end
+
+def requires_port(port, &blk)
+  port_open = true
+  begin
+    s = TCPSocket.new('localhost', port)
+    s.close()
+  rescue
+    port_open = false
+  end
+
+  blk.call if port_open
+end

data/spec/middleware_spec.rb

@@ -0,0 +1,143 @@
+require 'helper'
+
+describe ZMachine::HttpRequest do
+
+  class EmptyMiddleware; end
+
+  class GlobalMiddleware
+    def response(resp)
+      resp.response_header['X-Global'] = 'middleware'
+    end
+  end
+
+  it "should accept middleware" do
+    ZMachine.run {
+      lambda {
+        conn = ZMachine::HttpRequest.new('http://127.0.0.1:8090')
+        conn.use ResponseMiddleware
+        conn.use EmptyMiddleware
+
+        ZMachine.stop
+      }.should_not raise_error
+    }
+  end
+
+  context "configuration" do
+    class ConfigurableMiddleware
+      def initialize(conf, &block)
+        @conf = conf
+        @block = block
+      end
+
+      def response(resp)
+        resp.response_header['X-Conf'] = @conf
+        resp.response_header['X-Block'] = @block.call
+      end
+    end
+
+    it "should accept middleware initialization parameters" do
+      ZMachine.run {
+        conn = ZMachine::HttpRequest.new('http://127.0.0.1:8090')
+        conn.use ConfigurableMiddleware, 'conf-value' do
+          'block-value'
+        end
+
+        req = conn.get
+        req.callback {
+          req.response_header['X-Conf'].should match('conf-value')
+          req.response_header['X-Block'].should match('block-value')
+          ZMachine.stop
+        }
+      }
+    end
+  end
+
+  context "request" do
+    class ResponseMiddleware
+      def response(resp)
+        resp.response_header['X-Header'] = 'middleware'
+        resp.response = 'Hello, Middleware!'
+      end
+    end
+
+    it "should execute response middleware before user callbacks" do
+      ZMachine.run {
+        conn = ZMachine::HttpRequest.new('http://127.0.0.1:8090')
+        conn.use ResponseMiddleware
+
+        req = conn.get
+        req.callback {
+          req.response_header['X-Header'].should match('middleware')
+          req.response.should match('Hello, Middleware!')
+          ZMachine.stop
+        }
+      }
+    end
+
+    it "should execute global response middleware before user callbacks" do
+      ZMachine.run {
+        ZMachine::HttpRequest.use GlobalMiddleware
+
+        conn = ZMachine::HttpRequest.new('http://127.0.0.1:8090')
+
+        req = conn.get
+        req.callback {
+          req.response_header['X-Global'].should match('middleware')
+          ZMachine.stop
+        }
+      }
+    end
+  end
+
+  context "request" do
+    class RequestMiddleware
+      def request(client, head, body)
+        head['X-Middleware'] = 'middleware'   # insert new header
+        body += ' modified'                   # modify post body
+
+        [head, body]
+      end
+    end
+
+    it "should execute request middleware before dispatching request" do
+      ZMachine.run {
+        conn = ZMachine::HttpRequest.new('http://127.0.0.1:8090/')
+        conn.use RequestMiddleware
+
+        req = conn.post :body => "data"
+        req.callback {
+          req.response_header.status.should == 200
+          req.response.should match(/data modified/)
+          ZMachine.stop
+        }
+      }
+    end
+  end
+
+  context "jsonify" do
+    class JSONify
+      def request(client, head, body)
+        [head, MultiJson.dump(body)]
+      end
+
+      def response(resp)
+        resp.response = MultiJson.load(resp.response)
+      end
+    end
+
+    it "should use middleware to JSON encode and JSON decode the body" do
+      ZMachine.run {
+        conn = ZMachine::HttpRequest.new('http://127.0.0.1:8090/')
+        conn.use JSONify
+
+        req = conn.post :body => {:ruby => :hash}
+        req.callback {
+          req.response_header.status.should == 200
+          req.response.should == {"ruby" => "hash"}
+          ZMachine.stop
+        }
+      }
+    end
+  end
+
+end

data/spec/multi_spec.rb

@@ -0,0 +1,104 @@
+require 'helper'
+require 'stallion'
+
+describe ZMachine::MultiRequest do
+
+  let(:multi) { ZMachine::MultiRequest.new }
+  let(:url)   { 'http://127.0.0.1:8090/' }
+
+  it "should submit multiple requests in parallel and return once all of them are complete" do
+    ZMachine.run {
+      multi.add :a, ZMachine::HttpRequest.new(url).get
+      multi.add :b, ZMachine::HttpRequest.new(url).post
+      multi.add :c, ZMachine::HttpRequest.new(url).head
+      multi.add :d, ZMachine::HttpRequest.new(url).delete
+      multi.add :e, ZMachine::HttpRequest.new(url).put
+
+      multi.callback {
+        multi.responses[:callback].size.should == 5
+        multi.responses[:callback].each { |name, response|
+          [ :a, :b, :c, :d, :e ].should include(name)
+          response.response_header.status.should == 200
+        }
+        multi.responses[:errback].size.should == 0
+
+        ZMachine.stop
+      }
+    }
+  end
+
+  it "should require unique keys for each deferrable" do
+    lambda do
+      multi.add :df1, ZMachine::DefaultDeferrable.new
+      multi.add :df1, ZMachine::DefaultDeferrable.new
+    end.should raise_error("Duplicate Multi key")
+  end
+
+
+  describe "#requests" do
+    it "should return the added requests" do
+      request1 = double('request1', :callback => nil, :errback => nil)
+      request2 = double('request2', :callback => nil, :errback => nil)
+
+      multi.add :a, request1
+      multi.add :b, request2
+
+      multi.requests.should == {:a => request1, :b => request2}
+    end
+  end
+
+  describe "#responses" do
+    it "should have an empty :callback hash" do
+      multi.responses[:callback].should be_a(Hash)
+      multi.responses[:callback].size.should == 0
+    end
+
+    it "should have an empty :errback hash" do
+      multi.responses[:errback].should be_a(Hash)
+      multi.responses[:errback].size.should == 0
+    end
+
+    it "should provide access to the requests by name" do
+      ZMachine.run {
+        request1 = ZMachine::HttpRequest.new(url).get
+        request2 = ZMachine::HttpRequest.new(url).post
+        multi.add :a, request1
+        multi.add :b, request2
+
+        multi.callback {
+          multi.responses[:callback][:a].should equal(request1)
+          multi.responses[:callback][:b].should equal(request2)
+
+          ZMachine.stop
+        }
+      }
+    end
+  end
+
+  describe "#finished?" do
+    it "should be true when no requests have been added" do
+      multi.should be_finished
+    end
+
+    it "should be false while the requests are not finished" do
+      ZMachine.run {
+        multi.add :a, ZMachine::HttpRequest.new(url).get
+        multi.should_not be_finished
+
+        ZMachine.stop
+      }
+    end
+
+    it "should be finished when all requests are finished" do
+      ZMachine.run {
+        multi.add :a, ZMachine::HttpRequest.new(url).get
+        multi.callback {
+          multi.should be_finished
+
+          ZMachine.stop
+        }
+      }
+    end
+  end
+
+end