puppet 3.4.3 → 3.5.0.rc1

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

@@ -200,42 +200,38 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
       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|
+        parameters = 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
+
+        expect(parameters[0][:name]).to match(%r{unmanaged:\$HOME/bin/daily.job_>>_\$HOME/tmp/out_2>&1-\d+})
+        expect(parameters[0][:minute]).to eq(['5'])
+        expect(parameters[0][:hour]).to eq(['0'])
+        expect(parameters[0][:weekday]).to eq(:absent)
+        expect(parameters[0][:month]).to eq(:absent)
+        expect(parameters[0][:monthday]).to eq(:absent)
+        expect(parameters[0][:special]).to eq(:absent)
+        expect(parameters[0][:command]).to match(%r{\$HOME/bin/daily.job >> \$HOME/tmp/out 2>&1})
+        expect(parameters[0][:ensure]).to eq(:present)
+        expect(parameters[0][:environment]).to eq(:absent)
+        expect(parameters[0][:user]).to eq(:absent)
+
+        expect(parameters[1][:name]).to match(%r{unmanaged:\$HOME/bin/monthly-\d+})
+        expect(parameters[1][:minute]).to eq(['15'])
+        expect(parameters[1][:hour]).to eq(['14'])
+        expect(parameters[1][:weekday]).to eq(:absent)
+        expect(parameters[1][:month]).to eq(:absent)
+        expect(parameters[1][:monthday]).to eq(['1'])
+        expect(parameters[1][:special]).to eq(:absent)
+        expect(parameters[1][:command]).to match(%r{\$HOME/bin/monthly})
+        expect(parameters[1][:ensure]).to eq(:present)
+        expect(parameters[1][:environment]).to eq(:absent)
+        expect(parameters[1][:user]).to eq(:absent)
+        expect(parameters[1][:target]).to eq('foobar')
       end
 
       it "should be able to parse puppet manged cronjobs" do

data/spec/unit/provider/file/posix_spec.rb

@@ -85,7 +85,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
   describe "#owner" do
     it "should return the uid of the file owner" do
       FileUtils.touch(path)
-      owner = Puppet::FileSystem::File.new(path).stat.uid
+      owner = Puppet::FileSystem.stat(path).uid
 
       provider.owner.should == owner
     end
@@ -178,7 +178,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
   describe "#group" do
     it "should return the gid of the file group" do
       FileUtils.touch(path)
-      group = Puppet::FileSystem::File.new(path).stat.gid
+      group = Puppet::FileSystem.stat(path).gid
 
       provider.group.should == group
     end

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -138,6 +138,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi) do
   end
 
   it "should be able to test whether a group exists" do
+    Puppet::Util::ADSI.stubs(:sid_uri_safe).returns(nil)
     Puppet::Util::ADSI.stubs(:connect).returns stub('connection')
     provider.should be_exists
 

data/spec/unit/provider/mount_spec.rb

@@ -79,11 +79,22 @@ describe Puppet::Provider::Mount do
       @mounter.remount
     end
 
+    it "should mount with '-o update' on OpenBSD" do
+      @mounter.stubs(:info)
+      @mounter.stubs(:options)
+      @resource.stubs(:[]).with(:remounts).returns(false)
+      Facter.expects(:value).with(:operatingsystem).returns 'OpenBSD'
+      @mounter.expects(:mountcmd).with("-o", "update", @name)
+      @mounter.remount
+    end
+
     it "should unmount and mount if the resource does not specify it supports remounting" do
       @mounter.stubs(:info)
+      @mounter.stubs(:options)
       @resource.stubs(:[]).with(:remounts).returns(false)
-      @mounter.expects(:unmount)
+      Facter.expects(:value).with(:operatingsystem).returns 'AIX'
       @mounter.expects(:mount)
+      @mounter.expects(:unmount)
       @mounter.remount
     end
 

data/spec/unit/provider/nameservice/directoryservice_spec.rb

@@ -110,7 +110,7 @@ describe 'DirectoryService password behavior' do
 
   it 'should execute convert_binary_to_xml once when getting the password on >= 10.7' do
     subject.expects(:convert_binary_to_xml).returns({'SALTED-SHA512' => StringIO.new(pw_string)})
