puppet 4.4.0 → 4.5.0

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/catalog/compiler_spec.rb

@@ -94,6 +94,13 @@ describe Puppet::Resource::Catalog::Compiler do
       @compiler.find(@request)
     end
 
+    it "should pass node containing percent character to the compiler" do
+      node_with_percent_character = Puppet::Node.new "%6de"
+      Puppet::Node.indirection.stubs(:find).returns(node_with_percent_character)
+      Puppet::Parser::Compiler.expects(:compile).with(node_with_percent_character, anything)
+      @compiler.find(@request)
+    end
+
     it "should extract and save any facts from the request" do
       Puppet::Node.indirection.expects(:find).with(@name, anything).returns @node
       @compiler.expects(:extract_facts_from_request).with(@request)

data/spec/unit/indirector/msgpack_spec.rb

@@ -76,12 +76,22 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
         expect(subject.find(request)).to be_nil
       end
 
+      it "can load a UTF-8 file from disk" do
+        rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+
+        with_content(model.new(rune_utf8).to_msgpack) do
+          instance = subject.find(request)
+          expect(instance).to be_an_instance_of model
+          expect(instance.value).to eq(rune_utf8)
+        end
+      end
+
       it "raises a descriptive error when the file can't be read" do
         with_content(model.new('foo').to_msgpack) do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          File.expects(:read).with(file).raises(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file, {:encoding => 'utf-8'}).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read MessagePack/
         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/module_spec.rb

@@ -609,21 +609,21 @@ describe Puppet::Module do
 
   it "should have metadata if it has a metadata file and its data is not empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
 
     expect(@module).to be_has_metadata
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
 
     expect(@module).to be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns "This is some invalid json.\n"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
     expect(@module).not_to be_has_metadata
   end
 
@@ -646,7 +646,7 @@ describe Puppet::Module do
 
   it "should tolerate failure to parse" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns(my_fixture('trailing-comma.json'))
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
     expect(@module.has_metadata?).to be_falsey
   end
@@ -656,7 +656,7 @@ describe Puppet::Module do
 
     mod = Puppet::Module.new("foo", "/path", mock("env"))
     mod.stubs(:metadata_file).returns "/my/file"
-    File.stubs(:read).with("/my/file").returns text
+    File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns text
     mod
   end
 
@@ -681,7 +681,7 @@ describe Puppet::Module do
       it "should fail if #{attr} is not present in the metadata file" do
         @data.delete(attr.to_sym)
         @text = @data.to_pson
-        File.stubs(:read).with("/my/file").returns @text
+        File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns @text
         expect { @module.load_metadata }.to raise_error(
           Puppet::Module::MissingMetadata,
           "No #{attr} module metadata provided for foo"
@@ -690,6 +690,30 @@ describe Puppet::Module do
     end
   end
 
+  describe "when loading the metadata file from disk" do
+    it "should properly parse utf-8 contents" do
+      rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+      metadata_json = tmpfile('metadata.json')
+      File.open(metadata_json, 'w') do |file|
+        file.puts <<-EOF
+  {
+    "license" : "GPL2",
+    "author" : "#{rune_utf8}",
+    "version" : "1.0",
+    "source" : "http://foo/",
+    "dependencies" : []
+  }
+        EOF
+      end
+
+      mod = Puppet::Module.new('foo', '/path', mock('env'))
+      mod.stubs(:metadata_file).returns metadata_json
+
+      mod.load_metadata
+      expect(mod.author).to eq(rune_utf8)
+    end
+  end
+
   it "should be able to tell if there are local changes" do
     modpath = tmpdir('modpath')
     foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -56,37 +56,41 @@ describe Puppet::ModuleTool::Applications::Builder do
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitartifact'))
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitimportantfile'))
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/sub/artifact'))
+      Puppet::FileSystem.touch(File.join(path, "git\u16A0\u16C7\u16BB"))
       Puppet::FileSystem.touch(File.join(path, 'pmtignored.foo'))
       Puppet::FileSystem.mkpath(File.join(path, 'pmtdirectory/sub'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtimportantfile'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtartifact'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/sub/artifact'))
+      Puppet::FileSystem.touch(File.join(path, "pmt\u16A0\u16C7\u16BB"))
     end
 
     def create_pmtignore_file
-      Puppet::FileSystem.open(File.join(path, '.pmtignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.pmtignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-PMTIGNORE
 pmtignored.*
 pmtdirectory/sub/**
 pmtdirectory/pmt*
 !pmtimportantfile
+pmt\u16A0\u16C7\u16BB
 PMTIGNORE
       end
     end
 
     def create_gitignore_file
-      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.gitignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-GITIGNORE
 gitignored.*
 gitdirectory/sub/**
 gitdirectory/git*
 !gitimportantfile
+git\u16A0\u16C7\u16BB
 GITIGNORE
       end
     end
 
     def create_symlink_gitignore_file
-      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.gitignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-GITIGNORE
 symlinkfile
     GITIGNORE
@@ -152,6 +156,10 @@ symlinkfile
         expect(target_exists?('gitignored.foo')).to eq true
       end
 
+      it "leaves UTF-8 files" do
+        expect(target_exists?("git\u16A0\u16C7\u16BB")).to eq true
+      end
+
       it "leaves directories" do
         expect(target_exists?('gitdirectory')).to eq true
       end
@@ -178,6 +186,10 @@ symlinkfile
         expect(target_exists?('gitignored.foo')).to eq false
       end
 
+      it "ignores UTF-8 files" do
+        expect(target_exists?("git\u16A0\u16C7\u16BB")).to eq false
+      end
+
       it "ignores directories" do
         expect(target_exists?('gitdirectory')).to eq true
       end
@@ -204,6 +216,10 @@ symlinkfile
         expect(target_exists?('pmtignored.foo')).to eq true
       end
 
+      it "leaves UTF-8 files" do
+        expect(target_exists?("pmt\u16A0\u16C7\u16BB")).to eq true
+      end
+
       it "leaves directories" do
         expect(target_exists?('pmtdirectory')).to eq true
       end
@@ -230,6 +246,10 @@ symlinkfile
         expect(target_exists?('pmtignored.foo')).to eq false
       end
 
+      it "ignores UTF-8 files" do
+        expect(target_exists?("pmt\u16A0\u16C7\u16BB")).to eq false
+      end
+
       it "ignores directories" do
         expect(target_exists?('pmtdirectory')).to eq true
       end