puppet 0.25.5 → 2.6.0

data/test/ral/providers/package/aptitude.rb

@@ -5,67 +5,79 @@ require File.dirname(__FILE__) + '/../../../lib/puppettest'
 require 'mocha'
 
 class AptitudePackageProviderTest < PuppetTest::TestCase
-    confine "Aptitude package provider missing" =>
-        Puppet::Type.type(:package).provider(:aptitude).suitable?
-
-    def setup
-        super
-        @type = Puppet::Type.type(:package)
-    end
-
-    def test_install
-        pkg = @type.new :name => 'faff',
-                           :provider => :aptitude,
-                           :ensure => :present,
-                           :source => "/tmp/faff.deb"
-
-        pkg.provider.expects(
-                         :dpkgquery
-                      ).with(
-                              '-W',
-                              '--showformat',
-                              '${Status} ${Package} ${Version}\n',
-                              'faff'
-                      ).returns(
-                            "deinstall ok config-files faff 1.2.3-1\n"
-                      ).times(1)
-
-        pkg.provider.expects(
-                         :aptitude
-                   ).with(
-                         '-y',
-                         '-o',
-                         'DPkg::Options::=--force-confold',
-                         :install,
-                         'faff'
-                      ).returns(0)
-
-        pkg.evaluate.each { |state|
-                    state.forward
-          }
-    end
-
-    def test_purge
-        pkg = @type.new :name => 'faff', :provider => :aptitude, :ensure => :purged
-
-        pkg.provider.expects(
-                         :dpkgquery
-                      ).with(
-                            '-W',
-                            '--showformat',
-                            '${Status} ${Package} ${Version}\n',
-                            'faff'
-                      ).returns(
-                            "install ok installed faff 1.2.3-1\n"
-                      ).times(1)
-        pkg.provider.expects(
-                         :aptitude
-                      ).with(
-                            '-y',
-                            'purge',
-                            'faff'
-                      ).returns(0)
-
-        pkg.evaluate.each { |state| state.forward }
-    end
+  include PuppetTest
+
+  confine "Aptitude package provider missing" =>
+    Puppet::Type.type(:package).provider(:aptitude).suitable?
+
+  def setup
+    super
+    @type = Puppet::Type.type(:package)
+  end
+
+  def test_install
+    pkg = @type.new :name => 'faff',
+      :provider => :aptitude,
+      :ensure => :present,
+      :source => "/tmp/faff.deb"
+
+    pkg.provider.expects(
+      :dpkgquery
+
+        ).with(
+
+          '-W',
+          '--showformat',
+          '${Status} ${Package} ${Version}\n',
+
+          'faff'
+            ).returns(
+              "deinstall ok config-files faff 1.2.3-1\n"
+            ).times(1)
+
+    pkg.provider.expects(
+      :aptitude
+
+        ).with(
+
+          '-y',
+          '-o',
+          'DPkg::Options::=--force-confold',
+          :install,
+
+          'faff'
+            ).returns(0)
+
+    assert_apply( pkg )
+  end
+
+  def test_purge
+    pkg = @type.new :name => 'faff', :provider => :aptitude, :ensure => :purged
+
+    pkg.provider.expects(
+      :dpkgquery
+
+        ).with(
+
+          '-W',
+          '--showformat',
+          '${Status} ${Package} ${Version}\n',
+
+          'faff'
+            ).returns(
+              "install ok installed faff 1.2.3-1\n"
+            ).times(1)
+    pkg.provider.expects(
+      :aptitude
+
+        ).with(
+
+          '-y',
+          'purge',
+
+          'faff'
+            ).returns(0)
+
+    assert_apply( pkg )
+  end
 end

data/test/ral/providers/package/aptrpm.rb

@@ -5,84 +5,96 @@ require File.dirname(__FILE__) + '/../../../lib/puppettest'
 require 'mocha'
 
 class AptrpmPackageProviderTest < PuppetTest::TestCase
-    confine "Apt package provider missing" =>
-        Puppet::Type.type(:package).provider(:aptrpm).suitable?
+  confine "Apt package provider missing" =>
+    Puppet::Type.type(:package).provider(:aptrpm).suitable?
 
-    def setup
-        super
-        @type = Puppet::Type.type(:package)
-    end
+  def setup
+    super
+    @type = Puppet::Type.type(:package)
+  end
 
-    def test_install
-        pkg = @type.new :name => 'faff',
-                           :provider => :aptrpm,
-                           :ensure => :present,
-                           :source => "/tmp/faff.rpm"
-
-        pkg.provider.expects(
-                            :rpm
-                      ).with(
-                            '-q',
-                            'faff',
-                            '--nosignature',
-                            '--nodigest',
-                            '--qf',
-                            "%{NAME}-%{VERSION}-%{RELEASE} %{VERSION}-%{RELEASE}\n"
-                      ).raises(Puppet::ExecutionFailure, "couldn't find rpm").times(1)
-
-        pkg.provider.expects(
-                         :aptget
-                    ).with(
-                         '-q',
-                         '-y',
-                         "install",
-                         'faff'
-                    ).returns(0)
-
-        pkg.evaluate.each { |state| state.forward }
-    end
+  def test_install
+    pkg = @type.new :name => 'faff',
+      :provider => :aptrpm,
+      :ensure => :present,
+      :source => "/tmp/faff.rpm"
 
-    def test_uninstall
-        pkg = @type.new :name => 'faff', :provider => :aptrpm, :ensure => :absent
-
-        pkg.provider.expects(
-                         :rpm
-                    ).with(
-                        '-q',
-                        'faff',
-                        '--nosignature',
-                        '--nodigest',
-                        '--qf',
-                        "%{NAME}-%{VERSION}-%{RELEASE} %{VERSION}-%{RELEASE}\n"
-                    ).returns(
-                        "faff-1.2.3-1 1.2.3-1\n"
-                    ).times(1)
-        pkg.provider.expects(
-                        :aptget
-                    ).with(
-                        '-y',
-                        '-q',
-                        'remove',
-                        'faff'
-                    ).returns(0)
-
-        pkg.evaluate.each { |state| state.forward }
-    end
+    pkg.provider.expects(
+      :rpm
+
+        ).with(
+
+          '-q',
+          'faff',
+          '--nosignature',
+          '--nodigest',
+          '--qf',
+
+          "%{NAME}-%{VERSION}-%{RELEASE} %{VERSION}-%{RELEASE}\n"
+            ).raises(Puppet::ExecutionFailure, "couldn't find rpm").times(1)
+
+    pkg.provider.expects(
+      :aptget
+
+        ).with(
+
+          '-q',
+          '-y',
+          "install",
+
+          'faff'
+          ).returns(0)
+
+    pkg.evaluate.each { |state| state.forward }
+  end
+
+  def test_uninstall
+    pkg = @type.new :name => 'faff', :provider => :aptrpm, :ensure => :absent
+
+    pkg.provider.expects(
+      :rpm
+
+        ).with(
+
+          '-q',
+          'faff',
+          '--nosignature',
+          '--nodigest',
+          '--qf',
+
+          "%{NAME}-%{VERSION}-%{RELEASE} %{VERSION}-%{RELEASE}\n"
+          ).returns(
+            "faff-1.2.3-1 1.2.3-1\n"
+          ).times(1)
+    pkg.provider.expects(
+      :aptget
+
+        ).with(
+
+          '-y',
+          '-q',
+          'remove',
+
+          'faff'
+          ).returns(0)
+
+    pkg.evaluate.each { |state| state.forward }
+  end
 
-    # LAK: I don't know where this test will ever return true..
-    def disabled_test_latest
-        pkg = @type.new :name => 'ssh', :provider => :aptrpm
+  # LAK: I don't know where this test will ever return true..
+  def disabled_test_latest
+    pkg = @type.new :name => 'ssh', :provider => :aptrpm
 
-        assert(pkg, "did not create pkg")
-        status = pkg.provider.query
-        assert(status, "ssh is not installed")
-        assert(status[:ensure] != :absent, "ssh is not installed")
+    assert(pkg, "did not create pkg")
+    status = pkg.provider.query
+    assert(status, "ssh is not installed")
+    assert(status[:ensure] != :absent, "ssh is not installed")
 
-        latest = nil
-        assert_nothing_raised("Could not call latest") do
-            latest = pkg.provider.latest
-        end
-        assert(latest, "Could not get latest value from apt")
+    latest = nil
+    assert_nothing_raised("Could not call latest") do
+      latest = pkg.provider.latest
     end
+    assert(latest, "Could not get latest value from apt")
+  end
 end
 

data/test/ral/providers/parsedfile.rb

@@ -10,685 +10,686 @@ require 'puppet/provider/parsedfile'
 require 'facter'
 
 class TestParsedFile < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::FileParsing
-
-    Puppet::Type.newtype(:testparsedfiletype) do
-        ensurable
-        newproperty(:one) do
-            newvalue(:a)
-            newvalue(:b)
-        end
-        newproperty(:two) do
-            newvalue(:c)
-            newvalue(:d)
-        end
+  include PuppetTest
+  include PuppetTest::FileParsing
+
+  Puppet::Type.newtype(:testparsedfiletype) do
+    ensurable
+    newproperty(:one) do
+      newvalue(:a)
+      newvalue(:b)
+    end
+    newproperty(:two) do
+      newvalue(:c)
+      newvalue(:d)
+    end
 
-        newparam(:name) do
-        end
+    newparam(:name) do
+    end
 
-        # The target should always be a property, not a parameter.
-        newproperty(:target) do
-            defaultto { @resource.class.defaultprovider.default_target }
-        end
+    # The target should always be a property, not a parameter.
+    newproperty(:target) do
+      defaultto { @resource.class.defaultprovider.default_target }
     end
+  end
 
-    # A simple block to skip the complexity of a full transaction.
-    def apply(resource)
-        [:one, :two, :ensure, :target].each do |st|
-            Puppet.info "Setting %s: %s => %s" %
-                [resource[:name], st, resource.should(st)]
-            resource.provider.send(st.to_s + "=", resource.should(st))
-        end
+  # A simple block to skip the complexity of a full transaction.
+  def apply(resource)
+    [:one, :two, :ensure, :target].each do |st|
+      Puppet.info "Setting #{resource[:name]}: #{st} => #{resource.should(st)}"
+      resource.provider.send(st.to_s + "=", resource.should(st))
     end
+  end
+
+  def mkresource(name, options = {})
+    options[:one] ||= "a"
+    options[:two] ||= "c"
+    options[:name] ||= name
 
-    def mkresource(name, options = {})
-        options[:one] ||= "a"
-        options[:two] ||= "c"
-        options[:name] ||= name
+    resource = @type.new(options)
+  end
 
-        resource = @type.new(options)
+  def mkprovider(name = :parsed)
+    @provider = @type.provide(name, :parent => Puppet::Provider::ParsedFile, :filetype => :ram, :default_target => "yayness") do
+      record_line name, :fields => %w{name one two}
     end
+  end
+
+  def setup
+    super
+    @type = Puppet::Type.type(:testparsedfiletype)
+  end
 
-    def mkprovider(name = :parsed)
-        @provider = @type.provide(name, :parent => Puppet::Provider::ParsedFile,
-            :filetype => :ram, :default_target => "yayness") do
-            record_line name, :fields => %w{name one two}
-        end
+  def teardown
+    if defined?(@provider)
+      @type.unprovide(@provider.name)
+      @provider = nil
     end
+    super
+  end
 
-    def setup
-        super
-        @type = Puppet::Type.type(:testparsedfiletype)
+  def test_create_provider
+    assert_nothing_raised do
+      mkprovider
     end
+  end
 
-    def teardown
-        if defined? @provider
-            @type.unprovide(@provider.name)
-            @provider = nil
-        end
-        super
+  def test_resource_attributes
+    prov = nil
+    assert_nothing_raised do
+      prov = mkprovider
     end
 
-    def test_create_provider
-        assert_nothing_raised do
-            mkprovider
-        end
+    [:one, :two, :name].each do |attr|
+      assert(prov.method_defined?(attr), "Did not define #{attr}")
     end
 
-    def test_resource_attributes
-        prov = nil
-        assert_nothing_raised do
-            prov = mkprovider
-        end
+    # Now make sure they stay around
+    fakeresource = fakeresource(:testparsedfiletype, "yay")
 
-        [:one, :two, :name].each do |attr|
-            assert(prov.method_defined?(attr), "Did not define %s" % attr)
-        end
+    file = prov.new(fakeresource)
+    assert(file, "Could not make provider")
 
-        # Now make sure they stay around
-        fakeresource = fakeresource(:testparsedfiletype, "yay")
+    assert_nothing_raised("Could not set provider name") do
+      file.name = :yayness
+    end
+
+    # The provider converts to strings
+    assert_equal(:yayness, file.name)
+  end
 
-        file = prov.new(fakeresource)
-        assert(file, "Could not make provider")
+  def test_filetype
+    prov = mkprovider
 
-        assert_nothing_raised("Could not set provider name") do
-            file.name = :yayness
-        end
+    flat = Puppet::Util::FileType.filetype(:flat)
+    ram = Puppet::Util::FileType.filetype(:ram)
+    assert_nothing_raised do
+      prov.filetype = :flat
+    end
 
-        # The provider converts to strings
-        assert_equal(:yayness, file.name)
+    assert_equal(flat, prov.filetype)
+
+    assert_nothing_raised do
+      prov.filetype = ram
+    end
+    assert_equal(ram, prov.filetype)
+  end
+
+  # Make sure we correctly create a new filetype object, but only when
+  # necessary.
+  def test_fileobject
+    prov = mkprovider
+
+    path = tempfile
+    obj = nil
+    assert_nothing_raised do
+      obj = prov.target_object(path)
     end
 
-    def test_filetype
-        prov = mkprovider
+    # The default filetype is 'ram'
+    assert_instance_of(Puppet::Util::FileType.filetype(:ram), obj)
 
-        flat = Puppet::Util::FileType.filetype(:flat)
-        ram = Puppet::Util::FileType.filetype(:ram)
-        assert_nothing_raised do
-            prov.filetype = :flat
-        end
+    newobj = nil
+    assert_nothing_raised do
+      newobj = prov.target_object(path)
+    end
 
-        assert_equal(flat, prov.filetype)
+    assert_equal(obj, newobj, "did not reuse file object")
 
-        assert_nothing_raised do
-            prov.filetype = ram
-        end
-        assert_equal(ram, prov.filetype)
+    # now make sure clear does the right thing
+    assert_nothing_raised do
+      prov.clear
+    end
+    assert_nothing_raised do
+      newobj = prov.target_object(path)
     end
 
-    # Make sure we correctly create a new filetype object, but only when
-    # necessary.
-    def test_fileobject
-        prov = mkprovider
+    assert(obj != newobj, "did not reuse file object")
+  end
+
+  def test_retrieve
+    prov = mkprovider
 
-        path = tempfile()
-        obj = nil
-        assert_nothing_raised do
-            obj = prov.target_object(path)
-        end
+    prov.filetype = :ram
 
-        # The default filetype is 'ram'
-        assert_instance_of(Puppet::Util::FileType.filetype(:ram), obj)
+    # Override the parse method with our own
+    prov.meta_def(:parse) do |text|
+      return [text]
+    end
 
-        newobj = nil
-        assert_nothing_raised do
-            newobj = prov.target_object(path)
-        end
+    path = :yayness
+    file = prov.target_object(path)
+    text = "a test"
+    file.write(text)
 
-        assert_equal(obj, newobj, "did not reuse file object")
+    ret = nil
+    assert_nothing_raised do
+      ret = prov.retrieve(path)
+    end
 
-        # now make sure clear does the right thing
-        assert_nothing_raised do
-            prov.clear
-        end
-        assert_nothing_raised do
-            newobj = prov.target_object(path)
-        end
+    assert_equal([text], ret)
 
-        assert(obj != newobj, "did not reuse file object")
+    # Now set the text to nil and make sure we get an empty array
+    file.write(nil)
+    assert_nothing_raised do
+      ret = prov.retrieve(path)
     end
 
-    def test_retrieve
-        prov = mkprovider
+    assert_equal([], ret)
 
-        prov.filetype = :ram
+    # And the empty string should return an empty array
+    file.write("")
+    assert_nothing_raised do
+      ret = prov.retrieve(path)
+    end
 
-        # Override the parse method with our own
-        prov.meta_def(:parse) do |text|
-            return [text]
-        end
+    assert_equal([], ret)
+  end
 
-        path = :yayness
-        file = prov.target_object(path)
-        text = "a test"
-        file.write(text)
+  # Verify that prefetch will parse the file, create any necessary instances,
+  # and set the 'is' values appropriately.
+  def test_prefetch
+    prov = mkprovider
 
-        ret = nil
-        assert_nothing_raised do
-            ret = prov.retrieve(path)
-        end
+    prov.filetype = :ram
+    prov.default_target = :default
 
-        assert_equal([text], ret)
+    # Create a couple of demo files
+    prov.target_object(:file1).write "bill b c\njill b d"
 
-        # Now set the text to nil and make sure we get an empty array
-        file.write(nil)
-        assert_nothing_raised do
-            ret = prov.retrieve(path)
-        end
+    prov.target_object(:default).write "will b d\n"
 
-        assert_equal([], ret)
+    # Create some resources for some of those demo files
+    bill = mkresource "bill", :target => :file1, :one => "b", :two => "c"
+    will = mkresource "will", :target => :default, :one => "b", :two => "d"
 
-        # And the empty string should return an empty array
-        file.write("")
-        assert_nothing_raised do
-            ret = prov.retrieve(path)
-        end
+    resources = {"bill" => bill, "will" => will}
+    prov_ids = {"bill" => bill.provider.object_id, "will" => will.provider.object_id}
 
-        assert_equal([], ret)
+    assert_nothing_raised do
+      prov.prefetch(resources)
     end
 
-    # Verify that prefetch will parse the file, create any necessary instances,
-    # and set the 'is' values appropriately.
-    def test_prefetch
-        prov = mkprovider
+    assert(bill.provider.object_id != prov_ids["bill"], "provider was not replaced in resource")
+    assert(will.provider.object_id != prov_ids["will"], "provider was not replaced in resource")
 
-        prov.filetype = :ram
-        prov.default_target = :default
+    # Make sure we prefetched our resources.
+    assert_equal("b", bill.provider.one, "did not prefetch resource from file1")
+    assert_equal("c", bill.provider.two, "did not prefetch resource from file1")
+    assert_equal("b", will.provider.one, "did not prefetch resource from default")
+    assert_equal("d", will.provider.two, "did not prefetch resource from default")
 
-        # Create a couple of demo files
-        prov.target_object(:file1).write "bill b c\njill b d"
+    # Now modify our resources and write them out, making sure that prefetching
+    # hasn't somehow destroyed this ability
+    bill[:one] = "a"
+    will[:one] = "a"
 
-        prov.target_object(:default).write "will b d\n"
+    assert_apply(bill)
+    assert_apply(will)
 
-        # Create some resources for some of those demo files
-        bill = mkresource "bill", :target => :file1, :one => "b", :two => "c"
-        will = mkresource "will", :target => :default, :one => "b", :two => "d"
+    prov.prefetch(resources)
+    assert_equal("a", bill.provider.one, "did not prefetch resource from file1")
+    assert_equal("a", will.provider.one, "did not prefetch resource from default")
 
-        resources = {"bill" => bill, "will" => will}
-        prov_ids = {"bill" => bill.provider.object_id, "will" => will.provider.object_id}
+    assert_equal("bill a c\njill b d\n", prov.target_object(:file1).read,
+      "Did not write changed resource correctly")
+    assert_equal("will a d\n", prov.target_object(:default).read,
+      "Did not write changed default resource correctly")
+  end
 
-        assert_nothing_raised do
-            prov.prefetch(resources)
-        end
+  # Make sure we can correctly prefetch on a target.
+  def test_prefetch_target
+    prov = mkprovider
 
-        assert(bill.provider.object_id != prov_ids["bill"], "provider was not replaced in resource")
-        assert(will.provider.object_id != prov_ids["will"], "provider was not replaced in resource")
+    prov.filetype = :ram
+    target = :yayness
+    prov.target_object(target).write "yay b d"
 
-        # Make sure we prefetched our resources.
-        assert_equal("b", bill.provider.one, "did not prefetch resource from file1")
-        assert_equal("c", bill.provider.two, "did not prefetch resource from file1")
-        assert_equal("b", will.provider.one, "did not prefetch resource from default")
-        assert_equal("d", will.provider.two, "did not prefetch resource from default")
+    records = nil
+    assert_nothing_raised do
+      records = prov.prefetch_target(:yayness)
+    end
 
-        # Now modify our resources and write them out, making sure that prefetching
-        # hasn't somehow destroyed this ability
-        bill[:one] = "a"
-        will[:one] = "a"
+    # Now make sure we correctly got the hash
+    record = records.find { |r| r[:name] == "yay" }
+    assert(record, "Did not get record in prefetch_target")
+    assert_equal("b", record[:one])
+    assert_equal("d", record[:two])
+  end
+
+  def test_prefetch_match
+    prov = mkprovider
+
+    prov.meta_def(:match) do |record, resources|
+      # Look for matches on :one
+      if res = resources.find { |name, resource| resource.should(:one).to_s == record[:one].to_s }
+        res[1]
+      else
+        nil
+      end
+    end
 
-        assert_apply(bill)
-        assert_apply(will)
+    prov.filetype = :ram
+    target = :yayness
+    prov.target_object(target).write "foo b d"
 
-        prov.prefetch(resources)
-        assert_equal("a", bill.provider.one, "did not prefetch resource from file1")
-        assert_equal("a", will.provider.one, "did not prefetch resource from default")
+    resource = mkresource "yay", :target => :yayness, :one => "b"
 
-        assert_equal("bill a c\njill b d\n", prov.target_object(:file1).read,
-            "Did not write changed resource correctly")
-        assert_equal("will a d\n", prov.target_object(:default).read,
-            "Did not write changed default resource correctly")
+    assert_nothing_raised do
+      prov.prefetch("yay" => resource)
     end
 
-    # Make sure we can correctly prefetch on a target.
-    def test_prefetch_target
-        prov = mkprovider
+    # Now make sure we correctly got the hash
+    mprov = resource.provider
+    assert_equal("yay", resource[:name])
+    assert_equal("b", mprov.one)
+    assert_equal("d", mprov.two)
+  end
 
-        prov.filetype = :ram
-        target = :yayness
-        prov.target_object(target).write "yay b d"
+  # We need to test that we're retrieving files from all three locations:
+  # from any existing target_objects, from the default file location, and
+  # from any existing resource instances.
+  def test_targets
+    prov = mkprovider
 
-        records = nil
-        assert_nothing_raised do
-            records = prov.prefetch_target(:yayness)
-        end
+    files = {}
 
-        # Now make sure we correctly got the hash
-        record = records.find { |r| r[:name] == "yay" }
-        assert(record, "Did not get record in prefetch_target")
-        assert_equal("b", record[:one])
-        assert_equal("d", record[:two])
-    end
+    # Set the default target
+    default = tempfile
+    files[:default] = default
+    prov.default_target = default
 
-    def test_prefetch_match
-        prov = mkprovider
+    # Create a file object
+    inmem = tempfile
+    files[:inmemory] = inmem
+    prov.target_object(inmem).write("inmem yay ness")
 
-        prov.meta_def(:match) do |record, resources|
-            # Look for matches on :one
-            if res = resources.find { |name, resource| resource.should(:one).to_s == record[:one].to_s }
-                res[1]
-            else
-                nil
-            end
-        end
+    # Lastly, create a resource with separate is and should values
+    mtarget = tempfile
+    files[:resources] = mtarget
+    resource = mkresource "yay", :target => mtarget
 
-        prov.filetype = :ram
-        target = :yayness
-        prov.target_object(target).write "foo b d"
+    assert(resource.should(:target), "Did not get a value for target")
 
-        resource = mkresource "yay", :target => :yayness, :one => "b"
+    list = nil
 
-        assert_nothing_raised do
-            prov.prefetch("yay" => resource)
-        end
+    # First run it without the resource
+    assert_nothing_raised do
+      list = prov.targets
+    end
 
-        # Now make sure we correctly got the hash
-        mprov = resource.provider
-        assert_equal("yay", resource[:name])
-        assert_equal("b", mprov.one)
-        assert_equal("d", mprov.two)
+    # Make sure it got the first two, but not the resources file
+    files.each do |name, file|
+      if name == :resources
+        assert(! list.include?(file), "Provider somehow found resource target when no resource was passed")
+      else
+        assert(list.include?(file), "Provider did not find #{name} file")
+      end
     end
 
-    # We need to test that we're retrieving files from all three locations:
-    # from any existing target_objects, from the default file location, and
-    # from any existing resource instances.
-    def test_targets
-        prov = mkprovider
+    # Now list with the resource passed
+    assert_nothing_raised do
+      list = prov.targets("yay" => resource)
+    end
 
-        files = {}
+    # And make sure we get all three files
+    files.each do |name, file|
+      assert(list.include?(file), "Provider did not find #{name} file when resource was passed")
+    end
+  end
 
-        # Set the default target
-        default = tempfile()
-        files[:default] = default
-        prov.default_target = default
+  # Make sure that flushing behaves correctly.  This is what actually writes
+  # the data out to disk.
+  def test_flush
+    prov = mkprovider
 
-        # Create a file object
-        inmem = tempfile()
-        files[:inmemory] = inmem
-        prov.target_object(inmem).write("inmem yay ness")
+    prov.filetype = :ram
+    prov.default_target = :yayness
 
-        # Lastly, create a resource with separate is and should values
-        mtarget = tempfile()
-        files[:resources] = mtarget
-        resource = mkresource "yay", :target => mtarget
+    # Create some resources.
+    one = mkresource "one", :one => "a", :two => "c", :target => :yayness
+    two = mkresource "two", :one => "b", :two => "d", :target => :yayness
+    resources = {"one" => one, "two" => two}
 
-        assert(resource.should(:target), "Did not get a value for target")
+    # Write out a file with different data.
+    prov.target_object(:yayness).write "one b d\ntwo a c"
 
-        list = nil
+    prov.prefetch(resources)
 
-        # First run it without the resource
-        assert_nothing_raised do
-            list = prov.targets
-        end
+    # Apply and flush the first resource.
+    assert_nothing_raised do
+      apply(one)
+    end
+    assert_nothing_raised { one.flush }
 
-        # Make sure it got the first two, but not the resources file
-        files.each do |name, file|
-            if name == :resources
-                assert(! list.include?(file), "Provider somehow found resource target when no resource was passed")
-            else
-                assert(list.include?(file), "Provider did not find %s file" % name)
-            end
-        end
+    # Make sure it didn't clear out our property hash
+    assert_equal(:a, one.provider.one)
+    assert_equal(:c, one.provider.two)
 
-        # Now list with the resource passed
-        assert_nothing_raised do
-            list = prov.targets("yay" => resource)
-        end
+    # And make sure it's right on disk
+    assert(prov.target_object(:yayness).read.include?("one a c"), "Did not write out correct data")
 
-        # And make sure we get all three files
-        files.each do |name, file|
-            assert(list.include?(file), "Provider did not find %s file when resource was passed" % name)
-        end
-    end
+    # Make sure the second resource has not been modified
+    assert_equal("a", two.provider.one, "Two was flushed early")
+    assert_equal("c", two.provider.two, "Two was flushed early")
 
-    # Make sure that flushing behaves correctly.  This is what actually writes
-    # the data out to disk.
-    def test_flush
-        prov = mkprovider
+    # And on disk
+    assert(prov.target_object(:yayness).read.include?("two a c"), "Wrote out other resource")
 
-        prov.filetype = :ram
-        prov.default_target = :yayness
+    # Now fetch the data again and make sure we're still right
+    assert_nothing_raised { prov.prefetch(resources) }
+    assert_equal("a", one.provider.one)
+    assert_equal("a", two.provider.one)
 
-        # Create some resources.
-        one = mkresource "one", :one => "a", :two => "c", :target => :yayness
-        two = mkresource "two", :one => "b", :two => "d", :target => :yayness
-        resources = {"one" => one, "two" => two}
+    # Now flush the second resource and make sure it goes well
+    assert_nothing_raised { apply(two) }
+    assert_nothing_raised { two.flush }
 
-        # Write out a file with different data.
-        prov.target_object(:yayness).write "one b d\ntwo a c"
+    # And make sure it didn't clear our hash
+    assert_equal(:b, two.provider.one)
+  end
 
-        prov.prefetch(resources)
+  # Make sure it works even if the file does not currently exist
+  def test_creating_file
+    prov = mkprovider
+    prov.clear
 
-        # Apply and flush the first resource.
-        assert_nothing_raised do
-            apply(one)
-        end
-        assert_nothing_raised { one.flush }
+    prov.default_target = :basic
 
-        # Make sure it didn't clear out our property hash
-        assert_equal(:a, one.provider.one)
-        assert_equal(:c, one.provider.two)
+    resource = mkresource "yay", :target => :basic, :one => "a", :two => "c"
 
-        # And make sure it's right on disk
-        assert(prov.target_object(:yayness).read.include?("one a c"),
-            "Did not write out correct data")
+    assert_equal(:present, resource.should(:ensure))
 
-        # Make sure the second resource has not been modified
-        assert_equal("a", two.provider.one, "Two was flushed early")
-        assert_equal("c", two.provider.two, "Two was flushed early")
+    apply(resource)
 
-        # And on disk
-        assert(prov.target_object(:yayness).read.include?("two a c"),
-            "Wrote out other resource")
+    assert_nothing_raised do
+      resource.flush
+    end
 
-        # Now fetch the data again and make sure we're still right
-        assert_nothing_raised { prov.prefetch(resources) }
-        assert_equal("a", one.provider.one)
-        assert_equal("a", two.provider.one)
+    assert_equal("yay a c\n", prov.target_object(:basic).read,
+      "Did not create file")
 
-        # Now flush the second resource and make sure it goes well
-        assert_nothing_raised { apply(two) }
-        assert_nothing_raised { two.flush }
+    # Make a change
+    resource.provider.one = "b"
 
-        # And make sure it didn't clear our hash
-        assert_equal(:b, two.provider.one)
+    # Flush it
+    assert_nothing_raised do
+      resource.flush
     end
 
-    # Make sure it works even if the file does not currently exist
-    def test_creating_file
-        prov = mkprovider
-        prov.clear
+    # And make sure our resource doesn't appear twice in the file.
+    assert_equal("yay b c\n", prov.target_object(:basic).read, "Wrote record to file twice")
+  end
 
-        prov.default_target = :basic
+  # Make sure a record can switch targets.
+  def test_switching_targets
+    prov = mkprovider
 
-        resource = mkresource "yay", :target => :basic, :one => "a", :two => "c"
+    prov.filetype = :ram
+    prov.default_target = :first
 
-        assert_equal(:present, resource.should(:ensure))
+    # Make three resources, one for each target and one to switch
+    first = mkresource "first", :target => :first
+    second = mkresource "second", :target => :second
+    mover = mkresource "mover", :target => :first
 
-        apply(resource)
+    [first, second, mover].each do |m|
+      assert_nothing_raised("Could not apply #{m[:name]}") do
+        apply(m)
+      end
+    end
 
-        assert_nothing_raised do
-            resource.flush
-        end
+    # Flush.
+    [first, second, mover].each do |m|
+      assert_nothing_raised do
+        m.flush
+      end
+    end
 
-        assert_equal("yay a c\n", prov.target_object(:basic).read,
-            "Did not create file")
+    check = proc do |target, name|
+      assert(prov.target_object(target).read.include?("#{name} a c"), "Did not sync #{name}")
+    end
+    # Make sure the data is there
+    check.call(:first, :first)
+    check.call(:second, :second)
+    check.call(:first, :mover)
 
-        # Make a change
-        resource.provider.one = "b"
+    # Now change the target for the mover
+    mover[:target] = :second
 
-        # Flush it
-        assert_nothing_raised do
-            resource.flush
-        end
+    # Apply it
+    assert_nothing_raised do
+      apply(mover)
+    end
 
-        # And make sure our resource doesn't appear twice in the file.
-        assert_equal("yay b c\n", prov.target_object(:basic).read,
-            "Wrote record to file twice")
+    # Flush
+    assert_nothing_raised do
+      mover.flush
     end
 
-    # Make sure a record can switch targets.
-    def test_switching_targets
-        prov = mkprovider
+    # Make sure the data is there
+    check.call(:first, :first)
+    check.call(:second, :second)
+    check.call(:second, :mover)
 
-        prov.filetype = :ram
-        prov.default_target = :first
+    # And make sure the mover is no longer in the first file
+    assert(prov.target_object(:first) !~ /mover/, "Mover was not removed from first file")
+  end
 
-        # Make three resources, one for each target and one to switch
-        first = mkresource "first", :target => :first
-        second = mkresource "second", :target => :second
-        mover = mkresource "mover", :target => :first
+  # Make sure that 'ensure' correctly calls 'sync' on all properties.
+  def test_ensure
+    prov = mkprovider
 
-        [first, second, mover].each do |m|
-            assert_nothing_raised("Could not apply %s" % m[:name]) do
-                apply(m)
-            end
-        end
+    prov.filetype = :ram
+    prov.default_target = :first
 
-        # Flush.
-        [first, second, mover].each do |m|
-            assert_nothing_raised do
-                m.flush
-            end
-        end
+    # Make two resources, one that starts on disk and one that doesn't
+    ondisk = mkresource "ondisk", :target => :first
+    notdisk = mkresource "notdisk", :target => :first
 
-        check = proc do |target, name|
-            assert(prov.target_object(target).read.include?("%s a c" % name),
-                "Did not sync %s" % name)
-        end
-        # Make sure the data is there
-        check.call(:first, :first)
-        check.call(:second, :second)
-        check.call(:first, :mover)
+    prov.target_object(:first).write "ondisk a c\n"
+    prov.prefetch("ondisk" => ondisk, "notdisk" => notdisk)
 
-        # Now change the target for the mover
-        mover[:target] = :second
 
-        # Apply it
-        assert_nothing_raised do
-            apply(mover)
-        end
+      assert_equal(
+        :present, notdisk.should(:ensure),
 
-        # Flush
-        assert_nothing_raised do
-            mover.flush
-        end
+      "Did not get default ensure value")
 
-        # Make sure the data is there
-        check.call(:first, :first)
-        check.call(:second, :second)
-        check.call(:second, :mover)
+    # Try creating the object
+    assert_nothing_raised { notdisk.provider.create }
 
-        # And make sure the mover is no longer in the first file
-        assert(prov.target_object(:first) !~ /mover/,
-            "Mover was not removed from first file")
+    # Now make sure all of the data is copied over correctly.
+    notdisk.class.validproperties.each do |property|
+      assert_equal(notdisk.should(property), notdisk.provider.property_hash[property],
+        "#{property} was not copied over during creation")
     end
 
-    # Make sure that 'ensure' correctly calls 'sync' on all properties.
-    def test_ensure
-        prov = mkprovider
+    # Flush it to disk and make sure it got copied down
+    assert_nothing_raised do
+      notdisk.flush
+    end
 
-        prov.filetype = :ram
-        prov.default_target = :first
+    assert(prov.target_object(:first).read =~ /^notdisk/,
+      "Did not write out object to disk")
+    assert(prov.target_object(:first).read =~ /^ondisk/,
+      "Lost object on disk")
 
-        # Make two resources, one that starts on disk and one that doesn't
-        ondisk = mkresource "ondisk", :target => :first
-        notdisk = mkresource "notdisk", :target => :first
+    # Make sure our on-disk resource behaves appropriately.
+    assert_equal(:present, ondisk.provider.ensure)
 
-        prov.target_object(:first).write "ondisk a c\n"
-        prov.prefetch("ondisk" => ondisk, "notdisk" => notdisk)
+    # Now destroy the object
+    assert_nothing_raised { notdisk.provider.destroy }
 
-        assert_equal(:present, notdisk.should(:ensure),
-            "Did not get default ensure value")
+    assert_nothing_raised { notdisk.flush }
 
-        # Try creating the object
-        assert_nothing_raised { notdisk.provider.create() }
+    # And make sure it's no longer present
+    assert(prov.target_object(:first).read !~ /^notdisk/, "Did not remove thing from disk")
+    assert(prov.target_object(:first).read =~ /^ondisk/, "Lost object on disk")
+    assert_equal(:present, ondisk.provider.ensure)
+  end
 
-        # Now make sure all of the data is copied over correctly.
-        notdisk.class.validproperties.each do |property|
-            assert_equal(notdisk.should(property), notdisk.provider.property_hash[property],
-                "%s was not copied over during creation" % property)
-        end
+  def test_absent_fields
+    prov = @type.provide(:record, :parent => Puppet::Provider::ParsedFile) do
+      record_line :record, :fields => %w{name one two},
+        :separator => "\s"
+    end
+    cleanup { @type.unprovide(:record) }
 
-        # Flush it to disk and make sure it got copied down
-        assert_nothing_raised do
-            notdisk.flush
-        end
+    line = prov.parse_line("a  d")
 
-        assert(prov.target_object(:first).read =~ /^notdisk/,
-            "Did not write out object to disk")
-        assert(prov.target_object(:first).read =~ /^ondisk/,
-            "Lost object on disk")
+    assert_equal("a", line[:name], "field name was not set")
+    assert_equal(:absent, line[:one], "field one was not set to absent")
 
-        # Make sure our on-disk resource behaves appropriately.
-        assert_equal(:present, ondisk.provider.ensure)
+    # Now use a different provider with a non-blank "absent"
+    prov = @type.provide(:cronstyle, :parent => Puppet::Provider::ParsedFile) do
+      record_line :cronstyle, :fields => %w{name one two},
+        :separator => "\s", :absent => "*"
+    end
+    cleanup { @type.unprovide(:cronstyle) }
+    line = prov.parse_line("a * d")
 
-        # Now destroy the object
-        assert_nothing_raised { notdisk.provider.destroy() }
+    assert_equal("a", line[:name], "field name was not set")
+    assert_equal(:absent, line[:one], "field one was not set to absent")
+  end
 
-        assert_nothing_raised { notdisk.flush }
-
-        # And make sure it's no longer present
-        assert(prov.target_object(:first).read !~ /^notdisk/,
-            "Did not remove thing from disk")
-        assert(prov.target_object(:first).read =~ /^ondisk/,
-            "Lost object on disk")
-        assert_equal(:present, ondisk.provider.ensure)
-    end
-
-    def test_absent_fields
-        prov = @type.provide(:record, :parent => Puppet::Provider::ParsedFile) do
-            record_line :record, :fields => %w{name one two},
-                :separator => "\s"
-        end
-        cleanup { @type.unprovide(:record) }
+  # This test is because in x2puppet I was having problems where multiple
+  # retrievals somehow destroyed the 'is' values.
+  def test_value_retrieval
+    prov = mkprovider
+    prov.default_target = :yayness
 
-        line = prov.parse_line("a  d")
+    prov.target_object(:yayness).write "bill a c\njill b d"
 
-        assert_equal("a", line[:name], "field name was not set")
-        assert_equal(:absent, line[:one], "field one was not set to absent")
+    list = @type.instances
 
-        # Now use a different provider with a non-blank "absent"
-        prov = @type.provide(:cronstyle, :parent => Puppet::Provider::ParsedFile) do
-            record_line :cronstyle, :fields => %w{name one two},
-                :separator => "\s", :absent => "*"
-        end
-        cleanup { @type.unprovide(:cronstyle) }
-        line = prov.parse_line("a * d")
+    bill = list.find { |r| r[:name] == "bill" }
+    jill = list.find { |r| r[:name] == "jill" }
+    assert(bill, "Could not find bill")
+    assert(jill, "Could not find jill")
 
-        assert_equal("a", line[:name], "field name was not set")
-        assert_equal(:absent, line[:one], "field one was not set to absent")
+    prov = bill.provider
+
+    4.times do |i|
+      assert(prov.one, "Did not get a value for 'one' on try #{(i + 1)}")
     end
 
-    # This test is because in x2puppet I was having problems where multiple
-    # retrievals somehow destroyed the 'is' values.
-    def test_value_retrieval
-        prov = mkprovider
-        prov.default_target = :yayness
+    # First make sure we can retrieve values multiple times from the
+    # provider
+    bills_values = nil
+    assert_nothing_raised do
+      bills_values = bill.retrieve
+    end
 
-        prov.target_object(:yayness).write "bill a c\njill b d"
+    assert(bills_values[bill.property(:one)],
+      "Bill does not have a value for 'one'")
+    assert(bills_values[bill.property(:one)],
+      "Bill does not have a value for 'one' on second try")
+    assert_nothing_raised do
+      bill.retrieve
+    end
+    assert(bills_values[bill.property(:one)],
+      "bill's value for 'one' disappeared")
+  end
 
-        list = @type.instances
+  # Make sure that creating a new resource finds existing records in memory
+  def test_initialize_finds_records
+    prov = mkprovider
+    prov.default_target = :yayness
 
-        bill = list.find { |r| r[:name] == "bill" }
-        jill = list.find { |r| r[:name] == "jill" }
-        assert(bill, "Could not find bill")
-        assert(jill, "Could not find jill")
+    prov.target_object(:yayness).write "bill a c\njill b d"
 
-        prov = bill.provider
+    prov.prefetch
 
-        4.times do |i|
-            assert(prov.one, "Did not get a value for 'one' on try %s" % (i + 1))
-        end
+    # Now make a resource
+    bill = @type.new :name => "bill"
 
-        # First make sure we can retrieve values multiple times from the
-        # provider
-        bills_values = nil
-        assert_nothing_raised do
-            bills_values = bill.retrieve
-        end
+    assert_equal("a", bill.provider.one, "Record was not found in memory")
+  end
 
-        assert(bills_values[bill.property(:one)],
-               "Bill does not have a value for 'one'")
-        assert(bills_values[bill.property(:one)],
-               "Bill does not have a value for 'one' on second try")
-        assert_nothing_raised do
-            bill.retrieve
-        end
-        assert(bills_values[bill.property(:one)],
-               "bill's value for 'one' disappeared")
-    end
+  # Make sure invalid fields always show up as insync
+  def test_invalid_fields
 
-    # Make sure that creating a new resource finds existing records in memory
-    def test_initialize_finds_records
-        prov = mkprovider
-        prov.default_target = :yayness
+    prov = @type.provide(
+      :test, :parent => Puppet::Provider::ParsedFile,
 
-        prov.target_object(:yayness).write "bill a c\njill b d"
+      :filetype => :ram, :default_target => :yayness) do
+      record_line :test, :fields => %w{name two}
+    end
+    cleanup do @type.unprovide(:test) end
 
-        prov.prefetch
+    bill = nil
+    assert_nothing_raised do
+      bill = @type.new :name => "bill",
+        :one => "a", :two => "c"
+    end
 
-        # Now make a resource
-        bill = @type.new :name => "bill"
+    assert_apply(bill)
 
-        assert_equal("a", bill.provider.one, "Record was not found in memory")
+    prov.prefetch
+    current_value = nil
+    assert_nothing_raised do
+      current_value = bill.retrieve
     end
 
-    # Make sure invalid fields always show up as insync
-    def test_invalid_fields
-        prov = @type.provide(:test, :parent => Puppet::Provider::ParsedFile,
-            :filetype => :ram, :default_target => :yayness) do
-            record_line :test, :fields => %w{name two}
-        end
-        cleanup do @type.unprovide(:test) end
+    assert_events([], bill)
+  end
+
+  # Make sure we call the prefetch hook at the right place.
+  def test_prefetch_hook
 
-        bill = nil
-        assert_nothing_raised do
-            bill = @type.new :name => "bill",
-                :one => "a", :two => "c"
-        end
+    prov = @type.provide(
+      :test, :parent => Puppet::Provider::ParsedFile,
 
-        assert_apply(bill)
+      :filetype => :ram, :default_target => :yayness) do
 
-        prov.prefetch
-        current_value = nil
-        assert_nothing_raised do
-            current_value = bill.retrieve
-        end
+      def self.prefetch_hook(records)
+        records
+      end
 
-        assert(bill.insync?(current_value),
-            "An invalid field marked the record out of sync")
+      record_line :test, :fields => %w{name two}
     end
+    cleanup do @type.unprovide(:test) end
 
-    # Make sure we call the prefetch hook at the right place.
-    def test_prefetch_hook
-        prov = @type.provide(:test, :parent => Puppet::Provider::ParsedFile,
-            :filetype => :ram, :default_target => :yayness) do
+    target = "target"
 
-            def self.prefetch_hook(records)
-                records
-            end
+    records = [{:target => "nope"}]
+    targeted = {:target => "target"}
+    prov.send(:instance_variable_set, "@records", records)
+    prov.expects(:retrieve).with(target).returns([targeted])
 
-            record_line :test, :fields => %w{name two}
-        end
-        cleanup do @type.unprovide(:test) end
+    prov.expects(:prefetch_hook).with([targeted]).returns([targeted])
 
-        target = "target"
+    prov.prefetch_target(target)
+  end
 
-        records = [{:target => "nope"}]
-        targeted = {:target => "target"}
-        prov.send(:instance_variable_set, "@records", records)
-        prov.expects(:retrieve).with(target).returns([targeted])
+  # #529
+  def test_keep_content_with_target
+    mkprovider
+    @provider.filetype = :flat
+    dpath = tempfile
+    opath = tempfile
+    @provider.default_target = dpath
 
-        prov.expects(:prefetch_hook).with([targeted]).returns([targeted])
+    dtarget = @provider.target_object(dpath)
+    otarget = @provider.target_object(opath)
 
-        prov.prefetch_target(target)
-    end
+    dtarget.write("dname a c\n")
+    otarget.write("oname b d\n")
 
-    # #529
-    def test_keep_content_with_target
-        mkprovider
-        @provider.filetype = :flat
-        dpath = tempfile
-        opath = tempfile
-        @provider.default_target = dpath
+    # Now make a resource that targets elsewhat.
+    res = @type.new(:name => "test", :one => "a", :two => "c", :target => opath)
 
-        dtarget = @provider.target_object(dpath)
-        otarget = @provider.target_object(opath)
+    assert(res.property(:target), "Target is a parameter, not a property")
 
-        dtarget.write("dname a c\n")
-        otarget.write("oname b d\n")
+    assert_apply(res)
 
-        # Now make a resource that targets elsewhat.
-        res = @type.new(:name => "test", :one => "a", :two => "c",
-            :target => opath)
 
-        assert(res.property(:target), "Target is a parameter, not a property")
+      assert_equal(
+        "oname b d\ntest a c\n", otarget.read,
 
-        assert_apply(res)
-
-        assert_equal("oname b d\ntest a c\n", otarget.read,
-            "did not get correct results in specified target")
-    end
+      "did not get correct results in specified target")
+  end
 end