waitfor 0.1.0 → 0.1.7

data/lib/waitfor/version.rb

@@ -1,9 +1,10 @@
-module WaitFor #:nodoc:
-  module VERSION #:nodoc:
+# @author James Bobowski
+module WaitFor
+  module VERSION
     MAJOR = 0
     MINOR = 1
-    TINY  = 0
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    TINY  = 7
+    
+    STRING = [ MAJOR, MINOR, TINY ].join( '.' )
   end
 end

data/spec/configuration_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname( __FILE__ ) + '/spec_helper.rb'
+require 'lib/waitfor/settings/configuration'
+
+describe WaitFor::Settings::Configuration do
+
+# This isn't working like it's supposed to!
+#  context ".new" do
+#    it "should accept an options parameter then hand off the parsing to the parser classes" do
+#      new_method = WaitFor::Settings::Configuration.method( :new )
+#
+#      WaitFor::Settings::Configuration.stub!( :new ).and_return do |*args|
+#        config = new_method.call( *args )
+#        config.should_receive( :parser_factory )
+#        config
+#      end
+#    end
+#  end
+
+  context "#parser_factory" do
+    it "should use the LegacyParser class when the options parameter's Class is of type Fixnum" do
+      WaitFor::Settings::LegacyParser.should_receive( :parse ).with( 0, an_instance_of( WaitFor::Settings::Configuration ) )
+      WaitFor::Settings::Configuration.new( 0 )
+    end
+
+    it "should use the Parser class when the options parameter's Class is of type Hash" do
+      WaitFor::Settings::Parser.should_receive( :parse ).with( { }, an_instance_of( WaitFor::Settings::Configuration ) )
+      WaitFor::Settings::Configuration.new( { } )
+    end
+
+    it "should raise an exception when the options parameter's Class isn't either Fixnum or Hash" do
+      lambda { WaitFor::Settings::Configuration.new( false ) }.should raise_error
+    end
+  end
+end

data/spec/fixnum_spec.rb

@@ -1,29 +1,27 @@
 require File.dirname( __FILE__ ) + '/spec_helper.rb'
 
-describe Fixnum, "Convert Seconds to Seconds" do
-  it "should take the unit of 'second' ( singular ) with the amount of 1 and return 1" do
-    1 == 1.second
+describe Fixnum do
+  context ".second" do
+    it "should take the singular unit of 'second' and return the number of seconds" do
+      1 == 1.second
+    end
   end
 
-  it "should take the unit of 'seconds' ( plural ) with the amount of 1 and return 1" do
-    1 == 1.seconds
+  context ".seconds" do
+    it "should take the plural unit of 'seconds' and return the number of seconds" do
+      5 == 5.seconds
+    end
   end
 
-  it "should take the unit of 'seconds' with the amount of 60 and return 60" do
-    60 == 60.seconds
-  end
-end
-
-describe Fixnum, "Convert Minutes to Seconds" do
-  it "should take the unit of 'minute' ( singular ) with the amount of 1 and return 60" do
-    60 == 1.minute
+  context ".minute" do
+    it "should take the singular unit of 'minute' and return the number of seconds" do
+      60 == 1.minute
+    end
   end
 
-  it "should take the unit of 'minutes' ( plural ) with the amount of 1 and return 60" do
-    60 == 1.minutes
+  context ".minutes" do
+    it "should take the plural unit of 'minutes' and return the number of seconds" do
+      300 == 5.minutes
+    end
   end
-
-  it "should take the unit of 'minutes' with the amount of 5 and return 300" do
-    300 == 5.minutes
-  end
-end
+end

