serverside 0.4.1 → 0.4.3

data/spec/http_spec.rb

@@ -1,41 +1,7 @@
-require File.join(File.dirname(__FILE__), '../lib/serverside')
+require File.join(File.dirname(__FILE__), 'spec_helper')
 
 include ServerSide::HTTP
 
-class SpecHTTPServer
-  include Server
-  
-  attr_accessor :in, :state, :request_headers, :request_header_count, 
-    :request_cookies, :response_headers
-  
-  attr_accessor :method, :uri, :query, :http_version
-  attr_accessor :params, :persistent, :content_length
-  
-  def initialize
-    reset
-  end
-  
-  def reset
-    post_init
-    @response = ''
-    @closed = false
-  end
-  
-  attr_reader :response, :closed
-  
-  def send_data(data)
-    @response << data
-  end
-  
-  def close_connection_after_writing
-    @closed = true
-  end
-  
-  def send_error_response(e)
-    raise e
-  end
-end
-
 context "An HTTP Request should be considered malformed" do
   setup do
     @server = SpecHTTPServer.new
@@ -43,56 +9,74 @@ context "An HTTP Request should be considered malformed" do
   
   specify "if the request-line size is too big" do
     l = "GET /#{'x' * (MAX_REQUEST_LINE_SIZE - 12)}"
-    proc {@server.receive_data(l)}.should_not raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should_not raise_error(BadRequestError)
 
     @server.reset
-    l = "GET /#{'x' * MAX_REQUEST_LINE_SIZE}"
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    l = "GET /#{'x' * MAX_REQUEST_LINE_SIZE} HTTP/1.1\r\n"
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
   end
   
   specify "if the request-line is malformed" do
     l = "abcde\r\n"
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
     
     @server.reset
     l = "GET /\r\n"
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
 
     @server.reset
     l = "GET HTTP/\r\n"
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
+  end
+  
+  specify "if a query parameter name is too big" do
+    l = "GET /?#{'x' * MAX_PARAMETER_NAME_SIZE}=2 HTTP/1.1\r\n"
+    proc {@server.receive_data(l)}.should_not raise_error(BadRequestError)
+
+    @server.reset
+    l = "GET /?#{'x' * MAX_PARAMETER_NAME_SIZE + 'y'}=2 HTTP/1.1\r\n"
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
   end
   
   specify "if the header count is too big" do
-    l = "GET / HTTP/1.1\r\n" + "Accept: *\r\n" * (MAX_HEADER_COUNT - 1)
-    proc {@server.receive_data(l)}.should_not raise_error(MalformedRequestError)
+    l = "GET / HTTP/1.1\r\n" + ("Accept: *\r\n" * (MAX_HEADER_COUNT - 1))
+    proc {@server.receive_data(l)}.should_not raise_error(BadRequestError)
 
     @server.reset
     l = "GET / HTTP/1.1\r\n" + "Accept: *\r\n" * (MAX_HEADER_COUNT + 10)
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
   end
   
   specify "if a header is too big" do
-    l = "GET / HTTP/1.1\r\n#{'x' * MAX_HEADER_SIZE}: 1\r\n"
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    l = "GET / HTTP/1.1\r\nAccept: #{'x' * MAX_HEADER_SIZE}\r\n"
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
+  end
+  
+  specify "if a header name is too big" do
+    l = "GET / HTTP/1.1\r\n#{'x' * MAX_HEADER_NAME_SIZE}: 1\r\n"
+    proc {@server.receive_data(l)}.should_not raise_error(BadRequestError)
+
+    @server.reset
+    l = "GET / HTTP/1.1\r\n#{'x' * MAX_HEADER_NAME_SIZE + 'y'}: 1\r\n"
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
   end
   
   specify "if a header is malformed" do
     l = %[GET / HTTP/1.1\r\ntest: 231\r\n]
-    proc {@server.receive_data(l)}.should_not raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should_not raise_error(BadRequestError)
 
     @server.reset
     l = %[GET / HTTP/1.1\r\nmitchesunu no haha\r\n]
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
   end
   
   specify "if it contains a malformed cookie header" do
     l = %[GET / HTTP/1.1\r\nCookie: a=b\r\n]
-    proc {@server.receive_data(l)}.should_not raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should_not raise_error(BadRequestError)
 
     @server.reset
     l = %[GET / HTTP/1.1\r\nCookie: zzxxcc\r\n]
-    proc {@server.receive_data(l)}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data(l)}.should raise_error(BadRequestError)
   end
 end
 
@@ -101,17 +85,12 @@ context "A server in the initial state" do
     @server = SpecHTTPServer.new
   end
   
