puppet 4.5.3-x64-mingw32 → 4.6.1-x64-mingw32

data/spec/unit/face/parser_spec.rb

@@ -14,6 +14,12 @@ describe Puppet::Face[:parser, :current] do
         from_an_interactive_terminal
       end
 
+      after(:each) do
+        # Reset cache of loaders (many examples run in the *root* environment
+        # which exists in "eternity")
+        Puppet.lookup(:current_environment).loaders = nil
+      end
+
       it "validates the configured site manifest when no files are given" do
         manifest = file_containing('site.pp', "{ invalid =>")
 

data/spec/unit/face/plugin_spec.rb

@@ -12,10 +12,6 @@ describe Puppet::Face[:plugin, :current] do
   end
 
   context "download" do
-    before :each do
-      Puppet.features.stubs(:external_facts?).returns(true)
-    end
-
     it "downloads plugins and external facts" do
       Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
 

data/spec/unit/file_system_spec.rb

@@ -649,5 +649,90 @@ describe "Puppet::FileSystem" do
         end.to raise_error(Errno::EEXIST)
       end
     end
+
+    describe 'expand_path' do
+      it 'should raise an error when given nil, like Ruby File.expand_path' do
+        expect { File.expand_path(nil) }.to raise_error(TypeError)
+
+        # match Ruby behavior
+        expect { Puppet::FileSystem.expand_path(nil) }.to raise_error(TypeError)
+      end
+
+      it 'with an expanded path passed to Dir.glob, the same expanded path will be returned' do
+        # this exists specifically for Puppet::Pops::Loader::ModuleLoaders::FileBased#add_to_index
+        # which should receive an expanded path value from it's parent Environment
+        # and will later compare values generated by Dir.glob
+        tmp_long_file = tmpfile('foo.bar', tmpdir('super-long-thing-that-Windows-shortens'))
+        Puppet::FileSystem.touch(tmp_long_file)
+        expanded_path = Puppet::FileSystem.expand_path(tmp_long_file)
+
+        expect(expanded_path).to eq(Dir.glob(expanded_path).first)
+      end
+
+      describe 'on non-Windows', :unless => Puppet::Util::Platform.windows? do
+        it 'should produce the same results as the Ruby File.expand_path' do
+          # on Windows this may be 8.3 style, but not so on other platforms
+          # only done since ::File.expects(:expand_path).with(path).at_least_once
+          # cannot be used since it will cause a stack overflow
+          path = tmpdir('foobar')
+
+          expect(Puppet::FileSystem.expand_path(path)).to eq(File.expand_path(path))
+        end
+      end
+
+      describe 'on Windows', :if => Puppet::Util::Platform.windows? do
+        let(:nonexist_file) { 'C:\\file~1.ext' }
+        let(:nonexist_path) { 'C:\\progra~1\\missing\\path\\file.ext' }
+
+        ['/', '\\'].each do |slash|
+          it "should return the absolute path including system drive letter when given #{slash}, like Ruby File.expand_path" do
+
+            # regardless of slash direction, return value is drive letter
+            expanded = Puppet::FileSystem.expand_path(slash)
+            expect(expanded).to eq(ENV['SystemDrive'] + File::SEPARATOR)
+            expect(expanded).to eq(File.expand_path(slash))
+          end
+        end
+
+        it 'should behave like Rubys File.expand_path for a file that doesnt exist' do
+          expect(Puppet::FileSystem.exist?(nonexist_file)).to be_falsey
+          # this will change c:\\file~1.ext to c:/file~1.ext (existing Ruby behavior), but not expand any ~
+          ruby_expanded = File.expand_path(nonexist_file)
+          expect(ruby_expanded).to match(/~/)
+          expect(Puppet::FileSystem.expand_path(nonexist_file)).to eq(ruby_expanded)
+        end
+
+        it 'should behave like Rubys File.expand_path for a file with a parent path that doesnt exist' do
+          expect(Puppet::FileSystem.exist?(nonexist_path)).to be_falsey
+          # this will change c:\\progra~1 to c:/progra~1 (existing Ruby behavior), but not expand any ~
+          ruby_expanded = File.expand_path(nonexist_path)
+          expect(ruby_expanded).to match(/~/)
+          expect(Puppet::FileSystem.expand_path(nonexist_path)).to eq(ruby_expanded)
+        end
+
+        it 'should expand a shortened path completely, unlike Ruby File.expand_path' do
+          tmp_long_dir = tmpdir('super-long-thing-that-Windows-shortens')
+          short_path = Puppet::Util::Windows::File.get_short_pathname(tmp_long_dir)
+
+          # a shortened path to the temp dir will have a least 2 ~
+          # for instance, C:\\Users\\Administrator\\AppData\\Local\\Temp\\rspecrun2016####-####-#######\\super-long-thing-that-Windows-shortens\
+          # or C:\\Windows\\Temp\\rspecrun2016####-####-#######\\super-long-thing-that-Windows-shortens\
+          # will shorten to Temp\\rspecr~#\\super-~1
+          expect(short_path).to match(/~.*~/)
+
+          # expand with Ruby, noting not all ~ have been expanded
+          # which is the primary reason that a Puppet helper exists
+          ruby_expanded = File.expand_path(short_path)
+          expect(ruby_expanded).to match(/~/)
+
+          # Puppet expansion uses the Windows API and has no ~ remaining
+          puppet_expanded = Puppet::FileSystem.expand_path(short_path)
+          expect(puppet_expanded).to_not match(/~/)
+
+          # and the directories are one and the same
+          expect(File.identical?(short_path, puppet_expanded)).to be_truthy
+        end
+      end
+    end
   end
 end

