ably-em-http-request 1.1.8

data/spec/middleware/oauth2_spec.rb

@@ -0,0 +1,15 @@
+describe EventMachine::AblyHttpRequest::Middleware::OAuth2 do
+  it "should add an access token to a URI with no query parameters" do
+    middleware = EventMachine::AblyHttpRequest::Middleware::OAuth2.new(:access_token => "fedcba9876543210")
+    uri = Addressable::URI.parse("https://graph.facebook.com/me")
+    middleware.update_uri! uri
+    uri.to_s.should == "https://graph.facebook.com/me?access_token=fedcba9876543210"
+  end
+
+  it "should add an access token to a URI with query parameters" do
+    middleware = EventMachine::AblyHttpRequest::Middleware::OAuth2.new(:access_token => "fedcba9876543210")
+    uri = Addressable::URI.parse("https://graph.facebook.com/me?fields=photo")
+    middleware.update_uri! uri
+    uri.to_s.should == "https://graph.facebook.com/me?fields=photo&access_token=fedcba9876543210"
+  end
+end

data/spec/middleware_spec.rb

@@ -0,0 +1,143 @@
+require 'helper'
+
+describe EventMachine::AblyHttpRequest::HttpRequest do
+
+  class EmptyMiddleware; end
+
+  class GlobalMiddleware
+    def response(resp)
+      resp.response_header['X-Global'] = 'middleware'
+    end
+  end
+
+  it "should accept middleware" do
+    EventMachine.run {
+      lambda {
+        conn = EM::AblyHttpRequest::HttpRequest.new('http://127.0.0.1:8090')
+        conn.use ResponseMiddleware
+        conn.use EmptyMiddleware
+
+        EM.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
+      EventMachine.run {
+        conn = EM::AblyHttpRequest::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')
+          EM.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
+      EventMachine.run {
+        conn = EM::AblyHttpRequest::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!')
+          EM.stop
+        }
+      }
+    end
+
+    it "should execute global response middleware before user callbacks" do
+      EventMachine.run {
+        EM::AblyHttpRequest::HttpRequest.use GlobalMiddleware
+
+        conn = EM::AblyHttpRequest::HttpRequest.new('http://127.0.0.1:8090')
+
+        req = conn.get
+        req.callback {
+          req.response_header['X-Global'].should match('middleware')
+          EM.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
+      EventMachine.run {
+        conn = EventMachine::AblyHttpRequest::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/)
+          EventMachine.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
+      EventMachine.run {
+        conn = EventMachine::AblyHttpRequest::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"}
+          EventMachine.stop
+        }
+      }
+    end
+  end
+
+end

data/spec/multi_spec.rb

@@ -0,0 +1,104 @@
+require 'helper'
+require 'stallion'
+
+describe EventMachine::AblyHttpRequest::MultiRequest do
+
+  let(:multi) { EventMachine::AblyHttpRequest::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
+    EventMachine.run {
+      multi.add :a, EventMachine::AblyHttpRequest::HttpRequest.new(url).get
+      multi.add :b, EventMachine::AblyHttpRequest::HttpRequest.new(url).post
+      multi.add :c, EventMachine::AblyHttpRequest::HttpRequest.new(url).head
+      multi.add :d, EventMachine::AblyHttpRequest::HttpRequest.new(url).delete
+      multi.add :e, EventMachine::AblyHttpRequest::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
+
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should require unique keys for each deferrable" do
+    lambda do
+      multi.add :df1, EM::DefaultDeferrable.new
+      multi.add :df1, EM::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
+      EventMachine.run {
+        request1 = EventMachine::AblyHttpRequest::HttpRequest.new(url).get
+        request2 = EventMachine::AblyHttpRequest::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)
+
+          EventMachine.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
+      EventMachine.run {
+        multi.add :a, EventMachine::AblyHttpRequest::HttpRequest.new(url).get
+        multi.should_not be_finished
+
+        EventMachine.stop
+      }
+    end
+
+    it "should be finished when all requests are finished" do
+      EventMachine.run {
+        multi.add :a, EventMachine::AblyHttpRequest::HttpRequest.new(url).get
+        multi.callback {
+          multi.should be_finished
+
+          EventMachine.stop
+        }
+      }
+    end
+  end
+
+end

data/spec/pipelining_spec.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+describe EventMachine::AblyHttpRequest::HttpRequest do
+
+  it "should perform successful pipelined GETs" do
+    EventMachine.run do
+
+      # Mongrel doesn't support pipelined requests - bah!
+      conn = EventMachine::AblyHttpRequest::HttpRequest.new('http://www.bing.com/')
+
+      pipe1 = conn.get :keepalive => true
+      pipe2 = conn.get :path => '/news', :keepalive => true
+
+      processed = 0
+      stop = proc { EM.stop if processed == 2}
+
+      pipe1.errback { failed(conn) }
+      pipe1.callback {
+        processed += 1
+        pipe1.response_header.status.should == 200
+        stop.call
+      }
+
+      pipe2.errback { failed(conn) }
+      pipe2.callback {
+        processed += 1
+        pipe2.response_header.status.should == 200
+        pipe2.response.should match(/html/i)
+        stop.call
+      }
+
+    end
+  end
+
+  it "should perform successful pipelined HEAD requests" do
+    EventMachine.run do
+      conn = EventMachine::AblyHttpRequest::HttpRequest.new('http://www.bing.com/')
+
+      pipe1 = conn.head :keepalive => true
+      pipe2 = conn.head :path => '/news', :keepalive => true
+
+      processed = 0
+      stop = proc { EM.stop if processed == 2}
+
+      pipe1.errback { failed(conn) }
+      pipe1.callback {
+        processed += 1
+        pipe1.response_header.status.should == 200
+        stop.call
+      }
+
+      pipe2.errback { failed(conn) }
+      pipe2.callback {
+        processed += 1
+        pipe2.response_header.status.should == 200
+        stop.call
+      }
+
+    end
+
+  end
+end