puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/property_spec.rb

@@ -139,6 +139,17 @@ describe Puppet::Property do
       property.stubs(:path).returns "/my/param"
       property.event.source_description.should == "/my/param"
     end
+
+    it "should have the 'invalidate_refreshes' value set if set on a value" do
+      property.stubs(:event_name).returns :my_event
+      property.stubs(:should).returns "foo"
+      foo = mock()
+      foo.expects(:invalidate_refreshes).returns(true)
+      collection = mock()
+      collection.expects(:match?).with("foo").returns(foo)
+      property.class.stubs(:value_collection).returns(collection)
+      property.event.invalidate_refreshes.should be_true
+    end
   end
 
   describe "when shadowing metaparameters" do

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -744,6 +744,7 @@ describe provider_class do
         @resource[:context] = "/files/etc/test"
         @resource[:load_path] = my_fixture_dir
 
+        @provider.expects(:print_load_errors).with(:warning => true)
         aug = @provider.open_augeas
         aug.should_not == nil
         aug.match("/files/etc/fstab").should == []
@@ -754,6 +755,7 @@ describe provider_class do
       it "should load standard files if context isn't specific" do
         @resource[:context] = "/files/etc"
 
+        @provider.expects(:print_load_errors).with(:warning => false)
         aug = @provider.open_augeas
         aug.should_not == nil
         aug.match("/files/etc/fstab").should == ["/files/etc/fstab"]
@@ -763,6 +765,7 @@ describe provider_class do
       it "should not optimise if the context is a complex path" do
         @resource[:context] = "/files/*[label()='etc']"
 
+        @provider.expects(:print_load_errors).with(:warning => false)
         aug = @provider.open_augeas
         aug.should_not == nil
         aug.match("/files/etc/fstab").should == ["/files/etc/fstab"]

data/spec/unit/provider/cron/crontab_spec.rb

@@ -8,10 +8,15 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
     provider
   end
 
+  def compare_crontab_text(have, want)
+    # We should have four header lines, and then the text...
+    have.lines.to_a[0..3].should be_all {|x| x =~ /^# / }
+    have.lines.to_a[4..-1].join('').should == want
+  end
+
   context "with the simple samples" do
     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],
@@ -28,12 +33,6 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       end
     end
 
