puppet 0.25.5 → 2.6.0

data/test/ral/providers/port/parsed.rb

@@ -48,7 +48,7 @@ require 'puppettest'
 #            end
 #            @provider.default_target = file
 #
-#            assert_nothing_raised("failed to fetch %s" % file) {
+#            assert_nothing_raised("failed to fetch #{file}") {
 #                @provider.prefetch
 #            }
 #
@@ -60,7 +60,7 @@ require 'puppettest'
 #            assert_equal("53", dns[:number], "dns number is wrong")
 #
 #            text = nil
-#            assert_nothing_raised("failed to generate %s" % file) do
+#            assert_nothing_raised("failed to generate #{file}") do
 #                text = @provider.to_file(@provider.target_records(file))
 #            end
 #
@@ -83,7 +83,7 @@ require 'puppettest'
 #                end
 #            #    assert_equal(old.chomp.gsub(/\s+/, ''),
 #            #        new.gsub(/\s+/, ''),
-#            #        "Lines are not equal in %s" % file)
+#            #        "Lines are not equal in #{file}")
 #            end
 #        end
 #    end
@@ -121,13 +121,13 @@ require 'puppettest'
 #                    hash.each do |param, value|
 #                        if value
 #                            assert_equal(value, record[param],
-#                                "did not get %s out of '%s'" % [param, line])
+#                                "did not get #{param} out of '#{line}'")
 #                        end
 #                    end
 #
 #                    # Now make sure it generates correctly
 #                    assert_equal(line, @provider.to_line(record),
-#                        "Did not generate %s correctly" % line)
+#                        "Did not generate #{line} correctly")
 #                end
 #            end
 #        end

data/test/ral/providers/provider.rb

@@ -6,524 +6,524 @@ require 'puppettest'
 require 'facter'
 
 class TestProvider < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def echo
-        echo = Puppet::Util.binary("echo")
+  def echo
+    echo = Puppet::Util.binary("echo")
 
-        unless echo
-            raise "Could not find 'echo' binary; cannot complete test"
-        end
+    raise "Could not find 'echo' binary; cannot complete test" unless echo
+
+    echo
+  end
 
-        return echo
+  def newprovider
+    # Create our provider
+    provider = Class.new(Puppet::Provider) do
+      @name = :fakeprovider
     end
+    provider.initvars
 
-    def newprovider
-        # Create our provider
-        provider = Class.new(Puppet::Provider) do
-            @name = :fakeprovider
-        end
-        provider.initvars
+    provider
+  end
 
-        return provider
+  def setup
+    super
+    @type = Puppet::Type.newtype(:provider_test) do
+      newparam(:name) {}
+      ensurable
     end
-
-    def setup
-        super
-        @type = Puppet::Type.newtype(:provider_test) do
-            newparam(:name) {}
-            ensurable
+    cleanup { Puppet::Type.rmtype(:provider_test) }
+  end
+
+  def test_confine_defaults_to_suitable
+
+    provider = newprovider
+    assert(provider.suitable?, "Marked unsuitable with no confines")
+  end
+
+  def test_confine_results
+    {
+      {:true => true} => true,
+      {:true => false} => false,
+      {:false => false} => true,
+      {:false => true} => false,
+      {:operatingsystem => Facter.value(:operatingsystem)} => true,
+      {:operatingsystem => :yayness} => false,
+      {:nothing => :yayness} => false,
+      {:exists => echo} => true,
+      {:exists => "/this/file/does/not/exist"} => false,
+    }.each do |hash, result|
+      provider = newprovider
+
+      # First test :true
+      hash.each do |test, val|
+        assert_nothing_raised do
+          provider.confine test => val
         end
-        cleanup { Puppet::Type.rmtype(:provider_test) }
-    end
+      end
 
-    def test_confine_defaults_to_suitable
+      assert_equal(result, provider.suitable?, "Failed for #{hash.inspect}")
 
-        provider = newprovider
-        assert(provider.suitable?, "Marked unsuitable with no confines")
+      provider.initvars
     end