-  specify "should initialize all header-related variables" do
-    @server.request_headers = {1 => 2}
-    @server.request_header_count = 20
-    @server.request_cookies = {:z => :y}
-    @server.response_headers = [1, 2, 3]
-
+  specify "should create a new request instance" do
+    req1 = @server.request
     @server.set_state(:state_initial)
-    @server.request_headers.should == {}
-    @server.request_header_count.should == 0
-    @server.request_cookies.should == {}
-    @server.response_headers.should == []
+    req2 = @server.request
+    
+    req1.should_not == req2
   end
   
   specify "should transition to state_request_line" do
@@ -137,26 +116,26 @@ context "A server in the request_line state" do
     @server.state.should_not == :state_request_line
   end
   
-  specify "should extract method, uri, query and http version from the request line" do
+  specify "should extract method, path, query and http version from the request line" do
     @server.receive_data("GET /abc?q=z HTTP/1.1\r\n")
-    @server.method.should == :get
-    @server.uri.should == '/abc'
-    @server.query.should == 'q=z'
-    @server.http_version.should == '1.1'
+    @server.request.method.should == :get
+    @server.request.path.should == '/abc'
+    @server.request.query.should == 'q=z'
+    @server.request.http_version.should == '1.1'
   end
   
   specify "should set persistent to true if the http version is 1.1" do
     @server.receive_data("GET / HTTP/1.1\r\n")
-    @server.persistent.should be_true
+    @server.request.persistent.should be_true
 
     @server.reset
     @server.receive_data("GET / HTTP/1.0\r\n")
-    @server.persistent.should be_false
+    @server.request.persistent.should be_false
   end
   
   specify "should parse the query into params and unescape the values" do
     @server.receive_data("GET /?x=1&y=2%203 HTTP/1.1\r\n")
-    @server.params.should == {:x => '1', :y => '2 3'}
+    @server.request.params.should == {:x => '1', :y => '2 3'}
   end
   
   specify "should transition to state_request_headers" do
@@ -165,25 +144,26 @@ context "A server in the request_line state" do
     @server.state.should == :state_request_headers
   end
   
-  specify "should raise MalformedRequestError on invalid request line size" do
-    proc {@server.receive_data("abc" * MAX_REQUEST_LINE_SIZE)}.should \
-      raise_error(MalformedRequestError)
+  specify "should raise BadRequestError on invalid request line size" do
+    l = "GET /#{'x' * MAX_REQUEST_LINE_SIZE} HTTP/1.1\r\n"
+    proc {@server.receive_data(l)}.should \
+      raise_error(BadRequestError)
   end
   
-  specify "should raise MalformedRequestError if the request line is invalid" do
-    proc {@server.receive_data("GET\r\n")}.should raise_error(MalformedRequestError)
+  specify "should raise BadRequestError if the request line is invalid" do
+    proc {@server.receive_data("GET\r\n")}.should raise_error(BadRequestError)
     
     @server.reset
-    proc {@server.receive_data("GET /\r\n")}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data("GET /\r\n")}.should raise_error(BadRequestError)
 
     @server.reset
-    proc {@server.receive_data("GET / 1.1\r\n")}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data("GET / 1.1\r\n")}.should raise_error(BadRequestError)
 
     @server.reset
-    proc {@server.receive_data("GET ?q=1 HTTP/1.1\r\n")}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data("GET ?q=1 HTTP/1.1\r\n")}.should raise_error(BadRequestError)
 
     @server.reset
-    proc {@server.receive_data("GET / HTTP 1.1\r\n")}.should raise_error(MalformedRequestError)
+    proc {@server.receive_data("GET / HTTP 1.1\r\n")}.should raise_error(BadRequestError)
   end
 end
 
@@ -200,39 +180,39 @@ context "A server in the request_headers state" do
   
   specify "should parse each header as it arrives" do
     @server.receive_data("Accept: text/xml\r\n")
-    @server.request_headers.should == {'Accept' => 'text/xml'}
-    @server.request_header_count.should == 1
+    @server.request.headers.should == {:accept => 'text/xml'}
+    @server.request.header_count.should == 1
     
     @server.receive_data("Cookie: x=1\r\n")
-    @server.request_headers.should == {'Accept' => 'text/xml', 'Cookie' => 'x=1'}
-    @server.request_header_count.should == 2
+    @server.request.headers.should == {:accept => 'text/xml', :cookie => 'x=1'}
+    @server.request.header_count.should == 2
   end
   
   specify "should parse the Content-Length header into content_length" do
     @server.receive_data("Content-Length: 1234\r\n")
-    @server.content_length.should == 1234
+    @server.request.content_length.should == 1234
   end
   
   specify "should set persistent if a Connection header is received" do
     # HTTP 1.0 mode
-    @server.persistent = false
+    @server.request.persistent = false
     @server.receive_data("Connection: keep-alive\r\n")
