puppet 4.4.2-universal-darwin → 4.5.0-universal-darwin

data/spec/unit/functions/regsubst_spec.rb

@@ -44,6 +44,10 @@ describe 'the regsubst function' do
     it 'should handle case insensitive flag' do
       expect(regsubst('the monkey breaks baNAna trees', 'b[an]+a', 'coconut', 'I')).to eql('the monkey breaks coconut trees')
     end
+
+    it 'should allow hash as replacement' do
+      expect(regsubst('tuto', '[uo]', { 'u' => 'o', 'o' => 'u' }, 'G')).to eql('totu')
+    end
   end
 
   context 'when using a regexp pattern' do
@@ -70,6 +74,10 @@ describe 'the regsubst function' do
     it 'should treat Regexp as Regexp[//]' do
       expect(regsubst('abc', type_parser.parse("Regexp"), '_', 'G')).to eql('_a_b_c_')
     end
+
+    it 'should allow hash as replacement' do
+      expect(regsubst('tuto', /[uo]/, { 'u' => 'o', 'o' => 'u' }, 'G')).to eql('totu')
+    end
   end
 
   context 'when using an array target' do

data/spec/unit/functions/then_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the then function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'calls a lambda passing one argument' do
+    expect(compile_to_catalog("then(testing) |$x| { notify { $x: } }")).to have_resource('Notify[testing]')
+  end
+
+  it 'produces what lambda returns if value is not undef' do
+    expect(compile_to_catalog("notify{ then(1) |$x| { testing }: }")).to have_resource('Notify[testing]')
+  end
+
+  it 'does not call lambda if argument is undef' do
+    expect(compile_to_catalog('then(undef) |$x| { notify { "failed": } }')).to_not have_resource('Notify[failed]')
+  end
+
+  it 'produces undef if given value is undef' do
+    expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test-Undef-ing]')
+    notify{ "test-${type(then(undef) |$x| { testing })}-ing": }
+    SOURCE
+  end
+
+  it 'errors when lambda wants too many args' do
+    expect do
+      compile_to_catalog('then(1) |$x, $y| { }')
+    end.to raise_error(/'then' block expects 1 argument, got 2/m)
+  end
+
+  it 'errors when lambda wants too few args' do
+    expect do
+      compile_to_catalog('then(1) || { }')
+    end.to raise_error(/'then' block expects 1 argument, got none/m)
+  end
+
+end

data/spec/unit/functions4_spec.rb

@@ -14,15 +14,15 @@ module FunctionAPISpecModule
     end
 
     def add_function(name, function)
-      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, name)
-      entry = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, function, __FILE__)
-      @constants[typed_name] = entry
+      set_entry(Puppet::Pops::Loader::Loader::TypedName.new(:function, name), function, __FILE__)
     end
 
     def add_type(name, type)
-      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:type, name)
-      entry = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, type, __FILE__)
-      @constants[typed_name] = entry
+      set_entry(Puppet::Pops::Loader::Loader::TypedName.new(:type, name), type, __FILE__)
+    end
+
+    def set_entry(typed_name, value, origin = nil)
+      @constants[typed_name] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
     end
 
     # override StaticLoader
@@ -472,10 +472,10 @@ describe 'the 4x function api' do
       end
     end
 
-    context 'can use a loader when parsing types in function dispatch' do
+    context 'can use a loader when parsing types in function dispatch, and' do
       let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
 
-      it 'and resolve a referenced Type alias' do
+      it 'resolve a referenced Type alias' do
         the_loader = loader()
         the_loader.add_type('myalias', type_alias_t('MyAlias', 'Integer'))
         here = get_binding(the_loader)
@@ -495,7 +495,7 @@ describe 'the 4x function api' do
         expect(parser.evaluate({}, program)).to eql(10)
       end
 
-      it 'and distinguish between a Type alias and a Resource type' do
+      it 'reports a reference to an unresolved type' do
         the_loader = loader()
         here = get_binding(the_loader)
         fc = eval(<<-CODE, here)
@@ -511,11 +511,79 @@ describe 'the 4x function api' do
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
         Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
