puppet 4.10.12 → 5.0.0

data/spec/unit/transaction/resource_harness_spec.rb

@@ -233,7 +233,7 @@ describe Puppet::Transaction::ResourceHarness do
         @harness.evaluate(resource)
       end.to raise_error(Exception)
 
-      expect(@logs.first.message).to eq("change from absent to present failed: Exception")
+      expect(@logs.first.message).to eq("change from 'absent' to 'present' failed: Exception")
       expect(@logs.first.level).to eq(:err)
     end
 
@@ -296,7 +296,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should log and pass the exception through" do
       expect { @harness.evaluate(@resource) }.to raise_error(Exception, /baz/)
-      expect(@logs.first.message).to eq("change from absent to 1 failed: baz")
+      expect(@logs.first.message).to eq("change from 'absent' to 1 failed: baz")
       expect(@logs.first.level).to eq(:err)
     end
   end
@@ -325,7 +325,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should log and pass the exception through" do
       expect { @harness.evaluate(@resource) }.to raise_error(Exception, /slithy/)
-      expect(@logs.first.message).to eq("change from absent to 1 failed: slithy")
+      expect(@logs.first.message).to eq("change from 'absent' to 1 failed: slithy")
       expect(@logs.first.level).to eq(:err)
     end
   end

data/spec/unit/transaction_spec.rb

@@ -50,7 +50,7 @@ describe Puppet::Transaction do
     expect(transaction.report.resource_statuses[resource.to_s]).to equal(status)
   end
 
-  it "should not consider there to be failed resources if no statuses are marked failed" do
+  it "should not consider there to be failed or failed_to_restart resources if no statuses are marked failed" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
     transaction = transaction_with_resource(resource)
     transaction.evaluate
@@ -59,7 +59,7 @@ describe Puppet::Transaction do
   end
 
   it "should use the provided report object" do
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, report, nil)
 
     expect(transaction.report).to eq(report)
@@ -86,7 +86,7 @@ describe Puppet::Transaction do
 
     it "should set retrieval time on the report" do
       catalog = Puppet::Resource::Catalog.new
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       catalog.retrieval_duration = 5
 
       report.expects(:add_times).with(:config_retrieval, 5)
@@ -174,6 +174,13 @@ describe Puppet::Transaction do
 
       expect(@transaction).to be_any_failed
     end
+
+    it "should report any_failed if any resources failed to restart" do
+      @transaction.evaluate
+      @transaction.report.resource_statuses[@resource.to_s].failed_to_restart = true
+
+      expect(@transaction).to be_any_failed
+    end
   end
 
   describe "#unblock" do
@@ -330,7 +337,7 @@ describe Puppet::Transaction do
   describe "after resource traversal" do
     let(:catalog) { Puppet::Resource::Catalog.new }
     let(:prioritizer) { Puppet::Graph::RandomPrioritizer.new }
-    let(:report) { Puppet::Transaction::Report.new("apply") }
+    let(:report) { Puppet::Transaction::Report.new }
     let(:transaction) { Puppet::Transaction.new(catalog, report, prioritizer) }
     let(:generator) { Puppet::Transaction::AdditionalResourceGenerator.new(catalog, nil, prioritizer) }
 
@@ -675,23 +682,26 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a resource that requires itself" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
   end
 
   it "errors with a dependency cycle for a self-requiring resource also required by another resource" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
         notify { other: require => Notify[cycle] }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
   end
 
   it "errors with a dependency cycle for a resource that requires itself and another resource" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle:
@@ -699,10 +709,11 @@ describe Puppet::Transaction do
         }
         notify { other: }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
   end
 
   it "errors with a dependency cycle for a resource that is later modified to require itself" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: }
@@ -710,7 +721,41 @@ describe Puppet::Transaction do
           require => Notify[cycle]
         }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+  end
+
+  context "when generating a report for a transaction with a dependency cycle" do
+    let(:catalog) do
+      compile_to_ral(<<-MANIFEST)
+        notify { foo: require => Notify[bar] }
+        notify { bar: require => Notify[foo] }
+      MANIFEST
+    end
+
+    let(:prioritizer) { Puppet::Graph::SequentialPrioritizer.new }
+    let(:transaction) { Puppet::Transaction.new(catalog,
+                                          Puppet::Transaction::Report.new("apply"),
+                                          prioritizer) }
+
+    before(:each) do
+      expect { transaction.evaluate }.to raise_error(Puppet::Error)
+      transaction.report.finalize_report
+    end
+
+    it "should report resources involved in a dependency cycle as failed" do
+      expect(transaction.report.resource_statuses['Notify[foo]']).to be_failed
+      expect(transaction.report.resource_statuses['Notify[bar]']).to be_failed
+    end
+
+    it "should generate a failure event for a resource in a dependency cycle" do
+      status = transaction.report.resource_statuses['Notify[foo]']
+      expect(status.events.first.status).to eq('failure')
+      expect(status.events.first.message).to eq('resource is part of a dependency cycle')
+    end
+
+    it "should report that the transaction is failed" do
+      expect(transaction.report.status).to eq('failed')
+    end
   end
 
   it "reports a changed resource with a successful run" do

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

