infopark-politics 0.3.2pg55d4620 → 0.3.2

data/lib/politics/static_queue_worker.rb

@@ -223,10 +223,6 @@ module Politics
       workers
     end
 
-    def hostname
-      nil
-    end
-
     private
 
     def restart_wanted?
@@ -333,7 +329,7 @@ module Politics
     end
 
     def register_with_bonjour
-      server = DRb.start_service("druby://#{hostname || ""}:0", self)
+      server = DRb.start_service(nil, self)
       @uri = DRb.uri
       @port = URI.parse(DRb.uri).port
 

data/lib/politics/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+module Politics
+  module Version
+    STRING = "0.3.2"
+  end
+end

metadata

@@ -1,207 +1,107 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: infopark-politics
-version: !ruby/object:Gem::Version 
-  hash: 3630819867
-  prerelease: 5
-  segments: 
-  - 0
-  - 3
-  - 2
-  - pg
-  - 55
-  - d
-  - 4620
-  version: 0.3.2pg55d4620
+version: !ruby/object:Gem::Version
+  version: 0.3.2
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Mike Perham
-- "Tilo Pr\xC3\xBCtz"
+- Tilo Prütz
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-11-09 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 2
-        - 14
-        version: "2.14"
-  name: rspec
-  version_requirements: *id001
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 10
-        version: "10"
-  name: rake
-  version_requirements: *id002
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 21
-        segments: 
-        - 3
-        - 9
-        version: "3.9"
-  name: rdoc
-  version_requirements: *id003
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id004 !ruby/object:Gem::Requirement 
+date: 2013-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: memcache-client
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 0
-        - 2
-        version: "0.2"
-  name: rubygems-tasks
-  version_requirements: *id004
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
   prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 1
-        - 5
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.5.0
-  name: memcache-client
-  version_requirements: *id005
-  prerelease: false
-  type: :runtime
-- !ruby/object:Gem::Dependency 
-  requirement: &id006 !ruby/object:Gem::Requirement 
+- !ruby/object:Gem::Dependency
+  name: starling-starling
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 43
-        segments: 
-        - 0
-        - 9
-        - 8
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.9.8
-  name: starling-starling
-  version_requirements: *id006
-  prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency 
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        - 4
-        version: "0.4"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+- !ruby/object:Gem::Dependency
   name: net-mdns
-  version_requirements: *id007
-  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.4'
   type: :runtime
-description: ""
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Algorithms and Tools for Distributed Computing in Ruby.
 email: tilo@infopark.de
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - History.rdoc
 - LICENSE
 - README.rdoc
-files: 
-- .gitignore
-- .rbenv-version
-- .rspec
-- Gemfile
-- History.rdoc
-- LICENSE
-- Manifest
-- README.rdoc
-- Rakefile
-- VERSION
-- dcc_config.rb
+files:
 - examples/queue_worker_example.rb
 - examples/token_worker_example.rb
-- infopark-politics.gemspec
 - lib/init.rb
 - lib/politics.rb
 - lib/politics/discoverable_node.rb
 - lib/politics/static_queue_worker.rb
 - lib/politics/token_worker.rb
-- spec/spec_helper.rb
-- spec/static_queue_worker_spec.rb
-- test/static_queue_worker_test.rb
-- test/test_helper.rb
-- test/token_worker_test.rb
-has_rdoc: true
+- lib/politics/version.rb
+- History.rdoc
+- LICENSE
+- README.rdoc
 homepage: http://github.com/infopark/politics
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 31
-      segments: 
-      - 1
-      - 8
-      version: "1.8"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Algorithms and Tools for Distributed Computing in Ruby.
-test_files: 
-- spec/spec_helper.rb
-- spec/static_queue_worker_spec.rb
-- test/static_queue_worker_test.rb
-- test/test_helper.rb
-- test/token_worker_test.rb
+test_files: []

data/.gitignore

@@ -1,2 +0,0 @@
-pkg
-Gemfile.lock

data/.rbenv-version

