puppet 7.7.0-universal-darwin → 7.11.0-universal-darwin

data/spec/unit/functions/empty_spec.rb

@@ -56,6 +56,16 @@ describe 'the empty function' do
     end
   end
 
+  context 'for a sensitive string it' do
+    it 'returns true when empty' do
+      expect(compile_to_catalog("notify { String(empty(Sensitive(''))): }")).to have_resource('Notify[true]')
+    end
+
+    it 'returns false when not empty' do
+      expect(compile_to_catalog("notify { String(empty(Sensitive(' '))): }")).to have_resource('Notify[false]')
+    end
+  end
+
   context 'for a binary it' do
     it 'returns true when empty' do
       expect(compile_to_catalog("notify { String(empty(Binary(''))): }")).to have_resource('Notify[true]')

data/spec/unit/functions/logging_spec.rb

@@ -6,6 +6,7 @@ describe 'the log function' do
 
   def collect_logs(code)
     Puppet[:code] = code
+    Puppet[:environment_timeout] = 10
     node = Puppet::Node.new('logtest')
     compiler = Puppet::Parser::Compiler.new(node)
     node.environment.check_for_reparse

data/spec/unit/functions/lookup_spec.rb

@@ -870,6 +870,46 @@ describe "The lookup function" do
       end
     end
 
+    context 'with lookup_options' do
+      let(:environment_files) do
+        {
+          env_name => {
+            'hiera.yaml' => <<-YAML.unindent,
+              ---
+              version: 5
+              YAML
+            'data' => {
+              'common.yaml' => common_yaml
+            }
+          }
+        }
+      end
+
+      context 'that are empty' do
+        let(:common_yaml) { <<-YAML.unindent }
+          lookup_options:
+          a: b
+          YAML
+
+        it 'ignores empty options' do
+          expect(lookup('a')).to eq("b")
+        end
+      end
+
+      context 'that contains a legal yaml hash with unexpected types' do
+        let(:common_yaml) { <<-YAML.unindent }
+          lookup_options:
+            :invalid_symbol
+          YAML
+
+        it 'fails lookup and reports a type mismatch' do
+          expect {
+            lookup('a')
+          }.to raise_error(Puppet::DataBinding::LookupError, /has wrong type, expects Puppet::LookupValue, got Runtime\[ruby, 'Symbol'\]/)
+        end
+      end
+    end
+
     context 'with lookup_options configured using patterns' do
       let(:mod_common) {
         <<-YAML.unindent
@@ -1019,6 +1059,30 @@ describe "The lookup function" do
         })
       end
 
+      context 'and lookup_options is empty' do
+        let(:mod_common) { <<-YAML.unindent }
+          lookup_options:
+          mod::a: b
+          YAML
+
+        it 'ignores empty options' do
+          expect(lookup('mod::a')).to eq("b")
+        end
+      end
+
+      context 'and lookup_options contains a legal hash with unexpected types' do
+        let(:mod_common) { <<-YAML.unindent }
+          lookup_options:
+            :invalid_symbol
+          YAML
+
+        it 'fails lookup and reports a type mismatch' do
+          expect {
+            lookup('mod::a')
+          }.to raise_error(Puppet::DataBinding::LookupError, /has wrong type, expects Puppet::LookupValue, got Runtime\[ruby, 'Symbol'\]/)
+        end
+      end
+
       context 'and patterns in module are not limited to module keys' do
         let(:mod_common) {
           <<-YAML.unindent
@@ -3303,6 +3367,29 @@ describe "The lookup function" do
           end
         end
 
+        context 'using options containing intepolated paths to the key pair' do
+          let(:scope_additions) { { 'priv_path' => private_key_path, 'pub_path' => public_key_path } }
+
+          let(:hiera_yaml) do
+            <<-YAML.unindent
+          version: 5
+          defaults:
+            datadir: #{code_dir}/hieradata
+          hierarchy:
+            - name: "secret data"
+              lookup_key: eyaml_lookup_key
+              path: common.eyaml
+              options:
+                pkcs7_private_key: "%{priv_path}"
+                pkcs7_public_key: "%{pub_path}"
+            YAML
+          end
+
+          it 'finds data in the global layer' do
+            expect(lookup('a')).to eql("Encrypted value 'a' (from global)")
+          end
+        end
+
         context 'with special extension declared in options' do
           let(:environment_files) { {} }
           let(:hiera_yaml) do

data/spec/unit/functions/unwrap_spec.rb

@@ -15,6 +15,14 @@ describe 'the unwrap function' do
     expect(eval_and_collect_notices(code)).to eq(['unwrapped value is 12345'])
   end
 
+  it 'just returns a non-sensitive value' do
+    code = <<-CODE
+      $non_sensitive = "12345"
+      notice("value is still ${non_sensitive.unwrap}")
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['value is still 12345'])
+  end
+
   it 'unwraps a sensitive value when given a code block' do
     code = <<-CODE
       $sensitive = Sensitive.new("12345")