-    Puppet::FileSystem::File.expects(:exist?).with(plist_path).once.returns(true)
+    Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
     Plist.expects(:parse_xml).returns(shadow_hash_data)
     # On Mac OS X 10.7 we first need to convert to xml when reading the password
     subject.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', plist_path)
@@ -126,7 +126,7 @@ describe 'DirectoryService password behavior' do
   it 'should convert xml-to-binary and binary-to-xml when setting the pw on >= 10.7' do
     subject.expects(:convert_binary_to_xml).returns({'SALTED-SHA512' => StringIO.new(pw_string)})
     subject.expects(:convert_xml_to_binary).returns(binary_plist)
-    Puppet::FileSystem::File.expects(:exist?).with(plist_path).once.returns(true)
+    Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
     Plist.expects(:parse_xml).returns(shadow_hash_data)
     # On Mac OS X 10.7 we first need to convert to xml
     subject.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', plist_path)
@@ -138,7 +138,7 @@ describe 'DirectoryService password behavior' do
 
   it '[#13686] should handle an empty ShadowHashData field in the users plist' do
     subject.expects(:convert_xml_to_binary).returns(binary_plist)
-    Puppet::FileSystem::File.expects(:exist?).with(plist_path).once.returns(true)
+    Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
     Plist.expects(:parse_xml).returns({'ShadowHashData' => nil})
     subject.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', plist_path)
     subject.expects(:plutil).with('-convert', 'binary1', plist_path)

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

@@ -63,7 +63,7 @@ Version table:
 
   it "should preseed with the provided responsefile when preseeding is called for" do
     @resource.expects(:[]).with(:responsefile).returns "/my/file"
-    Puppet::FileSystem::File.expects(:exist?).with("/my/file").returns true
+    Puppet::FileSystem.expects(:exist?).with("/my/file").returns true
 
     @provider.expects(:info)
     @provider.expects(:preseed).with("/my/file")

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

@@ -18,7 +18,7 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
 
     def rpm
       pkg.provider.expects(:rpm).
-        with('-q', 'faff', '--nosignature', '--nodigest', '--qf',
+        with('-q', '--whatprovides', 'faff', '--nosignature', '--nodigest', '--qf',
              "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n")
     end
 

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

@@ -130,6 +130,18 @@ describe provider_class do
       ]
     end
 
+    it "should ignore platform specifications" do
+      provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
+        systemu (1.2.0)
+        nokogiri (1.6.1 ruby java x86-mingw32 x86-mswin32-60, 1.4.4.1 x86-mswin32)
+      HEREDOC
+
+      provider_class.instances.map {|p| p.properties}.should == [
+        {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
+        {:ensure => ["1.6.1", "1.4.4.1"], :provider => :gem, :name => 'nokogiri'}
+      ]
+    end
+
     it "should not fail when an unmatched line is returned" do
       provider_class.expects(:execute).with(%w{/my/gem list --local}).
         returns(File.read(my_fixture('line-with-1.8.5-warning')))

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

@@ -36,6 +36,10 @@ describe Puppet::Type.type(:package).provider(:msi) do
   end
 
   describe 'on Windows', :as_platform => :windows do
+    after :each do
+      Puppet::Type.type(:package).defaultprovider = nil
+    end
+
     it 'should not be the default provider' do
       # provider.expects(:execute).never
       Puppet::Type.type(:package).defaultprovider.should_not == subject.class

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

@@ -10,22 +10,22 @@ describe provider_class do
 
   def expect_read_from_pkgconf(lines)
     pkgconf = stub(:readlines => lines)
-    Puppet::FileSystem::File.expects(:exist?).with('/etc/pkg.conf').returns(true)
+    Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
     File.expects(:open).with('/etc/pkg.conf', 'rb').returns(pkgconf)
   end
 
   def expect_pkgadd_with_source(source)
     provider.expects(:pkgadd).with do |fullname|
-      ENV.should_not be_key 'PKG_PATH'
+      ENV.should_not be_key('PKG_PATH')
       fullname.should == source
     end
   end
 
   def expect_pkgadd_with_env_and_name(source, &block)
-    ENV.should_not be_key 'PKG_PATH'
+    ENV.should_not be_key('PKG_PATH')
 
     provider.expects(:pkgadd).with do |fullname|
-      ENV.should be_key 'PKG_PATH'
+      ENV.should be_key('PKG_PATH')
       ENV['PKG_PATH'].should == source
 
       fullname.should == provider.resource[:name]
@@ -34,7 +34,7 @@ describe provider_class do
 
     yield
 
-    ENV.should_not be_key 'PKG_PATH'
+    ENV.should_not be_key('PKG_PATH')
   end
 
   before :each do
@@ -76,27 +76,27 @@ describe provider_class do
 
   context "#install" do
     it "should fail if the resource doesn't have a source" do
-      Puppet::FileSystem::File.expects(:exist?).with('/etc/pkg.conf').returns(false)
+      Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(false)
 
       expect {
         provider.install
-      }.to raise_error Puppet::Error, /must specify a package source/
+      }.to raise_error(Puppet::Error, /must specify a package source/)
     end
 
     it "should fail if /etc/pkg.conf exists, but is not readable" do