-    @server.persistent.should be_true
+    @server.request.persistent.should be_true
     
     @server.reset
     @server.receive_data("GET / HTTP/1.1\r\n")
     @server.receive_data("Connection: close\r\n")
-    @server.persistent.should be_false
+    @server.request.persistent.should be_false
 
     @server.reset
     @server.receive_data("GET / HTTP/1.1\r\n")
     @server.receive_data("Connection: xxxxzzzz\r\n")
-    @server.persistent.should be_false
+    @server.request.persistent.should be_false
   end
   
   specify "Should parse the Cookie header" do
     @server.receive_data("Cookie: x=1; y=2%203\r\n")
-    @server.request_cookies.should == {:x => '1', :y => '2 3'}
+    @server.request.cookies.should == {:x => '1', :y => '2 3'}
   end
   
   specify "should transition to stat_response once an empty line is received" do
@@ -248,12 +228,34 @@ context "A server in the request_headers state" do
     @server.state.should == :state_request_body
   end
   
-  specify "should raise MalformedRequestError on invalid header size" do
+  specify "should raise BadRequestError on invalid header size" do
     proc {@server.receive_data("#{'x' * MAX_HEADER_SIZE}: 13\r\n\r\n")}.should \
-      raise_error(MalformedRequestError)
+      raise_error(BadRequestError)
   end
   
-  specify "should raise MalformedRequestError on malformed header" do
-    proc {@server.receive_data("abc\r\n")}.should raise_error(MalformedRequestError)
+  specify "should raise BadRequestError on malformed header" do
+    proc {@server.receive_data("abc\r\n")}.should raise_error(BadRequestError)
   end
-end
+end
+
+context "A persistent connection" do
+  setup do
+    @server = SpecHTTPServer.new
+
+    m = Module.new do
+      define_method(:handle) {|req| raise "hi there"}
+      define_method(:handle_error) {|e| send_response(Response.error(e))}
+    end
+    @server.extend(m)
+  end
+  
+  specify "should correctly handle errors" do
+    @server.receive_data("GET / HTTP/1.1\r\n\r\n")
+    @server.response.scan('500').should == ['500']
+  end
+
+  specify "should correctly handle parsing errors" do
+    @server.receive_data("GET abb\r\n\r\n")
+    @server.response.scan('400').should == ['400']
+  end
+end

data/spec/js_spec.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "A new JS representation" do
+  specify "should work with no arguments" do
+    js = ServerSide::JS.new
+    js.to_s.should == 'null'
+    
+    js.abc 123
+    js.to_s.should == '{"abc":123}'
+  end
+  
+  specify "should accept a callback" do
+    js = ServerSide::JS.new('fn')
+    js.to_s.should == 'fn(null);'
+  end
+
+  specify "should accept a block and run it" do
+    js = ServerSide::JS.new do |j|
+      j.abc  123
+    end
+    js.to_s.should == '{"abc":123}'
+  end
+end
+
+context "JS instance methods" do
+  setup do
+    @js = ServerSide::JS.new
+  end
+  
+  specify "should accept strings" do
+    @js.x 'zzz'
+    @js.to_s.should == '{"x":"zzz"}'
+  end
+  
+  specify "should accept numbers" do
+    @js.x 3
+    @js.to_s.should == '{"x":3}'
+    
+    @js = ServerSide::JS.new
+    @js.x 4.5
+    @js.to_s.should == '{"x":4.5}'
+  end
+  
+  specify "should accept true, false, nil" do
+    @js.x true
+    @js.to_s.should == '{"x":true}'
+    
+    @js = ServerSide::JS.new
+    @js.x false
+    @js.to_s.should == '{"x":false}'
+
+    @js = ServerSide::JS.new
+    @js.x nil
+    @js.to_s.should == '{"x":null}'
+  end
+  
+  specify "should accept arrays" do
+    @js.x [1, 2, 3]
+    @js.to_s.should == '{"x":[1,2,3]}'
+  end
+
+  specify "should accept blocks" do
+    @js.x {|j| j.y 'hello'}
+    @js.to_s.should == '{"x":{"y":"hello"}}'
+  end
+  
+  specify "should support << operator" do
+    @js << 1
+    @js << 2
+    @js.to_s.should == '[1,2]'
+
+    @js = ServerSide::JS.new
+    @js.xxx {|j| j << 1 << 2}
+    @js.to_s.should == '{"xxx":[1,2]}'
+  end
+  
+  specify "should accept JS objects" do
+    @js.y [1, 2, 3, 4]
+    
+    @outer = ServerSide::JS.new do |j|
+      j.x @js
+    end
+    
+    @outer.to_s.should == '{"x":{"y":[1,2,3,4]}}'
+  end
+end

