puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/unit/type/cron_spec.rb

@@ -452,7 +452,7 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
     describe "special" do
       %w(reboot yearly annually monthly weekly daily midnight hourly).each do |value|
         it "should support the value '#{value}'" do
-          expect { described_class.new(:name => 'foo', :special => value ) }.to_not raise_error(Puppet::Error, /cannot specify both a special schedule and a value/)
+          expect { described_class.new(:name => 'foo', :special => value ) }.to_not raise_error
         end
       end
 
@@ -462,7 +462,7 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
             it "should accept the value '#{value}' for special" do
               expect {
                 described_class.new(:name => 'foo', :minute => :absent, :special => value )
-              }.to_not raise_error(Puppet::Error, /cannot specify both a special schedule and a value/)
+              }.to_not raise_error
             end
           }
         end
@@ -477,7 +477,7 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
           it "should accept the 'absent' value for special" do
             expect {
               described_class.new(:name => 'foo', :minute => "1", :special => :absent )
-            }.to_not raise_error(Puppet::Error, /cannot specify both a special schedule and a value/)
+            }.to_not raise_error
           end
         end
       end

data/spec/unit/type/exec_spec.rb

@@ -204,6 +204,15 @@ describe Puppet::Type.type(:exec) do
         }.to raise_error Puppet::Error, /Parameter user failed/
       end
 
+      it "accepts the current user" do
+        Puppet.features.stubs(:root?).returns(false)
+        Etc.stubs(:getpwuid).returns(Struct::Passwd.new('input'))
+
+        type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => 'input')
+
+        expect(type[:user]).to eq('input')
+      end
+
       ['one', 2, 'root', 4294967295, 4294967296].each do |value|
         it "should accept '#{value}' as user if we are root" do
           Puppet.features.stubs(:root?).returns(true)

data/spec/unit/type/file/content_spec.rb

@@ -332,7 +332,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     end
 
     describe "from local source" do
-      let(:source_content) { "source file content\r\n"*10000 }
+      let(:source_content) { "source file content\r\n"*10 }
       before(:each) do
         sourcename = tmpfile('source')
         resource[:backup] = false
@@ -362,104 +362,87 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       end
     end
 
-    describe "from an explicit fileserver" do
-      let(:source_content) { "source file content\n"*10000 }
-      let(:response) { stub_everything 'response' }
+    describe 'from remote source' do
+      let(:source_content) { "source file content\n"*10 }
       let(:source) { resource.newattr(:source) }
+      let(:response) { stub_everything('response') }
+      let(:conn) { mock('connection') }
 
       before(:each) do
         resource[:backup] = false
-        response.stubs(:read_body).multiple_yields(*(["source file content\n"]*10000))
-
-        conn = mock('connection')
-        conn.stubs(:request_get).yields response
-
-        Puppet::Network::HttpPool.expects(:http_instance).with('somehostname',any_parameters).returns(conn).at_least_once
-
         # This needs to be invoked to properly initialize the content property,
         # or attempting to write a file will fail.
         resource.newattr(:content)
 
-        source.stubs(:metadata).returns stub_everything('metadata', :source => "puppet://somehostname/test/foo", :ftype => 'file')
+        response.stubs(:read_body).multiple_yields(*source_content.lines)
+        conn.stubs(:request_get).yields(response)
       end
 
-      describe "and the request was successful" do
-        before { response.stubs(:code).returns '200' }
-
-        it "should write the contents to the file" do
-          resource.write(source)
-          Puppet::FileSystem.binread(filename).should == source_content
-        end
+      it 'should use an explicit fileserver if source starts with puppet://' do
+        response.stubs(:code).returns('200')
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet://somehostname/test/foo', :ftype => 'file')
+        Puppet::Network::HttpPool.expects(:http_instance).with('somehostname', anything).returns(conn)
 
-        with_digest_algorithms do
-          it "should return the checksum computed" do
-            File.open(filename, 'w') do |file|
-              resource[:checksum] = digest_algorithm
-              content.write(file).should == "{#{digest_algorithm}}#{digest(source_content)}"
-            end
-          end
-        end
+        resource.write(source)
       end
 
