experella-proxy 0.0.10 → 0.0.11

data/spec/experella-proxy/backend_server_spec.rb

@@ -2,18 +2,18 @@ require 'spec_helper'
 
 describe ExperellaProxy::BackendServer do
 
-  let(:backend) {
-    ExperellaProxy::BackendServer.new("host", "port", {:concurrency => "2", :name => "name",
-                                                       :accepts => {"Host" => "experella", :path => "ella"},
-                                                       :mangle => {"Connection" => "close"}
-                                                      })
-  }
-  let(:min_backend) {
+  let(:backend) do
+    ExperellaProxy::BackendServer.new("host", "port", :concurrency => "2", :name => "name",
+                                                       :accepts => { "Host" => "experella", :path => "ella" },
+                                                       :mangle => { "Connection" => "close" }
+                                                      )
+  end
+  let(:min_backend) do
     ExperellaProxy::BackendServer.new("host", "port")
-  }
-  let(:matcher) {
+  end
+  let(:matcher) do
     backend.message_matcher
-  }
+  end
 
   describe "#new" do
 
@@ -45,7 +45,7 @@ describe ExperellaProxy::BackendServer do
     end
 
     it "mangle should be nil" do
-      backend.mangle.should == {:Connection => "close"}
+      backend.mangle.should == { :Connection => "close" }
       min_backend.mangle.should be_nil
     end
 
@@ -64,14 +64,12 @@ describe ExperellaProxy::BackendServer do
 
   describe "#accept?" do
 
-
     it "returns false if desired request header missing" do
       request = ExperellaProxy::Request.new("")
       request.update_header(:request_url => "/docs")
       backend.accept?(request).should be_false
     end
 
-
     it "returns false if request headers doesn't match the message_matcher" do
       request = ExperellaProxy::Request.new("")
       request.update_header(:Host => "experella.com", :request_url => "/docs")
@@ -81,15 +79,15 @@ describe ExperellaProxy::BackendServer do
     end
 
     it "accepts a block as message matcher" do
-      lambdaBackend = ExperellaProxy::BackendServer.new("host", "port", {:concurrency => "2", :name => "name",
-                                                         :accepts => lambda { |req|
+      lambdaBackend = ExperellaProxy::BackendServer.new("host", "port", :concurrency => "2", :name => "name",
+                                                         :accepts => lambda do |req|
                                                            if req.header[:Host] == "google.com"
                                                              true
                                                            else
                                                              false
                                                            end
-                                                         }
-      })
+                                                         end
+      )
       request = ExperellaProxy::Request.new("")
       request.update_header(:Host => "google.com", :request_url => "/docs")
       lambdaBackend.accept?(request).should be_true
@@ -106,4 +104,4 @@ describe ExperellaProxy::BackendServer do
 
   end
 
-end
+end

data/spec/experella-proxy/configuration_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe ExperellaProxy::Configuration do
-  let(:config) {
+  let(:config) do
     ExperellaProxy.config
-  }
+  end
 
   it "should load a config file" do
     config.backends.size.should == 4
@@ -17,7 +17,7 @@ describe ExperellaProxy::Configuration do
   end
 
   it "should raise NoConfigError if config filepath doesn't exist" do
-    lambda { config.read_config_file("/a/non/existing/filepath")
-    }.should raise_error(ExperellaProxy::Configuration::NoConfigError)
+    lambda do config.read_config_file("/a/non/existing/filepath")
+    end.should raise_error(ExperellaProxy::Configuration::NoConfigError)
   end
 end

data/spec/experella-proxy/connection_manager_spec.rb

@@ -2,13 +2,12 @@ require 'spec_helper'
 
 describe ExperellaProxy::ConnectionManager do
 
-  let(:manager) {
+  let(:manager) do
     ExperellaProxy::ConnectionManager.new
-  }
+  end
 
   class Testconnection
-
-    def initialize()
+    def initialize
       @request = ExperellaProxy::Request.new(self)
     end
 
@@ -41,8 +40,8 @@ describe ExperellaProxy::ConnectionManager do
       manager.add_backend(ExperellaProxy::BackendServer.new("host", "port"))
       manager.backend_count.should == 1
       manager.backend_queue_count.should == 1
-      manager.backend_available?(Testconnection.new().get_request)
-      manager.backend_available?(Testconnection.new().get_request)
+      manager.backend_available?(Testconnection.new.get_request)
+      manager.backend_available?(Testconnection.new.get_request)
       manager.backend_count.should == 1
       manager.backend_queue_count.should == 0
       manager.connection_count.should == 1
