agent 0.10.0 → 0.11.0

data/spec/notifier_spec.rb

@@ -7,28 +7,28 @@ describe Agent::Notifier do
 
   it "should notify using a payload" do
     @notifier.notify(1)
-    @notifier.payload.should == 1
+    expect(@notifier.payload).to eq(1)
   end
 
   it "should acknowledge notification" do
-    @notifier.should_not be_notified
+    expect(@notifier).not_to be_notified
     @notifier.notify(1)
-    @notifier.should be_notified
+    expect(@notifier).to be_notified
   end
 
   it "should only notify once" do
     @notifier.notify(1)
     @notifier.notify(2)
-    @notifier.payload.should == 1
+    expect(@notifier.payload).to eq(1)
   end
 
   it "should return nil when notified for the first time" do
-    @notifier.notify(1).should be_nil
+    expect(@notifier.notify(1)).to be_nil
   end
 
   it "should return an error when notified more than once" do
     @notifier.notify(1)
-    @notifier.notify(2).should be_message("already notified")
+    expect(@notifier.notify(2)).to be_message("already notified")
   end
 
   it "should allow waiting on a notification and should signal when it is notified" do
@@ -37,6 +37,6 @@ describe Agent::Notifier do
     sleep 0.1 # make sure the notifier in the goroutine is waiting
     @notifier.notify(1)
     payload, _ = ack.receive
-    payload.should == 1
+    expect(payload).to eq(1)
   end
 end

data/spec/once_spec.rb

@@ -13,8 +13,8 @@ describe Agent::Once do
       r << 1
     end
 
-    r.size.should == 1
-    r.first.should == 1
+    expect(r.size).to eq(1)
+    expect(r.first).to eq(1)
   end
 
   it "should only execute the first block passed to it" do
@@ -28,8 +28,8 @@ describe Agent::Once do
       r << 2
     end
 
-    r.size.should == 1
-    r.first.should == 1
+    expect(r.size).to eq(1)
+    expect(r.first).to eq(1)
   end
 
   it "should return the value returned from the block" do
@@ -37,18 +37,18 @@ describe Agent::Once do
       1
     end
 
-    value.should == 1
+    expect(value).to eq(1)
   end
 
   it "should return nil for value and an error if it has already been used" do
     value, error = @once.perform{ 1 }
-    value.should == 1
-    error.should be_nil
+    expect(value).to eq(1)
+    expect(error).to be_nil
 
     value, error = @once.perform{ 2 }
-    value.should be_nil
-    error.should_not be_nil
-    error.should be_message("already performed")
+    expect(value).to be_nil
+    expect(error).not_to be_nil
+    expect(error).to be_message("already performed")
   end
 
   it "should have minimal contention between threads when they contend for position" do
@@ -81,9 +81,9 @@ describe Agent::Once do
     # wait for the finished channel to be completed
     2.times{ finished_channel.receive }
 
-    r.size.should == 1
-    # Onlt the first sleep should be performed, so things should quickly
-    (Time.now.to_f - s).should be_within(0.05).of(0.15)
+    expect(r.size).to eq(1)
+    # Only the first sleep should be performed, so things should happen quickly
+    expect(Time.now.to_f - s).to be_within(0.05).of(0.15)
 
     waiting_channel.close
     finished_channel.close

data/spec/pop_spec.rb

@@ -9,16 +9,16 @@ describe Agent::Pop do
     end
 
     it "should close" do
-      @pop.should_not be_closed
+      expect(@pop).not_to be_closed
       @pop.close
-      @pop.should be_closed
+      expect(@pop).to be_closed
     end
 
     it "should run multiple times" do
       @pop.send{1}
-      @pop.should be_received
+      expect(@pop).to be_received
       @pop.send{2}
-      @pop.object.should == 2
+      expect(@pop.object).to eq(2)
     end
 
     it "should continue when received" do
@@ -28,7 +28,7 @@ describe Agent::Pop do
 
       s, _ = @ack.receive
 
-      (Time.now - s).should be_within(0.01).of(0)
+      expect(Time.now - s).to be_within(0.01).of(0)
     end
 
     it "should continue when closed" do
