puppet 6.0.4 → 6.0.5

data/spec/integration/util/windows/registry_spec.rb

@@ -253,5 +253,44 @@ describe Puppet::Util::Windows::Registry do
       end
     end
   end
+
+  context "#values_by_name" do
+    let(:hkey)   { stub 'hklm' }
+    let(:subkey) { stub 'subkey' }
+
+    before :each do
+      subject.stubs(:root).returns(hkey)
+    end
+
+    context "when reading values" do
+      let (:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
+      let (:puppet_key) { "SOFTWARE\\Puppet Labs"}
+      let (:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
+
+      before(:each) do
+        hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg|
+          reg.write('valuename1', Win32::Registry::REG_SZ, 'value1')
+          reg.write('valuename2', Win32::Registry::REG_SZ, 'value2')
+        end
+      end
+
+      after(:each) do
+        hklm.open(puppet_key, Win32::Registry::KEY_ALL_ACCESS) do |reg|
+          subject.delete_key(reg, subkey_name)
+        end
+      end
+
+      it "should return only the values for the names specified" do
+        hklm.open("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg_key|
+          vals = subject.values_by_name(reg_key, ['valuename1', 'missingname'])
+
+          expect(vals).to have_key('valuename1')
+          expect(vals).to_not have_key('valuename2')
+          expect(vals['valuename1']).to eq('value1')
+          expect(vals['missingname']).to be_nil
+        end
+      end
+    end
+  end
 end
 end

data/spec/unit/application/device_spec.rb

@@ -75,25 +75,25 @@ describe Puppet::Application::Device do
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
       Puppet[:onetime] = true
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(0)
-      @device.setup_host
+      @device.setup_host('device.example.com')
     end
 
     it "should use supplied waitforcert when --onetime is specified" do
       Puppet[:onetime] = true
       @device.handle_waitforcert(60)
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(60)
-      @device.setup_host
+      @device.setup_host('device.example.com')
     end
 
     it "should use a default value for waitforcert when --onetime and --waitforcert are not specified" do
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(120)
-      @device.setup_host
+      @device.setup_host('device.example.com')
     end
 
     it "should use the waitforcert setting when checking for a signed certificate" do
       Puppet[:waitforcert] = 10
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(10)
-      @device.setup_host
+      @device.setup_host('device.example.com')
     end
 
     it "should set the log destination with --logdest" do
@@ -271,14 +271,14 @@ describe Puppet::Application::Device do
 
     it "should create a new ssl host" do
       Puppet::SSL::Host.expects(:new).returns(@host)
-      @device.setup_host
+      @device.setup_host('device.example.com')
     end
 
     it "should wait for a certificate" do
       @device.options.stubs(:[]).with(:waitforcert).returns(123)
       @host.expects(:wait_for_cert).with(123)
 
-      @device.setup_host
+      @device.setup_host('device.example.com')
     end
   end
 
@@ -292,6 +292,7 @@ describe Puppet::Application::Device do
       @device.options.stubs(:[]).with(:facts).returns(false)
       @device.options.stubs(:[]).with(:resource).returns(false)
       @device.options.stubs(:[]).with(:to_yaml).returns(false)
+      @device.options.stubs(:[]).with(:libdir).returns(nil)
       @device.options.stubs(:[]).with(:client)
       @device.command_line.stubs(:args).returns([])
       Puppet::Util::NetworkDevice::Config.stubs(:devices).returns({})
@@ -497,7 +498,9 @@ describe Puppet::Application::Device do
         expect { @device.main }.to exit_with 1
       end
 
-      it "should print the device url scheme, host, and port" do
+      it "should retrieve plugins and print the device url scheme, host, and port" do
+        Puppet.stubs(:info)
+        Puppet.expects(:info).with "Retrieving pluginfacts"
         Puppet.expects(:info).with "starting applying configuration to device1 at ssh://testhost"
         Puppet.expects(:info).with "starting applying configuration to device2 at https://testhost:443/some/path"
         expect { @device.main }.to exit_with 1

data/spec/unit/application/lookup_spec.rb

@@ -13,7 +13,8 @@ describe Puppet::Application::Lookup do
     ensure
       $stdout = saved_stdout
     end
-    capture.string.strip
+    # Drop end of line and an optional yaml end of document
+    capture.string.gsub(/\n(\.\.\.\n)?\Z/m, '')
   end
 
   context "when running with incorrect command line options" do

data/spec/unit/application/ssl_spec.rb

@@ -5,6 +5,8 @@ require 'openssl'
 require 'puppet/test_ca'
 
 describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
+  include PuppetSpec::Files
+
   let(:ssl) do
     app = Puppet::Application[:ssl]
     app.options[:verbose] = true
@@ -25,6 +27,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
 
     Puppet.settings.use(:main)
     Puppet[:certname] = name
+    Puppet[:vardir] = tmpdir("ssl_testing")
 
     # Host assumes ca cert and crl are present
     File.open(Puppet[:localcacert], 'w') { |f| f.write(@ca_cert.to_pem) }
@@ -293,9 +296,10 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
     end
 
     it 'deletes the request' do
-      File.open(Puppet[:hostcsr], 'w') { |f| f.write(@host[:csr].to_pem) }
+      path = File.join(Puppet[:requestdir], "#{Puppet[:certname]}.pem")
+      File.open(path, 'w') { |f| f.write(@host[:csr].to_pem) }
 
-      expects_command_to_pass(%r{Removed certificate request #{Puppet[:hostcsr]}})
+      expects_command_to_pass(%r{Removed certificate request #{path}})
     end
 
     it 'deletes the passfile' do
@@ -368,5 +372,20 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
         expects_command_to_pass(%r{Removed certificate .*puppetserver.pem})
       end
     end
+
+    context 'when cleaning a device' do
+      before do
+        ssl.command_line.args = ['clean', '--target', 'device.example.com']
+        ssl.parse_options
+      end
+
+      it 'deletes the device certificate' do
+        device_cert_path = File.join(Puppet[:devicedir], 'device.example.com', 'ssl', 'certs')
+        device_cert_file = File.join(device_cert_path, 'device.example.com.pem')
+        FileUtils.mkdir_p(device_cert_path)
+        File.open(device_cert_file, 'w') { |f| f.write('device.example.com') }
+        expects_command_to_pass(%r{Removed certificate #{device_cert_file}})
+     end
+  end
   end
 end

data/spec/unit/forge/forge_spec.rb

@@ -59,10 +59,11 @@ describe Puppet::Forge do
       it "includes any defined module_groups, ensuring to only encode them once in the URI" do
         Puppet[:module_groups] = 'base+pe'
         module_name = 'puppetlabs-acl'
+        exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
 
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=#{module_name}&sort_by=version&module_groups=base%20pe"
+          encoded_uri = "/v3/releases?module=#{module_name}&sort_by=version&exclude_fields=#{exclusions}&module_groups=base%20pe"
           http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 
@@ -71,10 +72,11 @@ describe Puppet::Forge do
 
       it "single encodes the module name term in the URI" do
         module_name = "puppetlabs-#{mixed_utf8_query_param}"
+        exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
 
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version"
+          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version&exclude_fields=#{exclusions}"
           http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 

data/spec/unit/functions/logging_spec.rb

@@ -18,9 +18,16 @@ describe 'the log function' do
 
   def expect_log(code, log_level, message)
     logs = collect_logs(code)
-    expect(logs.size).to eql(1)
-    expect(logs[0].level).to eql(log_level)
-    expect(logs[0].message).to eql(message)
+
+    # There's a chance that additional messages could have been
+    # added during code compilation like debug messages from
+    # Facter. This happened on Appveyor when the Appveyor image
+    # failed to resolve the domain fact. Since these messages are
+    # not relevant to our test, and since they can (possibly) be
+    # injected at any location in our logs array, it is good enough
+    # to assert that our desired log _is_ included in the logs array
+    # instead of trying to figure out _where_ it is included.
+    expect(logs).to include(satisfy { |log| log.level == log_level && log.message == message })
   end
 
   before(:each) do

data/spec/unit/indirector/yaml_spec.rb

@@ -141,7 +141,7 @@ describe Puppet::Indirector::Yaml do
       dir_containing_instances([one, two])
 
       request = indirection.request(:search, "*", nil)
-      expect(terminus.search(request)).to eq([one, two])
+      expect(terminus.search(request)).to contain_exactly(one, two)
     end
 
     it "should return an array containing a single instance of fact when globbing 'one*'" do

data/spec/unit/pops/loaders/loader_spec.rb

@@ -447,8 +447,7 @@ describe 'The Loader' do
           end
 
           context 'with no explicit dependencies' do
-
-            let(:modules) {
+            let(:modules) do
               {
                 'a' => {
                   'functions' => a_functions,
@@ -468,12 +467,12 @@ describe 'The Loader' do
                   'types' => c_types,
                 },
               }
+            end
 
-              it 'discover is only called once on dependent loader' do
-                ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
-                expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
-              end
-            }
+            it 'discover is only called once on dependent loader' do
+              ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
+              expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
+            end
           end
         end
       end

data/spec/unit/pops/model/pn_transformer_spec.rb

@@ -42,6 +42,10 @@ describe 'Puppet::Pops::Model::PNTransformer' do
       expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(
         call('hash', call('=>', 'a', 1), call('=>', 'b', 2)))
     end
+
+    it 'replaces empty/nil body with a Nop' do
+      expect(Puppet::Pops::Model::PNTransformer.transform(nil)).to eq(call('nop'))
+    end
   end
 
   def lit(value)

data/spec/unit/pops/types/p_timespan_type_spec.rb

@@ -68,6 +68,28 @@ describe 'Timespan type' do
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true false))
       end
+
+      it 'accepts integer values when specifying the range' do
+        code = <<-CODE
+            notice(Timespan(1) =~ Timespan[1, 2])
+            notice(Timespan(3) =~ Timespan[1])
+            notice(Timespan(0) =~ Timespan[default, 2])
+            notice(Timespan(0) =~ Timespan[1, 2])
+            notice(Timespan(3) =~ Timespan[1, 2])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true false false))
+      end
+
+      it 'accepts float values when specifying the range' do
+        code = <<-CODE
+            notice(Timespan(1.0) =~ Timespan[1.0, 2.0])
+            notice(Timespan(3.0) =~ Timespan[1.0])
+            notice(Timespan(0.0) =~ Timespan[default, 2.0])
+            notice(Timespan(0.0) =~ Timespan[1.0, 2.0])
+            notice(Timespan(3.0) =~ Timespan[1.0, 2.0])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true false false))
+      end
     end
 
     context 'a Timespan instance' do

data/spec/unit/pops/types/p_timestamp_type_spec.rb

@@ -74,6 +74,25 @@ describe 'Timestamp type' do
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true false))
       end
+
+      it 'accepts integer values when specifying the range' do
+        code = <<-CODE
+            notice(Timestamp(1) =~ Timestamp[1, 2])
+            notice(Timestamp(3) =~ Timestamp[1])
+            notice(Timestamp(0) =~ Timestamp[default, 2])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+      end
+
+      it 'accepts float values when specifying the range' do
+        code = <<-CODE
+            notice(Timestamp(1.0) =~ Timestamp[1.0, 2.0])
+            notice(Timestamp(3.0) =~ Timestamp[1.0])
+            notice(Timestamp(0.0) =~ Timestamp[default, 2.0])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+      end
+
     end
 
     context 'a Timestamp instance' do

data/spec/unit/pops/types/string_converter_spec.rb

@@ -707,6 +707,15 @@ describe 'The string converter' do
      expect(formatted).to eq(result)
     end
 
+    it 'applies a short form format' do
+      result = [
+        "[1,",
+        "  [2, 3],",
+        "  4]"
+        ].join("\n")
+      expect(converter.convert([1, [2,3], 4], '%#a')).to eq(result)
+    end
+
     it 'treats hashes as nested arrays wrt indentation' do
       string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
@@ -855,6 +864,17 @@ describe 'The string converter' do
       expect(converter.convert({1 => "hello", 2 => {3=> "world"}}, string_formats)).to eq(result)
     end
 
+    it 'applies a short form format' do
+      result = [
+        "{",
+        "  1 => {",
+        "    2 => 3",
+        "  },",
+        "  4 => 5",
+        "}"].join("\n")
+      expect(converter.convert({1 => {2 => 3}, 4 => 5}, '%#h')).to eq(result)
+    end
+
     context "containing an array" do
       it 'the hash and array renders without breaks and indentation by default' do
         result = "{1 => [1, 2, 3]}"

data/spec/unit/provider/group/ldap_spec.rb

@@ -1,54 +1,51 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:group).provider(:ldap)
-
-describe provider_class do
+describe Puppet::Type.type(:group).provider(:ldap) do
   it "should have the Ldap provider class as its baseclass" do