@@ -76,8 +75,8 @@ describe ExperellaProxy::ConnectionManager do
     it "should return a connection if any queued conn matches" do
       backend = ExperellaProxy::BackendServer.new("host", "port")
       manager.add_backend(backend)
-      manager.backend_available?(Testconnection.new().get_request)
-      manager.backend_available?(Testconnection.new().get_request)
+      manager.backend_available?(Testconnection.new.get_request)
+      manager.backend_available?(Testconnection.new.get_request)
       ret = manager.free_backend(backend)
       ret.should be_an_instance_of Testconnection
     end
@@ -85,11 +84,11 @@ describe ExperellaProxy::ConnectionManager do
     it "should return nil and requeue backend if no conn matches" do
       backend = ExperellaProxy::BackendServer.new("host", "port")
       manager.add_backend(backend)
-      manager.backend_available?(Testconnection.new().get_request)
+      manager.backend_available?(Testconnection.new.get_request)
       backend_queue = manager.backend_queue_count
       workload = backend.workload
       ret = manager.free_backend(backend)
-      ret.should == nil
+      ret.should.nil?
       manager.backend_queue_count.should == (backend_queue + 1)
       backend.workload.should == (workload - 1)
     end
@@ -101,8 +100,8 @@ describe ExperellaProxy::ConnectionManager do
       backend = ExperellaProxy::BackendServer.new("host", "port")
       manager.add_backend(backend)
       connections = []
-      connections[1] = Testconnection.new()
-      connections[2] = Testconnection.new()
+      connections[1] = Testconnection.new
+      connections[2] = Testconnection.new
       manager.backend_available?(connections[1].get_request)
       manager.backend_available?(connections[2].get_request)
       count_before = manager.connection_count
@@ -113,9 +112,9 @@ describe ExperellaProxy::ConnectionManager do
 
   describe "#backend_available?" do
     before(:each) do
-      manager.add_backend(ExperellaProxy::BackendServer.new("host", "port", {:concurrency => 3, :accepts => {"Host" => "test"}}))
-      manager.add_backend(ExperellaProxy::BackendServer.new("host2", "port", {:accepts => {"Host" => "bla"}}))
-      manager.add_backend(ExperellaProxy::BackendServer.new("host3", "port", {:accepts => {"Host" => "blax"}}))
+      manager.add_backend(ExperellaProxy::BackendServer.new("host", "port", :concurrency => 3, :accepts => { "Host" => "test" }))
+      manager.add_backend(ExperellaProxy::BackendServer.new("host2", "port", :accepts => { "Host" => "bla" }))
+      manager.add_backend(ExperellaProxy::BackendServer.new("host3", "port", :accepts => { "Host" => "blax" }))
     end
     it "returns first matching backend and removes it from queue" do
       conn = Testconnection.new
@@ -156,4 +155,4 @@ describe ExperellaProxy::ConnectionManager do
 
   end
 
-end
+end

data/spec/experella-proxy/experella-proxy_spec.rb

@@ -22,23 +22,23 @@ describe ExperellaProxy do
 
   # static testnames send to spawned experella for simplecov
   ENV_TESTNAMES = {
-    "should get response from the echoserver via the proxy" => "response",
-    "should respond with 404" => "404",
-    "should respond with 400 on malformed request" => "400",
-    "should respond with 503" => "503",
-    "should reuse keep-alive connections" => "keep-alive",
+    "should get response from the echoserver via the proxy"                => "response",
+    "should respond with 404"                                              => "404",
+    "should respond with 400 on malformed request"                         => "400",
+    "should respond with 503"                                              => "503",
+    "should reuse keep-alive connections"                                  => "keep-alive",
     "should handle chunked post requests and strip invalid Content-Length" => "chunked-request",
-    "should rechunk and stream Transfer-Encoding chunked responses" => "chunked-response",
-    "should timeout inactive connections after config.timeout" => "timeout",
-    "should handle pipelined requests correctly" => "pipelined",
-    "should accept requests on all set proxy domains" => "multiproxy",
-    "should be able to handle post requests" => "post"
+    "should rechunk and stream Transfer-Encoding chunked responses"        => "chunked-response",
+    "should timeout inactive connections after config.timeout"             => "timeout",
+    "should handle pipelined requests correctly"                           => "pipelined",
+    "should accept requests on all set proxy domains"                      => "multiproxy",
+    "should be able to handle post requests"                               => "post"
   }
 
   describe "EchoServer" do
     before :each do
       @pid = spawn("ruby", "#{echo_server}", "127.0.0.10", "7654")
