furnish 0.0.4 → 0.1.0

data/test/mt_cases.rb

@@ -1,37 +1,8 @@
-require 'furnish/provisioners/dummy'
+require 'dummy_classes'
 require 'furnish/test'
 
-Dummy = Furnish::Provisioner::Dummy unless defined? Dummy
-
-class StartFailDummy < Dummy
-  def startup(*args)
-    super
-    false
-  end
-end
-
-class StopFailDummy < Dummy
-  def shutdown
-    super
-    false
-  end
-end
-
-class StartExceptionDummy < Dummy
-  def startup(*args)
-    super
-    raise "ermagherd startup"
-  end
-end
-
-class StopExceptionDummy < Dummy
-  def shutdown(*args)
-    super
-    raise "ermagherd shutdown"
-  end
-end
-
 module Furnish
+  # These tests are run for both threaded and serial cases.
   class RestartingSchedulerTestCase < SchedulerTestCase
     def teardown
       sched.stop
@@ -49,6 +20,91 @@ module Furnish
       assert(provisioner.store[ [name, "shutdown"].join("-") ], "dummy provisioner for #{name} recorded the shutdown run")
     end
 
+    def test_recovery_mode
+      [RecoverableDummy, RaisingRecoverableDummy].each do |prov|
+        test1 = "#{prov}-test1"
+        test2 = "#{prov}-test2"
+        test3 = "#{prov}-test3"
+
+        sched.s(test1, Dummy.new)
+        sched.s(test2, prov.new)
+        sched.run rescue nil # FIXME oof. maybe move this to indepedent tests for serial mode?
+        assert(sched.serial || sched.running?)
+        unless sched.serial
+          sleep 0.1 while !sched.needs_recovery.has_key?(test2)
+        end
+        assert(sched.needs_recovery?)
+        assert_includes(sched.needs_recovery.keys, test2)
+        refute_solved(test2)
+        sched.s(test3, Dummy.new, [test2])
+        refute_solved(test3)
+        assert(sched.serial || sched.running?)
+        assert_empty(sched.recover)
+        assert(sched.serial || sched.running?)
+        if sched.serial
+          sched.run rescue nil
+        end
+        sched.wait_for(test1, test2, test3)
+        assert_started(test2)
+        assert_started(test3)
+        assert_started(test1)
+        sched.teardown
+        sched.stop
+
+        test4 = "#{prov}-test4"
+        test5 = "#{prov}-test5"
+
+        [test1, test2, test3, test4, test5].each { |x| x.replace(x + "-permfail") }
+
+        sched.s(test1, Dummy.new)
+        sched.s(test2, prov.new)
+        sched.s(test3, Dummy.new, [test2])
+        sched.s(test4, FailedRecoverDummy.new)
+        sched.s(test5, Dummy.new, [test4])
+        sched.run rescue nil
+        if sched.serial
+          assert(sched.needs_recovery?)
+        end
+        sched.run rescue nil
+        assert(sched.serial || sched.running?)
+        unless sched.serial
+          sleep 0.1 while !sched.needs_recovery.has_key?(test2)
+          sleep 0.1 while !sched.needs_recovery.has_key?(test4)
+        end
+        assert(sched.needs_recovery?)
+        refute_solved(test2)
+        refute_solved(test3)
+        refute_solved(test4)
+        assert(sched.serial || sched.running?)
+        assert_equal({ test4 => false }, sched.recover)
+        assert(sched.serial || sched.running?)
+        if sched.serial
+          sched.run rescue nil
+        end
+        sched.wait_for(test1, test2, test3)
+        assert_started(test2)
+        assert_started(test3)
+        assert_started(test1)
+        refute_solved(test4)
+        refute_solved(test5)
+        sched.force_deprovision = true
+        sched.deprovision_group(test4)
+        sched.force_deprovision = false
+        refute_includes(sched.needs_recovery.keys, test4)
+        refute(sched.needs_recovery?)
+        sched.s(test4, Dummy.new)
+        if sched.serial
+          sched.run
+        end
+        assert(sched.serial || sched.running?)
+        sched.wait_for(test4, test5)
+        assert_solved(test4) # we tore it down, so assert_started will break here.
+        assert_started(test5)
+        sched.teardown
+        sched.stop
+      end
+    end
+
     def test_run_tracking
       #--
       # This is a tad convoluted. Dummy's startup method sets an ivar which