data/spec/legacy_parser_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname( __FILE__ ) + '/spec_helper.rb'
+require 'lib/waitfor/settings/legacy_parser'
+
+describe WaitFor::Settings::LegacyParser do
+  context ".parse" do
+    before do
+      @mock_legacy_parser = mock( WaitFor::Settings::LegacyParser )
+      @mock_config = mock( WaitFor::Settings::Configuration )
+
+      WaitFor::Settings::Configuration.stub!( :new ).and_return( @mock_config )
+      WaitFor::Settings::LegacyParser.stub!( :new ).and_return( @mock_legacy_parser )
+    end
+
+    it "should accept Fixnum and call the parse method then return a populated Configuration object" do
+      WaitFor::Settings::LegacyParser.should_receive( :new ).once.with( 0, @mock_config )
+      @mock_legacy_parser.should_receive( :parse ).once
+      @mock_legacy_parser.should_receive( :config ).once.and_return( @mock_config )
+
+      WaitFor::Settings::LegacyParser.parse( 0, @mock_config ).should == @mock_config
+    end
+  end
+
+  context "#parse" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+    end
+
+    it "should call each of the private parse methods" do
+      @mock_config.should_receive( :exception= ).once.with( WaitFor::TimeoutError )
+
+      @legacy_parser = WaitFor::Settings::LegacyParser.new( 0, @mock_config )
+      @legacy_parser.should_receive( :parse_time ).once
+      @legacy_parser.parse
+    end
+  end
+
+  context "#parse_time" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+    end
+
+    it "should accept Fixnum and set it to the Configuration object's seconds attribute" do
+      @mock_config.should_receive( :exception= ).once.with( WaitFor::TimeoutError )
+      @mock_config.should_receive( :seconds= ).once.with( 0 )
+
+      @legacy_parser = WaitFor::Settings::LegacyParser.new( 0, @mock_config )
+      @legacy_parser.send( :parse_time )
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,147 @@
+require File.dirname( __FILE__ ) + '/spec_helper.rb'
+require 'lib/waitfor/settings/legacy_parser'
+require 'lib/waitfor/settings/parser'
+
+describe WaitFor::Settings::Parser do
+  context ".parse" do
+    before do
+      @mock_parser = mock( WaitFor::Settings::Parser )
+      @mock_config = mock( WaitFor::Settings::Configuration )
+
+      WaitFor::Settings::Configuration.stub!( :new ).and_return( @mock_config )
+      WaitFor::Settings::Parser.stub!( :new ).and_return( @mock_parser )
+    end
+
+    it "should accept Hash and call the parse method then return a populated Configuration object" do
+      WaitFor::Settings::Parser.should_receive( :new ).once.with( { }, @mock_config )
+      @mock_parser.should_receive( :parse ).once
+      @mock_parser.should_receive( :config ).once.and_return( @mock_config )
+
+      WaitFor::Settings::Parser.parse( { }, @mock_config ).should == @mock_config
+    end
+  end
+
+  context "#parse" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+    end
+
+    it "should call each of the private parse methods" do
+      @parser = WaitFor::Settings::Parser.new( { }, @mock_config )
+
+      @parser.should_receive( :parse_seconds ).once
+      @parser.should_receive( :parse_minutes ).once
+      @parser.should_receive( :parse_exception ).once
+      @parser.should_receive( :parse_message ).once
+
+      @parser.parse
+    end
+
+    it "should parse any combination of :second, :seconds, :minute or :minutes and combine them into seconds" do
+      @parser = WaitFor::Settings::Parser.new( { :second => 1, :seconds => 1, :minute => 1, :minutes => 1 }, @mock_config )
+
+      # Retrieve the existing number of seconds
+      # Should be 0 initially since this is first time we retrieve it
+      # Then should be 2 after that because we parsed seconds
+      @mock_config.should_receive( :seconds ).and_return( 0, 2 )
+
+      # We expect the parse_seconds method will attempt to set :seconds to 2
+      @mock_config.should_receive( :seconds= ).with( 2 )
+
+      # We expect the parse_minutes method will attempt to set :seconds to 122, which 2 minutes with the 2 seconds above added in
+      @mock_config.should_receive( :seconds= ).with( 122 )
+
+      # We expect the parse_exception method to set the default exception
+      @mock_config.should_receive( :exception= ).once.with( WaitFor::TimeoutError )
+
+      # We expect the parse_exception method to set the default message
+      @mock_config.should_receive( :message= ).once.with( "WaitFor timed out!" )
+
+      @parser.parse
+    end
+  end
+
+  context "#parse_seconds" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+    end
+
+    it "should accept a hash containing :second or :seconds and set it to the setting object's seconds attribute" do
+      @parser = WaitFor::Settings::Parser.new( { :second => 1, :seconds => 1 }, @mock_config )
+      @mock_config.should_receive( :seconds ).once.and_return( 0 )
+      @mock_config.should_receive( :seconds= ).once.with( 2 )
+
+      @parser.send( :parse_seconds )
+    end
+
+    it "should set object's seconds attribute to 0 when hash does not contain :second or :seconds" do
+      @parser = WaitFor::Settings::Parser.new( { }, @mock_config )
+      @mock_config.should_receive( :seconds ).once.and_return( 0 )
+      @mock_config.should_receive( :seconds= ).once.with( 0 )
+
+      @parser.send( :parse_seconds )
+    end
+  end
+
+  context "#parse_minutes" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+    end
+
+    it "should accept a hash containing :minute or :minutes and set it to the setting object's seconds attribute" do
+      @parser = WaitFor::Settings::Parser.new( { :minute => 1, :minutes => 1 }, @mock_config )
+      @mock_config.should_receive( :seconds ).once.and_return( 0 )
+      @mock_config.should_receive( :seconds= ).once.with( 120 )
+
+      @parser.send( :parse_minutes )
+    end
+
+    it "should set object's seconds attribute to 0 when hash does not contain :minute or :minutes" do
+      @parser = WaitFor::Settings::Parser.new( { }, @mock_config )
+      @mock_config.should_receive( :seconds ).once.and_return( 0 )
+      @mock_config.should_receive( :seconds= ).once.with( 0 )
+
+      @parser.send( :parse_minutes )
+    end
+  end
+
+  context "#parse_exception" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+    end
+
+    it "should accept a hash containing :exception and set it to the setting object's exception attribute" do
+      @parser = WaitFor::Settings::Parser.new( { :exception => WaitFor::TimeoutError }, @mock_config )
+      @mock_config.should_receive( :exception= ).once.with( WaitFor::TimeoutError )
+
+      @parser.send( :parse_exception )
+    end
+
+    it "should set object's exception attribute to WaitFor::TimeoutError when hash does not contain :exception" do
+      @parser = WaitFor::Settings::Parser.new( { }, @mock_config )
+      @mock_config.should_receive( :exception= ).once.with( WaitFor::TimeoutError )
+
+      @parser.send( :parse_exception )
+    end
+  end
+
+  context "#parse_message" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+    end
+
+    it "should accept a hash containing :message and set it to the setting object's message attribute" do
+      @parser = WaitFor::Settings::Parser.new( { :message => "Message" }, @mock_config )
+      @mock_config.should_receive( :message= ).once.with( "Message" )
+
+      @parser.send( :parse_message )
+    end
+
+    it "should set object's message attribute to the default error message when hash does not contain :message" do
+      @parser = WaitFor::Settings::Parser.new( { }, @mock_config )
+      @mock_config.should_receive( :message= ).once.with( "WaitFor timed out!" )
+
+      @parser.send( :parse_message )
+    end
+  end
+end

