agent 0.10.0 → 0.11.0

data/spec/queues_spec.rb

@@ -7,22 +7,22 @@ describe Agent::Queues do
 
   it "should register queues" do
     Agent::Queues.register("foo", String, 10)
-    Agent::Queues["foo"].should be_a(Agent::Queue)
-    Agent::Queues["foo"].type.should == String
-    Agent::Queues["foo"].max.should == 10
+    expect(Agent::Queues["foo"]).to be_a(Agent::Queue)
+    expect(Agent::Queues["foo"].type).to eq(String)
+    expect(Agent::Queues["foo"].max).to eq(10)
   end
 
   it "should delete queues" do
     Agent::Queues.register("foo", String, 10)
     Agent::Queues.delete("foo")
-    Agent::Queues["foo"].should be_nil
+    expect(Agent::Queues["foo"]).to be_nil
   end
 
   it "should remove all queues queues" do
     Agent::Queues.register("foo", String, 10)
     Agent::Queues.register("bar", String, 10)
     Agent::Queues.clear
-    Agent::Queues["foo"].should be_nil
-    Agent::Queues["bar"].should be_nil
+    expect(Agent::Queues["foo"]).to be_nil
+    expect(Agent::Queues["bar"]).to be_nil
   end
 end

data/spec/selector_spec.rb

@@ -7,14 +7,14 @@ describe Agent::Selector do
   #   - http://golang.org/doc/go_spec.html#Select_statements
 
   it "should yield Selector on select call" do
-    select! {|s| s.should be_kind_of Agent::Selector}
+    select! {|s| expect(s).to be_kind_of Agent::Selector}
   end
 
   it "should return immediately on empty select block" do
     s = Time.now.to_f
     select! {}
 
-    (Time.now.to_f - s).should be_within(0.05).of(0)
+    expect(Time.now.to_f - s).to be_within(0.05).of(0)
   end
 
   it "should timeout select statement" do
@@ -23,25 +23,25 @@ describe Agent::Selector do
       s.timeout(0.1) { r.push :timeout }
     end
 
-    r.first.should == :timeout
-    (Time.now.to_f - now).should be_within(0.05).of(0.1)
+    expect(r.first).to eq(:timeout)
+    expect(Time.now.to_f - now).to be_within(0.05).of(0.1)
   end
 
   it "should not raise an error when a block is missing on default" do
-    lambda {
+    expect {
       select! do |s|
         s.default
       end
-    }.should_not raise_error(Agent::Errors::BlockMissing)
+    }.not_to raise_error
   end
 
   it "should not raise an error when a block is missing on timeout" do
-    lambda {
+    expect {
       select! do |s|
         s.timeout(1)
         s.default
       end
-    }.should_not raise_error(Agent::Errors::BlockMissing)
+    }.not_to raise_error
   end
 
   context "with unbuffered channels" do
@@ -58,26 +58,26 @@ describe Agent::Selector do
         s.case(@c, :send, 1)
         s.case(@c, :receive)
         s.default
-        s.cases.size.should == 3
+        expect(s.cases.size).to eq(3)
       end
     end
 
     it "should not raise an error when a block is missing on receive" do
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :receive)
           s.default
         end
-      }.should_not raise_error(Agent::Errors::BlockMissing)
+      }.not_to raise_error
     end
 
     it "should not raise an error when a block is missing on send" do
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :send, 1)
           s.default
         end
-      }.should_not raise_error(Agent::Errors::BlockMissing)
+      }.not_to raise_error
     end
 
     it "should scan all cases to identify available actions and execute first available one" do
@@ -92,8 +92,8 @@ describe Agent::Selector do
         s.case(@c, :receive) { r.push 3 }
       end
 
-      r.size.should == 1
-      r.first.should == 2
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(2)
     end
 
     it "should evaluate default case immediately if no other cases match" do
@@ -104,28 +104,57 @@ describe Agent::Selector do
         s.default { r.push :default }
       end
 
-      r.size.should == 1
-      r.first.should == :default
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(:default)
+    end
+
+    it "should evaluate a matching prior closed channel in preference to the default case" do
+      r = []
+
+      @c.close
+      select! do |s|
+        s.case(@c, :receive) { r.push :from_closed }
+        s.default { r.push :default }
+      end
+
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(:from_closed)
+    end
+
+    it "should receive from channels that are closed while selecting on said channels" do
+      r = []
+
+      Thread.new do
+        sleep 0.2
+        @c.close
+      end
+
+      select! do |s|
+        s.case(@c, :receive) { r.push :from_closed }
+      end
+
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(:from_closed)
     end
 
     it "should raise an error if the channel is closed out from under it and you are sending to it" do
       go!{ sleep 0.25; @c.close }
 
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :send, 1)
         end
