serverside 0.1.59

data/test/functional/static_server_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'net/http'
+
+class StaticServerTest < Test::Unit::TestCase
+  
+  def test_basic
+    t = Thread.new {ServerSide::Server.new('0.0.0.0', 17654, ServerSide::Connection::Static)}
+    sleep 0.1
+
+    h = Net::HTTP.new('localhost', 17654)
+    resp, data = h.get('/qqq.zzz', nil)
+    assert_equal 404, resp.code.to_i
+    assert_equal "Couldn't open file /qqq.zzz.", 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/plain', resp['Content-Type']
+    # Net::HTTP includes this header in the request, so our server returns
+    # likewise.
+    assert_equal 'close', resp['Connection']
+    t.exit
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/serverside')
+require 'test/unit'

data/test/unit/application_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ApplicationTest < Test::Unit::TestCase
+  class App1 < ServerSide::Application::Base
+    configure(:port => 8001)
+  end
+
+  class App2 < ServerSide::Application::Base
+    configure(:port => 8002)
+  end
+
+  def test_config
+    assert_equal 8001, App1.configuration[:port]
+    assert_equal 8002, App2.configuration[:port]
+  end
+end

data/test/unit/cluster_test.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'fileutils'
+
+class ClusterTest < Test::Unit::TestCase
+  FN = Daemon::Cluster::PidFile::FN
+  
+  def test_pid_fn
+    assert_equal 'serverside_cluster.pid', Daemon::Cluster::PidFile::FN
+  end
+  
+  def test_pid_delete
+    FileUtils.touch(FN)
+    assert_equal true, File.file?(FN)
+    Daemon::Cluster::PidFile.delete
+    assert_equal false, File.file?(FN)
+  end
+  
+  def test_pid_store_pid
+    FileUtils.rm(FN) if File.file?(FN)
+    Daemon::Cluster::PidFile.store_pid(1111)
+    assert_equal "1111\n", IO.read(FN)
+    Daemon::Cluster::PidFile.store_pid(2222)
+    assert_equal "1111\n2222\n", IO.read(FN)
+  end
+  
+  def test_pid_recall_pids
+    FileUtils.rm(FN) if File.file?(FN)
+    assert_raise(Errno::ENOENT) {Daemon::Cluster::PidFile.recall_pids}
+    File.open(FN, 'w') {|f| f.puts 3333; f.puts 4444}
+    assert_equal [3333, 4444], Daemon::Cluster::PidFile.recall_pids
+    
+    FileUtils.rm(FN)
+    Daemon::Cluster::PidFile.store_pid(6666)
+    Daemon::Cluster::PidFile.store_pid(7777)
+    assert_equal [6666, 7777], Daemon::Cluster::PidFile.recall_pids
+  end
+  
+  class DummyCluster < Daemon::Cluster
+    FN = 'result'
+    
+    def self.server_loop(port)
+      at_exit {File.open(FN, 'a') {|f| f.puts port}}
+      loop {sleep 60}
+    end
+    
+    def self.ports
+      5555..5556
+    end
+  end
+  
+  def test_fork_server
+    FileUtils.rm(DummyCluster::FN) if File.file?(DummyCluster::FN)
+    pid = DummyCluster.fork_server(1111)
+    sleep 1
+    Process.kill('TERM', pid)
+    sleep 0.1
+    assert_equal true, File.file?(DummyCluster::FN)
+    File.open(DummyCluster::FN, 'r') do |f|
+      assert_equal 1111, f.gets.to_i
+      assert_equal true, f.eof?
+    end
+    FileUtils.rm(DummyCluster::FN) if File.file?(DummyCluster::FN)
+  end
+  
+  def test_start_servers
+    FileUtils.rm(DummyCluster::FN) if File.file?(DummyCluster::FN)
+    DummyCluster.start_servers
+    sleep 0.5
+    pids = Daemon::Cluster::PidFile.recall_pids
+    assert_equal 2, pids.length
+    pids.each {|pid| Process.kill('TERM', pid)}
+    sleep 0.5
+    File.open(DummyCluster::FN, 'r') do |f|
+      p1, p2 = f.gets.to_i, f.gets.to_i
+      assert_equal true, DummyCluster.ports.include?(p1)
+      assert_equal true, DummyCluster.ports.include?(p2)
+      assert p1 != p2
+      assert_equal true, f.eof?
+    end
+    FileUtils.rm(DummyCluster::FN) if File.file?(DummyCluster::FN)
+  end
+  
+  def test_stop_servers
+    DummyCluster.start_servers
+    sleep 0.5
+    pids = Daemon::Cluster::PidFile.recall_pids
+    DummyCluster.stop_servers
+    sleep 0.5
+    assert_equal false, File.file?(FN)
+    File.open(DummyCluster::FN, 'r') do |f|
+      p1, p2 = f.gets.to_i, f.gets.to_i
+      assert_equal true, DummyCluster.ports.include?(p1)
+      assert_equal true, DummyCluster.ports.include?(p2)
+      assert p1 != p2
+      assert_equal true, f.eof?
+    end
+    FileUtils.rm(DummyCluster::FN) if File.file?(DummyCluster::FN)
+  end
+  
+  class DummyCluster2 < Daemon::Cluster
+    def self.daemon_loop
+      @@a = true
+    end
+    
+    def self.start_servers
+      @@b = true
+    end
+    
+    def self.stop_servers
+      @@c = true
+    end
+    
+    def self.a; @@a; end
+    def self.b; @@b; end
+    def self.c; @@c; end
+  end
+  
+  def test_start
+    DummyCluster2.start
+    assert_equal true, DummyCluster2.a
+    assert_equal true, DummyCluster2.b
+    
+    DummyCluster2.stop
+    assert_equal true, DummyCluster2.c
+  end
+  
+  def test_stop
+  end
+end