-      Puppet::FileSystem::File.expects(:exist?).with('/etc/pkg.conf').returns(true)
+      Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
       File.expects(:open).with('/etc/pkg.conf', 'rb').raises(Errno::EACCES)
 
       expect {
         provider.install
-      }.to raise_error Errno::EACCES, /Permission denied/
+      }.to raise_error(Errno::EACCES, /Permission denied/)
     end
 
     it "should fail if /etc/pkg.conf exists, but there is no installpath" do
       expect_read_from_pkgconf([])
       expect {
         provider.install
-      }.to raise_error Puppet::Error, /No valid installpath found in \/etc\/pkg\.conf and no source was set/
+      }.to raise_error(Puppet::Error, /No valid installpath found in \/etc\/pkg\.conf and no source was set/)
     end
 
     it "should install correctly when given a directory-unlike source" do

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

@@ -12,6 +12,8 @@ describe provider do
   before do
     resolver.stubs(:which).with('/usr/bin/pacman').returns('/usr/bin/pacman')
     provider.stubs(:which).with('/usr/bin/pacman').returns('/usr/bin/pacman')
+    resolver.stubs(:which).with('/usr/bin/yaourt').returns('/usr/bin/yaourt')
+    provider.stubs(:which).with('/usr/bin/yaourt').returns('/usr/bin/yaourt')
     @resource = Puppet::Type.type(:package).new(:name => 'package')
     @provider = provider.new(@resource)
   end
@@ -24,11 +26,18 @@ describe provider do
     end
 
     it "should call pacman to install the right package quietly" do
+
+      if @provider.yaourt?
+        args = ['/usr/bin/yaourt', '--noconfirm', '-S', @resource[:name]]
+      else
+        args = ['/usr/bin/pacman', '--noconfirm', '--noprogressbar', '-Sy', @resource[:name]]
+      end
+
       executor.
         expects(:execute).
         at_least_once.
-        with(["/usr/bin/pacman", "--noconfirm", "--noprogressbar", "-Sy", @resource[:name]], no_extra_options).
-        returns ""
+        with(args, no_extra_options).
+        returns ''
 
       @provider.install
     end
@@ -186,15 +195,22 @@ EOF
     end
   end
 
+
+
   describe "when fetching a package list" do
-    it "should query pacman" do
+    it "should retrieve installed packages" do
       provider.expects(:execpipe).with(["/usr/bin/pacman", '-Q'])
-      provider.instances
+      provider.installedpkgs
+    end
+
+    it "should retrieve installed package groups" do
+      provider.expects(:execpipe).with(["/usr/bin/pacman", '-Qg'])
+      provider.installedgroups
     end
 
     it "should return installed packages with their versions" do
       provider.expects(:execpipe).yields(StringIO.new("package1 1.23-4\npackage2 2.00\n"))
-      packages = provider.instances
+      packages = provider.installedpkgs
 
       packages.length.should == 2
 
@@ -211,15 +227,28 @@ EOF
       }
     end
 