@@ -38,13 +38,13 @@ describe Agent::Pop do
 
       s, _ = @ack.receive
 
-      (Time.now - s).should be_within(0.01).of(0)
+      expect(Time.now - s).to be_within(0.01).of(0)
     end
 
     it "should be able to be gracefully rolled back" do
-      @pop.should_not be_received
+      expect(@pop).not_to be_received
       @pop.send{ raise Agent::Errors::Rollback }
-      @pop.should_not be_received
+      expect(@pop).not_to be_received
     end
 
     it "should continue when it was already closed" do
@@ -56,7 +56,7 @@ describe Agent::Pop do
 
       s, _ = @ack.receive
 
-      (Time.now - s).should be_within(0.01).of(0.2)
+      expect(Time.now - s).to be_within(0.01).of(0.2)
     end
   end
 
@@ -67,38 +67,38 @@ describe Agent::Pop do
     end
 
     it "should only send only once" do
-      @blocking_once.should_not be_performed
+      expect(@blocking_once).not_to be_performed
       @pop.send{1}
-      @pop.should be_received
-      @blocking_once.should be_performed
-      @pop.object.should == 1
+      expect(@pop).to be_received
+      expect(@blocking_once).to be_performed
+      expect(@pop.object).to eq(1)
 
       @pop.send{2}
-      @pop.object.should == 1
+      expect(@pop.object).to eq(1)
 
-      lambda{@pop.send{raise "an error"} }.should_not raise_error
+      expect{@pop.send{raise "an error"} }.not_to raise_error
     end
 
     it "be able to be gracefully rolled back" do
-      @blocking_once.should_not be_performed
-      @pop.should_not be_received
+      expect(@blocking_once).not_to be_performed
+      expect(@pop).not_to be_received
       @pop.send{ raise Agent::Errors::Rollback }
-      @blocking_once.should_not be_performed
-      @pop.should_not be_received
+      expect(@blocking_once).not_to be_performed
+      expect(@pop).not_to be_received
     end
 
     it "should send only once even when it is closed" do
       @pop.close
-      @blocking_once.should_not be_performed
+      expect(@blocking_once).not_to be_performed
       @pop.send{1}
-      @pop.should be_received
-      @blocking_once.should be_performed
-      @pop.object.should == nil
+      expect(@pop).to be_received
+      expect(@blocking_once).to be_performed
+      expect(@pop.object).to be_nil
 
       @pop.send{2}
-      @pop.object.should == nil
+      expect(@pop.object).to be_nil
 
-      lambda{@pop.send{raise "an error"} }.should_not raise_error
+      expect{@pop.send{raise "an error"} }.not_to raise_error
     end
   end
 
@@ -109,15 +109,15 @@ describe Agent::Pop do
     end
 
     it "should notify when being sent" do
-      @notifier.should_not be_notified
+      expect(@notifier).not_to be_notified
       @pop.send{1}
-      @notifier.should be_notified
+      expect(@notifier).to be_notified
     end
 
     it "should notify when being closed" do
-      @notifier.should_not be_notified
+      expect(@notifier).not_to be_notified
       @pop.close
-      @notifier.should be_notified
+      expect(@notifier).to be_notified
     end
   end
 

data/spec/push_spec.rb

@@ -9,17 +9,17 @@ describe Agent::Push do
     end
 
     it "should close" do
-      @push.should_not be_closed
+      expect(@push).not_to be_closed
       @push.close
-      @push.should be_closed
+      expect(@push).to be_closed
     end
 
     it "should run multiple times" do
       i = 0
       @push.receive{|v| i += 1 }
-      @push.should be_sent
+      expect(@push).to be_sent
       @push.receive{|v| i += 1 }
-      i.should == 2
+      expect(i).to eq(2)
     end
 
     it "should continue when sent" do
@@ -29,18 +29,18 @@ describe Agent::Push do
 
       s, _ = @ack.receive
 
