em-http-request 0.2.5 → 0.2.6

data/README.rdoc

@@ -3,8 +3,10 @@
 EventMachine based HTTP Request interface. Supports streaming response processing, uses Ragel HTTP parser. 
 - Simple interface for single & parallel requests via deferred callbacks
 - Automatic gzip & deflate decoding
-- Basic-Auth support
-- Custom timeouts 
+- Basic-Auth & OAuth support
+- Custom timeouts
+- Proxy support (with SSL Tunneling)
+- Bi-directional communication with web-socket services
 
 Screencast / Demo of using EM-HTTP-Request: 
 - http://everburning.com/news/eventmachine-screencast-em-http-request/
@@ -35,6 +37,7 @@ Screencast / Demo of using EM-HTTP-Request:
   }
 
 == Multi request example
+Fire and wait for multiple requess to complete via the MultiRequest interface.
 
   EventMachine.run {
     multi = EventMachine::MultiRequest.new
@@ -52,6 +55,7 @@ Screencast / Demo of using EM-HTTP-Request:
   }
 
 == Basic-Auth example
+Full basic author support. For OAuth, check examples/oauth-tweet.rb file.
 
   EventMachine.run {
     http = EventMachine::HttpRequest.new('http://www.website.com/').get :head => {'authorization' => ['user', 'pass']}
@@ -63,17 +67,6 @@ Screencast / Demo of using EM-HTTP-Request:
     }
   }
 
-== OAuth example
-
-  EventMachine.run {
-    http = EventMachine::HttpRequest.new('http://www.website.com/').get :head => {'authorization' => 'OAuth oauth_nonce=...'}
-    http.errback { failed }
-    http.callback {
-      p http.response_header
-      EventMachine.stop
-    }
-  }
-
 
 == POST example
   EventMachine.run {
@@ -84,6 +77,9 @@ Screencast / Demo of using EM-HTTP-Request:
   }
 
 == Streaming body processing
+Allows you to consume an HTTP stream of content in real-time. Each time a new piece of conent is pushed
+to the client, it is passed to the stream callback for you to operate on.
+
   EventMachine.run {
     http = EventMachine::HttpRequest.new('http://www.website.com/').get
     http.stream { |chunk| print chunk }
@@ -92,10 +88,33 @@ Screencast / Demo of using EM-HTTP-Request:
   }
 
 == Proxy example
