puppet 4.2.3 → 4.3.0

data/spec/unit/network/authorization_spec.rb

@@ -1,5 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/network/http'
+require 'puppet/network/http/api/indirected_routes'
 require 'puppet/network/authorization'
 
 describe Puppet::Network::Authorization do
@@ -9,7 +11,7 @@ describe Puppet::Network::Authorization do
 
   subject { AuthTest.new }
 
-  describe "when creating an authconfig object" do
+  context "when creating an authconfig object" do
     before :each do
       # Other tests may have created an authconfig, so we have to undo that.
       @orig_auth_config = Puppet::Network::AuthConfigLoader.instance_variable_get(:@auth_config)
@@ -26,9 +28,35 @@ describe Puppet::Network::Authorization do
 
     it "creates default ACL entries if no file has been read" do
       Puppet::Network::AuthConfigParser.expects(:new_from_file).raises Errno::ENOENT
-      Puppet::Network::AuthConfig.any_instance.expects(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
 
       subject.authconfig
     end
   end
+
+  class TestAuthConfig
+    def check_authorization(method, path, params); end
+  end
+
+  class TestAuthConfigLoader
+    def self.authconfig
+      TestAuthConfig.new
+    end
+  end
+
+  context "when checking authorization" do
+    after :each do
+      Puppet::Network::Authorization.authconfigloader_class = nil
+    end
+
+    it "delegates to the authconfig object" do
+      Puppet::Network::Authorization.authconfigloader_class =
+          TestAuthConfigLoader
+      TestAuthConfig.any_instance.expects(:check_authorization).with(
+          :save, '/mypath', {:param1 => "value1"}).returns("yay, it worked!")
+      expect(subject.check_authorization(
+                 :save, '/mypath',
+                 {:param1 => "value1"})).to eq("yay, it worked!")
+    end
+  end
 end

data/spec/unit/network/http/connection_spec.rb

@@ -42,31 +42,18 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  context "when methods that accept a block are called with a block" do
-    let (:host) { "my_server" }
+  context "when handling requests", :vcr do
+    let (:host) { "my-server" }
     let (:port) { 8140 }
     let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
 
-    before :each do
-      httpok.stubs(:body).returns ""
-
-      # This stubbing relies a bit more on knowledge of the internals of Net::HTTP
-      # than I would prefer, but it works on ruby 1.8.7 and 1.9.3, and it seems
-      # valuable enough to have tests for blocks that this is probably warranted.
-      socket = stub_everything("socket")
-      TCPSocket.stubs(:open).returns(socket)
-
-      Net::HTTP::Post.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Head.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Get.any_instance.stubs(:exec).returns("")
-      Net::HTTPResponse.stubs(:read_new).returns(httpok)
-    end
-
-    [:request_get, :request_head, :request_post].each do |method|
+    { :request_get  => {},
+      :request_head => {},
+      :request_post => "param: value" }.each do |method,body|
       context "##{method}" do
         it "should yield to the block" do
           block_executed = false
-          subject.send(method, "/foo", {}) do |response|
+          subject.send(method, "/foo", body) do |response|
             block_executed = true
           end
           expect(block_executed).to eq(true)
@@ -118,6 +105,14 @@ describe Puppet::Network::HTTP::Connection do
     let (:host) { "my_server" }
     let (:port) { 8140 }
 
+    before :all do
+      WebMock.disable!
+    end
+
+    after :all do
+      WebMock.enable!
+    end
+
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
       connection = Puppet::Network::HTTP::Connection.new(
         host, port,

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
@@ -112,6 +116,7 @@ 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
@@ -141,11 +146,90 @@ 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 report 'trusted' parameters as trusted_data but as inauthentic if running as non-root" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = { 'authenticated' => true,
+                                     'certname'      => 'foo',
+                                     'extensions'    => 'things' }
+
+      Puppet.features.stubs(:root?).returns(false)
+
+      Puppet.ignore(:trusted_information)
+      compiler = Puppet::Parser::Compiler.new(node)
+      Puppet.restore(:trusted_information)
+
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to eq({ 'authenticated' => false,
+                                             'certname'      => 'foo',
+                                             'extensions'    => 'things' })
+    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
@@ -629,7 +713,7 @@ describe Puppet::Parser::Compiler do
       @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]")
+      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
@@ -637,7 +721,7 @@ describe Puppet::Parser::Compiler do
       @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]")
+      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

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

@@ -103,7 +103,7 @@ describe 'function for dynamically creating resources' do
 
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
-      }.to raise_error(Puppet::Error, 'Must pass one to Foocreateresource[blah] on node foonode')
+      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node foonode/)
     end
 
     it 'should be able to add multiple defines' do

data/spec/unit/parser/resource_spec.rb

@@ -105,9 +105,9 @@ describe Puppet::Parser::Resource do
       @arguments = {:scope => @scope}
     end
 
-    it "should fail unless #{name.to_s} is specified" do
+    it "should fail unless hash is specified" do
       expect {
-        Puppet::Parser::Resource.new('file', '/my/file')
+        Puppet::Parser::Resource.new('file', '/my/file', nil)
       }.to raise_error(ArgumentError, /Resources require a hash as last argument/)
     end
 
