net-http-server 0.2.2 → 0.2.3

data/spec/net/http/server/chunked_stream_spec.rb

@@ -11,14 +11,14 @@ describe Net::HTTP::Server::ChunkedStream do
       socket = StringIO.new("%x\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read.should == data
+      expect(stream.read).to eq(data)
     end
 
     it "should ignore any extension data, after the length field" do
       socket = StringIO.new("%x;lol\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read.should == data
+      expect(stream.read).to eq(data)
     end
 
     it "should read an amount of data from a socket, directly into a buffer" do
@@ -28,22 +28,22 @@ describe Net::HTTP::Server::ChunkedStream do
       socket = StringIO.new("%x\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read(length,buffer).should == data[0,length]
+      expect(stream.read(length,buffer)).to eq(data[0,length])
     end
 
     it "should buffer unread data from the previously read chunk" do
       socket = StringIO.new("%x\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read(4).should == data[0,4]
-      stream.read.should == data[4..-1]
+      expect(stream.read(4)).to eq(data[0,4])
+      expect(stream.read).to eq(data[4..-1])
     end
 
     it "should return nil after it reads the last chunk" do
       socket = StringIO.new("0\r\n\r\n")
       stream = described_class.new(socket)
 
-      stream.read.should be_nil
+      expect(stream.read).to be_nil
     end
   end
 
@@ -52,7 +52,7 @@ describe Net::HTTP::Server::ChunkedStream do
       socket = StringIO.new
       stream = described_class.new(socket)
 
-      stream.write('foo').should == 3
+      expect(stream.write('foo')).to eq(3)
     end
 
     it "should write a length-line along with the data" do
@@ -61,7 +61,7 @@ describe Net::HTTP::Server::ChunkedStream do
 
       stream.write('foo')
 
-      socket.string.should == "3\r\nfoo\r\n"
+      expect(socket.string).to eq("3\r\nfoo\r\n")
     end
 
     it "should not write empty Strings" do
@@ -70,7 +70,7 @@ describe Net::HTTP::Server::ChunkedStream do
 
       stream.write('')
 
-      socket.string.should be_empty
+      expect(socket.string).to be_empty
     end
   end
 
@@ -81,7 +81,7 @@ describe Net::HTTP::Server::ChunkedStream do
 
       stream.close
 
-      socket.string.should == "0\r\n\r\n"
+      expect(socket.string).to eq("0\r\n\r\n")
     end
   end
 end

data/spec/net/http/server/daemon_spec.rb

@@ -8,17 +8,17 @@ describe Net::HTTP::Server::Daemon do
     subject { described_class.new { |request,response| } }
 
     it "should have a default host" do
-      subject.host.should_not be_nil
+      expect(subject.host).to eq(described_class::DEFAULT_HOST)
     end
 
     it "should have a default port" do
-      subject.port.should_not be_nil
+      expect(subject.port).to eq(described_class::DEFAULT_PORT)
     end
 
     it "should require a HTTP Request handler" do
-      lambda {
+      expect {
         described_class.new
-      }.should raise_error
+      }.to raise_error(ArgumentError,"no HTTP Request Handler block given")
     end
   end
 end

data/spec/net/http/server/parser_spec.rb

@@ -5,86 +5,86 @@ describe Net::HTTP::Server::Parser do
   it "should not parse garbage" do
     garbage = (1..255).map { |b| b.chr }.join * 100
 
-    lambda {
+    expect {
       subject.parse(garbage)
-    }.should raise_error(Parslet::ParseFailed)
+    }.to raise_error(Parslet::ParseFailed)
   end
 
   describe "request line" do
     it "should parse non-standard request methods" do
       request = subject.parse("FOO / HTTP/1.1\r\n\r\n")
 
-      request[:method].should == 'FOO'
+      expect(request[:method]).to eq('FOO')
     end
 
     it "should allow '*' as the path" do
       request = subject.parse("OPTIONS * HTTP/1.1\r\n\r\n")
 
-      request[:uri].should == '*'
+      expect(request[:uri]).to eq('*')
     end
 
     it "should not confuse the '/*' path with '*'" do
       request = subject.parse("OPTIONS /* HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/*'
+      expect(request[:uri][:path]).to eq('/*')
     end
 
     it "should parse absolute paths" do
       request = subject.parse("GET /absolute/path HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/absolute/path'
+      expect(request[:uri][:path]).to eq('/absolute/path')
     end
 
     it "should parse the params in the path" do
       request = subject.parse("GET /path;q=1;p=2 HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/path'
-      request[:uri][:params].should == 'q=1;p=2'
+      expect(request[:uri][:path]).to eq('/path')
+      expect(request[:uri][:params]).to eq('q=1;p=2')
     end
 
     it "should parse the query-string in the path" do
       request = subject.parse("GET /path?q=1&p=2 HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/path'
-      request[:uri][:query].should == 'q=1&p=2'
+      expect(request[:uri][:path]).to eq('/path')
+      expect(request[:uri][:query]).to eq('q=1&p=2')
     end
 
     it "should parse absolute URIs paths" do
       request = subject.parse("GET http://www.example.com:8080/path HTTP/1.1\r\n\r\n")
 
-      request[:uri][:scheme].should == 'http'
-      request[:uri][:host].should == 'www.example.com'
-      request[:uri][:port].should == '8080'
-      request[:uri][:path].should == '/path'
+      expect(request[:uri][:scheme]).to eq('http')
+      expect(request[:uri][:host]).to eq('www.example.com')
+      expect(request[:uri][:port]).to eq('8080')
+      expect(request[:uri][:path]).to eq('/path')
     end
 
     it "should parse non-http URIs" do
       request = subject.parse("GET xmpp://alice:secret@example.com/path HTTP/1.1\r\n\r\n")
 
-      request[:uri][:scheme].should == 'xmpp'
-      request[:uri][:user_info].should == 'alice:secret'
-      request[:uri][:host].should == 'example.com'
-      request[:uri][:path].should == '/path'
+      expect(request[:uri][:scheme]).to eq('xmpp')
+      expect(request[:uri][:user_info]).to eq('alice:secret')
+      expect(request[:uri][:host]).to eq('example.com')
+      expect(request[:uri][:path]).to eq('/path')
     end
 
     it "should parse the HTTP version" do
       request = subject.parse("GET /path HTTP/1.1\r\n\r\n")
 
-      request[:version].should == '1.1'
+      expect(request[:version]).to eq('1.1')
     end
 
     it "should allow future HTTP versions" do
       request = subject.parse("GET /path HTTP/2.0\r\n\r\n")
 
-      request[:version].should == '2.0'
+      expect(request[:version]).to eq('2.0')
     end
 
     it "should parse simple GET requests" do
       request = subject.parse("GET / HTTP/1.1\r\n\r\n")
 
-      request[:method].should == 'GET'
-      request[:uri][:path].should == '/'
-      request[:version].should == '1.1'
+      expect(request[:method]).to eq('GET')
+      expect(request[:uri][:path]).to eq('/')
+      expect(request[:version]).to eq('1.1')
     end
   end
 end

data/spec/net/http/server/requests_spec.rb

@@ -10,20 +10,20 @@ describe Net::HTTP::Server::Requests do
     it "should ignore requests that do not contain an HTTP version" do
       stream = StringIO.new("GET /\r\n")
 
-      read_request(stream).should be_nil
+      expect(read_request(stream)).to be_nil
     end
 
     it "should ignore requests with malformed headers" do
       stream = StringIO.new("GET / HTTP/1.1\r\nFoo: Bar\r\nBAZ\r\n\r\n")
 
-      read_request(stream).should be_nil
+      expect(read_request(stream)).to be_nil
     end
 
     it "should read requests with an HTTP Version and Headers" do
       request = "GET / HTTP/1.1\r\nFoo: Bar\r\n\r\n"
       stream = StringIO.new(request)
 
-      read_request(stream).should == request
+      expect(read_request(stream)).to eq(request)
     end
 
     it "should not read the body of the request" do
@@ -33,7 +33,7 @@ describe Net::HTTP::Server::Requests do
 
       read_request(stream)
 
-      stream.read.should == body
+      expect(stream.read).to eq(body)
     end
   end
 
@@ -42,21 +42,21 @@ describe Net::HTTP::Server::Requests do
       request = {:uri => {:scheme => 'https'}}
       normalize_uri(request)
 
-      request[:uri][:port].should == 443
+      expect(request[:uri][:port]).to eq(443)
     end
 
     it "should convert :port to an Integer" do
       request = {:uri => {:scheme => 'http', :port => '80'}}
       normalize_uri(request)
 
-      request[:uri][:port].should == 80
+      expect(request[:uri][:port]).to eq(80)
     end
 
     it "should replace a '*' URI with an empty Hash" do
       request = {:uri => '*'}
       normalize_uri(request)
 
-      request[:uri].should == {}
+      expect(request[:uri]).to eq({})
     end
   end
 
@@ -65,7 +65,7 @@ describe Net::HTTP::Server::Requests do
       request = {:headers => []}
       normalize_headers(request)
 
-      request[:headers].should == {}
+      expect(request[:headers]).to eq({})
     end
 
     it "should convert header names and values into a Hash" do
@@ -75,10 +75,10 @@ describe Net::HTTP::Server::Requests do
       ]}
       normalize_headers(request)
 
-      request[:headers].should == {
+      expect(request[:headers]).to eq({
         'Content-Type' => 'text/html',
         'Content-Length' => '5'
-      }
+      })
     end
 
     it "should group duplicate header names into the same Hash key" do
@@ -88,9 +88,9 @@ describe Net::HTTP::Server::Requests do
       ]}
       normalize_headers(request)
 
-      request[:headers].should == {
+      expect(request[:headers]).to eq({
         'Content-Type' => ['text/html', 'UTF8']
-      }
+      })
     end
   end
 end

data/spec/net/http/server/responses_spec.rb

@@ -17,23 +17,23 @@ describe Net::HTTP::Server::Responses do
     it "should write the HTTP Version" do
       parts = @stream.string.split(' ')
 
-      parts[0].should =~ /HTTP\/1.1/
+      expect(parts[0]).to match(/HTTP\/1.1/)
     end
 
     it "should write the Status Code" do
       parts = @stream.string.split(' ')
 
-      parts[1].should == status.to_s
+      expect(parts[1]).to eq(status.to_s)
     end
 
     it "should write the Reason String" do
       parts = @stream.string.split(' ')
 
-      parts[2].should == reason
+      expect(parts[2]).to eq(reason)
     end
 
     it "should end the line with a '\\r\\n'" do
-      @stream.string[-2..-1].should == "\r\n"
+      expect(@stream.string[-2..-1]).to eq("\r\n")
     end
   end
 
@@ -41,57 +41,57 @@ describe Net::HTTP::Server::Responses do
     it "should separate header names and values with a ': '" do
       write_headers(@stream, 'Foo' => 'Bar')
 
-      @stream.string.should include(': ')
+      expect(@stream.string).to include(': ')
     end
 
     it "should terminate each header with a '\\r\\n'" do
       write_headers(@stream, 'Foo' => 'Bar', 'Baz' => 'Qix')
 
-      @stream.string.split("\r\n").should =~ [
+      expect(@stream.string.split("\r\n")).to match_array([
         'Foo: Bar',
         'Baz: Qix'
-      ]
+      ])
     end
 
     it "should end the headers with a '\\r\\n'" do
       write_headers(@stream, {})
 
-      @stream.string.should == "\r\n"
+      expect(@stream.string).to eq("\r\n")
     end
 
     it "should write String headers" do
       write_headers(@stream, 'Content-Type' => 'text/html')
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Content-Type: text/html'
-      ]
+      ])
     end
 
     it "should write multiple headers for multi-line String values" do
       write_headers(@stream, 'Content-Type' => "text/html\ncharset=UTF8")
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Content-Type: text/html',
         'Content-Type: charset=UTF8'
-      ]
+      ])
     end
 
     it "should properly format Time values" do
       time = Time.parse('2011-01-25 14:15:29 -0800')
       write_headers(@stream, 'Date' => time)
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Date: Tue, 25 Jan 2011 22:15:29 GMT'
-      ]
+      ])
     end
 
     it "should write Array values as multiple headers" do
       write_headers(@stream, 'Content-Type' => ['text/html', 'charset=UTF8'])
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Content-Type: text/html',
         'Content-Type: charset=UTF8'