data/spec/unit/functions4_spec.rb

@@ -39,6 +39,15 @@ describe 'the 4x function api' do
 
   let(:loader) { FunctionAPISpecModule::TestFunctionLoader.new }
 
+  def parse_eval(code, here)
+    if here.respond_to?(:source_location)
+      eval(code, here, here.source_location[0], here.source_location[1])
+    else
+      # this can be removed when ruby < 2.6 is dropped
+      eval(code, here)
+    end
+  end
+
   it 'allows a simple function to be created without dispatch declaration' do
     f = Puppet::Functions.create_function('min') do
       def min(x,y)
@@ -160,7 +169,7 @@ describe 'the 4x function api' do
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
         func.call({}, 3, 10, 3, "4")
-      end.to raise_error(ArgumentError, "'min' expects one of:
+      end.to raise_error(ArgumentError, "The function 'min' was called with arguments it does not accept. It expects one of:
   (Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c*)
     rejected: parameter 'b' expects a Numeric value, got String
   (String x, String y, String a+)
@@ -231,7 +240,7 @@ describe 'the 4x function api' do
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
         func.call({}, 10, '20')
-      end.to raise_error(ArgumentError, "'min' expects one of:
+      end.to raise_error(ArgumentError, "The function 'min' was called with arguments it does not accept. It expects one of:
   (Numeric a, Numeric b)
     rejected: parameter 'b' expects a Numeric value, got String
   (String s1, String s2)
@@ -484,7 +493,7 @@ describe 'the 4x function api' do
         the_loader = loader()
         here = get_binding(the_loader)
         expect do
-          eval(<<-CODE, here)
+          parse_eval(<<-CODE, here)
             Puppet::Functions.create_function('testing::test') do
               local_types do
                 type 'MyType += Array[Integer]'
@@ -505,7 +514,7 @@ describe 'the 4x function api' do
         the_loader = loader()
         here = get_binding(the_loader)
         expect do
-          eval(<<-CODE, here)
+          parse_eval(<<-CODE, here)
             Puppet::Functions.create_function('testing::test') do
               dispatch :test do
                 param 'Array[1+=1]', :x
@@ -525,7 +534,7 @@ describe 'the 4x function api' do
       it 'uses return_type to validate returned value' do
         the_loader = loader()
         here = get_binding(the_loader)
-        fc = eval(<<-CODE, here)
+        fc = parse_eval(<<-CODE, here)
           Puppet::Functions.create_function('testing::test') do
             dispatch :test do
               param 'Integer', :x
@@ -547,7 +556,7 @@ describe 'the 4x function api' do
         the_loader = loader()
         the_loader.add_type('myalias', type_alias_t('MyAlias', 'Integer'))
         here = get_binding(the_loader)
-        fc = eval(<<-CODE, here)
+        fc = parse_eval(<<-CODE, here)
           Puppet::Functions.create_function('testing::test') do
             dispatch :test do
               param 'MyAlias', :x
@@ -567,7 +576,7 @@ describe 'the 4x function api' do
       it 'reports a reference to an unresolved type' do
         the_loader = loader()
         here = get_binding(the_loader)
-        fc = eval(<<-CODE, here)
+        fc = parse_eval(<<-CODE, here)
           Puppet::Functions.create_function('testing::test') do
             dispatch :test do
               param 'MyAlias', :x
@@ -586,7 +595,7 @@ describe 'the 4x function api' do
       it 'create local Type aliases' do
         the_loader = loader()
         here = get_binding(the_loader)
-        fc = eval(<<-CODE, here)
+        fc = parse_eval(<<-CODE, here)
           Puppet::Functions.create_function('testing::test') do
             local_types do
               type 'MyType = Array[Integer]'
@@ -608,7 +617,7 @@ describe 'the 4x function api' do
       it 'create nested local Type aliases' do
         the_loader = loader()
         here = get_binding(the_loader)
-        fc = eval(<<-CODE, here)
+        fc = parse_eval(<<-CODE, here)
           Puppet::Functions.create_function('testing::test') do
             local_types do
               type 'InnerType = Array[Integer]'
@@ -631,7 +640,7 @@ describe 'the 4x function api' do
       it 'create self referencing local Type aliases' do
         the_loader = loader()
         here = get_binding(the_loader)
-        fc = eval(<<-CODE, here)
+        fc = parse_eval(<<-CODE, here)
           Puppet::Functions.create_function('testing::test') do
             local_types do
               type 'Tree = Hash[String,Variant[String,Tree]]'

data/spec/unit/http/service/compiler_spec.rb

@@ -95,6 +95,14 @@ describe Puppet::HTTP::Service::Compiler do
       subject.post_catalog(certname, environment: 'production', facts: facts, configured_environment: 'agent_specified')
     end
 
+    it 'includes check_environment' do
+      stub_request(:post, uri)
+        .with(body: hash_including('check_environment' => 'false'))
+        .to_return(**catalog_response)
+
+      subject.post_catalog(certname, environment: 'production', facts: facts)
+    end
+
     it 'includes transaction_uuid' do
       uuid = "ec3d2844-b236-4287-b0ad-632fbb4d1ff0"
 

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -11,6 +11,9 @@ def set_facts(fact_hash)
 end
 
 describe Puppet::Resource::Catalog::Compiler do
+  include Matchers::Resource
+  include PuppetSpec::Files
+
   let(:compiler) { described_class.new }
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
@@ -236,6 +239,46 @@ describe Puppet::Resource::Catalog::Compiler do
       expect { compiler.find(@request) }.to raise_error Puppet::Error,
         "Unable to find a common checksum type between agent '' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
     end
+
+    it "prevents the environment from being evicted during compilation" do
+      Puppet[:environment_timeout] = 0
+
+      envs = Puppet.lookup(:environments)
+
+      expect(compiler).to receive(:compile) do
+        # we should get the same object
+        expect(envs.get!(:production)).to equal(envs.get!(:production))
+      end
+
+      compiler.find(@request)
+    end
+
+    context 'when checking agent and server specified environments' do
+      before :each do
+        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_server'))
+        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_agent'))
+
+        node.environment = 'env_server'
+        allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+
+        @request.environment = 'env_agent'
+      end
+
+      it 'ignores mismatched environments by default' do
+        catalog = compiler.find(@request)
+
+        expect(catalog.environment).to eq('env_server')
+        expect(catalog).to have_resource('Stage[main]')
+      end
+
+      it 'returns an empty catalog if asked to check the environment and they are mismatched' do
+        @request.options[:check_environment] = "true"
+        catalog = compiler.find(@request)
+
+        expect(catalog.environment).to eq('env_server')
+        expect(catalog.resources).to be_empty
+      end
+    end
   end
 
   describe "when handling a request with facts" do
@@ -564,6 +607,50 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata
     end
 
+    describe "and the environment is a symlink and versioned_environment_dirs is true" do
+
+      let(:tmpdir) { Dir.mktmpdir }
+
+      before(:each) do
+        Puppet[:versioned_environment_dirs] = true
+        prod_path = File.join(Puppet[:environmentpath], 'production')
+        FileUtils.rm_rf(prod_path)
+        FileUtils.symlink(tmpdir, prod_path)
+      end
+
+      it "inlines metadata for a file" do
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+        file { '#{path}':
+          ensure => file,
+          source => '#{source}'
+        }
+      MANIFEST
+
+        module_relative_path = 'modules/mymodule/files/config_file.txt'
+        metadata = stubs_file_metadata(checksum_type,
+                                       checksum_value,
+                                       module_relative_path,
+                                       File.join(tmpdir, module_relative_path) )
+        expect(metadata).to receive(:source=).with(source)
+        expect(metadata).to receive(:content_uri=).with("puppet:///#{module_relative_path}")
+
+        options = {
+          :environment => catalog.environment_instance,
+          :links => :manage,
+          :checksum_type => checksum_type.to_sym,
+          :source_permissions => :ignore
+        }
+        expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
+
+        compiler.send(:inline_metadata, catalog, checksum_type)
+
+
+        expect(catalog.metadata[path]).to eq(metadata)
+        expect(catalog.recursive_metadata).to be_empty
+
+      end
+    end
+
     it "inlines metadata for a file" do
       catalog = compile_to_catalog(<<-MANIFEST, node)
         file { '#{path}':

data/spec/unit/indirector/catalog/rest_spec.rb

@@ -33,6 +33,14 @@ describe Puppet::Resource::Catalog::Rest do
     described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
   end
 
+  it "passes 'check_environment'" do
+    stub_request(:post, uri)
+      .with(body: hash_including('check_environment' => 'true'))
+      .to_return(**catalog_response(catalog))
+
+    described_class.indirection.find(certname, check_environment: true)
+  end
+
   it 'constructs a catalog environment_instance' do
     env = Puppet::Node::Environment.remote('outerspace')
     catalog = Puppet::Resource::Catalog.new(certname, env)

data/spec/unit/indirector/indirection_spec.rb

@@ -499,7 +499,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should return the result of saving to the terminus" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -509,7 +509,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should use a request to save the object to the cache" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -519,7 +519,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should not save to the cache if the normal save fails" do
-          request = double('request', :instance => @instance, :node => nil)
+          request = double('request', :instance => @instance, :node => nil, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -534,6 +534,13 @@ describe Puppet::Indirector::Indirection do
 
           @indirection.save(@instance, '/my/key', :ignore_cache_save => true)
         end
+
+        it "should only save to the cache if the request specifies not to use the terminus" do
+          expect(@terminus).not_to receive(:save)
+          expect(@cache).to receive(:save)
+
+          @indirection.save(@instance, "/my/key", :ignore_terminus => true)
+        end
       end
     end
 

data/spec/unit/indirector/resource/ral_spec.rb

@@ -1,120 +1,85 @@
 require 'spec_helper'
 require 'puppet/indirector/resource/ral'
 
-describe "Puppet::Resource::Ral" do
+describe Puppet::Resource::Ral do
+  let(:my_instance) { Puppet::Type.type(:user).new(:name => "root") }
+  let(:wrong_instance) { Puppet::Type.type(:user).new(:name => "bob")}
+
+  def stub_retrieve(*instances)
+    instances.each do |i|
+      allow(i).to receive(:retrieve).and_return(Puppet::Resource.new(i, nil))
+    end
+  end
+
+  before do
+    described_class.indirection.terminus_class = :ral
+
+    # make sure we don't try to retrieve current state
+    allow_any_instance_of(Puppet::Type.type(:user)).to receive(:retrieve).never
+    stub_retrieve(my_instance, wrong_instance)
+  end
+
   it "disallows remote requests" do
     expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(false)
   end
 
   describe "find" do
-    before do
-      @request = double('request', :key => "user/root")
-    end
-
     it "should find an existing instance" do
-      my_resource    = double("my user resource")
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
 
-      wrong_instance = double("wrong user", :name => "bob")
-      my_instance    = double("my user",    :name => "root", :to_resource => my_resource)
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
-      expect(Puppet::Resource::Ral.new.find(@request)).to eq(my_resource)
+      actual_resource = described_class.indirection.find('user/root')
+      expect(actual_resource.name).to eq('User/root')
     end
 
     it "should produce Puppet::Error instead of ArgumentError" do
-      @bad_request = double('thiswillcauseanerror', :key => "thiswill/causeanerror")
-      expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
+      expect{described_class.indirection.find('thiswill/causeanerror')}.to raise_error(Puppet::Error)
     end
 
     it "if there is no instance, it should create one" do
-      wrong_instance = double("wrong user", :name => "bob")
-      root = double("Root User")
-      root_resource = double("Root Resource")
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, wrong_instance ])
-      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: "root")).and_return(root)
-      expect(root).to receive(:to_resource).and_return(root_resource)
-
-      result = Puppet::Resource::Ral.new.find(@request)
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([wrong_instance])
 
-      expect(result).to eq(root_resource)
+      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: "root")).and_return(my_instance)
+      expect(described_class.indirection.find('user/root')).to be
     end
   end
 
   describe "search" do