data/spec/spec.opts

@@ -1 +1,3 @@
---colour
+--colour
+--format profile
+--timeout 5

data/spec/spec_helper.rb

@@ -10,30 +10,23 @@ $:.unshift( File.dirname( __FILE__ ) + '/../lib' )
 require File.dirname( __FILE__ ) + '/../lib/waitfor.rb'
 require File.dirname( __FILE__ ) + '/../lib/waitfor/fixnum.rb'
 require File.dirname( __FILE__ ) + '/../lib/waitfor/timer.rb'
-require File.dirname( __FILE__ ) + '/../lib/waitfor/waitfor_timeout_error.rb'
+require File.dirname( __FILE__ ) + '/../lib/waitfor/timeout_error.rb'
 
-def timer
-  start_time = Time.now
-  yield
-  Time.now - start_time
-end
+NOW = Time.mktime( 1970, 01, 01, 00, 00, 00 )
 
 class CustomTestError < RuntimeError
 
 end
 
 class ToggleBetweenFalseAndTrue
-  def initialize
-    @status = false
+  @@status = true
+
+  def self.reset_status
+    @@status = true
   end
 
-  def status
-    if @status
-      @status = false
-      true
-    else
-      @status = true
-      false
-    end
+  def self.status?
+    @@status = ( not @@status )
+    @@status
   end
 end

data/spec/spec_helper_spec.rb

@@ -1,30 +1,20 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
-describe "timer method" do
-  it "should report an elapsed time of at least 1 second but not more than 2 seconds for the code 'sleep 1'" do
-    elapsed_time = timer {
-      sleep 1
-    }
-
-    elapsed_time.should be > 1
-    elapsed_time.should be < 2
-  end
-end
-
 describe CustomTestError do
   it "should be of a kind of RuntimeError" do
-    exception = CustomTestError.new
-    exception.should be_a_kind_of( RuntimeError )
+    CustomTestError.new.should be_a_kind_of( RuntimeError )
   end
 end
 
 describe ToggleBetweenFalseAndTrue do
