furnish 0.0.4 → 0.1.0

data/test/test_provisioner_group.rb

@@ -1,5 +1,6 @@
 require 'helper'
 
+# NOTE the dummy classes in this file are defined in test/dummy_classes.rb
 class TestProvisionerGroup < Furnish::TestCase
   def test_constructor
     dummy = Dummy.new
@@ -8,22 +9,24 @@ class TestProvisionerGroup < Furnish::TestCase
     assert_equal('blarg', pg.name)
     assert_kind_of(Set, pg.dependencies)
     assert_empty(pg.dependencies)
-    assert_equal('blarg', dummy.name)
+    assert_equal('blarg', dummy.furnish_group_name)
 
     dummy = Dummy.new
     pg = Furnish::ProvisionerGroup.new([dummy], 'blarg2', %w[blarg])
     assert_includes(pg, dummy)
     assert_equal('blarg2', pg.name)
     assert_equal(Set['blarg'], pg.dependencies)
-    assert_equal('blarg2', dummy.name)
+    assert_equal('blarg2', dummy.furnish_group_name)
+
+    assert_raises(ArgumentError, "A non-empty list of provisioners must be provided") { Furnish::ProvisionerGroup.new([], 'blarg3') }
+    assert_raises(ArgumentError, "A non-empty list of provisioners must be provided") { Furnish::ProvisionerGroup.new(nil, 'blarg3') }
   end
 
   def test_up_down
-    if ENV["FURNISH_DEBUG"]
-      $stderr.puts "Testing logging, output muted"
-      require 'stringio'
-      Furnish.logger = Furnish::Logger.new(StringIO.new, 3)
-    end
+    Furnish.logger.puts "Testing logging, output muted"
+
+    require 'stringio'
+    Furnish.logger = Furnish::Logger.new(StringIO.new, 3)
 
     store = Palsy::Object.new('dummy')
     dummy = Dummy.new
@@ -31,27 +34,176 @@ class TestProvisionerGroup < Furnish::TestCase
 
     assert(pg.startup, 'started')
     assert(store[ [pg.name, 'startup'].join("-") ], 'startup ran')
+    assert_nil(pg.group_state['index'])
+    assert_nil(pg.group_state['provisioner_args'])
+    assert_nil(pg.group_state['action'])
+    assert_nil(pg.group_state['provisioner'])
+
     assert(pg.shutdown, 'stopped')
     assert(store[ [pg.name, 'startup'].join("-") ], 'shutdown ran')
+    assert_nil(pg.group_state['index'])
+    assert_nil(pg.group_state['provisioner_args'])
+    assert_nil(pg.group_state['action'])
+    assert_nil(pg.group_state['provisioner'])
+
+    pg = Furnish::ProvisionerGroup.new([Dummy.new, StartFailDummy.new], 'track_test')
+    assert_raises(RuntimeError, "Could not provision #{pg.name} with provisioner #{dummy.class.name}") { pg.startup }
+    assert_equal(1, pg.group_state['index'])
+    assert_equal(:startup, pg.group_state['action'])
+    assert_equal(StartFailDummy, pg.group_state['provisioner'].class)
+    assert_equal({}, pg.group_state['provisioner_args'])
+
+    pg = Furnish::ProvisionerGroup.new([Dummy.new, StartExceptionDummy.new], 'track_test')
+    assert_raises(RuntimeError, "Could not provision #{pg.name} with provisioner #{dummy.class.name}") { pg.startup }
+    assert_equal(1, pg.group_state['index'])
+    assert_equal(:startup, pg.group_state['action'])
+    assert_equal(StartExceptionDummy, pg.group_state['provisioner'].class)
+    assert_equal({}, pg.group_state['provisioner_args'])
+
+    pg = Furnish::ProvisionerGroup.new([StopFailDummy.new, Dummy.new], 'track_test')
+    assert_raises(RuntimeError, "Could not deprovision #{pg.name}/#{dummy.class.name}") { pg.shutdown }
+    assert_equal(1, pg.group_state['index'])
+    assert_equal(:shutdown, pg.group_state['action'])
+    assert_equal(StopFailDummy, pg.group_state['provisioner'].class)
+
+    pg = Furnish::ProvisionerGroup.new([StopExceptionDummy.new, Dummy.new], 'track_test')
+    assert_raises(RuntimeError, "Could not deprovision #{pg.name}/#{dummy.class.name}") { pg.shutdown }
+    assert_equal(1, pg.group_state['index'])
+    assert_equal(:shutdown, pg.group_state['action'])
+    assert_equal(StopExceptionDummy, pg.group_state['provisioner'].class)
 
     dummy = StartFailDummy.new
