puppet 4.0.0 → 4.9.1

data/spec/unit/parser/compiler_spec.rb

@@ -49,6 +49,10 @@ class CompilerTestResource
   def line
     "42"
   end
+
+  def resource_type
+    self.class
+  end
 end
 
 describe Puppet::Parser::Compiler do
@@ -95,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"
@@ -112,13 +112,9 @@ describe Puppet::Parser::Compiler do
     it "should set its node attribute" 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
@@ -141,11 +137,72 @@ describe Puppet::Parser::Compiler do
       expect(compiler.classlist).to match_array(['foo', 'bar'])
     end
 
+    it "should return a catalog with the specified code_id" do
+      node = Puppet::Node.new("mynode")
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      compiler = Puppet::Parser::Compiler.new(node, :code_id => code_id)
+
+      expect(compiler.catalog.code_id).to eq(code_id)
+    end
+
     it "should add a 'main' stage to the catalog" do
       expect(@compiler.catalog.resource(:stage, :main)).to be_instance_of(Puppet::Parser::Resource)
     end
   end
 
+  describe "sanitize_node" do
+    it "should delete trusted from parameters" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] =  { :a => 42 }
+      node.parameters['preserve_me'] = 'other stuff'
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.parameters['trusted']).to eq(nil)
+      expect(sanitized.parameters['preserve_me']).to eq('other stuff')
+    end
+
+    it "should not report trusted_data if trusted is false" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = false
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to_not eq(false)
+    end
+
+    it "should not report trusted_data if trusted is not a hash" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = 'not a hash'
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to_not eq('not a hash')
+    end
+
+    it "should not report trusted_data if trusted hash doesn't include known keys" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = { :a => 42 }
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to_not eq({ :a => 42 })
+    end
+
+    it "should prefer trusted_data in the node above other plausible sources" do
+      node = Puppet::Node.new("mynode")
+      node.trusted_data = { 'authenticated' => true,
+                           'certname'      => 'the real deal',
+                           'extensions'    => 'things' }
+
+      node.parameters['trusted'] = { 'authenticated' => true,
+                                     'certname'      => 'not me',
+                                     'extensions'    => 'things' }
+
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to eq({ 'authenticated' => true,
+                                             'certname'      => 'the real deal',
+                                             'extensions'    => 'things' })
+    end
+  end
+
   describe "when managing scopes" do
 
     it "should create a top scope" do
@@ -192,6 +249,22 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.topscope['c']).to eq("d")
     end
 
+    it "should set node parameters that are of Symbol type as String variables in the top scope" do
+      params = {"a" => :b}
+      @node.stubs(:parameters).returns(params)
+      compile_stub(:set_node_parameters)
+      @compiler.compile
+      expect(@compiler.topscope['a']).to eq("b")
+    end
+
+    it "should set the node's environment as a string variable in top scope" do
+      compile_stub(:set_node_parameters)
+      @node.merge({'wat' => 'this is how the sausage is made'})
+      @compiler.compile
+      expect(@compiler.topscope['environment']).to eq("testing")
+      expect(@compiler.topscope['wat']).to eq('this is how the sausage is made')
+    end
+
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
@@ -526,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
@@ -542,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
 
@@ -576,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
@@ -615,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
 
@@ -628,22 +698,22 @@ 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
-      expect { @compiler.compile }.to raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
+      @compiler.environment.known_resource_types.add klass
+      expect { @compiler.compile }.to raise_error(Puppet::PreformattedError, /Class\[Foo\]: expects a value for parameter 'b'/)
     end
 
     it "should fail if invalid parameters are passed" do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
-      @compiler.topscope.known_resource_types.add klass
-      expect { @compiler.compile }.to raise_error(Puppet::ParseError, "Invalid parameter: '3' on Class[Foo]")
+      @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
@@ -684,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
@@ -696,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)
@@ -707,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
@@ -725,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)
@@ -735,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)
@@ -745,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)
@@ -756,6 +825,24 @@ describe Puppet::Parser::Compiler do
     end
   end
 
+  describe 'when using meta parameters to form relationships' do
+    include PuppetSpec::Compiler
+    [:before, :subscribe, :notify, :require].each do | meta_p |
+      it "an entry consisting of nested empty arrays is flattened for parameter #{meta_p}" do
+          expect {
+          node = Puppet::Node.new('someone')
+          manifest = <<-"MANIFEST"
+            notify{hello_kitty: message => meow, #{meta_p} => [[],[]]}
+            notify{hello_kitty2: message => meow, #{meta_p} => [[],[[]],[]]}
+          MANIFEST
+
+          catalog = compile_to_catalog(manifest, node)
+          catalog.to_ral
+        }.not_to raise_error
+      end
+    end
+  end
+
   describe "when evaluating node classes" do
     include PuppetSpec::Compiler