-      ]
+      ])
     end
   end
 
@@ -99,7 +99,7 @@ describe Net::HTTP::Server::Responses do
     it "should write each check of the body" do
       write_body(@stream,['one', 'two', 'three'])
 
-      @stream.string.should == 'onetwothree'
+      expect(@stream.string).to eq('onetwothree')
     end
   end
 end

data/spec/net/http/server/stream_spec.rb

@@ -9,7 +9,7 @@ describe Net::HTTP::Server::Stream do
 
     it "should read data from a socket" do
       stream = described_class.new(StringIO.new(data))
-      stream.read.should == data
+      expect(stream.read).to eq(data)
     end
 
     it "should read an amount of data from a socket, directly into a buffer" do
@@ -19,7 +19,7 @@ describe Net::HTTP::Server::Stream do
       stream = described_class.new(StringIO.new(data))
       stream.read(length,buffer)
       
-      buffer.should == data[0,length]
+      expect(buffer).to eq(data[0,length])
     end
   end
 
@@ -30,7 +30,7 @@ describe Net::HTTP::Server::Stream do
       stream = described_class.new(StringIO.new())
       stream.each { |chunk| results << chunk }
 
-      results.should be_empty
+      expect(results).to be_empty
     end
 
     it "should yield each chunk in the stream" do