@@ -47,13 +47,13 @@ describe Puppet::Type.type(:file).attrclass(:group) do
       it "should use the name of the user if it can find it" do
         resource.provider.stubs(:gid2name).with(1001).returns 'foos'
 
-        expect(group.send(prop_to_s, 1001)).to eq('foos')
+        expect(group.send(prop_to_s, 1001)).to eq("'foos'")
       end
 
       it "should use the id of the user if it can't" do
         resource.provider.stubs(:gid2name).with(1001).returns nil
 
-        expect(group.send(prop_to_s, 1001)).to eq(1001)
+        expect(group.send(prop_to_s, 1001)).to eq('1001')
       end
     end
   end

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

@@ -13,7 +13,7 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
     it "should reject non-string values" do
       expect {
         mode.value = 0755
-      }.to raise_error(Puppet::Error, /The file mode specification must be a string, not 'Fixnum'/)
+      }.to raise_error(Puppet::Error, /The file mode specification must be a string, not '(?:Fixnum|Integer)'/)
     end
 
     it "should accept values specified as octal numbers in strings" do
@@ -140,17 +140,17 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
   describe '#should_to_s' do
     describe 'with a 3-digit mode' do
       it 'returns a 4-digit mode with a leading zero' do
-        expect(mode.should_to_s('755')).to eq('0755')
+        expect(mode.should_to_s('755')).to eq("'0755'")
       end
     end
 
     describe 'with a 4-digit mode' do
       it 'returns the 4-digit mode when the first digit is a zero' do
-        expect(mode.should_to_s('0755')).to eq('0755')
+        expect(mode.should_to_s('0755')).to eq("'0755'")
       end
 
       it 'returns the 4-digit mode when the first digit is not a zero' do
-        expect(mode.should_to_s('1755')).to eq('1755')
+        expect(mode.should_to_s('1755')).to eq("'1755'")
       end
     end
   end
@@ -158,23 +158,23 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
   describe '#is_to_s' do
     describe 'with a 3-digit mode' do
       it 'returns a 4-digit mode with a leading zero' do
-        expect(mode.is_to_s('755')).to eq('0755')
+        expect(mode.is_to_s('755')).to eq("'0755'")
       end
     end
 
     describe 'with a 4-digit mode' do
       it 'returns the 4-digit mode when the first digit is a zero' do
-        expect(mode.is_to_s('0755')).to eq('0755')
+        expect(mode.is_to_s('0755')).to eq("'0755'")
       end
 
       it 'returns the 4-digit mode when the first digit is not a zero' do
-        expect(mode.is_to_s('1755')).to eq('1755')
+        expect(mode.is_to_s('1755')).to eq("'1755'")
       end
     end
 
     describe 'when passed :absent' do
-      it 'returns :absent' do
-        expect(mode.is_to_s(:absent)).to eq(:absent)
+      it "returns 'absent'" do
+        expect(mode.is_to_s(:absent)).to eq("'absent'")
       end
     end
   end

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

@@ -45,13 +45,13 @@ describe Puppet::Type.type(:file).attrclass(:owner) do
       it "should use the name of the user if it can find it" do
         resource.provider.stubs(:uid2name).with(1001).returns 'foo'
 
-        expect(owner.send(prop_to_s, 1001)).to eq('foo')
+        expect(owner.send(prop_to_s, 1001)).to eq("'foo'")
       end
 
       it "should use the id of the user if it can't" do
         resource.provider.stubs(:uid2name).with(1001).returns nil
 
-        expect(owner.send(prop_to_s, 1001)).to eq(1001)
+        expect(owner.send(prop_to_s, 1001)).to eq('1001')
       end
     end
   end

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

@@ -10,6 +10,8 @@ require 'spec_helper'
       @path = make_absolute("/my/file")
       @resource = Puppet::Type.type(:file).new :path => @path
       @sel = property.new :resource => @resource
+      @sel.stubs(:normalize_selinux_category).with("s0").returns("s0")
+      @sel.stubs(:normalize_selinux_category).with(nil).returns(nil)
     end
 
     it "retrieve on #{param} should return :absent if the file isn't statable" do

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

