puppet 5.0.1-x86-mingw32 → 5.1.0-x86-mingw32

data/man/man5/puppet.conf.5

@@ -121,7 +121,7 @@ These are the modules that will be used by \fIall\fR environments\. Note that th
 The address a listening server should bind to\.
 .
 .IP "\(bu" 4
-\fIDefault\fR: 0\.0\.0\.0
+\fIDefault\fR: *
 .
 .IP "" 0
 .

data/spec/fixtures/unit/provider/package/yum/yum-check-update-simple.txt

@@ -9,4 +9,5 @@ curl.i686                               7.32.0-10.fc20           updates
 curl.x86_64                             7.32.0-10.fc20           updates        
 gawk.i686                               4.1.0-3.fc20             updates        
 dhclient.i686                           12:4.1.1-38.P1.fc20      updates        
+java-1.8.0-openjdk.x86_64               1:1.8.0.131-2.b11.el7_3  updates
 selinux-policy.noarch                   3.12.1-163.fc20          updates-testing

data/spec/integration/parser/collection_spec.rb

@@ -312,7 +312,46 @@ describe 'collectors' do
         MANIFEST
       end
 
+      context 'when overriding an already evaluated resource' do
+        let(:logs) { [] }
+        let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+        let(:manifest) { <<-MANIFEST }
+          define foo($message) {
+            notify { "testing": message => $message }
+          }
+          foo { test: message => 'given' }
+          define delayed {
+            Foo <|  |> { message => 'overridden' }
+          }
+          delayed {'do it now': }
+        MANIFEST
+
+        around(:each) do |example|
+          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+            example.run
+          end
+        end
+
+        it 'and --strict=off, it silently skips the override' do
+          Puppet[:strict] = :off
+          expect_the_message_to_be(['given'], manifest)
+          expect(warnings).to be_empty
+        end
+
+        it 'and --strict=warning, it warns about the attempt to override and skips it' do
+          Puppet[:strict] = :warning
+          expect_the_message_to_be(['given'], manifest)
+          expect(warnings).to include(
+            /Attempt to override an already evaluated resource, defined at line 4, with new values at line 6/)
+        end
+
+        it 'and --strict=error, it fails compilation' do
+          Puppet[:strict] = :error
+          expect { compile_to_catalog(manifest) }.to raise_error(
+            /Attempt to override an already evaluated resource, defined at line 4, with new values at line 6/)
+          expect(warnings).to be_empty
+        end
+      end
     end
   end
-
 end

data/spec/shared_contexts/types_setup.rb

@@ -19,7 +19,7 @@ shared_context 'types_setup' do
       Puppet::Pops::Types::PIterableType,
       Puppet::Pops::Types::PIteratorType,
       Puppet::Pops::Types::PRuntimeType,
-      Puppet::Pops::Types::PHostClassType,
+      Puppet::Pops::Types::PClassType,
       Puppet::Pops::Types::PResourceType,
       Puppet::Pops::Types::PPatternType,
       Puppet::Pops::Types::PEnumType,
@@ -27,7 +27,7 @@ shared_context 'types_setup' do
       Puppet::Pops::Types::PStructType,
       Puppet::Pops::Types::PTupleType,
       Puppet::Pops::Types::PCallableType,
-      Puppet::Pops::Types::PType,
+      Puppet::Pops::Types::PTypeType,
       Puppet::Pops::Types::POptionalType,
       Puppet::Pops::Types::PDefaultType,
       Puppet::Pops::Types::PTypeReferenceType,
@@ -38,12 +38,51 @@ shared_context 'types_setup' do
       Puppet::Pops::Types::PTimestampType,
       Puppet::Pops::Types::PSensitiveType,
       Puppet::Pops::Types::PBinaryType,
+      Puppet::Pops::Types::PInitType
     ]
   end
   def all_types
     self.class.all_types
   end
 
