em-spec 0.2.0

data/README.rdoc

@@ -0,0 +1,84 @@
+Simple BDD API for testing asynchronous Ruby/EventMachine code
+(c) 2008 Aman Gupta (tmm1)
+
+em-spec can be used with either bacon or rspec.
+
+=Rspec
+There are two ways to use the Rspec extension.  To use it as a helper, include EM::SpecHelper in your describe block.  You then use the em method to wrap your evented test code.  Inside the em block, you must call #done after your expectations.  Everything works normally otherwise.
+
+  require "em-spec/rspec"
+  describe EventMachine do
+    include EM::SpecHelper
+  
+    it "works normally when not using #em" do
+      1.should == 1
+    end
+  
+    it "makes testing evented code easy with #em" do
+      em do
+        start = Time.now
+
+        EM.add_timer(0.5){
+          (Time.now-start).should be_close( 0.5, 0.1 )
+          done
+        }
+      end
+    end
+  end
+The other option is to include EM::Spec in your describe block.  This will patch Rspec so that all of your examples run inside an em block automatically:
+  require "em-spec/rspec"
+  describe EventMachine do
+    include EM::Spec
+    
+    it "requires a call to #done every time" do
+      1.should == 1
+      done
+    end
+    
+    it "runs test code in an em block automatically" do
+      start = Time.now
+
+      EM.add_timer(0.5){
+        (Time.now-start).should be_close( 0.5, 0.1 )
+        done
+      }
+    end
+  end
+
+=Bacon
+The API is identical to Bacon, except that you must explicitly call 'done' after all the current behavior's assertions have been made:
+
+  require 'em-spec/bacon'
+
+  EM.describe EventMachine do
+
+    should 'have timers' do
+      start = Time.now
+
+      EM.add_timer(0.5){
+        (Time.now-start).should.be.close 0.5, 0.1
+        done
+      }
+    end
+
+    should 'have periodic timers' do
+      num = 0
+      start = Time.now
+
+      timer = EM.add_periodic_timer(0.5){
+        if (num += 1) == 2
+          (Time.now-start).should.be.close 1.0, 0.1
+          EM.__send__ :cancel_timer, timer
+          done
+        end
+      }
+    end
+
+  end
+
+
+Resources:
+
+* Git repository: http://github.com/tmm1/em-spec
+* Bacon: http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/30b07b651b0662fd
+* Initial announcement: http://groups.google.com/group/eventmachine/browse_thread/thread/8b4e7ead72f9d013

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rake/testtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "em-spec"
+    s.description = s.summary = "Simple BDD API for testing asynchronous Ruby/EventMachine code"
+    s.email = "aman@tmm1.net"
+    s.homepage = "http://github.com/joshbuddy/em-spec"
+    s.authors = ["Aman Gupta"]
+    s.files = FileList["[A-Z]*", "{lib,test}/**/*"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+task :default => :spec
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test_spec.rb']
+  t.verbose = true
+end
+
+task :spec do
+  sh('rake test') rescue nil
+  sh('bacon test/bacon_spec.rb') rescue nil
+  sh 'spec -f specdoc test/rspec_spec.rb test/rspec_fail_examples.rb'
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/em-spec/bacon.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/../ext/fiber18'
+require 'rubygems'
+require 'eventmachine'
+
+module EventMachine
+  
+  def self.spec_backend=( backend )
+    @spec_backend = backend
+  end
+  
+  def self.spec_backend
+    @spec_backend
+  end
+  
+  def self.spec *args, &blk
+    raise ArgumentError, 'block required' unless block_given?
+    raise 'EventMachine reactor already running' if EM.reactor_running?
+
+    spec_backend.spec( args, blk )
+  end
+  class << self; alias :describe :spec; end
+
+  def self.bacon( *args, &block )
+    require File.dirname(__FILE__) + '/spec/bacon'
+    self.spec_backend = EventMachine::Spec::Bacon
+    self.spec( args, &block )
+  end
+
+end
+
+module EventMachine
+  module Spec
+    module Bacon
+      
+      def self.spec( args, blk )
+        EM.run do
+          ::Bacon.summary_on_exit
+          ($em_spec_fiber = Fiber.new{
+                              ::Bacon::FiberedContext.new(args.join(' '), &blk).run
+                              EM.stop_event_loop
+                            }).resume
+        end
+      end
+      
+    end
+  end
+end
+
+class Bacon::FiberedContext < Bacon::Context
+
+  SpecTimeoutExceededError = Class.new(RuntimeError)
+
+  def default_timeout(timeout)
+    $_em_default_time_to_finish = timeout
+  end
+
+  def cancel_timer
+    EM.cancel_timer($_em_timer) if $_em_timer
+  end
+
+  def timeout(time_to_run)
+    cancel_timer
+    $_em_timer = EM.add_timer(time_to_run) { done(false) }
+  end
+
+  def it *args
+    super{
+      if block_given?
+        if $_em_default_time_to_finish
+          timeout($_em_default_time_to_finish)
+        end
+        yield
+        Fiber.yield
+      end
+    }
+  end
+
+  def done(succeed = true)
+    cancel_timer
+    EM.next_tick{
+      if succeed 
+        :done.should == :done
+      else
+        should.flunk
+      end
+      $em_spec_fiber.resume if $em_spec_fiber
+    }
+  end
+end

data/lib/em-spec/rspec.rb

@@ -0,0 +1,71 @@
+require 'eventmachine'
+require File.dirname(__FILE__) + '/../ext/fiber18'
+
+module EventMachine
+  module SpecHelper
+    
+    SpecTimeoutExceededError = Class.new(RuntimeError)
+    
+    def self.included(cls)
+      ::Spec::Example::ExampleGroup.instance_eval "
+      @@_em_default_time_to_finish = nil
+      def self.default_timeout(timeout)
+        @@_em_default_time_to_finish = timeout
+      end
+      "
+    end
+    
+    def timeout(time_to_run)
+      EM.cancel_timer(@_em_timer) if @_em_timer
+      @_em_timer = EM.add_timer(time_to_run) { done; raise SpecTimeoutExceededError.new }
+    end
+    
+    def em(time_to_run = @@_em_default_time_to_finish, &block)
+      EM.run do
+        timeout(time_to_run) if time_to_run
+        em_spec_exception = nil
+        @_em_spec_fiber = Fiber.new do
+          begin
+            block.call
+          rescue Exception => em_spec_exception
+            done
+          end
+          Fiber.yield
+        end  
+
+        @_em_spec_fiber.resume
+
+        raise em_spec_exception if em_spec_exception
+      end
+    end
+
+    def done
+      EM.next_tick{
+        finish_em_spec_fiber
+      }
+    end
+
+    private
+
+    def finish_em_spec_fiber
+      EM.stop_event_loop if EM.reactor_running?
+      @_em_spec_fiber.resume if @_em_spec_fiber.alive?
+    end
+    
+  end
+  
+  module Spec
+
+    include SpecHelper
+
+    def instance_eval(&block)
+      em do
+        super(&block)
+      end
+    end
+
+  end
+  
+end
+
+

data/lib/em-spec/test.rb

@@ -0,0 +1,93 @@
+require 'eventmachine'
+require File.dirname(__FILE__) + '/../ext/fiber18'
+
+module EventMachine
+  TestTimeoutExceededError = Class.new(RuntimeError)
+
+  module TestHelper
+    
+    def self.included(cls)
+      cls.class_eval(<<-HERE_DOC, __FILE__, __LINE__)
+        DefaultTimeout = nil unless const_defined?(:DefaultTimeout)
+        
+        def self.default_timeout(timeout)
+          self.send(:remove_const, :DefaultTimeout)
+          self.send(:const_set, :DefaultTimeout, timeout)
+        end
+        
+        def current_default_timeout
+          DefaultTimeout
+        end
+      HERE_DOC
+      
+    end
+    
+    
+    def timeout(time_to_run)
+      EM.cancel_timer(@_em_timer) if @_em_timer
+      @_em_timer = EM.add_timer(time_to_run) { done('timeout exceeded') }
+    end
+    
+    def em(time_to_run = current_default_timeout, &block)
+      @flunk_test = nil
+      EM.run do
+        timeout(time_to_run) if time_to_run
+        em_spec_exception = nil
+        @_em_spec_fiber = Fiber.new do
+          begin
+            block.call
+          rescue Exception => em_spec_exception
+            done
+          end
+          Fiber.yield
+        end
+        
+        @_em_spec_fiber.resume
+        
+        raise em_spec_exception if em_spec_exception
+      end
+      raise(@flunk_test) if @flunk_test
+    end
+
+    def done(flunk_reason = nil)
+      EM.next_tick{
+        @flunk_test = flunk_reason
+        finish_em_spec_fiber
+      }
+    end
+
+    private
+
+    def finish_em_spec_fiber
+      EM.stop_event_loop if EM.reactor_running?
+      @_em_spec_fiber.resume if @_em_spec_fiber.alive?
+    end
+    
+  end
+  
+  module Test
+  
+    def self.included(cls)
+      cls.class_eval(<<-HERE_DOC, __FILE__, __LINE__)
+        include TestHelper
+
+        def self.default_timeout(timeout)
+          self.send(:remove_const, :DefaultTimeout)
+          self.send(:const_set, :DefaultTimeout, timeout)
+        end
+        
+        include TestHelper
+        alias_method :run_without_em, :run
+        def run(result, &block)
+          em(DefaultTimeout) { run_without_em(result, &block) }
+        end
+        
+      HERE_DOC
+      
+    end
+    
+  end
+  
+end
+
+

data/lib/ext/fiber18.rb

@@ -0,0 +1,81 @@
+# Poor Man's Fiber (API compatible Thread based Fiber implementation for Ruby 1.8)
+# (c) 2008 Aman Gupta (tmm1)
+
+unless defined? Fiber
+  require 'thread'
+
+  class FiberError < StandardError; end
+
+  class Fiber
+    def initialize
+      raise ArgumentError, 'new Fiber requires a block' unless block_given?
+
+      @yield = Queue.new
+      @resume = Queue.new
+
+      @thread = Thread.new{ @yield.push [ *yield(*@resume.pop) ] }
+      @thread.abort_on_exception = true
+      @thread[:fiber] = self
+    end
+    attr_reader :thread
+    
+    def alive?
+      @thread.alive?
+    end
+    
+    def resume *args
+      raise FiberError, 'dead fiber called' unless @thread.alive?
+      raise FiberError, 'double resume' if @thread == Thread.current
+      @resume.push(args)
+      result = @yield.pop
+      result.size > 1 ? result : result.first
+    end
+    
+    def resume!
+      @resume.push []
+    end
+    
+    def yield *args
+      @yield.push(args)
+      result = @resume.pop
+      result.size > 1 ? result : result.first
+    end
+    
+    def self.yield *args
+      raise FiberError, "can't yield from root fiber" unless fiber = Thread.current[:fiber]
+      fiber.yield(*args)
+    end
+
+    def self.current
+      Thread.current[:fiber] or raise FiberError, 'not inside a fiber'
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+else
+  require 'fiber' unless Fiber.respond_to?(:current)
+end
+
+if __FILE__ == $0
+  f = Fiber.new{ puts 'hi'; p Fiber.yield(1); puts 'bye'; :done }
+  p f.resume
+  p f.resume(2)
+end
+
+__END__
+
+$ ruby fbr.rb 
+hi
+1
+2
+bye
+:done
+
+$ ruby1.9 fbr.rb 
+hi
+1
+2
+bye
+:done

data/test/bacon_spec.rb

@@ -0,0 +1,70 @@
+require 'bacon'
+require File.dirname(__FILE__) + '/../lib/em-spec/bacon'
+
+EM.spec_backend = EventMachine::Spec::Bacon
+
+describe 'Bacon' do
+  should 'work as normal outside EM.describe' do
+    1.should == 1
+  end
+end
+
+EM.describe EventMachine do
+  should 'work' do
+    done
+  end
+
+  should 'have timers' do
+    start = Time.now
+
+    EM.add_timer(0.5){
+      (Time.now-start).should.be.close 0.5, 0.1
+      done
+    }
+  end
+
+  should 'have periodic timers' do
+    num = 0
+    start = Time.now
+
+    timer = EM.add_periodic_timer(0.5){
+      if (num += 1) == 2
+        (Time.now-start).should.be.close 1.0, 0.1
+        EM.__send__ :cancel_timer, timer
+        done
+      end
+    }
+  end
+
+  should 'have deferrables' do
+    defr = EM::DefaultDeferrable.new
+    defr.timeout(1)
+    defr.errback{
+      done
+    }
+  end
+
+  # it "should not block on failure" do
+  #   1.should == 2
+  # end
+
+end
+
+EM.describe EventMachine, "with time restrictions" do
+  default_timeout 2
+  
+  should 'succeed here' do
+    timeout(5)
+    EM.add_timer(3) { done }
+  end
+
+end
+
+EM.describe EventMachine, "with time restrictions" do
+  default_timeout 2
+  
+  should 'raise fail here' do
+    EM.add_timer(3) { done }
+  end
+
+end

data/test/rspec_fail_examples.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../lib/em-spec/rspec'
+
+describe EventMachine, "when running failing examples" do
+  include EM::Spec
+  
+  it "should not bubble failures beyond rspec" do
+    EM.add_timer(0.1) do
+      :should_not_bubble.should == :failures
+      done
+    end
+  end
+
+  it "should not block on failure" do
+     1.should == 2
+  end
+
+  
+end

data/test/rspec_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../lib/em-spec/rspec'
+
+describe 'Rspec' do
+  it 'should work as normal outside EM.describe' do
+    1.should == 1
+  end
+end
+
+describe EventMachine, "when testing with EM::SpecHelper" do
+  include EM::SpecHelper
+  
+  it "should not require a call to done when #em is not used" do
+    1.should == 1
+  end
+  
+  it "should have timers" do
+    em do
+      start = Time.now
+
+      EM.add_timer(0.5){
+        (Time.now-start).should be_close( 0.5, 0.1 )
+        done
+      }
+    end
+  end
+end
+
+describe EventMachine, "when testing with EM::Spec" do
+  include EM::Spec
+  
+  it 'should work' do
+    done
+  end
+
+  it 'should have timers' do
+    start = Time.now
+    
+    EM.add_timer(0.5){
+      (Time.now-start).should be_close( 0.5, 0.1 )
+      done
+    }
+  end
+
+  it 'should have periodic timers' do
+    num = 0
+    start = Time.now
+    
+    timer = EM.add_periodic_timer(0.5){
+      if (num += 1) == 2
+        (Time.now-start).should be_close( 1.0, 0.1 )
+        EM.__send__ :cancel_timer, timer
+        done
+      end
+    }
+  end
+
+  it 'should have deferrables' do
+    defr = EM::DefaultDeferrable.new
+    defr.timeout(1)
+    defr.errback{
+      done
+    }
+  end
+    
+end
+
+describe EventMachine, "when testing with EM::Spec with a maximum execution time per test" do
+
+  include EM::Spec
+
+  default_timeout 2
+
+  it 'should timeout before reaching done' do
+    EM.add_timer(3) {
+      done
+    }
+  end
+
+  it 'should timeout before reaching done' do
+    timeout(4)
+    EM.add_timer(3) {
+      done
+    }
+  end
+
+end
+
+describe "Rspec", "when running an example group after another group that uses EMSpec " do
+  it "should work normally" do
+    :does_not_hang.should_not be_false
+  end
+end

data/test/test_spec.rb

@@ -0,0 +1,96 @@
+require 'test/unit'
+require 'rubygems'
+require 'eventmachine'
+require 'lib/em-spec/test'
+
+class NormalTest < Test::Unit::TestCase
+  def test_trivial
+    assert_equal 1, 1
+  end
+end
+
+class EmSpecHelperTest < Test::Unit::TestCase
+  
+  include EventMachine::TestHelper
+
+  def test_trivial
+    em do
+      assert_equal 1, 1
+      done
+    end
+  end
+  
+  def test_timer
+    em do
+      start = Time.now
+
+      EM.add_timer(0.5){
+        assert_in_delta 0.5, Time.now-start, 0.1
+        done
+      }
+    end
+  end
+  
+end
+
+class EmSpecTest < Test::Unit::TestCase
+  
+  include EventMachine::Test
+
+  def test_working
+    done
+  end
+  
+  def test_timer
+    start = Time.now
+
+    EM.add_timer(0.5){
+      assert_in_delta 0.5, Time.now-start, 0.1
+      done
+    }
+  end
+
+  def test_deferrable
+    defr = EM::DefaultDeferrable.new
+    defr.timeout(1)
+    defr.errback{
+      done
+    }
+  end
+  
+end
+
+class EmSpecWithTimeoutTest < Test::Unit::TestCase
+  
+  include EventMachine::Test
+
+  default_timeout 2
+
+  def test_should_fail_to_timeout
+    EM.add_timer(3) {
+      done
+    }
+  end
+
+end
+
+class EmSpecWithTimeoutOverrideTest < Test::Unit::TestCase
+  
+  include EventMachine::Test
+
+  default_timeout 2
+
+  def test_timeout_override
+    timeout(4)
+    EM.add_timer(3) {
+      done
+    }
+  end
+
+end
+
+class AnotherNormalTest < Test::Unit::TestCase
+  def normal_test
+    assert_equal 1, 1
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: em-spec
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Simple BDD API for testing asynchronous Ruby/EventMachine code
+email: aman@tmm1.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/em-spec/bacon.rb
+- lib/em-spec/rspec.rb
+- lib/em-spec/test.rb
+- lib/ext/fiber18.rb
+- test/bacon_spec.rb
+- test/rspec_fail_examples.rb
+- test/rspec_spec.rb
+- test/test_spec.rb
+has_rdoc: true
+homepage: http://github.com/joshbuddy/em-spec
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple BDD API for testing asynchronous Ruby/EventMachine code
+test_files: 
+- test/bacon_spec.rb
+- test/rspec_fail_examples.rb
+- test/rspec_spec.rb
+- test/test_spec.rb