puppet 4.10.0 → 5.0.0

data/spec/integration/parser/compiler_spec.rb

@@ -12,7 +12,7 @@ class CompilerTestResource
   end
 
   def [](attr)
-    return nil if attr == :stage
+    return nil if (attr == :stage || attr == :alias)
     :main
   end
 
@@ -170,74 +170,44 @@ describe Puppet::Parser::Compiler do
       MANIFEST
       expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
     end
+
+    it 'makes all server settings available as $settings::all_local hash' do
+      node = Puppet::Node.new("testing")
+      catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'test': message => $settings::all_local['strict'] == 'warning' }
+      MANIFEST
+      expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
+    end
+
   end
 
   context 'when working with $server_facts' do
     include PuppetSpec::Compiler
-    context 'and have opted in to trusted_server_facts' do
-      before :each do
-        Puppet[:trusted_server_facts] = true
-      end
-
-      it 'should make $trusted available' do
-        node = Puppet::Node.new("testing")
-        node.add_server_facts({ "server_fact" => "foo" })
-
-        catalog = compile_to_catalog(<<-MANIFEST, node)
-            notify { 'test': message => $server_facts[server_fact] }
-        MANIFEST
 
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "foo")
-      end
+    it '$trusted is available' do
+      node = Puppet::Node.new("testing")
+      node.add_server_facts({ "server_fact" => "foo" })
 
-      it 'should not allow assignment to $server_facts' do
-        node = Puppet::Node.new("testing")
-        node.add_server_facts({ "server_fact" => "foo" })
+      catalog = compile_to_catalog(<<-MANIFEST, node)
+          notify { 'test': message => $server_facts[server_fact] }
+      MANIFEST
 
-        expect do
-          compile_to_catalog(<<-MANIFEST, node)
-              $server_facts = 'changed'
-              notify { 'test': message => $server_facts == 'changed' }
-          MANIFEST
-        end.to raise_error(Puppet::PreformattedError, /Attempt to assign to a reserved variable name: '\$server_facts'.*/)
-      end
+      expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "foo")
     end
 
-    context 'and have not opted in to hashed_node_data' do
-      before :each do
-        Puppet[:trusted_server_facts] = false
-      end
-
-      it 'should not make $server_facts available' do
-        node = Puppet::Node.new("testing")
-        node.add_server_facts({ "server_fact" => "foo" })
-
-        catalog = compile_to_catalog(<<-MANIFEST, node)
-            notify { 'test': message => ($server_facts == undef) }
-        MANIFEST
-
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-      end
-
-      it 'should allow assignment to $server_facts' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-            $server_facts = 'changed'
-            notify { 'test': message => $server_facts == 'changed' }
-        MANIFEST
+    it 'does not allow assignment to $server_facts' do
+      node = Puppet::Node.new("testing")
+      node.add_server_facts({ "server_fact" => "foo" })
 
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-      end
-      it 'should warn about assignment to $server_facts' do
-        catalog = compile_to_catalog(<<-MANIFEST)
+      expect do
+        compile_to_catalog(<<-MANIFEST, node)
             $server_facts = 'changed'
             notify { 'test': message => $server_facts == 'changed' }
         MANIFEST
-        expect(@logs).to have_matching_log(/Assignment to \$server_facts is deprecated/)
-
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-      end
+      end.to raise_error(Puppet::PreformattedError, /Attempt to assign to a reserved variable name: '\$server_facts'.*/)
     end
   end
+
   describe "the compiler when using 4.x language constructs" do
     include PuppetSpec::Compiler
 
@@ -394,9 +364,11 @@ describe Puppet::Parser::Compiler do
         end
       end
 
-      describe 'and classname is a Resource Reference and strict == :error' do
+      describe 'and classname is a Resource Reference' do
+        # tested with strict == off since this was once conditional on strict
+        # can be removed in a later version.
         before(:each) do
-          Puppet[:strict] = :error
+          Puppet[:strict] = :off
         end
 
         it 'is reported as an error' do
@@ -408,38 +380,6 @@ describe Puppet::Parser::Compiler do
         end
       end
 