data/spec/unit/functions/lookup_spec.rb

@@ -558,7 +558,7 @@ EOS
     it 'will explain deep merge results without options' do
       assemble_and_compile('${r}', "'abc::a'") do |scope|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
-        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.new.parse('Hash[String,String]'), nil, false, 'deep', lookup_invocation)
+        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.singleton.parse('Hash[String,String]'), nil, false, 'deep', lookup_invocation)
         expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
 Merge strategy deep
   Data Binding "hiera"
@@ -586,7 +586,7 @@ EOS
       assemble_and_compile('${r}', "'abc::a'") do |scope|
         Hiera.any_instance.expects(:lookup).with(any_parameters).returns({'k1' => 'global_g1'})
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
-        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.new.parse('Hash[String,String]'), nil, false, {'strategy' => 'deep', 'merge_hash_arrays' => true}, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.singleton.parse('Hash[String,String]'), nil, false, {'strategy' => 'deep', 'merge_hash_arrays' => true}, lookup_invocation)
         expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
 Merge strategy deep
   Options: {
@@ -645,7 +645,7 @@ EOS
     it 'will explain value access caused by dot notation in key' do
       assemble_and_compile('${r}', "'abc::a'") do |scope|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
-        Puppet::Pops::Lookup.lookup('abc::f.k1.s1', Puppet::Pops::Types::TypeParser.new.parse('String'), nil, false, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('abc::f.k1.s1', Puppet::Pops::Types::TypeParser.singleton.parse('String'), nil, false, nil, lookup_invocation)
         expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
 Merge strategy first
   Data Binding "hiera"
@@ -667,7 +667,7 @@ EOS
     it 'will provide a hash containing all explanation elements' do
       assemble_and_compile('${r}', "'abc::a'") do |scope|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
-        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.new.parse('Hash[String,String]'), nil, false, {'strategy' => 'deep', 'merge_hash_arrays' => true}, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.singleton.parse('Hash[String,String]'), nil, false, {'strategy' => 'deep', 'merge_hash_arrays' => true}, lookup_invocation)
         expect(lookup_invocation.explainer.to_hash).to eq(
             {
               :branches => [

data/spec/unit/functions/match_spec.rb

@@ -18,7 +18,7 @@ describe 'the match function' do
     Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'match')
   end
 
-  let(:type_parser) { Puppet::Pops::Types::TypeParser.new }
+  let(:type_parser) { Puppet::Pops::Types::TypeParser.singleton }
 
 
   it 'matches string and regular expression without captures' do
@@ -52,6 +52,6 @@ describe 'the match function' do
   end
 
   def type(s)
-    Puppet::Pops::Types::TypeParser.new.parse(s) 
+    Puppet::Pops::Types::TypeParser.singleton.parse(s)
   end
 end

data/spec/unit/functions/regsubst_spec.rb

@@ -18,7 +18,7 @@ describe 'the regsubst function' do
     Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'regsubst').call({}, *args)
   end
 
-  let(:type_parser) { Puppet::Pops::Types::TypeParser.new }
+  let(:type_parser) { Puppet::Pops::Types::TypeParser.singleton }
 
   context 'when using a string pattern' do
     it 'should raise an Error if there is less than 3 arguments' do

data/spec/unit/functions/split_spec.rb

@@ -18,7 +18,7 @@ describe 'the split function' do
     Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'split').call({}, *args)
   end
 
-  let(:type_parser) { Puppet::Pops::Types::TypeParser.new }
+  let(:type_parser) { Puppet::Pops::Types::TypeParser.singleton }
 
   it 'should raise an Error if there is less than 2 arguments' do
     expect { split('a,b') }.to raise_error(/'split' expects 2 arguments, got 1/)

data/spec/unit/functions/unwrap_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the unwrap function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'unwraps a sensitive value' do
+    code = <<-CODE
+      $sensitive = Sensitive.new("12345")
+      notice("unwrapped value is ${sensitive.unwrap}")
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['unwrapped value is 12345'])
+  end
+
+  it 'unwraps a sensitive value when given a code block' do
+    code = <<-CODE
+      $sensitive = Sensitive.new("12345")
+      $split = $sensitive.unwrap |$unwrapped| {
+        notice("unwrapped value is $unwrapped")
+        $unwrapped.split(/3/)
+      }
+      notice("split is $split")
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['unwrapped value is 12345', 'split is [12, 45]'])
+  end
+end

