timers_spec.rb in timers-2.0.0

- old
+ new

@@ -1,40 +1,40 @@
 require 'spec_helper'
 
 describe Timers do
-  # Level of accuracy enforced by most tests (50ms)
+  # Level of accuracy enforced by tests (50ms)
   Q = 0.05
 
   it "sleeps until the next timer" do
     interval   = Q * 2
     started_at = Time.now
 
     fired = false
     subject.after(interval) { fired = true }
     subject.wait
 
-    fired.should be_true
-    (Time.now - started_at).should be_within(Q).of interval
+    expect(fired).to be_true
+    expect(Time.now - started_at).to be_within(Q).of interval
   end
 
   it "fires instantly when next timer is in the past" do
     fired = false
     subject.after(Q) { fired = true }
     sleep(Q * 2)
     subject.wait
 
-    fired.should be_true
+    expect(fired).to be_true
   end
 
   it "calculates the interval until the next timer should fire" do
     interval = 0.1
 
     subject.after(interval)
-    subject.wait_interval.should be_within(Q).of interval
+    expect(subject.wait_interval).to be_within(Q).of interval
 
     sleep(interval)
-    subject.wait_interval.should be(0)
+    expect(subject.wait_interval).to be(0)
   end
 
   it "fires timers in the correct order" do
     result = []
 
@@ -43,35 +43,159 @@
     subject.after(Q * 1) { result << :one }
 
     sleep Q * 4
     subject.fire
 
-    result.should == [:one, :two, :three]
+    expect(result).to eq [:one, :two, :three]
   end
 
+  it "raises TypeError if given an invalid time" do
+    expect do
+      subject.after(nil) { nil }
+    end.to raise_exception(TypeError)
+  end
+
   describe "recurring timers" do
     it "continues to fire the timers at each interval" do
       result = []
 
       subject.every(Q * 2) { result << :foo }
 
       sleep Q * 3
       subject.fire
-      result.should == [:foo]
+      expect(result).to eq [:foo]
 
       sleep Q * 5
       subject.fire
-      result.should == [:foo, :foo]
+      expect(result).to eq [:foo, :foo]
     end
   end
-  
+
   describe "millisecond timers" do
     it "calculates the proper interval to wait until firing" do
       interval_ms = 25
 
       subject.after_milliseconds(interval_ms)
       expected_elapse = subject.wait_interval
 
-      subject.wait_interval.should be_within(Q).of (interval_ms / 1000.0)
+      expect(subject.wait_interval).to be_within(Q).of(interval_ms / 1000.0)
+    end
+  end
+
+  describe "pause and continue timers" do
+    before(:each) do
+      @interval   = Q * 2
+      started_at = Time.now
+
+      @fired = false
+      @timer = subject.every(@interval) { @fired = true }
+      @fired2 = false
+      @timer2 = subject.every(@interval) { @fired2 = true }
+    end
+
+    it "does not fire when paused" do
+      @timer.pause
+      subject.wait
+      expect(@fired).to be_false
+    end
+
+    it "fires when continued after pause" do
+      @timer.pause
+      subject.wait
+      @timer.continue
+      subject.wait
+      expect(@fired).to be_true
+    end
+
+    it "can pause all timers at once" do
+      subject.pause
+      subject.wait
+      expect(@fired).to be_false
+      expect(@fired2).to be_false
+    end
+
+    it "can continue all timers at once" do
+      subject.pause
+      subject.wait
+      subject.continue
+      subject.wait
+      expect(@fired).to be_true
+      expect(@fired2).to be_true
+    end
+
+    it "can fire the timer directly" do
+      fired = false
+      timer = subject.after( Q * 1 ) { fired = true }
+      timer.pause
+      subject.wait
+      expect(fired).not_to be_true
+      timer.continue
+      expect(fired).not_to be_true
+      timer.fire
+      expect(fired).to be_true
+    end
+
+  end
+
+  describe "delay timer" do
+    it "adds appropriate amount of time to timer" do
+      timer = subject.after(10)
+      timer.delay(5)
+      expect(timer.offset - subject.current_offset).to be_within(Q).of(15)
+    end
+  end
+
+  describe "delay timer collection" do
+    it "delay on set adds appropriate amount of time to all timers" do
+      timer = subject.after(10)
+      timer2 = subject.after(20)
+      subject.delay(5)
+      expect(timer.offset - subject.current_offset).to be_within(Q).of(15)
+      expect(timer2.offset - subject.current_offset).to be_within(Q).of(25)
+    end
+  end
+
+  describe "on delaying a timer" do
+    it "fires timers in the correct order" do
+      result = []
+
+      second = subject.after(Q * 2) { result << :two }
+      third = subject.after(Q * 3) { result << :three }
+      first = subject.after(Q * 1) { result << :one }
+      first.delay(Q * 3)
+
+      sleep Q * 5
+      subject.fire
+
+      expect(result).to eq [:two, :three, :one]
+    end
+  end
+
+  describe "Timer inspection" do
+    it "before firing" do
+      fired = false
+      timer = subject.after(Q * 5) { fired = true }
+      timer.pause
+      expect(fired).not_to be_true
+      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fires in [-\.\de]+ seconds>\Z/)
+    end
+
+    it "after firing" do
+      fired = false
+      timer = subject.after(Q) { fired = true }
+
+      subject.wait
+
+      expect(fired).to be_true
+      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fired [-\.\de]+ seconds ago>\Z/)
+    end
+
+    it "recurring firing" do
+      result = []
+      timer = subject.every(Q) { result << :foo }
+
+      subject.wait
+      expect(result).not_to be_empty
+      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fires in [-\.\de]+ seconds, recurs every #{sprintf("%0.2f", Q)}>\Z/)
     end
   end
 end