-      describe 'and classname is a Resource Reference and strict == :warning' do
-        before(:each) do
-          Puppet[:strict] = :warning
-        end
-
-        it 'is reported as a deprecation warning' do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notice Class[ToothFairy]
-            PP
-            expect(@logs).to have_matching_log(/Upper cased class-name in a Class\[<class-name>\] is deprecated, class-name should be a lowercase string/)
-
-          }.to_not raise_error()
-        end
-      end
-
-      describe 'and classname is a Resource Reference and strict == :off' do
-        before(:each) do
-          Puppet[:strict] = :off
-        end
-
-        it 'is not reported' do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notice Class[ToothFairy]
-            PP
-            expect(@logs).to_not have_matching_log(/Warning: Upper cased class-name in a Class\[<class-name>\] is deprecated, class-name should be a lowercase string/)
-
-          }.to_not raise_error()
-        end
-      end
-
       it "should not favor local scope (with class included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
@@ -459,22 +399,21 @@ describe Puppet::Parser::Compiler do
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
 
-      it "should not favor local scope, (with class not included in topscope)" do
-        catalog = compile_to_catalog(<<-PP)
-          class experiment {
+      it "should not favor local name scope" do
+        expect {
+          catalog = compile_to_catalog(<<-PP)
+            class experiment {
+              class baz {
+              }
+              notify {"x" : require => Class['baz'] }
+              notify {"y" : require => Class['experiment::baz'] }
+            }
             class baz {
             }
-            notify {"x" : require => Class['baz'] }
-            notify {"y" : require => Class['experiment::baz'] }
-          }
-          class baz {
-          }
-          include experiment
-          include experiment::baz
-        PP
-
-        expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
-        expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
+            include experiment
+            include experiment::baz
+          PP
+        }.to raise_error(/Could not find resource 'Class\[Baz\]' in parameter 'require'/)
       end
     end
 
@@ -543,9 +482,13 @@ describe Puppet::Parser::Compiler do
       end
     end
 
-    describe "relationships to non existing resources when strict == :error" do
+    describe "relationships to non existing resources (even with strict==off)" do
+      # At some point in the future, this test can be modified to simply ignore the strict flag,
+      # but since the current version is a change from being under control of strict, this is now
+      # explicit - the standard setting is strict == warning, here setting it to off
+      #
       before(:each) do
