puppet 0.25.5 → 2.6.0

data/test/ral/providers/cron/crontab.rb

@@ -7,626 +7,642 @@ require 'mocha'
 require 'puppettest/fileparsing'
 
 class TestCronParsedProvider < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::FileParsing
-
-
-    FIELDS = {
-        :crontab => %w{command minute hour month monthday weekday}.collect { |o| o.intern },
-        :freebsd_special => %w{special command}.collect { |o| o.intern },
-        :environment => [:line],
-        :blank => [:line],
-        :comment => [:line],
-    }
-
-    # These are potentially multi-line records; there's no one-to-one map, but they model
-    # a full cron job.  These tests assume individual record types will always be correctly
-    # parsed, so all they
-    def sample_crons
-        unless defined? @sample_crons
-            @sample_crons = YAML.load(File.read(File.join(@crondir, "crontab_collections.yaml")))
-        end
-        @sample_crons
+  include PuppetTest
+  include PuppetTest::FileParsing
+
+
+  FIELDS = {
+    :crontab => %w{command minute hour month monthday weekday}.collect { |o| o.intern },
+    :freebsd_special => %w{special command}.collect { |o| o.intern },
+    :environment => [:line],
+    :blank => [:line],
+    :comment => [:line],
+  }
+
+  # These are potentially multi-line records; there's no one-to-one map, but they model
+  # a full cron job.  These tests assume individual record types will always be correctly
+  # parsed, so all they
+  def sample_crons
+    @sample_crons ||= YAML.load(File.read(File.join(@crondir, "crontab_collections.yaml")))
+  end
+
+  # These are simple lines that can appear in the files; there is a one to one
+  # mapping between records and lines.  We have plenty of redundancy here because
+  # we use these records to build up our complex, multi-line cron jobs below.
+  def sample_records
+    @sample_records ||= YAML.load(File.read(File.join(@crondir, "crontab_sample_records.yaml")))
+  end
+
+  def setup
+    super
+    @type = Puppet::Type.type(:cron)
+    @provider = @type.provider(:crontab)
+    @provider.initvars
+    @crondir = datadir(File.join(%w{providers cron}))
+
+    @oldfiletype = @provider.filetype
+  end
+
+  def teardown
+    Puppet::Util::FileType.filetype(:ram).clear
+    @provider.clear
+    super
+  end
+
+  # Make sure a cron job matches up.  Any non-passed fields are considered absent.
+  def assert_cron_equal(msg, cron, options)
+    assert_instance_of(@provider, cron, "not an instance of provider in #{msg}")
+    options.each do |param, value|
+      assert_equal(value, cron.send(param), "#{param} was not equal in #{msg}")
     end
-
-    # These are simple lines that can appear in the files; there is a one to one
-    # mapping between records and lines.  We have plenty of redundancy here because
-    # we use these records to build up our complex, multi-line cron jobs below.
-    def sample_records
-        unless defined? @sample_records
-            @sample_records = YAML.load(File.read(File.join(@crondir, "crontab_sample_records.yaml")))
-        end
-        @sample_records
+    %w{command environment minute hour month monthday weekday}.each do |var|
+      assert_equal(:absent, cron.send(var), "#{var} was not parsed absent in #{msg}") unless options.include?(var.intern)
+    end
+  end
+
+  # Make sure a cron record matches.  This only works for crontab records.
+  def assert_record_equal(msg, record, options)
+    raise ArgumentError, "You must pass the required record type" unless options.include?(:record_type)
+    assert_instance_of(Hash, record, "not an instance of a hash in #{msg}")
+    options.each do |param, value|
+      assert_equal(value, record[param], "#{param} was not equal in #{msg}")
+    end
+    FIELDS[record[:record_type]].each do |var|
+      assert_equal(:absent, record[var], "#{var} was not parsed absent in #{msg}") unless options.include?(var)
     end
+  end
 
