serverside 0.3.1 → 0.4.1

data/spec/request_spec.rb

@@ -1,288 +0,0 @@
-require File.join(File.dirname(__FILE__), '../lib/serverside')
-require 'stringio'
-
-class DummyRequest2 < ServerSide::HTTP::Request
-  attr_accessor :calls, :parse_result, :persistent
-  
-  def parse
-    @calls ||= []
-    @calls << :parse
-    @parse_result
-  end
-  
-  def respond
-    @calls ||= []
-    @calls << :respond
-  end
-end
-
-context "HTTP::Request.process" do
-  specify "should call parse and and short-circuit if the result is nil" do
-    r = DummyRequest2.new(nil)
-    r.process.should_be_nil
-    r.calls.should == [:parse]
-
-    r.calls = []
-    r.parse_result = false
-    r.process.should_be false
-    r.calls.should == [:parse]
-  end
-  
-  specify "should follow parse with respond and return @persistent" do
-    r = DummyRequest2.new(nil)
-    r.parse_result = true
-    r.process.should_be_nil
-    r.calls.should == [:parse, :respond]
-    
-    r.calls = []
-    r.persistent = 'mau'
-    r.process.should == 'mau'
-    r.calls.should == [:parse, :respond]
-  end
-end
-
-class ServerSide::HTTP::Request
-  attr_writer :socket, :persistent, :response_headers
-end
-
-context "HTTP::Request.parse" do
-  specify "should return nil for invalid requests" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new('POST /test')
-    r.parse.should_be_nil
-    r.socket = StringIO.new('invalid string')
-    r.parse.should_be_nil
-    r.socket = StringIO.new('GET HTTP/1.1')
-    r.parse.should_be_nil
-    r.socket = StringIO.new('GET /test http')
-    r.parse.should_be_nil
-    r.socket = StringIO.new('GET /test HTTP')
-    r.parse.should_be_nil
-    r.socket = StringIO.new('GET /test HTTP/')
-    r.parse.should_be_nil
-    r.socket = StringIO.new('POST /test HTTP/1.1')
-    r.parse.should_be_nil
-  end
-  
-  specify "should parse valid requests and return request headers" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new(
-      "POST /test HTTP/1.1\r\nContent-Type: text/html\r\n\r\n")
-    r.parse.should_be r.headers
-    r.method.should == :post
-    r.path.should == '/test'
-    r.query.should_be_nil
-    r.version.should == '1.1'
-    r.parameters.should == {}
-    r.headers.should == {'Content-Type' => 'text/html'}
-    r.cookies.should == {}
-    r.response_cookies.should_be_nil
-    r.persistent.should == true
-  end
-  
-  specify "should correctly handle trailing slash in path" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new("POST /test/asdf/qw/ HTTP/1.1\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.path.should == '/test/asdf/qw'
-
-    r.socket = StringIO.new(
-      "POST /test/asdf/qw/?time=24%20hours HTTP/1.1\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.path.should == '/test/asdf/qw'
-  end
-  
-  specify "should parse URL-encoded parameters" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new(
-      "POST /test?q=node_history&time=24%20hours HTTP/1.1\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.parameters.size.should == 2
-    r.parameters[:time].should == '24 hours'
-    r.parameters[:q].should == 'node_history'
-  end
-  
-  specify "should correctly parse the HTTP version" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new(
-      "POST / HTTP/1.0\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.version.should == '1.0'
-    r.socket = StringIO.new(
-      "POST / HTTP/3.2\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.version.should == '3.2'
-  end
-  
-  specify "should set @persistent correctly" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new("POST / HTTP/1.0\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.persistent.should == false
-    r.socket = StringIO.new("POST / HTTP/1.1\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.persistent.should == true
-    r.socket = StringIO.new("POST / HTTP/0.6\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.persistent.should == false
-    r.socket = StringIO.new("POST / HTTP/1.1\r\nConnection: close\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.persistent.should == false
-    r.socket = StringIO.new("POST / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.persistent.should == true
-  end
-  
-  specify "should parse cookies" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new(
-      "POST / HTTP/1.0\r\nCookie: abc=1342; def=7%2f4\r\n\r\n")
-    r.parse.should_not_be_nil
-    r.headers['Cookie'].should == 'abc=1342; def=7%2f4'
-    r.cookies.size.should == 2
-    r.cookies[:abc].should == '1342'
-    r.cookies[:def].should == '7/4'
-  end
-  
-  specify "should parse the post body" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new(
-      "POST /?q=node_history HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 15\r\n\r\ntime=24%20hours")
-    r.parse.should_not_be_nil
-    r.parameters.size.should == 2
-    r.parameters[:q].should == 'node_history'
-    r.parameters[:time].should == '24 hours'
-  end
-end
-
-context "HTTP::Request.send_response" do
-  specify "should format a response with status and body" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.send_response(200, 'text', 'Hello there!')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!"
-  end
-  
-  specify "should format a response without connect-close when persistent" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(200, 'text', 'Hello there!')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!"
-  end
-  
-  specify "should format a response without content-length for streaming response" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(200, 'text')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\n"
-    r.stream('hey there')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\nhey there"
-  end
-  
-  specify "should include response_headers and headers in the response" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.persistent = true
-    r.response_headers['XXX'] = 'Test'
-    r.send_response(200, 'text')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nXXX: Test\r\n\r\n"
-
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(200, 'text', nil, nil, {'YYY' => 'TTT'})
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nYYY: TTT\r\n\r\n"
-  end
-  
-  specify "should set persistent to false if exception is raised" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.persistent = true
-    proc {r.send_response(200, 'text', 'Hello there!')}.should_not_raise
-    r.persistent.should == false
-  end
-
-  specify "should include cookies in the response" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    t = Time.now + 360
-    r.set_cookie(:session, "ABCDEFG", t)
-    r.response_cookies.should == "Set-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\n" 
-    r.send_response(200, 'text', 'Hi!')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nSet-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\nContent-Length: 3\r\n\r\nHi!" 
-
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.delete_cookie(:session)
-    r.response_cookies.should == "Set-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\n"
-    r.send_response(200, 'text', 'Hi!')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nSet-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\nContent-Length: 3\r\n\r\nHi!"
-  end
-end
-
-context "HTTP::Request.send_file" do
-  specify "should include a disposition header in the response" do
-    socket = StringIO.new
-    r = ServerSide::HTTP::Request.new(socket)
-    r.send_file('text', 'text/plain', :attachment)
-    socket.rewind
-    socket.read.should_match /Content-Disposition: attachment\r\n/
-  end
-  
-  specify "should use :inline as default disposition" do
-    socket = StringIO.new
-    r = ServerSide::HTTP::Request.new(socket)
-    r.send_file('text', 'text/plain')
-    socket.rewind
-    socket.read.should_match /Content-Disposition: inline\r\n/
-  end
-  
-  specify "should include filename parameter if specified" do
-    socket = StringIO.new
-    r = ServerSide::HTTP::Request.new(socket)
-    r.send_file('text', 'text/plain', :attachment, 'text.txt')
-    socket.rewind
-    socket.read.should_match /Content-Disposition: attachment; filename=text.txt\r\n/
-  end
-  
-  specify "should include a description header if specified" do
-    socket = StringIO.new
-    r = ServerSide::HTTP::Request.new(socket)
-    r.send_file('text', 'text/plain', :attachment, 'text.txt')
-    socket.rewind
-    socket.read.should_not_match /Content-Description:\s/
-
-    socket = StringIO.new
-    r = ServerSide::HTTP::Request.new(socket)
-    r.send_file('text', 'text/plain', :attachment, 'text.txt', 'this is text.')
-    socket.rewind
-    socket.read.should_match /Content-Description:\sthis is text\./
-  end
-end
-
-context "HTTP::Request.redirect" do
-  specify "should send a 302 response for temporary redirect" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.redirect('http://mau.com/132')
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 302\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n"
-  end
-  
-  specify "should send a 301 response for permanent redirect" do
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.redirect('http://mau.com/132', true)
-    r.socket.rewind
-    r.socket.read.should == "HTTP/1.1 301\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n"
-  end
-end

data/spec/routing_spec.rb

@@ -1,240 +0,0 @@
-require File.join(File.dirname(__FILE__), '../lib/serverside')
-require 'stringio'
-
-class ServerSide::Router
-  attr_accessor :t, :parameters, :path
-  
-  def self.rules
-    @@rules
-  end
-  
-  def self.reset
-    @@rules = []
-    @@default_route = nil
-    define_method(:respond) {nil}
-  end
-end
-
-R = ServerSide::Router
-
-context "Router.routes_defined?" do
-  specify "should return nil if no routes were defined" do
-    R.reset
-    R.routes_defined?.should_be_nil
-  end
-  
-  specify "should return true if routes were defined" do
-    R.reset
-    R.route('/controller') {}
-    R.routes_defined?.should_be true
-  end
-end
-
-context "Router.route" do
-  specify "should add the rule to @@rules" do
-    l = proc {1 + 1}
-    R.reset
-    R.route(:path => '/t', &l)
-    R.rules.size.should == 1
-    R.rules[0][0].should == {:path => '/t'}
-    R.rules[0][1].should == l
-  end
-  
-  specify "should convert a string argument to a path rule" do
-    R.reset
-    R.route('/test') {}
-    R.rules[0][0].should == {:path => '/test'}
-  end
-  
-  specify "should convert a regexp argument to a path rule" do
-    R.reset
-    R.route(/abc/) {}
-    R.rules[0][0].should == {:path => /abc/}
-  end
-  
-  specify "should convert an array argument into a multiple path rule" do
-    R.reset
-    R.route(['/a', '/b', '/c']) {}
-    R.rules[0][0].should == {:path => ['/a', '/b', '/c']}
-  end
-  
-  specify "should store a hash argument as the rule" do
-    R.reset
-    R.route(:a => 'abc', :b => 'def') {}
-    R.rules[0][0].should_be_a_kind_of Hash
-    R.rules[0][0].size.should == 2
-    R.rules[0][0][:a].should == 'abc'
-    R.rules[0][0][:b].should == 'def'
-  end
-  
-  specify "should unshift new rules into the rules array" do
-    R.reset
-    R.route('abc') {}
-    R.route('def') {}
-    R.route('ghi') {}
-    R.rules.size.should == 3
-    R.rules[0][0][:path].should == 'ghi'
-    R.rules[1][0][:path].should == 'def'
-    R.rules[2][0][:path].should == 'abc'
-  end
-  
-  specify "should accept a proc as a rule" do
-    R.reset
-    l1 = proc {}
-    l2 = proc {}
-    R.route(l1, &l2)
-    R.rules.size.should == 1
-    R.rules[0][0].should_be l1
-    R.rules[0][1].should_be l2
-  end
-end
-
-context "Router.compile_rules" do
-  specify "should compile a respond method for routing requests" do
-    R.reset
-    R.new(StringIO.new).respond.should_be_nil
-    R.rules << [{:t => 'abc'}, proc{:abc}]
-    R.rules << [{:t => 'def'}, proc{:def}]
-    R.default_route {:default}
-    # R.compile_rules - already called by default_route
-    r = R.new(StringIO.new)
-    r.t = 'abc'
-    r.respond.should == :abc
-    r.t = 'def'
-    r.respond.should == :def
-    r.t = ''
-    r.respond.should == :default
-  end
-  
-  specify "should allow handlers to give up on a request, and then pass it on." do
-    R.reset
-    R.default_route {:default}
-    R.new(StringIO.new).respond.should == :default
-    R.route('.*') {@path == '/first' ? :first : nil}
-    R.route('.*') {@path == '/second' ? :second : nil}
-    r = R.new(StringIO.new)
-    r.path = '/second'
-    r.respond.should == :second
-    r.path = '/first'
-    r.respond.should == :first
-    r.path = '/other'
-    r.respond.should == :default
-  end
-end
-
-context "Router.rule_to_statement" do
-  specify "should define procs as methods and construct a test expression" do
-    l1 = proc {}
-    l2 = proc {}
-    R.rule_to_statement(l1, l2).should == "if #{l1.proc_tag} && (r = #{l2.proc_tag}); return r; end\n"
-    r = R.new(StringIO.new)
-    r.should_respond_to l1.proc_tag
-    r.should_respond_to l2.proc_tag
-  end
-  
-  specify "should convert hash rule with single key-value to a test expression" do
-    l3 = proc {}
-    s = R.rule_to_statement({:path => '/.*'}, l3)
-    s =~ /^if \(@path =~ ([^\(]*)\)/
-    eval("R::#{$1}").should == /\/.*/
-    r = R.new(StringIO.new)
-    r.should_respond_to l3.proc_tag
-  end
-    
-  specify "should convert hash with multiple key-values to an OR test expression" do
-    l4 = proc {}
-    
-    s = R.rule_to_statement({:path => '/controller', :host => 'static'}, l4)
-    s.should_match /\(@path\s=~\s([^\)]+)\)/
-    s =~ /\(@path\s=~\s([^\)]+)\)/
-    eval("R::#{$1}").should == /\/controller/
-    s.should_match /\(@host\s=~\s([^\)]+)\)/
-    s =~ /\(@host\s=~\s([^\)]+)\)/
-    eval("R::#{$1}").should == /static/ 
-    r = R.new(StringIO.new)
-    r.should_respond_to l4.proc_tag
-  end
-  
-  specify "should convert hash with Array value to a test expression" do
-    l5 = proc {}
-    s = R.rule_to_statement({:path => ['/x', '/y']}, l5)
-    s =~ /^if\s\(\(@path\s=~\s([^\)]*)\)\|\|\(@path\s=~\s([^\)]*)\)\)/
-    eval("R::#{$1}").should == /\/x/
-    eval("R::#{$2}").should == /\/y/
-    r = R.new(StringIO.new)
-    r.should_respond_to l5.proc_tag
-  end
-end
-
-context "Router.condition part" do
-  specify "should compile a condition expression with key and value" do
-    s = R.condition_part(:path, 'abc')
-    s.should_match /\(@path\s=~\s(.*)\)$/
-    s =~ /\(@path\s=~\s(.*)\)$/
-    eval("R::#{$1}").should == /abc/
-  end
-  
-  specify "should parse parametrized value and compile it into a lambda" do
-    s = R.condition_part(:t, ':action/:id')
-    (s =~ /^\((.*)\)$/).should_not_be_nil
-    tag = $1
-    r = R.new(StringIO.new)
-    r.should_respond_to tag
-    r.parameters = {}
-    r.t = 'abc'
-    r.send(tag).should_be false
-    r.t = 'show/16'
-    r.send(tag).should_be true
-    r.parameters[:action].should == 'show'
-    r.parameters[:id].should == '16' 
-  end
-end
-
-context "Router.define_proc" do
-  specify "should convert a lambda into an instance method" do
-    l1 = proc {1 + 1}
-    tag = R.define_proc(&l1)
-    tag.should_be_a_kind_of Symbol
-    tag.should == l1.proc_tag.to_sym
-    r = R.new(StringIO.new)
-    r.should_respond_to(tag)
-    r.send(tag).should == 2
-  end
-end
-
-context "Router.cache_constant" do
-  specify "should cache a value as a constant inside the Router namespace" do
-    c = rand(100000)
-    tag = R.cache_constant(c)
-    tag.should_be_a_kind_of String
-    tag.should == c.const_tag
-    eval("R::#{tag}").should == c
-  end
-end
-
-context "Router.default_route" do
-  specify "should set the default route" do
-    R.default_route {'mau m'}
-    R.new(StringIO.new).default_handler.should == 'mau m'
-
-    R.default_route {654321}
-    R.new(StringIO.new).default_handler.should == 654321
-  end
-  
-  specify "should affect the result of routes_defined?" do
-    R.reset
-    R.routes_defined?.should_be_nil
-    R.default_route {654321}
-    R.routes_defined?.should_not_be_nil
-  end
-end
-
-context "Router.unhandled" do
-  specify "should send a 403 response" do
-    r = R.new(StringIO.new)
-    r.unhandled
-    r.socket.rewind
-    resp = r.socket.read
-    resp.should_match /HTTP\/1.1\s403(.*)\r\n/
-  end
-end

data/spec/server_spec.rb

@@ -1,40 +0,0 @@
-require File.join(File.dirname(__FILE__), '../lib/serverside')
-require 'stringio'
-require 'fileutils'
-
-include ServerSide::HTTP
-
-$http_connection_created = false
-
-class Connection
-  alias_method :orig_initialize, :initialize
-  def initialize(socket, request_class)
-    orig_initialize(socket, request_class)
-    if (request_class == ServerSide::HTTP::Request) && socket.is_a?(TCPSocket)
-      $http_connection_created = true
-    end
-  end
-end
-
-context "HTTP::Server" do
-  specify "should open TCP port for listening" do
-    server = Server.new('0.0.0.0', 17863, Request)
-    t = Thread.new {server.start}
-    proc {TCPServer.new('0.0.0.0', 17863)}.should_raise Errno::EADDRINUSE
-    t.exit
-    t.alive?.should_be false
-    server.listener.close
-  end
-  
-  specify "should loop indefinitely, accepting connections" do
-    $http_connection_created = false
-    server = Server.new('0.0.0.0', 17863, Request)
-    t = Thread.new {server.start}
-    sleep 0.2
-    s = nil
-    proc {s = TCPSocket.new('localhost', 17863)}.should_not_raise
-    sleep 0.2
-    $http_connection_created.should == true
-    server.listener.close
-  end
-end