puppet 2.7.19 → 2.7.20.rc1

data/spec/unit/type/mount_spec.rb

@@ -283,6 +283,7 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry", :u
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
+
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
 
     {:device => "/foo/bar", :blockdevice => "/other/bar", :target => "/what/ever", :fstype => 'eh', :options => "", :pass => 0, :dump => 0, :atboot => 0,
@@ -304,6 +305,8 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry", :u
   it "should use the provider to change the dump value" do
     @mount.provider.expects(:dump).returns 0
     @mount.provider.expects(:dump=).with(1)
+    @mount.provider.stubs(:respond_to?).returns(false)
+    @mount.provider.stubs(:respond_to?).with("dump=").returns(true)
 
     @mount[:dump] = 1
 
@@ -315,11 +318,16 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry", :u
     @mount.provider.expects(:options).returns 'soft'
     @mount.provider.expects(:ensure).returns :mounted
 
+    @mount.provider.stubs(:respond_to?).returns(false)
+    @mount.provider.stubs(:respond_to?).with("options=").returns(true)
+
     @mount.provider.expects(:unmount).in_sequence(syncorder)
     @mount.provider.expects(:options=).in_sequence(syncorder).with 'hard'
     @mount.expects(:flush).in_sequence(syncorder) # Call inside syncothers
     @mount.expects(:flush).in_sequence(syncorder) # I guess transaction or anything calls flush again
 
+    @mount.provider.stubs(:respond_to?).with(:options=).returns(true)
+
     @mount[:ensure] = :unmounted
     @mount[:options] = 'hard'
 

data/spec/unit/type/scheduled_task_spec.rb

@@ -34,7 +34,7 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
         described_class.new(:name => 'Test Task', :command => 'notepad.exe')
       }.to raise_error(
         Puppet::Error,
-        /Parameter command failed: Must be specified using an absolute path\./
+        /Parameter command failed on Scheduled_task\[Test Task\]: Must be specified using an absolute path\./
       )
     end
   end
@@ -77,7 +77,7 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
         )
       }.to raise_error(
         Puppet::Error,
-        /Parameter working_dir failed: Must be specified using an absolute path/
+        /Parameter working_dir failed on Scheduled_task\[Test Task\]: Must be specified using an absolute path/
       )
     end
 

data/spec/unit/util/adsi_spec.rb

@@ -28,25 +28,21 @@ describe Puppet::Util::ADSI do
     Puppet::Util::ADSI.computer_uri.should == "WinNT://testcomputername"
   end
 
-  describe ".sid_for_account" do
+  describe ".sid_for_account", :if => Puppet.features.microsoft_windows? do
     it "should return nil if the account does not exist" do
-      connection.expects(:execquery).returns([])
+      Puppet::Util::Windows::Security.expects(:name_to_sid).with('foobar').returns nil
 
       Puppet::Util::ADSI.sid_for_account('foobar').should be_nil
     end
 
     it "should return a SID for a passed user or group name" do
-      Puppet::Util::ADSI.expects(:execquery).with(
-        "SELECT Sid from Win32_Account WHERE Name = 'testers' AND LocalAccount = true"
-      ).returns([stub('acct_id', :Sid => 'S-1-5-32-547')])
+      Puppet::Util::Windows::Security.expects(:name_to_sid).with('testers').returns 'S-1-5-32-547'
 
       Puppet::Util::ADSI.sid_for_account('testers').should == 'S-1-5-32-547'
     end
 
     it "should return a SID for a passed fully-qualified user or group name" do
-      Puppet::Util::ADSI.expects(:execquery).with(
-        "SELECT Sid from Win32_Account WHERE Name = 'testers' AND Domain = 'MACHINE' AND LocalAccount = true"
-      ).returns([stub('acct_id', :Sid => 'S-1-5-32-547')])
+      Puppet::Util::Windows::Security.expects(:name_to_sid).with('MACHINE\testers').returns 'S-1-5-32-547'
 
       Puppet::Util::ADSI.sid_for_account('MACHINE\testers').should == 'S-1-5-32-547'
     end
@@ -229,4 +225,23 @@ describe Puppet::Util::ADSI do
       Puppet::Util::ADSI::Group.delete(groupname)
     end
   end
