infopark-politics 0.8.0 → 0.8.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NmUwNzYzMGNmM2M2MmJkOTliNjFlOTYwY2I1ZmI1NzYxOTA1ZTg1NA==
+    Mzc2YjVhN2QyNGFkNGYyMWZiZmIyNGUwMGE3MTRjZTYzYmU2ZWQzOA==
   data.tar.gz: !binary |-
-    YTFjZGEzODU3Y2NhOWU1YzQ2NGY0NTRiMTQzZDdlZGRlYjQzZmVlOQ==
+    MDVhZWYxNjk3OGUxMDAzNjNiNzg5YThlYjA5NThiNDZkMDY0ZjJhYg==
 SHA512:
   metadata.gz: !binary |-
-    Zjk3ZDA3NzU0MmUyMmNkNzEyNjgzN2UzYmQ2ZTkyNThkNjEwNjM4ZTc5MTY4
-    MjA4ZjIxNzgxMjA2ZjRlMGYwYmU1ODAxZTQ4M2Q2YTRjNzAyODlkYWIwOTlm
-    NGQxYzVjYTg4NGY3YWQyNmYyNDYwNmZhNGMwZjYxODIzZjQ3MDI=
+    YzBmZjU0ODE5MmVhY2VmZDM0ZTNiM2M5OTdiZjczMjNmYjQ3ZDcxNzk3ZGJi
+    NWQ3OWRlNjA2ZGUyYjg2YWYwYjUyYjc4ZWM3MjA5NDAyNGNmYzRiYzY0ZjUy
+    ZDA0YTFkZDY5MjQ2YmRhZGVmNzQzNGJhYWRiZGZkMmQwYmEyZjI=
   data.tar.gz: !binary |-
-    YjcyMDNlZTBjNzRlYTcyNDcyZmU5M2U3ODdlN2E3ODM2MjRiZTY3YWI2MzBm
-    Mzk3NDZiZDE5NmNlM2U2N2UxZDcwNDdhYTFlNDk4YzdjMmM1NmY4YTgzMWZh
-    NDVmOGQ4NzAzNjg3ODg0NzUwZTM5Zjg2Y2ExOGFlZjlmNjU0ZTQ=
+    YzIxOWJlNGVmZDVmOWRkNmQ5Mzg0NmE3MWRhZDQxZTFhMzBmZmZlZDI1ODBj
+    OGZkNDllODc4ZDA5OWZkNDFiNGNlNjVhY2Q4ZGU0OGY2NmY3NzBiYzU5Mjg1
+    NWZhYzQyNmY1YzJjOWUxNGQ3NDBiYzI3NWM1N2IwYzBmNjhkODg=

data/infopark-politics.gemspec

@@ -6,7 +6,7 @@ end
 
 Gem::Specification.new do |gem|
   gem.name = "infopark-politics"
-  gem.version = "0.8.0"
+  gem.version = "0.8.1"
   gem.summary = "Algorithms and Tools for Distributed Computing in Ruby."
   gem.description = ""
   gem.authors = ["Mike Perham", "Tilo Prütz"]

data/lib/politics/static_queue_worker.rb

@@ -103,12 +103,15 @@ module Politics
       end
 
       if restart_wanted?
+        log.info "restart triggered"
         as_dictator { populate_followers_to_stop }
         # keeping leader state as long as there are followers to stop
         while !followers_to_stop.empty?
+          log.info "waiting fo workers to stop: #{followers_to_stop}"
           relax(until_next_iteration / 2)
           seize_leadership
         end
+        log.info "leader exiting due to trigger"
         exit 0
       end
     end
@@ -126,7 +129,10 @@ module Politics
         log.debug "delivering bucket request"
         bucket_spec = next_bucket(requestor_uri, context)
         if !bucket_spec[0] && @followers_to_stop.include?(requestor_uri)
-          bucket_spec = [:stop, 0]
+          # the leader stops its own process and must not be killed by its worker
+          if requestor_uri != uri
+            bucket_spec = [:stop, 0]
+          end
           @followers_to_stop.delete(requestor_uri)
         end
         bucket_spec