+Full transparent proxy support with support for SSL tunneling.
+
   EventMachine.run {
-    http1 = EventMachine::HttpRequest.new('http://www.website.com/').get :proxy => {
+    http = EventMachine::HttpRequest.new('http://www.website.com/').get :proxy => {
       :host => 'www.myproxy.com',
       :port => 8080,
       :authorization => ['username', 'password'] # authorization is optional
+  }
+
+== WebSocket example
+Bi-directional communication with WebSockets: simply pass in a ws:// resource and the client will
+negotiate the connection upgrade for you. On successfull handshake the callback is invoked, and
+any incoming messages will be passed to the stream callback. The client can also send data to the
+server at will by calling the "send" method!
+- http://www.igvita.com/2009/12/22/ruby-websockets-tcp-for-the-browser/
+
+  EventMachine.run {
+    http = EventMachine::HttpRequest.new("ws://yourservice.com/websocket").get :timeout => 0
+ 
+    http.errback { puts "oops" }
+    http.callback {
+      puts "WebSocket connected!"
+      http.send("Hello client")
     }
 
+    http.stream { |msg|
+      puts "Recieved: #{msg}"
+      http.send "Pong: #{msg}"
+    }
+  }

data/Rakefile

@@ -36,7 +36,6 @@ end
 
 task :spec do
 	sh 'spec test/test_*.rb'
-	sh 'spec test/mock/test_*.rb'
 end
 
 def make(makedir)

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.2.6

data/examples/oauth-tweet.rb

@@ -0,0 +1,50 @@
+# Courtesy of Darcy Laycock:
+# http://gist.github.com/265261
+#
+
+require 'rubygems'
+
+require 'em-http'
+require 'oauth'
+
+# At a minimum, require 'oauth/request_proxy/em_http_request'
+# for this example, we'll use Net::HTTP like support.
+require 'oauth/client/em_http'
+
+# You need two things: an oauth consumer and an access token.
+# You need to generate an access token, I suggest looking elsewhere how to do that or wait for a full tutorial.
+# For a consumer key / consumer secret, signup for an app at:
+# http://twitter.com/apps/new
+
+# Edit in your details.
+CONSUMER_KEY = ""
+CONSUMER_SECRET = ""
+ACCESS_TOKEN = ""
+ACCESS_TOKEN_SECRET = ""
+
+def twitter_oauth_consumer
+  @twitter_oauth_consumer ||= OAuth::Consumer.new(CONSUMER_KEY, CONSUMER_SECRET, :site => "http://twitter.com")
+end
+
+def twitter_oauth_access_token
+  @twitter_oauth_access_token ||= OAuth::AccessToken.new(twitter_oauth_consumer, ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
+end
+
+EM.run do
+
+  request = EventMachine::HttpRequest.new('http://twitter.com/statuses/update.json')
+  http = request.post(:body => {'status' => 'Hello Twitter from em-http-request with OAuth'}, :head => {"Content-Type" => "application/x-www-form-urlencoded"}) do |client|
+    twitter_oauth_consumer.sign!(client, twitter_oauth_access_token)
+  end
+
+  http.callback do
+    puts "Response: #{http.response} (Code: #{http.response_header.status})"
+    EM.stop_event_loop
+  end
+
+  http.errback do
+    puts "Failed to post"
+    EM.stop_event_loop
+  end
+
+end

data/ext/http11_client/http11_client.c

@@ -27,6 +27,7 @@ void client_http_field(void *data, const char *field, size_t flen, const char *v
   VALUE req = (VALUE)data;
   VALUE v = Qnil;
   VALUE f = Qnil;
+  VALUE el = Qnil;
 
   v = rb_str_new(value, vlen);
   f = rb_str_new(field, flen);
@@ -41,7 +42,18 @@ void client_http_field(void *data, const char *field, size_t flen, const char *v
     }
   }
 
-  rb_hash_aset(req, f, v);
+  el = rb_hash_lookup(req, f);
+  switch(TYPE(el)) {
+    case T_ARRAY:
+      rb_ary_push(el, v);
+      break;
+    case T_STRING:
+      rb_hash_aset(req, f, rb_ary_new3(2, el, v));
+      break;
+    default:
+      rb_hash_aset(req, f, v);
+      break;
+  }
 }
 
 void client_reason_phrase(void *data, const char *at, size_t length)

data/lib/em-http/client.rb

@@ -212,7 +212,7 @@ module EventMachine
         # if connecting via proxy, then state will be :proxy_connected,
         # indicating successful tunnel. from here, initiate normal http
         # exchange
-      else  
+      else
         @state = :response_header
                       
         ssl = @options[:tls] || @options[:ssl] || {}
@@ -246,14 +246,43 @@ module EventMachine
       @stream = blk
     end
 
+    # raw data push from the client (WebSocket) should
+    # only be invoked after handshake, otherwise it will
+    # inject data into the header exchange
+    #
+    # frames need to start with 0x00-0x7f byte and end with
+    # an 0xFF byte. Per spec, we can also set the first
+    # byte to a value betweent 0x80 and 0xFF, followed by
+    # a leading length indicator
+    def send(data)
+      if @state == :websocket
+        send_data("\x00#{data}\xff")
+      end
+    end
+
     def normalize_body
-      if @options[:body].is_a? Hash
-        @options[:body].to_params
-      else
-        @options[:body]
+      @normalized_body ||= begin
+        if @options[:body].is_a? Hash
+          @options[:body].to_params
+        else
+          @options[:body]
+        end
+      end
+    end
+    
+    def normalize_uri
+      @normalized_uri ||= begin
+        uri = @uri.dup
+        encoded_query = encode_query(@uri.path, @options[:query], @uri.query)
+        path, query = encoded_query.split("?", 2)
+        uri.query = query unless encoded_query.empty?
+        uri.path  = path
+        uri
       end
     end
-                  
+
+    def websocket?; @uri.scheme == 'ws'; end
+    
     def send_request_header
       query   = @options[:query]
       head    = @options[:head] ? munge_header_keys(@options[:head]) : {}
@@ -267,7 +296,12 @@ module EventMachine
         head = proxy[:head] ? munge_header_keys(proxy[:head]) : {}
         head['proxy-authorization'] = proxy[:authorization] if proxy[:authorization]
         request_header = HTTP_REQUEST_HEADER % ['CONNECT', "#{@uri.host}:#{@uri.port}"]
-
+        
+      elsif websocket?
+        head['upgrade'] = 'WebSocket'
+        head['connection'] = 'Upgrade'
+        head['origin'] = @options[:origin] || @uri.host
+        
       else
         # Set the Content-Length if body is given
         head['content-length'] =  body.length if body
@@ -283,7 +317,7 @@ module EventMachine
         end
       end
 
-       # Set the Host header if it hasn't been specified already
+      # Set the Host header if it hasn't been specified already
       head['host'] ||= encode_host
 
       # Set the User-Agent if it hasn't been specified
@@ -357,6 +391,8 @@ module EventMachine
           process_response_footer
         when :body
           process_body
+        when :websocket
+          process_websocket
         when :finished, :invalid
           break
         else raise RuntimeError, "invalid state: #{@state}"
@@ -435,7 +471,15 @@ module EventMachine
         on_request_complete
       end
 
-      if @response_header.chunked_encoding?
+      if websocket?
+        if @response_header.status == 101
+          @state = :websocket
+          succeed
+        else
+          fail "websocket handshake failed"
+        end
+       
+      elsif @response_header.chunked_encoding?
         @state = :chunk_header
       elsif @response_header.content_length
         @state = :body
@@ -554,7 +598,23 @@ module EventMachine
       false
     end
 
-  
+    def process_websocket
+      return false if @data.empty?
+
+      # slice the message out of the buffer and pass in
+      # for processing, and buffer data otherwise
+      buffer = @data.read
+      while msg = buffer.slice!(/\000([^\377]*)\377/)
+        msg.gsub!(/^\x00|\xff$/, '')
+        @stream.call(msg)
+      end
+
+      # store remainder if message boundary has not yet
+      # been recieved
+      @data << buffer if not buffer.empty?
+
+      false
+    end
   end
 
 end

data/lib/em-http/mock.rb

@@ -1,11 +1,12 @@
 module EventMachine
-  class HttpRequest
+  class MockHttpRequest < EventMachine::HttpRequest
     
     include HttpEncoding
     
     class FakeHttpClient < EventMachine::HttpClient
 
-      def setup(response)
+      def setup(response, uri)
+        @uri = uri
         receive_data(response)
         succeed(self) 
       end
@@ -56,12 +57,12 @@ module EventMachine
     alias_method :real_send_request, :send_request
     
     protected
-    def send_request
+    def send_request(&blk)
       query = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}#{encode_query(@uri.path, @options[:query], @uri.query)}"
       if s = @@registry[query] and fake = s[@method]
         @@registry_count[query][@method] += 1
         client = FakeHttpClient.new(nil)
-        client.setup(fake)
+        client.setup(fake, @uri)
         client
       elsif @@pass_through_requests
         real_send_request

data/lib/em-http/request.rb

@@ -47,15 +47,15 @@ module EventMachine
     #     OK then)
     #
                                    
-    def get    options = {};  setup_request(:get,  options);    end
-    def head   options = {};  setup_request(:head, options);    end
-    def delete options = {};  setup_request(:delete, options);  end
-    def put    options = {};  setup_request(:put, options);     end
-    def post   options = {};  setup_request(:post, options);    end
+    def get    options = {}, &blk;  setup_request(:get,  options, &blk);    end
+    def head   options = {}, &blk;  setup_request(:head, options, &blk);    end
+    def delete options = {}, &blk;  setup_request(:delete, options, &blk);  end
+    def put    options = {}, &blk;  setup_request(:put, options, &blk);     end
+    def post   options = {}, &blk;  setup_request(:post, options, &blk);    end
 
     protected
 
-    def setup_request(method, options)
+    def setup_request(method, options, &blk)
       raise ArgumentError, "invalid request path" unless /^\// === @uri.path
       @options = options
       
@@ -76,10 +76,10 @@ module EventMachine
       @port_to_connect ||= 80
       
       @method = method.to_s.upcase
-      send_request
+      send_request(&blk)
     end
     
-    def send_request
+    def send_request(&blk)
       begin
        EventMachine.connect(@host_to_connect, @port_to_connect, EventMachine::HttpClient) { |c|
           c.uri = @uri
@@ -87,6 +87,7 @@ module EventMachine
           c.options = @options
           c.comm_inactivity_timeout = @options[:timeout]
           c.pending_connect_timeout = @options[:timeout]
+          blk.call(c) unless blk.nil?
         }
       rescue EventMachine::ConnectionError => e
         conn = EventMachine::HttpClient.new("")

data/spec/hash_spec.rb

@@ -0,0 +1,24 @@
+require 'spec/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.split("&").should include "a=alpha"
+      {:a => "alpha", :b => "beta"}.to_params.split("&").should include "b=beta"
+    end
+    
+    it "should transform a more complex hash into HTTP POST Params" do
+      {:a => "a", :b => ["c", "d", "e"]}.to_params.split("&").should include "a=a"
+      {:a => "a", :b => ["c", "d", "e"]}.to_params.split("&").should include "b[0]=c"
+      {:a => "a", :b => ["c", "d", "e"]}.to_params.split("&").should include "b[1]=d"
+      {:a => "a", :b => ["c", "d", "e"]}.to_params.split("&").should include "b[2]=e"
+    end
+
+    it "should transform a very complex hash into HTTP POST Params" do
+      params = {:a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]}.to_params.split("&")
+      params.should include "a=a"
+      params.should include "b[0][d]=d"
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'spec'
+require 'pp'
+
+require 'lib/em-http'
+require 'lib/em-http/mock'
+require 'em-websocket'