@@ -1 +0,0 @@
-1.8.7-p374

data/.rspec

@@ -1,2 +0,0 @@
---color
---format progress

data/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

data/Manifest

@@ -1,17 +0,0 @@
-examples/queue_worker_example.rb
-examples/token_worker_example.rb
-History.rdoc
-lib/init.rb
-lib/politics/discoverable_node.rb
-lib/politics/static_queue_worker.rb
-lib/politics/token_worker.rb
-lib/politics/version.rb
-lib/politics.rb
-LICENSE
-Manifest
-politics.gemspec
-Rakefile
-README.rdoc
-test/static_queue_worker_test.rb
-test/test_helper.rb
-test/token_worker_test.rb

data/Rakefile

@@ -1,25 +0,0 @@
-# encoding: utf-8
-require 'rdoc/task'
-require 'rake/testtask'
-require 'rspec/core/rake_task'
-require 'rubygems/tasks'
-
-Gem::Tasks.new
-
-desc "Run tests"
-Rake::TestTask.new do |t|
-  t.libs << 'test' << 'lib'
-  t.test_files = FileList['test/*_test.rb']
-end
-
-desc "Run specs"
-RSpec::Core::RakeTask.new
-
-desc "Create rdoc"
-Rake::RDocTask.new do |rd|
-  rd.main = "README.rdoc"
-  rd.rdoc_files.include("README.rdoc", "History.rdoc", "lib/**/*.rb")
-end
-
-
-task :default => :test

data/VERSION

@@ -1 +0,0 @@
-0.3.2

data/dcc_config.rb

@@ -1,5 +0,0 @@
-send_notifications_to "tilo@infopark.de"
-
-buckets "test" do
-  bucket(:specs).performs_rake_tasks("spec")
-end

data/infopark-politics.gemspec

@@ -1,38 +0,0 @@
-# encoding: utf-8
-requirement = Gem::Requirement.new(">= 1.6.2")
-unless requirement.satisfied_by?(Gem::Version.new(Gem::VERSION))
-  raise "You need at RubyGems in Version #{requirement} to build this gem."
-end
-
-version = `cd #{File.dirname(__FILE__)} && git describe --tags`.strip.gsub(/^v/, "").gsub(/-.*-/, "p")
-
-Gem::Specification.new do |gem|
-  gem.name = "infopark-politics"
-  gem.version = version
-  gem.summary = "Algorithms and Tools for Distributed Computing in Ruby."
-  gem.description = ""
-  gem.authors = ["Mike Perham", "Tilo Prütz"]
-  gem.email = "tilo@infopark.de"
-  gem.homepage = "http://github.com/infopark/politics"
-
-  gem.required_rubygems_version = Gem::Requirement.new(">= 1.8")
-  gem.extra_rdoc_files = [
-    "History.rdoc",
-    "LICENSE",
-    "README.rdoc"
-  ]
-  gem.files = `git ls-files`.split("\n")
-  gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.require_paths = ["lib"]
-
-  gem.add_development_dependency "rspec", ">= 2.14"
-  gem.add_development_dependency "rake", ">= 10"
-  gem.add_development_dependency "rdoc", ">= 3.9"
-  gem.add_development_dependency "rubygems-tasks", ">=0.2"
-
-  gem.add_runtime_dependency "memcache-client", ">= 1.5.0"
-  gem.add_runtime_dependency "starling-starling", ">= 0.9.8"
-  gem.add_runtime_dependency "net-mdns", ">= 0.4"
-end
-

data/spec/spec_helper.rb

@@ -1,17 +0,0 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-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
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-end

data/spec/static_queue_worker_spec.rb