-
-    def test_confine_results
-        {
-            {:true => true} => true,
-            {:true => false} => false,
-            {:false => false} => true,
-            {:false => true} => false,
-            {:operatingsystem => Facter.value(:operatingsystem)} => true,
-            {:operatingsystem => :yayness} => false,
-            {:nothing => :yayness} => false,
-            {:exists => echo} => true,
-            {:exists => "/this/file/does/not/exist"} => false,
-        }.each do |hash, result|
-            provider = newprovider
-
-            # First test :true
-            hash.each do |test, val|
-                assert_nothing_raised do
-                    provider.confine test => val
-                end
-            end
-
-            assert_equal(result, provider.suitable?, "Failed for %s" % [hash.inspect])
-
-            provider.initvars
+  end
+
+  def test_multiple_confines_do_not_override
+    provider = newprovider
+
+    # Make sure multiple confines don't overwrite each other
+    provider.confine :true => false
+    assert(! provider.suitable?)
+    provider.confine :true => true
+    assert(! provider.suitable?)
+  end
+
+  def test_one_failed_confine_is_sufficient
+
+    provider = newprovider
+
+    # Make sure we test multiple of them, and that a single false wins
+    provider.confine :true => true, :false => false
+    assert(provider.suitable?)
+    provider.confine :true => false
+    assert(! provider.suitable?)
+  end
+
+  # #1197 - the binary should not be
+  def test_command_checks_for_binaries_each_time
+    provider = newprovider
+
+    provider.commands :testing => "/no/such/path"
+
+    provider.stubs(:binary).returns "/no/such/path"
+
+    provider.command(:testing)
+    assert_equal("/no/such/path", provider.command(:testing), "Did not return correct binary path")
+  end
+
+  def test_command
+    {:echo => "echo", :echo_with_path => echo, :missing => "nosuchcommand", :missing_qualified => "/path/to/nosuchcommand"}.each do |name, command|
+      provider = newprovider
+      assert_nothing_raised("Could not define command #{name} with argument #{command} for provider") do
+        provider.commands(name => command)
+      end
+
+      if name.to_s =~ /missing/
+        assert_nil(provider.command(name), "Somehow got a response for missing commands")
+        assert(! provider.suitable?, "Provider was considered suitable with missing command")
+        next # skip, since we don't do any validity checking here.
+      end
+
+      assert_equal(echo, provider.command(name), "Did not get correct path for echo")
+      assert(provider.suitable?, "Provider was not considered suitable with 'echo'")
+
+      # Now make sure they both work
+      inst = provider.new(nil)
+      [provider, inst].each do |thing|
+        assert_nothing_raised("Could not call #{command} on #{thing}") do
+          out = thing.send(name, "some", "text")
+          assert_equal("some text\n", out)
         end
-    end
+      end
 
-    def test_multiple_confines_do_not_override
-        provider = newprovider
+      assert(provider.suitable?, "Provider considered unsuitable")
 
-        # Make sure multiple confines don't overwrite each other
-        provider.confine :true => false
-        assert(! provider.suitable?)
-        provider.confine :true => true
-        assert(! provider.suitable?)
-    end
+      # Now add an invalid command
+      assert_nothing_raised do
+        provider.commands :fake => "nosuchcommanddefinitely"
+      end
+      assert(! provider.suitable?, "Provider considered suitable")
 
-    def test_one_failed_confine_is_sufficient
+      assert_nil(provider.command(:fake), "Got a value for missing command")
+      assert_raise(Puppet::Error) do
+        provider.fake
+      end
 
-        provider = newprovider
+      Puppet[:trace] = false
+      assert_raise(Puppet::DevError) do
+        provider.command(:nosuchcmd)
+      end
 
-        # Make sure we test multiple of them, and that a single false wins
-        provider.confine :true => true, :false => false
-        assert(provider.suitable?)
-        provider.confine :true => false
-        assert(! provider.suitable?)
-    end
+      # Lastly, verify that we can find our superclass commands
+      newprov = Class.new(provider)
+      newprov.initvars
 
-    # #1197 - the binary should not be
-    def test_command_checks_for_binaries_each_time
-        provider = newprovider
+      assert_equal(echo, newprov.command(name))
+    end
+  end
 
-        provider.commands :testing => "/no/such/path"
+  def test_default?
+    provider = newprovider
 
-        provider.stubs(:binary).returns "/no/such/path"
+    assert(! provider.default?, "Was considered default with no settings")
 