data/{test/mock/test_mock.rb → spec/mock_spec.rb}

@@ -1,32 +1,25 @@
-require 'rubygems'
-require 'spec'
-require 'pp'
-
-require 'lib/em-http'
-require 'lib/em-http/mock'
+require 'spec/helper'
 
 describe 'em-http mock' do
 
   before(:each) do
-    EM::HttpRequest.reset_registry!
-    EM::HttpRequest.reset_counts!
+    EventMachine::MockHttpRequest.reset_registry!
+    EventMachine::MockHttpRequest.reset_counts!
   end
   
   it "should serve a fake http request from a file" do
-    EM::HttpRequest.register_file('http://www.google.ca:80/', :get, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
-    EM.run do 
-      http = EM::HttpRequest.new('http://www.google.ca/').get
-      http.callback do
+    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EM.run {
+      
+      http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
+      http.errback { fail }
+      http.callback {
         http.response.should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'google.ca')).split("\n\n", 2).last
-        EM.stop
-      end
-      http.errback do
-        fail
-        EM.stop
-      end
-    end
+        EventMachine.stop
+      }
+    }
     
-    EM::HttpRequest.count('http://www.google.ca:80/', :get).should == 1
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get).should == 1
   end
   
   it "should serve a fake http request from a string" do
@@ -52,32 +45,28 @@ window._gjp && _gjp()</script><style>td{line-height:.8em;}.gac_m td{line-height:
 ;google.y.first.push(function(){google.ac.b=true;google.ac.i(document.f,document.f.q,'','')});google.xjs&&google.j&&google.j.xi&&google.j.xi()</script></div><script>(function(){
 function a(){google.timers.load.t.ol=(new Date).getTime();google.report&&google.timers.load.t.xjs&&google.report(google.timers.load,google.kCSI)}if(window.addEventListener)window.addEventListener("load",a,false);else if(window.attachEvent)window.attachEvent("onload",a);google.timers.load.t.prt=(new Date).getTime();
 })();
-HEREDOC
-    EM::HttpRequest.register('http://www.google.ca:80/', :get, data)
-    EM.run do 
-      http = EM::HttpRequest.new('http://www.google.ca/').get
-      http.callback do
+    HEREDOC
+    EventMachine::MockHttpRequest.register('http://www.google.ca:80/', :get, data)
+    EventMachine.run {
+      
+      http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
+      http.errback { fail }
+      http.callback {
         http.response.should == data.split("\n\n", 2).last
-        EM.stop
-      end
-      http.errback do
-        fail
-        EM.stop
-      end
-    end
+        EventMachine.stop
+      }
+    }
     
-    EM::HttpRequest.count('http://www.google.ca:80/', :get).should == 1
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get).should == 1
   end
 
   it "should raise an exception if pass-thru is disabled" do