-  it "should have a status method that returns false then true then false then true" do
-    event = ToggleBetweenFalseAndTrue.new
+  before do
+    ToggleBetweenFalseAndTrue.reset_status
+  end
 
-    event.status.should be( false )
-    event.status.should be( true )
-    event.status.should be( false )
-    event.status.should be( true )
+  it "should have a status method that returns false then true then false then true" do
+    ToggleBetweenFalseAndTrue.status?.should be( false )
+    ToggleBetweenFalseAndTrue.status?.should be( true )
+    ToggleBetweenFalseAndTrue.status?.should be( false )
+    ToggleBetweenFalseAndTrue.status?.should be( true )
   end
 end

data/spec/timeout_error_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname( __FILE__ ) + '/spec_helper.rb'
+
+describe WaitFor::TimeoutError do
+  context ".new" do
+    it "should be of a kind of RuntimeError" do
+      exception = WaitFor::TimeoutError.new
+      exception.should be_a_kind_of( RuntimeError )
+    end
+  end
+end

data/spec/timer_spec.rb

@@ -1,83 +1,110 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname( __FILE__ ) + '/spec_helper.rb'
 
-describe Timer, "when checking out_of_time?" do
-  it "should return false when set for 5 seconds and queried immediately" do
-    timer = Timer.new 5
-    timer.out_of_time?.should be( false )
-  end
+describe WaitFor::Timer do
+  context ".new" do
+    before do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+      WaitFor::Settings::Configuration.stub!( :new ).and_return( @mock_config )
+    end
 
-  it "should raise a WaitFor::TimeoutError when set for 0 seconds and queried immediately" do
-    timer = Timer.new 0.seconds
-    lambda {
-      timer.out_of_time?.should be( true )
-    }.should raise_error( WaitFor::TimeoutError )
-  end
-end
+    it "should accept a hash of options and return a new WaitFor::Timer object with the options hash passed to a new Configuration object" do
+      WaitFor::Settings::Configuration.should_receive( :new ).once.with( { } )
 
-describe Timer, "when inputting duration in to_seconds" do
-  it "should accept a Fixnum value of 5 as 5 seconds" do
-    Timer.to_seconds( 1 ).should be( 1 )
-  end
+      new_timer = WaitFor::Timer.new( { } )
+      new_timer.instance_variable_get( :@config ).should == @mock_config
+    end
 
-  it "should accept a simple time DSL using a singular value of '1.second' as 1 second" do
-    Timer.to_seconds( 1.second ).should be( 1 )
-  end
+    it "should return a new WaitFor::Timer object with the start_time attribute set to the current time" do
+      Time.should_receive( :now ).once.and_return( Time.at( 0 ) )
 
-  it "should accept a simple time DSL using a plural value of '5.seconds' as 5 seconds" do
-    Timer.to_seconds( 5.seconds ).should be( 5 )
+      new_timer = WaitFor::Timer.new( { } )
+      new_timer.instance_variable_get( :@start_time ).should == Time.at( 0 )
+    end
   end
 
-  it "should accept a simple time DSL using a singular value of '1.minute' as 60 seconds" do
-    Timer.to_seconds( 1.minute ).should be( 60 )
-  end
+  context "#out_of_time?" do
+    before do
+      @new_timer = WaitFor::Timer.new( 0 )
+    end
 
-  it "should accept a simple time DSL using a plural value of '5.minutes' as 300 seconds" do
-    Timer.to_seconds( 5.minutes ).should be( 300 )
-  end
+    it "should raise an exception if the elapsed time has passed" do
+      @new_timer.stub!( :timed_out? ).and_return true
+      lambda { @new_timer.out_of_time? }.should raise_error
+    end
 
-  it "should accept a hash using a singular value of ':second => 1' as 1 second" do
-    Timer.to_seconds( :second => 1 ).should be( 1 )
+    it "should return false if the elapsed time has not passed" do
+      @new_timer.stub!( :timed_out? ).and_return false
+      lambda { @new_timer.out_of_time? }.should_not raise_error
+    end
   end
 
-  it "should accept a hash using a plural value of ':seconds => 5' as 5 seconds" do
-    Timer.to_seconds( :seconds => 5 ).should be( 5 )
-  end
+  context "#timed_out?" do
+    before do
+      @new_timer = WaitFor::Timer.new( 1 )
+    end
 