-      it "should not write anything if source is not found" do
-        response.stubs(:code).returns("404")
-        expect { resource.write(source) }.to raise_error(Net::HTTPError, /404/)
-        File.read(filename).should == "initial file content"
-      end
+      it 'should use the default fileserver if source starts with puppet:///' do
+        response.stubs(:code).returns('200')
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo', :ftype => 'file')
+        Puppet::Network::HttpPool.expects(:http_instance).with(Puppet.settings[:server], anything).returns(conn)
 
-      it "should raise an HTTP error in case of server error" do
-        response.stubs(:code).returns("500")
-        expect { content.write(fh) }.to raise_error(Net::HTTPError, /500/)
+        resource.write(source)
       end
 
-    end
+      it 'should percent encode reserved characters' do
+        response.stubs(:code).returns('200')
+        Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file')
 
-    describe "from remote source" do
-      let(:source_content) { "source file content\n"*10000 }
-      let(:response) { stub_everything 'response' }
-      let(:source) { resource.newattr(:source) }
+        conn.unstub(:request_get)
+        conn.expects(:request_get).with('/none/file_content/test/foo%20bar', anything).yields(response)
 
-      before(:each) do
-        resource[:backup] = false
-        response.stubs(:read_body).multiple_yields(*(["source file content\n"]*10000))
+        resource.write(source)
+      end
 
-        conn = stub_everything 'connection'
-        conn.stubs(:request_get).yields response
-        Puppet::Network::HttpPool.stubs(:http_instance).returns conn
+      describe 'when handling file_content responses' do
+        before(:each) do
+          Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
+          source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo', :ftype => 'file')
+        end
 
-        # This needs to be invoked to properly initialize the content property,
-        # or attempting to write a file will fail.
-        resource.newattr(:content)
-        source.stubs(:metadata).returns stub_everything('metadata', :source => "puppet://somehostname/test/foo", :ftype => 'file')
-      end
+        it 'should not write anything if source is not found' do
+          response.stubs(:code).returns('404')
+
+          expect { resource.write(source) }.to raise_error(Net::HTTPError, /404/)
+          expect(File.read(filename)).to eq('initial file content')
+        end
 
-      describe "and the request was successful" do
-        before { response.stubs(:code).returns '200' }
+        it 'should raise an HTTP error in case of server error' do
+          response.stubs(:code).returns('500')
 
-        it "should write the contents to the file" do
-          resource.write(source)
-          Puppet::FileSystem.binread(filename).should == source_content
+          expect { resource.write(source) }.to raise_error(Net::HTTPError, /500/)
         end
 
-        with_digest_algorithms do
-          it "should return the checksum computed" do
-            File.open(filename, 'w') do |file|
-              resource[:checksum] = digest_algorithm
-              content.write(file).should == "{#{digest_algorithm}}#{digest(source_content)}"
+        context 'and the request was successful' do
+          before(:each) { response.stubs(:code).returns '200' }
+
+          it 'should write the contents to the file' do
+            resource.write(source)
+            expect(Puppet::FileSystem.binread(filename)).to eq(source_content)
+          end
+
+          with_digest_algorithms do
+            it 'should return the checksum computed' do
+              File.open(filename, 'w') do |file|
+                resource[:checksum] = digest_algorithm
+                expect(content.write(file)).to eq("{#{digest_algorithm}}#{digest(source_content)}")
+              end
             end
           end
-        end
-      end
 
-      it "should not write anything if source is not found" do
-        response.stubs(:code).returns("404")
-        expect {resource.write(source)}.to raise_error(Net::HTTPError, /404/)
-        File.read(filename).should == "initial file content"
-      end
+        end
 
-      it "should raise an HTTP error in case of server error" do
-        response.stubs(:code).returns("500")
-        expect { content.write(fh) }.to raise_error(Net::HTTPError, /500/)
       end
     end
 

data/spec/unit/type/file/mode_spec.rb

@@ -6,7 +6,7 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
   include PuppetSpec::Files
 
   let(:path) { tmpfile('mode_spec') }
-  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0644 }
+  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => '0644' }
   let(:mode) { resource.property(:mode) }
 
   describe "#validate" do