-    EM::HttpRequest.pass_through_requests = false
-    EM.run do 
+    EventMachine::MockHttpRequest.pass_through_requests = false
+    EventMachine.run {
       proc {
-        http = EM::HttpRequest.new('http://www.google.ca/').get
+        http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
       }.should raise_error
-      EM.stop
-    end
-    
+      EventMachine.stop
+    }
   end
-  
 end

data/{test/test_multi.rb → spec/multi_spec.rb}

@@ -1,5 +1,5 @@
-require 'test/helper'
-require 'test/stallion'
+require 'spec/helper'
+require 'spec/stallion'
 
 describe EventMachine::MultiRequest do
 

data/{test/test_request.rb → spec/request_spec.rb}

@@ -1,14 +1,14 @@
-require 'test/helper'
-require 'test/stallion'
-require 'test/stub_server'
- 
+require 'spec/helper'
+require 'spec/stallion'
+require 'spec/stub_server'
+
 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 :timeout => 1
@@ -17,7 +17,7 @@ describe EventMachine::HttpRequest do
         http.response_header.status.should == 0
         EventMachine.stop
       }
-    }         
+    }
   end
 
   it "should fail GET on invalid host" do
@@ -54,7 +54,7 @@ describe EventMachine::HttpRequest do
       }
     }
   end