@@ -531,24 +531,6 @@ describe Puppet::Parser::Resource do
     end
   end
 
-  describe "when validating" do
-    it "should check each parameter" do
-      resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
-      resource[:one] = :two
-      resource[:three] = :four
-      resource.expects(:validate_parameter).with(:one)
-      resource.expects(:validate_parameter).with(:three)
-      resource.send(:validate)
-    end
-
-    it "should raise a parse error when there's a failure" do
-      resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
-      resource[:one] = :two
-      resource.expects(:validate_parameter).with(:one).raises ArgumentError
-      expect { resource.send(:validate) }.to raise_error(Puppet::ParseError)
-    end
-  end
-
   describe "when setting parameters" do
     before do
       @source = newclass "foobar"

data/spec/unit/pops/binder/config/binder_config_spec.rb

@@ -16,7 +16,7 @@ describe 'BinderConfig' do
     expect(config.layering_config[0]['name']).to    be == 'site'
     expect(config.layering_config[0]['include']).to be == ['confdir:/default?optional']
     expect(config.layering_config[1]['name']).to    be == 'modules'
-    expect(config.layering_config[1]['include']).to be == ['module:/*::default']
+    expect(config.layering_config[1]['include']).to be == ['module:/*::default', 'module:/*::metadata']
   end
 
   it 'should load binder_config.yaml if it exists in confdir)' do

data/spec/unit/pops/binder/injector_spec.rb

@@ -594,11 +594,11 @@ describe 'Injector' do
       it "should fail attempts to append, perform  uniq or flatten on type incompatible multibind hash" do
         hash_of_integer = type_factory.hash_of(type_factory.integer())
         ids = ["ducks1", "ducks2", "ducks3"]
-        mb = bindings.multibind(ids[0]).type(hash_of_integer.copy).name('broken_family0')
+        mb = bindings.multibind(ids[0]).type(hash_of_integer).name('broken_family0')
         mb.producer_options(:conflict_resolution => :append)
-        mb = bindings.multibind(ids[1]).type(hash_of_integer.copy).name('broken_family1')
+        mb = bindings.multibind(ids[1]).type(hash_of_integer).name('broken_family1')
         mb.producer_options(:flatten => :true)
-        mb = bindings.multibind(ids[2]).type(hash_of_integer.copy).name('broken_family2')
+        mb = bindings.multibind(ids[2]).type(hash_of_integer).name('broken_family2')
         mb.producer_options(:uniq => :true)
 
         injector = injector(binder.new(factory.layered_bindings(test_layer_with_bindings(bindings.model))))

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -208,13 +208,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a size constrained Array when the last two arguments specify this' do
       expr = fqr('Array')[fqr('String'), 1]