@@ -612,6 +612,19 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
         resource.write(source)
       end
 
+      it 'should request binary content' 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')
+
+        conn.unstub(:request_get)
+        conn.expects(:request_get).with do |_, options|
+          expect(options).to include('Accept' => 'application/octet-stream')
+        end.yields(response)
+
+        resource.write(source)
+      end
+
       describe 'when handling file_content responses' do
         before do
           File.open(filename, 'w') {|f| f.write "initial file content"}

data/spec/unit/type/nagios_spec.rb

@@ -1,5 +1,4 @@
 #! /usr/bin/env ruby
-# encoding: utf-8
 require 'spec_helper'
 
 require 'puppet/external/nagios'
@@ -88,13 +87,6 @@ define command {
 \tcommand_line                   LC_ALL=en_US.UTF-8 /usr/lib/nagios/plugins/check_haproxy -u 'http://blah:blah@$HOSTADDRESS$:8080/haproxy?stats\\;csv'
 \tcommand_name                   check_haproxy
 }
-EOL
-
-  UNICODE_NAGIOS_CONTACT = <<-EOL
-define contact {
-\talias                          Paul Tötterman
-\tcontact_name                   ptman
-}
 EOL
 
   it "should parse without error" do
@@ -198,19 +190,7 @@ EOL
     nagios_type.command_line = results[0].command_line
     expect(nagios_type.to_s).to eql(ANOTHER_ESCAPED_SEMICOLON)
   end
-  describe "when reading UTF8 values" do
-    it "should be converted to ASCII_8BIT for ruby 1.9 / 2.0", :if => RUBY_VERSION < "2.1.0" && String.method_defined?(:encode) do
-      parser = Nagios::Parser.new
-      results = parser.parse(UNICODE_NAGIOS_CONTACT)
-      expect(results[0].alias.encoding).to eq(Encoding::ASCII_8BIT)
-      expect(results[0].alias).to eq('Paul Tötterman'.force_encoding(Encoding::ASCII_8BIT))
-    end
-    it "must not be converted for ruby >= 2.1", :if => RUBY_VERSION >= "2.1.0" do
-      parser = Nagios::Parser.new
-      results = parser.parse(UNICODE_NAGIOS_CONTACT)
-      expect(results[0].alias.encoding).to eq(Encoding::UTF_8)
-    end
-  end
+
 end
 
 describe "Nagios generator" do

data/spec/unit/type/ssh_authorized_key_spec.rb

@@ -149,12 +149,12 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
 
       it "property should return well formed string of arrays from is_to_s" do
         resource = described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
-        expect(resource.property(:options).is_to_s(["a","b","c"])).to eq "a,b,c"
+        expect(resource.property(:options).is_to_s(["a","b","c"])).to eq "['a', 'b', 'c']"
       end
 
       it "property should return well formed string of arrays from should_to_s" do
         resource = described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
-        expect(resource.property(:options).should_to_s(["a","b","c"])).to eq "a,b,c"
+        expect(resource.property(:options).should_to_s(["a","b","c"])).to eq "['a', 'b', 'c']"
       end
 
     end

data/spec/unit/type/tidy_spec.rb

@@ -440,20 +440,6 @@ describe tidy do
       result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
       expect(result[@basepath + '/a'][:require].collect{|a| a.name[('File//a/' + @basepath).length..-1]}.join()).to eq('321')
     end
-
-    it "generates resources whose noop parameter matches the managed resource's noop parameter" do
-      @tidy[:recurse] = true
-      @tidy[:noop] = true
-
-      fileset = mock 'fileset'
-      Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns fileset
-      fileset.expects(:files).returns %w{. a a/2 a/1 a/3}
-      @tidy.stubs(:tidy?).returns true
-
-      result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
-
-      expect(result.values).to all(be_noop)
-    end
   end
 
   def lstat_is(path, stat)

data/spec/unit/type/user_spec.rb

@@ -369,8 +369,7 @@ describe Puppet::Type.type(:user) do
             is.force_encoding(Encoding::ASCII_8BIT)
             should.force_encoding(Encoding::UTF_8)
             expect(Encoding.compatible?(is, should)).to be_falsey
-            # append Regexp with 'n' to set encoding to ASCII_8BIT
-            expect(comment_property.change_to_s(is,should)).to match(/changed '\xE2\x98\x83' to '\xDB\xBF'/n)
+            expect(comment_property.change_to_s(is,should)).to match(/changed '\u{E2}\u{98}\u{83}' to '\u{DB}\u{BF}'/)
           end
         end
 