-        provider.command(:testing)
-        assert_equal("/no/such/path", provider.command(:testing), "Did not return correct binary path")
+    assert_nothing_raised do
+      provider.defaultfor :operatingsystem => Facter.value(:operatingsystem)
     end
 
-    def test_command
-        {:echo => "echo", :echo_with_path => echo, :missing => "nosuchcommand", :missing_qualified => "/path/to/nosuchcommand"}.each do |name, command|
-            provider = newprovider
-            assert_nothing_raised("Could not define command %s with argument %s for provider" % [name, command]) do
-                provider.commands(name => command)
-            end
-
-            if name.to_s =~ /missing/
-                assert_nil(provider.command(name), "Somehow got a response for missing commands")
-                assert(! provider.suitable?, "Provider was considered suitable with missing command")
-                next # skip, since we don't do any validity checking here.
-            end
-
-            assert_equal(echo, provider.command(name), "Did not get correct path for echo")
-            assert(provider.suitable?, "Provider was not considered suitable with 'echo'")
-
-            # Now make sure they both work
-            inst = provider.new(nil)
-            [provider, inst].each do |thing|
-                assert_nothing_raised("Could not call %s on %s" % [command, thing]) do
-                    out = thing.send(name, "some", "text")
-                    assert_equal("some text\n", out)
-                end
-            end
-
-            assert(provider.suitable?, "Provider considered unsuitable")
-
-            # Now add an invalid command
-            assert_nothing_raised do
-                provider.commands :fake => "nosuchcommanddefinitely"
-            end
-            assert(! provider.suitable?, "Provider considered suitable")
-
-            assert_nil(provider.command(:fake), "Got a value for missing command")
-            assert_raise(Puppet::Error) do
-                provider.fake
-            end
-
-            Puppet[:trace] = false
-            assert_raise(Puppet::DevError) do
-                provider.command(:nosuchcmd)
-            end
-
-            # Lastly, verify that we can find our superclass commands
-            newprov = Class.new(provider)
-            newprov.initvars
-
-            assert_equal(echo, newprov.command(name))
-        end
+    assert(provider.default?, "Was not considered default")
+
+    # Make sure any true value is sufficient.
+    assert_nothing_raised do
+      provider.defaultfor :operatingsystem => [
+        :yayness, :rahness,
+        Facter.value(:operatingsystem)
+      ]
     end
 
-    def test_default?
-        provider = newprovider
+    assert(provider.default?, "Was not considered default")
 
-        assert(! provider.default?, "Was considered default with no settings")
+    # Now make sure that a random setting returns false.
+    assert_nothing_raised do
+      provider.defaultfor :operatingsystem => :yayness
+    end
 
-        assert_nothing_raised do
-            provider.defaultfor :operatingsystem => Facter.value(:operatingsystem)
-        end
+    assert(! provider.default?, "Was considered default")
+  end
 
-        assert(provider.default?, "Was not considered default")
+  # Make sure that failed commands get their output in the error.
+  def test_outputonfailure
+    provider = newprovider
 
-        # Make sure any true value is sufficient.
-        assert_nothing_raised do
-            provider.defaultfor :operatingsystem => [
-                :yayness, :rahness,
-                Facter.value(:operatingsystem)
-            ]
-        end
+    dir = tstdir
+    file = File.join(dir, "mycmd")
+    sh = Puppet::Util.binary("sh")
+    File.open(file, "w") { |f|
+      f.puts %{#!#{sh}
+      echo A Failure >&2
+      exit 2
+      }
+    }
+    File.chmod(0755, file)
 
-        assert(provider.default?, "Was not considered default")
+    provider.commands :cmd => file
 
-        # Now make sure that a random setting returns false.
-        assert_nothing_raised do
-            provider.defaultfor :operatingsystem => :yayness
-        end
+    inst = provider.new(nil)
 
-        assert(! provider.default?, "Was considered default")
+    assert_raise(Puppet::ExecutionFailure) do
+      inst.cmd "some", "arguments"
     end
 
-    # Make sure that failed commands get their output in the error.
-    def test_outputonfailure
-        provider = newprovider
+    out = nil
+    begin
+      inst.cmd "some", "arguments"
+    rescue Puppet::ExecutionFailure => detail
+      out = detail.to_s
+    end
 