data/test/unit/connection_test.rb

@@ -0,0 +1,193 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'stringio'
+
+class ConnectionTest < Test::Unit::TestCase
+  class DummyConnection1 < ServerSide::Connection::Base
+    attr_reader :count, :conn
+    
+    def process
+      @count ||= 0
+      @count += 1
+    end
+  end
+
+  def test_new
+    r = DummyConnection1.new('hello')
+    assert_equal 'hello', r.conn
+    assert_equal 1, r.count
+  end
+  
+  class DummyConnection
+    attr_reader :opened
+    
+    def initialize
+      @opened = true
+    end
+    
+    def close
+      @opened = false
+    end
+  end
+  
+  class DummyConnection2 < ServerSide::Connection::Base
+    attr_accessor :count, :persistent
+    
+    def parse_request
+      @count ||= 0
+      @count += 1
+      @persistent = @count < 1000
+    end
+    
+    def respond
+    end
+  end
+  
+  def test_process
+    c = DummyConnection.new
+    r = DummyConnection2.new(c)
+    sleep 0.2
+    assert_equal false, c.opened
+    assert_equal 1000, r.count
+  end
+  
+  class ServerSide::Connection::Base 
+    attr_accessor :conn, :method, :query, :version, :path, :parameters,
+      :headers, :persistent
+  end
+  
+  class DummyConnection3 < ServerSide::Connection::Base
+    def initialize
+    end
+  end
+  
+  def test_parse_request_invalid
+    r = DummyConnection3.new
+    r.conn = StringIO.new('POST /test')
+    assert_nil r.parse_request
+    r.conn = StringIO.new('invalid string')
+    assert_nil r.parse_request
+    r.conn = StringIO.new('GET HTTP/1.1')
+    assert_nil r.parse_request
+    r.conn = StringIO.new('GET /test http')
+    assert_nil r.parse_request
+    r.conn = StringIO.new('GET /test HTTP')
+    assert_nil r.parse_request
+    r.conn = StringIO.new('GET /test HTTP/')
+    assert_nil r.parse_request
+    r.conn = StringIO.new('POST /test HTTP/1.1')
+    assert_nil r.parse_request
+  end
+  
+  def test_parse_request
+    r = DummyConnection3.new
+    r.conn = StringIO.new("POST /test HTTP/1.1\r\n\r\n")
+    assert_kind_of Hash, r.parse_request
+    assert_equal :post, r.method
+    assert_equal '/test', r.path
+    assert_nil r.query
+    assert_equal '1.1', r.version
+    assert_equal({}, r.parameters)
+    assert_equal({}, r.headers)
+    assert_equal true, r.persistent
+
+    # trailing slash in path    
+    r = DummyConnection3.new
+    r.conn = StringIO.new("POST /test/asdf/qw/?time=24%20hours HTTP/1.1\r\n\r\n")
+    assert_kind_of Hash, r.parse_request
+    assert_equal :post, r.method
+    assert_equal '/test/asdf/qw', r.path
+    assert_equal 'time=24%20hours', r.query
+    assert_equal '1.1', r.version
+    assert_equal({:time => '24 hours'}, r.parameters)
+    assert_equal({}, r.headers)
+    assert_equal true, r.persistent
+    
+    r.conn = StringIO.new("GET /cex?q=node_state HTTP/1.1\r\n\r\n")
+    assert_kind_of Hash, r.parse_request
+    assert_equal :get, r.method
+    assert_equal '/cex', r.path
+    assert_equal 'q=node_state', r.query
+    assert_equal({:q => 'node_state'}, r.parameters)
+    
+    r.conn = StringIO.new("GET / HTTP/1.0\r\n\r\n")
+    assert_kind_of Hash, r.parse_request
+    assert_equal false, r.persistent
+
+    r.conn = StringIO.new("GET / HTTP/invalid\r\n\r\n")
+    assert_kind_of Hash, r.parse_request
+    assert_equal 'invalid', r.version
+    assert_equal false, r.persistent
+    
+    r.conn = StringIO.new("GET / HTTP/1.1\r\nConnection: close\r\n\r\n")
+    assert_kind_of Hash, r.parse_request
+    assert_equal '1.1', r.version
+    assert_equal 'close', r.headers['Connection']
+    assert_equal false, r.persistent
+  end
+  
+  def test_send_response
+    r = DummyConnection3.new
+    # simple case
+    r.conn = StringIO.new
+    r.persistent = true
+    r.send_response(200, 'text', 'Hello there!')
+    r.conn.rewind
+    assert_equal "HTTP/1.1 200\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!",
+      r.conn.read
+
+    # include content-length    
+    r.conn = StringIO.new
+    r.persistent = true
+    r.send_response(404, 'text/html', '<h1>404!</h1>', 10) # incorrect length
+    r.conn.rewind
+    assert_equal "HTTP/1.1 404\r\nContent-Type: text/html\r\nContent-Length: 10\r\n\r\n<h1>404!</h1>",
+      r.conn.read
+
+    # headers
+    r.conn = StringIO.new
+    r.persistent = true
+    r.send_response(404, 'text/html', '<h1>404!</h1>', nil, {'ETag' => 'xxyyzz'})
+    r.conn.rewind
+    assert_equal "HTTP/1.1 404\r\nContent-Type: text/html\r\nETag: xxyyzz\r\nContent-Length: 13\r\n\r\n<h1>404!</h1>",
+      r.conn.read
+
+    # no body
+    r.conn = StringIO.new
+    r.persistent = true
+    r.send_response(404, 'text/html', nil, nil, {'Set-Cookie' => 'abc=123'})
+    r.conn.rewind
+    assert_equal "HTTP/1.1 404\r\nConnection: close\r\nContent-Type: text/html\r\nSet-Cookie: abc=123\r\n\r\n",
+      r.conn.read
+    assert_equal false, r.persistent
+
+    # not persistent
+    r.conn = StringIO.new
+    r.persistent = false
+    r.send_response(200, 'text', 'Hello there!')
+    r.conn.rewind
+    assert_equal "HTTP/1.1 200\r\nConnection: close\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!",
+      r.conn.read
+      
+    # socket error
+    r.conn = nil
+    r.persistent = true
+    assert_nothing_raised {r.send_response(200, 'text', 'Hello there!')}
+    assert_equal false, r.persistent
+  end
+  
+  def test_stream
+    r = DummyConnection3.new
+    r.conn = StringIO.new
+    r.stream 'hey there'
+    r.conn.rewind
+    assert_equal 'hey there', r.conn.read
+    
+    r.conn = StringIO.new
+    r.persistent = true
+    r.send_response(404, 'text/html', nil, nil, {'Set-Cookie' => 'abc=123'})
+    r.stream('hey there')
+    r.conn.rewind
+    assert_equal "HTTP/1.1 404\r\nConnection: close\r\nContent-Type: text/html\r\nSet-Cookie: abc=123\r\n\r\nhey there",
+      r.conn.read
+  end
+end