-      expected_t = types.array_of(String)
-      types.constrain_size(expected_t, 1, :default)
+      expected_t = types.array_of(String, types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Array')[fqr('String'), 1, 2]
-      expected_t = types.array_of(String)
-      types.constrain_size(expected_t, 1, 2)
+      expected_t = types.array_of(String, types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
@@ -227,11 +225,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     #
     it 'produces a Tuple[String] from the expression Tuple[String]' do
       expr = fqr('Tuple')[fqr('String')]
-      expect(evaluate(expr)).to be_the_type(types.tuple(String))
+      expect(evaluate(expr)).to be_the_type(types.tuple([String]))
 
       # arguments are flattened
       expr = fqr('Tuple')[[fqr('String')]]
-      expect(evaluate(expr)).to be_the_type(types.tuple(String))
+      expect(evaluate(expr)).to be_the_type(types.tuple([String]))
     end
 
     it "Tuple parameterization gives an error if parameter is not a type" do
@@ -241,13 +239,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a varargs Tuple when the last two arguments specify size constraint' do
       expr = fqr('Tuple')[fqr('String'), 1]
-      expected_t = types.tuple(String)
-      types.constrain_size(expected_t, 1, :default)
+      expected_t = types.tuple([String], types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Tuple')[fqr('String'), 1, 2]
-      expected_t = types.tuple(String)
-      types.constrain_size(expected_t, 1, 2)
+      expected_t = types.tuple([String], types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
@@ -416,7 +412,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     it 'produces a NotUndef instance with String type when given a literal String' do
       type_expr = fqr('NotUndef')[literal('hey')]
       tf = Puppet::Pops::Types::TypeFactory
-      expect(evaluate(type_expr)).to eql(tf.not_undef(tf.string('hey')))
+      expect(evaluate(type_expr)).to be_the_type(tf.not_undef(tf.string(nil, 'hey')))
+    end
+
+    it 'Produces Optional instance with String type when using a String argument' do
+      type_expr = fqr('Optional')[literal('hey')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to be_the_type(tf.optional(tf.string(nil, 'hey')))
     end
 
     # Type Type

data/spec/unit/pops/evaluator/basic_expressions_spec.rb

@@ -31,8 +31,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'should evaluator types to types' do
-      array_type = Puppet::Pops::Types::PArrayType.new()
-      array_type.element_type = Puppet::Pops::Types::PDataType.new()
+      array_type = Puppet::Pops::Types::PArrayType::DATA
       expect(evaluate(fqr('Array'))).to eq(array_type)
     end
   end

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -685,23 +685,23 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     # Type operations (full set tested by tests covering type calculator)
     {
       "Array[Integer]"                  => types.array_of(types.integer),
-      "Array[Integer,1]"                => types.constrain_size(types.array_of(types.integer),1, :default),
-      "Array[Integer,1,2]"              => types.constrain_size(types.array_of(types.integer),1, 2),
-      "Array[Integer,Integer[1,2]]"     => types.constrain_size(types.array_of(types.integer),1, 2),
-      "Array[Integer,Integer[1]]"       => types.constrain_size(types.array_of(types.integer),1, :default),
+      "Array[Integer,1]"                => types.array_of(types.integer, types.range(1, :default)),
+      "Array[Integer,1,2]"              => types.array_of(types.integer, types.range(1, 2)),
+      "Array[Integer,Integer[1,2]]"     => types.array_of(types.integer, types.range(1, 2)),
+      "Array[Integer,Integer[1]]"       => types.array_of(types.integer, types.range(1, :default)),
       "Hash[Integer,Integer]"           => types.hash_of(types.integer, types.integer),
-      "Hash[Integer,Integer,1]"         => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
-      "Hash[Integer,Integer,1,2]"       => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
-      "Hash[Integer,Integer,Integer[1,2]]" => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
-      "Hash[Integer,Integer,Integer[1]]"   => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
+      "Hash[Integer,Integer,1]"         => types.hash_of(types.integer, types.integer, types.range(1, :default)),
+      "Hash[Integer,Integer,1,2]"       => types.hash_of(types.integer, types.integer, types.range(1, 2)),
+      "Hash[Integer,Integer,Integer[1,2]]" => types.hash_of(types.integer, types.integer, types.range(1, 2)),
+      "Hash[Integer,Integer,Integer[1]]"   => types.hash_of(types.integer, types.integer, types.range(1, :default)),
       "Resource[File]"                  => types.resource('File'),
       "Resource['File']"                => types.resource(types.resource('File')),
       "File[foo]"                       => types.resource('file', 'foo'),
       "File[foo, bar]"                  => [types.resource('file', 'foo'), types.resource('file', 'bar')],
       "Pattern[a, /b/, Pattern[c], Regexp[d]]"  => types.pattern('a', 'b', 'c', 'd'),
-      "String[1,2]"                     => types.constrain_size(types.string,1, 2),
-      "String[Integer[1,2]]"            => types.constrain_size(types.string,1, 2),
-      "String[Integer[1]]"              => types.constrain_size(types.string,1, :default),
+      "String[1,2]"                     => types.string(types.range(1, 2)),
+      "String[Integer[1,2]]"            => types.string(types.range(1, 2)),
+      "String[Integer[1]]"              => types.string(types.range(1, :default)),
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
@@ -1195,6 +1195,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(scope.compiler).to have_relationship(['File', 'b', '->', 'File', 'y'])
     end
 
+    it 'should form a relation with 3.x resource -> resource' do
+      # Create a 3.x resource since this is the value given as arguments to defined type
+      scope['a_3x_resource']= Puppet::Parser::Resource.new('notify', 'a', {:scope => scope, :file => __FILE__, :line => 1})
+      source = "$a_3x_resource -> notify{b:}"
+      parser.evaluate_string(scope, source, __FILE__)
+      expect(scope.compiler).to have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
+    end
+
     it 'should tolerate (eliminate) duplicates in operands' do
       source = "[File[a], File[a]] -> File[x]"
       parser.evaluate_string(scope, source, __FILE__)

data/spec/unit/pops/evaluator/literal_evaluator_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/literal_evaluator'
+
+describe "Puppet::Pops::Evaluator::LiteralEvaluator" do
+  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+  let(:leval)  {  Puppet::Pops::Evaluator::LiteralEvaluator.new }
+
+  { "1"       => 1,
+    "3.14"    => 3.14,
+    "true"    => true,
+    "false"   => false,
+    "'1'"     => '1',
+    "'a'"     => 'a',
+    '"a"'     => 'a',
+    'a'       => 'a',
+    'a::b'    => 'a::b',
+
+    # special values
+    'default' => :default,
+    '/.*/'    => /.*/,
+
+    # collections
+    '[1,2,3]'     => [1,2,3],
+    '{a=>1,b=>2}' => {'a' => 1, 'b' => 2},
+
+  }.each do |source, result|
+    it "evaluates '#{source}' to #{result}" do
+      expect(leval.literal(parser.parse_string(source))).to eq(result)
+    end
+  end
+
+  it "evaluates undef to nil" do
+    expect(leval.literal(parser.parse_string('undef'))).to be_nil
+  end
+
+  ['1+1', 'File', '[1,2, 1+2]', '{a=>1+1}', 'Integer[1]', '"x$y"', '"x${y}z"'].each do |source|
+    it "throws :not_literal for non literal expression '#{source}'" do
+      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
+    end
+  end
+end