-  
+
   it "should perform successfull GET with a URI passed as argument" do
     EventMachine.run {
       uri = URI.parse('http://127.0.0.1:8080/')
@@ -66,7 +66,7 @@ describe EventMachine::HttpRequest do
         http.response.should match(/Hello/)
         EventMachine.stop
       }
-    }    
+    }
   end
 
   it "should perform successfull HEAD with a URI passed as argument" do
@@ -80,9 +80,9 @@ describe EventMachine::HttpRequest do
         http.response.should == ""
         EventMachine.stop
       }
-    }    
+    }
   end
-  
+
   # should be no different than a GET
   it "should perform successfull DELETE with a URI passed as argument" do
     EventMachine.run {
@@ -95,7 +95,7 @@ describe EventMachine::HttpRequest do
         http.response.should == ""
         EventMachine.stop
       }
-    }    
+    }
   end
 
   it "should return 404 on invalid path" do
@@ -103,7 +103,7 @@ describe EventMachine::HttpRequest do
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/fail').get
 
       http.errback { failed }
-      http.callback { 
+      http.callback {
         http.response_header.status.should == 404
         EventMachine.stop
       }
@@ -183,13 +183,13 @@ describe EventMachine::HttpRequest do
       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"}
@@ -197,7 +197,7 @@ describe EventMachine::HttpRequest do
       http.errback { failed }
       http.callback {
         http.response_header.status.should == 200
-        
+
         http.response.to_i.should == 10
         EventMachine.stop
       }
@@ -223,7 +223,7 @@ describe EventMachine::HttpRequest do
       http = EventMachine::HttpRequest.new('http://digg.com/').get
 
       http.errback { failed }
-      http.callback { 
+      http.callback {
         http.response_header.status.should == 200
         EventMachine.stop
       }
@@ -242,8 +242,8 @@ describe EventMachine::HttpRequest do
       }
     }
   end