@@ -1,544 +0,0 @@
-# encoding: utf-8
-# FIXME oberen Teil in spec_helper.rb auslagern
-require 'rubygems'
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require File.dirname(__FILE__) + '/../lib/init'
-Politics::log.level = Logger::FATAL
-
-class UninitializedWorker
-  include Politics::StaticQueueWorker
-  def initialize(memcache_client)
-    @memcache_client = memcache_client
-    log.level = Logger::FATAL
-  end
-
-  def start
-    process_bucket do |bucket|
-      sleep 0.1
-    end
-  end
-
-  def client_for(servers)
-    @memcache_client
-  end
-
-  def local_ip
-    IPAddr.new("127.0.0.1")
-  end
-
-  def at_exit
-  end
-end
-
-class Worker < UninitializedWorker
-  def initialize(memcache_client)
-    super
-    register_worker 'worker', 10, :iteration_length => 10
-  end
-end
-
-describe UninitializedWorker do
-  let(:memcache_client) { double('memcache', :set => nil, :get => nil) }
-  let(:worker) { UninitializedWorker.new memcache_client}
-
-  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}
-      handler = worker.register_worker('worker', 10, :iteration_length => 10)
-
-      worker.should_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]+|
-    end
-
-    it "should not have a hostname" do
-      worker.hostname.should be_nil
-    end
-
-    context "when it has a hostname" do
-      before do
-        worker.stub(: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]+|
-      end
-    end
-
-    context "when it does not have a hostname" do
-      before do
-        worker.stub(: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]+|
-      end
-    end
-  end
-end
-
-describe Worker do
-  let(:memcache_client) { double('memcache', :set => nil, :get => nil) }
-  let(:worker) { Worker.new memcache_client }
-
-  it "should provide 'until_next_iteration' even if nominate was not completed" do
-    worker.until_next_iteration
-  end
-
-  it "should return time to next iteration even if nominate was not completed" do
-    worker.until_next_iteration.should > 0
-    worker.until_next_iteration.should <= 10
-  end
-
-  it "should give access to the uri" do
-    worker.uri.should =~ %r(^druby://)
-  end
-
-  it "should be alive" do
-    worker.should be_alive
-  end
-
-  describe "when processing bucket" do
-    before do
-      DRbObject.stub(: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/)
-    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
-      end
-
-      it "should relax until next iteration on MemCache errors during nomination" do
-        worker.should_receive(:nominate).exactly(4).and_raise MemCache::MemCacheError.new("Buh!")
-        worker.should_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(MemCache::MemCacheError.new("Buh"))
-        worker.should_receive(:relax).with(666).exactly(4).times
-
-        worker.start
-      end
-
-      describe "as leader" do
-        before do
-          worker.stub(:leader?).and_return true
-        end
-
-        it "should do leader duties" do
-          worker.should_receive(:perform_leader_duties).exactly(4).times
-          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])
-        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).exactly(4).times.
-              and_return([1, 2])
-          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
-          end
-          worker.start
-        end
-      end
-    end
-  end
-
-  describe "when handling a bucket request" do
-    describe "as leader" do
-      before do
-        worker.stub(:leader?).and_return true
-      end
-
-      it "should deliver the bucket" do
-        worker.should_receive(:next_bucket).with("requestor").and_return "the bucket"
-        worker.bucket_request("requestor").should == "the bucket"
-      end
-
-      describe "when no buckets are left" do
-        before do
-          worker.stub(:find_workers).and_return(%w(1 2 3))
-          worker.populate_followers_to_stop
-          DRbObject.stub(: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").should == [:stop, 0]
-        end
-
-        it "should not deliver the :stop bucket if requestor is not in followers_to_stop list" do
-          worker.bucket_request("requestor")[0].should be_nil
-        end
-
-        it "should remove the requestor from the followers_to_stop list" do
-          worker.bucket_request("2")
-          worker.followers_to_stop.should =~ %w(1 3)
-        end
-      end
-    end
-
-    describe "as follower" do
-      before do
-        worker.stub(:leader?).and_return false
-      end
-
-      it "should deliver the :not_leader bucket" do
-        worker.bucket_request("requestor")[0].should == :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
-    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
-    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 []
-    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
-      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)
-      end
-
-      it "should update buckets periodically" do
-        worker.should_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
-        worker.perform_leader_duties
-      end
-
-      it "should seize the leadership periodically" do
-        worker.should_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
-        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)
-        worker.perform_leader_duties
-      end
-    end
-
-    describe "if there are no more buckets" do
-      before do
-        worker.stub(:buckets).and_return([])
-      end
-
-      it "should populate the followers_to_stop list before evaluating it if restart is wanted" do
-        worker.stub(:restart_wanted?).and_return true
-        worker.stub(:exit)
-        worker.should_receive(:populate_followers_to_stop).ordered.once
-        worker.should_receive(:followers_to_stop).ordered.and_return []
-        worker.perform_leader_duties
-      end
-
-      it "should 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)
-        worker.perform_leader_duties
-      end
-
-      describe "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)
-        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
-          worker.perform_leader_duties
-        end
-
-        it "should seize the leadership periodically" do
-          worker.should_receive(:seize_leadership).at_least(4).times
-          worker.perform_leader_duties
-        end
-      end
-
-      describe "if there are no more followers to stop" do
-        before do
-          worker.stub(:followers_to_stop).and_return([])
-        end
-
-        it "should relax until next iteration" do
-          worker.stub(:until_next_iteration).and_return(6)
-          worker.should_receive(:relax).with(6).once
-          worker.perform_leader_duties
-        end
-
-        it "should exit if restart is wanted" do
-          worker.stub(:restart_wanted?).and_return true
-          worker.should_receive(:exit).with(0)
-          worker.perform_leader_duties
-        end
-      end
-    end
-  end
-
-  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')
-    end
-
-    it "should set itself to leader" do
-      memcache_client.should_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)
-      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)
-      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())
-      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
-      end_of_leadership = now + 666
-
-      worker.seize_leadership 666
-      worker.until_next_iteration.should == 666
-
-      worker.seize_leadership
-      worker.until_next_iteration.should == 123
-
-      worker.seize_leadership 6
-      worker.until_next_iteration.should == 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('')[1].should == '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
-    end
-
-    it "should set the sleep time to half the time until_next_iteration" do
-      worker.sleep_until_next_bucket_time.should == 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
-    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
-    end
-  end
-
-  describe "when providing leader object" do
-    before do
-      worker.stub(: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"
-    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
-      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/)
-    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
-      worker.leader rescue nil
-    end
-  end
-
-  describe "when cleaning up" do
-    before do
-      worker.stub(:group_name).and_return('the group')
-    end
-
-    describe "as leader" do
-      before do
-        worker.stub(:leader?).and_return true
-        memcache_client.stub(:delete)
-      end
-
-      it "should remove the leadership token from memcache" do
-        memcache_client.should_receive(:delete).with('the group_token')
-        worker.send(:cleanup)
-      end
-
-      it "should remove the restart wanted flag from memcache" do
-        memcache_client.should_receive(:delete).with('the group_restart')
-        worker.send(:cleanup)
-      end
-    end
-
-    describe "as follower" do
-      before do
-        worker.stub(:leader?).and_return false
-      end
-
-      it "should not remove anything from memcache" do
-        memcache_client.should_not_receive(:delete)
-        worker.send(:cleanup)
-      end
-    end
-  end
-
-  describe "when finding workers" do
-    before do
-      Net::DNS::MDNSSD.stub(:browse).
-          and_yield(double('response1', :name => 'w1')).
-          and_yield(double('response2', :name => 'w2')).
-          and_yield(double('response3', :name => 'w3')).
-          and_yield(double('response4', :name => 'w4')).
-          and_return(@browser = double('browser', :stop => nil))
-      worker.stub(:sleep)
-    end
-
-    it "should browse mdns group and return workers found" do
-      worker.find_workers.should == %w(w1 w2 w3 w4)
-    end
-
-    it "should not add itself to the result list" do
-      worker.stub(:uri).and_return('w3')
-      worker.find_workers.should_not include('w3')
-    end
-
-    it "should stop browser thread after five seconds" do
-      worker.should_receive(:sleep).with(5).ordered
-      @browser.should_receive(:stop)
-      worker.find_workers
-    end
-  end
-
-  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))
-    end
-
-    it "should add all visible workers" do
-      worker.populate_followers_to_stop
-      worker.followers_to_stop.should =~ %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))
-      worker.populate_followers_to_stop
-      DRbObject.stub(: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)
-    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)
-    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)
-    end
-  end
-end