-        expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error, /parameter 'x' expects a Resource value, got Integer/)
+        expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error, /parameter 'x' references an unresolved type 'MyAlias'/)
+      end
+
+      it 'create local Type aliases' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            local_types do
+              type 'MyType = Array[Integer]'
+            end
+            dispatch :test do
+              param 'MyType', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test([10,20])', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
+        expect(parser.evaluate({}, program)).to eq([10,20])
+      end
+
+      it 'create nested local Type aliases' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            local_types do
+              type 'InnerType = Array[Integer]'
+              type 'OuterType = Hash[String,InnerType]'
+            end
+            dispatch :test do
+              param 'OuterType', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string("testing::test({'x' => [10,20]})", __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
+        expect(parser.evaluate({}, program)).to eq({'x' => [10,20]})
+      end
+
+      it 'create self referencing local Type aliases' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            local_types do
+              type 'Tree = Hash[String,Variant[String,Tree]]'
+            end
+            dispatch :test do
+              param 'Tree', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string("testing::test({'x' => {'y' => 'n'}})", __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
+        expect(parser.evaluate({}, program)).to eq({'x' => {'y' => 'n'}})
       end
     end
   end
 
+
   def create_noargs_function_class
     f = Puppet::Functions.create_function('test') do
       def test()

data/spec/unit/hiera_puppet_spec.rb

@@ -63,17 +63,58 @@ describe 'HieraPuppet' do
       expect(HieraPuppet.send(:hiera_config_file)).to eq(Puppet[:hiera_config])
     end
 
-    it "should use Puppet.settings[:codedir] as the base directory when hiera_config is not set" do
-      begin
+    context 'when hiera_config is not set' do
+      let(:code_hiera_config) { File.join(Puppet[:codedir], 'hiera.yaml') }
+      let(:conf_hiera_config) { File.join(Puppet[:confdir], 'hiera.yaml') }
+
+      before(:each) do
+        Puppet.settings.setting(:hiera_config).send(:remove_instance_variable, :@evaluated_default)
         Puppet.settings[:hiera_config] = nil
-      rescue ArgumentError => detail
-        raise unless detail.message =~ /unknown setting/
+        Puppet.settings[:codedir] = '/dev/null/puppetlabs/code'
+        Puppet.settings[:confdir] = '/dev/null/puppetlabs/puppet'
       end
-      Puppet.settings[:codedir] = "/dev/null/puppet"
-      hiera_config = File.join(Puppet[:codedir], 'hiera.yaml')
-      Puppet::FileSystem.stubs(:exist?).with(hiera_config).returns(true)
 
-      expect(HieraPuppet.send(:hiera_config_file)).to eq(hiera_config)
+      it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' does not exist" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
+      end
+
+      it "should use Puppet.settings[:confdir]/hiera.yaml when '$codedir/hiera.yaml' does not exist and '$confdir/hiera.yaml' exists" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(conf_hiera_config)
+      end
+
+      it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' exists" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
+      end
+
+      it "should return nil when neither '$codedir/hiera.yaml' nor '$confdir/hiera.yaml' exists" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(nil)
+      end
+
+      it "should return explicitly set option even if both '$codedir/hiera.yaml' and '$confdir/hiera.yaml' exists" do
+        if Puppet::Util::Platform.windows?
+          explicit_hiera_config = 'C:/an/explicit/hiera.yaml'
+        else
+          explicit_hiera_config = '/an/explicit/hiera.yaml'
+        end
+        Puppet.settings[:hiera_config] = explicit_hiera_config
+        Puppet::FileSystem.stubs(:exist?).with(explicit_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(explicit_hiera_config)
+      end
     end
   end
 

data/spec/unit/indirector/resource_type/parser_spec.rb

@@ -21,6 +21,11 @@ describe Puppet::Indirector::ResourceType::Parser do
     expect(Puppet::Indirector::Terminus.terminus_class(:resource_type, :parser)).to equal(Puppet::Indirector::ResourceType::Parser)
   end
 
+  it "is deprecated on the network, but still allows requests" do
+    Puppet.expects(:deprecation_warning)
+    expect(Puppet::Indirector::ResourceType::Parser.new.allow_remote_requests?).to eq(true)
+  end
+
   describe "when finding" do
     it "should return any found type from the request's environment" do
       type = Puppet::Resource::Type.new(:hostclass, "foo")

data/spec/unit/indirector/rest_spec.rb

@@ -190,6 +190,18 @@ describe Puppet::Indirector::REST do
     expect(Puppet::Indirector::REST.srv_service).to eq(:puppet)
   end
 
+  it 'excludes yaml from the Accept header' do
+    model.expects(:supported_formats).returns([:pson, :yaml, :binary])
+
+    expect(terminus.headers['Accept']).to eq('pson, binary')
+  end
+
+  it 'excludes b64_zlib_yaml from the Accept header' do
+    model.expects(:supported_formats).returns([:pson, :b64_zlib_yaml])
+
+    expect(terminus.headers['Accept']).to eq('pson')
+  end
+
   describe "when creating an HTTP client" do
     it "should use the class's server and port if the indirection request provides neither" do
       @request = stub 'request', :key => "foo", :server => nil, :port => nil

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::API::Master::V3::Environment do
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+
+  around :each do |example|
+    environment = Puppet::Node::Environment.create(:production, [], '/manifests')
+    loader = Puppet::Environments::Static.new(environment)
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  it "returns the environment catalog" do
+    request = Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }, :routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(response.code).to eq(200)
+
+    catalog = JSON.parse(response.body)
+    expect(catalog['environment']).to eq('production')
+    expect(catalog['applications']).to eq({})
+  end
+
+  it "returns 404 if the environment doesn't exist" do
+    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/development")
+
+    expect { subject.call(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError, /development is not a known environment/)
+  end
+
+  it "omits code_id if unspecified" do
+    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to be_nil
+  end
+
+  it "includes code_id if specified" do
+    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to eq('12345')
+  end
+
+  it "uses code_id from the catalog if it differs from the request" do
+    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
+
+    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('67890')
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to eq('67890')
+  end
+end
+

data/spec/unit/node/environment_spec.rb

@@ -428,6 +428,16 @@ describe Puppet::Node::Environment do
     end
 
     describe "when performing initial import" do
+      let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+      around :each do |example|
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.override(:loaders => loaders, :current_environment => env) do
+          example.run
+          Puppet::Pops::Loaders.clear
+        end
+      end
+
       it "loads from Puppet[:code]" do
         Puppet[:code] = "define foo {}"
         krt = env.known_resource_types

data/spec/unit/parser/compiler_spec.rb

@@ -258,7 +258,7 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.topscope['c']).to eq("d")
     end
 
-    it "should set node parameters thar are of Symbol type as String variables in the top scope" do
+    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)
@@ -838,6 +838,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
 
@@ -951,6 +969,7 @@ describe Puppet::Parser::Compiler do
     end
   end
 
+
   describe "when managing resource overrides" do
 
     before 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, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node foonode/)