+  def self.abstract_types
+    [ Puppet::Pops::Types::PAnyType,
+      Puppet::Pops::Types::PCallableType,
+      Puppet::Pops::Types::PEnumType,
+      Puppet::Pops::Types::PClassType,
+      Puppet::Pops::Types::PDefaultType,
+      Puppet::Pops::Types::PCollectionType,
+      Puppet::Pops::Types::PInitType,
+      Puppet::Pops::Types::PIterableType,
+      Puppet::Pops::Types::PIteratorType,
+      Puppet::Pops::Types::PNotUndefType,
+      Puppet::Pops::Types::PResourceType,
+      Puppet::Pops::Types::PRuntimeType,
+      Puppet::Pops::Types::POptionalType,
+      Puppet::Pops::Types::PPatternType,
+      Puppet::Pops::Types::PScalarType,
+      Puppet::Pops::Types::PScalarDataType,
+      Puppet::Pops::Types::PVariantType,
+      Puppet::Pops::Types::PUndefType,
+      Puppet::Pops::Types::PTypeReferenceType,
+      Puppet::Pops::Types::PTypeAliasType,
+    ]
+  end
+  def abstract_types
+    self.class.abstract_types
+  end
+
+  # Internal types. Not meaningful in pp
+  def self.internal_types
+    [ Puppet::Pops::Types::PTypeReferenceType,
+      Puppet::Pops::Types::PTypeAliasType,
+    ]
+  end
+  def internal_types
+    self.class.internal_types
+  end
+
+
   def self.scalar_data_types
     # PVariantType is also scalar data, if its types are all ScalarData
     [

data/spec/unit/agent_spec.rb

@@ -217,6 +217,17 @@ describe Puppet::Agent do
         @agent.run
       end
 
+      it 'should exit with 1 if an exception is raised' do
+        client = AgentTestClient.new
+        AgentTestClient.expects(:new).returns client
+
+        client.expects(:run).raises(StandardError)
+
+        Kernel.expects(:fork).yields
+        @agent.expects(:exit).with(1)
+        @agent.run
+      end
+
       it "should re-raise exit happening in the child" do
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => -1)]
         expect { @agent.run }.to raise_error(SystemExit)

data/spec/unit/file_bucket/dipper_spec.rb

@@ -91,15 +91,24 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         end
 
         it "should properly diff files on the filebucket" do
-          file1 = make_tmp_file("OriginalContent")
-          file2 = make_tmp_file("ModifiedContent")
+          file1 = make_tmp_file("OriginalContent\n")
+          file2 = make_tmp_file("ModifiedContent\n")
           @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
           checksum1 = @dipper.backup(file1)
           checksum2 = @dipper.backup(file2)
 
           # Diff without the context
-          diff12 = `diff -uN #{file1} #{file2} | sed '1,2d'`
-          diff21 = `diff -uN #{file2} #{file1} | sed '1,2d'`
+          # Lines we need to see match 'Content' instead of trimming diff output filter out
+          # surrounding noise...or hard code the check values
+          if Facter.value(:osfamily) == 'Solaris' &&
+            Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.0') >= 0
+            # Use gdiff on Solaris
+            diff12 = Puppet::Util::Execution.execute("gdiff -uN #{file1} #{file2}| grep Content")
+            diff21 = Puppet::Util::Execution.execute("gdiff -uN #{file2} #{file1}| grep Content")
+          else
+            diff12 = Puppet::Util::Execution.execute("diff -uN #{file1} #{file2}| grep Content")
+            diff21 = Puppet::Util::Execution.execute("diff -uN #{file2} #{file1}| grep Content")
+          end
 
           expect(@dipper.diff(checksum1, checksum2, nil, nil)).to include(diff12)
           expect(@dipper.diff(checksum1, nil, nil, file2)).to include(diff12)

data/spec/unit/functions/all_spec.rb