+
+  describe Puppet::Util::ADSI::UserProfile do
+    it "should be able to delete a user profile" do
+      connection.expects(:Delete).with("Win32_UserProfile.SID='S-A-B-C'")
+      Puppet::Util::ADSI::UserProfile.delete('S-A-B-C')
+    end
+
+    it "should warn on 2003" do
+      connection.expects(:Delete).raises(RuntimeError,
+ "Delete (WIN32OLERuntimeError)
+    OLE error code:80041010 in SWbemServicesEx
+      Invalid class
+    HRESULT error code:0x80020009
+      Exception occurred.")
+
+      Puppet.expects(:warning).with("Cannot delete user profile for 'S-A-B-C' prior to Vista SP1")
+      Puppet::Util::ADSI::UserProfile.delete('S-A-B-C')
+    end
+  end
 end

data/spec/unit/util/command_line_spec.rb

@@ -87,9 +87,18 @@ describe Puppet::Util::CommandLine do
     it "should find and invoke an executable with a hyphenated name" do
       commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
       Puppet::Util.expects(:which).with('puppet-whatever').returns('/dev/null/puppet-whatever')
-      commandline.expects(:exec).with('/dev/null/puppet-whatever', 'argument')
 
-      commandline.execute
+      # It is important that we abort at the point exec is called, because
+      # the code (reasonably) assumes that if `exec` is called processing
+      # immediately terminates, and we are replaced by the executed process.
+      #
+      # This raise isn't a perfect simulation of that, but it is enough to
+      # validate that the system works, and ... well, if exec is broken we
+      # have two problems, y'know.
+      commandline.expects(:exec).with('/dev/null/puppet-whatever', 'argument').
+        raises(SystemExit)
+
+      expect { commandline.execute }.to raise_error SystemExit
     end
 
     describe "and an external implementation cannot be found" do

data/spec/unit/util/feature_spec.rb

@@ -39,7 +39,7 @@ describe Puppet::Util::Feature do
     @features.should be_available
   end
 
-  it "should cache the results of a feature load" do
+  it "should cache the results of a feature load via code block" do
     $loaded_feature = 0
     @features.add(:myfeature) { $loaded_feature += 1 }
     @features.myfeature?
@@ -68,4 +68,15 @@ describe Puppet::Util::Feature do
 
     @features.should_not be_myfeature
   end
+
+  it "should change the feature to be present when its libraries become available" do
+    @features.add(:myfeature, :libs => %w{foo bar})
+    @features.expects(:require).twice().with("foo").raises(LoadError).then.returns(nil)
+    @features.stubs(:require).with("bar")
+
+    Puppet.expects(:debug)
+
+    @features.should_not be_myfeature
+    @features.should be_myfeature
+  end
 end

data/spec/unit/util/filetype_spec.rb

@@ -5,58 +5,26 @@ require 'puppet/util/filetype'
 
 # XXX Import all of the tests into this file.
 describe Puppet::Util::FileType do
-  describe "when backing up a file" do
-    before do
-      @file = Puppet::Util::FileType.filetype(:flat).new("/my/file")
-    end
-
-    it "should do nothing if the file does not exist" do
-      File.expects(:exists?).with("/my/file").returns false
-      @file.expects(:bucket).never
-      @file.backup
-    end
-
-    it "should use its filebucket to backup the file if it exists" do
-      File.expects(:exists?).with("/my/file").returns true
-
-      bucket = mock 'bucket'
-      bucket.expects(:backup).with("/my/file")
-
-      @file.expects(:bucket).returns bucket
-      @file.backup
-    end
-
-    it "should use the default filebucket" do
-      bucket = mock 'bucket'
-      bucket.expects(:bucket).returns "mybucket"
-
-      Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
-
-      @file.bucket.should == "mybucket"
-    end
-  end
-
   describe "the flat filetype" do
-    before do
-      @type = Puppet::Util::FileType.filetype(:flat)
-    end
+    let(:path) { '/my/file' }
+    let(:type) { Puppet::Util::FileType.filetype(:flat) }
+    let(:file) { type.new(path) }
+
     it "should exist" do
-      @type.should_not be_nil
+      type.should_not be_nil
     end
 
     describe "when the file already exists" do
       it "should return the file's contents when asked to read it" do
-        file = @type.new("/my/file")
-        File.expects(:exist?).with("/my/file").returns true
-        File.expects(:read).with("/my/file").returns "my text"
+        File.expects(:exist?).with(path).returns true
+        File.expects(:read).with(path).returns "my text"
 
         file.read.should == "my text"
       end
 
       it "should unlink the file when asked to remove it" do
-        file = @type.new("/my/file")
-        File.expects(:exist?).with("/my/file").returns true
-        File.expects(:unlink).with("/my/file")
+        File.expects(:exist?).with(path).returns true
+        File.expects(:unlink).with(path)
 
         file.remove
       end
@@ -64,36 +32,174 @@ describe Puppet::Util::FileType do
 
     describe "when the file does not exist" do
       it "should return an empty string when asked to read the file" do
-        file = @type.new("/my/file")
-        File.expects(:exist?).with("/my/file").returns false
+        File.expects(:exist?).with(path).returns false
 
         file.read.should == ""
       end
     end
 
     describe "when writing the file" do
+      let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
       before do
-        @file = @type.new("/my/file")
         FileUtils.stubs(:cp)
-
-        @tempfile = stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file"
-        Tempfile.stubs(:new).returns @tempfile
+        Tempfile.stubs(:new).returns tempfile
       end
 
       it "should first create a temp file and copy its contents over to the file location" do
-        Tempfile.expects(:new).with("puppet").returns @tempfile
-        @tempfile.expects(:print).with("my text")
-        @tempfile.expects(:flush)
-        @tempfile.expects(:close)
-        FileUtils.expects(:cp).with(@tempfile.path, "/my/file")
+        Tempfile.expects(:new).with("puppet").returns tempfile
+        tempfile.expects(:print).with("my text")
+        tempfile.expects(:flush)
+        tempfile.expects(:close)
+        FileUtils.expects(:cp).with(tempfile.path, path)
 
-        @file.write "my text"
+        file.write "my text"
       end
 
       it "should set the selinux default context on the file" do
-        @file.expects(:set_selinux_default_context).with("/my/file")
-        @file.write "eh"
+        file.expects(:set_selinux_default_context).with(path)
+        file.write "eh"
       end
     end
+
+    describe "when backing up a file" do
+      it "should do nothing if the file does not exist" do
+        File.expects(:exists?).with(path).returns false
+        file.expects(:bucket).never
+        file.backup
+      end
+
+      it "should use its filebucket to backup the file if it exists" do
+        File.expects(:exists?).with(path).returns true
+
+        bucket = mock 'bucket'
+        bucket.expects(:backup).with(path)
+
+        file.expects(:bucket).returns bucket
+        file.backup
+      end
+
+      it "should use the default filebucket" do
+        bucket = mock 'bucket'
+        bucket.expects(:bucket).returns "mybucket"
+
+        Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
+
+        file.bucket.should == "mybucket"
+      end
+    end
+  end
+
+  shared_examples_for "crontab provider" do
+    let(:cron)         { type.new('no_such_user') }
+    let(:crontab)      { File.read(my_fixture(crontab_output)) }
+    let(:options)      { { :failonfail => true, :combine => true } }
+    let(:uid)          { 'no_such_user' }
+    let(:user_options) { options.merge({:uid => uid}) }
+
+    it "should exist" do
+      type.should_not be_nil
+    end
+
+    describe "#read" do
+      it "should run crontab -l as the target user" do
+        Puppet::Util.expects(:execute).with(['crontab', '-l'], user_options).returns crontab
+        cron.read.should == crontab
+      end
+
+      it "should not switch user if current user is the target user" do
+        Puppet::Util.expects(:uid).with(uid).returns 9000
+        Puppet::Util::SUIDManager.expects(:uid).returns 9000
+        Puppet::Util.expects(:execute).with(['crontab', '-l'], options).returns crontab
+        cron.read.should == crontab
+      end
+
+      it "should treat an absent crontab as empty" do
+        Puppet::Util.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, absent_crontab)
+        cron.read.should == ''
+      end
+
+      it "should raise an error if the user is not authorized to use cron" do
+        Puppet::Util.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, unauthorized_crontab)
+        expect {
+          cron.read
+        }.to raise_error Puppet::Error, /User #{uid} not authorized to use cron/
+      end
+    end
+
+    describe "#remove" do
+      it "should run crontab -r as the target user" do
+        Puppet::Util.expects(:execute).with(['crontab', '-r'], user_options)
+        cron.remove
+      end
+
+      it "should not switch user if current user is the target user" do
+        Puppet::Util.expects(:uid).with(uid).returns 9000
+        Puppet::Util::SUIDManager.expects(:uid).returns 9000
+        Puppet::Util.expects(:execute).with(['crontab','-r'], options)
+        cron.remove
+      end
+    end
+
+    describe "#write" do
+      before :each do
+        @tmp_cron = Tempfile.new("puppet_crontab_spec")
+        @tmp_cron_path = @tmp_cron.path
+        Puppet::Util.stubs(:uid).with(uid).returns 9000
+        Tempfile.expects(:new).with("puppet_#{name}").returns @tmp_cron
+      end
+
+      after :each do
+        File.should_not be_exist @tmp_cron_path
+      end
+
+      it "should run crontab as the target user on a temporary file" do
+        File.expects(:chown).with(9000, nil, @tmp_cron_path)
+        Puppet::Util.expects(:execute).with(["crontab", @tmp_cron_path], user_options)
+
+        @tmp_cron.expects(:print).with("foo\n")
+        cron.write "foo\n"
+      end
+
+      it "should not switch user if current user is the target user" do
+        Puppet::Util::SUIDManager.expects(:uid).returns 9000
+        File.expects(:chown).with(9000, nil, @tmp_cron_path)
+        Puppet::Util.expects(:execute).with(["crontab", @tmp_cron_path], options)
+
+        @tmp_cron.expects(:print).with("foo\n")
+        cron.write "foo\n"
+      end
+    end
+  end
+
+  describe "the suntab filetype", :unless => Puppet.features.microsoft_windows? do
+    let(:type)           { Puppet::Util::FileType.filetype(:suntab) }
+    let(:name)           { type.name }
+    let(:crontab_output) { 'suntab_output' }
+
+    # possible crontab output was taken from here:
+    # http://docs.oracle.com/cd/E19082-01/819-2380/sysrescron-60/index.html
+    let(:absent_crontab) do
+      'crontab: can\'t open your crontab file'
+    end
+    let(:unauthorized_crontab) do
+      'crontab: you are not authorized to use cron. Sorry.'
+    end
+
+    it_should_behave_like "crontab provider"
+  end
+
+  describe "the aixtab filetype", :unless => Puppet.features.microsoft_windows? do
+    let(:type)           { Puppet::Util::FileType.filetype(:aixtab) }
+    let(:name)           { type.name }
+    let(:crontab_output) { 'aixtab_output' }
+
+    let(:absent_crontab) do
+      '0481-103 Cannot open a file in the /var/spool/cron/crontabs directory.'
+    end
+    let(:unauthorized_crontab) do
+      '0481-109 You are not authorized to use the cron command.'
+    end
+
+    it_should_behave_like "crontab provider"
   end
 end

