dwaite-em-http-request 0.1.9

data/test/test_hash.rb

@@ -0,0 +1,19 @@
+require 'test/helper'
+
+describe Hash do
+  
+  describe ".to_params" do
+    it "should transform a basic hash into HTTP POST Params" do
+      {:a => "alpha", :b => "beta"}.to_params.should == "a=alpha&b=beta"
+    end
+    
+    it "should transform a more complex hash into HTTP POST Params" do
+      {:a => "a", :b => ["c", "d", "e"]}.to_params.should == "a=a&b[0]=c&b[1]=d&b[2]=e"
+    end
+
+    # Ruby 1.8 Hash is not sorted, so this test breaks randomly. Maybe once we're all on 1.9. ;-)
+    # it "should transform a very complex hash into HTTP POST Params" do
+    #    {:a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]}.to_params.should == "a=a&b[0][d]=d&b[0][c]=c&b[1][f]=f&b[1][e]=e"
+    # end
+  end
+end

data/test/test_multi.rb

@@ -0,0 +1,29 @@
+require 'test/helper'
+require 'test/stallion'
+
+describe EventMachine::MultiRequest do
+
+  it "should submit multiple requests in parallel and return once all of them are complete" do
+    EventMachine.run {
+      
+      # create an instance of multi-request handler, and the requests themselves
+      multi = EventMachine::MultiRequest.new
+      
+      # add multiple requests to the multi-handler
+      multi.add(EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get(:query => {:q => 'test'}))
+      multi.add(EventMachine::HttpRequest.new('http://0.0.0.0/').get(:timeout => 1))
+      
+      multi.callback  {
+        # verify successfull request
+        multi.responses[:succeeded].size.should == 1
+        multi.responses[:succeeded].first.response.should match(/test/)
+        
+        # verify invalid requests
+        multi.responses[:failed].size.should == 1
+        multi.responses[:failed].first.response_header.status.should == 0
+        
+        EventMachine.stop
+      }
+    } 
+  end
+end

data/test/test_request.rb