-        Puppet[:strict] = :error
+        Puppet[:strict] = :off
       end
 
       [ 'before',
@@ -560,46 +503,22 @@ describe Puppet::Parser::Compiler do
           }.to raise_error(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
         end
       end
-    end
 
-    describe "relationships to non existing resources when strict == :warning" do
-      before(:each) do
-        Puppet[:strict] = :warning
-      end
-
-      [ 'before',
-        'subscribe',
-        'notify',
-        'require'].each do |meta_param|
-        it "are reported as a warning when formed via meta parameter #{meta_param}" do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notify{ x : #{meta_param} => Notify[tooth_fairy] }
-            PP
-            expect(@logs).to have_matching_log(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
-
-          }.to_not raise_error()
-        end
-      end
-    end
-
-    describe "relationships to non existing resources when strict == :off" do
-      before(:each) do
-        Puppet[:strict] = :off
+      it 'is not reported for virtual resources' do
+        expect { 
+          compile_to_catalog(<<-PP)
+            @notify{ x : require => Notify[tooth_fairy] }
+          PP
+        }.to_not raise_error
       end
 
-      [ 'before',
-        'subscribe',
-        'notify',
-        'require'].each do |meta_param|
-        it "does not log an error for meta parameter #{meta_param}" do
-          expect { 
-            compile_to_catalog(<<-PP)
-              notify{ x : #{meta_param} => Notify[tooth_fairy] }
-            PP
-            expect(@logs).to_not have_matching_log(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
-          }.to_not raise_error()
-        end
+      it 'is reported for a realized virtual resources' do
+        expect { 
+          compile_to_catalog(<<-PP)
+            @notify{ x : require => Notify[tooth_fairy] }
+            realize(Notify['x'])
+          PP
+        }.to raise_error(/Could not find resource 'Notify\[tooth_fairy\]' in parameter 'require'/)
       end
     end
 
@@ -617,8 +536,8 @@ describe Puppet::Parser::Compiler do
             mode => '0755',
           }
         MANIFEST
-        catalog = compile_to_catalog(base_manifest + relationship_code)
 
+        catalog = compile_to_catalog(base_manifest + relationship_code)
         resources = catalog.resources.select { |res| res.type == 'File' }
 
         actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
@@ -721,6 +640,34 @@ describe Puppet::Parser::Compiler do
           :relationships => [['a', 'b'], ['d', 'c']],
           :subscriptions => [['b', 'c'], ['e', 'd']])
       end
+
+      it 'should close the gap created by an intermediate empty set produced by collection' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> Notify<| tag == 'na' |> ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
+
+      it 'should close the gap created by empty set followed by empty collection' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> [] -> Notify<| tag == 'na' |> ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
+
+      it 'should close the gap created by empty collection surrounded by empty sets' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> [] -> Notify<| tag == 'na' |> -> [] ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
+
+      it 'should close the gap created by several intermediate empty sets produced by collection' do
+        source = "file { [aa, bb]: } [File[a], File[aa]] -> Notify<| tag == 'na' |> -> Notify<| tag == 'na' |> ~> [File[b], File[bb]]"
+        assert_creates_relationships(source,
+          :relationships => [ ],
+          :subscriptions => [['a', 'b'],['aa', 'b'],['a', 'bb'], ['aa', 'bb']])
+      end
     end
 
     context "when dealing with variable references" do
@@ -755,6 +702,25 @@ describe Puppet::Parser::Compiler do
       end
     end
 
+    context "when dealing with resources (e.g. File) that modifies its name from title" do
+      [['', ''],
+       ['', '/'],
+       ['/', ''],
+       ['/', '/']].each do |t, r|
+        it "a circular reference can be compiled with endings: title='#{t}' and ref='#{r}'" do
+          expect {
+            node = Puppet::Node.new("testing")
+            compile_to_catalog(<<-"MANIFEST", node)
+            file { '/tmp/bazinga.txt#{t}':
+              content => 'henrik testing',
+              require => File['/tmp/bazinga.txt#{r}']
+            }
+          MANIFEST
+          }.not_to raise_error
+        end
+      end
+    end
+
     context 'when working with the trusted data hash' do
       context 'and have opted in to hashed_node_data' do
         it 'should make $trusted available' do
@@ -1135,4 +1101,80 @@ describe Puppet::Parser::Compiler do
     end
   end
 
+  describe "the compiler when handling aliases" do
+    include PuppetSpec::Compiler
+
+    def extract_name(ref)
+      ref.sub(/.*\[(\w+)\]/, '\1')
+    end
+
+    def assert_created_relationships(catalog, type_name, expectations)
+      resources = catalog.resources.select { |res| res.type == type_name }
+
+      actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
+        resources.map do |res|
+          dependents = Array(res[relation])
+          dependents.map { |ref| [res.title, extract_name(ref)] }
+        end.inject(&:concat)
+      end
+
+      expect(actual_relationships).to match_array(expectations[:relationships] || [])
+      expect(actual_subscriptions).to match_array(expectations[:subscriptions] || [])
+    end
+
+    it 'allows a relationship to be formed using metaparam relationship' do
+      node = Puppet::Node.new("testnodex")
+      catalog = compile_to_catalog(<<-PP, node)
+        notify { 'actual_2':  before => 'Notify[alias_1]' }
+        notify { 'actual_1': alias => 'alias_1' }
+      PP
+      assert_created_relationships(catalog, 'Notify', { :relationships => [['actual_2', 'alias_1']] })
+    end
+
+    it 'allows a relationship to be formed using -> operator and alias' do
+      node = Puppet::Node.new("testnodex")
+      catalog = compile_to_catalog(<<-PP, node)
+        notify { 'actual_2':  }
+        notify { 'actual_1': alias => 'alias_1' }
+        Notify[actual_2] -> Notify[alias_1]
+      PP
+      assert_created_relationships(catalog, 'Notify', { :relationships => [['actual_2', 'alias_1']] })
+    end
+
+    it 'errors when an alias cannot be found when relationship is formed with -> operator' do
+      node = Puppet::Node.new("testnodex")
+      expect {
+        catalog = compile_to_catalog(<<-PP, node)
+          notify { 'actual_2':  }
+          notify { 'actual_1': alias => 'alias_1' }
+          Notify[actual_2] -> Notify[alias_2]
+        PP
+      }.to raise_error(/Could not find resource 'Notify\[alias_2\]'/)
+    end
+  end
+
+  describe 'the compiler when using collection and override' do
+    include PuppetSpec::Compiler
+
+    it 'allows an override when there is a default present' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        Package { require => Class['bar'] }
+        class bar { }
+        class foo {
+          package { 'python': }
+          package { 'pip': require => Package['python'] }
+
+          Package <| title == 'pip' |> {
+            name     => "python-pip",
+            category => undef,
+          }
+        }
+        include foo
+        include bar
+      MANIFEST
+      package = catalog.resource('Package', 'pip')
+      expect(catalog.resource('Package', 'pip')[:require].to_s).to eql('Package[python]')
+    end
+
+  end
 end

data/spec/integration/parser/dynamic_scoping_spec.rb

@@ -5,7 +5,6 @@ require 'puppet_spec/compiler'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'matchers/resource'
-require 'rgen/metamodel_builder'
 
 # These tests are in a separate file since othr compiler related tests have
 # been dramatically changed between 3.x and 4.x and it is a pain to merge

data/spec/integration/parser/pcore_resource_spec.rb

@@ -57,6 +57,17 @@ describe 'when pcore described resources types are in use' do
               end
             end;end
             EOF
+            'test3.rb' => <<-RUBY,
+              Puppet::Type.newtype(:test3) do
+                newproperty(:message)
+                newparam(:a) { isnamevar }
+                newparam(:b) { isnamevar }
+                newparam(:c) { isnamevar }
+                def self.title_patterns
+                  [ [ /^((.+)\\/(.*))$/,  [[:a], [:b], [:c]]] ]
+                end
+              end
+            RUBY
             'cap.rb' => <<-EOF
             module Puppet
             Type.newtype(:cap, :is_capability => true) do
@@ -112,12 +123,16 @@ describe 'when pcore described resources types are in use' do
         test2 { 'b':
           message => 'b works'
         }
+        test3 { 'x/y':
+          message => 'x/y works'
+        }
         cap { 'c':
           message => 'c works'
         }
       MANIFEST
       expect(catalog.resource(:test1, "a")['message']).to eq('a works')
       expect(catalog.resource(:test2, "b")['message']).to eq('b works')
+      expect(catalog.resource(:test3, "x/y")['message']).to eq('x/y works')
       expect(catalog.resource(:cap, "c")['message']).to eq('c works')
     end
 

data/spec/integration/parser/scope_spec.rb

@@ -8,6 +8,11 @@ describe "Two step scoping for variables" do
     expect(catalog.resource('Notify', 'something')[:message]).to eq(message)
   end
 
+  def expect_the_message_not_to_be(message, node = Puppet::Node.new('the node'))
+    catalog = compile_to_catalog(yield, node)
+    expect(catalog.resource('Notify', 'something')[:message]).to_not eq(message)
+  end
+
   before :each do
     Puppet.expects(:deprecation_warning).never
   end
@@ -250,13 +255,15 @@ describe "Two step scoping for variables" do
       end
     end
 
-    it "finds a qualified variable by following parent scopes of the specified scope" do
-      expect_the_message_to_be("from node") do <<-MANIFEST
+    it "finds a qualified variable by following inherited scope of the specified scope" do
+      expect_the_message_to_be("from parent") do <<-MANIFEST
             class c {
               notify { 'something': message => "$a::b" }
             }
-
-            class a { }
+            class parent {
+              $b = 'from parent'
+            }
+            class a inherits parent { }
 
             node default {
               $b = "from node"
@@ -267,6 +274,48 @@ describe "Two step scoping for variables" do
       end
     end
 
+    ['a:.b', '::a::b'].each do |ref|
+      it "does not resolve a qualified name on the form #{ref} against top scope" do
+        expect_the_message_not_to_be("from topscope") do <<-"MANIFEST"
+              class c {
+                notify { 'something': message => "$#{ref}" }
+              }
+              class parent {
+                $not_b = 'from parent'
+              }
+              class a inherits parent { }
+
+              $b = "from topscope"
+              node default {
+                include a
+                include c
+              }
+          MANIFEST
+        end
+      end
+    end
+
+    ['a:.b', '::a::b'].each do |ref|
+      it "does not resolve a qualified name on the form #{ref} against node scope" do
+        expect_the_message_not_to_be("from node") do <<-MANIFEST
+              class c {
+                notify { 'something': message => "$a::b" }
+              }
+              class parent {
+                $not_b = 'from parent'
+              }
+              class a inherits parent { }
+
+              node default {
+                $b = "from node"
+                include a
+                include c
+              }
+          MANIFEST
+        end
+      end
+    end
+
     it "finds values in its inherited scope when the inherited class is qualified to the top" do
       expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {

data/spec/integration/resource/catalog_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog do
-  it "should support pson" do
-    expect(Puppet::Resource::Catalog.supported_formats).to be_include(:pson)
-  end
-
   describe "when using the indirector" do
     before do
       # This is so the tests work w/out networking.

data/spec/integration/resource/type_collection_spec.rb

@@ -83,5 +83,11 @@ describe Puppet::Resource::TypeCollection do
       mk_module(name, :define => true, :mydefine => ["mymod::mydefine"])
       expect(@code.find_definition("mymod::mydefine").name).to eq("mymod::mydefine")
     end
+
+    it 'should be able to load definitions from their own file using uppercased name' do
+      name = 'mymod'
+      mk_module(name, :define => true, :mydefine => ['mymod::mydefine'])
+      expect(@code.find_definition('Mymod::Mydefine')).not_to be_nil
+    end
   end
 end

data/spec/integration/transaction/report_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Transaction::Report do
 
       Facter.stubs(:value).returns "host.domain.com"
 
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
 
       terminus.expects(:process).with(report)
 
@@ -31,7 +31,7 @@ describe Puppet::Transaction::Report do
 
       log = Puppet::Util::Log.new(:level => :info, :message => "foo")
 
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_resource_status(status)
       report << log
 

data/spec/integration/transaction_spec.rb

@@ -233,7 +233,7 @@ describe Puppet::Transaction do
     expect(Puppet::FileSystem.exist?(path)).not_to be_truthy
   end
 
-  it "should not let one failed refresh result in other refreshes failing" do
+  it "one failed refresh should propagate its failure to dependent refreshes" do
     path = tmpfile("path")
     newfile = tmpfile("file")
       file = Puppet::Type.type(:file).new(
@@ -263,7 +263,7 @@ describe Puppet::Transaction do
 
     catalog = mk_catalog(file, exec1, exec2)
     catalog.apply
-    expect(Puppet::FileSystem.exist?(newfile)).to be_truthy
+    expect(Puppet::FileSystem.exist?(newfile)).to be_falsey
   end
 
   # Ensure when resources have been generated with eval_generate that event

data/spec/integration/type/file_spec.rb

@@ -1074,6 +1074,35 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       expect(File.read(dest)).to eq("foo")
     end
 
+    it "should maintain source URIs as UTF-8 with Unicode characters in their names and be able to copy such files" do
+      # different UTF-8 widths
+      # 1-byte A
+      # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+      # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+      # 4-byte <U+070E> - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+      mixed_utf8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ<U+070E>
+
+      dest = tmpfile("destwith #{mixed_utf8}")
+      source = tmpfile_with_contents("filewith #{mixed_utf8}", "foo")
+      catalog.add_resource described_class.new(:path => dest, :source => source)
+
+      catalog.apply
+
+      # find the resource and verify
+      resource = catalog.resources.first { |r| r.title == "File[#{dest}]" }
+      uri_path = resource.parameters[:source].uri.path
+
+      # note that Windows file:// style URIs get an extra / in front of c:/ like /c:/
+      source_prefix = Puppet.features.microsoft_windows? ? '/' : ''
+
+      # the URI can be round-tripped through unescape
+      expect(URI.unescape(uri_path)).to eq(source_prefix + source)
+      # and is properly UTF-8
+      expect(uri_path.encoding).to eq (Encoding::UTF_8)
+
+      expect(File.read(dest)).to eq('foo')
+    end
+
     it "should be able to copy individual files even if recurse has been specified" do
       source = tmpfile_with_contents("source", "foo")
       dest = tmpfile("dest")

data/spec/integration/type/package_spec.rb

@@ -33,12 +33,18 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
       else
         :yum
       end
+    when 'Suse'
+      if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemmajrelease), '10') >= 0
+        :zypper
+      else
+        :rug
+      end
     when 'FreeBSD'
       :ports
     when 'OpenBSD'
       :openbsd
     when 'DragonFly'
-      :pkgin
+      :pkgng
     when 'OpenWrt'
       :opkg
     end