data/spec/unit/functions/versioncmp_spec.rb

@@ -18,7 +18,7 @@ describe "the versioncmp function" do
     Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'versioncmp').call({}, *args)
   end
 
-  let(:type_parser) { Puppet::Pops::Types::TypeParser.new }
+  let(:type_parser) { Puppet::Pops::Types::TypeParser.singleton }
 
   it 'should raise an Error if there is less than 2 arguments' do
     expect { versioncmp('a,b') }.to raise_error(/expects 2 arguments, got 1/)

data/spec/unit/functions4_spec.rb

@@ -14,11 +14,11 @@ module FunctionAPISpecModule
     end
 
     def add_function(name, function)
-      set_entry(Puppet::Pops::Loader::Loader::TypedName.new(:function, name), function, __FILE__)
+      set_entry(Puppet::Pops::Loader::TypedName.new(:function, name), function, __FILE__)
     end
 
     def add_type(name, type)
-      set_entry(Puppet::Pops::Loader::Loader::TypedName.new(:type, name), type, __FILE__)
+      set_entry(Puppet::Pops::Loader::TypedName.new(:type, name), type, __FILE__)
     end
 
     def set_entry(typed_name, value, origin = nil)
@@ -467,7 +467,7 @@ describe 'the 4x function api' do
         # evaluate a puppet call
         source = "testing::test(10) |$x| { $x+1 }"
         program = parser.parse_string(source, __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate(scope, program)).to eql(11)
       end
     end
@@ -491,7 +491,7 @@ describe 'the 4x function api' do
         CODE
         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
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eql(10)
       end
 
@@ -510,7 +510,7 @@ describe 'the 4x function api' do
         CODE
         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
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error, /parameter 'x' references an unresolved type 'MyAlias'/)
       end
 
@@ -532,7 +532,7 @@ describe 'the 4x function api' do
         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
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq([10,20])
       end
 
@@ -555,7 +555,7 @@ describe 'the 4x function api' do
         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
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq({'x' => [10,20]})
       end
 
@@ -577,7 +577,7 @@ describe 'the 4x function api' do
         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
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq({'x' => {'y' => 'n'}})
       end
     end

data/spec/unit/indirector/facts/facter_spec.rb

@@ -60,14 +60,6 @@ describe Puppet::Node::Facts::Facter do
       @facter.find(@request)
     end
 
-    it 'should not include external facts when feature is not present' do
-      reset = sequence 'reset'
-      Puppet.features.stubs(:external_facts?).returns false
-      Facter.expects(:reset).in_sequence(reset)
-      Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
-      @facter.find(@request)
-    end
-
     it "should return a Facts instance" do
       expect(@facter.find(@request)).to be_instance_of(Puppet::Node::Facts)
     end
@@ -140,7 +132,7 @@ describe Puppet::Node::Facts::Facter do
     end
   end
 
-  describe 'when setting up external search paths', :if => Puppet.features.external_facts? do
+  describe 'when setting up external search paths' do
     let(:pluginfactdest) { File.expand_path 'plugin/dest' }
     let(:modulepath) { File.expand_path 'module/foo' }
     let(:modulefactsd) { File.expand_path 'module/foo/facts.d'  }

data/spec/unit/indirector/rest_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'json'
 require 'puppet/indirector'
 require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