@@ -0,0 +1,358 @@
+require 'test/helper'
+require 'test/stallion'
+ 
+describe EventMachine::HttpRequest do
+
+  def failed
+    EventMachine.stop
+    fail
+  end
+  
+  it "should fail GET on DNS timeout" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.1.1.1/').get
+      http.callback { failed }
+      http.errback {
+        http.response_header.status.should == 0
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should fail GET on invalid host" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://google1.com/').get
+      http.callback { failed }
+      http.errback {
+        http.response_header.status.should == 0
+        http.errors.should match(/no connection/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should fail GET on missing path" do
+    EventMachine.run {
+      lambda {
+        EventMachine::HttpRequest.new('http://www.google.com').get
+      }.should raise_error(ArgumentError)
+
+      EventMachine.stop
+    }
+  end
+
+  it "should perform successfull GET" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Hello/)
+        EventMachine.stop
+      }
+    }
+  end
+  
+  it "should perform successfull GET with a URI passed as argument" do
+    EventMachine.run {
+      uri = URI.parse('http://127.0.0.1:8080/')
+      http = EventMachine::HttpRequest.new(uri).get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Hello/)
+        EventMachine.stop
+      }
+    }    
+  end
+
+  it "should perform successfull HEAD with a URI passed as argument" do
+    EventMachine.run {
+      uri = URI.parse('http://127.0.0.1:8080/')
+      http = EventMachine::HttpRequest.new(uri).head
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == ""
+        EventMachine.stop
+      }
+    }    
+  end
+
+  it "should return 404 on invalid path" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/fail').get
+
+      http.errback { failed }
+      http.callback { 
+        http.response_header.status.should == 404
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should build query parameters from Hash" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :query => {:q => 'test'}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/test/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should pass query parameters string" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :query => "q=test"
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/test/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should encode an array of query parameters" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_query').get :query => {:hash => ['value1', 'value2']}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/hash\[\]=value1&hash\[\]=value2/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successfull POST" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => "data"
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/data/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successfull POST with Ruby Hash/Array as params" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => {"key1" => 1, "key2" => [2,3]}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        
+        http.response.should match(/key1=1&key2\[0\]=2&key2\[1\]=3/)
+        EventMachine.stop
+      }
+    }
+  end
+  
+  it "should perform successfull POST with Ruby Hash/Array as params and with the correct content length" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_length').post :body => {"key1" => "data1"}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        
+        http.response.to_i.should == 10
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successfull GET with custom header" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'if-none-match' => 'evar!'}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 304
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform a streaming GET" do
+    EventMachine.run {
+
+      # digg.com uses chunked encoding
+      http = EventMachine::HttpRequest.new('http://digg.com/').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform basic auth" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'authorization' => ['user', 'pass']}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should work with keep-alive servers" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://mexicodiario.com/touch.public.json.php').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should detect deflate encoding" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/deflate').get :head => {"accept-encoding" => "deflate"}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header["CONTENT_ENCODING"].should == "deflate"
+        http.response.should == "compressed"
+
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should detect gzip encoding" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/gzip').get :head => {"accept-encoding" => "gzip, compressed"}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header["CONTENT_ENCODING"].should == "gzip"
+        http.response.should == "compressed"
+
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should timeout after 10 seconds" do
+    EventMachine.run {
+      t = Time.now.to_i
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/timeout').get :timeout => 1
+
+      http.errback {
+        (Time.now.to_i - t).should >= 2
+        EventMachine.stop
+      }
+      http.callback { failed }
+    }
+  end
+
+  it "should optionally pass the response body progressively" do
+    EventMachine.run {
+      body = ''
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get 
+
+      http.errback { failed }
+      http.stream { |chunk| body += chunk }
+
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == ''
+        body.should match(/Hello/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should optionally pass the deflate-encoded response body progressively" do
+    EventMachine.run {
+      body = ''
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/deflate').get :head => {"accept-encoding" => "deflate, compressed"}
+
+      http.errback { failed }
+      http.stream { |chunk| body += chunk }
+
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header["CONTENT_ENCODING"].should == "deflate"
+        http.response.should == ''
+        body.should == "compressed"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should initiate SSL/TLS on HTTPS connections" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('https://mail.google.com:443/mail/').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 302
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should accept & return cookie header to user" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/set_cookie').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header.cookie.should == "id=1; expires=Tue, 09-Aug-2011 17:53:39 GMT; path=/;"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should pass cookie header to server from string" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_cookie').get :head => {'cookie' => 'id=2;'}
+
+      http.errback { failed }
+      http.callback {
+        http.response.should == "id=2;"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should pass cookie header to server from Hash" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_cookie').get :head => {'cookie' => {'id' => 2}}
+
+      http.errback { failed }
+      http.callback {
+        http.response.should == "id=2;"
+        EventMachine.stop
+      }
+    }
+  end
+  
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: dwaite-em-http-request
+version: !ruby/object:Gem::Version 
+  version: 0.1.9
+platform: ruby
+authors: 
+- Ilya Grigorik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.2
+    version: 
+description: EventMachine based HTTP Request interface
+email: ilya@igvita.com
+executables: []
+
+extensions: 
+- ext/buffer/extconf.rb
+- ext/http11_client/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- em-http-request.gemspec
+- ext/buffer/em_buffer.c
+- ext/buffer/extconf.rb
+- ext/http11_client/ext_help.h
+- ext/http11_client/extconf.rb
+- ext/http11_client/http11_client.c
+- ext/http11_client/http11_parser.c
+- ext/http11_client/http11_parser.h
+- ext/http11_client/http11_parser.rl
+- lib/em-http.rb
+- lib/em-http/client.rb
+- lib/em-http/core_ext/hash.rb
+- lib/em-http/decoders.rb
+- lib/em-http/multi.rb
+- lib/em-http/request.rb
+- test/test_hash.rb
+- test/helper.rb
+- test/stallion.rb
+- test/test_multi.rb
+- test/test_request.rb
+has_rdoc: true
+homepage: http://github.com/igrigorik/em-http-request
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: em-http-request
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: EventMachine based HTTP Request interface
+test_files: []
+