-        dir = tstdir()
-        file = File.join(dir, "mycmd")
-        sh = Puppet::Util.binary("sh")
-        File.open(file, "w") { |f|
-            f.puts %{#!#{sh}
-            echo A Failure >&2
-            exit 2
-            }
-        }
-        File.chmod(0755, file)
 
-        provider.commands :cmd => file
+      assert(
+        out =~ /A Failure/,
 
-        inst = provider.new(nil)
+        "Did not receive command output on failure")
 
-        assert_raise(Puppet::ExecutionFailure) do
-            inst.cmd "some", "arguments"
-        end
 
-        out = nil
-        begin
-            inst.cmd "some", "arguments"
-        rescue Puppet::ExecutionFailure => detail
-            out = detail.to_s
-        end
+          assert(
+            out =~ /Execution of/,
+
+        "Did not receive info wrapper on failure")
+  end
 
-        assert(out =~ /A Failure/,
-               "Did not receive command output on failure")
+  def test_mk_resource_methods
+    prov = newprovider
+    resourcetype = Struct.new(:validproperties, :parameters)
+    m = resourcetype.new([:prop1, :prop2], [:param1, :param2])
+    prov.resource_type = m
 
-        assert(out =~ /Execution of/,
-               "Did not receive info wrapper on failure")
+    assert_nothing_raised("could not call mk_resource_methods") do
+      prov.mk_resource_methods
     end
 
-    def test_mk_resource_methods
-        prov = newprovider
-        resourcetype = Struct.new(:validproperties, :parameters)
-        m = resourcetype.new([:prop1, :prop2], [:param1, :param2])
-        prov.resource_type = m
+    obj = prov.new(nil)
 
-        assert_nothing_raised("could not call mk_resource_methods") do
-            prov.mk_resource_methods
-        end
+    %w{prop1 prop2 param1 param2}.each do |param|
+      assert(prov.public_method_defined?(param), "no getter for #{param}")
+      assert(prov.public_method_defined?(param + "="), "no setter for #{param}")
 
-        obj = prov.new(nil)
 
-        %w{prop1 prop2 param1 param2}.each do |param|
-            assert(prov.public_method_defined?(param), "no getter for %s" % param)
-            assert(prov.public_method_defined?(param + "="), "no setter for %s" % param)
+        assert_equal(
+          :absent, obj.send(param),
 
-            assert_equal(:absent, obj.send(param),
-                "%s did not default to :absent")
-            val = "testing %s" % param
-            assert_nothing_raised("Could not call setter for %s" % param) do
-                obj.send(param + "=", val)
-            end
-            assert_equal(val, obj.send(param),
-                "did not get correct value for %s" % param)
-        end
+          "%s did not default to :absent")
+      val = "testing #{param}"
+      assert_nothing_raised("Could not call setter for #{param}") do
+        obj.send(param + "=", val)
+      end
+
+        assert_equal(
+          val, obj.send(param),
+
+          "did not get correct value for #{param}")
     end
+  end
 
-    # Make sure optional commands get looked up but don't affect suitability.
-    def test_optional_commands
-        type = Puppet::Type.newtype(:optional_commands) {}
+  # Make sure optional commands get looked up but don't affect suitability.
+  def test_optional_commands
+    type = Puppet::Type.newtype(:optional_commands) {}
 
-        cleanup { Puppet::Type.rmtype(:optional_commands) }
+    cleanup { Puppet::Type.rmtype(:optional_commands) }
 
-        # Define a provider with mandatory commands
-        required = type.provide(:required) {
-            commands :missing => "/no/such/binary/definitely"
-        }
+    # Define a provider with mandatory commands
+    required = type.provide(:required) {
+      commands :missing => "/no/such/binary/definitely"
+    }
 
-        # And another with optional commands
-        optional = type.provide(:optional) {
-            optional_commands :missing => "/no/such/binary/definitely"
-        }
+    # And another with optional commands
+    optional = type.provide(:optional) {
+      optional_commands :missing => "/no/such/binary/definitely"
+    }
 
-        assert(! required.suitable?, "Provider with missing commands considered suitable")
-        assert_nil(required.command(:missing), "Provider returned non-nil from missing command")
+    assert(! required.suitable?, "Provider with missing commands considered suitable")
+    assert_nil(required.command(:missing), "Provider returned non-nil from missing command")
 
