puppet 4.5.3-x86-mingw32 → 4.6.1-x86-mingw32

data/spec/unit/parser/compiler_spec.rb

@@ -99,10 +99,6 @@ describe Puppet::Parser::Compiler do
     expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /Compilation has been halted because.*bad environment/)
   end
 
-  it "should include the resource type collection helper" do
-    expect(Puppet::Parser::Compiler.ancestors).to be_include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   it "should be able to return a class list containing all added classes" do
     @compiler.add_class ""
     @compiler.add_class "one"
@@ -117,13 +113,8 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.node).to equal(@node)
     end
 
-    it "should detect when ast nodes are absent" do
-      expect(@compiler.ast_nodes?).to be_falsey
-    end
-
-    it "should detect when ast nodes are present" do
-      @known_resource_types.expects(:nodes?).returns true
-      expect(@compiler.ast_nodes?).to be_truthy
+    it "the set of ast_nodes should be empty" do
+      expect(@compiler.environment.known_resource_types.nodes?).to be_falsey
     end
 
     it "should copy the known_resource_types version to the catalog" do
@@ -608,14 +599,13 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should raise an error if a class is not found" do
-      @scope.expects(:find_hostclass).with("notfound").returns(nil)
+      @scope.environment.known_resource_types.expects(:find_hostclass).with("notfound").returns(nil)
       expect{ @compiler.evaluate_classes(%w{notfound}, @scope) }.to raise_error(Puppet::Error, /Could not find class/)
     end
 
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
-      @compiler.topscope.expects(:find_hostclass).with('foo').returns(nil)
       expect{ @compiler.compile }.to raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
@@ -624,9 +614,7 @@ describe Puppet::Parser::Compiler do
 
     before do
       Puppet.settings[:data_binding_terminus] = "none"
-      @class = stub 'class', :name => "my::class"
-      @scope.stubs(:find_hostclass).with("myclass").returns(@class)
-
+      @class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "myclass")
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
@@ -658,7 +646,7 @@ describe Puppet::Parser::Compiler do
       def define_class(name, parameters)
         @node.classes[name] = parameters
         klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => @ast_obj, 'p2' => @ast_obj})
-        @compiler.topscope.known_resource_types.add klass
+        @compiler.environment.known_resource_types.add klass
       end
 
       def compile
@@ -697,7 +685,7 @@ describe Puppet::Parser::Compiler do
         ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
         klasses.each do |name|
           klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => ast_obj, 'p2' => ast_obj})
-          @compiler.topscope.known_resource_types.add klass
+          @compiler.environment.known_resource_types.add klass
         end
         catalog = @compiler.compile
 
@@ -710,7 +698,7 @@ describe Puppet::Parser::Compiler do
       klass = {'foo'=>{'a'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'a' => nil, 'b' => nil})
-      @compiler.topscope.known_resource_types.add klass
+      @compiler.environment.known_resource_types.add klass
       expect { @compiler.compile }.to raise_error(Puppet::PreformattedError, /Class\[Foo\]: expects a value for parameter 'b'/)
     end
 
@@ -718,14 +706,14 @@ describe Puppet::Parser::Compiler do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
-      @compiler.topscope.known_resource_types.add klass
+      @compiler.environment.known_resource_types.add klass
       expect { @compiler.compile }.to raise_error(Puppet::PreformattedError, /Class\[Foo\]: has no parameter named '3'/)
     end
 
     it "should ensure class is in catalog without params" do
       @node.classes = klasses = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
-      @compiler.topscope.known_resource_types.add foo
+      @compiler.environment.known_resource_types.add foo
       catalog = @compiler.compile
       expect(catalog.classes).to include 'foo'
     end
@@ -766,7 +754,7 @@ describe Puppet::Parser::Compiler do
 
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
-      @scope.stubs(:find_hostclass).with("MyClass").returns(@class)
+      @scope.environment.known_resource_types.stubs(:find_hostclass).with("MyClass").returns(@class)
       @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