@@ -41,7 +41,7 @@ describe Net::HTTP::Server::Stream do
       stream = described_class.new(StringIO.new(data))
       stream.each { |chunk| results << chunk }
 
-      results.should == chunks
+      expect(results).to eq(chunks)
     end
   end
 
@@ -51,7 +51,7 @@ describe Net::HTTP::Server::Stream do
       data = chunks.join('')
 
       stream = described_class.new(StringIO.new(data))
-      stream.body.should == data
+      expect(stream.body).to eq(data)
     end
   end
 
@@ -60,7 +60,7 @@ describe Net::HTTP::Server::Stream do
       data = "foo\n\rbar"
 
       stream = described_class.new(StringIO.new)
-      stream.write(data).should == data.length
+      expect(stream.write(data)).to eq(data.length)
     end
   end
 end

data/spec/rack/handler/helpers/test_request.rb

@@ -6,6 +6,15 @@ class TestRequest
   def call(env)
     status = env["QUERY_STRING"] =~ /secret/ ? 403 : 200
     env["test.postdata"] = env["rack.input"].read
+    # clean out complex objects that won't translate over anyways.
+    env.keys.each do |key|
+      case env[key]
+      when String, Fixnum, Bignum
+        # leave it
+      else
+        env[key] = nil
+      end
+    end
     body = env.to_yaml
     size = body.respond_to?(:bytesize) ? body.bytesize : body.size
     [status, {"Content-Type" => "text/yaml", "Content-Length" => size.to_s}, [body]]