-        assert(optional.suitable?, "Provider with optional commands considered unsuitable")
-        assert_nil(optional.command(:missing), "Provider returned non-nil from missing command")
+    assert(optional.suitable?, "Provider with optional commands considered unsuitable")
+    assert_nil(optional.command(:missing), "Provider returned non-nil from missing command")
 
-        assert_raise(Puppet::Error, "Provider did not fail when missing command was called") do
-            optional.missing
-        end
+    assert_raise(Puppet::Error, "Provider did not fail when missing command was called") do
+      optional.missing
     end
+  end
 
-    # Disabling, since I might not keep this interface
-    def disabled_test_read_and_each
-        # Create a new provider
-        provider = @type.provide(:testing)
+  # Disabling, since I might not keep this interface
+  def disabled_test_read_and_each
+    # Create a new provider
+    provider = @type.provide(:testing)
 
-        assert_raise(Puppet::DevError, "Did not fail when :read was not overridden") do
-            provider.read
-        end
+    assert_raise(Puppet::DevError, "Did not fail when :read was not overridden") do
+      provider.read
+    end
 
-        children = [:one, :two]
-        provider.meta_def(:read) do
-            children
-        end
+    children = [:one, :two]
+    provider.meta_def(:read) do
+      children
+    end
 
-        result = []
-        assert_nothing_raised("could not call 'each' on provider class") do
-            provider.each { |i| result << i }
-        end
+    result = []
+    assert_nothing_raised("could not call 'each' on provider class") do
+      provider.each { |i| result << i }
+    end
 
-        assert_equal(children, result, "did not get correct list from each")
+    assert_equal(children, result, "did not get correct list from each")
 
-        assert_equal(children, provider.collect { |i| i }, "provider does not include enumerable")
-    end
+    assert_equal(children, provider.collect { |i| i }, "provider does not include enumerable")
+  end
 
-    def test_source
-        base = @type.provide(:base)
+  def test_source
+    base = @type.provide(:base)
 
-        assert_equal(:base, base.source, "source did not default correctly")
-        assert_equal(:base, base.source, "source did not default correctly")
+    assert_equal(:base, base.source, "source did not default correctly")
+    assert_equal(:base, base.source, "source did not default correctly")
 
-        sub = @type.provide(:sub, :parent => :base)
+    sub = @type.provide(:sub, :parent => :base)
 
-        assert_equal(:sub, sub.source, "source did not default correctly for sub class")
-        assert_equal(:sub, sub.source, "source did not default correctly for sub class")
+    assert_equal(:sub, sub.source, "source did not default correctly for sub class")
+    assert_equal(:sub, sub.source, "source did not default correctly for sub class")
 
-        other = @type.provide(:other, :parent => :base, :source => :base)
+    other = @type.provide(:other, :parent => :base, :source => :base)
 
-        assert_equal(:base, other.source, "source did not override")
-        assert_equal(:base, other.source, "source did not override")
-    end
+    assert_equal(:base, other.source, "source did not override")
+    assert_equal(:base, other.source, "source did not override")
+  end
 
-    # Make sure we can initialize with either a resource or a hash, or none at all.
-    def test_initialize
-        test = @type.provide(:test)
+  # Make sure we can initialize with either a resource or a hash, or none at all.
+  def test_initialize
+    test = @type.provide(:test)
 
-        inst = @type.new :name => "boo"
-        prov = nil
-        assert_nothing_raised("Could not init with a resource") do
-            prov = test.new(inst)
-        end
-        assert_equal(prov.resource, inst, "did not set resource correctly")
-        assert_equal(inst.name, prov.name, "did not get resource name")
+    inst = @type.new :name => "boo"
+    prov = nil
+    assert_nothing_raised("Could not init with a resource") do
+      prov = test.new(inst)
+    end
+    assert_equal(prov.resource, inst, "did not set resource correctly")
+    assert_equal(inst.name, prov.name, "did not get resource name")
 
-        params = {:name => :one, :ensure => :present}
-        assert_nothing_raised("Could not init with a hash") do
-            prov = test.new(params)
-        end
-        assert_equal(params, prov.send(:instance_variable_get, "@property_hash"), "did not set resource correctly")
-        assert_equal(:one, prov.name, "did not get name from hash")
+    params = {:name => :one, :ensure => :present}
+    assert_nothing_raised("Could not init with a hash") do
+      prov = test.new(params)
+    end
+    assert_equal(params, prov.send(:instance_variable_get, "@property_hash"), "did not set resource correctly")
+    assert_equal(:one, prov.name, "did not get name from hash")
 