-    def setup
-        super
-        @type = Puppet::Type.type(:cron)
-        @provider = @type.provider(:crontab)
-        @provider.initvars
-        @crondir = datadir(File.join(%w{providers cron}))
+  def assert_header(file)
+    header = []
+    file.gsub! /^(# HEADER: .+$)\n/ do
+      header << $1
+      ''
+    end
+    assert_equal(4, header.length, "Did not get four header lines")
+  end
+
+  # This handles parsing every possible iteration of cron records.  Note that this is only
+  # single-line stuff and doesn't include multi-line values (e.g., with names and/or envs).
+  # Those have separate tests.
+  def test_parse_line
+    # First just do each sample record one by one
+    sample_records.each do |name, options|
+      result = nil
+      assert_nothing_raised("Could not parse #{name}: '#{options[:text]}'") do
+        result = @provider.parse_line(options[:text])
+      end
+      assert_record_equal("record for #{name}", result, options[:record])
+    end
 
-        @oldfiletype = @provider.filetype
+    # Then do them all at once.
+    records = []
+    text = ""
+    sample_records.each do |name, options|
+      records << options[:record]
+      text += options[:text] + "\n"
     end
 
-    def teardown
-        Puppet::Util::FileType.filetype(:ram).clear
-        @provider.clear
-        super
+    result = nil
+    assert_nothing_raised("Could not match all records in one file") do
+      result = @provider.parse(text)
     end
 
-    # Make sure a cron job matches up.  Any non-passed fields are considered absent.
-    def assert_cron_equal(msg, cron, options)
-        assert_instance_of(@provider, cron, "not an instance of provider in %s" % msg)
-        options.each do |param, value|
-            assert_equal(value, cron.send(param), "%s was not equal in %s" % [param, msg])
-        end
-        %w{command environment minute hour month monthday weekday}.each do |var|
-            unless options.include?(var.intern)
-                assert_equal(:absent, cron.send(var), "%s was not parsed absent in %s" % [var, msg])
-            end
-        end
+    records.zip(result).each do |should, record|
+      assert_record_equal("record for #{should.inspect} in full match", record, should)
+    end
+  end
+
+  # Here we test that each record generates to the correct text.
+  def test_generate_line
+    # First just do each sample record one by one
+    sample_records.each do |name, options|
+      result = nil
+      assert_nothing_raised("Could not generate #{name}: '#{options[:record]}'") do
+        result = @provider.to_line(options[:record])
+      end
+      assert_equal(options[:text], result, "Did not generate correct text for #{name}")
     end
 
-    # Make sure a cron record matches.  This only works for crontab records.
-    def assert_record_equal(msg, record, options)
-        unless options.include?(:record_type)
-            raise ArgumentError, "You must pass the required record type"
-        end
-        assert_instance_of(Hash, record, "not an instance of a hash in %s" % msg)
-        options.each do |param, value|
-            assert_equal(value, record[param], "%s was not equal in %s" % [param, msg])
-        end
-        FIELDS[record[:record_type]].each do |var|
-            unless options.include?(var)
-                assert_equal(:absent, record[var], "%s was not parsed absent in %s" % [var, msg])
-            end
-        end
+    # Then do them all at once.
+    records = []
+    text = ""
+    sample_records.each do |name, options|
+      records << options[:record]
+      text += options[:text] + "\n"
     end
 
-    def assert_header(file)
-        header = []
-        file.gsub! /^(# HEADER: .+$)\n/ do
-            header << $1
-            ''
-        end
-        assert_equal(4, header.length, "Did not get four header lines")
+    result = nil
+    assert_nothing_raised("Could not match all records in one file") do
+      result = @provider.to_file(records)
     end
 
-    # This handles parsing every possible iteration of cron records.  Note that this is only
-    # single-line stuff and doesn't include multi-line values (e.g., with names and/or envs).
-    # Those have separate tests.
-    def test_parse_line
-        # First just do each sample record one by one
-        sample_records.each do |name, options|
-            result = nil
-            assert_nothing_raised("Could not parse %s: '%s'" % [name, options[:text]]) do
-                result = @provider.parse_line(options[:text])
-            end
-            assert_record_equal("record for %s" % name, result, options[:record])
-        end
+    assert_header(result)
 
-        # Then do them all at once.
-        records = []
-        text = ""
-        sample_records.each do |name, options|
-            records << options[:record]
-            text += options[:text] + "\n"
-        end
+    assert_equal(text, result, "Did not generate correct full crontab")
+  end
 
-        result = nil
-        assert_nothing_raised("Could not match all records in one file") do
-            result = @provider.parse(text)
+  # Test cronjobs that are made up from multiple records.
+  def test_multi_line_cronjobs
+    fulltext = ""
+    all_records = []
+    sample_crons.each do |name, record_names|
+      records = record_names.collect do |record_name|
+        unless record = sample_records[record_name]
+          raise "Could not find sample record #{record_name}"
         end
+        record
+      end
+
+      text = records.collect { |r| r[:text] }.join("\n") + "\n"
+      record_list = records.collect { |r| r[:record] }
+
+      # Add it to our full collection
+      all_records += record_list
+      fulltext += text
+
+      # First make sure we generate each one correctly
+      result = nil
+      assert_nothing_raised("Could not generate multi-line cronjob #{name}") do
+        result = @provider.to_file(record_list)
+      end
+      assert_header(result)
+      assert_equal(text, result, "Did not generate correct text for multi-line cronjob #{name}")
+
+      # Now make sure we parse each one correctly
+      assert_nothing_raised("Could not parse multi-line cronjob #{name}") do
+        result = @provider.parse(text)
+      end
+      record_list.zip(result).each do |should, record|
+        assert_record_equal("multiline cronjob #{name}", record, should)
+      end
+    end
 
-        records.zip(result).each do |should, record|
-            assert_record_equal("record for %s in full match" % should.inspect, record, should)
-        end
+    # Make sure we can generate it all correctly
+    result = nil
+    assert_nothing_raised("Could not generate all multi-line cronjobs") do
+      result = @provider.to_file(all_records)
     end
+    assert_header(result)
+    assert_equal(fulltext, result, "Did not generate correct text for all multi-line cronjobs")
 
-    # Here we test that each record generates to the correct text.
-    def test_generate_line
-        # First just do each sample record one by one
-        sample_records.each do |name, options|
-            result = nil
-            assert_nothing_raised("Could not generate %s: '%s'" % [name, options[:record]]) do
-                result = @provider.to_line(options[:record])
-            end
-            assert_equal(options[:text], result, "Did not generate correct text for %s" % name)
+    # Now make sure we parse them all correctly
+    assert_nothing_raised("Could not parse multi-line cronjobs") do
+      result = @provider.parse(fulltext)
+    end
+    all_records.zip(result).each do |should, record|
+      assert_record_equal("multiline cronjob %s", record, should)
+    end
+  end
+
+  # Take our sample files, and make sure we can entirely parse them,
+  # then that we can generate them again and we get the same data.
+  def test_parse_and_generate_sample_files
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    crondir = datadir(File.join(%w{providers cron}))
+    files = Dir.glob("#{crondir}/crontab.*")
+
+    setme
+    @provider.default_target = @me
+    target = @provider.target_object(@me)
+    files.each do |file|
+      str = args = nil
+      assert_nothing_raised("could not load #{file}") do
+        str, args = YAML.load(File.read(file))
+      end
+
+      # Stupid old yaml
+      args.each do |hash|
+        hash.each do |param, value|
+          if param.is_a?(String) and param =~ /^:/
+            hash.delete(param)
+            param = param.sub(/^:/,'').intern
+            hash[param] = value
+          end
+
+          if value.is_a?(String) and value =~ /^:/
+            value = value.sub(/^:/,'').intern
+            hash[param] = value
+          end
         end
-
-        # Then do them all at once.
-        records = []
-        text = ""
-        sample_records.each do |name, options|
-            records << options[:record]
-            text += options[:text] + "\n"
+      end
+      target.write(str)
+      assert_nothing_raised("could not parse #{file}") do
+        @provider.prefetch
+      end
+      records = @provider.send(:instance_variable_get, "@records")
+
+      args.zip(records) do |should, sis|
+        # Make the values a bit more equal.
+        should[:target] = @me
+        should[:ensure] = :present
+        #should[:environment] ||= []
+        should[:on_disk] = true
+        is = sis.dup
+        sis.dup.each do |p,v|
+          is.delete(p) if v == :absent
         end
 
-        result = nil
-        assert_nothing_raised("Could not match all records in one file") do
-            result = @provider.to_file(records)
-        end
+              assert_equal(
+        should, is,
+        
+          "Did not parse #{file} correctly")
+      end
 
-        assert_header(result)
+      assert_nothing_raised("could not generate #{file}") do
+        @provider.flush_target(@me)
+      end
 
-        assert_equal(text, result, "Did not generate correct full crontab")
+      assert_equal(str, target.read, "#{file} changed")
+      @provider.clear
     end
+  end
+
+  # A simple test to see if we can load the cron from disk.
+  def test_load
+    setme
+    records = nil
+    assert_nothing_raised {
+      records = @provider.retrieve(@me)
+    }
+    assert_instance_of(Array, records, "did not get correct response")
+  end
+
+  # Test that a cron job turns out as expected, by creating one and generating
+  # it directly
+  def test_simple_to_cron
+    # make the cron
+    setme
+
+    name = "yaytest"
+    args = {:name => name,
+      :command => "date > /dev/null",
+      :minute => "30",
+      :user => @me,
+      :record_type => :crontab
+    }
+    # generate the text
+    str = nil
+    assert_nothing_raised {
+      str = @provider.to_line(args)
+    }
 
-    # Test cronjobs that are made up from multiple records.
-    def test_multi_line_cronjobs
-        fulltext = ""
-        all_records = []
-        sample_crons.each do |name, record_names|
-            records = record_names.collect do |record_name|
-                unless record = sample_records[record_name]
-                    raise "Could not find sample record %s" % record_name
-                end
-                record
-            end
-
-            text = records.collect { |r| r[:text] }.join("\n") + "\n"
-            record_list = records.collect { |r| r[:record] }
-
-            # Add it to our full collection
-            all_records += record_list
-            fulltext += text
-
-            # First make sure we generate each one correctly
-            result = nil
-            assert_nothing_raised("Could not generate multi-line cronjob %s" % [name]) do
-                result = @provider.to_file(record_list)
-            end
-            assert_header(result)
-            assert_equal(text, result, "Did not generate correct text for multi-line cronjob %s" % name)
-
-            # Now make sure we parse each one correctly
-            assert_nothing_raised("Could not parse multi-line cronjob %s" % [name]) do
-                result = @provider.parse(text)
-            end
-            record_list.zip(result).each do |should, record|
-                assert_record_equal("multiline cronjob %s" % name, record, should)
-            end
-        end
 
-        # Make sure we can generate it all correctly
-        result = nil
-        assert_nothing_raised("Could not generate all multi-line cronjobs") do
-            result = @provider.to_file(all_records)
-        end
-        assert_header(result)
-        assert_equal(fulltext, result, "Did not generate correct text for all multi-line cronjobs")
+          assert_equal(
+        "# Puppet Name: #{name}\n30 * * * * date > /dev/null", str,
+        
+      "Cron did not generate correctly")
+  end
+
+  # Test that comments are correctly retained
+  def test_retain_comments
+    str = "# this is a comment\n#and another comment\n"
+    user = "fakeuser"
+    records = nil
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    target = @provider.target_object(user)
+    target.write(str)
+    assert_nothing_raised {
+      @provider.prefetch
+    }
 
-        # Now make sure we parse them all correctly
-        assert_nothing_raised("Could not parse multi-line cronjobs") do
-            result = @provider.parse(fulltext)
-        end
-        all_records.zip(result).each do |should, record|
-            assert_record_equal("multiline cronjob %s", record, should)
-        end
-    end
+    assert_nothing_raised {
+      newstr = @provider.flush_target(user)
+      assert(target.read.include?(str), "Comments were lost")
+    }
+  end
 
-    # Take our sample files, and make sure we can entirely parse them,
-    # then that we can generate them again and we get the same data.
-    def test_parse_and_generate_sample_files
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        crondir = datadir(File.join(%w{providers cron}))
-        files = Dir.glob("%s/crontab.*" % crondir)
-
-        setme
-        @provider.default_target = @me
-        target = @provider.target_object(@me)
-        files.each do |file|
-            str = args = nil
-            assert_nothing_raised("could not load %s" % file) do
-                str, args = YAML.load(File.read(file))
-            end
-
-            # Stupid old yaml
-            args.each do |hash|
-                hash.each do |param, value|
-                    if param.is_a?(String) and param =~ /^:/
-                        hash.delete(param)
-                        param = param.sub(/^:/,'').intern
-                        hash[param] = value
-                    end
-
-                    if value.is_a?(String) and value =~ /^:/
-                        value = value.sub(/^:/,'').intern
-                        hash[param] = value
-                    end
-                end
-            end
-            target.write(str)
-            assert_nothing_raised("could not parse %s" % file) do
-                @provider.prefetch
-            end
-            records = @provider.send(:instance_variable_get, "@records")
-
-            args.zip(records) do |should, sis|
-                # Make the values a bit more equal.
-                should[:target] = @me
-                should[:ensure] = :present
-                #should[:environment] ||= []
-                should[:on_disk] = true
-                is = sis.dup
-                sis.dup.each do |p,v|
-                    is.delete(p) if v == :absent
-                end
-                assert_equal(should, is,
-                    "Did not parse %s correctly" % file)
-            end
-
-            assert_nothing_raised("could not generate %s" % file) do
-                @provider.flush_target(@me)
-            end
-
-            assert_equal(str, target.read, "%s changed" % file)
-            @provider.clear
-        end
-    end
+  def test_simpleparsing
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    text = "5 1,2 * 1 0 /bin/echo funtest"
 
-    # A simple test to see if we can load the cron from disk.
-    def test_load
-        setme()
-        records = nil
-        assert_nothing_raised {
-            records = @provider.retrieve(@me)
-        }
-        assert_instance_of(Array, records, "did not get correct response")
-    end
+    records = nil
+    assert_nothing_raised {
+      records = @provider.parse(text)
+    }
 
-    # Test that a cron job turns out as expected, by creating one and generating
-    # it directly
-    def test_simple_to_cron
-        # make the cron
-        setme()
-
-        name = "yaytest"
-        args = {:name => name,
-            :command => "date > /dev/null",
-            :minute => "30",
-            :user => @me,
-            :record_type => :crontab
-        }
-        # generate the text
-        str = nil
-        assert_nothing_raised {
-            str = @provider.to_line(args)
-        }
-
-        assert_equal("# Puppet Name: #{name}\n30 * * * * date > /dev/null", str,
-            "Cron did not generate correctly")
-    end
+    should = {
+      :minute => %w{5},
+      :hour => %w{1 2},
+      :monthday => :absent,
+      :month => %w{1},
+      :weekday => %w{0},
+      :command => "/bin/echo funtest"
+    }
 
-    # Test that comments are correctly retained
-    def test_retain_comments
-        str = "# this is a comment\n#and another comment\n"
-        user = "fakeuser"
-        records = nil
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        target = @provider.target_object(user)
-        target.write(str)
-        assert_nothing_raised {
-            @provider.prefetch
-        }
-
-        assert_nothing_raised {
-            newstr = @provider.flush_target(user)
-            assert(target.read.include?(str), "Comments were lost")
-        }
-    end
+    is = records.shift
+    assert(is, "Did not get record")
 
-    def test_simpleparsing
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        text = "5 1,2 * 1 0 /bin/echo funtest"
-
-        records = nil
-        assert_nothing_raised {
-            records = @provider.parse(text)
-        }
-
-        should = {
-            :minute => %w{5},
-            :hour => %w{1 2},
-            :monthday => :absent,
-            :month => %w{1},
-            :weekday => %w{0},
-            :command => "/bin/echo funtest"
-        }
-
-        is = records.shift
-        assert(is, "Did not get record")
-
-        should.each do |p, v|
-            assert_equal(v, is[p], "did not parse %s correctly" % p)
-        end
+    should.each do |p, v|
+      assert_equal(v, is[p], "did not parse #{p} correctly")
     end
+  end
 
-    # Make sure we can create a cron in an empty tab.
-    # LAK:FIXME This actually modifies the user's crontab,
-    # which is pretty heinous.
-    def test_mkcron_if_empty
-        setme
-        @provider.filetype = @oldfiletype
-
-        records = @provider.retrieve(@me)
+  # Make sure we can create a cron in an empty tab.
+  # LAK:FIXME This actually modifies the user's crontab,
+  # which is pretty heinous.
+  def test_mkcron_if_empty
+    setme
+    @provider.filetype = @oldfiletype
 
-        target = @provider.target_object(@me)
+    records = @provider.retrieve(@me)
 
-        cleanup do
-            if records.length == 0
-                target.remove
-            else
-                target.write(@provider.to_file(records))
-            end
-        end
+    target = @provider.target_object(@me)
 
-        # Now get rid of it
-        assert_nothing_raised("Could not remove cron tab") do
-            target.remove
-        end
+    cleanup do
+      if records.length == 0
+        target.remove
+      else
+        target.write(@provider.to_file(records))
+      end
+    end
 
-        @provider.flush :target => @me, :command => "/do/something",
-            :record_type => :crontab
-        created = @provider.retrieve(@me)
-        assert(created.detect { |r| r[:command] == "/do/something" },
-            "Did not create cron tab")
+    # Now get rid of it
+    assert_nothing_raised("Could not remove cron tab") do
+      target.remove
     end
 
-    # Make sure we correctly bidirectionally parse things.
-    def test_records_and_strings
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        setme
-
-        target = @provider.target_object(@me)
-
-        [
-            "* * * * * /some/command",
-            "0,30 * * * * /some/command",
-            "0-30 * * * * /some/command",
-            "# Puppet Name: name\n0-30 * * * * /some/command",
-            "# Puppet Name: name\nVAR=VALUE\n0-30 * * * * /some/command",
-            "# Puppet Name: name\nVAR=VALUE\nC=D\n0-30 * * * * /some/command",
-            "0 * * * * /some/command"
-        ].each do |str|
-            @provider.initvars
-            str += "\n"
-            target.write(str)
-            assert_equal(str, target.read,
-                "Did not write correctly")
-            assert_nothing_raised("Could not prefetch with %s" % str.inspect) do
-                @provider.prefetch
-            end
-            assert_nothing_raised("Could not flush with %s" % str.inspect) do
-                @provider.flush_target(@me)
-            end
-
-            assert_equal(str, target.read,
-                "Changed in read/write")
-
-            @provider.clear
-        end
+    @provider.flush :target => @me, :command => "/do/something",
+      :record_type => :crontab
+    created = @provider.retrieve(@me)
+    assert(created.detect { |r| r[:command] == "/do/something" }, "Did not create cron tab")
+  end
+
+  # Make sure we correctly bidirectionally parse things.
+  def test_records_and_strings
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    setme
+
+    target = @provider.target_object(@me)
+
+    [
+      "* * * * * /some/command",
+      "0,30 * * * * /some/command",
+      "0-30 * * * * /some/command",
+      "# Puppet Name: name\n0-30 * * * * /some/command",
+      "# Puppet Name: name\nVAR=VALUE\n0-30 * * * * /some/command",
+      "# Puppet Name: name\nVAR=VALUE\nC=D\n0-30 * * * * /some/command",
+      "0 * * * * /some/command"
+    ].each do |str|
+      @provider.initvars
+      str += "\n"
+      target.write(str)
+
+            assert_equal(
+        str, target.read,
+        
+        "Did not write correctly")
+      assert_nothing_raised("Could not prefetch with #{str.inspect}") do
+        @provider.prefetch
+      end
+      assert_nothing_raised("Could not flush with #{str.inspect}") do
+        @provider.flush_target(@me)
+      end
+
+
+            assert_equal(
+        str, target.read,
+        
+        "Changed in read/write")
+
+      @provider.clear
     end
+  end
 
-    # Test that a specified cron job will be matched against an existing job
-    # with no name, as long as all fields match
-    def test_matchcron
-        mecron = "0,30 * * * * date
+  # Test that a specified cron job will be matched against an existing job
+  # with no name, as long as all fields match
+  def test_matchcron
+    mecron = "0,30 * * * * date
 
-        * * * * * funtest
-        # a comment
-        0,30 * * 1 * date
-        "
+    * * * * * funtest
+    # a comment
+    0,30 * * 1 * date
+    "
 
-        youcron = "0,30 * * * * date
+    youcron = "0,30 * * * * date
 
-        * * * * * yaytest
-        # a comment
-        0,30 * * 1 * fooness
-        "
-        setme
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        you = "you"
+    * * * * * yaytest
+    # a comment
+    0,30 * * 1 * fooness
+    "
+    setme
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    you = "you"
 
-        # Write the same tab to multiple targets
-        @provider.target_object(@me).write(mecron.gsub(/^\s+/, ''))
-        @provider.target_object(you).write(youcron.gsub(/^\s+/, ''))
+    # Write the same tab to multiple targets
+    @provider.target_object(@me).write(mecron.gsub(/^\s+/, ''))
+    @provider.target_object(you).write(youcron.gsub(/^\s+/, ''))
 
-        # Now make some crons that should match
-        matchers = [
-            @type.new(
-                :name => "yaycron",
-                :minute => [0, 30],
-                :command => "date",
-                :user => @me
-            ),
-            @type.new(
-                :name => "youtest",
-                :command => "yaytest",
-                :user => you
-            )
-        ]
+    # Now make some crons that should match
+    matchers = [
 
-        nonmatchers = [
-            @type.new(
-                :name => "footest",
-                :minute => [0, 30],
-                :hour => 1,
-                :command => "fooness",
-                :user => @me # wrong target
-            ),
             @type.new(
-                :name => "funtest2",
-                :command => "funtest",
-                :user => you # wrong target for this cron
-            )
-        ]
+                
+        :name => "yaycron",
+        :minute => [0, 30],
+        :command => "date",
+        
+        :user => @me
+      ),
 
-        # Create another cron so we prefetch two of them
-        @type.new(:name => "testing", :minute => 30, :command => "whatever", :user => "you")
+            @type.new(
+                
+        :name => "youtest",
+        :command => "yaytest",
+        
+        :user => you
+      )
+    ]
 
-        assert_nothing_raised("Could not prefetch cron") do
-            @provider.prefetch([matchers, nonmatchers].flatten.inject({}) { |crons, cron| crons[cron.name] = cron; crons })
-        end
+    nonmatchers = [
 
-        matchers.each do |cron|
-            assert_equal(:present, cron.provider.ensure, "Cron %s was not matched" % cron.name)
-            if value = cron.value(:minute) and value == "*"
-                value = :absent
-            end
-            assert_equal(value, cron.provider.minute, "Minutes were not retrieved, so cron was not matched")
-            assert_equal(cron.value(:target), cron.provider.target, "Cron %s was matched from the wrong target" % cron.name)
-        end
+            @type.new(
+                
+        :name => "footest",
+        :minute => [0, 30],
+        :hour => 1,
+        :command => "fooness",
+        
+        :user => @me # wrong target
+      ),
 
-        nonmatchers.each do |cron|
-            assert_equal(:absent, cron.provider.ensure, "Cron %s was incorrectly matched" % cron.name)
-        end
+            @type.new(
+                
+        :name => "funtest2",
+        :command => "funtest",
+        
+        :user => you # wrong target for this cron
+      )
+    ]
+
+    # Create another cron so we prefetch two of them
+    @type.new(:name => "testing", :minute => 30, :command => "whatever", :user => "you")
+
+    assert_nothing_raised("Could not prefetch cron") do
+      @provider.prefetch([matchers, nonmatchers].flatten.inject({}) { |crons, cron| crons[cron.name] = cron; crons })
     end
 
-    def test_data
-        setme
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        target = @provider.target_object(@me)
-        fakedata("data/providers/cron/examples").each do |file|
-            text = File.read(file)
-            target.write(text)
-
-            assert_nothing_raised("Could not parse %s" % file) do
-                @provider.prefetch
-            end
-            # mark the provider modified
-            @provider.modified(@me)
-
-            # and zero the text
-            target.write("")
-
-            result = nil
-            assert_nothing_raised("Could not generate %s" % file) do
-                @provider.flush_target(@me)
-            end
-
-            # Ignore whitespace differences, since those don't affect function.
-            modtext = text.gsub(/[ \t]+/, " ")
-            modtarget = target.read.gsub(/[ \t]+/, " ")
-            assert_equal(modtext, modtarget,
-                "File was not rewritten the same")
-
-            @provider.clear
-        end
+    matchers.each do |cron|
+      assert_equal(:present, cron.provider.ensure, "Cron #{cron.name} was not matched")
+      if value = cron.value(:minute) and value == "*"
+        value = :absent
+      end
+      assert_equal(value, cron.provider.minute, "Minutes were not retrieved, so cron was not matched")
+      assert_equal(cron.value(:target), cron.provider.target, "Cron #{cron.name} was matched from the wrong target")
     end
 
-    # Match freebsd's annoying @daily stuff.
-    def test_match_freebsd_special
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        setme
-
-        target = @provider.target_object(@me)
-
-        [
-            "@daily /some/command",
-            "@daily /some/command more"
-        ].each do |str|
-            @provider.initvars
-            str += "\n"
-            target.write(str)
-            assert_nothing_raised("Could not prefetch with %s" % str.inspect) do
-                @provider.prefetch
-            end
-            records = @provider.send(:instance_variable_get, "@records")
-            records.each do |r|
-                assert_equal(:freebsd_special, r[:record_type],
-                    "Did not create lines as freebsd lines")
-            end
-            assert_nothing_raised("Could not flush with %s" % str.inspect) do
-                @provider.flush_target(@me)
-            end
-
-            assert_equal(str, target.read,
-                "Changed in read/write")
-
-            @provider.clear
-        end
+    nonmatchers.each do |cron|
+      assert_equal(:absent, cron.provider.ensure, "Cron #{cron.name} was incorrectly matched")
     end
-
-    # #707
-    def test_write_freebsd_special
-        assert_equal(@provider.to_line(:record_type => :crontab, :ensure => :present, :special => "reboot", :command => "/bin/echo something"), "@reboot /bin/echo something")
+  end
+
+  def test_data
+    setme
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    target = @provider.target_object(@me)
+    fakedata("data/providers/cron/examples").each do |file|
+      text = File.read(file)
+      target.write(text)
+
+      assert_nothing_raised("Could not parse #{file}") do
+        @provider.prefetch
+      end
+      # mark the provider modified
+      @provider.modified(@me)
+
+      # and zero the text
+      target.write("")
+
+      result = nil
+      assert_nothing_raised("Could not generate #{file}") do
+        @provider.flush_target(@me)
+      end
+
+      # Ignore whitespace differences, since those don't affect function.
+      modtext = text.gsub(/[ \t]+/, " ")
+      modtarget = target.read.gsub(/[ \t]+/, " ")
+      assert_equal(modtext, modtarget, "File was not rewritten the same")
+
+      @provider.clear
     end
+  end
+
+  # Match freebsd's annoying @daily stuff.
+  def test_match_freebsd_special
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    setme
+
+    target = @provider.target_object(@me)
+
+    [
+      "@daily /some/command",
+      "@daily /some/command more"
+    ].each do |str|
+      @provider.initvars
+      str += "\n"
+      target.write(str)
+      assert_nothing_raised("Could not prefetch with #{str.inspect}") do
+        @provider.prefetch
+      end
+      records = @provider.send(:instance_variable_get, "@records")
+      records.each do |r|
+
+              assert_equal(
+        :freebsd_special, r[:record_type],
+        
+          "Did not create lines as freebsd lines")
+      end
+      assert_nothing_raised("Could not flush with #{str.inspect}") do
+        @provider.flush_target(@me)
+      end
+
+
+            assert_equal(
+        str, target.read,
+        
+        "Changed in read/write")
+
+      @provider.clear
+    end
+  end
 
-    def test_prefetch
-        cron = @type.new :command => "/bin/echo yay", :name => "test", :hour => 4
+  # #707
+  def test_write_freebsd_special
+    assert_equal(@provider.to_line(:record_type => :crontab, :ensure => :present, :special => "reboot", :command => "/bin/echo something"), "@reboot /bin/echo something")
+  end
 
-        assert_nothing_raised("Could not prefetch cron") do
-            cron.provider.class.prefetch("test" => cron)
-        end
+  def test_prefetch
+    cron = @type.new :command => "/bin/echo yay", :name => "test", :hour => 4
+
+    assert_nothing_raised("Could not prefetch cron") do
+      cron.provider.class.prefetch("test" => cron)
     end
+  end
 
-    # Testing #669.
-    def test_environment_settings
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        setme
+  # Testing #669.
+  def test_environment_settings
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    setme
 
-        target = @provider.target_object(@me)
+    target = @provider.target_object(@me)
 
-        # First with no env settings
-        resource = @type.new :command => "/bin/echo yay", :name => "test", :hour => 4
-        cron = resource.provider
+    # First with no env settings
+    resource = @type.new :command => "/bin/echo yay", :name => "test", :hour => 4
+    cron = resource.provider
 
-        cron.ensure = :present
-        cron.command = "/bin/echo yay"
-        cron.hour = %w{4}
-        cron.flush
+    cron.ensure = :present
+    cron.command = "/bin/echo yay"
+    cron.hour = %w{4}
+    cron.flush
 
-        result = target.read
-        assert_equal("# Puppet Name: test\n* 4 * * * /bin/echo yay\n", result, "Did not write cron out correctly")
+    result = target.read
+    assert_equal("# Puppet Name: test\n* 4 * * * /bin/echo yay\n", result, "Did not write cron out correctly")
 
-        # Now set the env
-        cron.environment = "TEST=foo"
-        cron.flush
+    # Now set the env
+    cron.environment = "TEST=foo"
+    cron.flush
 
-        result = target.read
-        assert_equal("# Puppet Name: test\nTEST=foo\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
+    result = target.read
+    assert_equal("# Puppet Name: test\nTEST=foo\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
 
-        # Modify it
-        cron.environment = ["TEST=foo", "BLAH=yay"]
-        cron.flush
+    # Modify it
+    cron.environment = ["TEST=foo", "BLAH=yay"]
+    cron.flush
 
-        result = target.read
-        assert_equal("# Puppet Name: test\nTEST=foo\nBLAH=yay\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
+    result = target.read
+    assert_equal("# Puppet Name: test\nTEST=foo\nBLAH=yay\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
 
-        # And remove it
-        cron.environment = :absent
-        cron.flush
+    # And remove it
+    cron.environment = :absent
+    cron.flush
 
-        result = target.read
-        assert_equal("# Puppet Name: test\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
-    end
+    result = target.read
+    assert_equal("# Puppet Name: test\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
+  end
 
-    # Testing #1216
-    def test_strange_lines
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-        text = " 5 \t\t 1,2 * 1 0 /bin/echo funtest"
-
-        records = nil
-        assert_nothing_raised {
-            records = @provider.parse(text)
-        }
-
-        should = {
-            :minute => %w{5},
-            :hour => %w{1 2},
-            :monthday => :absent,
-            :month => %w{1},
-            :weekday => %w{0},
-            :command => "/bin/echo funtest"
-        }
-
-        is = records.shift
-        assert(is, "Did not get record")
-
-        should.each do |p, v|
-            assert_equal(v, is[p], "did not parse %s correctly" % p)
-        end
+  # Testing #1216
+  def test_strange_lines
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    text = " 5 \t\t 1,2 * 1 0 /bin/echo funtest"
+
+    records = nil
+    assert_nothing_raised {
+      records = @provider.parse(text)
+    }
+
+    should = {
+      :minute => %w{5},
+      :hour => %w{1 2},
+      :monthday => :absent,
+      :month => %w{1},
+      :weekday => %w{0},
+      :command => "/bin/echo funtest"
+    }
+
+    is = records.shift
+    assert(is, "Did not get record")
+
+    should.each do |p, v|
+      assert_equal(v, is[p], "did not parse #{p} correctly")
     end
+  end
 end