data/test/static_queue_worker_test.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__) + '/test_helper'
-
-Thread.abort_on_exception = true
-
-class Worker
-  include Politics::StaticQueueWorker
-  def initialize
-    register_worker 'worker', 10, :iteration_length => 10
-  end
-
-  def start
-    process_bucket do |bucket|
-      sleep 1
-    end
-  end
-end
-
-class StaticQueueWorkerTest < Test::Unit::TestCase
-
-  context "nodes" do
-    setup do
-      @nodes = []
-      5.times do
-        @nodes << nil
-      end
-    end
-
-    should "start up" do
-      processes = @nodes.map do
-        fork do
-          ['INT', 'TERM'].each { |signal|
-            trap(signal) { exit(0) }
-          }
-          Worker.new.start
-        end
-      end
-      sleep 10
-      puts "Terminating"
-      Process.kill('INT', *processes)
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-require 'rubygems'
-require 'test/unit'
-
-begin
-  gem 'thoughtbot-shoulda', '>=2.0.2'
-  require 'shoulda'
-rescue LoadError => e
-  puts "Please install shoulda: `sudo gem install thoughtbot-shoulda -s http://gems.github.com`"
-end
-
-begin
-  require 'mocha'
-rescue LoadError => e
-  puts "Please install mocha: `sudo gem install mocha`"
-end
-
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require File.dirname(__FILE__) + '/../lib/init'
-Politics::log.level = Logger::WARN