+      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node test/)
     end
 
     it 'should be able to add multiple defines' do
@@ -169,7 +169,7 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'blah'=>{'one'=>'two'}})
         MANIFEST
-      end.to raise_error(/Could not find declared class blah at line 1:11 on node foonode/)
+      end.to raise_error(/Could not find declared class blah at line 1:11 on node test/)
     end
 
     it 'should be able to add edges' do

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

@@ -24,7 +24,7 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
   it 'raises and error for Resource that is not of class type' do
     expect {
       @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('file')])
-    }.to raise_error(ArgumentError, /Cannot use a Resource\[file\] where a Resource\['class', name\] is expected/)
+    }.to raise_error(ArgumentError, /Cannot use a Resource\[File\] where a Resource\['class', name\] is expected/)
   end
 
   it 'raises and error for Resource that is unspecific' do

data/spec/unit/parser/resource_spec.rb

@@ -193,6 +193,13 @@ describe Puppet::Parser::Resource do
       expect(@compiler.catalog).to be_edge(foo_stage, resource)
     end
 
+    it 'should allow a resource reference to be undef' do
+      Puppet[:code] = "notify { 'hello': message=>'yo', notify => undef }"
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+      expect(edges).to include(['Class[main]', 'Notify[hello]'])
+    end
+
     it "should allow edges to propagate multiple levels down the scope hierarchy" do
       Puppet[:code] = <<-MANIFEST
         stage { before: before => Stage[main] }
@@ -556,7 +563,7 @@ describe Puppet::Parser::Resource do
 
   # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
   it "should not include 'undef' parameters when converting itself to a hash" do
-    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => mock("scope")
+    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => @scope
     resource[:owner] = :undef
     resource[:mode] = "755"
     expect(resource.to_hash[:owner]).to be_nil