-      sleep(0.8) #let the server startup, specs may fail if this is set to low
+      sleep(0.8) # let the server startup, specs may fail if this is set to low
     end
     after :each do
       Process.kill('QUIT', @pid)
@@ -46,9 +46,9 @@ describe ExperellaProxy do
     end
 
     it "should get response from the echoserver" do
-      lambda {
+      lambda do
         EM.run do
-          http = EventMachine::HttpRequest.new("http://127.0.0.10:7654").get({:connect_timeout => 1})
+          http = EventMachine::HttpRequest.new("http://127.0.0.10:7654").get(:connect_timeout => 1)
           http.errback {
             EventMachine.stop
             raise "http request failed"
@@ -58,7 +58,7 @@ describe ExperellaProxy do
             EventMachine.stop
           }
         end
-      }.should_not raise_error
+      end.should_not raise_error
     end
   end
 
@@ -68,9 +68,9 @@ describe ExperellaProxy do
         ENV["TESTNAME"] = ENV_TESTNAMES[test.example.description]
       end
       @pid = spawn("ruby", "#{echo_server}", "127.0.0.10", "7654")
-      @pid2 = spawn("#{experella_proxy}", "run", "--", "--config=#{File.join(File.dirname(__FILE__),"/../fixtures/test_config.rb")}")
-      sleep(0.8) #let the server startup, specs may fail if this is set to low
-      ExperellaProxy.init(:configfile => File.join(File.dirname(__FILE__),"/../fixtures/test_config.rb"))
+      @pid2 = spawn("#{experella_proxy}", "run", "--", "--config=#{File.join(File.dirname(__FILE__), "/../fixtures/test_config.rb")}")
+      sleep(0.8) # let the server startup, specs may fail if this is set to low
+      ExperellaProxy.init(:configfile => File.join(File.dirname(__FILE__), "/../fixtures/test_config.rb"))
       config.backends.each do |backend|
         connection_manager.add_backend(ExperellaProxy::BackendServer.new(backend[:host], backend[:port], backend))
       end
@@ -86,10 +86,10 @@ describe ExperellaProxy do
       log.info "should get response from the echoserver via the proxy"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
-            ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            ).get(:connect_timeout => 1, :head => { "Host" => "experella.com" })
             http.errback {
               EventMachine.stop
               raise "http request failed"
@@ -99,7 +99,7 @@ describe ExperellaProxy do
               EventMachine.stop
             }
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -107,18 +107,18 @@ describe ExperellaProxy do
       log.info "should respond with 404"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
 
             multi = EventMachine::MultiRequest.new
             multi_shuffle = []
-            multi_shuffle[0] = Proc.new {
+            multi_shuffle[0] = proc {
               multi.add :head, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
-              ).head({:connect_timeout => 1})
+              ).head(:connect_timeout => 1)
             }
-            multi_shuffle[1] = Proc.new {
+            multi_shuffle[1] = proc {
               multi.add :get, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
-              ).get({:connect_timeout => 1})
+              ).get(:connect_timeout => 1)
             }
             multi_shuffle.shuffle!
             multi_shuffle.each do |p|
@@ -137,9 +137,8 @@ describe ExperellaProxy do
               EventMachine.stop
             end
 
-
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -147,11 +146,11 @@ describe ExperellaProxy do
       log.info "should respond with 400 on malformed request"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
-            ).post({:connect_timeout => 1, :head => {"Host" => "experella.com", "Transfer-Encoding" => "chunked"},
-                   :body => "9\r\nMalformed\r\na\r\nchunked da\r\n2\rta HERE\r\n0\r\n\r\n"})
+            ).post(:connect_timeout => 1, :head => { "Host" => "experella.com", "Transfer-Encoding" => "chunked" },
+                   :body => "9\r\nMalformed\r\na\r\nchunked da\r\n2\rta HERE\r\n0\r\n\r\n")
             http.errback {
               EventMachine.stop
               raise "http request failed"
@@ -161,7 +160,7 @@ describe ExperellaProxy do
               EventMachine.stop
             }
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -169,18 +168,18 @@ describe ExperellaProxy do
       log.info "should respond with 503"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
 
             multi = EventMachine::MultiRequest.new
             multi_shuffle = []
-            multi_shuffle[0] = Proc.new {
+            multi_shuffle[0] = proc {
               multi.add :head, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}/oneroute"
-              ).head({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+              ).head(:connect_timeout => 1, :head => { "Host" => "experella.com" })
             }