-  it "should accept a hash using a singular value of ':minute => 1' as 60 seconds" do
-    Timer.to_seconds( :minute => 1 ).should be( 60 )
-  end
+    it "should return true if the elapsed time has passed is greater than or equal the limit" do
+      @new_timer.stub!( :elapsed_time ).and_return( 1 )
+      @new_timer.send( :timed_out? ).should be true
+    end
 
-  it "should accept a hash using a plural value of ':minutes => 5' as 300 seconds" do
-    Timer.to_seconds( :minutes => 5 ).should be( 300 )
+    it "should return false if the elapsed time has passed is less than the limit" do
+      @new_timer.stub!( :elapsed_time ).and_return( 0 )
+      @new_timer.send( :timed_out? ).should be false
+    end
   end
-end
 
-describe Timer, "when inputting custom errors" do
-  it "should raise a CustomTestError when passed the value of ':exception => CustomTestError" do
-    timer = Timer.new :seconds => 0, :exception => CustomTestError
-    lambda {
-      timer.out_of_time?.should be( true )
-    }.should raise_error( CustomTestError )
-  end
+  context "#elapsed_time" do
+    before do
+      Time.should_receive( :now ).twice.and_return( Time.at( 0 ), Time.at( 1 ) )
+      @new_timer = WaitFor::Timer.new( 1 )
+    end
 
-  it "should raise a CustomTestError when passed the value of ':error => CustomTestError" do
-    timer = Timer.new :seconds => 0, :error => CustomTestError
-    lambda {
-      timer.out_of_time?.should be( true )
-    }.should raise_error( CustomTestError )
+    it "should return the elapsed time in seconds" do
+      @new_timer.send( :elapsed_time ).should == 1
+    end
   end
 
-  it "should raise an error with the custom message 'Custom Error Message' when passed the value of ':message => 'Custom Error Message'" do
-    timer = Timer.new :seconds => 0, :message => "Custom Error Message"
-    lambda {
-      timer.out_of_time?.should be( true )
-    }.should raise_error( "Custom Error Message" )
-  end
+  context "#raise_exception" do
+    before do
+      @new_timer = WaitFor::Timer.new( 0 )
+    end
+
+    it "should raise the default WaitFor exception" do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+      @mock_config.should_receive( :exception ).once.and_return( WaitFor::TimeoutError )
+      @mock_config.should_receive( :message ).once.and_return( nil )
+      @new_timer.instance_variable_set( :@config, @mock_config )
+
+      lambda { @new_timer.send( :raise_exception ) }.should raise_error( WaitFor::TimeoutError, "WaitFor::TimeoutError" )
+    end
+
+    it "should raise the default WaitFor exception with the specified message" do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+      @mock_config.should_receive( :exception ).once.and_return( WaitFor::TimeoutError )
+      @mock_config.should_receive( :message ).once.and_return( "Timeout Error!" )
+      @new_timer.instance_variable_set( :@config, @mock_config )
+
+      lambda { @new_timer.send( :raise_exception ) }.should raise_error( WaitFor::TimeoutError, "Timeout Error!" )
+    end
 
-  it "should raise a CustomTestError with the custom message 'Custom Error Message' when passed the value of ':exception => CustomTestError' and ':message => 'Custom Error Message'" do
-    timer = Timer.new :seconds => 0, :exception => CustomTestError, :message => "Custom Error Message"
-    lambda {
-      timer.out_of_time?.should be( true )
-    }.should raise_error( CustomTestError, "Custom Error Message" )
+    it "should raise the specified exception" do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+      @mock_config.should_receive( :exception ).once.and_return( CustomTestError )
+      @mock_config.should_receive( :message ).once.and_return( nil )
+      @new_timer.instance_variable_set( :@config, @mock_config )
+
+      lambda { @new_timer.send( :raise_exception ) }.should raise_error( CustomTestError, "CustomTestError" )
+    end
+
+
+    it "should raise the specified exception with the specified message" do
+      @mock_config = mock( WaitFor::Settings::Configuration )
+      @mock_config.should_receive( :exception ).once.and_return( CustomTestError )
+      @mock_config.should_receive( :message ).once.and_return( "Custom Test Error" )
+      @new_timer.instance_variable_set( :@config, @mock_config )
+
+      lambda { @new_timer.send( :raise_exception ) }.should raise_error( CustomTestError, "Custom Test Error" )
+    end
   end
-end
+end