-  
-  it "should send proper OAuth auth header" do 
+
+  it "should send proper OAuth auth header" do
     EventMachine.run {
       oauth_header = 'OAuth oauth_nonce="oqwgSYFUD87MHmJJDv7bQqOF2EPnVus7Wkqj5duNByU", b=c, d=e'
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/oauth_auth').get :head => {'authorization' => oauth_header}
@@ -254,7 +254,7 @@ describe EventMachine::HttpRequest do
         http.response.should == oauth_header
         EventMachine.stop
       }
-    } 
+    }
   end
 
   it "should work with keep-alive servers" do
@@ -318,7 +318,7 @@ describe EventMachine::HttpRequest do
   it "should optionally pass the response body progressively" do
     EventMachine.run {
       body = ''
-      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get 
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
 
       http.errback { failed }
       http.stream { |chunk| body += chunk }
@@ -461,7 +461,7 @@ describe EventMachine::HttpRequest do
       }
     end
 
-     it "should not override content-type when passing in ruby hash/array for body" do
+    it "should not override content-type when passing in ruby hash/array for body" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post({
             :body => {:a => :b}, :head => {'content-type' => 'text'}})
@@ -480,44 +480,153 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/relative-location').get
 
-        http.errback { failed }
-        http.callback {
-          http.response_header['LOCATION'].should == 'http://127.0.0.1:8080/forwarded'
-          EventMachine.stop
-        }
+      http.errback { failed }
+      http.callback {
+        http.response_header['LOCATION'].should == 'http://127.0.0.1:8080/forwarded'
+        EventMachine.stop
       }
+    }
   end   
   