-            multi_shuffle[1] = Proc.new {
+            multi_shuffle[1] = proc {
               multi.add :get, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}/anotherpath"
-              ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+              ).get(:connect_timeout => 1, :head => { "Host" => "experella.com" })
             }
             multi_shuffle.shuffle!
             multi_shuffle.each do |p|
@@ -199,9 +198,8 @@ describe ExperellaProxy do
               EventMachine.stop
             end
 
-
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -209,10 +207,10 @@ describe ExperellaProxy do
       log.info "should reuse keep-alive connections"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             conn = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}")
-            req1 = conn.get({:connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
+            req1 = conn.get(:connect_timeout => 1, :keepalive => true, :head => { "Host" => "experella.com" })
 
             req1.errback {
               EventMachine.stop
@@ -220,14 +218,14 @@ describe ExperellaProxy do
             }
             req1.callback {
               req1.response.should start_with "you sent: "
-              req2 = conn.get({:path => '/about/', :connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
+              req2 = conn.get(:path => '/about/', :connect_timeout => 1, :keepalive => true, :head => { "Host" => "experella.com" })
               req2.errback {
                 EventMachine.stop
                 raise "http request 2 failed"
               }
               req2.callback {
                 req2.response.should start_with "you sent: "
-                req3 = conn.get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+                req3 = conn.get(:connect_timeout => 1, :head => { "Host" => "experella.com" })
                 req3.errback {
                   EventMachine.stop
                   raise "http request 3 failed"
@@ -239,7 +237,7 @@ describe ExperellaProxy do
               }
             }
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -247,7 +245,7 @@ describe ExperellaProxy do
       log.info "should stream chunked post requests"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             # this will issue a Post Request with Content-Length AND Transfer-Encoding chunked, where the data is
             # correctly encoded in chunks. The Proxy should therefor strip the Content-Length and forward the data
@@ -265,10 +263,10 @@ describe ExperellaProxy do
             expected_body = String.new
             chunks = 20 + rand(20)
             # all alphanumeric characters
-            o = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map { |i| i.to_a }.flatten
-            while chunks > 0 do
-              #chunksize 10 to 1510 characters
-              string = (0...(10 + rand(1500))).map { o[rand(o.length)] }.join
+            o = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map{ |i| i.to_a }.flatten
+            while chunks > 0
+              # chunksize 10 to 1510 characters
+              string = (0...(10 + rand(1500))).map{ o[rand(o.length)] }.join
               body << string.size.to_s(16)
               body << "\r\n"
               body << string
@@ -279,8 +277,8 @@ describe ExperellaProxy do
             body << "0\r\n\r\n"
 
             http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
-            ).post({:connect_timeout => 1, :head => {"Host" => "experella.com", "Transfer-Encoding" => "chunked"},
-                   :body => body})
+            ).post(:connect_timeout => 1, :head => { "Host" => "experella.com", "Transfer-Encoding" => "chunked" },
+                   :body => body)
             http.errback {
               EventMachine.stop
               raise "http request failed"
@@ -309,7 +307,7 @@ describe ExperellaProxy do
               EventMachine.stop
             }
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
 
     end
@@ -319,17 +317,17 @@ describe ExperellaProxy do
       log.info "should rechunk and stream Transfer-Encoding chunked responses"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}/chunked"
-            ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            ).get(:connect_timeout => 1, :head => { "Host" => "experella.com" })
             http.errback {
               EventMachine.stop
               raise "http request failed"
             }
             received_chunks = ""
             http.stream { |chunk|
-             received_chunks << chunk
+              received_chunks << chunk
             }
             http.callback {
               true.should be_true
@@ -338,7 +336,7 @@ describe ExperellaProxy do
               EventMachine.stop
             }
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
 
     end
@@ -348,14 +346,14 @@ describe ExperellaProxy do
       EM.epoll
       EM.run do
 
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             time = Time.now
             conn = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}")