@@ -192,4 +192,29 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
       (stat.mode & 0777).to_s(8).should == "644"
     end
   end
+
+  describe '#sync with a symbolic mode of +X for a file' do
+    let(:resource_sym) { Puppet::Type.type(:file).new :path => path, :mode => 'g+wX' }
+    let(:mode_sym) { resource_sym.property(:mode) }
+
+    before { FileUtils.touch(path) }
+
+    it 'does not change executable bit if no executable bit is set' do
+      Puppet::FileSystem.chmod(0644, path)
+
+      mode_sym.sync
+
+      stat = Puppet::FileSystem.stat(path)
+      (stat.mode & 0777).to_s(8).should == '664'
+    end
+
+    it 'does change executable bit if an executable bit is set' do
+      Puppet::FileSystem.chmod(0744, path)
+
+      mode_sym.sync
+
+      stat = Puppet::FileSystem.stat(path)
+      (stat.mode & 0777).to_s(8).should == '774'
+    end
+  end
 end

data/spec/unit/type/file/source_spec.rb

@@ -176,7 +176,7 @@ describe Puppet::Type.type(:file).attrclass(:source) do
   end
 
   describe "when copying the source values" do
-    before do
+    before :each do
       @resource = Puppet::Type.type(:file).new :path => @foobar
 
       @source = source.new(:resource => @resource)
@@ -186,6 +186,28 @@ describe Puppet::Type.type(:file).attrclass(:source) do
       Puppet.features.stubs(:root?).returns true
     end
 
+    it "should not issue a deprecation warning if the source mode value is a Numeric" do
+      @metadata.stubs(:mode).returns 0173
+      if Puppet::Util::Platform.windows?
+        Puppet.expects(:deprecation_warning).with(regexp_matches(/Copying owner\/mode\/group from the source file on Windows is deprecated/)).at_least_once
+      else
+        Puppet.expects(:deprecation_warning).never
+      end
+
+      @source.copy_source_values
+    end
+
+    it "should not issue a deprecation warning if the source mode value is a String" do
+      @metadata.stubs(:mode).returns "173"
+      if Puppet::Util::Platform.windows?
+        Puppet.expects(:deprecation_warning).with(regexp_matches(/Copying owner\/mode\/group from the source file on Windows is deprecated/)).at_least_once
+      else
+        Puppet.expects(:deprecation_warning).never
+      end
+
+      @source.copy_source_values
+    end
+
     it "should fail if there is no metadata" do
       @source.stubs(:metadata).returns nil
       @source.expects(:devfail).raises ArgumentError
@@ -409,7 +431,7 @@ describe Puppet::Type.type(:file).attrclass(:source) do
           @source.stubs(:local?).returns false
           Puppet.expects(:deprecation_warning).with(deprecation_message).at_least_once
           @resource[:group] = 2
-          @resource[:mode] = 3
+          @resource[:mode] = "0003"
 
           @source.copy_source_values
         end
@@ -418,7 +440,7 @@ describe Puppet::Type.type(:file).attrclass(:source) do
           @source.stubs(:local?).returns false
           Puppet.expects(:deprecation_warning).with(deprecation_message).at_least_once
           @resource[:owner] = 1
-          @resource[:mode] = 3
+          @resource[:mode] = "0003"
 
           @source.copy_source_values
         end
@@ -437,7 +459,7 @@ describe Puppet::Type.type(:file).attrclass(:source) do
           Puppet.expects(:deprecation_warning).with(deprecation_message).never
           @resource[:owner] = 1
           @resource[:group] = 2
-          @resource[:mode] = 3
+          @resource[:mode] = "0003"
 
           @source.copy_source_values
         end

data/spec/unit/type/file_spec.rb

@@ -418,7 +418,7 @@ describe Puppet::Type.type(:file) do
     it "should not copy values to the child which were set by the source" do
       source = File.expand_path(__FILE__)
       file[:source] = source
-      metadata = stub 'metadata', :owner => "root", :group => "root", :mode => 0755, :ftype => "file", :checksum => "{md5}whatever", :source => source
+      metadata = stub 'metadata', :owner => "root", :group => "root", :mode => '0755', :ftype => "file", :checksum => "{md5}whatever", :source => source
       file.parameter(:source).stubs(:metadata).returns metadata
 
       file.parameter(:source).copy_source_values