-      (Time.now - s).should be_within(0.02).of(0)
+      expect(Time.now - s).to be_within(0.02).of(0)
     end
 
     it "should raise an error on the waiter when closed" do
       go!{ sleep 0.1; @push.close }
-      lambda{ @push.wait }.should raise_error(Agent::Errors::ChannelClosed)
+      expect{ @push.wait }.to raise_error(Agent::Errors::ChannelClosed)
     end
 
     it "be able to be gracefully rolled back" do
-      @push.should_not be_sent
+      expect(@push).not_to be_sent
       @push.receive{|v| raise Agent::Errors::Rollback }
-      @push.should_not be_sent
+      expect(@push).not_to be_sent
     end
   end
 
@@ -50,16 +50,16 @@ describe Agent::Push do
     let(:push){ Agent::Push.new(object, :skip_marshal => skip_marshal) }
 
     it "makes a copy of the object" do
-      push.object.should == object
-      push.object.object_id.should_not == object.object_id
+      expect(push.object).to eq(object)
+      expect(push.object.object_id).not_to eq(object.object_id)
     end
 
     context "with an object type that skips marshaling" do
       let(:object){ ::Queue.new }
 
       it "does not make a copy of the object" do
-        push.object.should == object
-        push.object.object_id.should == object.object_id
+        expect(push.object).to eq(object)
+        expect(push.object.object_id).to eq(object.object_id)
       end
     end
 
@@ -67,8 +67,8 @@ describe Agent::Push do
       let(:skip_marshal){ true }
 
       it "does not make a copy of the object" do
-        push.object.should == object
-        push.object.object_id.should == object.object_id
+        expect(push.object).to eq(object)
+        expect(push.object.object_id).to eq(object.object_id)
       end
     end
   end
@@ -82,23 +82,23 @@ describe Agent::Push do
     it "should only send only once" do
       i = 0
 
-      @blocking_once.should_not be_performed
+      expect(@blocking_once).not_to be_performed
       @push.receive{|v| i += 1 }
-      @push.should be_sent
-      @blocking_once.should be_performed
+      expect(@push).to be_sent
+      expect(@blocking_once).to be_performed
 
       @push.receive{|v| i += 1 }
-      i.should == 1
+      expect(i).to eq(1)
 
-      lambda{@push.receive{raise "an error"} }.should_not raise_error
+      expect{@push.receive{raise "an error"} }.not_to raise_error
     end
 
     it "be able to be gracefully rolled back" do
-      @blocking_once.should_not be_performed
-      @push.should_not be_sent
+      expect(@blocking_once).not_to be_performed
+      expect(@push).not_to be_sent
       @push.receive{|v| raise Agent::Errors::Rollback }
-      @blocking_once.should_not be_performed
-      @push.should_not be_sent
+      expect(@blocking_once).not_to be_performed
+      expect(@push).not_to be_sent
     end
   end
 
@@ -109,15 +109,15 @@ describe Agent::Push do
     end
 
     it "should notify when being sent" do
-      @notifier.should_not be_notified
+      expect(@notifier).not_to be_notified
       @push.receive{|v|}
-      @notifier.should be_notified
+      expect(@notifier).to be_notified
     end
 
     it "should notify when being closed" do
-      @notifier.should_not be_notified
+      expect(@notifier).not_to be_notified
       @push.close
-      @notifier.should be_notified
+      expect(@notifier).to be_notified
     end
   end
 

data/spec/queue_spec.rb

@@ -8,20 +8,20 @@ describe Agent::Queue do
     end
 
     it "should be buffered" do
-      @queue.should be_buffered
+      expect(@queue).to be_buffered
     end
 
     it "should not be unbuffered" do
-      @queue.should_not be_unbuffered
+      expect(@queue).not_to be_unbuffered
     end
 
     it "should raise an error if the queue size is <= 0" do
-      lambda{ Agent::Queue::Buffered.new(String, 0) }.should raise_error(Agent::Errors::InvalidQueueSize)
-      lambda{ Agent::Queue::Buffered.new(String, -1) }.should raise_error(Agent::Errors::InvalidQueueSize)
+      expect{ Agent::Queue::Buffered.new(String, 0) }.to raise_error(Agent::Errors::InvalidQueueSize)
+      expect{ Agent::Queue::Buffered.new(String, -1) }.to raise_error(Agent::Errors::InvalidQueueSize)
     end
 
     it "should raise an erro when an object of an invalid type is pushed" do
-      lambda { @queue.push(1) }.should raise_error(Agent::Errors::InvalidType)
+      expect { @queue.push(1) }.to raise_error(Agent::Errors::InvalidType)
     end
 
     it "should enqueue and dequeue in order" do
@@ -31,16 +31,16 @@ describe Agent::Queue do
 
       20.times do |i|
         o = @queue.pop[0].to_i
-        o.should > previous
+        expect(o).to be > previous
         previous = o
       end
     end
 
     context "when the queue is empty" do
       it "should hold any attempts to pop from it" do
-        @queue.operations.should be_empty
+        expect(@queue.operations).to be_empty
         @queue.pop(:deferred => true)
-        @queue.operations.should_not be_empty
+        expect(@queue.operations).not_to be_empty
       end
 
       it "should be able to be pushed to" do
@@ -48,17 +48,17 @@ describe Agent::Queue do
       end
 
       it "should increase in size when pushed to" do
-        @queue.size.should == 0
+        expect(@queue.size).to eq(0)
         @queue.push("1")
-        @queue.size.should == 1
+        expect(@queue.size).to eq(1)
       end
 
       it "should be pushable" do
-        @queue.push?.should == true
+        expect(@queue.push?).to eq(true)
       end
 
       it "should not be poppable" do
-        @queue.pop?.should == false
+        expect(@queue.pop?).to eq(false)
       end
     end
 
@@ -72,27 +72,27 @@ describe Agent::Queue do
       end
 
       it "should increase in size when pushed to" do
-        @queue.size.should == 1
+        expect(@queue.size).to eq(1)
         @queue.push("1")
-        @queue.size.should == 2
+        expect(@queue.size).to eq(2)
       end
 
       it "should be able to be popped from" do
-        @queue.pop[0].should == "1"
+        expect(@queue.pop[0]).to eq("1")
       end
 
       it "should decrease in size when popped from" do
-        @queue.size.should == 1
+        expect(@queue.size).to eq(1)
         @queue.pop
-        @queue.size.should == 0
+        expect(@queue.size).to eq(0)
       end
 
       it "should be pushable" do
-        @queue.push?.should == true
+        expect(@queue.push?).to eq(true)
       end
 
       it "should be poppable" do
-        @queue.pop?.should == true
+        expect(@queue.pop?).to eq(true)
       end
     end
 
@@ -102,21 +102,21 @@ describe Agent::Queue do
       end
 
       it "should hold any attempts to push to it" do
-        @queue.operations.should be_empty
+        expect(@queue.operations).to be_empty
         @queue.push("1", :deferred => true)
-        @queue.operations.should_not be_empty
+        expect(@queue.operations).not_to be_empty
       end
 
       it "should be able to be popped from" do
-        @queue.pop[0].should == "1"
+        expect(@queue.pop[0]).to eq("1")
       end
 
       it "should not be pushable" do
-        @queue.push?.should == false
+        expect(@queue.push?).to eq(false)
       end
 
       it "should be poppable" do
-        @queue.pop?.should == true
+        expect(@queue.pop?).to eq(true)
       end
     end
 
@@ -126,51 +126,51 @@ describe Agent::Queue do
       end
 
       it "should go from open to closed" do
-        @queue.should_not be_closed
-        @queue.should be_open
+        expect(@queue).not_to be_closed
+        expect(@queue).to be_open
         @queue.close
-        @queue.should be_closed
-        @queue.should_not be_open
+        expect(@queue).to be_closed
+        expect(@queue).not_to be_open
       end
 
       it "should close all the waiting operations" do
-        @push1.should be_sent
-        @push2.should be_sent
-        @push3.should_not be_sent
-        @push3.should_not be_closed
+        expect(@push1).to be_sent
+        expect(@push2).to be_sent
+        expect(@push3).not_to be_sent
+        expect(@push3).not_to be_closed
 
         @queue.close
 