+    it "should return installed groups with a dummy version" do
+      provider.expects(:execpipe).yields(StringIO.new("group1 pkg1\ngroup1 pkg2"))
+      groups = provider.installedgroups
+
+      groups.length.should == 1
+
+      groups[0].properties.should == {
+        :provider => :pacman,
+        :ensure   => '1',
+        :name     => 'group1'
+      }
+    end
+
     it "should return nil on error" do
-      provider.expects(:execpipe).raises(Puppet::ExecutionFailure.new("ERROR!"))
+      provider.expects(:execpipe).twice.raises(Puppet::ExecutionFailure.new("ERROR!"))
       provider.instances.should be_nil
     end
 
     it "should warn on invalid input" do
       provider.expects(:execpipe).yields(StringIO.new("blah"))
       provider.expects(:warning).with("Failed to match line blah")
-      provider.instances.should == []
+      provider.installedpkgs == []
     end
   end
 

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

@@ -3,8 +3,8 @@ require "spec_helper"
 provider_class = Puppet::Type.type(:package).provider(:pkgin)
 
 describe provider_class do
-  let(:resource) { Puppet::Type.type(:package).new(:name => "vim") }
-  subject        { provider_class.new(resource) }
+  let(:resource) { Puppet::Type.type(:package).new(:name => "vim", :provider => :pkgin) }
+  subject        { resource.provider }
 
   describe "Puppet provider interface" do
     it "can return the list of all packages" do
@@ -13,19 +13,28 @@ describe provider_class do
   end
 
   describe "#install" do
-    before { resource[:ensure] = :absent }
 
+   describe "a package not installed" do
+    before { resource[:ensure] = :absent }
     it "uses pkgin install to install" do
-      subject.expects(:pkgin).with("-y", :install, "vim")
+      subject.expects(:pkgin).with("-y", :install, "vim").once()
+      subject.install
+    end
+   end
+
+   describe "a package with a fixed version" do
+    before { resource[:ensure] = '7.2.446' }
+    it "uses pkgin install to install a fixed version" do
+      subject.expects(:pkgin).with("-y", :install, "vim-7.2.446").once()
       subject.install
     end
+   end
+
   end
 
   describe "#uninstall" do
-    before { resource[:ensure] = :present }
-
     it "uses pkgin remove to uninstall" do
-      subject.expects(:pkgin).with("-y", :remove, "vim")
+      subject.expects(:pkgin).with("-y", :remove, "vim").once()
       subject.uninstall
     end
   end
@@ -50,13 +59,13 @@ describe provider_class do
     it "populates each provider with an installed package" do
       zlib_provider, zziplib_provider = provider_class.instances
       zlib_provider.get(:name).should == "zlib"
-      zlib_provider.get(:ensure).should == :present
+      zlib_provider.get(:ensure).should == "1.2.3"
       zziplib_provider.get(:name).should == "zziplib"
-      zziplib_provider.get(:ensure).should == :present
+      zziplib_provider.get(:ensure).should == "0.13.59"
     end
   end
 
-  describe "#query" do
+  describe "#latest" do
     before do
       provider_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
     end
@@ -66,60 +75,62 @@ describe provider_class do
         "vim-7.2.446 =        Vim editor (vi clone) without GUI\nvim-share-7.2.446 =  Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
       end
 
-      it "returns a hash stating the package is present" do
-        result = subject.query
-        result[:ensure].should == :present
-        result[:name].should == "vim"
-        result[:provider].should == :pkgin
+      it "returns installed version" do
+        subject.expects(:properties).returns( { :ensure => "7.2.446" } )
+        subject.latest.should == "7.2.446"
       end
     end
 
     context "when the package is out of date" do
       let(:pkgin_search_output) do
-        "vim-7.2.446 <        Vim editor (vi clone) without GUI\nvim-share-7.2.446 =  Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
+        "vim-7.2.447 <        Vim editor (vi clone) without GUI\nvim-share-7.2.447 <  Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
       end
 