@@ -1357,13 +1357,13 @@ describe Puppet::Type.type(:file) do
       target = described_class.new(
         :ensure => :file, :path => @target,
         :catalog => catalog, :content => 'yayness',
-        :mode => 0644)
+        :mode => '0644')
       catalog.add_resource target
 
       @link_resource = described_class.new(
         :ensure => :link, :path => @link,
         :target => @target, :catalog => catalog,
-        :mode => 0755)
+        :mode => '0755')
       catalog.add_resource @link_resource
 
       # to prevent the catalog from trying to write state.yaml

data/spec/unit/type/nagios_spec.rb

@@ -125,7 +125,7 @@ EOL
       parser =  Nagios::Parser.new
       expect {
         results = parser.parse(ESCAPED_SEMICOLON)
-      }.to_not raise_error Nagios::Parser::SyntaxError
+      }.to_not raise_error
     end
 
     it "should ignore it if it is a comment" do
@@ -147,7 +147,7 @@ EOL
       parser =  Nagios::Parser.new
       expect {
         results = parser.parse(POUND_SIGN_HASH_SYMBOL_NOT_IN_FIRST_COLUMN)
-      }.to_not raise_error Nagios::Parser::SyntaxError
+      }.to_not raise_error
     end
 
 
@@ -170,7 +170,7 @@ EOL
       parser =  Nagios::Parser.new
       expect {
         results = parser.parse(ANOTHER_ESCAPED_SEMICOLON)
-      }.to_not raise_error Nagios::Parser::SyntaxError
+      }.to_not raise_error
     end
 
     it "should parse correctly" do
@@ -217,6 +217,15 @@ describe "Nagios generator" do
     results = parser.parse(nagios_type.to_s)
     results[0].command_line.should eql(param)
   end
+
+  it "should accept FixNum params and convert to string" do
+    param = 1
+    nagios_type = Nagios::Base.create(:serviceescalation)
+    nagios_type.first_notification = param
+    parser =  Nagios::Parser.new
+    results = parser.parse(nagios_type.to_s)
+    results[0].first_notification.should eql(param.to_s)
+  end
 end
 
 describe "Nagios resource types" do

data/spec/unit/type/resources_spec.rb

@@ -5,6 +5,11 @@ resources = Puppet::Type.type(:resources)
 
 # There are still plenty of tests to port over from test/.
 describe resources do
+
+  before :each do
+    described_class.reset_system_users_max_uid!
+  end
+
   describe "when initializing" do
     it "should fail if the specified resource type does not exist" do
       Puppet::Type.stubs(:type).with { |x| x.to_s.downcase == "resources"}.returns resources
@@ -47,7 +52,7 @@ describe resources do
     it "can be set to true for a resource type that has instances and can accept ensure" do
       instance.resource_type.stubs(:respond_to?).returns true
       instance.resource_type.stubs(:validproperty?).returns true
-      expect { instance[:purge] = 'yes' }.not_to raise_error Puppet::Error
+      expect { instance[:purge] = 'yes' }.to_not raise_error
     end
   end
 
@@ -56,6 +61,7 @@ describe resources do
       before do
         @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
         @res.catalog = Puppet::Resource::Catalog.new
+        Puppet::FileSystem.stubs(:exist?).with('/etc/login.defs').returns false
       end
 
       it "should never purge hardcoded system users" do
@@ -71,60 +77,89 @@ describe resources do
         @res.user_check(user).should be_false
       end
 