-        assert_nothing_raised("Could not init with no argument") do
-            prov = test.new()
-        end
+    assert_nothing_raised("Could not init with no argument") do
+      prov = test.new
+    end
 
-        assert_raise(Puppet::DevError, "did not fail when no name is present") do
-            prov.name
-        end
+    assert_raise(Puppet::DevError, "did not fail when no name is present") do
+      prov.name
     end
+  end
 end
 
 class TestProviderFeatures < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def setup
-        super
-        @type = Puppet::Type.newtype(:feature_test) do
-            newparam(:name) {}
-            ensurable
-        end
-        cleanup { Puppet::Type.rmtype(:feature_test) }
+  def setup
+    super
+    @type = Puppet::Type.newtype(:feature_test) do
+      newparam(:name) {}
+      ensurable
+    end
+    cleanup { Puppet::Type.rmtype(:feature_test) }
 
-        @features = {:numeric => [:one, :two], :alpha => [:a, :b]}
+    @features = {:numeric => [:one, :two], :alpha => [:a, :b]}
 
-        @features.each do |name, methods|
-            assert_nothing_raised("Could not define features") do
-                @type.feature(name, "boo", :methods => methods)
-            end
+    @features.each do |name, methods|
+      assert_nothing_raised("Could not define features") do
+        @type.feature(name, "boo", :methods => methods)
+      end
+    end
+  end
+
+  # Give them the basic run-through.
+  def test_method_features
+    @providers = {:numbers => @features[:numeric], :letters => @features[:alpha]}
+    @providers[:both] = @features[:numeric] + @features[:alpha]
+    @providers[:mixed] = [:one, :b]
+    @providers[:neither] = [:something, :else]
+
+    @providers.each do |name, methods|
+      assert_nothing_raised("Could not create provider #{name}") do
+        @type.provide(name) do
+          methods.each do |name|
+            define_method(name) {}
+          end
         end
+      end
     end
 
-    # Give them the basic run-through.
-    def test_method_features
-        @providers = {:numbers => @features[:numeric], :letters => @features[:alpha]}
-        @providers[:both] = @features[:numeric] + @features[:alpha]
-        @providers[:mixed] = [:one, :b]
-        @providers[:neither] = [:something, :else]
-
-        @providers.each do |name, methods|
-            assert_nothing_raised("Could not create provider %s" % name) do
-                @type.provide(name) do
-                    methods.each do |name|
-                        define_method(name) {}
-                    end
-                end
-            end
+    resource = @type.new(:name => "foo")
+    {:numbers => [:numeric], :letters => [:alpha], :both => [:numeric, :alpha], :mixed => [], :neither => []}.each do |name, should|
+      should.sort! { |a,b| a.to_s <=> b.to_s }
+      provider = @type.provider(name)
+      assert(provider, "Could not find provider #{name}")
+      assert_equal(should, provider.features, "Provider #{name} has incorrect features")
+
+      inst = provider.new(resource)
+      # Make sure the boolean methods work on both the provider and
+      # instance.
+      @features.keys.each do |feature|
+        method = feature.to_s + "?"
+        assert(inst.respond_to?(method), "No boolean instance method for #{name} on #{feature}")
+        assert(provider.respond_to?(method), "No boolean class method for #{name} on #{feature}")
+
+        if should.include?(feature)
+          assert(provider.feature?(feature), "class missing feature? #{feature}")
+          assert(inst.feature?(feature), "instance missing feature? #{feature}")
+          assert(provider.send(method), "class missing feature #{feature}")
+          assert(inst.send(method), "instance missing feature #{feature}")
+          assert(inst.satisfies?(feature), "instance.satisfy #{feature} returned false")
+          else
+            assert(! provider.feature?(feature), "class has feature? #{feature}")
+            assert(! inst.feature?(feature), "instance has feature? #{feature}")
+            assert(! provider.send(method), "class has feature #{feature}")
+            assert(! inst.send(method), "instance has feature #{feature}")
+            assert(! inst.satisfies?(feature), "instance.satisfy #{feature} returned true")
+          end
         end
 