data/test/token_worker_test.rb

@@ -1,79 +0,0 @@
-# encoding: utf-8
-require 'test_helper'
-
-class TokenWorkerTest < Test::Unit::TestCase
-
-  context "token workers" do
-    setup do
-      @harness = Class.new
-      @harness.send(:include, Politics::TokenWorker)
-      @harness.any_instance.stubs(:cleanup)
-      @harness.any_instance.stubs(:loop?).returns(false)
-      @harness.any_instance.stubs(:pause_until_expiry)
-      @harness.any_instance.stubs(:relax)
-
-      @worker = @harness.new
-    end
-
-    should "test_instance_property_accessors" do
-      assert @worker.iteration_length = 20
-      assert_equal 20, @worker.iteration_length
-    end
-
-    should 'test_tracks_a_registered_singleton' do
-      assert_nil @worker.class.worker_instance
-      @worker.register_worker('testing')
-      assert_equal @worker.class.worker_instance, @worker
-    end
-
-    should 'not process if they are not leader' do
-      @worker.expects(:nominate)
-      @worker.expects(:leader?).returns(false)
-      @worker.register_worker('testing')
-      @worker.process do
-        assert false
-      end
-    end
-
-    should 'handle unexpected MemCache errors' do
-      @worker.expects(:nominate)
-      @worker.expects(:leader?).raises(MemCache::MemCacheError)
-      Politics::log.expects(:error).times(3)
-
-      @worker.register_worker('testing')
-      @worker.process do
-        assert false
-      end
-    end
-
-    should 'process if they are leader' do
-      @worker.expects(:nominate)
-      @worker.expects(:leader?).returns(true)
-      @worker.register_worker('testing')
-
-      worked = 0
-      @worker.process do
-        worked += 1
-      end
-
-      assert_equal 1, worked
-    end
-
-    should 'not allow processing without registration' do
-      assert_raises ArgumentError do
-        @worker.process
-      end
-    end
-
-    should 'not allow processing by old instances' do
-      @worker.register_worker('testing')
-
-      foo = @worker.class.new
-      foo.register_worker('testing')
-
-      assert_raises SecurityError do
-        @worker.process
-      end
-    end
-  end
-end