-      }.should raise_error(Agent::Errors::ChannelClosed)
+      }.to raise_error(Agent::Errors::ChannelClosed)
     end
 
     it "should not raise an error if the channel is closed out from under it and you are receiving from it" do
       go!{ sleep 0.25; @c.close }
 
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :receive){}
         end
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     context "select immediately available channel" do
@@ -142,8 +171,8 @@ describe Agent::Selector do
           s.default { r.push :empty }
         end
 
-        r.size.should == 1
-        r.first.should == :receive
+        expect(r.size).to eq(1)
+        expect(r.first).to eq(:receive)
         c.close
       end
 
@@ -161,8 +190,8 @@ describe Agent::Selector do
           s.default { r.push :empty }
         end
 
-        r.size.should == 1
-        r.first.should == :send
+        expect(r.size).to eq(1)
+        expect(r.first).to eq(:send)
         c.close
       end
     end
@@ -180,8 +209,8 @@ describe Agent::Selector do
           s.case(c, :receive) {|value| r.push value }
         end
 
-        r.size.should == 1
-        (Time.now.to_f - now).should be_within(0.1).of(0.2)
+        expect(r.size).to eq(1)
+        expect(Time.now.to_f - now).to be_within(0.1).of(0.2)
         c.close
       end
 
@@ -190,13 +219,13 @@ describe Agent::Selector do
 
         # brittle.. counting on select to execute within 0.5s
         now = Time.now.to_f
-        go!{sleep(0.2); c.receive[0].should == 2 }
+        go!{sleep(0.2); expect(c.receive[0]).to eq(2 )}
 
         select! do |s|
           s.case(c, :send, 2)
         end
 
-        (Time.now.to_f - now).should be_within(0.1).of(0.2)
+        expect(Time.now.to_f - now).to be_within(0.1).of(0.2)
         c.close
       end
 
@@ -224,13 +253,13 @@ describe Agent::Selector do
 
         ack.receive
 
-        res.size.should == 1
-        res.first.should == 3
+        expect(res.size).to eq(1)
+        expect(res.first).to eq(3)
 
         # 0.3s goroutine should eventually fire
-        cr.receive[0].should == 2
+        expect(cr.receive[0]).to eq(2)
 
-        (Time.now.to_f - now).should be_within(0.05).of(0.3)
+        expect(Time.now.to_f - now).to be_within(0.05).of(0.3)
         cw.close
         cr.close
       end
@@ -250,26 +279,26 @@ describe Agent::Selector do
       select! do |s|
         s.case(@c, :send, 1)
         s.case(@c, :receive)
-        s.cases.size.should == 2
+        expect(s.cases.size).to eq(2)
       end
     end
 
     it "should not raise an error when a block is missing on receive" do
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :receive)
           s.default
         end
-      }.should_not raise_error(Agent::Errors::BlockMissing)
+      }.not_to raise_error
     end
 
     it "should not raise an error when a block is missing on send" do
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :send, 1)
           s.default
         end
-      }.should_not raise_error(Agent::Errors::BlockMissing)
+      }.not_to raise_error
     end
 
     it "should scan all cases to identify available actions and execute first available one" do
@@ -282,8 +311,8 @@ describe Agent::Selector do
         s.case(@c, :receive) { r.push 3 }
       end
 
-      r.size.should == 1
-      r.first.should == 2
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(2)
     end
 
     it "should evaluate default case immediately if no other cases match" do
@@ -296,8 +325,38 @@ describe Agent::Selector do
         s.default { r.push :default }
       end
 
-      r.size.should == 1
-      r.first.should == :default
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(:default)
+    end
+
+    it "should evaluate a matching prior closed channel in preference to the default case" do
+      r = []
+
+      @c.close
+
+      select! do |s|
+        s.case(@c, :receive) { r.push :from_closed }
+        s.default { r.push :default }
+      end
+
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(:from_closed)
+    end
+
+    it "should receive from channels that are closed while selecting on said channels" do
+      r = []
+
+      Thread.new do
+        sleep 0.2
+        @c.close
+      end
+
+      select! do |s|
+        s.case(@c, :receive) { r.push :from_closed }
+      end
+
+      expect(r.size).to eq(1)
+      expect(r.first).to eq(:from_closed)
     end
 
     it "should raise an error if the channel is closed out from under it and you are sending to it" do