-    before do
-      @request = double('request', :key => "user/", :options => {})
-    end
-
     it "should convert ral resources into regular resources" do
-      my_resource = double("my user resource", :title => "my user resource")
-      my_instance = double("my user", :name => "root", :to_resource => my_resource)
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
 
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
+      actual = described_class.indirection.search('user')
+      expect(actual).to contain_exactly(an_instance_of(Puppet::Resource))
     end
 
     it "should filter results by name if there's a name in the key" do
-      my_resource = double("my user resource", title: "my user resource")
-      allow(my_resource).to receive(:to_resource).and_return(my_resource)
-      allow(my_resource).to receive(:[]).with(:name).and_return("root")
-
-      wrong_resource = double("wrong resource")
-      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
-      allow(wrong_resource).to receive(:[]).with(:name).and_return("bad")
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
 
-      my_instance    = double("my user",    :to_resource => my_resource)
-      wrong_instance = double("wrong user", :to_resource => wrong_resource)
-
-      @request = double('request', :key => "user/root", :options => {})
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
+      actual = described_class.indirection.search('user/root')
+      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/root'))
     end
 
     it "should filter results by query parameters" do
-      wrong_resource = double("my user resource", title: "my user resource")
-      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
-      allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
-
-      my_resource = double("wrong resource", title: "wrong resource")
-      allow(my_resource).to receive(:to_resource).and_return(my_resource)
-      allow(my_resource).to receive(:[]).with(:name).and_return("bob")
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
 