@@ -12,15 +13,34 @@ shared_examples_for "a REST terminus method" do |terminus_method|
 
   HTTP_ERROR_CODES.each do |code|
     describe "when the response code is #{code}" do
-      let(:response) { mock_response(code, 'error messaged!!!') }
+      let(:message) { 'error messaged!!!' }
+      let(:body) do
+        JSON.generate({
+          :issue_kind => 'server-error',
+          :message    => message,
+          :stacktrace => ['worst/stack/trace/ever.rb:4']
+        })
+      end
+      let(:response) { mock_response(code, body, 'application/json') }
+
+      describe "when the response is plain text" do
+        let(:response) { mock_response(code, message) }
+
+        it "raises an http error with the body of the response when plain text" do
+
+          expect {
+            terminus.send(terminus_method, request)
+          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
+        end
+      end
 
-      it "raises an http error with the body of the response" do
+      it "raises an http error with the body's message field when json" do
         expect {
           terminus.send(terminus_method, request)
-        }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{response.body}")
+        }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
       end
 
-      it "does not attempt to deserialize the response" do
+      it "does not attempt to deserialize the response into a model" do
         model.expects(:convert_from).never
 
         expect {
@@ -40,15 +60,14 @@ shared_examples_for "a REST terminus method" do |terminus_method|
 
       describe "and the body is compressed" do
         it "raises an http error with the decompressed body of the response" do
-          uncompressed_body = "why"
-          compressed_body = Zlib::Deflate.deflate(uncompressed_body)
+          compressed_body = Zlib::Deflate.deflate(body)
 
-          response = mock_response(code, compressed_body, 'text/plain', 'deflate')
-          connection.expects(http_method).returns(response)
+          compressed_response = mock_response(code, compressed_body, 'application/json', 'deflate')
+          connection.expects(http_method).returns(compressed_response)
 
           expect {
             terminus.send(terminus_method, request)
-          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{uncompressed_body}")
+          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
         end
       end
     end
@@ -186,6 +205,73 @@ describe Puppet::Indirector::REST do
     expect(terminus_class.port).to eq(543)
   end
 
+  it "should use a failover-selected server if set" do
+    terminus_class.expects(:server_setting).returns nil
+    Puppet.override(:server => "myserver") do
+      expect(terminus_class.server).to eq("myserver")
+    end
+  end
+
+  it "should use a failover-selected port if set" do
+    terminus_class.expects(:port_setting).returns nil
+    Puppet.override(:serverport => 321) do
+      expect(terminus_class.port).to eq(321)
+    end
+  end
+
+  it "should use server_list for server when available" do
+    terminus_class.expects(:server_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"]]
+    expect(terminus_class.server).to eq("foo")
+  end
+
+  it "should prefer failover-selected server from server list" do
+    terminus_class.expects(:server_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
+    Puppet.override(:server => "bar") do
+      expect(terminus_class.server).to eq("bar")
+    end
+  end
+
+  it "should use server_list for port when available" do
+    terminus_class.expects(:port_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"]]
+    expect(terminus_class.port).to eq(123)
+  end
+
+  it "should prefer failover-selected port from server list" do
+    terminus_class.expects(:port_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
+    Puppet.override(:serverport => "321") do
+      expect(terminus_class.port).to eq(321)
+    end
+  end
+
+  it "should use an explicitly specified more-speciic server when failover is active" do
+    terminus_class.expects(:server_setting).returns :ca_server
+    Puppet[:ca_server] = "myserver"
+    Puppet.override(:server => "anotherserver") do
+      expect(terminus_class.server).to eq("myserver")
+    end
+  end
+
+  it "should use an explicitly specified more-specific port when failover is active" do
+    terminus_class.expects(:port_setting).returns :ca_port
+    Puppet[:ca_port] = 321
+    Puppet.override(:serverport => 543) do
+      expect(terminus_class.port).to eq(321)
+    end
+  end
+
+  it "should use a default port when a more-specific server is set" do
+    terminus_class.expects(:server_setting).returns :ca_server
+    terminus_class.expects(:port_setting).returns :ca_port
+    Puppet[:ca_server] = "myserver"
+    Puppet.override(:server => "anotherserver", :port => 666) do
+      expect(terminus_class.port).to eq(8140)
+    end
+  end
+
   it 'should default to :puppet for the srv_service' do
     expect(Puppet::Indirector::REST.srv_service).to eq(:puppet)
   end