@@ -305,21 +364,21 @@ describe Agent::Selector do
 
       go!{ sleep 0.25; @c.close }
 
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :send, 1)
         end
-      }.should raise_error(Agent::Errors::ChannelClosed)
+      }.to raise_error(Agent::Errors::ChannelClosed)
     end
 
     it "should not raise an error if the channel is closed out from under it and you are receiving from it" do
       go!{ sleep 0.25; @c.close }
 
-      lambda {
+      expect {
         select! do |s|
           s.case(@c, :receive){}
         end
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     context "select immediately available channel" do
@@ -334,8 +393,8 @@ describe Agent::Selector do
           s.default { r.push :empty }
         end
 
-        r.size.should == 1
-        r.first.should == :receive
+        expect(r.size).to eq(1)
+        expect(r.first).to eq(:receive)
         c.close
       end
 
@@ -349,8 +408,8 @@ describe Agent::Selector do
           s.default { r.push :empty }
         end
 
-        r.size.should == 1
-        r.first.should == :send
+        expect(r.size).to eq(1)
+        expect(r.first).to eq(:send)
         c.close
       end
     end
@@ -368,8 +427,8 @@ describe Agent::Selector do
           s.case(c, :receive) {|value| r.push value }
         end
 
-        r.size.should == 1
-        (Time.now.to_f - now).should be_within(0.1).of(0.2)
+        expect(r.size).to eq(1)
+        expect(Time.now.to_f - now).to be_within(0.1).of(0.2)
         c.close
       end
 
@@ -385,8 +444,8 @@ describe Agent::Selector do
           s.case(c, :send, 2)
         end
 
-        c.receive[0].should == 2
-        (Time.now.to_f - now).should be_within(0.1).of(0.2)
+        expect(c.receive[0]).to eq(2)
+        expect(Time.now.to_f - now).to be_within(0.1).of(0.2)
         c.close
       end
 
@@ -416,13 +475,13 @@ describe Agent::Selector do
         ack.receive
 
         # 0.8s goroutine should have consumed the message first
-        res.size.should == 1
-        res.first.should == 1
+        expect(res.size).to eq(1)
+        expect(res.first).to eq(1)
 
         # send case should have fired, and we should have a message
-        cw.receive[0].should == 3
+        expect(cw.receive[0]).to eq(3)
 
-        (Time.now.to_f - now).should be_within(0.1).of(0.2)
+        expect(Time.now.to_f - now).to be_within(0.1).of(0.2)
         cw.close
         cr.close
       end

data/spec/spec_helper.rb

@@ -9,7 +9,6 @@ require "agent"
 require "timeout"
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/spec/uuid_spec.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 
 describe Agent::UUID do
   it "should generate a uuid" do
-    Agent::UUID.generate.should match(/^[0-9a-f]{8}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{12}$/)
+    expect(Agent::UUID.generate).to match(/^[0-9a-f]{8}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{12}$/)
   end
 
   it "should generate unique IDs across the BLOCK_SIZE boundary" do
     upper_bound = Agent::UUID::BLOCK_SIZE * 2 + 10
     uuids = (1..upper_bound).map{ Agent::UUID.generate }
-    uuids.size.should == uuids.uniq.size
+    expect(uuids.size).to eq(uuids.uniq.size)
   end
 end

data/spec/wait_group_spec.rb

@@ -17,17 +17,17 @@ describe Agent::WaitGroup do
 
   it "should decrement the cound when WaitGroup#done is called" do
     @wait_group.add(1)
-    @wait_group.count.should == 1
+    expect(@wait_group.count).to eq(1)
     @wait_group.done
-    @wait_group.count.should == 0
+    expect(@wait_group.count).to eq(0)
   end
 
   it "should error when the count becomes negative via WaitGroup#add" do
-    lambda{ @wait_group.add(-1) }.should raise_error(Agent::Errors::NegativeWaitGroupCount)
+    expect{ @wait_group.add(-1) }.to raise_error(Agent::Errors::NegativeWaitGroupCount)
   end
 
   it "should error when the count becomes negative via WaitGroup#done" do
-    lambda{ @wait_group.done }.should raise_error(Agent::Errors::NegativeWaitGroupCount)
+    expect{ @wait_group.done }.to raise_error(Agent::Errors::NegativeWaitGroupCount)
   end
 
   it "should allow waiting on a wait_group and should signal when it is done" do
@@ -39,7 +39,7 @@ describe Agent::WaitGroup do
 
     @wait_group.wait
 
-    (Time.now - t).should be_within(0.01).of(0.2)
+    expect(Time.now - t).to be_within(0.01).of(0.2)
   end
 
 end