-    def compare_crontab_text(have, want)
-      # We should have four header lines, and then the text...
-      have.lines.to_a[0..3].should be_all {|x| x =~ /^# / }
-      have.lines.to_a[4..-1].join('').should == want
-    end
-
     ########################################################################
     # Simple input fixtures for testing.
     samples = YAML.load(File.read(my_fixture('single_line.yaml')))
@@ -113,4 +112,95 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       end
     end
   end
+
+  context "when receiving a vixie cron header from the cron interface" do
+    it "should not write that header back to disk" do
+      vixie_header = File.read(my_fixture('vixie_header.txt'))
+      vixie_records = subject.parse(vixie_header)
+      compare_crontab_text subject.to_file(vixie_records), ""
+    end
+  end
+
+  context "when adding a cronjob with the same command as an existing job" do
+    let(:record) { {:name => "existing", :user => "root", :command => "/bin/true", :record_type => :crontab} }
+    let(:resource) { Puppet::Type::Cron.new(:name => "test", :user => "root", :command => "/bin/true") }
+    let(:resources) { { "test" => resource } }
+
+    before :each do
+      subject.stubs(:prefetch_all_targets).returns([record])
+    end
+
+# this would be a more fitting test, but I haven't yet
+# figured out how to get it working
+#    it "should include both jobs in the output" do
+#      subject.prefetch(resources)
+#      class Puppet::Provider::ParsedFile
+#        def self.records
+#          @records
+#        end
+#      end
+#      subject.to_file(subject.records).should match /Puppet name: test/
+#    end
+
+    it "should not base the new resource's provider on the existing record" do
+      subject.expects(:new).with(record).never
+      subject.stubs(:new)
+      subject.prefetch(resources)
+    end
+  end
+
+  context "when prefetching an entry now managed for another user" do
+    let(:resource) do
+     s = stub(:resource)
+     s.stubs(:[]).with(:user).returns 'root'
+     s
+    end
+
+    let(:record) { {:name => "test", :user => "nobody", :command => "/bin/true", :record_type => :crontab} }
+    let(:resources) { { "test" => resource } }
+
+    before :each do
+      subject.stubs(:prefetch_all_targets).returns([record])
+    end
+
+    it "should try and use the match method to find a more fitting record" do
+      subject.expects(:match).with(record, resources)
+      subject.prefetch(resources)
+    end
+
+    it "should not match a provider to the resource" do
+      resource.expects(:provider=).never
+      subject.prefetch(resources)
+    end
+
+    it "should not find the resource when looking up the on-disk record" do
+      subject.prefetch(resources)
+      subject.resource_for_record(record, resources).should be_nil
+    end
+  end
+
+  context "when matching resources to existing crontab entries" do
+    let(:first_resource) { Puppet::Type::Cron.new(:name => :one, :user => 'root', :command => '/bin/true') }
+    let(:second_resource) { Puppet::Type::Cron.new(:name => :two, :user => 'nobody', :command => '/bin/false') }
+
+    let(:resources) {{:one => first_resource, :two => second_resource}}
+
+    describe "with a record with a matching name and mismatching user (#2251)" do
+      # Puppet::Resource objects have #should defined on them, so in these
+      # examples we have to use the monkey patched `must` alias for the rspec
+      # `should` method.
+
+      it "doesn't match the record to the resource" do
+        record = {:name => :one, :user => 'notroot', :record_type => :crontab}
+        subject.resource_for_record(record, resources).must be_nil
+      end
+    end
+
+    describe "with a record with a matching name and matching user" do
+      it "matches the record to the resource" do
+        record = {:name => :two, :target => 'nobody', :command => '/bin/false'}
+        subject.resource_for_record(record, resources).must == second_resource
+      end
+    end
+  end
 end

data/spec/unit/provider/cron/parsed_spec.rb

@@ -0,0 +1,325 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:cron).provider(:crontab) do
+
+  let :provider do
+    described_class.new(:command => '/bin/true')
+  end
+
+  let :resource do
+    Puppet::Type.type(:cron).new(
+      :minute      => %w{0 15 30 45},
+      :hour        => %w{8-18 20-22},
+      :monthday    => %w{31},
+      :month       => %w{12},
+      :weekday     => %w{7},
+      :name        => 'basic',
+      :command     => '/bin/true',
+      :target      => 'root',
+      :provider    => provider
+    )
+  end
+
+  let :resource_special do
+    Puppet::Type.type(:cron).new(
+      :special => 'reboot',
+      :name    => 'special',
+      :command => '/bin/true',
+      :target  => 'nobody'
+    )
+  end
+
+  let :record_special do
+    {
+      :record_type => :crontab,
+      :special     => 'reboot',
+      :command     => '/bin/true',
+      :on_disk     => true,
+      :target      => 'nobody'
+    }
+  end
+
+  let :record do
+    {
+      :record_type => :crontab,
+      :minute      => %w{0 15 30 45},
+      :hour        => %w{8-18 20-22},
+      :monthday    => %w{31},
+      :month       => %w{12},
+      :weekday     => %w{7},
+      :special     => :absent,
+      :command     => '/bin/true',
+      :on_disk     => true,
+      :target      => 'root'
+    }
+  end
+
+  describe "when determining the correct filetype" do
+    it "should use the suntab filetype on Solaris" do
+      Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+      described_class.filetype.should == Puppet::Util::FileType::FileTypeSuntab
+    end
+
+    it "should use the aixtab filetype on AIX" do
+      Facter.stubs(:value).with(:osfamily).returns 'AIX'
+      described_class.filetype.should == Puppet::Util::FileType::FileTypeAixtab
+    end
+
+    it "should use the crontab filetype on other platforms" do
+      Facter.stubs(:value).with(:osfamily).returns 'Not a real operating system family'
+      described_class.filetype.should == Puppet::Util::FileType::FileTypeCrontab
+    end
+  end
+
+  # I'd use ENV.expects(:[]).with('USER') but this does not work because
+  # ENV["USER"] is evaluated at load time.
+  describe "when determining the default target" do
+    it "should use the current user #{ENV['USER']}", :if => ENV['USER'] do
+      described_class.default_target.should == ENV['USER']
+    end
+
+    it "should fallback to root", :unless => ENV['USER'] do
+      described_class.default_target.should == "root"
+    end
+  end
+
+  describe "when parsing a record" do
+    it "should parse a comment" do
+      described_class.parse_line("# This is a test").should == {
+        :record_type => :comment,
+        :line        => "# This is a test",
+      }
+    end
+
+    it "should get the resource name of a PUPPET NAME comment" do
+      described_class.parse_line('# Puppet Name: My Fancy Cronjob').should == {
+        :record_type => :comment,
+        :name        => 'My Fancy Cronjob',
+        :line        => '# Puppet Name: My Fancy Cronjob',
+      }
+    end
+
+    it "should ignore blank lines" do
+      described_class.parse_line('').should == {:record_type => :blank, :line => ''}
+      described_class.parse_line(' ').should == {:record_type => :blank, :line => ' '}
+      described_class.parse_line("\t").should == {:record_type => :blank, :line => "\t"}
+      described_class.parse_line("  \t ").should == {:record_type => :blank, :line => "  \t "}
+    end
+
+    it "should extract environment assignments" do
+      # man 5 crontab: MAILTO="" with no value can be used to surpress sending
+      # mails at all
+      described_class.parse_line('MAILTO=""').should == {:record_type => :environment, :line => 'MAILTO=""'}
+      described_class.parse_line('FOO=BAR').should == {:record_type => :environment, :line => 'FOO=BAR'}
+      described_class.parse_line('FOO_BAR=BAR').should == {:record_type => :environment, :line => 'FOO_BAR=BAR'}
+    end
+
+    it "should extract a cron entry" do
+      described_class.parse_line('* * * * * /bin/true').should == {
+        :record_type => :crontab,
+        :hour        => :absent,
+        :minute      => :absent,
+        :month       => :absent,
+        :weekday     => :absent,
+        :monthday    => :absent,
+        :special     => :absent,
+        :command     => '/bin/true'
+      }
+      described_class.parse_line('0,15,30,45 8-18,20-22 31 12 7 /bin/true').should == {
+        :record_type => :crontab,
+        :minute      => %w{0 15 30 45},
+        :hour        => %w{8-18 20-22},
+        :monthday    => %w{31},
+        :month       => %w{12},
+        :weekday     => %w{7},
+        :special     => :absent,
+        :command     => '/bin/true'
+      }
+      # A percent sign will cause the rest of the string to be passed as
+      # standard input and will also act as a newline character. Not sure
+      # if puppet should convert % to a \n as the command property so the
+      # test covers the current behaviour: Do not do any conversions
+      described_class.parse_line('0 22 * * 1-5   mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%').should == {
+        :record_type => :crontab,
+        :minute      => %w{0},
+        :hour        => %w{22},
+        :monthday    => :absent,
+        :month       => :absent,
+        :weekday     => %w{1-5},
+        :special     => :absent,
+        :command     => 'mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%'
+      }
+    end
+
+    describe "it should support special strings" do
+      ['reboot','yearly','anually','monthly', 'weekly', 'daily', 'midnight', 'hourly'].each do |special|
+        it "should support @#{special}" do
+          described_class.parse_line("@#{special} /bin/true").should == {
+            :record_type => :crontab,
+            :hour        => :absent,
+            :minute      => :absent,
+            :month       => :absent,
+            :weekday     => :absent,
+            :monthday    => :absent,
+            :special     => special,
+            :command     => '/bin/true'
+          }
+        end
+      end
+    end
+  end
+
+  describe ".instances" do
+    before :each do
+      described_class.stubs(:default_target).returns 'foobar'
+    end
+
+    describe "on linux" do
+      before do
+        Facter.stubs(:value).with(:osfamily).returns 'Linux'
+        Facter.stubs(:value).with(:operatingsystem)
+      end
+
+      it "should be empty if user has no crontab" do
+        # `crontab...` does only capture stdout here. On vixie-cron-4.1
+        # STDERR shows "no crontab for foobar" but stderr is ignored as
+        # well as the exitcode.
+        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ""
+        described_class.instances.should be_empty
+      end
+
+      it "should be empty if user is not present" do
+        # `crontab...` does only capture stdout. On vixie-cron-4.1
+        # STDERR shows "crontab:  user `foobar' unknown" but stderr is
+        # ignored as well as the exitcode
+        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ""
+        described_class.instances.should be_empty
+      end
+
+      it "should be able to create records from not-managed records" do
+        described_class.expects(:target_object).returns File.new(my_fixture('simple'))
+        described_class.instances.map do |p|
+          h = {:name => p.get(:name)}
+          Puppet::Type.type(:cron).validproperties.each do |property|
+            h[property] = p.get(property)
+          end
+          h
+        end.should == [
+          {
+            :name        => :absent,
+            :minute      => ['5'],
+            :hour        => ['0'],
+            :weekday     => :absent,
+            :month       => :absent,
+            :monthday    => :absent,
+            :special     => :absent,
+            :command     => '$HOME/bin/daily.job >> $HOME/tmp/out 2>&1',
+            :ensure      => :present,
+            :environment => :absent,
+            :user        => :absent,
+            :target      => 'foobar'
+          },
+          {
+            :name        => :absent,
+            :minute      => ['15'],
+            :hour        => ['14'],
+            :weekday     => :absent,
+            :month       => :absent,
+            :monthday    => ['1'],
+            :special     => :absent,
+            :command     => '$HOME/bin/monthly',
+            :ensure      => :present,
+            :environment => :absent,
+            :user        => :absent,
+            :target      => 'foobar'
+          }
+        ]
+      end
+
+      it "should be able to parse puppet manged cronjobs" do
+        described_class.expects(:target_object).returns File.new(my_fixture('managed'))
+        described_class.instances.map do |p|
+          h = {:name => p.get(:name)}
+          Puppet::Type.type(:cron).validproperties.each do |property|
+            h[property] = p.get(property)
+          end
+          h
+        end.should == [
+          {
+            :name        => 'real_job',
+            :minute      => :absent,
+            :hour        => :absent,
+            :weekday     => :absent,
+            :month       => :absent,
+            :monthday    => :absent,
+            :special     => :absent,
+            :command     => '/bin/true',
+            :ensure      => :present,
+            :environment => :absent,
+            :user        => :absent,
+            :target      => 'foobar'
+          },
+          {
+            :name        => 'complex_job',
+            :minute      => :absent,
+            :hour        => :absent,
+            :weekday     => :absent,
+            :month       => :absent,
+            :monthday    => :absent,
+            :special     => 'reboot',
+            :command     => '/bin/true >> /dev/null 2>&1',
+            :ensure      => :present,
+            :environment => [
+              'MAILTO=foo@example.com',
+              'SHELL=/bin/sh'
+            ],
+            :user        => :absent,
+            :target      => 'foobar'
+          }
+        ]
+      end
+    end
+  end
+
+  describe ".match" do
+    describe "normal records" do
+      it "should match when all fields are the same" do
+        described_class.match(record,{resource[:name] => resource}).must == resource
+      end
+
+      {
+        :minute      => %w{0 15 31 45},
+        :hour        => %w{8-18},
+        :monthday    => %w{30 31},
+        :month       => %w{12 23},
+        :weekday     => %w{4},
+        :command     => '/bin/false',
+        :target      => 'nobody'
+      }.each_pair do |field, new_value|
+        it "should not match a record when #{field} does not match" do
+          record[field] = new_value
+          described_class.match(record,{resource[:name] => resource}).must be_false
+        end
+      end
+    end
+
+    describe "special records" do
+      it "should match when all fields are the same" do
+        described_class.match(record_special,{resource_special[:name] => resource_special}).must == resource_special
+      end
+
+      {
+        :special => 'monthly',
+        :command => '/bin/false',
+        :target  => 'root'
+      }.each_pair do |field, new_value|
+        it "should not match a record when #{field} does not match" do
+          record_special[field] = new_value
+          described_class.match(record_special,{resource_special[:name] => resource_special}).must be_false
+        end
+      end
+    end
+  end
+end