@@ -31,7 +40,7 @@ class TestRequest
         passwd = header.delete(:passwd)
 
         get = Net::HTTP::Get.new(path, header)
-        get.basic_auth user, passwd if user && passwd
+        get.basic_auth user, passwd  if user && passwd
         http.request(get) { |response|
           @status = response.code.to_i
           if response.content_type == "text/yaml"
@@ -50,14 +59,14 @@ class TestRequest
 
         post = Net::HTTP::Post.new(path, header)
         post.form_data = formdata
-        post.basic_auth user, passwd if user && passwd
+        post.basic_auth user, passwd  if user && passwd
         http.request(post) { |response|
           @status = response.code.to_i
           @response = YAML.load(response.body)
         }
       }
     end
-    
+
     def load_yaml(response)
       begin
         @response = YAML.load(response.body)

data/spec/rack/handler/http_spec.rb

@@ -12,7 +12,8 @@ describe Rack::Handler::HTTP do
   before(:all) do
     app = Rack::Builder.app do
       use Rack::Lint
-      use Rack::Static, :urls => ["/spec/images"]
+      use Rack::Static, :urls => ["/images"],
+                        :root => TestRequest::Helpers::ROOT
       run TestRequest.new
     end
     
@@ -31,56 +32,56 @@ describe Rack::Handler::HTTP do
   
   it "should respond to a simple get request" do
     GET "/"