-    pg = Furnish::ProvisionerGroup.new(dummy, 'blarg2')
+    pg = Furnish::ProvisionerGroup.new([ReturnsDataDummy.new, dummy], 'blarg2')
     assert_raises(RuntimeError, "Could not provision #{pg.name} with provisioner #{dummy.class.name}") { pg.startup }
+    assert_equal(1, pg.group_state['index'])
+    assert_equal(:startup, pg.group_state['action'])
+    assert_equal(dummy.class, pg.group_state['provisioner'].class)
+    assert_equal({:started => 1}, pg.group_state['provisioner_args'])
 
     dummy = StopFailDummy.new
     pg = Furnish::ProvisionerGroup.new(dummy, 'blarg3')
     assert_raises(RuntimeError, "Could not deprovision #{pg.name}/#{dummy.class.name}") { pg.shutdown }
-    pg.shutdown(true)
+    assert_equal(0, pg.group_state['index'])
+    assert_equal(:shutdown, pg.group_state['action'])
+    assert_equal(dummy.class, pg.group_state['provisioner'].class)
+    pg.shutdown({ }, true)
+    assert_nil(pg.group_state['index'])
+    assert_nil(pg.group_state['provisioner_args'])
+    assert_nil(pg.group_state['action'])
+    assert_nil(pg.group_state['provisioner'])
 
     dummy = StartExceptionDummy.new
     pg = Furnish::ProvisionerGroup.new(dummy, 'blarg4')
     assert_raises(RuntimeError, "Could not provision #{pg.name} with provisioner #{dummy.class.name}") { pg.startup }
+    assert_equal(:startup, pg.group_state['action'])
+    assert_equal(dummy.class, pg.group_state['provisioner'].class)
 
     dummy = StopExceptionDummy.new
     pg = Furnish::ProvisionerGroup.new(dummy, 'blarg4')
     assert_raises(RuntimeError, "Could not deprovision #{pg.name}/#{dummy.class.name}") { pg.shutdown }
-    pg.shutdown(true)
+    assert_equal(0, pg.group_state['index'])
+    assert_equal(:shutdown, pg.group_state['action'])
+    assert_equal(dummy.class, pg.group_state['provisioner'].class)
+    pg.shutdown({ }, true)
+    assert_nil(pg.group_state['index'])
+    assert_nil(pg.group_state['provisioner_args'])
+    assert_nil(pg.group_state['action'])
+    assert_nil(pg.group_state['provisioner'])
     sleep 0.1 # wait for flush