@@ -166,6 +172,10 @@ module Politics
       raise "Please provide a method ”find_workers” returning a list of all other worker URIs"
     end
 
+    def restart_wanted?
+      memcache_client.get(restart_flag)
+    end
+
     private
 
     attr_reader :iteration_end, :memcache_client
@@ -177,10 +187,6 @@ module Politics
     def before_perform_leader_duties
     end
 
-    def restart_wanted?
-      memcache_client.get(restart_flag)
-    end
-
     def bucket_process(bucket, sleep_time)
       case bucket
       when nil

data/spec/static_queue_worker_spec.rb

@@ -40,46 +40,46 @@ describe UninitializedWorker do
 
   describe "when initializing" do
     it "should register the removal of the leadership as exit handler" do
-      worker.should_receive(:at_exit).ordered.and_return {|&h| h}
+      expect(worker).to receive(:at_exit).ordered {|&h| h}
       handler = worker.register_worker('worker', 10, :iteration_length => 10)
 
-      worker.should_receive(:internal_cleanup).ordered
-      worker.should_receive(:cleanup).ordered
+      expect(worker).to receive(:internal_cleanup).ordered
+      expect(worker).to receive(:cleanup).ordered
       handler.call
     end
 
     it "should have a druby url" do
       worker.register_worker('worker', 10, :iteration_length => 10)