-    status.should == 200
+    expect(status).to eq(200)
   end
   
   it "should have CGI headers on GET" do
     GET("/")
-    response["REQUEST_METHOD"].should == "GET"
-    response["SCRIPT_NAME"].should == ''
-    response["PATH_INFO"].should == "/"
-    response["QUERY_STRING"].should == ""
-    response["test.postdata"].should == ""
+    expect(response["REQUEST_METHOD"]).to eq("GET")
+    expect(response["SCRIPT_NAME"]).to eq('')
+    expect(response["PATH_INFO"]).to eq("/")
+    expect(response["QUERY_STRING"]).to eq("")
+    expect(response["test.postdata"]).to eq("")
 
     GET("/test/foo?quux=1")
-    response["REQUEST_METHOD"].should == "GET"
-    response["SCRIPT_NAME"].should == ''
-    response["REQUEST_URI"].should == "/test/foo"
-    response["PATH_INFO"].should == "/test/foo"
-    response["QUERY_STRING"].should == "quux=1"
+    expect(response["REQUEST_METHOD"]).to eq("GET")
+    expect(response["SCRIPT_NAME"]).to eq('')
+    expect(response["REQUEST_URI"]).to eq("/test/foo")
+    expect(response["PATH_INFO"]).to eq("/test/foo")
+    expect(response["QUERY_STRING"]).to eq("quux=1")
   end
 
   it "should have CGI headers on POST" do
     POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.should == 200
-    response["REQUEST_METHOD"].should == "POST"
-    response["REQUEST_URI"].should == "/"
-    response["QUERY_STRING"].should == ""
-    response["HTTP_X_TEST_HEADER"].should == "42"
-    response["test.postdata"].should == "rack-form-data=23"
+    expect(status).to eq(200)
+    expect(response["REQUEST_METHOD"]).to eq("POST")
+    expect(response["REQUEST_URI"]).to eq("/")
+    expect(response["QUERY_STRING"]).to eq("")
+    expect(response["HTTP_X_TEST_HEADER"]).to eq("42")
+    expect(response["test.postdata"]).to eq("rack-form-data=23")
   end
 
   it "should support HTTP auth" do
     GET("/test", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].should == "Basic cnV0aDpzZWNyZXQ="
+    expect(response["HTTP_AUTHORIZATION"]).to eq("Basic cnV0aDpzZWNyZXQ=")
   end
 
   it "should set status" do
     GET("/test?secret")
-    status.should == 403
-    response["rack.url_scheme"].should == "http"
+    expect(status).to eq(403)
+    expect(response["rack.url_scheme"]).to eq("http")
   end
 
   it "should not set content-type to '' in requests" do
     GET("/test", 'Content-Type' => '')
-    response['Content-Type'].should == nil
+    expect(response['Content-Type']).to eq(nil)
   end
   
   it "should serve images" do
     file_size = File.size(File.join(File.dirname(__FILE__), 'images', 'image.jpg'))
-    GET("/spec/images/image.jpg")
-    status.should == 200
-    response.content_length.should == file_size
-    response.body.size.should == file_size
+    GET("/images/image.jpg")
+    expect(status).to eq(200)
+    expect(response.content_length).to eq(file_size)
+    expect(response.body.size).to eq(file_size)
   end
 end

data/spec/spec_helper.rb

@@ -1,2 +1 @@
-gem 'rspec', '~> 2.4'
 require 'rspec'