puppet 5.5.8 → 5.5.10

data/spec/unit/application/device_spec.rb

@@ -299,6 +299,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({})
@@ -504,7 +505,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
@@ -74,7 +75,7 @@ describe Puppet::Application::Lookup do
         lookup.command_line.stubs(:args).returns(['atton', 'kreia'])
         lookup.stubs(:generate_scope).yields('scope')
         Puppet::Pops::Lookup.stubs(:lookup).returns('rand')
-        expect(run_lookup(lookup)).to eql("--- rand\n...")
+        expect(run_lookup(lookup)).to eql("--- rand")
       end
     end
 
@@ -85,7 +86,7 @@ describe Puppet::Application::Lookup do
 
       Puppet::Pops::Lookup.stubs(:lookup).returns('rand')
 
-      expect(run_lookup(lookup)).to eql("--- rand\n...")
+      expect(run_lookup(lookup)).to eql("--- rand")
     end
   end
 
@@ -502,14 +503,14 @@ Searching for "a"
       it "is unaffected by global variables unless '--compile' is used" do
         lookup.options[:node] = node
         lookup.command_line.stubs(:args).returns(['c'])
-        expect(run_lookup(lookup)).to eql("--- This is\n...")
+        expect(run_lookup(lookup)).to eql("--- This is")
       end
 
       it "is affected by global variables when '--compile' is used" do
         lookup.options[:node] = node
         lookup.options[:compile] = true
         lookup.command_line.stubs(:args).returns(['c'])
-        expect(run_lookup(lookup)).to eql("--- This is C from site.pp\n...")
+        expect(run_lookup(lookup)).to eql("--- This is C from site.pp")
       end
 
       it 'receives extra facts in top scope' do
@@ -523,7 +524,7 @@ Searching for "a"
         lookup.options[:node] = node
         lookup.options[:fact_file] = filename
         lookup.command_line.stubs(:args).returns(['c'])
-        expect(run_lookup(lookup)).to eql("--- This is C from facts\n...")
+        expect(run_lookup(lookup)).to eql("--- This is C from facts")
       end
 
       it 'receives extra facts in the facts hash' do
@@ -537,7 +538,7 @@ Searching for "a"
         lookup.options[:node] = node
         lookup.options[:fact_file] = filename
         lookup.command_line.stubs(:args).returns(['g'])
-        expect(run_lookup(lookup)).to eql("--- This is G from facts in facts hash\n...")
+        expect(run_lookup(lookup)).to eql("--- This is G from facts in facts hash")
       end
     end
 
@@ -547,14 +548,14 @@ Searching for "a"
       it "works OK in the absense of '--compile'" do
         lookup.options[:node] = node
         lookup.command_line.stubs(:args).returns(['c'])
-        expect(run_lookup(lookup)).to eql("--- This is C from data.pp\n...")
+        expect(run_lookup(lookup)).to eql("--- This is C from data.pp")
       end
 
       it "global scope is affected by global variables when '--compile' is used" do
         lookup.options[:node] = node
         lookup.options[:compile] = true
         lookup.command_line.stubs(:args).returns(['c'])
-        expect(run_lookup(lookup)).to eql("--- This is C from site.pp\n...")
+        expect(run_lookup(lookup)).to eql("--- This is C from site.pp")
       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/indirector/yaml_spec.rb

@@ -124,7 +124,7 @@ describe Puppet::Indirector::Yaml do
       Dir.expects(:glob).with(:glob).returns(%w{one.yaml two.yaml})
       YAML.expects(:load_file).with("one.yaml").returns @one;
       YAML.expects(:load_file).with("two.yaml").returns @two;