data/spec/request_spec.rb

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+include ServerSide::HTTP
+
+context "A Request" do
+  setup do
+    @server = SpecHTTPServer.new
+
+    m = Module.new do
+      attr_reader :req, :error
+      define_method(:handle) {|req| @req = req}
+      define_method(:handle_error) {|e| @error = e}
+    end
+    @server.extend(m)
+  end
+  
+  MOCK_GET1 = "GET / HTTP/1.1\r\n\r\n"
+
+  specify "should be passed to the handle request" do
+    @server.receive_data(MOCK_GET1)
+    
+    @server.req.should be_a_kind_of(ServerSide::HTTP::Request)
+  end
+  
+  MOCK_POST1 = "POST /abcd HTTP/1.1\r\n\r\n"
+
+  specify "should provide the HTTP method" do
+    @server.receive_data(MOCK_GET1)
+    @server.request.method.should == :get
+
+    @server.set_state(:state_initial)
+    @server.receive_data(MOCK_POST1)
+    @server.request.method.should == :post
+  end
+
+  MOCK_HTTP_1_0 = "GET /xxx HTTP/1.0\r\n\r\n"
+  
+  specify "should provide the HTTP version" do
+    @server.receive_data(MOCK_GET1)
+    @server.request.http_version.should == '1.1'
+    @server.request.persistent.should == true
+    
+    @server.set_state(:state_initial)
+    @server.receive_data(MOCK_HTTP_1_0)
+    @server.request.http_version.should == '1.0'
+    @server.request.persistent.should == false
+  end
+  
+  specify "should provide the request line" do
+    @server.receive_data(MOCK_GET1)
+    @server.request.request_line.should == 'GET / HTTP/1.1'
+  end
+  
+  MOCK_GET_PARAMS = "GET /?q=state&f=xml HTTP/1.1\r\n\r\n"
+  MOCK_POST_PARAMS = "POST / HTTP/1.1\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 12\r\n\r\nq=state&f=js"
+  
+  specify "should provide the parameters" do
+    @server.receive_data(MOCK_GET1)
+    @server.request.params.should == {}
+
+    @server.set_state(:state_initial)
+    @server.receive_data(MOCK_GET_PARAMS)
+    @server.request.params.should == {:q => 'state', :f => 'xml'}
+
+    @server.set_state(:state_initial)
+    @server.receive_data(MOCK_POST_PARAMS)
+    @server.request.params.should == {:q => 'state', :f => 'js'}
+  end
+  
+  MOCK_GET2 = "GET /xxx HTTP/1.0\r\nHost: reality-scada.net\r\n\r\n"
+  MOCK_GET3 = "GET /xxx HTTP/1.0\r\nHost: abc.net:443\r\n\r\n"
+  MOCK_GET4 = "GET /xxx HTTP/1.0\r\nHost: xyz.net:3321\r\n\r\n"
+  
+  specify "should provide the host and port" do
+    @server.receive_data(MOCK_GET2)
+    @server.request.host.should == 'reality-scada.net'
+    @server.request.port.should be_nil
+    @server.request.should_not be_encrypted
+
+    @server.set_state(:state_initial)
+    @server.receive_data(MOCK_GET3)
+    @server.request.host.should == 'abc.net'
+    @server.request.port.should == 443
+    @server.request.should be_encrypted
+
+    @server.set_state(:state_initial)
+    @server.receive_data(MOCK_GET4)
+    @server.request.host.should == 'xyz.net'
+    @server.request.port.should == 3321
+    @server.request.should_not be_encrypted
+  end
+  
+  MOCK_GET5 = "GET / HTTP/1.1\r\nX-Forwarded-For: 12.33.44.55\r\n\r\n"
+  
+  specify "should provide the client name" do
+    m = Module.new do
+      def get_peername; end
+    end
+    @server.extend(m)
+    
+    @server.receive_data(MOCK_GET1)
+    @server.request.client_name.should be_nil
+
+    @server.set_state(:state_initial)
+    @server.receive_data(MOCK_GET5)
+    @server.request.client_name.should == '12.33.44.55'
+  end
+end
+
+context "Request.accept?" do
+  setup do
+    @req = Request.new(nil)
+  end
+  
+  specify "should return nil if the Accept header is not there" do
+    @req.accept?(//).should be_nil
+  end
+  
+  specify "should match the Accept header to the supplied pattern" do
+    @req.headers[:accept] = 'text/html; text/plain'
+    @req.accept?(/html/).should be_true
+    @req.accept?(/plain/).should be_true
+    @req.accept?(/^text/).should be_true
+    @req.accept?(/text$/).should_not be_true
+  end
+  
+  specify "should support String patterns as well" do
+    @req.headers[:accept] = 'text/html; text/plain'
+    @req.accept?('html').should be_true
+    @req.accept?('plain').should be_true
+    @req.accept?('xml').should_not be_true
+  end
+end