-      worker.uri.should =~ %r|druby://.*:[0-9]+|
+      expect(worker.uri).to match(%r|druby://.*:[0-9]+|)
     end
 
     it "should not have a hostname" do
-      worker.send(:hostname).should be_nil
+      expect(worker.send(:hostname)).to be_nil
     end
 
     it "should not have a bucket_request_context" do
-      worker.send(:bucket_request_context).should be_nil
+      expect(worker.send(:bucket_request_context)).to be_nil
     end
 
     context "when it has a hostname" do
       before do
-        worker.stub(:hostname).and_return '127.0.0.1'
+        allow(worker).to receive(:hostname).and_return '127.0.0.1'
       end
 
       it "should use it" do
         worker.register_worker('worker', 10, :iteration_length => 10)
-        worker.uri.should =~ %r|druby://127.0.0.1:[0-9]+|
+        expect(worker.uri).to match(%r|druby://127.0.0.1:[0-9]+|)
       end
     end
 
     context "when it does not have a hostname" do
       before do
-        worker.stub(:hostname).and_return nil
+        allow(worker).to receive(:hostname).and_return nil
       end
 
       it "should use the systems hostname" do
         worker.register_worker('worker', 10, :iteration_length => 10)
-        worker.uri.should =~ %r|druby://localhost:[0-9]+|
+        expect(worker.uri).to match(%r|druby://#{`hostname -f`.chomp}:[0-9]+|)
       end
     end
   end
@@ -94,54 +94,54 @@ describe Worker do
   end
 
   it "should return time to next iteration even if nominate was not completed" do
-    worker.until_next_iteration.should == 0
+    expect(worker.until_next_iteration).to eq(0)
   end
 
   it "should give access to the uri" do
-    worker.uri.should =~ %r(^druby://)
+    expect(worker.uri).to match(%r(^druby://))
   end
 
   it "should be alive" do
-    worker.should be_alive
+    expect(worker).to be_alive
   end
 
   describe "when processing bucket" do
     before do
-      DRbObject.stub(:new).with(nil, worker.uri).
+      allow(DRbObject).to receive(:new).with(nil, worker.uri).
           and_return(@worker_drb = double('drb', :alive? => true))
     end
 
     it "should raise an error if it is not alive via Drb" do
-      @worker_drb.stub(:alive?).and_raise("drb error")
-      lambda {worker.start}.should raise_error(/cannot reach self/)
-      @worker_drb.stub(:alive?).and_return(false)
-      lambda {worker.start}.should raise_error(/not alive/)
+      allow(@worker_drb).to receive(:alive?).and_raise("drb error")
+      expect {worker.start}.to raise_error(/cannot reach self/)
+      allow(@worker_drb).to receive(:alive?).and_return(false)
+      expect {worker.start}.to raise_error(/not alive/)
     end
 
     describe "" do
       before do
-        worker.stub(:until_next_iteration).and_return 666
-        worker.stub(:nominate)
-        worker.stub(:loop?).and_return true, true, true, false
+        allow(worker).to receive(:until_next_iteration).and_return 666
+        allow(worker).to receive(:nominate)
+        allow(worker).to receive(:loop?).and_return true, true, true, false
       end
 
       it "should relax until next iteration on MemCache errors during nomination" do
-        worker.should_receive(:nominate).exactly(4).and_raise Dalli::DalliError.new("Buh!")
-        worker.should_receive(:relax).with(666).exactly(4).times
+        expect(worker).to receive(:nominate).exactly(4).and_raise Dalli::DalliError.new("Buh!")
+        expect(worker).to receive(:relax).with(666).exactly(4).times
 
         worker.start
       end
 
       it "should relax until next iteration on MemCache errors during request for leader" do
-        worker.should_receive(:leader_uri).exactly(4).and_raise(Dalli::DalliError.new("Buh"))
-        worker.should_receive(:relax).with(666).exactly(4).times
+        expect(worker).to receive(:leader_uri).exactly(4).and_raise(Dalli::DalliError.new("Buh"))
+        expect(worker).to receive(:relax).with(666).exactly(4).times
 
         worker.start
       end
 
       describe "as leader" do
         before do
-          worker.stub(:leader?).and_return true
+          allow(worker).to receive(:leader?).and_return true
           allow(worker).to receive(:bucket_process) { sleep 0.5 }
           allow(worker).to receive(:relax)
           allow(worker).to receive(:leader).and_return(double('leader', bucket_request: nil))
@@ -149,37 +149,37 @@ describe Worker do
 
         it "performs leader duties in a separate thread" do
           # four iterations of 0.5 seconds → two leader threads of one second
-          worker.should_receive(:perform_leader_duties).exactly(2).times { sleep 1 }
+          expect(worker).to receive(:perform_leader_duties).exactly(2).times { sleep 1 }
           worker.start
         end
       end
 
       describe "as follower" do
         before do
-          worker.stub(:leader?).and_return false
-          worker.stub(:leader_uri).and_return "the leader"
-          worker.stub(:leader).and_return(@leader = double('leader'))
-          @leader.stub(:bucket_request).and_return([1, 0])
+          allow(worker).to receive(:leader?).and_return false
+          allow(worker).to receive(:leader_uri).and_return "the leader"
+          allow(worker).to receive(:leader).and_return(@leader = double('leader'))
+          allow(@leader).to receive(:bucket_request).and_return([1, 0])
         end
 
         it "should get the bucket to process from the leader at every iteration" do
-          worker.should_receive(:leader).exactly(4).times.and_return @leader
-          @leader.should_receive(:bucket_request).with(worker.uri, nil).exactly(4).times.
+          expect(worker).to receive(:leader).exactly(4).times.and_return @leader
+          expect(@leader).to receive(:bucket_request).with(worker.uri, nil).exactly(4).times.
               and_return([1, 2])
           worker.start
         end
 
         it "should send the bucket_request_context with the bucket request" do
-          worker.stub(:loop?).and_return false
-          worker.stub(:bucket_request_context).and_return "the context"
-          @leader.should_receive(:bucket_request).with(worker.uri, "the context")
+          allow(worker).to receive(:loop?).and_return false
+          allow(worker).to receive(:bucket_request_context).and_return "the context"
+          expect(@leader).to receive(:bucket_request).with(worker.uri, "the context")
           worker.start
         end
 
         it "should exit on :stop bucket" do
-          @leader.should_receive(:bucket_request).ordered.once.and_return([:stop, 0])
-          worker.should_receive(:exit).with(0).ordered.and_return do
-            worker.should_receive(:loop?).and_return false
+          expect(@leader).to receive(:bucket_request).ordered.once.and_return([:stop, 0])
+          expect(worker).to receive(:exit).with(0).ordered do
+            expect(worker).to receive(:loop?).and_return false
           end
           worker.start
         end
@@ -190,73 +190,107 @@ describe Worker do
   describe "when handling a bucket request" do
     describe "as leader" do
       before do
-        worker.stub(:leader?).and_return true
+        allow(worker).to receive(:leader?).and_return true
+        allow(worker).to receive(:uri).and_return leader
       end
 
-      it "should deliver the bucket" do
-        worker.should_receive(:next_bucket).with("requestor", "context").and_return "the bucket"
-        worker.bucket_request("requestor", "context").should == "the bucket"
+      subject { worker.bucket_request(requestor, context) }
+
+      let(:requestor) { 'requestor' }
+      let(:context) { 'context' }
+      let(:leader) { 'leader' }
+
+      it "delivers the bucket" do
+        expect(worker).to receive(:next_bucket).with("requestor", "context").and_return "the bucket"
+        expect(subject).to eq("the bucket")
       end
 
       describe "when no buckets are left" do
         before do
-          worker.stub(:find_workers).and_return(%w(1 2 3))
+          allow(worker).to receive(:find_workers).and_return(["1", "2", "3", leader])
           worker.populate_followers_to_stop
-          DRbObject.stub(:new).and_return(double('o', :alive? => true))
+          allow(DRbObject).to receive(:new).and_return(double('o', :alive? => true))
         end
 
-        it "should deliver the :stop bucket if requestor is in followers_to_stop list" do
-          worker.bucket_request("1", nil).should == [:stop, 0]
-        end
+        context "when requestor is in followers_to_stop list" do
+          context "when requestor is another worker" do
+            let(:requestor) { '2' }
+
+            it "delivers the :stop bucket" do
+              expect(subject).to eq([:stop, 0])
+            end
+
+            it "removes the requestor from the followers_to_stop list" do
+              expect {
+                subject
+              }.to change {
+                worker.followers_to_stop
+              }.from(["1", "2", "3", leader]).to(["1", "3", leader])
+            end
+          end
+
+          context "when requestor is leaders worker" do
+            let(:requestor) { leader }
 
-        it "should not deliver the :stop bucket if requestor is not in followers_to_stop list" do
-          worker.bucket_request("requestor", nil)[0].should be_nil
+            it "does not deliver the :stop bucket" do
+              expect(subject[0]).to be_nil
+            end
+
+            it "removes the requestor from the followers_to_stop list" do
+              expect {
+                subject
+              }.to change {
+                worker.followers_to_stop
+              }.from(["1", "2", "3", leader]).to(["1", "2", "3"])
+            end
+          end
         end
 
-        it "should remove the requestor from the followers_to_stop list" do
-          worker.bucket_request("2", nil)
-          worker.followers_to_stop.should =~ %w(1 3)
+        context "when requestor is not in followers_to_stop list" do
+          it "does not deliver the :stop bucket" do
+            expect(subject[0]).to be_nil
+          end
         end
       end
     end
 
     describe "as follower" do
       before do
-        worker.stub(:leader?).and_return false
+        allow(worker).to receive(:leader?).and_return false
       end
 
       it "should deliver the :not_leader bucket" do
-        worker.bucket_request("requestor", nil)[0].should == :not_leader
+        expect(worker.bucket_request("requestor", nil)[0]).to eq(:not_leader)
       end
     end
   end
 
   describe "when determining if restart is wanted" do
     it "should return true if the restart flag is set in memcache" do
-      memcache_client.should_receive(:get).with('worker_restart').and_return true
-      worker.should be_restart_wanted
+      expect(memcache_client).to receive(:get).with('worker_restart').and_return true
+      expect(worker).to be_restart_wanted
     end
 
     it "should return false if the restart flag is not set in memcache" do
-      memcache_client.should_receive(:get).with('worker_restart').and_return false
-      worker.should_not be_restart_wanted
-      memcache_client.should_receive(:get).with('worker_restart').and_return nil
-      worker.should_not be_restart_wanted
+      expect(memcache_client).to receive(:get).with('worker_restart').and_return false
+      expect(worker).not_to be_restart_wanted
+      expect(memcache_client).to receive(:get).with('worker_restart').and_return nil
+      expect(worker).not_to be_restart_wanted
     end
   end
 
   describe "when performing leader duties" do
     before do
-      worker.stub(:until_next_iteration).and_return 0
-      worker.stub(:leader?).and_return true
-      worker.stub(:dictatorship_length).and_return 666
-      worker.stub(:iteration_length).and_return 5
-      worker.stub(:find_workers).and_return []
-      worker.stub(:initialize_buckets)
+      allow(worker).to receive(:until_next_iteration).and_return 0
+      allow(worker).to receive(:leader?).and_return true
+      allow(worker).to receive(:dictatorship_length).and_return 666
+      allow(worker).to receive(:iteration_length).and_return 5
+      allow(worker).to receive(:find_workers).and_return []
+      allow(worker).to receive(:initialize_buckets)
     end
 
     it "performs before_perform_leader_duties callback" do
-      worker.should_receive(:before_perform_leader_duties)
+      expect(worker).to receive(:before_perform_leader_duties)
       worker.perform_leader_duties
     end
 
@@ -265,52 +299,52 @@ describe Worker do
     end
 
     it "should initialize buckets as dictator" do
-      worker.should_receive(:seize_leadership).with(666).ordered
-      worker.should_receive(:initialize_buckets).ordered
-      worker.should_receive(:seize_leadership).ordered
+      expect(worker).to receive(:seize_leadership).with(666).ordered
+      expect(worker).to receive(:initialize_buckets).ordered
+      expect(worker).to receive(:seize_leadership).ordered
       worker.perform_leader_duties
     end
 
     describe "as long as there are buckets" do
       before do
-        worker.stub(:buckets).and_return([1], [2], [3], [4], [])
-        worker.stub(:relax)
+        allow(worker).to receive(:buckets).and_return([1], [2], [3], [4], [])
+        allow(worker).to receive(:relax)
       end
 
       it "should update buckets periodically" do
-        worker.should_receive(:update_buckets).exactly(4).times
+        expect(worker).to receive(:update_buckets).exactly(4).times
         worker.perform_leader_duties
       end
 
       it "should relax half of the time to the next iteration" do
-        worker.stub(:until_next_iteration).and_return(6)
-        worker.should_receive(:relax).with(3).exactly(4).times
+        allow(worker).to receive(:until_next_iteration).and_return(6)
+        expect(worker).to receive(:relax).with(3).exactly(4).times
         worker.perform_leader_duties
       end
 
       it "should seize the leadership periodically" do
-        worker.should_receive(:seize_leadership).at_least(4).times
+        expect(worker).to receive(:seize_leadership).at_least(4).times
         worker.perform_leader_duties
       end
 
       it "should seize the leadership periodically even if restart is wanted" do
-        worker.stub(:restart_wanted?).and_return true
-        worker.stub(:exit)
-        worker.should_receive(:seize_leadership).at_least(4).times
+        allow(worker).to receive(:restart_wanted?).and_return true
+        allow(worker).to receive(:exit)
+        expect(worker).to receive(:seize_leadership).at_least(4).times
         worker.perform_leader_duties
       end
 
       it "should not update buckets if restart is wanted" do
-        worker.stub(:restart_wanted?).and_return true
-        worker.stub(:exit)
-        worker.should_not_receive(:update_buckets)
+        allow(worker).to receive(:restart_wanted?).and_return true
+        allow(worker).to receive(:exit)
+        expect(worker).not_to receive(:update_buckets)
         worker.perform_leader_duties
       end
     end
 
     describe "if there are no more buckets" do
       before do
-        worker.stub(:buckets).and_return([])
+        allow(worker).to receive(:buckets).and_return([])
       end
 
       context "when restart is wanted" do
@@ -320,36 +354,37 @@ describe Worker do
         end
 
         it "populates the followers_to_stop list before evaluating it" do
-          worker.should_receive(:populate_followers_to_stop).ordered.once
-          worker.should_receive(:followers_to_stop).ordered.and_return []
+          expect(worker).to receive(:populate_followers_to_stop).ordered.once
+          expect(worker).to receive(:followers_to_stop).ordered.and_return []
           worker.perform_leader_duties
         end
 
         context "as long as there are followers to stop" do
           before do
-            worker.stub(:followers_to_stop).and_return([1], [2], [3], [4], [])
-            worker.stub(:relax)
+            # followers_to_stop is called twice due to logging
+            allow(worker).to receive(:followers_to_stop).and_return([1], [1], [2], [2], [])
+            allow(worker).to receive(:relax)
           end
 
           it "relaxes half of the time to the next iteration" do
-            worker.stub(:until_next_iteration).and_return(6)
-            worker.should_receive(:relax).with(3).exactly(4).times
+            allow(worker).to receive(:until_next_iteration).and_return(6)
+            expect(worker).to receive(:relax).with(3).exactly(2).times
             worker.perform_leader_duties
           end
 
           it "seizes the leadership periodically" do
-            worker.should_receive(:seize_leadership).at_least(4).times
+            expect(worker).to receive(:seize_leadership).at_least(2).times
             worker.perform_leader_duties
           end
         end
 
         context "if there are no more followers to stop" do
           before do
-            worker.stub(:followers_to_stop).and_return([])
+            allow(worker).to receive(:followers_to_stop).and_return([])
           end
 
           it "exits" do
-            worker.should_receive(:exit).with(0)
+            expect(worker).to receive(:exit).with(0)
             worker.perform_leader_duties
           end
         end
@@ -361,8 +396,8 @@ describe Worker do
         end
 
         it "does not populate the followers_to_stop list if restart is not wanted" do
-          worker.stub(:restart_wanted?).and_return false
-          worker.should_not_receive(:populate_followers_to_stop)
+          allow(worker).to receive(:restart_wanted?).and_return false
+          expect(worker).not_to receive(:populate_followers_to_stop)
           worker.perform_leader_duties
         end
       end
@@ -371,133 +406,133 @@ describe Worker do
 
   describe "when seizing leadership" do
     before do
-      worker.stub(:uri).and_return('myself')
-      worker.stub(:iteration_length).and_return 123
-      worker.stub(:token).and_return('dcc-group')
+      allow(worker).to receive(:uri).and_return('myself')
+      allow(worker).to receive(:iteration_length).and_return 123
+      allow(worker).to receive(:token).and_return('dcc-group')
     end
 
     it "should set itself to leader" do
-      memcache_client.should_receive(:set).with(anything(), 'myself', anything())
+      expect(memcache_client).to receive(:set).with(anything(), 'myself', anything())
       worker.seize_leadership
     end
 
     it "should seize the leadership for the amount of seconds given" do
-      memcache_client.should_receive(:set).with(anything(), anything(), 666)
+      expect(memcache_client).to receive(:set).with(anything(), anything(), 666)
       worker.seize_leadership 666
     end
 
     it "should seize the leadership for iteration_length if no duration is given" do
-      memcache_client.should_receive(:set).with(anything(), anything(), 123)
+      expect(memcache_client).to receive(:set).with(anything(), anything(), 123)
       worker.seize_leadership
     end
 
     it "should seize the leadership for the worker's group" do
-      memcache_client.should_receive(:set).with('dcc-group', anything(), anything())
+      expect(memcache_client).to receive(:set).with('dcc-group', anything(), anything())
       worker.seize_leadership
     end
 
     it "should have the next iteration exactly when the seized leadership ends" do
       now = Time.now
-      Time.stub(:now).and_return now
+      allow(Time).to receive(:now).and_return now
       end_of_leadership = now + 666
 
       worker.seize_leadership 666
-      worker.until_next_iteration.should == 666
+      expect(worker.until_next_iteration).to eq(666)
 
       worker.seize_leadership
-      worker.until_next_iteration.should == 123
+      expect(worker.until_next_iteration).to eq(123)
 
       worker.seize_leadership 6
-      worker.until_next_iteration.should == 6
+      expect(worker.until_next_iteration).to eq(6)
     end
   end
 
   describe "when creating next bucket" do
     it "should set the sleep time to sleep_until_next_bucket_time" do
-      worker.should_receive(:sleep_until_next_bucket_time).and_return 'the sleep time'
-      worker.next_bucket('', nil)[1].should == 'the sleep time'
+      expect(worker).to receive(:sleep_until_next_bucket_time).and_return 'the sleep time'
+      expect(worker.next_bucket('', nil)[1]).to eq('the sleep time')
     end
   end
 
   describe "when computing the sleep_until_next_bucket_time" do
     before do
-      worker.stub(:iteration_length).and_return 10
-      worker.stub(:until_next_iteration).and_return 6
+      allow(worker).to receive(:iteration_length).and_return 10
+      allow(worker).to receive(:until_next_iteration).and_return 6
     end
 
     it "should set the sleep time to half the time until_next_iteration" do
-      worker.sleep_until_next_bucket_time.should == 3
+      expect(worker.sleep_until_next_bucket_time).to eq(3)
     end
 
     it "should set the sleep time to at least 1 second" do
-      worker.stub(:until_next_iteration).and_return 0.6
-      worker.sleep_until_next_bucket_time.should == 1
+      allow(worker).to receive(:until_next_iteration).and_return 0.6
+      expect(worker.sleep_until_next_bucket_time).to eq(1)
     end
 
     it "should set the sleep time to at most a half of the interation_length" do
-      worker.stub(:until_next_iteration).and_return 60
-      worker.sleep_until_next_bucket_time.should == 5
+      allow(worker).to receive(:until_next_iteration).and_return 60
+      expect(worker.sleep_until_next_bucket_time).to eq(5)
     end
   end
 
   describe "when providing leader object" do
     before do
-      worker.stub(:until_next_iteration).and_return 0
+      allow(worker).to receive(:until_next_iteration).and_return 0
     end
 
     it "should return a drb object with the leader uri" do
-      worker.stub(:leader_uri).and_return("leader's uri")
-      DRbObject.should_receive(:new).with(nil, "leader's uri").and_return "leader"
-      worker.leader.should == "leader"
+      allow(worker).to receive(:leader_uri).and_return("leader's uri")
+      expect(DRbObject).to receive(:new).with(nil, "leader's uri").and_return "leader"
+      expect(worker.leader).to eq("leader")
     end
 
     it "should try three times to get the leader on anarchy (no leader)" do
-      worker.should_receive(:leader_uri).at_least(3).times.and_return nil
+      expect(worker).to receive(:leader_uri).at_least(3).times.and_return nil
       worker.leader rescue nil
     end
 
     it "should raise an error when leader cannot be determined during anarchy" do
-      worker.stub(:leader_uri).and_return nil
-      lambda {worker.leader}.should raise_error(/cannot determine leader/)
+      allow(worker).to receive(:leader_uri).and_return nil
+      expect {worker.leader}.to raise_error(/cannot determine leader/)
     end
 
     it "should sleep until next iteration before retrying to get leader" do
-      worker.stub(:leader_uri).and_return nil
-      worker.stub(:until_next_iteration).and_return 666
-      worker.should_receive(:relax).with(666).exactly(2).times
+      allow(worker).to receive(:leader_uri).and_return nil
+      allow(worker).to receive(:until_next_iteration).and_return 666
+      expect(worker).to receive(:relax).with(666).exactly(2).times
       worker.leader rescue nil
     end
   end
 
   describe "when cleaning up" do
     before do
-      worker.stub(:group_name).and_return('the group')
+      allow(worker).to receive(:group_name).and_return('the group')
     end
 
     describe "as leader" do
       before do
-        worker.stub(:leader?).and_return true
-        memcache_client.stub(:delete)
+        allow(worker).to receive(:leader?).and_return true
+        allow(memcache_client).to receive(:delete)
       end
 
       it "should remove the leadership token from memcache" do
-        memcache_client.should_receive(:delete).with('the group_token')
+        expect(memcache_client).to receive(:delete).with('the group_token')
         worker.send(:internal_cleanup)
       end
 
       it "should remove the restart wanted flag from memcache" do
-        memcache_client.should_receive(:delete).with('the group_restart')
+        expect(memcache_client).to receive(:delete).with('the group_restart')
         worker.send(:internal_cleanup)
       end
     end
 
     describe "as follower" do
       before do
-        worker.stub(:leader?).and_return false
+        allow(worker).to receive(:leader?).and_return false
       end
 
       it "should not remove anything from memcache" do
-        memcache_client.should_not_receive(:delete)
+        expect(memcache_client).not_to receive(:delete)
         worker.send(:internal_cleanup)
       end
     end
@@ -505,39 +540,39 @@ describe Worker do
 
   describe "when populating followers_to_stop" do
     before do
-      worker.stub(:find_workers).and_return(%w(a b c))
-      DRbObject.stub(:new).and_return(double('o', :alive? => true))
+      allow(worker).to receive(:find_workers).and_return(%w(a b c))
+      allow(DRbObject).to receive(:new).and_return(double('o', :alive? => true))
     end
 
     it "should add all visible workers" do
       worker.populate_followers_to_stop
-      worker.followers_to_stop.should =~ %w(a b c)
+      expect(worker.followers_to_stop).to match_array(%w(a b c))
     end
   end
 
   describe "when delivering followers_to_stop" do
     before do
-      worker.stub(:find_workers).and_return(%w(a b c))
+      allow(worker).to receive(:find_workers).and_return(%w(a b c))
       worker.populate_followers_to_stop
-      DRbObject.stub(:new).and_return(double('o', :alive? => true))
+      allow(DRbObject).to receive(:new).and_return(double('o', :alive? => true))
     end
 
     it "should return the actual followers_to_stop" do
-      worker.followers_to_stop.should =~ %w(a b c)
+      expect(worker.followers_to_stop).to match_array(%w(a b c))
     end
 
     it "should not deliver entries that are not reachable at the moment" do
-      DRbObject.stub(:new).with(nil, 'a').and_return(double('o', :alive? => false))
-      DRbObject.stub(:new).with(nil, 'b').and_return(x = double('o'))
-      x.stub(:alive?).and_raise DRb::DRbConnError.new('nix da')
-      worker.followers_to_stop.should == %w(c)
+      allow(DRbObject).to receive(:new).with(nil, 'a').and_return(double('o', :alive? => false))
+      allow(DRbObject).to receive(:new).with(nil, 'b').and_return(x = double('o'))
+      allow(x).to receive(:alive?).and_raise DRb::DRbConnError.new('nix da')
+      expect(worker.followers_to_stop).to eq(%w(c))
     end
 
     it "should not remove unreachable entries from the list - maybe they reappear" do
-      DRbObject.stub(:new).with(nil, 'a').and_return(double('o', :alive? => false))
-      worker.followers_to_stop.should =~ %w(b c)
-      DRbObject.stub(:new).with(nil, 'a').and_return(double('o', :alive? => true))
-      worker.followers_to_stop.should =~ %w(a b c)
+      allow(DRbObject).to receive(:new).with(nil, 'a').and_return(double('o', :alive? => false))
+      expect(worker.followers_to_stop).to match_array(%w(b c))
+      allow(DRbObject).to receive(:new).with(nil, 'a').and_return(double('o', :alive? => true))
+      expect(worker.followers_to_stop).to match_array(%w(a b c))
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: infopark-politics
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-30 00:00:00.000000000 Z
+date: 2015-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec