puppet 0.25.5 → 2.6.0

data/test/ral/providers/user/useradd.rb

@@ -5,238 +5,229 @@ require File.dirname(__FILE__) + '/../../../lib/puppettest'
 require 'mocha'
 
 class UserAddProviderTest < PuppetTest::TestCase
-    confine "useradd user provider missing" =>
-        Puppet::Type.type(:user).provider(:useradd).suitable?
-
-    def setup
-        super
-        @type = Puppet::Type.type(:user)
-        @provider = Puppet::Type.type(:user).provider(:useradd)
-        @home = tempfile
-        @vals = {:name => 'faff',
-            :provider => :useradd,
-            :ensure => :present,
-            :uid => 5000,
-            :gid => 5000,
-            :home => @home,
-            :comment => "yayness",
-            :groups => %w{one two}
-        }
+  confine "useradd user provider missing" =>
+    Puppet::Type.type(:user).provider(:useradd).suitable?
+
+  def setup
+    super
+    @type = Puppet::Type.type(:user)
+    @provider = Puppet::Type.type(:user).provider(:useradd)
+    @home = tempfile
+    @vals = {:name => 'faff',
+      :provider => :useradd,
+      :ensure => :present,
+      :uid => 5000,
+      :gid => 5000,
+      :home => @home,
+      :comment => "yayness",
+      :groups => %w{one two}
+    }
+  end
+
+  def setup_user
+    @user = @type.new(@vals)
+
+    @vals.each do |name, val|
+      next unless @user.class.validproperty?(name)
     end
+    @user
+  end
 
-    def setup_user
-        @user = @type.new(@vals)
+  def test_features
+    [:manages_homedir].each do |feature|
 
-        @vals.each do |name, val|
-            next unless @user.class.validproperty?(name)
-        end
-        @user
-    end
-
-    def test_features
-        [:manages_homedir].each do |feature|
-            assert(@provider.feature?(feature),
-                "useradd provider is missing %s" % feature)
-        end
+            assert(
+        @provider.feature?(feature),
+        
+        "useradd provider is missing #{feature}")
     end
+  end
 
-    def test_create
-        user = setup_user
-
-        @vals.each do |name, val|
-            next unless user.class.validproperty?(name)
-        end
+  def test_create
+    user = setup_user
 
-        user.expects(:allowdupe?).returns(false)
-        user.expects(:managehome?).returns(false)
+    @vals.each do |name, val|
+      next unless user.class.validproperty?(name)
+    end
 
-        user.provider.expects(:execute).with do |params|
-            command = params.shift
-            assert_equal(@provider.command(:add), command,
-                "Got incorrect command")
+    user.expects(:allowdupe?).returns(false)
+    user.expects(:managehome?).returns(false)
 
-            if %w{Fedora RedHat}.include?(Facter.value(:operatingsystem))
-                assert(params.include?("-M"),
-                    "Did not disable homedir creation on red hat")
-                params.delete("-M")
-            end
+    user.provider.expects(:execute).with do |params|
+      command = params.shift
+      assert_equal(@provider.command(:add), command,
+        "Got incorrect command")
 
-            options = {}
-            while params.length > 0
-                options[params.shift] = params.shift
-            end
+      if %w{Fedora RedHat}.include?(Facter.value(:operatingsystem))
+        assert(params.include?("-M"), "Did not disable homedir creation on red hat")
+        params.delete("-M")
+      end
 
-            @vals[:groups] = @vals[:groups].join(",")
+      options = {}
+      options[params.shift] = params.shift while params.length > 0
 
-            flags = {:home => "-d", :groups => "-G", :gid => "-g",
-                :uid => "-u", :comment => "-c"}
+      @vals[:groups] = @vals[:groups].join(",")
 
-            flags.each do |param, flag|
-                assert_equal(@vals[param], options[flag],
-                    "Got incorrect value for %s" % param)
-            end
+      flags = {:home => "-d", :groups => "-G", :gid => "-g",
+        :uid => "-u", :comment => "-c"}
 
-            true
-        end
+      flags.each do |param, flag|
+        assert_equal(@vals[param], options[flag], "Got incorrect value for #{param}")
+      end
 
-        user.provider.create
+      true
     end
 
-    # Make sure we add the right flags when managing home
-    def test_managehome
-        @vals[:managehome] = true
-        setup_user
+    user.provider.create
+  end
 
-        assert(@user.provider.respond_to?(:manages_homedir?),
-            "provider did not get managehome test set")
+  # Make sure we add the right flags when managing home
+  def test_managehome
+    @vals[:managehome] = true
+    setup_user
 
-        assert(@user.managehome?, "provider did not get managehome")
 
-        # First run
-        @user.expects(:managehome?).returns(true)
+          assert(
+        @user.provider.respond_to?(:manages_homedir?),
+        
+      "provider did not get managehome test set")
 
-        @user.provider.expects(:execute).with do |params|
-            assert_equal(params[0], @provider.command(:add),
-                "useradd was not called")
-            assert(params.include?("-m"),
-                "Did not add -m when managehome was in affect")
-            assert(! params.include?("-M"),
-                "Added -M when managehome was in affect")
+    assert(@user.managehome?, "provider did not get managehome")
 
-            true
-        end
+    # First run
+    @user.expects(:managehome?).returns(true)
 
-        @user.provider.create
+    @user.provider.expects(:execute).with do |params|
+      assert_equal(params[0], @provider.command(:add), "useradd was not called")
+      assert(params.include?("-m"), "Did not add -m when managehome was in affect")
+      assert(! params.include?("-M"), "Added -M when managehome was in affect")
 
-        # Start again, this time with manages_home off
-        @vals[:managehome] = false
-        setup_user
+      true
+    end
 
-        # First run
-        @user.expects(:managehome?).returns(false)
+    @user.provider.create
 
-        @user.provider.expects(:execute).with do |params|
-            assert_equal(params[0], @provider.command(:add),
-                "useradd was not called")
-            if %w{Fedora RedHat}.include?(Facter.value(:operatingsystem))
-                assert(params.include?("-M"),
-                    "Did not add -M on Red Hat")
-            end
-            assert(! params.include?("-m"),
-                "Added -m when managehome was disabled")
+    # Start again, this time with manages_home off
+    @vals[:managehome] = false
+    setup_user
 
-            true
-        end
+    # First run
+    @user.expects(:managehome?).returns(false)
+
+    @user.provider.expects(:execute).with do |params|
+      assert_equal(params[0], @provider.command(:add), "useradd was not called")
+      assert(params.include?("-M"), "Did not add -M on Red Hat") if %w{Fedora RedHat}.include?(Facter.value(:operatingsystem))
+      assert(! params.include?("-m"), "Added -m when managehome was disabled")
 
-        @user.provider.create
+      true
     end
 
-    def test_allowdupe
-        @vals[:allowdupe] = true
-        setup_user
+    @user.provider.create
+  end
 
-        assert(@user.provider.respond_to?(:allows_duplicates?),
-            "provider did not get allowdupe test set")
+  def test_allowdupe
+    @vals[:allowdupe] = true
+    setup_user
 
-        assert(@user.allowdupe?, "provider did not get allowdupe")
 
-        # First run
-        @user.expects(:allowdupe?).returns(true)
+          assert(
+        @user.provider.respond_to?(:allows_duplicates?),
+        
+      "provider did not get allowdupe test set")
 
-        @user.provider.expects(:execute).with do |params|
-            assert_equal(params[0], @provider.command(:add),
-                "useradd was not called")
-            assert(params.include?("-o"),
-                "Did not add -o when allowdupe was in affect")
+    assert(@user.allowdupe?, "provider did not get allowdupe")
 
-            true
-        end
+    # First run
+    @user.expects(:allowdupe?).returns(true)
 
-        @user.provider.create
+    @user.provider.expects(:execute).with do |params|
+      assert_equal(params[0], @provider.command(:add), "useradd was not called")
+      assert(params.include?("-o"), "Did not add -o when allowdupe was in affect")
 
-        # Start again, this time with manages_home off
-        @vals[:allowdupe] = false
-        setup_user
+      true
+    end
 
-        # First run
-        @user.expects(:allowdupe?).returns(false)
+    @user.provider.create
 
-        @user.provider.expects(:execute).with do |params|
-            assert_equal(params[0], @provider.command(:add),
-                "useradd was not called")
-            assert(! params.include?("-o"),
-                "Added -o when allowdupe was disabled")
+    # Start again, this time with manages_home off
+    @vals[:allowdupe] = false
+    setup_user
 
-            true
-        end
+    # First run
+    @user.expects(:allowdupe?).returns(false)
 
-        @user.provider.create
+    @user.provider.expects(:execute).with do |params|
+      assert_equal(params[0], @provider.command(:add), "useradd was not called")
+      assert(! params.include?("-o"), "Added -o when allowdupe was disabled")
+
+      true
     end
 
-    def test_manages_password
-        unless @provider.feature?(:manages_passwords)
-            return
-        end
-        @vals[:password] = "somethingorother"
-        setup_user
-
-        @user.provider.expects(:execute).with do |params|
-            assert_equal(params[0], @provider.command(:add),
-                "useradd was not called")
-            params.shift
-            options = {}
-            params.each_with_index do |p, i|
-                if p =~ /^-/ and p != "-M"
-                    options[p] = params[i + 1]
-                end
-            end
-            assert_equal(options["-p"], @vals[:password],
-                "Did not set password in useradd call")
-            true
+    @user.provider.create
+  end
+
+  def test_manages_password
+    return unless @provider.feature?(:manages_passwords)
+    @vals[:password] = "somethingorother"
+    setup_user
+
+    @user.provider.expects(:execute).with do |params|
+      assert_equal(params[0], @provider.command(:add), "useradd was not called")
+      params.shift
+      options = {}
+      params.each_with_index do |p, i|
+        if p =~ /^-/ and p != "-M"
+          options[p] = params[i + 1]
         end
+      end
+      assert_equal(options["-p"], @vals[:password], "Did not set password in useradd call")
+      true
+    end
 
-        @user.provider.create
-
-        # Now mark the user made, and make sure the right command is called
-        setup_user
-        @vals[:password] = "somethingelse"
-
-        @user.provider.expects(:execute).with do |params|
-            assert_equal(params[0], @provider.command(:modify),
-                "usermod was not called")
-
-            options = {}
-            params.each_with_index do |p, i|
-                if p =~ /^-/ and p != "-M"
-                    options[p] = params[i + 1]
-                end
-            end
-            assert_equal(options["-p"], @vals[:password],
-                "Did not set password in useradd call")
-            true
+    @user.provider.create
+
+    # Now mark the user made, and make sure the right command is called
+    setup_user
+    @vals[:password] = "somethingelse"
+
+    @user.provider.expects(:execute).with do |params|
+      assert_equal(params[0], @provider.command(:modify), "usermod was not called")
+
+      options = {}
+      params.each_with_index do |p, i|
+        if p =~ /^-/ and p != "-M"
+          options[p] = params[i + 1]
         end
+      end
 
-        @user.provider.password = @vals[:password]
+            assert_equal(
+        options["-p"], @vals[:password],
+        
+        "Did not set password in useradd call")
+      true
     end
 
+    @user.provider.password = @vals[:password]
+  end
+
 end
 
 class UserRootAddProviderTest < PuppetTest::TestCase
-    confine "useradd user provider missing" => Puppet::Type.type(:user).provider(:useradd).suitable?
-    confine "useradd does not manage passwords" => Puppet::Type.type(:user).provider(:useradd).manages_passwords?
-    confine "not running as root" => (Process.uid == 0)
+  confine "useradd user provider missing" => Puppet::Type.type(:user).provider(:useradd).suitable?
+  confine "useradd does not manage passwords" => Puppet::Type.type(:user).provider(:useradd).manages_passwords?
+  confine "not running as root" => (Process.uid == 0)
 
-    def test_password
-        user = Puppet::Type.type(:user).new(:name => "root", :check => [:password], :provider => :useradd)
+  def test_password
+    user = Puppet::Type.type(:user).new(:name => "root", :check => [:password], :provider => :useradd)
 
-        provider = user.provider
+    provider = user.provider
 
-        assert_nothing_raised("Could not check password") do
-            pass = provider.password
-            assert(pass, "Did not get password for root")
-            assert(pass!= "x", "Password was retrieved from /etc/passwd instead of /etc/shadow")
-        end
+    assert_nothing_raised("Could not check password") do
+      pass = provider.password
+      assert(pass, "Did not get password for root")
+      assert(pass!= "x", "Password was retrieved from /etc/passwd instead of /etc/shadow")
     end
+  end
 end
 
 

data/test/ral/type/cron.rb

@@ -7,486 +7,499 @@ require 'puppettest'
 # Test cron job creation, modification, and destruction
 
 class TestCron < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def setup
-        super
+  def setup
+    super
 
-        setme()
+    setme
 
-        @crontype = Puppet::Type.type(:cron)
-        @provider = @crontype.defaultprovider
-        if @provider.respond_to?(:filetype=)
-            @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        end
-        @crontype = Puppet::Type.type(:cron)
+    @crontype = Puppet::Type.type(:cron)
+    @provider = @crontype.defaultprovider
+    if @provider.respond_to?(:filetype=)
+      @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
     end
+    @crontype = Puppet::Type.type(:cron)
+  end
 
-    def teardown
-        super
-        @crontype.defaultprovider = nil
-    end
+  def teardown
+    super
+    @crontype.defaultprovider = nil
+  end
 
-    def eachprovider
-        @crontype.suitableprovider.each do |provider|
-            yield provider
-        end
+  def eachprovider
+    @crontype.suitableprovider.each do |provider|
+      yield provider
     end
-
-    # Back up the user's existing cron tab if they have one.
-    def cronback
-        tab = nil
-        assert_nothing_raised {
-            tab = Puppet::Type.type(:cron).filetype.read(@me)
-        }
-
-        if $? == 0
-            @currenttab = tab
-        else
-            @currenttab = nil
-        end
+  end
+
+  # Back up the user's existing cron tab if they have one.
+  def cronback
+    tab = nil
+    assert_nothing_raised {
+      tab = Puppet::Type.type(:cron).filetype.read(@me)
+    }
+
+    @currenttab = $CHILD_STATUS == 0 ? tab : nil
+  end
+
+  # Restore the cron tab to its original form.
+  def cronrestore
+    assert_nothing_raised {
+      if @currenttab
+        @crontype.filetype.new(@me).write(@currenttab)
+      else
+        @crontype.filetype.new(@me).remove
+      end
+    }
+  end
+
+  # Create a cron job with all fields filled in.
+  def mkcron(name, addargs = true)
+    cron = nil
+    command = "date > #{tmpdir()}/crontest#{name}"
+    args = nil
+    if addargs
+      args = {
+        :command => command,
+        :name => name,
+        :user => @me,
+        :minute => rand(59),
+        :month => "1",
+        :monthday => "1",
+        :hour => "1"
+      }
+    else
+      args = {:command => command, :name => name}
     end
+    assert_nothing_raised {
+      cron = @crontype.new(args)
+    }
 
-    # Restore the cron tab to its original form.
-    def cronrestore
-        assert_nothing_raised {
-            if @currenttab
-                @crontype.filetype.new(@me).write(@currenttab)
-            else
-                @crontype.filetype.new(@me).remove
-            end
-        }
-    end
+    cron
+  end
 
-    # Create a cron job with all fields filled in.
-    def mkcron(name, addargs = true)
-        cron = nil
-        command = "date > %s/crontest%s" % [tmpdir(), name]
-        args = nil
-        if addargs
-            args = {
-                :command => command,
-                :name => name,
-                :user => @me,
-                :minute => rand(59),
-                :month => "1",
-                :monthday => "1",
-                :hour => "1"
-            }
-        else
-            args = {:command => command, :name => name}
-        end
-        assert_nothing_raised {
-            cron = @crontype.new(args)
-        }
+  # Run the cron through its paces -- install it then remove it.
+  def cyclecron(cron)
+    obj = Puppet::Type::Cron.cronobj(@me)
 
-        return cron
-    end
+    text = obj.read
+    name = cron.name
+    comp = mk_catalog(name, cron)
 
-    # Run the cron through its paces -- install it then remove it.
-    def cyclecron(cron)
-        obj = Puppet::Type::Cron.cronobj(@me)
+    assert_events([:cron_created], comp)
+    cron.provider.class.prefetch
+    currentvalue = cron.retrieve
 
-        text = obj.read
-        name = cron.name
-        comp = mk_catalog(name, cron)
+    assert(cron.insync?(currentvalue), "Cron is not in sync")
 
-        assert_events([:cron_created], comp)
-        cron.provider.class.prefetch
-        currentvalue = cron.retrieve
+    assert_events([], comp)
 
-        assert(cron.insync?(currentvalue), "Cron is not in sync")
+    curtext = obj.read
+    text.split("\n").each do |line|
+      assert(curtext.include?(line), "Missing '#{line}'")
+    end
+    obj = Puppet::Type::Cron.cronobj(@me)
 
-        assert_events([], comp)
+    cron[:ensure] = :absent
 
-        curtext = obj.read
-        text.split("\n").each do |line|
-            assert(curtext.include?(line), "Missing '%s'" % line)
-        end
-        obj = Puppet::Type::Cron.cronobj(@me)
+    assert_events([:cron_removed], comp)
 
-        cron[:ensure] = :absent
+    cron.provider.class.prefetch
+    currentvalue = cron.retrieve
 
-        assert_events([:cron_removed], comp)
+    assert(cron.insync?(currentvalue), "Cron is not in sync")
+    assert_events([], comp)
+  end
 
-        cron.provider.class.prefetch
-        currentvalue = cron.retrieve
+  # Test that a cron job with spaces at the end doesn't get rewritten
+  def test_trailingspaces
+    eachprovider do |provider|
+      cron = nil
+      # make the cron
+      name = "yaytest"
+      command = "date > /dev/null "
+      assert_nothing_raised {
 
-        assert(cron.insync?(currentvalue), "Cron is not in sync")
-        assert_events([], comp)
-    end
+        cron = @crontype.new(
 
-    # Test that a cron job with spaces at the end doesn't get rewritten
-    def test_trailingspaces
-        eachprovider do |provider|
-            cron = nil
-            # make the cron
-            name = "yaytest"
-            command = "date > /dev/null "
-            assert_nothing_raised {
-                cron = @crontype.new(
-                    :name => name,
-                    :command => "date > /dev/null ",
-                    :month => "May",
-                    :user => @me
-                )
-            }
-            property = cron.send(:property, :command)
-            cron.provider.command = command
-            cron.provider.ensure = :present
-            cron.provider.user = @me
-            cron.provider.month = ["4"]
-            cron.provider.class.prefetch
-            currentvalue = cron.retrieve
-
-            currentvalue.each do |prop, value|
-                # We're only interested in comparing the command.
-                next unless prop.name.to_s == "command"
-                assert(prop.insync?(value), "Property %s is not considered in sync with value %s" % [prop.name, value.inspect])
-            end
-        end
+          :name => name,
+          :command => "date > /dev/null ",
+          :month => "May",
+
+          :user => @me
+        )
+      }
+      property = cron.send(:property, :command)
+      cron.provider.command = command
+      cron.provider.ensure = :present
+      cron.provider.user = @me
+      cron.provider.month = ["4"]
+      cron.provider.class.prefetch
+      currentvalue = cron.retrieve
+      assert(cron.parameter(:command).insync?(currentvalue[:command]), "Property :command is not considered in sync with value #{currentvalue[:command]}")
     end
+  end
 
-    def test_makeandretrievecron
-        %w{storeandretrieve a-name another-name more_naming SomeName}.each do |name|
-            cron = mkcron(name)
-            catalog = mk_catalog(name, cron)
-            trans = assert_events([:cron_created], catalog, name)
+  def test_makeandretrievecron
+    %w{storeandretrieve a-name another-name more_naming SomeName}.each do |name|
+      cron = mkcron(name)
+      catalog = mk_catalog(name, cron)
+      trans = assert_events([:cron_created], catalog, name)
 
-            cron.provider.class.prefetch
-            cron = nil
+      cron.provider.class.prefetch
+      cron = nil
 
-            assert(cron = catalog.resource(:cron, name), "Could not retrieve named cron")
-            assert_instance_of(Puppet::Type.type(:cron), cron)
-        end
+      assert(cron = catalog.resource(:cron, name), "Could not retrieve named cron")
+      assert_instance_of(Puppet::Type.type(:cron), cron)
     end
-
-    # Do input validation testing on all of the parameters.
-    def test_arguments
-        values = {
-            :monthday => {
-                :valid => [ 1, 13, "1" ],
-                :invalid => [ -1, 0, 32 ]
-            },
-            :weekday => {
-                :valid => [ 0, 3, 6, "1", "tue", "wed",
-                    "Wed", "MOnday", "SaTurday" ],
-                :invalid => [ -1, 8, "13", "tues", "teusday", "thurs" ]
-            },
-            :hour => {
-                :valid => [ 0, 21, 23 ],
-                :invalid => [ -1, 24 ]
-            },
-            :minute => {
-                :valid => [ 0, 34, 59 ],
-                :invalid => [ -1, 60 ]
-            },
-            :month => {
-                :valid => [ 1, 11, 12, "mar", "March", "apr", "October", "DeCeMbEr" ],
-                :invalid => [ -1, 0, 13, "marc", "sept" ]
+  end
+
+  # Do input validation testing on all of the parameters.
+  def test_arguments
+    values = {
+      :monthday => {
+        :valid => [ 1, 13, "1" ],
+        :invalid => [ -1, 0, 32 ]
+      },
+      :weekday => {
+        :valid => [ 0, 3, 6, "1", "tue", "wed",
+          "Wed", "MOnday", "SaTurday" ],
+        :invalid => [ -1, 8, "13", "tues", "teusday", "thurs" ]
+      },
+      :hour => {
+        :valid => [ 0, 21, 23 ],
+        :invalid => [ -1, 24 ]
+      },
+      :minute => {
+        :valid => [ 0, 34, 59 ],
+        :invalid => [ -1, 60 ]
+      },
+      :month => {
+        :valid => [ 1, 11, 12, "mar", "March", "apr", "October", "DeCeMbEr" ],
+        :invalid => [ -1, 0, 13, "marc", "sept" ]
+      }
+    }
+
+    cron = mkcron("valtesting")
+    values.each { |param, hash|
+      # We have to test the valid ones first, because otherwise the
+      # property will fail to create at all.
+      [:valid, :invalid].each { |type|
+        hash[type].each { |value|
+          case type
+          when :valid
+            assert_nothing_raised {
+              cron[param] = value
             }
-        }
 
-        cron = mkcron("valtesting")
-        values.each { |param, hash|
-            # We have to test the valid ones first, because otherwise the
-            # property will fail to create at all.
-            [:valid, :invalid].each { |type|
-                hash[type].each { |value|
-                    case type
-                    when :valid
-                        assert_nothing_raised {
-                            cron[param] = value
-                        }
-
-                        if value.is_a?(Integer)
-                            assert_equal([value.to_s], cron.should(param),
-                                "Cron value was not set correctly")
-                        end
-                    when :invalid
-                        assert_raise(Puppet::Error, "%s is incorrectly a valid %s" %
-                            [value, param]) {
-                            cron[param] = value
-                        }
-                    end
-
-                    if value.is_a?(Integer)
-                        value = value.to_s
-                        redo
-                    end
-                }
+            assert_equal([value.to_s], cron.should(param), "Cron value was not set correctly") if value.is_a?(Integer)
+          when :invalid
+            assert_raise(Puppet::Error, "#{value} is incorrectly a valid #{param}") {
+              cron[param] = value
             }
+          end
+
+          if value.is_a?(Integer)
+            value = value.to_s
+            redo
+          end
         }
-    end
+      }
+    }
+  end
 
-    # Verify that comma-separated numbers are not resulting in rewrites
-    def test_comma_separated_vals_work
-        eachprovider do |provider|
-            cron = nil
-            assert_nothing_raised {
-                cron = @crontype.new(
-                    :command => "/bin/date > /dev/null",
-                    :minute => [0, 30],
-                    :name => "crontest",
-                    :provider => provider.name
-                )
-            }
+  # Verify that comma-separated numbers are not resulting in rewrites
+  def test_comma_separated_vals_work
+    eachprovider do |provider|
+      cron = nil
+      assert_nothing_raised {
+
+        cron = @crontype.new(
 
+          :command => "/bin/date > /dev/null",
+          :minute => [0, 30],
+          :name => "crontest",
+
+          :provider => provider.name
+        )
+      }
 
-            cron.provider.ensure = :present
-            cron.provider.command = '/bin/date > /dev/null'
-            cron.provider.minute = %w{0 30}
-            cron.provider.class.prefetch
-            currentvalue = cron.retrieve
 
-            currentvalue.each do |prop, value|
-                # We're only interested in comparing minutes.
-                next unless prop.name.to_s == "minute"
-                assert(prop.insync?(value), "Property %s is not considered in sync with value %s" % [prop.name, value.inspect])
-            end
-        end
+      cron.provider.ensure = :present
+      cron.provider.command = '/bin/date > /dev/null'
+      cron.provider.minute = %w{0 30}
+      cron.provider.class.prefetch
+      currentvalue = cron.retrieve
+
+      currentvalue.each do |name, value|
+        # We're only interested in comparing minutes.
+        next unless name.to_s == "minute"
+        assert(cron.parameter(name).insync?(value), "Property #{name} is not considered in sync with value #{value.inspect}")
+      end
     end
+  end
 
-    def test_fieldremoval
-        cron = nil
-        assert_nothing_raised {
-            cron = @crontype.new(
-                :command => "/bin/date > /dev/null",
-                :minute => [0, 30],
-                :name => "crontest",
-                :provider => :crontab
-            )
-        }
+  def test_fieldremoval
+    cron = nil
+    assert_nothing_raised {
 
-        assert_events([:cron_created], cron)
-        cron.provider.class.prefetch
+      cron = @crontype.new(
 
-        cron[:minute] = :absent
-        assert_events([:cron_changed], cron)
+        :command => "/bin/date > /dev/null",
+        :minute => [0, 30],
+        :name => "crontest",
 
-        current_values = nil
-        assert_nothing_raised {
-            cron.provider.class.prefetch
-            current_values = cron.retrieve
-        }
-        assert_equal(:absent, current_values[cron.property(:minute)])
-    end
+        :provider => :crontab
+      )
+    }
 
-    def test_listing
-        # Make a crontab cron for testing
-        provider = @crontype.provider(:crontab)
-        return unless provider.suitable?
+    assert_events([:cron_created], cron)
+    cron.provider.class.prefetch
 
-        ft = provider.filetype
-        provider.filetype = :ram
-        cleanup { provider.filetype = ft }
+    cron[:minute] = :absent
+    assert_events([:minute_changed], cron)
 
-        setme
-        cron = @crontype.new(:name => "testing",
-            :minute => [0, 30],
-            :command => "/bin/testing",
-            :user => @me
-        )
-        # Write it to our file
-        assert_apply(cron)
-
-        crons = []
-        assert_nothing_raised {
-            @crontype.instances.each do |cron|
-                crons << cron
-            end
-        }
+    current_values = nil
+    assert_nothing_raised {
+      cron.provider.class.prefetch
+      current_values = cron.retrieve
+    }
+    assert_equal(:absent, current_values[cron.property(:minute)])
+  end
+
+  def test_listing
+    # Make a crontab cron for testing
+    provider = @crontype.provider(:crontab)
+    return unless provider.suitable?
 
-        crons.each do |cron|
-            assert_instance_of(@crontype, cron, "Did not receive a real cron object")
-            assert_instance_of(String, cron.value(:user),
-                "Cron user is not a string")
-        end
+    ft = provider.filetype
+    provider.filetype = :ram
+    cleanup { provider.filetype = ft }
+
+    setme
+
+      cron = @crontype.new(
+        :name => "testing",
+      :minute => [0, 30],
+      :command => "/bin/testing",
+
+      :user => @me
+    )
+    # Write it to our file
+    assert_apply(cron)
+
+    crons = []
+    assert_nothing_raised {
+      @crontype.instances.each do |cron|
+        crons << cron
+      end
+    }
+
+    crons.each do |cron|
+      assert_instance_of(@crontype, cron, "Did not receive a real cron object")
+
+        assert_instance_of(
+          String, cron.value(:user),
+
+          "Cron user is not a string")
     end
+  end
 
-    def verify_failonnouser
-        assert_raise(Puppet::Error) do
-            @crontype.retrieve("nosuchuser")
-        end
+  def verify_failonnouser
+    assert_raise(Puppet::Error) do
+      @crontype.retrieve("nosuchuser")
     end
+  end
 
-    def test_divisionnumbers
-        cron = mkcron("divtest")
-        cron[:minute] = "*/5"
+  def test_divisionnumbers
+    cron = mkcron("divtest")
+    cron[:minute] = "*/5"
 
-        assert_apply(cron)
+    assert_apply(cron)
 
-        cron.provider.class.prefetch
-        currentvalue = cron.retrieve
+    cron.provider.class.prefetch
+    currentvalue = cron.retrieve
 
-        assert_equal(["*/5"], currentvalue[cron.property(:minute)])
-    end
+    assert_equal(["*/5"], currentvalue[cron.property(:minute)])
+  end
 
-    def test_ranges
-        cron = mkcron("rangetest")
-        cron[:minute] = "2-4"
+  def test_ranges
+    cron = mkcron("rangetest")
+    cron[:minute] = "2-4"
 
-        assert_apply(cron)
+    assert_apply(cron)
 
-        current_values = nil
-        assert_nothing_raised {
-            cron.provider.class.prefetch
-            current_values = cron.retrieve
-        }
+    current_values = nil
+    assert_nothing_raised {
+      cron.provider.class.prefetch
+      current_values = cron.retrieve
+    }
+
+    assert_equal(["2-4"], current_values[cron.property(:minute)])
+  end
 
-        assert_equal(["2-4"], current_values[cron.property(:minute)])
+
+  def provider_set(cron, param, value)
+    unless param =~ /=$/
+      param = "#{param}="
     end
 
+    cron.provider.send(param, value)
+  end
 
-    def provider_set(cron, param, value)
-      unless param =~ /=$/
-        param = "%s=" % param
-      end
+  def test_value
+    cron = mkcron("valuetesting", false)
 
-      cron.provider.send(param, value)
-    end
+    # First, test the normal properties
+    [:minute, :hour, :month].each do |param|
+      cron.newattr(param)
+      property = cron.property(param)
 
-    def test_value
-        cron = mkcron("valuetesting", false)
+      assert(property, "Did not get #{param} property")
 
-        # First, test the normal properties
-        [:minute, :hour, :month].each do |param|
-            cron.newattr(param)
-            property = cron.property(param)
+      assert_nothing_raised {
+        #                property.is = :absent
+        provider_set(cron, param, :absent)
+      }
 
-            assert(property, "Did not get %s property" % param)
+      val = "*"
+      assert_equal(val, cron.value(param))
 
-            assert_nothing_raised {
-#                property.is = :absent
-                 provider_set(cron, param, :absent)
-            }
+      # Make sure arrays work, too
+      provider_set(cron, param, ["1"])
+      assert_equal(%w{1}, cron.value(param))
 
-            val = "*"
-            assert_equal(val, cron.value(param))
+      # Make sure values get comma-joined
+      provider_set(cron, param, %w{2 3})
+      assert_equal(%w{2 3}, cron.value(param))
 
-            # Make sure arrays work, too
-            provider_set(cron, param, ["1"])
-            assert_equal(%w{1}, cron.value(param))
+      # Make sure "should" values work, too
+      cron[param] = "4"
+      assert_equal(%w{4}, cron.value(param))
 
-            # Make sure values get comma-joined
-            provider_set(cron, param, %w{2 3})
-            assert_equal(%w{2 3}, cron.value(param))
+      cron[param] = ["4"]
+      assert_equal(%w{4}, cron.value(param))
 
-            # Make sure "should" values work, too
-            cron[param] = "4"
-            assert_equal(%w{4}, cron.value(param))
+      cron[param] = ["4", "5"]
+      assert_equal(%w{4 5}, cron.value(param))
 
-            cron[param] = ["4"]
-            assert_equal(%w{4}, cron.value(param))
+      provider_set(cron, param, :absent)
+      assert_equal(%w{4 5}, cron.value(param))
+    end
 
-            cron[param] = ["4", "5"]
-            assert_equal(%w{4 5}, cron.value(param))
+    Puppet[:trace] = false
 
-            provider_set(cron, param, :absent)
-            assert_equal(%w{4 5}, cron.value(param))
-        end
+    # Now make sure that :command works correctly
+    cron.delete(:command)
+    cron.newattr(:command)
+    property = cron.property(:command)
 
-        Puppet[:trace] = false
+    assert_nothing_raised {
+      provider_set(cron, :command, :absent)
+    }
 
-        # Now make sure that :command works correctly
-        cron.delete(:command)
-        cron.newattr(:command)
-        property = cron.property(:command)
+    param = :command
+    # Make sure arrays work, too
+    provider_set(cron, param, ["/bin/echo"])
+    assert_equal("/bin/echo", cron.value(param))
 
-        assert_nothing_raised {
-            provider_set(cron, :command, :absent)
-        }
+    # Make sure values are not comma-joined
+    provider_set(cron, param, %w{/bin/echo /bin/test})
+    assert_equal("/bin/echo", cron.value(param))
 
-        param = :command
-        # Make sure arrays work, too
-        provider_set(cron, param, ["/bin/echo"])
-        assert_equal("/bin/echo", cron.value(param))
+    # Make sure "should" values work, too
+    cron[param] = "/bin/echo"
+    assert_equal("/bin/echo", cron.value(param))
 
-        # Make sure values are not comma-joined
-        provider_set(cron, param, %w{/bin/echo /bin/test})
-        assert_equal("/bin/echo", cron.value(param))
+    cron[param] = ["/bin/echo"]
+    assert_equal("/bin/echo", cron.value(param))
 
-        # Make sure "should" values work, too
-        cron[param] = "/bin/echo"
-        assert_equal("/bin/echo", cron.value(param))
+    cron[param] = %w{/bin/echo /bin/test}
+    assert_equal("/bin/echo", cron.value(param))
 
-        cron[param] = ["/bin/echo"]
-        assert_equal("/bin/echo", cron.value(param))
+    provider_set(cron, param, :absent)
+    assert_equal("/bin/echo", cron.value(param))
+  end
 
-        cron[param] = %w{/bin/echo /bin/test}
-        assert_equal("/bin/echo", cron.value(param))
+  def test_multiple_users
+    crons = []
+    users = ["root", nonrootuser.name]
+    users.each do |user|
 
-        provider_set(cron, param, :absent)
-        assert_equal("/bin/echo", cron.value(param))
-    end
+      cron = Puppet::Type.type(:cron).new(
+
+        :name => "testcron-#{user}",
+        :user => user,
+        :command => "/bin/echo",
 
-    def test_multiple_users
-        crons = []
-        users = ["root", nonrootuser.name]
-        users.each do |user|
-            cron = Puppet::Type.type(:cron).new(
-                :name => "testcron-#{user}",
-                :user => user,
-                :command => "/bin/echo",
-                :minute => [0,30]
-            )
-            crons << cron
-
-            assert_equal(cron.should(:user), cron.should(:target),
-                "Target was not set correctly for %s" % user)
-        end
-        provider = crons[0].provider.class
-
-        assert_apply(*crons)
-
-        users.each do |user|
-            users.each do |other|
-                next if user == other
-                text = provider.target_object(other).read
-
-                assert(text !~ /testcron-#{user}/,
-                       "%s's cron job is in %s's tab" %
-                       [user, other])
-            end
-        end
+        :minute => [0,30]
+      )
+      crons << cron
+
+      assert_equal(cron.should(:user), cron.should(:target),
+        "Target was not set correctly for #{user}")
     end
+    provider = crons[0].provider.class
+
+    assert_apply(*crons)
+
+    users.each do |user|
+      users.each do |other|
+        next if user == other
+        text = provider.target_object(other).read
+
 
-    # Make sure the user stuff defaults correctly.
-    def test_default_user
-        crontab = @crontype.provider(:crontab)
-        if crontab.suitable?
-            inst = @crontype.new(
-                :name => "something", :command => "/some/thing",
-                :provider => :crontab)
-            assert_equal(Etc.getpwuid(Process.uid).name, inst.should(:user),
-                "user did not default to current user with crontab")
-            assert_equal(Etc.getpwuid(Process.uid).name, inst.should(:target),
-                "target did not default to current user with crontab")
-
-            # Now make a new cron with a user, and make sure it gets copied
-            # over
-            inst = @crontype.new(:name => "yay", :command => "/some/thing",
-                :user => "bin", :provider => :crontab)
-            assert_equal("bin", inst.should(:target),
-                "target did not default to user with crontab")
-        end
+          assert(
+            text !~ /testcron-#{user}/,
+
+            "#{user}'s cron job is in #{other}'s tab")
+      end
     end
+  end
+
+  # Make sure the user stuff defaults correctly.
+  def test_default_user
+    crontab = @crontype.provider(:crontab)
+    if crontab.suitable?
+
+      inst = @crontype.new(
+
+        :name => "something", :command => "/some/thing",
+
+        :provider => :crontab)
+      assert_equal(Etc.getpwuid(Process.uid).name, inst.should(:user), "user did not default to current user with crontab")
+      assert_equal(Etc.getpwuid(Process.uid).name, inst.should(:target), "target did not default to current user with crontab")
+
+      # Now make a new cron with a user, and make sure it gets copied
+      # over
+
+        inst = @crontype.new(
+          :name => "yay", :command => "/some/thing",
 
-    # #705 - make sure extra spaces don't screw things up
-    def test_spaces_in_command
-        string = "echo   multiple  spaces"
-        cron = @crontype.new(:name => "space testing", :command => string)
-        assert_apply(cron)
+          :user => "bin", :provider => :crontab)
 
-        cron = @crontype.new(:name => "space testing", :command => string)
+            assert_equal(
+              "bin", inst.should(:target),
 
-        # Now make sure that it's correctly in sync
-        cron.provider.class.prefetch("testing" => cron)
-        properties = cron.retrieve
-        command, result = properties.find { |prop, value| prop.name == :command }
-        assert_equal(string, result, "Cron did not pick up extra spaces in command")
-        assert(command.insync?(string), "Command changed with multiple spaces")
+              "target did not default to user with crontab")
     end
+  end
+
+  # #705 - make sure extra spaces don't screw things up
+  def test_spaces_in_command
+    string = "echo   multiple  spaces"
+    cron = @crontype.new(:name => "space testing", :command => string)
+    assert_apply(cron)
+
+    cron = @crontype.new(:name => "space testing", :command => string)
+
+    # Now make sure that it's correctly in sync
+    cron.provider.class.prefetch("testing" => cron)
+    properties = cron.retrieve
+    assert_equal(string, properties[:command], "Cron did not pick up extra spaces in command")
+    assert(cron.parameter(:command).insync?(properties[:command]), "Command changed with multiple spaces")
+  end
 end