+  it 'should let you pass a block to be called once the client is created' do
+    client = nil
+    EventMachine.run {
+      request = EventMachine::HttpRequest.new('http://127.0.0.1:8080/')
+      http = request.post { |c|
+        c.options[:body] = {:callback_run => 'yes'}
+        client = c
+      }
+      http.errback { failed }
+      http.callback {
+        client.should be_kind_of(EventMachine::HttpClient)
+        http.response_header.status.should == 200
+        http.response.should match(/callback_run=yes/)
+        client.normalize_uri.should == Addressable::URI.parse('http://127.0.0.1:8080/')
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should retrieve multiple cookies" do
+    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EventMachine.run {
+
+      http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
+      http.errback { fail }
+      http.callback {
+        c1 = "PREF=ID=9454187d21c4a6a6:TM=1258403955:LM=1258403955:S=2-mf1n5oV5yAeT9-; expires=Wed, 16-Nov-2011 20:39:15 GMT; path=/; domain=.google.ca"
+        c2 = "NID=28=lvxxVdiBQkCetu_WFaUxLyB7qPlHXS5OdAGYTqge_laVlCKVN8VYYeVBh4bNZiK_Oan2gm8oP9GA-FrZfMPC3ZMHeNq37MG2JH8AIW9LYucU8brOeuggMEbLNNXuiWg4; expires=Tue, 18-May-2010 20:39:15 GMT; path=/; domain=.google.ca; HttpOnly"
+        http.response_header.cookie.should == [c1, c2]
+
+        EventMachine.stop
+      }
+    }
+
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get).should == 1
+  end
+
   context "connections via proxy" do
-    
+
     it "should work with proxy servers" do
       EventMachine.run {
 
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :proxy => {:host => '127.0.0.1', :port => 8082}
 
         http.errback { p http.inspect; failed }
-        http.callback { 
+        http.callback {
           http.response_header.status.should == 200
           http.response.should == 'Hello, World!'
           EventMachine.stop
         }
       }
-    end 
+    end
 
     it "should proxy POST data" do
       EventMachine.run {
 
-         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post({
-           :body => "data", :proxy => {:host => '127.0.0.1', :port => 8082}})
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post({
+            :body => "data", :proxy => {:host => '127.0.0.1', :port => 8082}})
 
-         http.errback { failed }
-         http.callback { 
-           http.response_header.status.should == 200
-           http.response.should match(/data/)
-           EventMachine.stop
-         }
-       }
-     end
-     
+        http.errback { failed }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response.should match(/data/)
+          EventMachine.stop
+        }
+      }
+    end
+  end
+
+  context "websocket connection" do
+    # Spec: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-55
+    #
+    # ws.onopen     = http.callback
+    # ws.onmessage  = http.stream { |msg| }
+    # ws.errback    = no connection
+    #
+
+    it "should invoke errback on failed upgrade" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('ws://127.0.0.1:8080/').get :timeout => 0
+
+        http.callback { failed }
+        http.errback {
+          http.response_header.status.should == 200
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should complete websocket handshake and transfer data from client to server and back" do
+      EventMachine.run {
+        MSG = "hello bi-directional data exchange"
+
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8085) do |ws|
+          ws.onmessage {|msg| ws.send msg}
+        end
+
+        http = EventMachine::HttpRequest.new('ws://127.0.0.1:8085/').get :timeout => 1
+        http.errback { failed }
+        http.callback {
+          http.response_header.status.should == 101
+          http.response_header['CONNECTION'].should match(/Upgrade/)
+          http.response_header['UPGRADE'].should match(/WebSocket/)
+
+          # push should only be invoked after handshake is complete
+          http.send(MSG)
+        }
+        
+        http.stream { |chunk|
+          chunk.should == MSG
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should split multiple messages from websocket server into separate stream callbacks" do
+      EM.run do
+        messages = %w[1 2]
+        recieved = []
+
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8085) do |ws|
+          ws.onopen {
+            ws.send messages[0]
+            ws.send messages[1]
+          }
+        end
+
+        EventMachine.add_timer(0.1) do
+          http = EventMachine::HttpRequest.new('ws://127.0.0.1:8085/').get :timeout => 0
+          http.errback { failed }
+          http.callback { http.response_header.status.should == 101 }
+          http.stream {|msg|
+            msg.should == messages[recieved.size]
+            recieved.push msg
+
+            EventMachine.stop if recieved.size == messages.size
+          }
+        end
+      end
+    end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: em-http-request
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors: 
 - Ilya Grigorik
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-12 00:00:00 -05:00
+date: 2009-12-31 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,7 @@ files:
 - VERSION
 - examples/fetch.rb
 - examples/fibered-http.rb
+- examples/oauth-tweet.rb
 - ext/buffer/em_buffer.c
 - ext/buffer/extconf.rb
 - ext/http11_client/ext_help.h
@@ -65,14 +66,14 @@ files:
 - lib/em-http/mock.rb
 - lib/em-http/multi.rb
 - lib/em-http/request.rb
-- test/helper.rb
-- test/mock/fixtures/google.ca
-- test/mock/test_mock.rb
-- test/stallion.rb
-- test/stub_server.rb
-- test/test_hash.rb
-- test/test_multi.rb
-- test/test_request.rb
+- spec/fixtures/google.ca
+- spec/hash_spec.rb
+- spec/helper.rb
+- spec/mock_spec.rb
+- spec/multi_spec.rb
+- spec/request_spec.rb
+- spec/stallion.rb
+- spec/stub_server.rb
 has_rdoc: true
 homepage: http://github.com/igrigorik/em-http-request
 licenses: []
@@ -102,12 +103,13 @@ signing_key:
 specification_version: 3
 summary: EventMachine based, async HTTP Request interface
 test_files: 
-- test/helper.rb
-- test/mock/test_mock.rb
-- test/stallion.rb
-- test/stub_server.rb
-- test/test_hash.rb
-- test/test_multi.rb
-- test/test_request.rb
+- spec/hash_spec.rb
+- spec/helper.rb
+- spec/mock_spec.rb
+- spec/multi_spec.rb
+- spec/request_spec.rb
+- spec/stallion.rb
+- spec/stub_server.rb
 - examples/fetch.rb
 - examples/fibered-http.rb
+- examples/oauth-tweet.rb

data/test/helper.rb

@@ -1,5 +0,0 @@
-require 'rubygems'
-require 'spec'
-require 'pp'
-
-require 'lib/em-http'

data/test/test_hash.rb

@@ -1,19 +0,0 @@
-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