-    assert_match(%r!Deprovision #{dummy.class.name}/#{pg.name} had errors:!, Furnish.logger.string)
+    assert_includes(Furnish.logger.string.split(/\n/), "Deprovision of #{pg.name}[#{dummy.class.name}] had errors:")
+  end
+
+  def test_recover
+    [ RecoverableDummy, RaisingRecoverableDummy ].each do |prov|
+      pg = Furnish::ProvisionerGroup.new(prov.new, "#{prov.name}-recover1")
+      assert_raises(RuntimeError) { pg.startup }
+      assert_equal(0, pg.group_state['index'])
+      assert_equal(:startup, pg.group_state['action'])
+      assert_equal(prov, pg.group_state['provisioner'].class)
+      assert_equal({ }, pg.group_state['provisioner_args'])
+      assert(pg.recover)
+      assert_nil(pg.group_state['index'])
+      assert_nil(pg.group_state['provisioner_args'])
+      assert_nil(pg.group_state['action'])
+      assert_nil(pg.group_state['provisioner'])
+      assert(pg.first.run_state[:startup])
+
+      pg = Furnish::ProvisionerGroup.new(prov.new, "#{prov.name}-recover2")
+      assert_raises(RuntimeError) { pg.shutdown }
+      assert_equal(0, pg.group_state['index'])
+      assert_equal(:shutdown, pg.group_state['action'])
+      assert_equal(prov, pg.group_state['provisioner'].class)
+      assert_equal({ }, pg.group_state['provisioner_args'])
+      assert(pg.recover)
+      assert_nil(pg.group_state['index'])
+      assert_nil(pg.group_state['provisioner_args'])
+      assert_nil(pg.group_state['action'])
+      assert_nil(pg.group_state['provisioner'])
+      assert(pg.first.run_state[:shutdown])
+
+      pg = Furnish::ProvisionerGroup.new([Dummy.new, prov.new], "#{prov.name}-recover3")
+      assert_raises(RuntimeError) { pg.startup }
+      assert_equal(1, pg.group_state['index'])
+      assert_equal(:startup, pg.group_state['action'])
+      assert_equal(prov, pg.group_state['provisioner'].class)
+      assert(pg.group_state['provisioner_args'])
+      assert(pg.first.run_state[:startup])
+      refute(pg.last.run_state[:startup])
+      assert(pg.recover)
+      assert_nil(pg.group_state['index'])
+      assert_nil(pg.group_state['provisioner_args'])
+      assert_nil(pg.group_state['action'])
+      assert_nil(pg.group_state['provisioner'])
+      assert(pg.last.run_state[:startup])
+
+      pg = Furnish::ProvisionerGroup.new([Dummy.new, prov.new], "#{prov.name}-recover4")
+      assert_raises(RuntimeError) { pg.shutdown }
+      assert_equal(0, pg.group_state['index'])
+      assert_equal(:shutdown, pg.group_state['action'])
+      assert_equal(prov, pg.group_state['provisioner'].class)
+      assert_equal({ }, pg.group_state['provisioner_args'])
+      refute(pg.first.run_state[:shutdown])
+      refute(pg.last.run_state[:shutdown])
+      assert(pg.recover)
+      assert_nil(pg.group_state['index'])
+      assert_nil(pg.group_state['provisioner_args'])
+      assert_nil(pg.group_state['action'])
+      assert_nil(pg.group_state['provisioner'])
+
+      assert(pg.first.run_state[:shutdown])
+      assert(pg.last.run_state[:shutdown])
+
+      pg = Furnish::ProvisionerGroup.new([prov.new, Dummy.new], "#{prov.name}-recover5")
+      assert_raises(RuntimeError) { pg.startup }
+      assert_equal(0, pg.group_state['index'])
+      assert_equal(:startup, pg.group_state['action'])
+      assert_equal(prov, pg.group_state['provisioner'].class)
+      assert_equal({ }, pg.group_state['provisioner_args'])
+      refute(pg.first.run_state[:startup])
+      refute(pg.last.run_state[:startup])
+      assert(pg.recover)
+      assert_nil(pg.group_state['index'])
+      assert_nil(pg.group_state['provisioner_args'])
+      assert_nil(pg.group_state['action'])
+      assert_nil(pg.group_state['provisioner'])
+      assert_equal({ :startup => true }, pg.first.run_state[:startup])
+      assert(pg.last.run_state[:startup])
+
+      pg = Furnish::ProvisionerGroup.new([prov.new, Dummy.new], "#{prov.name}-recover6")
+      assert_raises(RuntimeError) { pg.shutdown }
+      assert_equal(1, pg.group_state['index'])
+      assert_equal(:shutdown, pg.group_state['action'])
+      assert_equal(prov, pg.group_state['provisioner'].class)
+      assert_equal({ }, pg.group_state['provisioner_args'])
+      refute(pg.first.run_state[:shutdown])
+      assert(pg.last.run_state[:shutdown])
+      assert(pg.recover)
+      assert_nil(pg.group_state['index'])
+      assert_nil(pg.group_state['provisioner_args'])
+      assert_nil(pg.group_state['action'])
+      assert_nil(pg.group_state['provisioner'])
+      assert_equal({ :shutdown => true }, pg.first.run_state[:shutdown])
+      assert(pg.last.run_state[:shutdown])
+    end
   end
 end

data/test/test_scheduler_basic.rb

@@ -2,14 +2,12 @@ require 'helper'
 
 class TestSchedulerBasic < Furnish::SchedulerTestCase
   def test_schedule_provision
-    sched = Furnish::Scheduler.new
-
     assert(sched.schedule_provision('blarg', [Dummy.new]), 'we can schedule')
     assert_includes(sched.vm.waiters.keys, 'blarg', 'exists in the waiters')
     assert_includes(sched.vm.groups.keys, 'blarg', 'exists in the vm group set')
     assert_equal(1, sched.vm.groups['blarg'].count, 'one item array')
     assert_kind_of(Furnish::Provisioner::Dummy, sched.vm.groups['blarg'].first, 'first object is our dummy object')
-    assert_equal('blarg', sched.vm.groups['blarg'].first.name, 'name is set properly')
+    assert_equal('blarg', sched.vm.groups['blarg'].first.furnish_group_name, 'name is set properly')
     assert_nil(sched.schedule_provision('blarg', [Dummy.new]), 'does not schedule twice')
 
     assert(sched.schedule_provision('blarg2', Dummy.new), 'scheduling does not need an array')
@@ -17,7 +15,7 @@ class TestSchedulerBasic < Furnish::SchedulerTestCase
     assert_includes(sched.vm.groups.keys, 'blarg2', 'exists in the vm group set')
     assert_kind_of(Furnish::ProvisionerGroup, sched.vm.groups['blarg2'], 'boxes our single item')
     assert_kind_of(Furnish::Provisioner::Dummy, sched.vm.groups['blarg2'].first, 'first object is our dummy object')
-    assert_equal('blarg2', sched.vm.groups['blarg2'].first.name, 'name is set properly')
+    assert_equal('blarg2', sched.vm.groups['blarg2'].first.furnish_group_name, 'name is set properly')
 
     assert_raises(
       RuntimeError,
@@ -30,4 +28,59 @@ class TestSchedulerBasic < Furnish::SchedulerTestCase
     assert_includes(sched.vm.waiters.keys, 'blarg4', 'included in waiters list')
     assert_includes(sched.vm.dependencies['blarg4'], 'blarg2', 'dependencies are tracked for provision')
   end
+
+  def test_protocol
+    # NOTE these classes are in test/dummy_classes.rb
+    assert(sched.schedule_provision('blarg', [YieldsIntegerBarDummy.new, AcceptsIntegerBarDummy.new]))
+    assert(sched.schedule_provision('blarg1', [YieldsIntegerBarDummy.new, RequiresBarDummy.new]))
+    assert(sched.schedule_provision('blarg2', [YieldsStringBarDummy.new, AcceptsStringBarDummy.new]))
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg3', [YieldsStringBarDummy.new, RequiresBarDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg4', [YieldsStringBarDummy.new, AcceptsIntegerBarDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg5', [YieldsFooDummy.new, AcceptsIntegerBarDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg6', [YieldsFooDummy.new, RequiresBarDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg7', [YieldsIntegerBarDummy.new, AcceptsFooDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg8', [YieldsStringBarDummy.new, AcceptsFooDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg9', [YieldsIntegerBarDummy.new, RequiresBarAcceptsFooDummy.new]) }
+    assert(sched.schedule_provision('blarg10', [YieldsFooBarDummy.new, RequiresBarAcceptsFooDummy.new]))
+    assert(sched.schedule_provision('blarg11', [YieldsFooBarDummy.new, AcceptsFooDummy.new]))
+    assert(sched.schedule_provision('blarg12', [YieldsFooBarDummy.new, AcceptsIntegerBarDummy.new]))
+    assert(sched.schedule_provision('blarg13', [YieldsFooDummy.new, AcceptsFooDummy.new]))
+    assert(sched.schedule_provision('blarg14', [YieldsFooBarDummy.new, RequiresBarDummy.new]))
+    assert(sched.schedule_provision('blarg15', [YieldsIntegerBarDummy.new, YieldsFooDummy.new, RequiresBarAcceptsFooDummy.new]))
+
+    assert(sched.schedule_provision('blarg-shutdown', [ShutdownAcceptsIntegerBarDummy.new, ShutdownYieldsIntegerBarDummy.new]))
+    assert(sched.schedule_provision('blarg1-shutdown', [ShutdownRequiresBarDummy.new, ShutdownYieldsIntegerBarDummy.new]))
+    assert(sched.schedule_provision('blarg2-shutdown', [ShutdownAcceptsStringBarDummy.new, ShutdownYieldsStringBarDummy.new]))
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg3-shutdown', [ShutdownRequiresBarDummy.new, ShutdownYieldsStringBarDummy.new] ) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg4-shutdown', [ShutdownAcceptsIntegerBarDummy.new, ShutdownYieldsStringBarDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg5-shutdown', [ShutdownAcceptsIntegerBarDummy.new, ShutdownYieldsFooDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg6-shutdown', [ShutdownRequiresBarDummy.new, ShutdownYieldsFooDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg7-shutdown', [ShutdownAcceptsFooDummy.new, ShutdownYieldsIntegerBarDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg8-shutdown', [ShutdownAcceptsFooDummy.new, ShutdownYieldsStringBarDummy.new]) }
+    assert_raises(ArgumentError) { sched.schedule_provision('blarg9-shutdown', [ShutdownRequiresBarAcceptsFooDummy.new, ShutdownYieldsIntegerBarDummy.new]) }
+    assert(sched.schedule_provision('blarg10-shutdown', [ShutdownRequiresBarAcceptsFooDummy.new, ShutdownYieldsFooBarDummy.new]))
+    assert(sched.schedule_provision('blarg11-shutdown', [ShutdownAcceptsFooDummy.new, ShutdownYieldsFooBarDummy.new]))
+    assert(sched.schedule_provision('blarg12-shutdown', [ShutdownAcceptsIntegerBarDummy.new, ShutdownYieldsFooBarDummy.new]))
+    assert(sched.schedule_provision('blarg13-shutdown', [ShutdownAcceptsFooDummy.new, ShutdownYieldsFooDummy.new]))
+    assert(sched.schedule_provision('blarg14-shutdown', [ShutdownRequiresBarDummy.new, ShutdownYieldsFooBarDummy.new]))
+    assert(sched.schedule_provision('blarg15-shutdown', [ShutdownRequiresBarAcceptsFooDummy.new, ShutdownYieldsFooDummy.new, ShutdownYieldsIntegerBarDummy.new]))
+  end
+
+  def test_cascade_protocol
+    assert(sched.schedule_provision('blarg-cascade1', [ReturnsInfoDummy.new, Dummy.new, Dummy.new]))
+    assert(sched.schedule_provision('blarg-cascade2', [Dummy.new, Dummy.new, ReturnsInfoDummy.new]))
+    sched.run
+    assert(sched.serial || sched.running?)
+    sched.wait_for('blarg-cascade1', 'blarg-cascade2')
+    assert_solved('blarg-cascade1')
+    assert_solved('blarg-cascade2')
+    cascade1 = sched.vm.groups['blarg-cascade1']
+    cascade2 = sched.vm.groups['blarg-cascade2']
+    assert_equal({ :startup_blah => [1] }, cascade1.last.run_state[:startup])
+    assert_equal({ :startup_blah => [1] }, cascade2.last.run_state[:startup])
+    sched.teardown
+
+    assert_equal({ :shutdown_blah => [1] }, cascade1.first.run_state[:shutdown])
+    assert_equal({ :shutdown_blah => [1] }, cascade2.first.run_state[:shutdown])
+  end
 end

data/test/test_scheduler_threaded.rb

@@ -1,19 +1,6 @@
 require 'helper'
 
-class SleepyDummy < Dummy
-  def startup(*args)
-    sleep 1
-    super
-  end
-end
-
-class SleepyFailingDummy < SleepyDummy
-  def startup(*args)
-    super
-    return false
-  end
-end
-
+# NOTE the dummy classes in this file are defined in test/dummy_classes.rb
 class TestSchedulerThreaded < Furnish::RestartingSchedulerTestCase
   def setup
     super
@@ -32,12 +19,13 @@ class TestSchedulerThreaded < Furnish::RestartingSchedulerTestCase
     #
     # this actually tests that functionality, so kill the monitor prematurely.
     #
-    @monitor.kill rescue nil
     assert(sched.schedule_provision('blarg', SleepyFailingDummy.new))
     sched.run
     assert(sched.running?, 'running after provision')
-    sleep 3
-    assert_raises(RuntimeError, "Could not provision blarg with provisioner SleepyFailingDummy") { sched.running? }
+    sleep 4
+    assert(sched.running?, 'still running after failure')
+    assert_kind_of(RuntimeError, sched.needs_recovery['blarg'])
+    assert_equal("Could not provision blarg[SleepyFailingDummy]", sched.needs_recovery['blarg'].message)
     sched.teardown
     refute(sched.running?, 'not running after teardown')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: furnish
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-25 00:00:00.000000000 Z
+date: 2013-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: palsy
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.0.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,17 +80,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.8
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.8
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -156,17 +156,22 @@ files:
 - furnish.gemspec
 - lib/furnish.rb
 - lib/furnish/logger.rb
+- lib/furnish/protocol.rb
 - lib/furnish/provisioner.rb
 - lib/furnish/provisioner_group.rb
+- lib/furnish/provisioners/api.rb
 - lib/furnish/provisioners/dummy.rb
 - lib/furnish/scheduler.rb
 - lib/furnish/test.rb
 - lib/furnish/version.rb
 - lib/furnish/vm.rb
+- test/dummy_classes.rb
 - test/helper.rb
 - test/mt_cases.rb
+- test/test_api.rb
 - test/test_dummy.rb
 - test/test_logger.rb
+- test/test_protocol.rb
 - test/test_provisioner_group.rb
 - test/test_scheduler_basic.rb
 - test/test_scheduler_serial.rb
@@ -183,10 +188,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 2505276676287387659
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -195,7 +197,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2505276676287387659
+      hash: 4039116121410524587
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -203,10 +205,13 @@ signing_key:
 specification_version: 3
 summary: A novel way to do virtual machine provisioning
 test_files:
+- test/dummy_classes.rb
 - test/helper.rb
 - test/mt_cases.rb
+- test/test_api.rb
 - test/test_dummy.rb
 - test/test_logger.rb
+- test/test_protocol.rb
 - test/test_provisioner_group.rb
 - test/test_scheduler_basic.rb
 - test/test_scheduler_serial.rb