-    expect(provider_class.superclass).to equal(Puppet::Provider::Ldap)
+    expect(described_class.superclass).to equal(Puppet::Provider::Ldap)
   end
 
   it "should manage :posixGroup objectclass" do
-    expect(provider_class.manager.objectclasses).to eq([:posixGroup])
+    expect(described_class.manager.objectclasses).to eq([:posixGroup])
   end
 
   it "should use 'ou=Groups' as its relative base" do
-    expect(provider_class.manager.location).to eq("ou=Groups")
+    expect(described_class.manager.location).to eq("ou=Groups")
   end
 
   it "should use :cn as its rdn" do
-    expect(provider_class.manager.rdn).to eq(:cn)
+    expect(described_class.manager.rdn).to eq(:cn)
   end
 
   it "should map :name to 'cn'" do
-    expect(provider_class.manager.ldap_name(:name)).to eq('cn')
+    expect(described_class.manager.ldap_name(:name)).to eq('cn')
   end
 
   it "should map :gid to 'gidNumber'" do
-    expect(provider_class.manager.ldap_name(:gid)).to eq('gidNumber')
+    expect(described_class.manager.ldap_name(:gid)).to eq('gidNumber')
   end
 
   it "should map :members to 'memberUid', to be used by the user ldap provider" do