-        @push3.should be_closed
+        expect(@push3).to be_closed
       end
 
       it "should clear all waiting operations" do
-        @queue.operations.size.should   == 1
-        @queue.pushes.size.should == 1
+        expect(@queue.operations.size).to   eq(1)
+        expect(@queue.pushes.size).to eq(1)
         @queue.close
-        @queue.operations.size.should == 0
-        @queue.pushes.size.should == 0
+        expect(@queue.operations.size).to eq(0)
+        expect(@queue.pushes.size).to eq(0)
       end
 
       it "should clear all elements at rest" do
-        @queue.queue.size.should == 2
+        expect(@queue.queue.size).to eq(2)
         @queue.close
-        @queue.queue.size.should == 0
+        expect(@queue.queue.size).to eq(0)
       end
 
       context "after it is closed" do
         before{ @queue.close }
 
         it "should raise an error when #close is called again" do
-          lambda{ @queue.close }.should raise_error(Agent::Errors::ChannelClosed)
+          expect{ @queue.close }.to raise_error(Agent::Errors::ChannelClosed)
         end
 
         it "should raise an error when a value is pushed onto the queue" do
-          lambda{ @queue.push("1") }.should raise_error(Agent::Errors::ChannelClosed)
+          expect{ @queue.push("1") }.to raise_error(Agent::Errors::ChannelClosed)
         end
 
         it "should return [nil, false] when popping from the queue" do
-          @queue.pop.should == [nil, false]
+          expect(@queue.pop).to eq([nil, false])
         end
       end
     end
@@ -185,9 +185,9 @@ describe Agent::Queue do
         @queue.remove_operations(removable_pushes)
         while @queue.pop?
           i = @queue.pop[0]
-          i.should_not be_nil
-          i.should_not == "6"
-          i.should_not == "7"
+          expect(i).not_to be_nil
+          expect(i).not_to eq("6")
+          expect(i).not_to eq("7")
         end
       end
     end
@@ -199,11 +199,11 @@ describe Agent::Queue do
     end
 
     it "should not be buffered" do
-      @queue.should_not be_buffered
+      expect(@queue).not_to be_buffered
     end
 
     it "should be unbuffered" do
-      @queue.should be_unbuffered
+      expect(@queue).to be_unbuffered
     end
 
     it "should enqueue and dequeue in order" do
@@ -213,32 +213,32 @@ describe Agent::Queue do
 
       20.times do |i|
         o = @queue.pop[0].to_i
-        o.should > previous
+        expect(o).to be > previous
         previous = o
       end
     end
 
     context "when there are no operations waiting" do
       it "should not be poppable" do
-        @queue.pop?.should == false
+        expect(@queue.pop?).to eq(false)
       end
 
       it "should not be pushable" do
-        @queue.push?.should == false
+        expect(@queue.push?).to eq(false)
       end
 
       it "should queue pushes" do
-        @queue.operations.size.should == 0
+        expect(@queue.operations.size).to eq(0)
         push = @queue.push("1", :deferred => true)
-        push.should_not be_sent
-        @queue.operations.size.should == 1
+        expect(push).not_to be_sent
+        expect(@queue.operations.size).to eq(1)
       end
 
       it "should queue pops" do
-        @queue.operations.size.should == 0
+        expect(@queue.operations.size).to eq(0)
         pop = @queue.pop(:deferred => true)
-        pop.should_not be_received
-        @queue.operations.size.should == 1
+        expect(pop).not_to be_received
+        expect(@queue.operations.size).to eq(1)
       end
     end
 
@@ -248,25 +248,25 @@ describe Agent::Queue do
       end
 
       it "should not be poppable" do
-        @queue.pop?.should == false
+        expect(@queue.pop?).to eq(false)
       end
 
       it "should be pushable" do
-        @queue.push?.should == true
+        expect(@queue.push?).to eq(true)
       end
 
       it "should execute a push and the waiting pop immediately" do
         push = @queue.push("1", :deferred => true)