-      it "returns a hash stating the package is present" do
-        result = subject.query
-        result[:ensure].should == :present
-        result[:name].should == "vim"
-        result[:provider].should == :pkgin
+      it "returns the version to be installed" do
+        subject.latest.should == "7.2.447"
       end
     end
 
     context "when the package is ahead of date" do
       let(:pkgin_search_output) do
-        "vim-7.2.446 >        Vim editor (vi clone) without GUI\nvim-share-7.2.446 =  Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
+        "vim-7.2.446 >        Vim editor (vi clone) without GUI\nvim-share-7.2.446 >  Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
       end
 
-      it "returns a hash stating the package is present" do
-        result = subject.query
-        result[:ensure].should == :present
-        result[:name].should == "vim"
-        result[:provider].should == :pkgin
+      it "returns current version" do
+        subject.expects(:properties).returns( { :ensure => "7.2.446" } )
+        subject.latest.should == "7.2.446"
       end
     end
 
-    context "when the package is not installed" do
+    context "when multiple candidates do exists" do
       let(:pkgin_search_output) do
-        "vim-7.2.446          Vim editor (vi clone) without GUI\nvim-share-7.2.446 =  Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
+        <<-SEARCH
+vim-7.1 >            Vim editor (vi clone) without GUI
+vim-share-7.1 >      Data files for the vim editor (vi clone)
+vim-7.2.446 =        Vim editor (vi clone) without GUI
+vim-share-7.2.446 =  Data files for the vim editor (vi clone)
+vim-7.3 <            Vim editor (vi clone) without GUI
+vim-share-7.3 <      Data files for the vim editor (vi clone)
+
+=: package is installed and up-to-date
+<: package is installed but newer version is available
+>: installed package has a greater version than available package
+SEARCH
       end
 
-      it "returns a hash stating the package is present" do
-        result = subject.query
-        result[:ensure].should == :absent
-        result[:name].should == "vim"
-        result[:provider].should == :pkgin
+      it "returns the newest available version" do
+        provider_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
+        subject.latest.should == "7.3"
       end
     end
 
     context "when the package cannot be found" do
       let(:pkgin_search_output) do
-        "\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
+        "No results found for is-puppet"
       end
 
       it "returns nil" do
-        subject.query.should be_nil
+        expect { subject.latest }.to raise_error(Puppet::Error, "No candidate to be installed")
       end
     end
   end
@@ -129,21 +140,19 @@ describe provider_class do
       let(:package) { "vim-7.2.446 =        Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        hash = provider_class.parse_pkgin_line(package)
-        hash[:name].should == "vim"
-        hash[:ensure].should == :present
-        hash[:provider].should == :pkgin
+        provider_class.parse_pkgin_line(package).should == { :name => "vim" ,
+                                                             :status => "=" ,
+                                                             :ensure => "7.2.446" }
       end
     end
 
     context "with an installed package with a hyphen in the name" do
-      let(:package) { "ruby18-puppet-0.25.5nb1 = Configuration management framework written in Ruby" }
+      let(:package) { "ruby18-puppet-0.25.5nb1 > Configuration management framework written in Ruby" }
 
       it "extracts the name and status" do
-        hash = provider_class.parse_pkgin_line(package)
-        hash[:name].should == "ruby18-puppet"
-        hash[:ensure].should == :present
-        hash[:provider].should == :pkgin
+        provider_class.parse_pkgin_line(package).should == { :name =>  "ruby18-puppet",
+                                                             :status => ">" ,
+                                                             :ensure => "0.25.5nb1" }
       end
     end
 
@@ -151,18 +160,11 @@ describe provider_class do
       let(:package) { "vim-7.2.446          Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        hash = provider_class.parse_pkgin_line(package)
-        hash[:name].should == "vim"
-        hash[:ensure].should == :absent
-        hash[:provider].should == :pkgin
+        provider_class.parse_pkgin_line(package).should == { :name => "vim" ,
+                                                             :status => nil ,
+                                                             :ensure => "7.2.446" }
       end
 
-      it "extracts the name and an overridden status" do
-        hash = provider_class.parse_pkgin_line(package, :present)
-        hash[:name].should == "vim"
-        hash[:ensure].should == :present
-        hash[:provider].should == :pkgin
-      end
     end
 
     context "with an invalid package" do