-        resource = @type.new(:name => "foo")
-        {:numbers => [:numeric], :letters => [:alpha], :both => [:numeric, :alpha],
-            :mixed => [], :neither => []}.each do |name, should|
-                should.sort! { |a,b| a.to_s <=> b.to_s }
-                provider = @type.provider(name)
-                assert(provider, "Could not find provider %s" % name)
-                assert_equal(should, provider.features,
-                    "Provider %s has incorrect features" % name)
-
-                inst = provider.new(resource)
-                # Make sure the boolean methods work on both the provider and
-                # instance.
-                @features.keys.each do |feature|
-                    method = feature.to_s + "?"
-                    assert(inst.respond_to?(method),
-                        "No boolean instance method for %s on %s" %
-                        [name, feature])
-                    assert(provider.respond_to?(method),
-                        "No boolean class method for %s on %s" % [name, feature])
-
-                    if should.include?(feature)
-                        assert(provider.feature?(feature),
-                            "class missing feature? %s" % feature)
-                        assert(inst.feature?(feature),
-                            "instance missing feature? %s" % feature)
-                        assert(provider.send(method),
-                            "class missing feature %s" % feature)
-                        assert(inst.send(method),
-                            "instance missing feature %s" % feature)
-                        assert(inst.satisfies?(feature),
-                            "instance.satisfy %s returned false" % feature)
-                    else
-                        assert(! provider.feature?(feature),
-                            "class has feature? %s" % feature)
-                        assert(! inst.feature?(feature),
-                            "instance has feature? %s" % feature)
-                        assert(! provider.send(method),
-                            "class has feature %s" % feature)
-                        assert(! inst.send(method),
-                            "instance has feature %s" % feature)
-                        assert(! inst.satisfies?(feature),
-                            "instance.satisfy %s returned true" % feature)
-                    end
-                end
-
-            end
-
-        Puppet[:trace] = true
-        Puppet::Type.loadall
-        Puppet::Type.eachtype do |type|
-            assert(type.respond_to?(:feature),
-                "No features method defined for %s" % type.name)
-        end
+      end
+
+    Puppet[:trace] = true
+    Puppet::Type.loadall
+    Puppet::Type.eachtype do |type|
+      assert(type.respond_to?(:feature), "No features method defined for #{type.name}")
     end
+  end
 
-    def test_has_feature
-        # Define a new feature that has no methods
-        @type.feature(:nomeths, "desc")
+  def test_has_feature
+    # Define a new feature that has no methods
+    @type.feature(:nomeths, "desc")
 
-        # Define a provider with nothing
-        provider = @type.provide(:nothing) {}
+    # Define a provider with nothing
+    provider = @type.provide(:nothing) {}
 
-        assert(provider.respond_to?(:has_features),
-            "Provider did not get 'has_features' method added")
-        assert(provider.respond_to?(:has_feature),
-            "Provider did not get the 'has_feature' alias method")
 
-        # One with the numeric methods and nothing else
-        @type.provide(:numbers) do
-            define_method(:one) {}
-            define_method(:two) {}
-        end
+      assert(
+        provider.respond_to?(:has_features),
 
-        # Another with the numbers and a declaration
-        @type.provide(:both) do
-            define_method(:one) {}
-            define_method(:two) {}
+      "Provider did not get 'has_features' method added")
 
-            has_feature :alpha
-        end
+        assert(
+          provider.respond_to?(:has_feature),
 
-        # And just the declaration
-        @type.provide(:letters) do
-            has_feature :alpha
-        end
+      "Provider did not get the 'has_feature' alias method")
 
-        # And a provider that declares it has our methodless feature.
-        @type.provide(:none) do
-            has_feature :nomeths
-        end
+    # One with the numeric methods and nothing else
+    @type.provide(:numbers) do
+      define_method(:one) {}
+      define_method(:two) {}
+    end
 