-            req1 = conn.get({:connect_timeout => 1, :inactivity_timeout => config.timeout + 5,
-                             :keepalive => true, :head => {"Host" => "experella.com"}})
+            req1 = conn.get(:connect_timeout => 1, :inactivity_timeout => config.timeout + 5,
+                             :keepalive => true, :head => { "Host" => "experella.com" })
             req1.errback {
-              #this shouldnt happen, but when it does it should at least be because of a timeout
+              # this shouldnt happen, but when it does it should at least be because of a timeout
               time = Time.now - time
               time.should >= config.timeout
               time.should < config.timeout + 5
@@ -365,7 +363,7 @@ describe ExperellaProxy do
             req1.callback {
               req1.response.should start_with "you sent: "
             }
-            #check for inactivity timeout
+            # check for inactivity timeout
             EventMachine.add_periodic_timer(1) do
               if conn.conn.get_idle_time.nil?
                 time = Time.now - time
@@ -378,22 +376,21 @@ describe ExperellaProxy do
               end
             end
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
-
     it "should handle pipelined requests correctly" do
       log.info "should handle pipelined requests correctly"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             conn = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}")
 
-            pipe1 = conn.get({:connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
-            pipe2 = conn.get({:path => '/about/', :connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
-            pipe3 = conn.get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            pipe1 = conn.get(:connect_timeout => 1, :keepalive => true, :head => { "Host" => "experella.com" })
+            pipe2 = conn.get(:path => '/about/', :connect_timeout => 1, :keepalive => true, :head => { "Host" => "experella.com" })
+            pipe3 = conn.get(:connect_timeout => 1, :head => { "Host" => "experella.com" })
             pipe1.errback {
               EventMachine.stop
               raise "http request 1 failed"
@@ -423,7 +420,7 @@ describe ExperellaProxy do
               EventMachine.stop
             }
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -431,16 +428,16 @@ describe ExperellaProxy do
       log.info "should accept requests on all set proxy domains"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
 
             multi = EventMachine::MultiRequest.new
             multi_shuffle = []
             i = 0
-            while config.proxy.length > i do
-              multi_shuffle[i] = Proc.new { |i|
+            while config.proxy.length > i
+              multi_shuffle[i] = proc { |i|
                 multi.add i, EventMachine::HttpRequest.new("http://#{config.proxy[i][:host]}:#{config.proxy[i][:port]}"
-                ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+                ).get(:connect_timeout => 1, :head => { "Host" => "experella.com" })
               }
               i += 1
             end
@@ -462,7 +459,7 @@ describe ExperellaProxy do
               EventMachine.stop
             end
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -470,10 +467,10 @@ describe ExperellaProxy do
       log.info "should be able to handle post requests"
       EM.epoll
       EM.run do
-        lambda {
+        lambda do
           EventMachine.add_timer(0.2) do
             http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
-            ).post({:connect_timeout => 1, :head => {"Host" => "experella.com"}, :body => "Message body"})
+            ).post(:connect_timeout => 1, :head => { "Host" => "experella.com" }, :body => "Message body")
             http.errback {
               EventMachine.stop
               raise "http post failed"
@@ -484,9 +481,9 @@ describe ExperellaProxy do
               EventMachine.stop
             }
           end
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
   end
-end
+end

data/spec/experella-proxy/request_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe ExperellaProxy::Request do
 
-  let(:request) {
+  let(:request) do
     ExperellaProxy::Request.new("conn")
-  }
+  end
 
   describe "#new" do
 
@@ -51,7 +51,7 @@ describe ExperellaProxy::Request do
 
   describe "#add_uri" do
     it "adds a hash to the URI hash" do
-      request.add_uri({:path => "/hello"})
+      request.add_uri(:path => "/hello")
       request.uri[:path].should eql("/hello")
     end
   end
@@ -67,15 +67,15 @@ describe ExperellaProxy::Request do
     it "overwrites values of existing keys" do
       request.update_header("Host" => "xyz", :request_url => "abcd")
       request.update_header("Host" => "abc")
-      request.header.should eql({:Host => "abc", :request_url => "abcd"})
+      request.header.should eql(:Host => "abc", :request_url => "abcd")
     end
   end
 
   describe "#reconstruct_header" do
     it "writes a valid http header into send_buffer" do
       request << "HeaderDummy\r\n\r\n"
-      request.update_header({:http_method => "GET", :request_url => "/index",
-                            "Host" => "localhost", "Connection" => "keep-alive", :"Via-X" => ["Lukas", "Amy", "George"]})
+      request.update_header(:http_method => "GET", :request_url => "/index",
+                            "Host" => "localhost", "Connection" => "keep-alive", :"Via-X" => %w(Lukas Amy George))
       request.reconstruct_header
       data = request.flush
       data.start_with?("GET /index HTTP/1.1\r\n").should be_true
@@ -85,4 +85,4 @@ describe ExperellaProxy::Request do
     end
   end
 
-end
+end