@@ -778,8 +766,7 @@ describe Puppet::Parser::Compiler do
   describe "when evaluating AST nodes with no AST nodes present" do
 
     it "should do nothing" do
-      @compiler.expects(:ast_nodes?).returns(false)
-      @compiler.known_resource_types.expects(:nodes).never
+      @compiler.environment.known_resource_types.stubs(:nodes).returns(false)
       Puppet::Parser::Resource.expects(:new).never
 
       @compiler.send(:evaluate_ast_node)
@@ -789,16 +776,16 @@ describe Puppet::Parser::Compiler do
   describe "when evaluating AST nodes with AST nodes present" do
 
     before do
-      @compiler.known_resource_types.stubs(:nodes?).returns true
+      @compiler.environment.known_resource_types.stubs(:nodes?).returns true
 
       # Set some names for our test
       @node.stubs(:names).returns(%w{a b c})
-      @compiler.known_resource_types.stubs(:node).with("a").returns(nil)
-      @compiler.known_resource_types.stubs(:node).with("b").returns(nil)
-      @compiler.known_resource_types.stubs(:node).with("c").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("a").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("b").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("c").returns(nil)
 
       # It should check this last, of course.
-      @compiler.known_resource_types.stubs(:node).with("default").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
@@ -807,7 +794,7 @@ describe Puppet::Parser::Compiler do
 
     it "should evaluate the first node class matching the node name" do
       node_class = stub 'node', :name => "c", :evaluate_code => nil
-      @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
+      @compiler.environment.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
@@ -817,7 +804,7 @@ describe Puppet::Parser::Compiler do
 
     it "should match the default node if no matching node can be found" do
       node_class = stub 'node', :name => "default", :evaluate_code => nil
-      @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
+      @compiler.environment.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
@@ -827,7 +814,7 @@ describe Puppet::Parser::Compiler do
 
     it "should evaluate the node resource immediately rather than using lazy evaluation" do
       node_class = stub 'node', :name => "c"
-      @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
+      @compiler.environment.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
@@ -969,7 +956,6 @@ describe Puppet::Parser::Compiler do
     end
   end
 
-
   describe "when managing resource overrides" do
 
     before do

data/spec/unit/{appmgmt_spec.rb → parser/environment_compiler_spec.rb}

@@ -480,7 +480,6 @@ EOS
     end
   end
 
-
   describe "in the environment catalog" do
     it "does not fail if there is no site expression" do
       expect {
@@ -490,6 +489,18 @@ EOS
       }.to_not raise_error()
     end
 
+    it "ignores usage of hiera_include() at topscope for classification" do
+      Puppet.expects(:debug).with(regexp_matches /Ignoring hiera_include/)
+
+      expect {
+        catalog = compile_to_env_catalog(<<-EOC).to_resource
+        hiera_include('classes')
+        site { }
+        EOC
+      }.to_not raise_error()
+
+    end
+
     it "includes components and capability resources" do
       catalog = compile_to_env_catalog(MANIFEST).to_resource
       apps = catalog.resources.select do |res|

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -1,9 +1,11 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'puppet_spec/files'
 
 describe 'function for dynamically creating resources' do
   include PuppetSpec::Compiler
+  include PuppetSpec::Files
 
   before :each do
     node      = Puppet::Node.new("floppy", :environment => 'production')
@@ -31,6 +33,35 @@ describe 'function for dynamically creating resources' do
     expect { @scope.function_create_resources(['foo',{},'foo']) }.to raise_error(ArgumentError, 'create_resources(): third argument, if provided, must be a hash')
   end
 