-    expect(provider_class.manager.ldap_name(:members)).to eq('memberUid')
+    expect(described_class.manager.ldap_name(:members)).to eq('memberUid')
   end
 
   describe "when being created" do
     before do
       # So we don't try to actually talk to ldap
       @connection = mock 'connection'
-      provider_class.manager.stubs(:connect).yields @connection
+      described_class.manager.stubs(:connect).yields @connection
     end
 
     describe "with no gid specified" do
       it "should pick the first available GID after the largest existing GID" do
         low = {:name=>["luke"], :gid=>["600"]}
         high = {:name=>["testing"], :gid=>["640"]}
-        provider_class.manager.expects(:search).returns([low, high])
+        described_class.manager.expects(:search).returns([low, high])
 
         resource = stub 'resource', :should => %w{whatever}
         resource.stubs(:should).with(:gid).returns nil
         resource.stubs(:should).with(:ensure).returns :present
-        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance = described_class.new(:name => "luke", :ensure => :absent)
         instance.stubs(:resource).returns resource
 
         @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["641"] }
@@ -58,12 +55,12 @@ describe provider_class do
       end
 
       it "should pick '501' as its GID if no groups are found" do
-        provider_class.manager.expects(:search).returns nil
+        described_class.manager.expects(:search).returns nil
 
         resource = stub 'resource', :should => %w{whatever}
         resource.stubs(:should).with(:gid).returns nil
         resource.stubs(:should).with(:ensure).returns :present
