puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/provider/package/openbsd_spec.rb

@@ -10,7 +10,7 @@ describe provider_class do
 
   def expect_read_from_pkgconf(lines)
     pkgconf = stub(:readlines => lines)
-    File.expects(:exist?).with('/etc/pkg.conf').returns(true)
+    Puppet::FileSystem::File.expects(:exist?).with('/etc/pkg.conf').returns(true)
     File.expects(:open).with('/etc/pkg.conf', 'rb').returns(pkgconf)
   end
 
@@ -76,7 +76,7 @@ describe provider_class do
 
   context "#install" do
     it "should fail if the resource doesn't have a source" do
-      File.expects(:exist?).with('/etc/pkg.conf').returns(false)
+      Puppet::FileSystem::File.expects(:exist?).with('/etc/pkg.conf').returns(false)
 
       expect {
         provider.install
@@ -84,7 +84,7 @@ describe provider_class do
     end
 
     it "should fail if /etc/pkg.conf exists, but is not readable" do
-      File.expects(:exist?).with('/etc/pkg.conf').returns(true)
+      Puppet::FileSystem::File.expects(:exist?).with('/etc/pkg.conf').returns(true)
       File.expects(:open).with('/etc/pkg.conf', 'rb').raises(Errno::EACCES)
 
       expect {

data/spec/unit/provider/package/rpm_spec.rb

@@ -20,7 +20,8 @@ describe provider_class do
   let(:resource) do
     Puppet::Type.type(:package).new(
       :name     => resource_name,
-      :ensure   => :installed
+      :ensure   => :installed,
+      :provider => 'rpm'
     )
   end
 
@@ -138,23 +139,40 @@ describe provider_class do
 
     describe "when not already installed" do
       it "should only include the '-i' flag" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-i", '/path/to/package'], execute_options)
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
         provider.install
       end
-   end
+    end
 
-   describe "when an older version is installed" do
-     before(:each) do
-       # Force the provider to think a version of the package is already installed
-       # This is real hacky. I'm sorry.  --jeffweiss 25 Jan 2013
-       provider.instance_variable_get('@property_hash')[:ensure] = '1.2.3.3'
-     end
+    describe "when installed with options" do
+      let(:resource) do
+        Puppet::Type.type(:package).new(
+          :name            => resource_name,
+          :ensure          => :installed,
+          :provider        => 'rpm',
+          :source          => '/path/to/package',
+          :install_options => ['-D', {'--test' => 'value'}, '-Q']
+        )
+      end
 
-     it "should include the '-U --oldpackage' flags" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
+      it "should include the options" do
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
         provider.install
-     end
-   end
+      end
+    end
+
+    describe "when an older version is installed" do
+      before(:each) do
+        # Force the provider to think a version of the package is already installed
+        # This is real hacky. I'm sorry.  --jeffweiss 25 Jan 2013
+        provider.instance_variable_get('@property_hash')[:ensure] = '1.2.3.3'
+      end
+
+      it "should include the '-U --oldpackage' flags" do
+         Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
+         provider.install
+      end
+    end
   end
 
   describe "#latest" do
@@ -268,6 +286,31 @@ describe provider_class do
     end
   end
 
+  describe "#install_options" do
+    it "should return empty array by default" do
+      provider.install_options.should == []
+    end
+
+    it "should return install_options when set" do
+      provider.resource[:install_options] = ['-n']
+      provider.install_options.should == ['-n']
+    end
+
+    it "should return multiple install_options when set" do
+      provider.resource[:install_options] = ['-L', '/opt/puppet']
+      provider.install_options.should == ['-L', '/opt/puppet']
+    end
+
+    it 'should return install_options when set as hash' do
+      provider.resource[:install_options] = { '-Darch' => 'vax' }
+      provider.install_options.should == ['-Darch=vax']
+    end
+    it 'should return install_options when an array with hashes' do
+      provider.resource[:install_options] = [ '-L', { '-Darch' => 'vax' }]
+      provider.install_options.should == ['-L', '-Darch=vax']
+    end
+  end
+
   describe ".nodigest" do
     { '4.0'   => nil,
       '4.0.1' => nil,

data/spec/unit/provider/package/windows_spec.rb

@@ -14,8 +14,7 @@ describe Puppet::Type.type(:package).provider(:windows) do
   end
 
   def expect_execute(command, status)
-    provider.expects(:execute).with(command, execute_options)
-    provider.expects(:exit_status).returns(status)
+    provider.expects(:execute).with(command, execute_options).returns(Puppet::Util::Execution::ProcessOutput.new('',status))
   end
 
   describe 'provider features' do
@@ -23,6 +22,7 @@ describe Puppet::Type.type(:package).provider(:windows) do
     it { should be_uninstallable }
     it { should be_install_options }
     it { should be_uninstall_options }
+    it { should be_versionable }
   end
 
   describe 'on Windows', :if => Puppet.features.microsoft_windows? do
@@ -36,17 +36,19 @@ describe Puppet::Type.type(:package).provider(:windows) do
       pkg1 = stub('pkg1')
       pkg2 = stub('pkg2')
 
-      prov1 = stub('prov1', :name => 'pkg1', :package => pkg1)
-      prov2 = stub('prov2', :name => 'pkg2', :package => pkg2)
+      prov1 = stub('prov1', :name => 'pkg1', :version => '1.0.0', :package => pkg1)
+      prov2 = stub('prov2', :name => 'pkg2', :version => nil, :package => pkg2)
 
       Puppet::Provider::Package::Windows::Package.expects(:map).multiple_yields([prov1], [prov2]).returns([prov1, prov2])
 
       providers = provider.class.instances
       providers.count.should == 2
       providers[0].name.should == 'pkg1'
+      providers[0].version.should == '1.0.0'
       providers[0].package.should == pkg1
 
       providers[1].name.should == 'pkg2'
+      providers[1].version.should be_nil
       providers[1].package.should == pkg2
     end
 
@@ -59,13 +61,21 @@ describe Puppet::Type.type(:package).provider(:windows) do
 
   context '#query' do
     it 'should return the hash of the matched packaged' do
-      pkg = mock(:name => 'pkg1')
+      pkg = mock(:name => 'pkg1', :version => nil)
       pkg.expects(:match?).returns(true)
       Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
 
       provider.query.should == { :name => 'pkg1', :ensure => :installed, :provider => :windows }
     end
 
+    it 'should include the version string when present' do
+      pkg = mock(:name => 'pkg1', :version => '1.0.0')
+      pkg.expects(:match?).returns(true)
+      Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
+
+      provider.query.should == { :name => 'pkg1', :ensure => '1.0.0', :provider => :windows }
+    end
+
     it 'should return nil if no package was found' do
       Puppet::Provider::Package::Windows::Package.expects(:find)
 
@@ -102,13 +112,6 @@ describe Puppet::Type.type(:package).provider(:windows) do
       provider.install
     end
 
-    it 'should warn if the package requests a reboot' do
-      expect_execute(command, 194)
-      provider.expects(:warning).with('The package requested a reboot to finish the operation.')
-
-      provider.install
-    end
-
     it 'should warn if reboot initiated' do
       expect_execute(command, 1641)
       provider.expects(:warning).with('The package installed successfully and the system is rebooting now.')
@@ -161,13 +164,6 @@ describe Puppet::Type.type(:package).provider(:windows) do
       provider.uninstall
     end
 
-    it 'should warn if the package requests a reboot' do
-      expect_execute(command, 194)
-      provider.expects(:warning).with('The package requested a reboot to finish the operation.')
-
-      provider.uninstall
-    end
-
     it 'should warn if reboot initiated' do
       expect_execute(command, 1641)
       provider.expects(:warning).with('The package uninstalled successfully and the system is rebooting now.')

data/spec/unit/provider/service/base_spec.rb

@@ -34,7 +34,7 @@ describe "base service provider" do
     end
 
     before :each do
-      File.unlink(flag) if File.exist?(flag)
+      Puppet::FileSystem::File.unlink(flag) if Puppet::FileSystem::File.exist?(flag)
     end
 
     it { should be }

data/spec/unit/provider/service/daemontools_spec.rb

@@ -99,9 +99,14 @@ describe provider_class do
   end
 
   describe "when enabling" do
-    it "should create a symlink between daemon dir and service dir" do
-      FileTest.stubs(:symlink?).returns(false)
-      File.expects(:symlink).with(File.join(@daemondir,"myservice"), File.join(@servicedir,"myservice")).returns(0)
+    it "should create a symlink between daemon dir and service dir", :if => Puppet.features.manages_symlinks?  do
+      daemon_path = File.join(@daemondir, "myservice")
+      stub_daemon = stub(daemon_path, :symlink? => false)
+      Puppet::FileSystem::File.expects(:new).with(daemon_path).returns(stub_daemon)
+      service_path = File.join(@servicedir, "myservice")
+      mock_service = mock(service_path, :symlink? => false)
+      Puppet::FileSystem::File.expects(:new).with(service_path).returns(mock_service)
+      stub_daemon.expects(:symlink).returns(0)
       @provider.enable
     end
   end
@@ -109,16 +114,19 @@ describe provider_class do
   describe "when disabling" do
     it "should remove the symlink between daemon dir and service dir" do
       FileTest.stubs(:directory?).returns(false)
-      FileTest.stubs(:symlink?).returns(true)
-      File.expects(:unlink).with(File.join(@servicedir,"myservice"))
+      path = File.join(@servicedir,"myservice")
+      mocked_file = mock(path, :symlink? => true)
+      Puppet::FileSystem::File.expects(:new).with(path).returns(mocked_file)
+      Puppet::FileSystem::File.expects(:unlink).with(path)
       @provider.stubs(:texecute).returns("")
       @provider.disable
     end
 
     it "should stop the service" do
       FileTest.stubs(:directory?).returns(false)
-      FileTest.stubs(:symlink?).returns(true)
-      File.stubs(:unlink)
+      mocked_file = mock('anything', :symlink? => true)
+      Puppet::FileSystem::File.expects(:new).returns(mocked_file)
+      Puppet::FileSystem::File.stubs(:unlink)
       @provider.expects(:stop)
       @provider.disable
     end
@@ -134,7 +142,9 @@ describe provider_class do
     [true, false].each do |t|
       it "should return #{t} if the symlink exists" do
         @provider.stubs(:status).returns(:stopped)
-        FileTest.stubs(:symlink?).returns(t)
+        path = File.join(@servicedir,"myservice")
+        mocked_file = mock(path, :symlink? => t)
+        Puppet::FileSystem::File.expects(:new).with(path).returns(mocked_file)
 
         @provider.enabled?.should == "#{t}".to_sym
       end

data/spec/unit/provider/service/freebsd_spec.rb

@@ -62,13 +62,13 @@ OUTPUT
   end
 
   it "should enable only the selected service" do
-    File.stubs(:exists?).with('/etc/rc.conf').returns(true)
+    Puppet::FileSystem::File.stubs(:exist?).with('/etc/rc.conf').returns(true)
     File.stubs(:read).with('/etc/rc.conf').returns("openntpd_enable=\"NO\"\nntpd_enable=\"NO\"\n")
     fh = stub 'fh'
     File.stubs(:open).with('/etc/rc.conf', File::WRONLY).yields(fh)
     fh.expects(:<<).with("openntpd_enable=\"NO\"\nntpd_enable=\"YES\"\n")
-    File.stubs(:exists?).with('/etc/rc.conf.local').returns(false)
-    File.stubs(:exists?).with('/etc/rc.conf.d/ntpd').returns(false)
+    Puppet::FileSystem::File.stubs(:exist?).with('/etc/rc.conf.local').returns(false)
+    Puppet::FileSystem::File.stubs(:exist?).with('/etc/rc.conf.d/ntpd').returns(false)
 
     @provider.rc_replace('ntpd', 'ntpd', 'YES')
   end

data/spec/unit/provider/service/gentoo_spec.rb

@@ -13,7 +13,9 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
     # The initprovider (parent of the gentoo provider) does a stat call
     # before it even tries to execute an initscript. We use sshd in all the
     # tests so make sure it is considered present.
-    File.stubs(:stat).with('/etc/init.d/sshd')
+    sshd_path = '/etc/init.d/sshd'
+    stub_file = stub(sshd_path, :stat => stub('stat'))
+    Puppet::FileSystem::File.stubs(:new).with(sshd_path).returns stub_file
   end
 
   let :initscripts do
@@ -48,7 +50,6 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
 
     it "should get a list of services from /etc/init.d but exclude helper scripts" do
       FileTest.expects(:directory?).with('/etc/init.d').returns true
-      File.stubs(:symlink?).returns(false)
       Dir.expects(:entries).with('/etc/init.d').returns initscripts
       (initscripts - helperscripts).each do |script|
         FileTest.expects(:executable?).with("/etc/init.d/#{script}").returns true
@@ -56,6 +57,8 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
       helperscripts.each do |script|
         FileTest.expects(:executable?).with("/etc/init.d/#{script}").never
       end
+
+      Puppet::FileSystem::File.stubs(:new).returns stub('file', :symlink? => false)
       described_class.instances.map(&:name).should == [
         'alsasound',
         'bootmisc',

data/spec/unit/provider/service/init_spec.rb

@@ -62,12 +62,12 @@ describe Puppet::Type.type(:service).provider(:init) do
       described_class.instances.should be_all { |provider| provider.get(:hasstatus) == true }
     end
 
-    it "should discard upstart jobs" do
+    it "should discard upstart jobs", :if => Puppet.features.manages_symlinks? do
       not_init_service, *valid_services = @services
-      File.stubs(:symlink?).returns false
-      File.stubs(:symlink?).with("tmp/#{not_init_service}").returns(true)
-      File.stubs(:readlink).with("tmp/#{not_init_service}").returns("/lib/init/upstart-job")
-
+      path = "tmp/#{not_init_service}"
+      mocked_file = mock(path, :symlink? => true, :readlink => "/lib/init/upstart-job")
+      Puppet::FileSystem::File.stubs(:new).returns stub('file', :symlink? => false)
+      Puppet::FileSystem::File.expects(:new).with(path).returns(mocked_file)
       described_class.instances.map(&:name).should == valid_services
     end
 
@@ -82,7 +82,7 @@ describe Puppet::Type.type(:service).provider(:init) do
   describe "when checking valid paths" do
     it "should discard paths that do not exist" do
       File.expects(:directory?).with(paths[0]).returns false
-      File.expects(:exist?).with(paths[0]).returns false
+      Puppet::FileSystem::File.expects(:exist?).with(paths[0]).returns false
       File.expects(:directory?).with(paths[1]).returns true
 
       provider.paths.should == [paths[1]]
@@ -90,7 +90,7 @@ describe Puppet::Type.type(:service).provider(:init) do
 
     it "should discard paths that are not directories" do
       paths.each do |path|
-        File.expects(:exist?).with(path).returns true
+        Puppet::FileSystem::File.expects(:exist?).with(path).returns true
         File.expects(:directory?).with(path).returns false
       end
       provider.paths.should be_empty
@@ -103,28 +103,28 @@ describe Puppet::Type.type(:service).provider(:init) do
     end
 
     it "should be able to find the init script in the service path" do
-      File.expects(:exist?).with("#{paths[0]}/myservice").returns true
-      File.expects(:exist?).with("#{paths[1]}/myservice").never # first one wins
+      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice").returns true
+      Puppet::FileSystem::File.expects(:exist?).with("#{paths[1]}/myservice").never # first one wins
       provider.initscript.should == "/service/path/myservice"
     end
 
     it "should be able to find the init script in an alternate service path" do
-      File.expects(:exist?).with("#{paths[0]}/myservice").returns false
-      File.expects(:exist?).with("#{paths[1]}/myservice").returns true
+      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice").returns false
+      Puppet::FileSystem::File.expects(:exist?).with("#{paths[1]}/myservice").returns true
       provider.initscript.should == "/alt/service/path/myservice"
     end
 
     it "should be able to find the init script if it ends with .sh" do
-      File.expects(:exist?).with("#{paths[0]}/myservice").returns false
-      File.expects(:exist?).with("#{paths[1]}/myservice").returns false
-      File.expects(:exist?).with("#{paths[0]}/myservice.sh").returns true
+      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice").returns false
+      Puppet::FileSystem::File.expects(:exist?).with("#{paths[1]}/myservice").returns false
+      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice.sh").returns true
       provider.initscript.should == "/service/path/myservice.sh"
     end
 
     it "should fail if the service isn't there" do
       paths.each do |path|
-        File.expects(:exist?).with("#{path}/myservice").returns false
-        File.expects(:exist?).with("#{path}/myservice.sh").returns false
+        Puppet::FileSystem::File.expects(:exist?).with("#{path}/myservice").returns false
+        Puppet::FileSystem::File.expects(:exist?).with("#{path}/myservice.sh").returns false
       end
       expect { provider.initscript }.to raise_error(Puppet::Error, "Could not find init script for 'myservice'")
     end
@@ -134,7 +134,7 @@ describe Puppet::Type.type(:service).provider(:init) do
     before :each do
       File.stubs(:directory?).with("/service/path").returns true
       File.stubs(:directory?).with("/alt/service/path").returns true
-      File.stubs(:exist?).with("/service/path/myservice").returns true
+      Puppet::FileSystem::File.stubs(:exist?).with("/service/path/myservice").returns true
     end
 
     [:start, :stop, :status, :restart].each do |method|

data/spec/unit/provider/service/launchd_spec.rb

@@ -209,29 +209,82 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
-  describe "when encountering malformed plists" do
-    let(:plist_without_label) do
-      {
-        'LimitLoadToSessionType' => 'Aqua'
-      }
-    end
-    let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
-
-    it "[17624] should warn that the plist in question is being skipped" do
-      provider.expects(:launchd_paths).returns(['/Library/LaunchAgents'])
-      provider.expects(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').returns([busted_plist_path])
-      provider.expects(:read_plist).with(busted_plist_path).returns(plist_without_label)
-      Puppet.expects(:warning).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
-      provider.jobsearch
-    end
-
-    it "[15929] should skip plists that plutil cannot read" do
-      provider.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout',
-        busted_plist_path).raises(Puppet::ExecutionFailure, 'boom')
-      Puppet.expects(:warning).with("Cannot read file #{busted_plist_path}; " +
-                                    "Puppet is skipping it. \n" +
-                                    "Details: boom")
-      provider.read_plist(busted_plist_path)
+  describe "make_label_to_path_map" do
+    before do
+      # clear out this class variable between runs
+      if provider.instance_variable_defined? :@label_to_path_map
+        provider.send(:remove_instance_variable, :@label_to_path_map)
+      end
+    end
+    describe "when encountering malformed plists" do
+      let(:plist_without_label) do
+        {
+          'LimitLoadToSessionType' => 'Aqua'
+        }
+      end
+      let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
+
+      it "[17624] should warn that the plist in question is being skipped" do
+        provider.expects(:launchd_paths).returns(['/Library/LaunchAgents'])
+        provider.expects(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').returns([busted_plist_path])
+        provider.expects(:read_plist).with(busted_plist_path).returns(plist_without_label)
+        Puppet.expects(:warning).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
+        provider.make_label_to_path_map
+      end
+
+      it "[15929] should skip plists that plutil cannot read" do
+        provider.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout',
+          busted_plist_path).raises(Puppet::ExecutionFailure, 'boom')
+        Puppet.expects(:warning).with("Cannot read file #{busted_plist_path}; " +
+                                      "Puppet is skipping it. \n" +
+                                      "Details: boom")
+        provider.read_plist(busted_plist_path)
+      end
+    end
+    it "should return the cached value when available" do
+      provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
+      provider.make_label_to_path_map.should eq({'xx'=>'yy'})
+    end
+    describe "when successful" do
+      let(:launchd_dir) { '/Library/LaunchAgents' }
+      let(:plist) { launchd_dir + '/foo.bar.service.plist' }
+      let(:label) { 'foo.bar.service' }
+      before do
+        provider.instance_variable_set(:@label_to_path_map, nil)
+        provider.expects(:launchd_paths).returns([launchd_dir])
+        provider.expects(:return_globbed_list_of_file_paths).with(launchd_dir).returns([plist])
+        provider.expects(:read_plist).with(plist).returns({'Label'=>'foo.bar.service'})
+      end
+      it "should read the plists and return their contents" do
+        provider.make_label_to_path_map.should eq({label=>plist})
+      end
+      it "should re-read the plists and return their contents when refreshed" do
+        provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
+        provider.make_label_to_path_map(true).should eq({label=>plist})
+      end
+    end
+  end
+
+  describe "jobsearch" do
+    let(:map) { {"org.mozilla.puppet" => "/path/to/puppet.plist",
+                 "org.mozilla.python" => "/path/to/python.plist"} }
+    it "returns the entire map with no args" do
+      provider.expects(:make_label_to_path_map).returns(map)
+      provider.jobsearch.should == map
+    end
+    it "returns a singleton hash when given a label" do
+      provider.expects(:make_label_to_path_map).returns(map)
+      provider.jobsearch("org.mozilla.puppet").should == { "org.mozilla.puppet" => "/path/to/puppet.plist" }
+    end
+    it "refreshes the label_to_path_map when label is not found" do
+      provider.expects(:make_label_to_path_map).with().returns({})
+      provider.expects(:make_label_to_path_map).with(true).returns(map)
+      provider.jobsearch("org.mozilla.puppet").should == { "org.mozilla.puppet" => "/path/to/puppet.plist" }
+    end
+    it "raises Puppet::Error when the label is still not found" do
+      provider.expects(:make_label_to_path_map).with().returns(map)
+      provider.expects(:make_label_to_path_map).with(true).returns(map)
+      expect { provider.jobsearch("NOSUCH") }.to raise_error(Puppet::Error)
     end
   end
 end