+  context 'when being called from a manifest in a file' do
+    let(:dir) do
+      dir_containing('manifests', {
+              'site.pp' => <<-EOF
+                # comment here to make the call be on a particular
+                # source line (3)
+                create_resources('notify', {
+                  'a'  => { 'message'=>'message a'},
+                  'b'  => { 'message'=>'message b'},
+                  }
+                )
+              EOF
+          }
+      )
+    end
+
+    it 'file and line information where call originates is written to all resources created in one call' do
+      node = Puppet::Node.new('test')
+      file = File.join(dir, 'site.pp')
+      Puppet[:manifest] = file
+      catalog = Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
+
+      expect(catalog.resource(:notify, 'a').file).to eq(file)
+      expect(catalog.resource(:notify, 'a').line).to eq(3)
+      expect(catalog.resource(:notify, 'b').file).to eq(file)
+      expect(catalog.resource(:notify, 'b').line).to eq(3)
+    end
+
+  end
   describe 'when creating native types' do
     it 'empty hash should not cause resources to be added' do
       noop_catalog = compile_to_catalog("create_resources('file', {})")
@@ -43,6 +74,16 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
     end
 
+    it 'should pick up and pass on file and line information' do
+      # mock location as the compile_to_catalog sets Puppet[:code} which does not
+      # have file/line support.
+      Puppet::Pops::PuppetStack.expects(:stacktrace).once.returns([['test.pp', 1234]])
+      catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
+      r = catalog.resource(:file, "/etc/foo")
+      expect(r.file).to eq('test.pp')
+      expect(r.line).to eq(1234)
+    end
+
     it 'should be able to add virtual resources' do
       catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
@@ -54,16 +95,16 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo").exported).to eq(true)
     end
 
-    it 'should accept multiple types' do
+    it 'should accept multiple resources' do
       catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
       expect(catalog.resource(:notify, "foo")['message']).to eq('one')
       expect(catalog.resource(:notify, "bar")['message']).to eq('two')
     end
 
-    it 'should fail to add non-existing type' do
+    it 'should fail to add non-existing resource type' do
       expect do
         @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
-      end.to raise_error(/Invalid resource type create-resource-foo/)
+      end.to raise_error(/Unknown resource type: 'create-resource-foo'/)
     end
 
     it 'should be able to add edges' do
@@ -84,6 +125,15 @@ describe 'function for dynamically creating resources' do
       expect(rg.path_between(foo,nil)).to_not be
     end
 
+    it 'should filter out undefined edges in an array as they cause errors' do
+      rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>[undef]}})")
+      test  = rg.vertices.find { |v| v.title == 'test' }
+      foo   = rg.vertices.find { |v| v.title == 'foo' }
+      expect(test).to be
+      expect(foo).to be
+      expect(rg.path_between(foo,nil)).to_not be
+    end
+
     it 'should account for default values' do
       catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'})")
       expect(catalog.resource(:file, "/etc/foo")['group']).to eq('bar')
@@ -112,7 +162,29 @@ describe 'function for dynamically creating resources' do
 
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
-      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node test/)
+      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one'/)
+    end
+
+    it 'should accept undef as explicit value when parameter has no default value' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foocreateresource($one) {
+            notify { $name: message => "aaa${one}bbb" }
+          }
+
+          create_resources('foocreateresource', {'blah'=>{ one => undef}})
+        MANIFEST
+      expect(catalog.resource(:notify, "blah")['message']).to eq('aaabbb')
+    end
+
+    it 'should use default value expression if given value is undef' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foocreateresource($one = 'xx') {
+            notify { $name: message => "aaa${one}bbb" }
+          }
+
+          create_resources('foocreateresource', {'blah'=>{ one => undef}})
+        MANIFEST
+      expect(catalog.resource(:notify, "blah")['message']).to eq('aaaxxbbb')
     end
 
     it 'should be able to add multiple defines' do

data/spec/unit/parser/functions/require_spec.rb

@@ -18,7 +18,7 @@ describe "the require function" do
 
     @scope.stubs(:findresource)
     @klass = stub 'class', :name => "myclass"
-    @scope.stubs(:find_hostclass).returns(@klass)
+    @scope.environment.known_resource_types.stubs(:find_hostclass).returns(@klass)
 
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
     @scope.stubs(:resource).returns @resource