@@ -379,8 +378,7 @@ describe Puppet::Type.type(:user) do
             is.force_encoding(Encoding::UTF_8)
             should.force_encoding(Encoding::UTF_8)
             expect(Encoding.compatible?(is, should)).to be_truthy
-            # append Regexp with 'u' to set encoding to UTF_8
-            expect(comment_property.change_to_s(is,should)).to match(/changed '\u2603' to '\u06FF'/u)
+            expect(comment_property.change_to_s(is,should)).to match(/changed '\u{2603}' to '\u{6FF}'/u)
           end
         end
       end

data/spec/unit/util/at_fork_spec.rb

@@ -0,0 +1,150 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe 'Puppet::Util::AtFork' do
+  EXPECTED_HANDLER_METHODS = [:prepare, :parent, :child]
+
+  before :each do
+    Puppet::Util.class_exec do
+      const_set(:AtFork, Module.new)
+    end
+  end
+
+  after :each do
+    Puppet::Util.class_exec do
+      remove_const(:AtFork)
+    end
+  end
+
+  describe '.get_handler' do
+    context 'when on Solaris' do
+      before :each do
+        Facter.expects(:value).with(:operatingsystem).returns('Solaris')
+      end
+
+      after :each do
+        Object.class_exec do
+          remove_const(:Fiddle) if const_defined?(:Fiddle)
+        end
+      end
+
+      def stub_solaris_handler(stub_noop_too = false)
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
+          if lib == 'puppet/util/at_fork/solaris'
+            load lib + '.rb'
+            true
+          elsif stub_noop_too && lib == 'puppet/util/at_fork/noop'
+            Puppet::Util::AtFork.class_exec do
+              const_set(:Noop, Class.new)
+            end
+            true
+          else
+            false
+          end
+        end.returns(true)
+
+        unless stub_noop_too
+          Object.class_exec do
+            const_set(:Fiddle, Module.new do
+              const_set(:TYPE_VOIDP, nil)
+              const_set(:TYPE_VOID,  nil)
+              const_set(:TYPE_INT,   nil)
+              const_set(:DLError,    Class.new(StandardError))
+              const_set(:Handle,     Class.new)
+              const_set(:Function,   Class.new)
+            end)
+          end
+        end
+
+        TOPLEVEL_BINDING.eval('self').stubs(:require).with() do |lib|
+          if lib == 'fiddle'
+            raise LoadError, 'no fiddle' if stub_noop_too
+          else
+            Kernel.require lib
+          end
+          true
+        end.returns(true)
+      end
+
+      it %q(should return the Solaris specific AtFork handler) do
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
+          if lib == 'puppet/util/at_fork/solaris'
+            Puppet::Util::AtFork.class_exec do
+              const_set(:Solaris, Class.new)
+            end
+            true
+          else
+            false
+          end
+        end.returns(true)
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Solaris)
+      end
+
+      it %q(should return the Noop handler when Fiddle could not be loaded) do
+        stub_solaris_handler(true)
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Noop)
+      end
+
+      it %q(should fail when libcontract cannot be loaded) do
+        stub_solaris_handler
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).raises(Fiddle::DLError, 'no such library')
+        expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such library')
+      end
+
+      it %q(should fail when libcontract doesn't define all the necessary functions) do
+        stub_solaris_handler
+        handle = stub('Fiddle::Handle')
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).returns(handle)
+        handle.expects(:[]).raises(Fiddle::DLError, 'no such method')
+        expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such method')
+      end
+
+      it %q(the returned Solaris specific handler should respond to the expected methods) do
+        stub_solaris_handler
+        handle = stub('Fiddle::Handle')
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).returns(handle)
+        handle.stubs(:[]).returns(nil)
+        Fiddle::Function.stubs(:new).returns(Proc.new {})
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.public_methods).to include(*EXPECTED_HANDLER_METHODS)
+      end
+    end
+
+    context 'when NOT on Solaris' do
+      before :each do
+        Facter.expects(:value).with(:operatingsystem).returns(nil)
+      end
+
+      def stub_noop_handler(namespace_only = false)
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
+          if lib == 'puppet/util/at_fork/noop'
+            if namespace_only
+              Puppet::Util::AtFork.class_exec do
+                const_set(:Noop, Class.new)
+              end
+            else
+              load lib + '.rb'
+            end
+            true
+          else
+            false
+          end
+        end.returns(true)
+      end
+
+      it %q(should return the Noop AtFork handler) do
+        stub_noop_handler(true)
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Noop)
+      end
+
+      it %q(the returned Noop handler should respond to the expected methods) do
+        stub_noop_handler
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.public_methods).to include(*EXPECTED_HANDLER_METHODS)
+      end
+    end
+  end
+end