io-reactor 0.05 → 1.0.4

data/rake/testing.rb

@@ -0,0 +1,191 @@
+# 
+# Rake tasklib for testing tasks
+# $Id: testing.rb 14 2008-07-23 23:16:30Z deveiant $
+# 
+# Authors:
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+
+COVERAGE_MINIMUM = 85.0 unless defined?( COVERAGE_MINIMUM )
+SPEC_FILES       = [] unless defined?( SPEC_FILES )
+TEST_FILES       = [] unless defined?( TEST_FILES )
+
+COMMON_SPEC_OPTS = ['-c', '-f', 's'] unless defined?( COMMON_SPEC_OPTS )
+
+COVERAGE_TARGETDIR = BASEDIR + 'coverage' unless defined?( COVERAGE_TARGETDIR )
+RCOV_EXCLUDES      = 'spec,tests,/Library/Ruby,/var/lib,/usr/local/lib' unless
+	defined?( RCOV_EXCLUDES )
+
+
+desc "Run all defined tests"
+task :test do
+	unless SPEC_FILES.empty?
+		log "Running specs"
+		Rake::Task['spec:quiet'].invoke
+	end
+	
+	unless TEST_FILES.empty?
+		log "Running unit tests"
+		Rake::Task[:unittests].invoke 
+	end
+end
+
+
+### RSpec specifications
+begin
+	gem 'rspec', '>= 1.1.3'
+	require 'spec/rake/spectask'
+
+	### Task: spec
+	Spec::Rake::SpecTask.new( :spec ) do |task|
+		task.spec_files = SPEC_FILES
+		task.libs += [LIBDIR]
+		task.spec_opts = COMMON_SPEC_OPTS
+	end
+
+
+	namespace :spec do
+		desc "Run rspec every time there's a change to one of the files"
+		task :autotest do
+			require 'autotest/rspec'
+
+			autotester = Autotest::Rspec.new
+			autotester.exceptions = %r{\.svn|\.skel}
+			autotester.run
+		end
+
+
+		desc "Generate quiet output"
+		Spec::Rake::SpecTask.new( :quiet ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f', 'p', '-D']
+		end
+
+		desc "Generate HTML output for a spec run"
+		Spec::Rake::SpecTask.new( :html ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f','h', '-D']
+		end
+
+		desc "Generate plain-text output for a CruiseControl.rb build"
+		Spec::Rake::SpecTask.new( :text ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f','p']
+		end
+	end
+rescue LoadError => err
+	task :no_rspec do
+		$stderr.puts "Specification tasks not defined: %s" % [ err.message ]
+	end
+
+	task :spec => :no_rspec
+	namespace :spec do
+		task :autotest => :no_rspec
+		task :quiet => :no_rspec
+		task :html => :no_rspec
+		task :text => :no_rspec
+	end
+end
+
+
+### Test::Unit tests
+begin
+	require 'rake/testtask'
+	
+	Rake::TestTask.new( :unittests ) do |task|
+		task.libs += [LIBDIR]
+		task.test_files = TEST_FILES
+		task.verbose = true
+	end
+
+rescue LoadError => err
+	task :no_test do
+		$stderr.puts "Test tasks not defined: %s" % [ err.message ]
+	end
+
+	task :unittests => :no_rspec
+end
+
+	
+### RCov (via RSpec) tasks
+begin
+	gem 'rcov'
+	gem 'rspec', '>= 1.1.3'
+
+	### Task: coverage (via RCov)
+	### Task: rcov
+	desc "Build test coverage reports"
+	unless SPEC_FILES.empty?
+		Spec::Rake::SpecTask.new( :coverage ) do |task|
+			task.spec_files = SPEC_FILES
+			task.libs += [LIBDIR]
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS
+			task.rcov = true
+		end
+	end
+	unless TEST_FILES.empty?
+		require 'rcov/rcovtask'
+
+		Rcov::RcovTask.new do |task|
+			task.libs += [LIBDIR]
+			task.test_files = TEST_FILES
+			task.verbose = true
+			task.rcov_opts = RCOV_OPTS
+		end
+	end
+
+
+	task :rcov => [:coverage] do; end
+
+	### Other coverage tasks
+	namespace :coverage do
+		desc "Generate a detailed text coverage report"
+		Spec::Rake::SpecTask.new( :text ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = RCOV_OPTS + ['--text-report']
+			task.rcov = true
+		end
+
+		desc "Show differences in coverage from last run"
+		Spec::Rake::SpecTask.new( :diff ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = ['--text-coverage-diff']
+			task.rcov = true
+		end
+
+		### Task: verify coverage
+		desc "Build coverage statistics"
+		VerifyTask.new( :verify => :rcov ) do |task|
+			task.threshold = COVERAGE_MINIMUM
+		end
+
+		desc "Run RCov in 'spec-only' mode to check coverage from specs"
+		Spec::Rake::SpecTask.new( :speconly ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = ['--exclude', RCOV_EXCLUDES, '--text-report', '--save']
+			task.rcov = true
+		end
+	end
+
+	task :clobber_coverage do
+		rmtree( COVERAGE_TARGETDIR )
+	end
+
+rescue LoadError => err
+	task :no_rcov do
+		$stderr.puts "Coverage tasks not defined: RSpec+RCov tasklib not available: %s" %
+		[ err.message ]
+	end
+
+	task :coverage => :no_rcov
+	task :clobber_coverage
+	task :rcov => :no_rcov
+	namespace :coverage do
+		task :text => :no_rcov
+		task :diff => :no_rcov
+	end
+	task :verify => :no_rcov
+end
+
+

data/rake/verifytask.rb

@@ -0,0 +1,64 @@
+#####################################################################
+###	S U B V E R S I O N   T A S K S   A N D   H E L P E R S
+#####################################################################
+
+require 'rake/tasklib'
+
+#
+# Work around the inexplicable behaviour of the original RDoc::VerifyTask, which 
+# errors if your coverage isn't *exactly* the threshold.
+# 
+
+# A task that can verify that the RCov coverage doesn't
+# drop below a certain threshold. It should be run after
+# running Spec::Rake::SpecTask.
+class VerifyTask < Rake::TaskLib
+	
+	COVERAGE_PERCENTAGE_PATTERN = 
+		%r{<tt class='coverage_code'>(\d+\.\d+)%</tt>}
+	
+	# Name of the task. Defaults to :verify_rcov
+	attr_accessor :name
+
+	# Path to the index.html file generated by RCov, which
+	# is the file containing the total coverage.
+	# Defaults to 'coverage/index.html'
+	attr_accessor :index_html
+
+	# Whether or not to output details. Defaults to true.
+	attr_accessor :verbose
+
+	# The threshold value (in percent) for coverage. If the 
+	# actual coverage is not equal to this value, the task will raise an 
+	# exception. 
+	attr_accessor :threshold
+
+	def initialize( name=:verify )
+		@name = name
+		@index_html = 'coverage/index.html'
+		@verbose = true
+		yield self if block_given?
+		raise "Threshold must be set" if @threshold.nil?
+		define
+	end
+
+	def define
+		desc "Verify that rcov coverage is at least #{threshold}%"
+
+		task @name do
+			total_coverage = nil
+			if match = File.read( index_html ).match( COVERAGE_PERCENTAGE_PATTERN )
+				total_coverage = Float( match[1] )
+			else
+				raise "Couldn't find the coverage percentage in #{index_html}"
+			end
+
+			puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
+			if total_coverage < threshold
+				raise "Coverage must be at least #{threshold}% but was #{total_coverage}%"
+			end
+		end
+	end
+end
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/io/reactor_spec.rb

@@ -0,0 +1,269 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+begin
+	require 'tmpdir'
+	require 'spec/runner'
+	require 'io/reactor'
+	require 'socket'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+
+TMPFILE   = Pathname.new( Dir.tmpdir ) + "ioreactor-spec.#{Process.pid}"
+HOST      = 'localhost'
+PORT      = 5656
+TEST_DATA = File.read( __FILE__ )
+
+$stderr.sync = $stdout.sync = true
+
+
+describe IO::Reactor do
+
+	before( :each ) do
+		@reactor = IO::Reactor.new
+		@reader, @writer = IO.pipe
+	end
+
+	after( :each ) do
+		@reactor.clear
+	end
+	
+
+	### #register/#registered? with no block
+	it "allows registration of an IO for write events" do
+		@reactor.register( @writer, :write )
+
+		@reactor.should be_registered( @writer )
+		@reactor.handles[ @writer ][ :events ].should == [:write]
+	end
+
+	it "allows registration of an IO for read events" do
+		@reactor.register( @reader, :read )
+
+		@reactor.should be_registered( @reader )
+		@reactor.handles[ @reader ][ :events ].should == [:read]
+	end
+
+	it "allows registration of an IO for error events" do
+		@reactor.register( @writer, :error )
+
+		@reactor.should be_registered( @writer )
+		@reactor.handles[ @writer ][ :events ].should == [:error]
+	end
+
+	it "allows registration of an IO for multiple events" do
+		@reactor.register( @writer, :read, :write )
+
+		@reactor.should be_registered( @writer )
+		@reactor.handles[ @writer ][ :events ].should have(2).members
+		@reactor.handles[ @writer ][ :events ].should include( :read )
+		@reactor.handles[ @writer ][ :events ].should include( :write )
+	end
+
+
+	it "allows registration of a handler with an IO for selected events" do
+		@reactor.register( @writer, :write ) {|io, event|  }
+
+		@reactor.should be_registered( @writer )
+		@reactor.handles[ @writer ][ :events ].should == [:write]
+	end
+
+
+	it "allows registration of an argument list with a handler" do
+		@reactor.register( @writer, :write, "foo", :bar, :something ) {|io, event|  }
+
+		@reactor.should be_registered( @writer )
+		@reactor.handles[ @writer ][ :events ].should == [:write]
+		@reactor.handles[ @writer ][ :args ].should == ["foo", :bar, :something]
+	end
+
+
+	it "allows all registered handles to be cleared" do
+		@reactor.register( @reader, :read )
+		@reactor.register( @writer, :write )
+
+		@reactor.clear
+
+		@reactor.handles.should be_empty()
+		@reactor.should_not be_registered( @writer )
+		@reactor.should_not be_registered( @reader )
+	end
+
+
+	it "calls registered handlers for events on an IO when they occur" do
+		data_to_send = TEST_DATA.dup
+		received_data = ''
+		
+		@reactor.register( @reader, :read ) do |io, event|
+			if io.eof?
+				@reactor.unregister( io )
+				io.close
+			else
+				received_data << io.read( 256 )
+			end
+		end
+		@reactor.register( @writer, :write ) do |io, event|
+			if data_to_send.empty?
+				@reactor.unregister( io )
+				io.close
+			else
+				bytes = io.write( data_to_send )
+				data_to_send.slice!( 0, bytes )
+			end
+		end
+
+		@reactor.poll until @reactor.empty?
+		
+		received_data.should == TEST_DATA
+	end
+	
+	
+	it "calls a provided fallback handler if there is no handler registered for an " +
+	   "event when it occurs" do
+
+		data_to_send = TEST_DATA.dup
+		received_data = ''
+		
+		@reactor.register( @reader, :read )
+		@reactor.register( @writer, :write )
+
+		until @reactor.empty?
+			@reactor.poll do |io, event|
+				case event
+				when :read
+					if io.eof?
+						@reactor.unregister( io )
+						io.close
+					else
+						received_data << io.read( 256 )
+					end
+
+				when :write
+					if data_to_send.empty?
+						@reactor.unregister( io )
+						io.close
+					else
+						bytes = io.write( data_to_send )
+						data_to_send.slice!( 0, bytes )
+					end
+					
+				when :error
+					@reactor.unregister( io )
+					io.close
+				else
+					fail "Reactor got unexpected event %p on %p" % [ event, io ]
+				end
+			end
+		end
+		
+		received_data.should == TEST_DATA
+	end
+
+
+	### A class that will encapsulate how we want to read or write from the Reactor
+	class IOStrategy
+		def initialize( reactor, buffer='' )
+			@reactor = reactor
+			@buffer = buffer
+		end
+		
+		attr_reader :buffer
+		
+		def read_from( io, event )
+			raise ArgumentError, "expected to read, not #{event}" unless event == :read
+			if io.eof?
+				@reactor.unregister( io )
+				io.close
+			else
+				@buffer << io.read( 256 )
+			end
+		end
+		
+		def write_to( io, event )
+			raise ArgumentError, "expected to write, not #{event}" unless event == :write
+			if @buffer.empty?
+				@reactor.unregister( io )
+				io.close
+			else
+				bytes = io.write( @buffer )
+				@buffer.slice!( 0, bytes )
+			end
+		end
+	end
+	
+	it "uses method or proc handlers if those are used instead of blocks" do
+		reader = IOStrategy.new( @reactor )
+		writer = IOStrategy.new( @reactor, TEST_DATA.dup )
+		
+		@reactor.register( @reader, :read, &reader.method(:read_from) )
+		@reactor.register( @writer, :write, &writer.method(:write_to) )
+		@reactor.poll until @reactor.empty?
+		
+		reader.buffer.should == TEST_DATA
+	end
+	
+	
+	it "saves pending events if there is no handler registered for them and no fallback " +
+	   "handler provided" do
+
+		@reactor.register( $stdout, :write )
+		@reactor.poll( 1.0 ).should == 1
+		
+		@reactor.pending_events.should have(1).members
+		@reactor.pending_events.keys.should include( $stdout )
+		@reactor.pending_events[ $stdout ].should == [ :write ]
+	end
+
+	it "knows what events are enabled for which handles" do
+		@reactor.register( @writer )
+		@reactor.should_not have_event_enabled( @writer, :read )
+		@reactor.enable_events( @writer, :read, :write )
+		@reactor.should have_event_enabled( @writer, :read )
+		@reactor.should have_event_enabled( @writer, :write )
+	end
+
+
+	it "allows events to be unregistered for a handle" do
+		@reactor.register( @writer, :write, :read )
+		@reactor.disable_events( @writer, :read )
+		@reactor.should_not have_event_enabled( @writer, :read )
+	end
+	
+
+	it "doesn't allow the error event to be disabled for a handle" do
+		@reactor.register( @writer, :write )
+		lambda {
+			@reactor.disable_events( @writer, :error )
+		}.should raise_error
+	end
+
+
+	it "can remove the handler for a handle" do
+		handler = lambda { }
+		@reactor.register( @writer, :write, &handler )
+		@reactor.remove_handler( @writer ).should == handler
+	end
+
+
+	it "can clear the handler arguments for a handle" do
+		@reactor.register( @writer, :write, :an_arg )
+		@reactor.remove_args( @writer )
+		@reactor.handles[ @writer ][:args].should be_empty()
+	end
+
+end # class PollTestCase
+