@@ -45,7 +45,7 @@ describe "the require function" do
   it "should lookup the absolute class path" do
     @scope.compiler.stubs(:evaluate_classes)
 
-    @scope.expects(:find_hostclass).with("::myclass").returns(@klass)
+    @scope.environment.known_resource_types.expects(:find_hostclass).with("::myclass").returns(@klass)
     @klass.expects(:name).returns("myclass")
 
     @scope.function_require(["myclass"])

data/spec/unit/parser/resource_spec.rb

@@ -54,10 +54,6 @@ describe Puppet::Parser::Resource do
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
-  it "should use the resource type collection helper module" do
-    expect(Puppet::Parser::Resource.ancestors).to be_include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   it "should use the scope's environment as its environment" do
     @scope.expects(:environment).returns("myenv").at_least_once
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment).to eq("myenv")
@@ -157,7 +153,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should add an edge to any specified stage for class resources" do
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       other_stage = Puppet::Parser::Resource.new(:stage, "other", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, other_stage)
@@ -171,7 +167,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should fail if an unknown stage is specified" do
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
@@ -183,7 +179,7 @@ describe Puppet::Parser::Resource do
       main      = @compiler.catalog.resource(:stage, :main)
       foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, foo_stage)
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'foo_stage'
       @compiler.add_resource(@scope, resource)
@@ -200,6 +196,16 @@ describe Puppet::Parser::Resource do
       expect(edges).to include(['Class[main]', 'Notify[hello]'])
     end
 
+    it 'should evaluate class in the same file without include' do
+      Puppet[:code] = <<-MANIFEST
+        class a($myvar = 'hello') {}
+        class { 'a': myvar => 'goodbye' }
+        notify { $a::myvar: }
+      MANIFEST
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      expect(catalog.resource('Notify[goodbye]')).to be_a(Puppet::Resource)
+    end
+
     it "should allow edges to propagate multiple levels down the scope hierarchy" do
       Puppet[:code] = <<-MANIFEST
         stage { before: before => Stage[main] }
@@ -246,7 +252,7 @@ describe Puppet::Parser::Resource do
 
     it "should add edges from top-level class resources to the main stage if no stage is specified" do
       main = @compiler.catalog.resource(:stage, :main)
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, resource)
 
@@ -258,9 +264,6 @@ describe Puppet::Parser::Resource do
 
   describe "when finishing" do
     before do
-      @class = newclass "myclass"
-      @nodedef = newnode("mynode")
-
       @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
     end
 
@@ -295,6 +298,13 @@ describe Puppet::Parser::Resource do
 
       expect(@resource[:owner]).to eq("other")
     end
+
+    it "converts parameters with Sensitive values to unwrapped values and metadata" do
+      @resource[:content] = Puppet::Pops::Types::PSensitiveType::Sensitive.new("hunter2")
+      @resource.finish
+      expect(@resource[:content]).to eq "hunter2"
+      expect(@resource.sensitive_parameters).to eq [:content]
+    end
   end
 
   describe "when being tagged" do

data/spec/unit/parser/scope_spec.rb

@@ -91,10 +91,6 @@ describe Puppet::Parser::Scope do
     }.to raise_error(Puppet::DevError, /you must pass a compiler instance/)
   end
 
-  it "should use the resource type collection helper to find its known resource types" do
-    expect(Puppet::Parser::Scope.ancestors).to include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   describe "when custom functions are called" do
     let(:env) { Puppet::Node::Environment.create(:testing, []) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => env)) }
@@ -230,7 +226,7 @@ describe Puppet::Parser::Scope do
 
     describe "and the variable is qualified" do
       before :each do
-        @known_resource_types = @scope.known_resource_types
+        @known_resource_types = @scope.environment.known_resource_types
 
         node      = Puppet::Node.new('localhost')
         @compiler = Puppet::Parser::Compiler.new(node)