-        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance = described_class.new(:name => "luke", :ensure => :absent)
         instance.stubs(:resource).returns resource
 
         @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["501"] }
@@ -75,27 +72,27 @@ describe provider_class do
   end
 
   it "should have a method for converting group names to GIDs" do
-    expect(provider_class).to respond_to(:name2id)
+    expect(described_class).to respond_to(:name2id)
   end
 
   describe "when converting from a group name to GID" do
     it "should use the ldap manager to look up the GID" do
-      provider_class.manager.expects(:search).with("cn=foo")
-      provider_class.name2id("foo")
+      described_class.manager.expects(:search).with("cn=foo")
+      described_class.name2id("foo")
     end
 
     it "should return nil if no group is found" do
-      provider_class.manager.expects(:search).with("cn=foo").returns nil
-      expect(provider_class.name2id("foo")).to be_nil
-      provider_class.manager.expects(:search).with("cn=bar").returns []
-      expect(provider_class.name2id("bar")).to be_nil
+      described_class.manager.expects(:search).with("cn=foo").returns nil
+      expect(described_class.name2id("foo")).to be_nil
+      described_class.manager.expects(:search).with("cn=bar").returns []
+      expect(described_class.name2id("bar")).to be_nil
     end
 
     # We shouldn't ever actually have more than one gid, but it doesn't hurt
     # to test for the possibility.
     it "should return the first gid from the first returned group" do
-      provider_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
-      expect(provider_class.name2id("foo")).to eq(10)
+      described_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
+      expect(described_class.name2id("foo")).to eq(10)
     end
   end
 end