@@ -66,14 +122,12 @@ module Furnish
       assert_equal("floop", sched.vm.groups['test1'].first.report.last, 'state was stored after provision success')
 
       assert(sched.schedule_provision('test2', [Dummy.new, StartFailDummy.new], []))
-
-      # the next few lines are an unfortunate necessity, sorry.
-      @monitor.kill rescue nil
-      assert_raises(RuntimeError) do
-        sched.run
-        sleep 0.1 while sched.running?
+      sched.run rescue nil # FIXME oof. maybe move this to indepedent tests for serial mode?
+      unless sched.serial
+        sleep 0.1 while !sched.needs_recovery.has_key?('test2')
       end
-
+      assert(sched.serial || sched.running?)
+      assert_includes(sched.needs_recovery.keys, 'test2')
       assert_equal("floop", sched.vm.groups['test2'].first.report.last, "provision failed but state is still stored for the provisions that succeeded")
     end
 
@@ -198,23 +252,25 @@ module Furnish
           tempfiles.push(tf)
           Furnish.logger = Furnish::Logger.new(tf)
 
-          sched.run(false)
+          sched.signal_handler = false
+          sched.run
           Process.kill(signal, Process.pid)
 
           sched.stop
           sleep 0.1 # wait for any writes to complete
 
-          %w[solved working waiting].each do |section|
+          %w[solved working waiting provisioning].each do |section|
             refute_match(/#{section}/, File.read(tf.path), "#{signal} yielded no output with the #{section} set")
           end
 
-          sched.run(true)
+          sched.signal_handler = true
+          sched.run
           Process.kill(signal, Process.pid)
 
           sched.stop
           sleep 0.1 # wait for any writes to complete
 
-          %w[solved working waiting].each do |section|
+          %w[solved working waiting provisioning].each do |section|
             assert_match(/#{section}/, File.read(tf.path), "#{signal} yielded output with the #{section} set")
           end
         end
@@ -226,10 +282,12 @@ module Furnish
     def test_provision_failures
       dummy = StartFailDummy.new
       assert(sched.schedule_provision('blarg', dummy))
-      assert_raises(RuntimeError, "Could not provision blarg with provisioner StartFailDummy") do
-        sched.run
-        sched.wait_for('blarg')
+      sched.run rescue nil # FIXME oof. maybe move this to indepedent tests for serial mode?
+      if !sched.serial
+        sleep 0.1 while !sched.needs_recovery.has_key?('blarg')
       end
+      assert(sched.serial || sched.running?, 'still running after failure')
+      assert_includes(sched.needs_recovery, 'blarg')
       sched.stop
       sched.deprovision_group('blarg')
 

data/test/test_api.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+class TestAPI < Furnish::TestCase
+  def setup
+    super
+    # NOTE this class is defined in test/dummy_classes.rb
+    @klass = APIDummy
+  end
+
+  def test_constructor
+    assert_raises(ArgumentError, "Arguments must be a kind of hash") { @klass.new(nil) }
+    obj = @klass.new(:foo => 1)
+    assert_equal(1, obj.foo, "attrs are set based on contents of constructor")
+    assert_raises(ArgumentError) { @klass.new(:quux => 2) }
+    assert_raises(ArgumentError) { @klass.new(:bar => 2) }
+    assert_raises(ArgumentError) { @klass.new(:foo => "string") }
+  end
+
+  def test_interface
+    assert_respond_to(@klass, :furnish_properties)
+    assert_respond_to(@klass, :furnish_property)
+
+    assert_kind_of(Hash, @klass.furnish_properties)
+    assert_includes(@klass.furnish_properties, :foo)
+    assert_includes(@klass.furnish_properties, :a_string)
+    refute_includes(@klass.furnish_properties, :bar)
+    assert_kind_of(Hash, @klass.furnish_properties[:foo])
+    assert_equal("does things with foo", @klass.furnish_properties[:foo][:description])
+    assert_equal(Integer, @klass.furnish_properties[:foo][:type])
+
+    obj = @klass.new(:foo => 1)
+
+    assert_respond_to(obj, :furnish_group_name)
+    assert_respond_to(obj, :furnish_group_name=)
+
+    %w[startup shutdown].each do |meth|
+      assert_raises(NotImplementedError, "#{meth} method not implemented for #{@klass.name}") { obj.send(meth) }
+    end
+  end
+
+  def test_report
+    obj = @klass.new(:foo => 1)
+    assert_equal(["unknown"], obj.report, "default report uses 'unknown' as the group name")
+    obj.furnish_group_name = "frobnik"
+    assert_equal(["frobnik"], obj.report, "when furnish_group_name is set, uses that in the report")
+  end
+
+  def test_to_s
+    obj = @klass.new(:foo => 1)
+    assert_equal("unknown[#{@klass.name}]", obj.to_s, "formatted properly without a furnish group name")
+    obj.furnish_group_name = "frobnik"
+    assert_equal("frobnik[#{@klass.name}]", obj.to_s, "formatted properly without a furnish group name")
+  end
+
+  def test_equality
+    assert_equal(Dummy.new, Dummy.new)
+    assert_equal(APIDummy.new(:foo => 1), APIDummy.new(:foo => 1))
+    refute_equal(APIDummy.new(:foo => 2), APIDummy.new(:foo => 1))
+    refute_equal(Dummy.new, StopFailDummy.new)
+  end
+
+  def test_recovery
+    prov = APIDummy.new
+    refute(prov.recover(:startup, nil))
+    prov = BrokenRecoverAPIDummy.new
+    assert_raises(NotImplementedError) { prov.recover(:startup, nil) }
+  end
+end

data/test/test_dummy.rb

@@ -14,7 +14,7 @@ require 'helper'
 class TestDummy < Furnish::TestCase
   def test_defaults
     dummy = Dummy.new
-    dummy.name = 'dummy_test'
+    dummy.furnish_group_name = 'dummy_test'
     assert(dummy.startup, 'startup returns true by default')
     assert(dummy.shutdown, 'shutdown returns true by default')
     assert_equal(['dummy_test', 'floop'], dummy.report, 'report returns boxed name and ivar by default')
@@ -29,7 +29,7 @@ class TestDummy < Furnish::TestCase
     machine_names = %w[one two three]
     machine_names.each do |name|
       dummy = Dummy.new
-      dummy.name = name
+      dummy.furnish_group_name = name
       assert(dummy.startup)
     end
 
@@ -42,7 +42,7 @@ class TestDummy < Furnish::TestCase
 
     machine_names.each do |name|
       dummy = Dummy.new
-      dummy.name = name
+      dummy.furnish_group_name = name
       assert(dummy.shutdown)
     end
 
@@ -54,7 +54,7 @@ class TestDummy < Furnish::TestCase
   def test_call_order
     dummies = Dummy.new, Dummy.new
     dummies.each_with_index do |x, i|
-      x.name = "foo"
+      x.furnish_group_name = "foo"
       x.id = "foo#{i}"
       assert(x.startup)
     end
@@ -72,10 +72,10 @@ class TestDummy < Furnish::TestCase
 
   def test_marshal
     dummy = Dummy.new
-    dummy.name = "dummy_marshal_test"
+    dummy.furnish_group_name = "dummy_marshal_test"
     assert(dummy.startup)
     assert(dummy.shutdown)
-    assert_equal([dummy.name, 'floop'], dummy.report)
+    assert_equal([dummy.furnish_group_name, 'floop'], dummy.report)
 
     obj = Palsy::Object.new('dummy')
     %w[startup shutdown report].each do |meth|

data/test/test_protocol.rb

@@ -0,0 +1,211 @@
+require 'helper'
+
+class TestProtocol < Furnish::TestCase
+  #--
+  # see the Furnish::Protocol docs for truth tables and whatnot
+  #++
+
+  def test_setters
+    proto = Furnish::Protocol.new
+    assert_equal([:requires, :accepts, :yields], Furnish::Protocol::VALIDATOR_NAMES)
+
+    Furnish::Protocol::VALIDATOR_NAMES.each do |vname|
+      proto.send(vname, :foo, "a description", Integer)
+      assert_includes(proto[vname], :foo)
+      assert_equal({ :description => "a description", :type => Integer }, proto[vname][:foo])
+      proto.send(vname, "bar")
+      assert_includes(proto[vname], :bar)
+      assert_equal({ :description => "", :type => Object }, proto[vname][:bar])
+    end
+
+    refute(proto[:accepts_from_any])
+    proto.accepts_from_any(true)
+    assert(proto[:accepts_from_any])
+  end
+
+  def test_configure
+    proto = Furnish::Protocol.new
+    proto.configure do
+      requires :foo, "a description", Integer
+      accepts "bar"
+      yields :quux, "another description", Hash
+    end
+
+    assert_includes(proto[:requires], :foo)
+    assert_includes(proto[:accepts], :bar)
+    assert_includes(proto[:yields], :quux)
+
+    assert_equal(
+      { :description => "a description", :type => Integer },
+      proto[:requires][:foo]
+    )
+
+    assert_equal(
+      { :description => "", :type => Object },
+      proto[:accepts][:bar]
+    )
+
+    assert_equal(
+      { :description => "another description", :type => Hash },
+      proto[:yields][:quux]
+    )
+
+    proto = Furnish::Protocol.new
+
+    assert_raises(RuntimeError) do
+      proto.configure do
+        accepts_from(Furnish::Protocol.new)
+      end
+    end
+
+    proto = Furnish::Protocol.new
+
+    assert_raises(RuntimeError) do
+      proto.configure do
+        requires_from(Furnish::Protocol.new)
+      end
+    end
+  end
+
+  def test_requires_from
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    assert(proto2.requires_from(nil))
+
+    proto1.yields(:bar)
+    proto2.requires(:bar)
+
+    assert(proto2.requires_from(proto1))
+
+    proto1 = Furnish::Protocol.new
+    refute(proto2.requires_from(proto1))
+
+    proto1.yields(:bar)
+    proto2 = Furnish::Protocol.new
+
+    assert(proto2.requires_from(proto1))
+
+    proto2.requires(:bar)
+    proto2.requires(:quux)
+
+    refute(proto2.requires_from(proto1))
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", Integer)
+    proto2.requires(:bar, "bar", Integer)
+
+    assert(proto2.requires_from(proto1), 'types match')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", Integer)
+    proto2.requires(:bar, "bar", Fixnum)
+
+    assert(proto2.requires_from(proto1), 'Integer is an ancestor of Fixnum')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", Fixnum)
+    proto2.requires(:bar, "bar", Integer)
+
+    refute(proto2.requires_from(proto1), 'Fixnum is not an ancestor of Integer')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", String)
+    proto2.requires(:bar, "bar", Integer)
+
+    refute(proto2.requires_from(proto1), 'completely different types (String/Integer)')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar")
+    proto2.requires(:bar, "bar", Integer)
+
+    assert(proto2.requires_from(proto1), 'default type is Object, succeeds with other types')
+  end
+
+  def test_accepts_from
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    assert(proto2.accepts_from(nil))
+
+    proto1.yields(:bar)
+    proto2.accepts(:bar)
+
+    assert(proto2.accepts_from(proto1))
+
+    proto1 = Furnish::Protocol.new
+    refute(proto2.accepts_from(proto1))
+
+    proto1.yields(:foo)
+    refute(proto2.accepts_from(proto1))
+
+    proto2.accepts_from_any(true)
+    assert(proto2.accepts_from(proto1))
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+    proto2.accepts(:quux)
+    proto2.accepts(:bar)
+    proto1.yields(:quux)
+
+    assert(proto2.accepts_from(proto1))
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", Integer)
+    proto2.accepts(:bar, "bar", Integer)
+
+    assert(proto2.accepts_from(proto1), 'types match')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", Integer)
+    proto2.accepts(:bar, "bar", Fixnum)
+
+    assert(proto2.accepts_from(proto1), 'Integer is an ancestor of Fixnum')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", Fixnum)
+    proto2.accepts(:bar, "bar", Integer)
+
+    refute(proto2.accepts_from(proto1), 'Fixnum is not an ancestor of Integer')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar", String)
+    proto2.accepts(:bar, "bar", Integer)
+
+    refute(proto2.accepts_from(proto1), 'completely different types (String/Integer)')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:bar, "bar")
+    proto2.accepts(:bar, "bar", Integer)
+
+    assert(proto2.accepts_from(proto1), 'default type is Object, succeeds with other types')
+
+    proto1 = Furnish::Protocol.new
+    proto2 = Furnish::Protocol.new
+
+    proto1.yields(:foo, "foo")
+    proto2.accepts(:bar, "bar", Integer)
+
+    refute(proto2.accepts_from(proto1), "nothing accepted is yielded")
+  end
+end