-        @pop.should be_received
-        push.should be_sent
-        @pop.object.should == "1"
+        expect(@pop).to be_received
+        expect(push).to be_sent
+        expect(@pop.object).to eq("1")
       end
 
       it "should queue pops" do
-        @queue.operations.size.should == 1
+        expect(@queue.operations.size).to eq(1)
         pop = @queue.pop(:deferred => true)
-        pop.should_not be_received
-        @queue.operations.size.should == 2
+        expect(pop).not_to be_received
+        expect(@queue.operations.size).to eq(2)
       end
     end
 
@@ -276,25 +276,25 @@ describe Agent::Queue do
       end
 
       it "should be poppable" do
-        @queue.pop?.should == true
+        expect(@queue.pop?).to eq(true)
       end
 
       it "should not be pushable" do
-        @queue.push?.should == false
+        expect(@queue.push?).to eq(false)
       end
 
       it "should queue pushes" do
-        @queue.operations.size.should == 1
+        expect(@queue.operations.size).to eq(1)
         push = @queue.push("1", :deferred => true)
-        push.should_not be_sent
-        @queue.operations.size.should == 2
+        expect(push).not_to be_sent
+        expect(@queue.operations.size).to eq(2)
       end
 
       it "should execute a pop and the waiting push immediately" do
         pop = @queue.pop(:deferred => true)
-        @push.should be_sent
-        pop.should be_received
-        pop.object.should == "1"
+        expect(@push).to be_sent
+        expect(pop).to be_received
+        expect(pop.object).to eq("1")
       end
     end
 
@@ -304,46 +304,46 @@ describe Agent::Queue do
       end
 
       it "should go from open to closed" do
-        @queue.should_not be_closed
-        @queue.should be_open
+        expect(@queue).not_to be_closed
+        expect(@queue).to be_open
         @queue.close
-        @queue.should be_closed
-        @queue.should_not be_open
+        expect(@queue).to be_closed
+        expect(@queue).not_to be_open
       end
 
       it "should close all the waiting operations" do
-        @push1.should_not be_sent
-        @push1.should_not be_closed
-        @push2.should_not be_sent
-        @push2.should_not be_closed
+        expect(@push1).not_to be_sent
+        expect(@push1).not_to be_closed
+        expect(@push2).not_to be_sent
+        expect(@push2).not_to be_closed
 
         @queue.close
 
-        @push1.should be_closed
-        @push2.should be_closed
+        expect(@push1).to be_closed
+        expect(@push2).to be_closed
       end
 
       it "should clear all waiting operations" do
-        @queue.operations.size.should   == 2
-        @queue.pushes.size.should == 2
+        expect(@queue.operations.size).to   eq(2)
+        expect(@queue.pushes.size).to eq(2)
         @queue.close
-        @queue.operations.size.should == 0
-        @queue.pushes.size.should == 0
+        expect(@queue.operations.size).to eq(0)
+        expect(@queue.pushes.size).to eq(0)
       end
 
       context "after it is closed" do
         before{ @queue.close }
 
         it "should raise an error when #close is called again" do
-          lambda{ @queue.close }.should raise_error(Agent::Errors::ChannelClosed)
+          expect{ @queue.close }.to raise_error(Agent::Errors::ChannelClosed)
         end
 
         it "should raise an error when a value is pushed onto the queue" do
-          lambda{ @queue.push("1") }.should raise_error(Agent::Errors::ChannelClosed)
+          expect{ @queue.push("1") }.to raise_error(Agent::Errors::ChannelClosed)
         end
 
         it "should return [nil, false] when popping from the queue" do
-          @queue.pop.should == [nil, false]
+          expect(@queue.pop).to eq([nil, false])
         end
       end
     end
@@ -358,9 +358,9 @@ describe Agent::Queue do
         @queue.remove_operations(removable_pushes)
         while @queue.pop?
           i = @queue.pop[0]
-          i.should_not be_nil
-          i.should_not == "6"
-          i.should_not == "7"
+          expect(i).not_to be_nil
+          expect(i).not_to eq("6")
+          expect(i).not_to eq("7")
         end
       end
     end