-      it "should purge manual users if unless_system_user => true" do
-        user_hash = {:name => 'system_user', :uid => 525, :system => true}
+      it "should purge non-system users if unless_system_user => true" do
+        user_hash = {:name => 'system_user', :uid => described_class.system_users_max_uid + 1, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
         @res.user_check(user).should be_true
       end
 
-      it "should purge system users over 500 if unless_system_user => 600" do
+      it "should not purge system users under 600 if unless_system_user => 600" do
         res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => 600
         res.catalog = Puppet::Resource::Catalog.new
-        user_hash = {:name => 'system_user', :uid => 525, :system => true}
+        user_hash = {:name => 'system_user', :uid => 500, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
         res.user_check(user).should be_false
       end
     end
 
-    describe "with unless_uid" do
-      describe "with a uid range" do
-        before do
-          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => 10_000..20_000
+    %w(FreeBSD OpenBSD).each do |os|
+      describe "on #{os}" do
+        before :each do
+          Facter.stubs(:value).with(:kernel).returns(os)
+          Facter.stubs(:value).with(:operatingsystem).returns(os)
+          Facter.stubs(:value).with(:osfamily).returns(os)
+          Puppet::FileSystem.stubs(:exist?).with('/etc/login.defs').returns false
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
           @res.catalog = Puppet::Resource::Catalog.new
         end
 
-        it "should purge uids that are not in a specified range" do
-          user_hash = {:name => 'special_user', :uid => 25_000}
+        it "should not purge system users under 1000" do
+          user_hash = {:name => 'system_user', :uid => 999}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_true
+          @res.user_check(user).should be_false
         end
 
-        it "should not purge uids that are in a specified range" do
-          user_hash = {:name => 'special_user', :uid => 15_000}
+        it "should purge users over 999" do
+          user_hash = {:name => 'system_user', :uid => 1000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_false
+          @res.user_check(user).should be_true
         end
       end
+    end
+
+    describe 'with login.defs present' do
+      before :each do
+        Puppet::FileSystem.expects(:exist?).with('/etc/login.defs').returns true
+        Puppet::FileSystem.expects(:each_line).with('/etc/login.defs').yields(' UID_MIN         1234 # UID_MIN comment ')
+        @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
+        @res.catalog = Puppet::Resource::Catalog.new
+      end
+
+      it 'should not purge a system user' do
+        user_hash = {:name => 'system_user', :uid => 1233}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        @res.user_check(user).should be_false
+      end
+
+      it 'should purge a non-system user' do
+        user_hash = {:name => 'system_user', :uid => 1234}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        @res.user_check(user).should be_true
+      end
+    end
 
-      describe "with a uid range array" do
+    describe "with unless_uid" do
+      describe "with a uid array" do
         before do
-          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [10_000..15_000, 15_000..20_000]
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [15_000, 15_001, 15_002]
           @res.catalog = Puppet::Resource::Catalog.new
         end
 
-        it "should purge uids that are not in a specified range array" do
+        it "should purge uids that are not in a specified array" do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           @res.user_check(user).should be_true
         end
 
-        it "should not purge uids that are in a specified range array" do
-          user_hash = {:name => 'special_user', :uid => 15_000}
+        it "should not purge uids that are in a specified array" do
+          user_hash = {:name => 'special_user', :uid => 15000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           @res.user_check(user).should be_false
@@ -132,31 +167,30 @@ describe resources do
 
       end
 
-      describe "with a uid array" do
+      describe "with a single integer uid" do
         before do
-          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [15_000, 15_001, 15_002]
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => 15_000
           @res.catalog = Puppet::Resource::Catalog.new
         end
 
-        it "should purge uids that are not in a specified array" do
+        it "should purge uids that are not specified" do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           @res.user_check(user).should be_true
         end
 
-        it "should not purge uids that are in a specified array" do
-          user_hash = {:name => 'special_user', :uid => 15000}
+        it "should not purge uids that are specified" do
+          user_hash = {:name => 'special_user', :uid => 15_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           @res.user_check(user).should be_false
         end
-
       end
 
-      describe "with a single uid" do
+      describe "with a single string uid" do
         before do
-          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => 15_000
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => '15000'
           @res.catalog = Puppet::Resource::Catalog.new
         end
 
@@ -177,7 +211,7 @@ describe resources do
 
       describe "with a mixed uid array" do
         before do
-          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [10_000..15_000, 16_666]
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => ['15000', 16_666]
           @res.catalog = Puppet::Resource::Catalog.new
         end
 
@@ -202,7 +236,7 @@ describe resources do
           @res.user_check(user).should be_true
         end
       end
-      
+
     end
   end