-        should = {:nothing => [], :both => [:numeric, :alpha],
-            :letters => [:alpha], :numbers => [:numeric],
-            :none => [:nomeths]}
-
-        should.each do |name, features|
-            provider_class = @type.provider(name)
-            provider = provider_class.new({})
-
-            assert(provider, "did not get provider named %s" % name)
-            features.sort! { |a,b| a.to_s <=> b.to_s }
-            assert_equal(features, provider.features, "Got incorrect feature list for provider instance %s" % name)
-            assert_equal(features, provider_class.features, "Got incorrect feature list for provider class %s" % name)
-            features.each do |feat|
-                assert(provider.feature?(feat), "Provider instance %s did not have feature %s" % [name, feat])
-                assert(provider_class.feature?(feat), "Provider class %s did not have feature %s" % [name, feat])
-            end
-        end
+    # Another with the numbers and a declaration
+    @type.provide(:both) do
+      define_method(:one) {}
+      define_method(:two) {}
+
+      has_feature :alpha
     end
 
-    def test_supports_parameter?
-        # Make some parameters for each setting
-        @type.newparam(:neither) {}
-        @type.newparam(:some, :required_features => :alpha)
-        @type.newparam(:both, :required_features => [:alpha, :numeric])
-
-        # and appropriate providers
-        nope = @type.provide(:nope) {}
-        maybe = @type.provide(:maybe) { has_feature(:alpha) }
-        yep = @type.provide(:yep) { has_features(:alpha, :numeric) }
-
-        # Now make sure our providers answer correctly.
-        [nope, maybe, yep].each do |prov|
-            assert(prov.respond_to?(:supports_parameter?), "%s does not respond to :supports_parameter?" % prov.name)
-            case prov.name
-            when :nope
-                supported = [:neither]
-                un = [:some, :both]
-            when :maybe
-                supported = [:neither, :some]
-                un = [:both]
-            when :yep
-                supported = [:neither, :some, :both]
-                un = []
-            end
-
-            supported.each do |param|
-                assert(prov.supports_parameter?(param), "%s was not supported by %s" % [param, prov.name])
-            end
-            un.each do |param|
-                assert(! prov.supports_parameter?(param), "%s was incorrectly supported by %s" % [param, prov.name])
-            end
-        end
+    # And just the declaration
+    @type.provide(:letters) do
+      has_feature :alpha
+    end
+
+    # And a provider that declares it has our methodless feature.
+    @type.provide(:none) do
+      has_feature :nomeths
+    end
+
+    should = {:nothing => [], :both => [:numeric, :alpha],
+      :letters => [:alpha], :numbers => [:numeric],
+      :none => [:nomeths]}
+
+    should.each do |name, features|
+      provider_class = @type.provider(name)
+      provider = provider_class.new({})
+
+      assert(provider, "did not get provider named #{name}")
+      features.sort! { |a,b| a.to_s <=> b.to_s }
+      assert_equal(features, provider.features, "Got incorrect feature list for provider instance #{name}")
+      assert_equal(features, provider_class.features, "Got incorrect feature list for provider class #{name}")
+      features.each do |feat|
+        assert(provider.feature?(feat), "Provider instance #{name} did not have feature #{feat}")
+        assert(provider_class.feature?(feat), "Provider class #{name} did not have feature #{feat}")
+      end
+    end
+  end
+
+  def test_supports_parameter?
+    # Make some parameters for each setting
+    @type.newparam(:neither) {}
+    @type.newparam(:some, :required_features => :alpha)
+    @type.newparam(:both, :required_features => [:alpha, :numeric])
+
+    # and appropriate providers
+    nope = @type.provide(:nope) {}
+    maybe = @type.provide(:maybe) { has_feature(:alpha) }
+    yep = @type.provide(:yep) { has_features(:alpha, :numeric) }
+
+    # Now make sure our providers answer correctly.
+    [nope, maybe, yep].each do |prov|
+      assert(prov.respond_to?(:supports_parameter?), "#{prov.name} does not respond to :supports_parameter?")
+      case prov.name
+      when :nope
+        supported = [:neither]
+        un = [:some, :both]
+      when :maybe
+        supported = [:neither, :some]
+        un = [:both]
+      when :yep
+        supported = [:neither, :some, :both]
+        un = []
+      end
+
+      supported.each do |param|
+        assert(prov.supports_parameter?(param), "#{param} was not supported by #{prov.name}")
+      end
+      un.each do |param|
+        assert(! prov.supports_parameter?(param), "#{param} was incorrectly supported by #{prov.name}")
+      end
     end
+  end
 end