net-http-server 0.1.0

data/spec/rack/handler/http_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'rack/handler/helpers/test_request'
+
+require 'rack/handler/http'
+require 'rack/lint'
+require 'rack/builder'
+require 'rack/static'
+
+describe Rack::Handler::HTTP do
+  include TestRequest::Helpers
+
+  let(:host) { '0.0.0.0' }
+  let(:port) { 9204 }
+  
+  before(:all) do
+    app = Rack::Builder.app do
+      use Rack::Lint
+      use Rack::Static, :urls => ["/spec/images"]
+      run TestRequest.new
+    end
+    
+    @server = Rack::Handler::HTTP.new(app, :Host => host, :Port => port)
+
+    Thread.new { @server.run }
+    Thread.pass until @server.running?
+  end
+  
+  after(:all) do
+    @server.stop
+    Thread.pass until @server.stopped?
+  end
+  
+  it "should respond to a simple get request" do
+    GET "/"
+    status.should == 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 == ""
+
+    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"
+  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"
+  end
+
+  it "should support HTTP auth" do
+    GET("/test", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should == "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  it "should set status" do
+    GET("/test?secret")
+    status.should == 403
+    response["rack.url_scheme"].should == "http"
+  end
+
+  it "should not set content-type to '' in requests" do
+    GET("/test", 'Content-Type' => '')
+    response['Content-Type'].should == 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
+  end
+end

data/spec/server/daemon_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'net/http/server/daemon'
+
+describe Net::HTTP::Server::Daemon do
+  subject { Net::HTTP::Server::Daemon }
+
+  describe "new" do
+    it "should have a default host" do
+      daemon = subject.new { |request,socket| }
+
+      daemon.host.should_not be_nil
+    end
+
+    it "should have a default port" do
+      daemon = subject.new { |request,socket| }
+
+      daemon.port.should_not be_nil
+    end
+
+    it "should require a HTTP Request handler" do
+      lambda {
+        subject.new
+      }.should raise_error
+    end
+  end
+end

data/spec/server/parser_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'net/http/server/parser'
+
+describe Net::HTTP::Server::Parser do
+  it "should not parse garbage" do
+    garbage = (1..255).map { |b| b.chr }.join * 100
+
+    lambda {
+      subject.parse(garbage)
+    }.should 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'
+    end
+
+    it "should allow '*' as the path" do
+      request = subject.parse("OPTIONS * HTTP/1.1\r\n\r\n")
+
+      request[:uri].should == '*'
+    end
+
+    it "should not confuse the '/*' path with '*'" do
+      request = subject.parse("OPTIONS /* HTTP/1.1\r\n\r\n")
+
+      request[:uri][:path].should == '*'
+    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'
+    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'
+    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'
+    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'
+    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'
+    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'
+    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'
+    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 be_nil
+      request[:version].should == '1.1'
+    end
+  end
+end

data/spec/server/requests_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'net/http/server/requests'
+
+require 'stringio'
+
+describe Net::HTTP::Server::Requests do
+  include Net::HTTP::Server::Requests
+
+  describe "read_request" 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
+    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
+    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
+    end
+
+    it "should not read the body of the request" do
+      request = "GET / HTTP/1.1\r\nFoo: Bar\r\n\r\n"
+      body = "<html>\r\n\t<body>hello</body>\r\n</html>\r\n"
+      stream = StringIO.new(request + body)
+
+      read_request(stream)
+
+      stream.read.should == body
+    end
+  end
+
+  describe "normalize_uri" do
+    it "should infer the :port, if :scheme is also set" do
+      request = {:uri => {:scheme => 'https'}}
+      normalize_uri(request)
+
+      request[:uri][:port].should == 443
+    end
+
+    it "should convert :port to an Integer" do
+      request = {:uri => {:scheme => 'http', :port => '80'}}
+      normalize_uri(request)
+
+      request[:uri][:port].should == 80
+    end
+
+    it "should default :path to '/'" do
+      request = {:uri => {:path => nil}}
+      normalize_uri(request)
+
+      request[:uri][:path].should == '/'
+    end
+
+    it "should ensure that the path begins with a '/'" do
+      request = {:uri => {:path => 'foo'}}
+      normalize_uri(request)
+
+      request[:uri][:path].should == '/foo'
+    end
+
+    it "should replace a '*' URI with an empty Hash" do
+      request = {:uri => '*'}
+      normalize_uri(request)
+
+      request[:uri].should == {}
+    end
+  end
+
+  describe "normalize_headers" do
+    it "should convert empty headers to an empty Hash" do
+      request = {:headers => []}
+      normalize_headers(request)
+
+      request[:headers].should == {}
+    end
+
+    it "should convert header names and values into a Hash" do
+      request = {:headers => [
+        {:name => 'Content-Type', :value => 'text/html'},
+        {:name => 'Content-Length', :value => '5'}
+      ]}
+      normalize_headers(request)
+
+      request[:headers].should == {
+        'Content-Type' => 'text/html',
+        'Content-Length' => '5'
+      }
+    end
+
+    it "should group duplicate header names into the same Hash key" do
+      request = {:headers => [
+        {:name => 'Content-Type', :value => 'text/html'},
+        {:name => 'Content-Type', :value => 'UTF8'},
+      ]}
+      normalize_headers(request)
+
+      request[:headers].should == {
+        'Content-Type' => ['text/html', 'UTF8']
+      }
+    end
+  end
+end

data/spec/server/responses_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'net/http/server/responses'
+
+require 'stringio'
+
+describe Net::HTTP::Server::Responses do
+  include Net::HTTP::Server::Responses
+
+  before(:each) { @stream = StringIO.new }
+
+  describe "write_status" do
+    let(:status) { 200 }
+    let(:reason) { Net::HTTP::Server::Responses::HTTP_STATUSES[status] }
+
+    before(:each) { write_status(@stream,status) }
+
+    it "should write the HTTP Version" do
+      parts = @stream.string.split(' ')
+
+      parts[0].should =~ /HTTP\/1.1/
+    end
+
+    it "should write the Status Code" do
+      parts = @stream.string.split(' ')
+
+      parts[1].should == status.to_s
+    end
+
+    it "should write the Reason String" do
+      parts = @stream.string.split(' ')
+
+      parts[2].should == reason
+    end
+
+    it "should end the line with a '\\r\\n'" do
+      @stream.string[-2..-1].should == "\r\n"
+    end
+  end
+
+  describe "write_headers" do
+    it "should separate header names and values with a ': '" do
+      write_headers(@stream, 'Foo' => 'Bar')
+
+      @stream.string.should 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 =~ [
+        'Foo: Bar',
+        'Baz: Qix'
+      ]
+    end
+
+    it "should end the headers with a '\\r\\n'" do
+      write_headers(@stream, {})
+
+      @stream.string.should == "\r\n"
+    end
+
+    it "should write String headers" do
+      write_headers(@stream, 'Content-Type' => 'text/html')
+
+      @stream.string.split("\r\n").should == [
+        '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 == [
+        '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 == [
+        '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 == [
+        'Content-Type: text/html',
+        'Content-Type: charset=UTF8'
+      ]
+    end
+  end
+
+  describe "write_body" do
+    it "should write each check of the body" do
+      write_body(@stream,['one', 'two', 'three'])
+
+      @stream.string.should == 'onetwothree'
+    end
+  end
+end

data/spec/server/server_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'net/http/server'
+
+describe Net::HTTP::Server do
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: net-http-server
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Postmodern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-26 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: parslet
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ore-tasks
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 4
+        - 0
+        version: 2.4.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  version_requirements: *id004
+description: A Rack compatible pure Ruby HTTP Server.
+email: postmodern.mod3@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- ChangeLog.md
+- LICENSE.txt
+files: 
+- .document
+- .gemtest
+- .rspec
+- .yardopts
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemspec.yml
+- lib/net/http/server.rb
+- lib/net/http/server/daemon.rb
+- lib/net/http/server/parser.rb
+- lib/net/http/server/requests.rb
+- lib/net/http/server/responses.rb
+- lib/net/http/server/server.rb
+- lib/net/http/server/version.rb
+- lib/rack/handler/http.rb
+- net-http-server.gemspec
+- spec/rack/handler/helpers/test_request.rb
+- spec/rack/handler/http_spec.rb
+- spec/rack/handler/images/image.jpg
+- spec/server/daemon_spec.rb
+- spec/server/parser_spec.rb
+- spec/server/requests_spec.rb
+- spec/server/responses_spec.rb
+- spec/server/server_spec.rb
+- spec/spec_helper.rb
+has_rdoc: yard
+homepage: http://github.com/postmodern/net-http-server
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: net-http-server
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A pure Ruby HTTP Server
+test_files: 
+- spec/server/daemon_spec.rb
+- spec/server/requests_spec.rb
+- spec/server/parser_spec.rb
+- spec/server/responses_spec.rb
+- spec/server/server_spec.rb
+- spec/rack/handler/http_spec.rb