data/spec/unit/util/log_spec.rb

@@ -295,7 +295,7 @@ describe Puppet::Util::Log do
 
     it "should include attributes @level, @message, @source, @tags, and @time" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
-      log.to_yaml_properties.should == %w{@level @message @source @tags @time}
+      log.to_yaml_properties.should =~ %w{@level @message @source @tags @time}
     end
 
     it "should include attributes @file and @line if specified" do

data/spec/unit/util/monkey_patches_spec.rb

@@ -4,6 +4,13 @@ require 'spec_helper'
 require 'puppet/util/monkey_patches'
 
 
+describe Symbol do
+  it "should return self from #intern" do
+    symbol = :foo
+    symbol.should equal symbol.intern
+  end
+end
+
 
 describe "yaml deserialization" do
   it "should call yaml_initialize when deserializing objects that have that method defined" do

data/spec/unit/util/rdoc_spec.rb

@@ -62,8 +62,14 @@ describe Puppet::Util::RDoc do
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end
 
-    it "should tell RDoc to exclude .pp files under any modules/<mod>/files section" do
-      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/files/.*\.pp$") }
+    it "should tell RDoc to exclude all files under any modules/<mod>/files section" do
+      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/files/.*$") }
+
+      Puppet::Util::RDoc.rdoc("myoutputdir", [])
+    end
+
+    it "should tell RDoc to exclude all files under any modules/<mod>/templates section" do
+      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/templates/.*$") }
 
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end