@@ -0,0 +1,97 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'shared_behaviours/iterative_functions'
+
+describe 'the all method' do
+  include PuppetSpec::Compiler
+
+  context "should be callable as" do
+    it 'all on an array' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $n = $a.all |$v| { $v > 0 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'all on an array with index' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [0,2,4]
+        $n = $a.all |$i, $v| { $v == $i * 2 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'all on a hash selecting entries' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {0=>0,1=>2,2=>4}
+        $n = $a.all |$e| { $e[1] == $e[0]*2 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'all on a hash selecting key and value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {0=>0,1=>2,2=>4}
+        $n = $a.all |$k,$v| { $v == $k*2 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+  end
+
+  context "produces a boolean" do
+    it 'true when boolean true is found' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.all |$v| { true }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'true when truthy is found' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.all |$v| { 42 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'false when truthy is not found (all undef)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.all |$v| { undef }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "false")['ensure']).to eq('present')
+    end
+
+    it 'false when truthy is not found (all false)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.all |$v| { false }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "false")['ensure']).to eq('present')
+    end
+
+  end
+  it_should_behave_like 'all iterative functions argument checks', 'any'
+  it_should_behave_like 'all iterative functions hash handling', 'any'
+
+end

data/spec/unit/functions/any_spec.rb

@@ -0,0 +1,109 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'shared_behaviours/iterative_functions'
+
+describe 'the any method' do
+  include PuppetSpec::Compiler
+
+  context "should be callable as" do
+    it 'any on an array' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $n = $a.any |$v| { $v == 2 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'any on an array with index' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.any |$i, $v| { $i == 2 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'any on a hash selecting entries' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>'ah','b'=>'be','c'=>'ce'}
+        $n = $a.any |$e| { $e[1] == 'be' }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'any on a hash selecting key and value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>'ah','b'=>'be','c'=>'ce'}
+        $n = $a.any |$k, $v| { $v == 'be' }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+  end
+
+  context 'stops iteration when result is known' do
+    it 'true when boolean true is found' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $n = $a.any |$v| { if $v == 1 { true } else { fail("unwanted") } }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+  end
+
+  context "produces a boolean" do
+    it 'true when boolean true is found' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.any |$v| { true }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'true when truthy is found' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.any |$v| { 42 }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "true")['ensure']).to eq('present')
+    end
+
+    it 'false when truthy is not found (all undef)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.any |$v| { undef }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "false")['ensure']).to eq('present')
+    end
+
+    it 'false when truthy is not found (all false)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [6,6,6]
+        $n = $a.any |$v| { false }
+        file { "$n": ensure => present }
+      MANIFEST
+
+      expect(catalog.resource(:file, "false")['ensure']).to eq('present')
+    end
+
+  end
+  it_should_behave_like 'all iterative functions argument checks', 'any'
+  it_should_behave_like 'all iterative functions hash handling', 'any'
+
+end

data/spec/unit/functions/hiera_spec.rb

@@ -293,6 +293,11 @@ describe 'when calling' do
         expect(func('mod::c')).to eql('mod::c (from module)')
       end
     end
+
+    it 'should not be disabled by data_binding_terminus setting' do
+      Puppet[:data_binding_terminus] = 'none'
+      expect(func('a')).to eql('first a')
+    end
   end
 
   context 'hiera_array' do

data/spec/unit/functions/new_spec.rb

@@ -39,6 +39,26 @@ describe 'the new function' do
     )}.to raise_error(Puppet::Error, /expects an Integer\[1, 5\] value, got Integer\[42, 42\]/)
   end
 
+  it 'accepts and returns a second parameter that is an instance of the first, even when the type has no backing new_function' do
+    expect(eval_and_collect_notices(<<-MANIFEST)).to eql(%w(true true true true true true))
+      notice(undef == Undef(undef))
+
+      notice(default == Default(default))
+
+      notice(Any == Type(Any))
+
+      $b = Binary('YmluYXI=')
+      notice($b == Binary($b))
+
+      $t = Timestamp('2012-03-04T09:10:11.001')
+      notice($t == Timestamp($t))
+
+      type MyObject = Object[{attributes => {'type' => String}}]
+      $o = MyObject('Remote')
+      notice($o == MyObject($o))
+    MANIFEST
+  end
+
   context 'when invoked on NotUndef' do
     it 'produces an instance of the NotUndef nested type' do
       expect(compile_to_catalog(<<-MANIFEST
@@ -640,6 +660,42 @@ describe 'the new function' do
         )}.to raise_error(Puppet::Error, error_match)
       end
     end
+
+    context 'when using the optional "tree" format' do
+      it 'can convert a tree in flat form to a hash' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2,0], d]], tree)
+          notify { test: message => $x }
+        MANIFEST
+        )).to have_resource('Notify[test]').with_parameter(:message, { 0 => 'a', 1 => { 0 => 'b', 1=> 'c'}, 2 => {0 => 'd'} })
+      end
+
+      it 'preserves array in flattened tree but overwrites entries if they are present' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2], [overwritten, kept]], [[2,0], d]], tree)
+          notify { test: message => $x }
+        MANIFEST
+        )).to have_resource('Notify[test]').with_parameter(:message, { 0 => 'a', 1 => { 0 => 'b', 1=> 'c'}, 2 => ['d', 'kept'] })
+      end
+
+      it 'preserves hash in flattened tree but overwrites entries if they are present' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2], {0 => 0, kept => 1}], [[2,0], d]], tree)
+          notify { test: message => $x }
+        MANIFEST
+  )).to have_resource('Notify[test]').with_parameter(:message, { 0 => 'a', 1 => { 0 => 'b', 1=> 'c'}, 2 => {0=>'d', 'kept'=>1} })
+      end
+    end
+
+    context 'when using the optional "tree_hash" format' do
+      it 'turns array in flattened tree into hash' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2], [overwritten, kept]], [[2,0], d]], hash_tree)
+          notify { test: message => $x }
+        MANIFEST
+        )).to have_resource('Notify[test]').with_parameter(:message, { 0=>'a', 1=>{ 0=>'b', 1=>'c'}, 2=>{0=>'d', 1=>'kept'}})
+      end
+    end
   end
 
   context 'when invoked on Struct' do
@@ -691,4 +747,14 @@ describe 'the new function' do
       )).to have_resource('Notify[Boolean, true]')
     end
   end
+
+  context 'when invoked on a Type' do
+    it 'creates a Type from its string representation' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Type.new('Integer[3,10]')
+        notify { "${type($x)}": }
+      MANIFEST
+      )).to have_resource('Notify[Type[Integer[3, 10]]]')
+    end
+  end
 end