-      my_instance    = double("my user",    :to_resource => my_resource)
-      wrong_instance = double("wrong user", :to_resource => wrong_resource)
-
-      @request = double('request', :key => "user/", :options => {:name => "bob"})
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
+      actual = described_class.indirection.search('user', name: 'bob')
+      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/bob'))
     end
 
     it "should return sorted results" do
-      a_resource = double("alice resource")
-      allow(a_resource).to receive(:to_resource).and_return(a_resource)
-      allow(a_resource).to receive(:title).and_return("alice")
-
-      b_resource = double("bob resource")
-      allow(b_resource).to receive(:to_resource).and_return(b_resource)
-      allow(b_resource).to receive(:title).and_return("bob")
-
-      a_instance = double("alice user", :to_resource => a_resource)
-      b_instance = double("bob user",   :to_resource => b_resource)
-
-      @request = double('request', :key => "user/", :options => {})
+      a_instance = Puppet::Type.type(:user).new(:name => "alice")
+      b_instance = Puppet::Type.type(:user).new(:name => "bob")
+      stub_retrieve(a_instance, b_instance)
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ b_instance, a_instance ])
 
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ b_instance, a_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([a_resource, b_resource])
+      expect(described_class.indirection.search('user').map(&:title)).to eq(['alice', 'bob'])
     end
   end
 
   describe "save" do
     it "returns a report covering the application of the given resource to the system" do
       resource = Puppet::Resource.new(:notify, "the title")
-      ral = Puppet::Resource::Ral.new
 
-      applied_resource, report = ral.save(Puppet::Indirector::Request.new(:ral, :save, 'testing', resource, :environment => Puppet::Node::Environment.remote(:testing)))
+      applied_resource, report = described_class.indirection.save(resource, nil, environment: Puppet::Node::Environment.remote(:testing))
 
       expect(applied_resource.title).to eq("the title")
       expect(report.environment).to eq("testing")