serverside 0.2.9 → 0.3.0

data/spec/server_spec.rb

@@ -0,0 +1,40 @@
+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

data/spec/static_spec.rb

@@ -0,0 +1,279 @@
+require File.join(File.dirname(__FILE__), '../lib/serverside')
+require 'stringio'
+require 'fileutils'
+
+class Dummy < ServerSide::HTTP::Request
+  def self.mime_types
+    @@mime_types
+  end
+  
+  attr_accessor :path, :socket, :headers
+  
+  def initialize
+    super(nil)
+    @headers = {}
+  end
+end
+
+include ServerSide
+
+context "Static.mime_types" do
+  specify "should be a hash" do
+    Dummy.mime_types.should_be_a_kind_of Hash
+  end
+  
+  specify "should return text/plain as the default mime type" do
+    Dummy.mime_types['.rb'].should == 'text/plain'
+    Dummy.mime_types['.invalid'].should == 'text/plain'
+  end
+  
+  specify "should return the correct mime type for common files" do
+    Dummy.mime_types['.html'].should == 'text/html' 
+    Dummy.mime_types['.css'].should == 'text/css' 
+    Dummy.mime_types['.js'].should == 'text/javascript' 
+    Dummy.mime_types['.gif'].should == 'image/gif' 
+    Dummy.mime_types['.jpg'].should == 'image/jpeg' 
+    Dummy.mime_types['.jpeg'].should == 'image/jpeg' 
+    Dummy.mime_types['.png'].should == 'image/png'
+  end
+end
+
+context "Static.serve_file" do
+  specify "should render correctly with file content, etag and size" do
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.serve_file(__FILE__)
+    c.socket.rewind
+    resp = c.socket.read
+    
+    resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+    fc = IO.read(__FILE__)
+    stat = File.stat(__FILE__)
+    etag = (ServerSide::Static::ETAG_FORMAT % 
+      [stat.mtime.to_i, stat.size, stat.ino])
+    resp.should_match /ETag:\s"#{etag}"\r\n/
+    resp.should_match /Content-Length:\s#{stat.size.to_s}\r\n/
+  end
+  
+  specify "should send a not modified response only if a correct etag is specified in the request" do
+    stat = File.stat(__FILE__)
+    etag = (ServerSide::Static::ETAG_FORMAT % 
+      [stat.mtime.to_i, stat.size, stat.ino])
+
+    # normal response
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.serve_file(__FILE__)
+    c.socket.rewind
+    resp = c.socket.read
+    
+    resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+    resp.should_match /ETag:\s"#{etag}"\r\n/
+    resp.should_match /Content-Length:\s#{stat.size.to_s}\r\n/
+      
+    # normal response (invalid etag)
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.headers['If-None-Match'] = "\"xxx-yyy\""
+    c.serve_file(__FILE__)
+    c.socket.rewind
+    resp = c.socket.read
+    
+    resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+    resp.should_match /ETag:\s"#{etag}"\r\n/
+    resp.should_match /Content-Length:\s#{stat.size.to_s}\r\n/
+    
+    # not modified (etag specified)
+    c.socket = StringIO.new
+    c.headers['If-None-Match'] = "\"#{etag}\""
+    c.valid_etag?(etag).should_be true
+    c.serve_file(__FILE__)
+    c.socket.rewind
+    resp = c.socket.read
+
+    resp.should_match /HTTP\/1.1\s304(.*)\r\n/
+
+    # modified response (file stamp changed)
+    FileUtils.touch(__FILE__)
+    c.socket = StringIO.new
+    c.headers['If-None-Match'] = etag
+    c.serve_file(__FILE__)
+    c.socket.rewind
+    resp = c.socket.read
+    
+    resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+    stat = File.stat(__FILE__)
+    etag = (ServerSide::Static::ETAG_FORMAT % 
+      [stat.mtime.to_i, stat.size, stat.ino])
+    resp.should_match /ETag:\s"#{etag}"\r\n/
+    resp.should_match /Content-Length:\s#{stat.size.to_s}\r\n/
+  end
+
+  specify "should serve a 404 response for invalid files" do
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.serve_file('invalid_file.html')
+    c.socket.rewind
+    resp = c.socket.read
+    
+    resp.should_match /HTTP\/1.1\s404(.*)\r\n/
+  end
+end
+
+class IO
+  def self.write(fn, content)
+    File.open(fn, 'w') {|f| f << content}
+  end
+end
+
+class ServerSide::Template
+  def self.reset
+    @@templates = {}
+  end
+end
+
+
+context "Static.serve_template" do
+  specify "should render .rhtml file as template" do
+    IO.write('tmp.rhtml', '<%= @t %>')
+    @t = Time.now.to_f
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.serve_template('tmp.rhtml', binding)
+    c.socket.rewind
+    resp = c.socket.read
+    resp.should.match /\r\n\r\n#{@t}$/
+    FileUtils.rm('tmp.rhtml')
+  end
+  
+  specify "should use its own binding when none is specified" do
+    Template.reset
+    IO.write('tmp.rhtml', '<%= @path %>')
+
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.path = '/test/hey'
+    c.serve_template('tmp.rhtml')
+    c.socket.rewind
+    resp = c.socket.read
+    resp.should.match /\r\n\r\n\/test\/hey$/
+    FileUtils.rm('tmp.rhtml')
+  end
+end
+
+context "Static.serve_dir" do
+  specify "should render a directory with all its entries" do
+    dir = File.dirname(__FILE__)
+  
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.path = dir
+    c.serve_dir(dir)
+    c.socket.rewind
+    resp = c.socket.read
+    
+    Dir.entries(dir).each do |fn|
+      next if fn =~ /^\./
+      resp.should_match /<a href="#{dir/fn}">(#{fn})<\/a>/
+    end
+  end
+end
+
+context "Static.serve_static" do
+  specify "should serve directories" do
+    dir = File.dirname(__FILE__)
+  
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.path = dir
+    c.serve_static(dir)
+    c.socket.rewind
+    resp = c.socket.read
+    
+    Dir.entries(dir).each do |fn|
+      next if fn =~ /^\./
+      resp.should_match /<a href="#{dir/fn}">(#{fn})<\/a>/
+    end
+  end
+  
+  specify "should serve files" do
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.serve_static(__FILE__)
+    c.socket.rewind
+    resp = c.socket.read
+    
+    # normal response
+    resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+    stat = File.stat(__FILE__)
+    etag = (ServerSide::Static::ETAG_FORMAT % 
+      [stat.mtime.to_i, stat.size, stat.ino])
+    resp.should_match /ETag:\s"#{etag}"\r\n/
+    resp.should_match /Content-Length:\s#{stat.size.to_s}\r\n/
+  end
+  
+  specify "should serve templates" do
+    Template.reset
+    IO.write('tmp.rhtml', '<%= 1 + 1%>')
+
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.serve_static('tmp.rhtml')
+    c.socket.rewind
+    resp = c.socket.read
+    
+    resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+    resp.should_match /\r\n\r\n2$/
+    
+    FileUtils.rm('tmp.rhtml')
+  end
+  
+  specify "should serve index.html if exists in directory path" do
+    dir = File.dirname(__FILE__)/:tmp_dir
+    FileUtils.mkdir(dir) rescue nil
+    begin
+      IO.write(dir/'index.html', '<h1>HI</h1>')
+      c = Dummy.new
+      c.socket = StringIO.new
+      c.serve_static(dir)
+      c.socket.rewind
+      resp = c.socket.read
+    
+      resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+      resp.should_match /\r\n\r\n<h1>HI<\/h1>$/
+      resp.should_match /Content-Type: text\/html/
+    ensure
+      FileUtils.rmtree(dir) rescue nil
+    end
+  end
+  
+  specify "should serve index.rhtml if exists in directory path" do
+    dir = File.dirname(__FILE__)/:tmp_dir
+    FileUtils.mkdir(dir) rescue puts "dir already exists"
+    begin
+      IO.write(dir/'index.rhtml', '<h1><%= @path %></h1>')
+      c = Dummy.new
+      c.socket = StringIO.new
+      c.path = dir
+      c.serve_static(dir)
+      c.socket.rewind
+      resp = c.socket.read
+    
+      resp.should_match /HTTP\/1.1\s200(.*)\r\n/
+      resp.should_match /\r\n\r\n<h1>#{dir}<\/h1>$/
+      resp.should_match /Content-Type: text\/html/
+    ensure
+      FileUtils.rmtree(dir) rescue nil
+    end
+  end
+  
+  specify "should serve a 404 response for invalid files" do
+    c = Dummy.new
+    c.socket = StringIO.new
+    c.serve_static('invalid_file.html')
+    c.socket.rewind
+    resp = c.socket.read
+    
+    resp.should_match /HTTP\/1.1\s404(.*)\r\n/
+  end
+end

data/spec/template_spec.rb

@@ -0,0 +1,129 @@
+require File.join(File.dirname(__FILE__), '../lib/serverside')
+require 'stringio'
+require 'fileutils'
+
+class ServerSide::Template
+  def self.templates
+    @@templates
+  end
+  
+  def self.reset
+    @@templates = {}
+  end
+end
+
+class IO
+  def self.write(fn, content)
+    File.open(fn, 'w') {|f| f << content}
+  end
+end
+
+include ServerSide
+
+context "ServerSide::Template.set" do
+  specify "should add an consisting of stamp and template to the templates hash" do
+    Template.reset
+    Template.templates.should_be_empty
+    t = Time.now
+    Template.set('test', 'hello', t)
+    Template.templates.include?('test').should_be true
+    a = Template.templates['test']
+    a.should_be_a_kind_of Array
+    a.size.should == 2
+    a.first.should_be t
+    a.last.should_be_a_kind_of ERB
+  end
+  
+  specify "should set stamp to nil by default" do
+    Template.set('test', 'hello')
+    Template.templates['test'].first.should_be_nil
+  end
+  
+  specify "should construct a new ERB instance with the body" do
+    Template.set('test', 'yo')
+    Template.templates['test'].last.result(binding).should == 'yo'
+  end
+end
+
+context "ServerSide::Template.validate" do
+  specify "should return nil for a non-existant template" do
+    Template.reset
+    Template.validate('test').should_be_nil
+    Template.validate('invalid_file_ref').should_be_nil
+  end
+  
+  specify "should load a file as template if the name references a file" do
+    Template.reset
+    t = Template.validate(__FILE__)
+    t.should_be_a_kind_of ERB
+    t.result(binding).should == IO.read(__FILE__)
+    Template.templates.size.should == 1
+    t = Template.templates[__FILE__]
+    t.first.should == File.mtime(__FILE__)
+    t.last.should_be_a_kind_of ERB
+  end
+  
+  specify "should return the ERB instance for an existing template" do
+    Template.reset
+    t = Template.validate(__FILE__)
+    t.should_be_a_kind_of ERB
+    t.result(binding).should == IO.read(__FILE__)
+  end
+  
+  specify "should reload a file if its stamp changed" do
+    Template.reset
+    IO.write('tmp', '1')
+    Template.validate('tmp').result(binding).should == '1'
+    Template.templates['tmp'].first.should == File.mtime('tmp')
+    sleep 1.5
+    IO.write('tmp', '2')
+    Template.validate('tmp').result(binding).should == '2'
+    Template.templates['tmp'].first.should == File.mtime('tmp')
+    FileUtils.rm('tmp')
+  end
+  
+  specify "should return nil and clear the cache if a cached file has been deleted" do
+    Template.reset
+    IO.write('tmp', '1')
+    Template.validate('tmp').result(binding).should == '1'
+    Template.templates['tmp'].first.should == File.mtime('tmp')
+    FileUtils.rm('tmp')
+    Template.validate('tmp').should_be_nil
+    Template.templates['tmp'].should_be_nil
+  end
+end
+
+context "ServerSide::Template.render" do
+  specify "should raise a RuntimeError for an invalid template" do
+    Template.reset
+    proc {Template.render('invalid', binding)}.should_raise RuntimeError
+  end
+  
+  specify "should render an existing ad-hoc template" do
+    Template.reset
+    Template.set('test', 'hello there')
+    Template.render('test', binding).should == 'hello there'
+  end
+  
+  specify "should render a file-based template" do
+    Template.reset
+    Template.render(__FILE__, binding).should == IO.read(__FILE__)
+  end
+  
+  specify "should validate a file-based template by checking its stamp" do
+    Template.reset
+    IO.write('tmp', '1')
+    Template.render('tmp', binding).should == '1'
+    sleep 1.5
+    IO.write('tmp', '2')
+    Template.render('tmp', binding).should == '2'
+    FileUtils.rm('tmp')
+  end
+  
+  specify "should pass the binding to the ERB instance for processing" do
+    @x = 23
+    Template.reset
+    Template.set('test', '<' + '%= @x %' + '>')
+    Template.render('test', binding).should == '23'
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: serverside
 version: !ruby/object:Gem::Version 
-  version: 0.2.9
-date: 2006-10-25 00:00:00 +02:00
+  version: 0.3.0
+date: 2006-11-27 00:00:00 +02:00
 summary: Performance-oriented web framework.
 require_paths: 
 - lib
@@ -33,46 +33,32 @@ files:
 - README
 - Rakefile
 - bin/serverside
-- test/unit
-- test/functional
-- test/spec
-- test/test_helper.rb
-- test/unit/connection_test.rb
-- test/unit/cluster_test.rb
-- test/unit/daemon_test.rb
-- test/unit/server_test.rb
-- test/unit/static_test.rb
-- test/unit/routing_test.rb
-- test/unit/core_ext_test.rb
-- test/unit/request_test.rb
-- test/unit/template_test.rb
-- test/functional/routing_server.rb
-- test/functional/static_server.rb
-- test/functional/primitive_static_server_test.rb
-- test/functional/request_body_test.rb
-- test/functional/static_profile.rb
-- test/functional/static_rfuzz.rb
-- test/functional/static_server_test.rb
-- test/functional/routing_server_test.rb
-- test/spec/controller_spec.rb
-- test/spec/core_ext_spec.rb
-- test/spec/request_spec.rb
-- test/spec/caching_spec.rb
-- test/spec/connection_spec.rb
-- lib/serverside
+- doc/rdoc
+- spec/core_ext_spec.rb
+- spec/connection_spec.rb
+- spec/caching_spec.rb
+- spec/request_spec.rb
+- spec/template_spec.rb
+- spec/static_spec.rb
+- spec/server_spec.rb
+- spec/routing_spec.rb
+- spec/controllers_spec.rb
+- spec/daemon_spec.rb
+- spec/cluster_spec.rb
 - lib/serverside.rb
-- lib/serverside/connection.rb
-- lib/serverside/cluster.rb
+- lib/serverside
+- lib/serverside/server.rb
 - lib/serverside/daemon.rb
 - lib/serverside/application.rb
-- lib/serverside/controller.rb
-- lib/serverside/server.rb
+- lib/serverside/core_ext.rb
+- lib/serverside/connection.rb
+- lib/serverside/cluster.rb
 - lib/serverside/static.rb
 - lib/serverside/routing.rb
-- lib/serverside/core_ext.rb
-- lib/serverside/request.rb
 - lib/serverside/template.rb
+- lib/serverside/request.rb
 - lib/serverside/caching.rb
+- lib/serverside/controllers.rb
 - CHANGELOG
 test_files: []
 

data/lib/serverside/controller.rb

@@ -1,67 +0,0 @@
-require File.join(File.dirname(__FILE__), 'routing')
-
-module ServerSide
-  class Controller
-    def self.mount(rule = nil, &block)
-      rule ||= block
-      raise ArgumentError, "No routing rule specified." if rule.nil?
-      c = Class.new(self) {}
-      ServerSide::Router.route(rule) {c.new(self)}
-      c
-    end
-    
-    def initialize(request)
-      @request = request
-      @path = request.path
-      @parameters = request.parameters
-      process
-      render_default if not @rendered
-    end
-    
-    def process
-    end
-    
-    def render_default
-      @request.send_response(200, 'text/plain', 'no response.')
-    end
-    
-    def render(body, content_type)
-      @request.send_response(200, content_type, body)
-      @rendered = true
-    end
-  end
-end
-
-__END__
-
-require 'rubygems'
-require 'active_support/inflector'
-require 'metaid'
-
-class ActionController
-  def self.default_routing_rule
-    if name.split('::').last =~ /(.+)Controller$/
-      controller = Inflector.underscore($1) 
-      {:path => ["/#{controller}/:action", "/#{controller}/:action/:id"]}
-    end
-  end
-
-  def self.inherited(c)
-    routing_rule = c.respond_to?(:routing_rule) ?
-      c.routing_rule : c.default_routing_rule
-    if routing_rule
-      ServerSide::Router.route(routing_rule) {c.new(self)}
-    end
-  end
-  
-  def self.route(arg = nil, &block)
-    rule = arg || block
-    meta_def(:get_route) {rule}
-  end
-end
-
-class MyController < ActionController
-  route "hello"
-end
-
-p MyController.get_route

data/test/functional/primitive_static_server_test.rb

@@ -1,61 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'net/http'
-
-class StaticServerTest < Test::Unit::TestCase
-  
-  class StaticRequest < ServerSide::HTTP::Request
-    def respond
-      begin
-#        set_cookie(:hello, 'world', Time.now + 30) if @cookies[:test] == 'hello'
-      rescue => e
-        puts e.message
-      end
-      status = 200
-      body = IO.read('.'/@path)
-    rescue => e
-      status = 404
-      body = "Couldn't open file #{@path}."
-    ensure
-      send_response(status, 'text', body)
-    end
-  end
-  
-  def test_basic
-    @t = Thread.new {ServerSide::HTTP::Server.new('0.0.0.0', 17654, StaticRequest)}
-    sleep 0.1
-
-    h = Net::HTTP.new('localhost', 17654)
-    resp, data = h.get('/qqq', nil)
-    assert_equal 404, resp.code.to_i
-    assert_equal "Couldn't open file /qqq.", data
-    
-    h = Net::HTTP.new('localhost', 17654)
-    resp, data = h.get("/#{__FILE__}", nil)
-    assert_equal 200, resp.code.to_i
-    assert_equal IO.read(__FILE__), data
-    assert_equal 'text', resp['Content-Type']
-    # Net::HTTP includes this header in the request, so our server returns
-    # likewise.
-    assert_equal 'close', resp['Connection']
-  end
-  
-  def test_cookies
-    @t = Thread.new {ServerSide::HTTP::Server.new('0.0.0.0', 17655, StaticRequest)}
-    sleep 0.1
-
-    h = Net::HTTP.new('localhost', 17655)
-    resp, data = h.get('/qqq', nil)
-    assert_equal 404, resp.code.to_i
-    assert_nil resp['Set-Cookie']
-    
-    h = Net::HTTP.new('localhost', 17655)
-    resp, data = h.get('/qqq', {'Cookie' => 'test=hello'})
-    assert_equal 404, resp.code.to_i
-    assert_not_nil resp['Set-Cookie'] =~ /hello=world/
-
-    h = Net::HTTP.new('localhost', 17655)
-    resp, data = h.get('/qqq', nil)
-    assert_equal 404, resp.code.to_i
-    assert_nil resp['Set-Cookie']
-  end
-end