data/test/unit/core_ext_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class StringTest < Test::Unit::TestCase
+  def test_uri_escape
+    assert_equal 'hello', 'hello'.uri_escape
+    assert_equal 'hello+world', 'hello world'.uri_escape
+    assert_equal 'Hello%2C+my+name+is+Inigo+Montoya%21',
+      'Hello, my name is Inigo Montoya!'.uri_escape
+  end
+  
+  def test_uri_unescape
+    assert_equal 'hello', 'hello'.uri_unescape
+    assert_equal 'hello world', 'hello+world'.uri_unescape
+    assert_equal 'Hello, my name is Inigo Montoya!',
+      'Hello%2C+my+name+is+Inigo+Montoya%21'.uri_unescape
+    assert_equal '%&asdf#231&?fgs!', '%&asdf#231&?fgs!'.uri_escape.uri_unescape 
+  end
+  
+  def test_slash
+    assert_equal 'sharon/eylon', 'sharon'/'/eylon'
+    assert_equal 'sharon/122', 'sharon/'/122
+    assert_equal 'test/schmest', 'test'/:schmest
+  end
+end
+
+class SymbolTest < Test::Unit::TestCase
+  def test_to_s
+    assert_equal 'hello', :hello.to_s
+    assert_equal 'yow_za', :yow_za.to_s
+    assert_equal :yow_za.to_s.object_id, :yow_za.to_s.object_id
+  end
+end

data/test/unit/daemon_test.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class DaemonTest < Test::Unit::TestCase
+  class TestDaemon < Daemon::Base
+    def self.start
+      @count = 0
+      loop {@count += 1; sleep 0.1}
+    end
+    
+    def self.result_fn
+      File.join(Daemon::WorkingDirectory, 'test.result')
+    end
+    
+    def self.stop
+      File.open(result_fn, 'w') {|f| f << @count}
+    end
+  end
+
+  def teardown
+    Daemon.control(TestDaemon, :stop) rescue nil
+  end
+  
+  def test_working_directory
+    assert_equal FileUtils.pwd, Daemon::WorkingDirectory
+  end
+  
+  def test_pid_fn
+    assert_equal File.join(Daemon::WorkingDirectory, 'daemon.base.pid'),
+      Daemon::Base.pid_fn
+    
+    assert_equal File.join(Daemon::WorkingDirectory, 'daemontest.testdaemon.pid'),
+      TestDaemon.pid_fn
+  end
+  
+  def test_pid_file_store
+    Daemon::PidFile.store(TestDaemon, 1234)
+    assert_equal IO.read(TestDaemon.pid_fn).to_i, 1234
+  end
+  
+  def test_pid_file_recall
+    FileUtils.rm(TestDaemon.pid_fn) rescue nil
+    assert_raise(RuntimeError) {Daemon::PidFile.recall(TestDaemon)}
+    Daemon::PidFile.store(TestDaemon, 5321)
+    assert_equal 5321, Daemon::PidFile.recall(TestDaemon)
+  end
+  
+  def test_start_stop
+    FileUtils.rm(TestDaemon.result_fn) rescue nil
+    Daemon.control(TestDaemon, :start)
+    sleep 0.2
+    assert_equal true, File.file?(TestDaemon.pid_fn)
+    sleep 0.5
+    assert_nothing_raised {Daemon::PidFile.recall(TestDaemon)}
+    Daemon.control(TestDaemon, :stop)
+    sleep 0.5
+    assert_equal true, File.file?(TestDaemon.result_fn)
+    FileUtils.rm(TestDaemon.result_fn) rescue nil
+  end
+  
+  def test_restart
+    FileUtils.rm(TestDaemon.result_fn) rescue nil
+    Daemon.control(TestDaemon, :start)
+    sleep 0.5
+    pid1 = Daemon::PidFile.recall(TestDaemon)
+    Daemon.control(TestDaemon, :restart)
+    sleep 0.5
+    pid2 = Daemon::PidFile.recall(TestDaemon)
+    assert pid1 != pid2
+    Daemon.control(TestDaemon, :stop)
+  end
+  
+  def test_invalid_control_cmd
+    assert_raise(RuntimeError) {Daemon.control(TestDaemon, :invalid)}
+  end
+end