-      expect(@store.search(@request)).to eq([@one, @two])
+      expect(@store.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

@@ -475,8 +475,7 @@ describe 'The Loader' do
           end
 
           context 'with no explicit dependencies' do
-
-            let(:modules) {
+            let(:modules) do
               {
                 'a' => {
                   'functions' => a_functions,
@@ -496,12 +495,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/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

@@ -698,6 +698,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
@@ -846,6 +855,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/cron/parsed_spec.rb

@@ -209,6 +209,8 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       end
 
       it "should contain no resources for a user who has no crontab" do
+        Puppet::Util.stubs(:uid).returns(10)
+
         Puppet::Util::Execution.expects(:execute)
           .with('crontab -u foobar -l', { failonfail: true, combine: true })
           .returns("")
@@ -218,9 +220,8 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       end
 
       it "should contain no resources for a user who is absent" do
-        Puppet::Util::Execution.expects(:execute)
-          .with('crontab -u foobar -l', { failonfail: true, combine: true })
-          .returns("")
+        Puppet::Util.stubs(:uid).returns(nil)
+
         expect(described_class.instances.select { |resource|
           resource.get('target') == 'foobar'
         }).to be_empty

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

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

@@ -1,9 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:group).provider(:pw)
-
-describe provider_class do
+describe Puppet::Type.type(:group).provider(:pw) do
   let :resource do
     Puppet::Type.type(:group).new(:name => "testgroup", :provider => :pw)
   end
@@ -20,8 +17,8 @@ describe provider_class do
     end
 
     it "should run pw with no additional flags when no properties are given" do
-      expect(provider.addcmd).to eq([provider_class.command(:pw), "groupadd", "testgroup"])
-      provider.expects(:execute).with([provider_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
+      expect(provider.addcmd).to eq([described_class.command(:pw), "groupadd", "testgroup"])
+      provider.expects(:execute).with([described_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
       provider.create
     end
 
@@ -53,16 +50,16 @@ describe provider_class do
   describe "when deleting groups" do
     it "should run pw with no additional flags" do
       provider.expects(:exists?).returns true
-      expect(provider.deletecmd).to eq([provider_class.command(:pw), "groupdel", "testgroup"])
-      provider.expects(:execute).with([provider_class.command(:pw), "groupdel", "testgroup"], has_entry(:custom_environment, {}))
+      expect(provider.deletecmd).to eq([described_class.command(:pw), "groupdel", "testgroup"])
+      provider.expects(:execute).with([described_class.command(:pw), "groupdel", "testgroup"], has_entry(:custom_environment, {}))
       provider.delete
     end
   end
 
   describe "when modifying groups" do
     it "should run pw with the correct arguments" do
-      expect(provider.modifycmd("gid", 12345)).to eq([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
-      provider.expects(:execute).with([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345], has_entry(:custom_environment, {}))
+      expect(provider.modifycmd("gid", 12345)).to eq([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
+      provider.expects(:execute).with([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345], has_entry(:custom_environment, {}))
       provider.gid = 12345
     end
 

data/spec/unit/provider/host/parsed_spec.rb

@@ -1,12 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
-require 'shared_behaviours/all_parsedfile_providers'
 
+require 'shared_behaviours/all_parsedfile_providers'
 require 'puppet_spec/files'
 
-provider_class = Puppet::Type.type(:host).provider(:parsed)
-
-describe provider_class do
+describe Puppet::Type.type(:host).provider(:parsed) do
   include PuppetSpec::Files
 
   before do
@@ -46,7 +43,6 @@ describe provider_class do
   end
 
   describe "when parsing on incomplete line" do
-
     it "should work for only ip" do
       expect(@provider.parse_line("127.0.0.1")[:line]).to eq("127.0.0.1")
     end
@@ -78,11 +74,9 @@ describe provider_class do
     it "should work for crazy incomplete lines" do
       expect(@provider.parse_line("%th1s is a\t cr$zy    !incompl1t line")[:line]).to eq("%th1s is a\t cr$zy    !incompl1t line")
     end
-
   end
 
   describe "when parsing a line with ip and hostname" do
-
     it "should parse an ipv4 from the first field" do
       expect(@provider.parse_line("127.0.0.1    localhost")[:ip]).to eq("127.0.0.1")
     end
@@ -102,7 +96,6 @@ describe provider_class do
     it "should set host_aliases to :absent" do
       expect(@provider.parse_line("::1     localhost")[:host_aliases]).to eq(:absent)
     end
-
   end
 
   describe "when parsing a line with ip, hostname and comment" do
@@ -121,11 +114,9 @@ describe provider_class do
     it "should parse the comment after the first '#' character" do
       expect(@provider.parse_line(@testline)[:comment]).to eq('A comment with a #-char')
     end
-
   end
 
   describe "when parsing a line with ip, hostname and aliases" do
-
     it "should parse alias from the third field" do
       expect(@provider.parse_line("127.0.0.1   localhost   localhost.localdomain")[:host_aliases]).to eq("localhost.localdomain")
     end
@@ -135,11 +126,9 @@ describe provider_class do
       expect(@provider.parse_line("127.0.0.1 host alias1\talias2")[:host_aliases]).to eq('alias1 alias2')
       expect(@provider.parse_line("127.0.0.1 host alias1\talias2   alias3")[:host_aliases]).to eq('alias1 alias2 alias3')
     end
-
   end
 
   describe "when parsing a line with ip, hostname, aliases and comment" do
-
     before do
       # Just playing with a few different delimiters
       @testline = "127.0.0.1\t   host  alias1\talias2   alias3   #   A comment with a #-char"
@@ -160,12 +149,11 @@ describe provider_class do
     it "should parse the comment after the first '#' character" do
       expect(@provider.parse_line(@testline)[:comment]).to eq('A comment with a #-char')
     end
-
   end
 
   describe "when operating on /etc/hosts like files" do
     it_should_behave_like "all parsedfile providers",
-      provider_class, my_fixtures('valid*')
+      described_class, my_fixtures('valid*')
 
     it "should be able to generate a simple hostfile entry" do
       host = mkhost(
@@ -227,7 +215,5 @@ describe provider_class do
       )
       expect(genhost(host)).to eq("192.0.0.1\thost\ta1 a2 a3 a4\t# Bazinga!\n")
     end
-
   end
-
 end