puppet 6.29.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/type/exec_spec.rb

@@ -239,19 +239,6 @@ RSpec.describe Puppet::Type.type(:exec) do
     expect(dependencies.collect(&:to_s)).to eq([Puppet::Relationship.new(tmp, execer).to_s])
   end
 
-  it "should be able to autorequire files mentioned in the array command" do
-    foo = make_absolute('/bin/foo')
-    catalog = Puppet::Resource::Catalog.new
-    tmp = Puppet::Type.type(:file).new(:name => foo)
-    execer = Puppet::Type.type(:exec).new(:name => 'test array', :command => [foo, 'bar'])
-
-    catalog.add_resource tmp
-    catalog.add_resource execer
-    dependencies = execer.autorequire(catalog)
-
-    expect(dependencies.collect(&:to_s)).to eq([Puppet::Relationship.new(tmp, execer).to_s])
-  end
-
   describe "when handling the path parameter" do
     expect = %w{one two three four}
     { "an array"                                      => expect,
@@ -359,13 +346,7 @@ RSpec.describe Puppet::Type.type(:exec) do
   end
 
   shared_examples_for "all exec command parameters" do |param|
-    array_cmd = ["/bin/example", "*"]
-    array_cmd = [["/bin/example", "*"]] if [:onlyif, :unless].include?(param)
-
-    commands = { "relative" => "example", "absolute" => "/bin/example" }
-    commands["array"] = array_cmd
-
-    commands.sort.each do |name, command|
+    { "relative" => "example", "absolute" => "/bin/example" }.sort.each do |name, command|
       describe "if command is #{name}" do
         before :each do
           @param = param
@@ -398,44 +379,45 @@ RSpec.describe Puppet::Type.type(:exec) do
   end
 
   shared_examples_for "all exec command parameters that take arrays" do |param|
-    [
-      %w{one two three},
-      [%w{one -a}, %w{two, -b}, 'three']
-    ].each do |input|
-      context "when given #{input.inspect} as input" do
-        let(:resource) { Puppet::Type.type(:exec).new(:name => @executable) }
-
-        it "accepts the array when all commands return valid" do
-          input = %w{one two three}
-          allow(resource.provider).to receive(:validatecmd).exactly(input.length).times.and_return(true)
-          resource[param] = input
-          expect(resource[param]).to eq(input)
-        end
+    describe "when given an array of inputs" do
+      before :each do
+        @test = Puppet::Type.type(:exec).new(:name => @executable)
+      end
 
-        it "rejects the array when any commands return invalid" do
-          input = %w{one two three}
-          allow(resource.provider).to receive(:validatecmd).with(input[0]).and_return(true)
-          allow(resource.provider).to receive(:validatecmd).with(input[1]).and_raise(Puppet::Error)
+      it "should accept the array when all commands return valid" do
+        input = %w{one two three}
+        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(true)
+        @test[param] = input
+        expect(@test[param]).to eq(input)
+      end
 
-          expect { resource[param] = input }.to raise_error(Puppet::ResourceError, /Parameter #{param} failed/)
+      it "should reject the array when any commands return invalid" do
+        input = %w{one two three}
+        expect(@test.provider).to receive(:validatecmd).with(input.first).and_return(false)
+        input[1..-1].each do |cmd|
+          expect(@test.provider).to receive(:validatecmd).with(cmd).and_return(true)
         end
+        @test[param] = input
+        expect(@test[param]).to eq(input)
+      end
 
-        it "stops at the first invalid command" do
-          input = %w{one two three}
-          allow(resource.provider).to receive(:validatecmd).with(input[0]).and_raise(Puppet::Error)
-
-          expect(resource.provider).not_to receive(:validatecmd).with(input[1])
-          expect(resource.provider).not_to receive(:validatecmd).with(input[2])
-          expect { resource[param] = input }.to raise_error(Puppet::ResourceError, /Parameter #{param} failed/)
-        end
+      it "should reject the array when all commands return invalid" do
+        input = %w{one two three}
+        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(false)
+        @test[param] = input
+        expect(@test[param]).to eq(input)
       end
     end
   end
 
   describe "when setting command" do
     subject { described_class.new(:name => @command) }
+    it "fails when passed an Array" do
+      expect { subject[:command] = [] }.to raise_error Puppet::Error, /Command must be a String/
+    end
+
     it "fails when passed a Hash" do
-      expect { subject[:command] = {} }.to raise_error Puppet::Error, /Command must be a String or Array<String>/
+      expect { subject[:command] = {} }.to raise_error Puppet::Error, /Command must be a String/
     end
   end
 
@@ -777,35 +759,6 @@ RSpec.describe Puppet::Type.type(:exec) do
           end
         end
 
-        context 'with an array of arrays with multiple items' do
-          before do
-            [true, false].each do |check|
-              allow(@test.provider).to receive(:run).with([@pass, '--flag'], check).
-                and_return(['test output', @pass_status])
-              allow(@test.provider).to receive(:run).with([@fail, '--flag'], check).
-                and_return(['test output', @fail_status])
-              allow(@test.provider).to receive(:run).with([@pass], check).
-                and_return(['test output', @pass_status])
-              allow(@test.provider).to receive(:run).with([@fail], check).
-                and_return(['test output', @fail_status])
-            end
-          end
-          it "runs if all the commands exits non-zero" do
-            @test[param] = [[@fail, '--flag'], [@fail], [@fail, '--flag']]
-            expect(@test.check_all_attributes).to eq(true)
-          end
-
-          it "does not run if one command exits zero" do
-            @test[param] = [[@pass, '--flag'], [@pass], [@fail, '--flag']]
-            expect(@test.check_all_attributes).to eq(false)
-          end
-
-          it "does not run if all command exits zero" do
-            @test[param] = [[@pass, '--flag'], [@pass], [@pass, '--flag']]
-            expect(@test.check_all_attributes).to eq(false)
-          end
-        end
-
         it "should emit output to debug" do
           Puppet::Util::Log.level = :debug
           @test[param] = @fail

data/spec/unit/type/file/checksum_spec.rb

@@ -18,8 +18,8 @@ describe checksum do
     @checksum.sum("foobar")
   end
 
-  it "should use :md5 to sum when no value is set" do
-    expect(@checksum).to receive(:md5).with("foobar").and_return("yay")
+  it "should use :sha256 to sum when no value is set" do
+    expect(@checksum).to receive(:sha256).with("foobar").and_return("yay")
     @checksum.sum("foobar")
   end
 
@@ -47,8 +47,8 @@ describe checksum do
     expect(@checksum.sum("foobar")).to eq("{sha384}#{sum}")
   end
 
-  it "should use :md5 as its default type" do
-    expect(@checksum.default).to eq(:md5)
+  it "should use :sha256 as its default type" do
+    expect(@checksum.default).to eq(:sha256)
   end
 
   it "should use its current value when asked to sum a file's content" do
@@ -57,8 +57,8 @@ describe checksum do
     @checksum.sum_file(@path)
   end
 
-  it "should use :md5 to sum a file when no value is set" do
-    expect(@checksum).to receive(:md5_file).with(@path).and_return("yay")
+  it "should use :sha256 to sum a file when no value is set" do
+    expect(@checksum).to receive(:sha256_file).with(@path).and_return("yay")
     @checksum.sum_file(@path)
   end
 

data/spec/unit/type/file/content_spec.rb

@@ -7,10 +7,11 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
   let(:filename) { tmpfile('testfile') }
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
   let(:catalog) { Puppet::Resource::Catalog.new(:test, environment) }
-  let(:resource) { Puppet::Type.type(:file).new :path => filename, :catalog => catalog }
+  let(:resource) { Puppet::Type.type(:file).new :path => filename, :catalog => catalog, :backup => 'puppet' }
 
   before do
     File.open(filename, 'w') {|f| f.write "initial file content"}
+    allow(described_class).to receive(:standalone?).and_return(false)
   end
 
   around do |example|

data/spec/unit/type/file/ensure_spec.rb

@@ -85,7 +85,7 @@ describe Puppet::Type.type(:file).attrclass(:ensure) do
         }.to raise_error(Puppet::Error, /Cannot create #{newpath}; parent directory #{File.dirname(newpath)} does not exist/)
       end
 
-      it "should accept octal mode as fixnum" do
+      it "should accept octal mode as integer" do
         resource[:mode] = '0700'
         expect(resource).to receive(:property_fix)
         expect(Dir).to receive(:mkdir).with(path, 0700)

data/spec/unit/type/file/mode_spec.rb

@@ -11,7 +11,7 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
     it "should reject non-string values" do
       expect {
         mode.value = 0755
-      }.to raise_error(Puppet::Error, /The file mode specification must be a string, not '(?:Fixnum|Integer)'/)
+      }.to raise_error(Puppet::Error, /The file mode specification must be a string, not 'Integer'/)
     end
 
     it "should accept values specified as octal numbers in strings" do

data/spec/unit/type/file/selinux_spec.rb

@@ -7,8 +7,10 @@ require 'spec_helper'
 
     before do
       @path = make_absolute("/my/file")
-      @resource = Puppet::Type.type(:file).new(:path => @path, :ensure => :file)
+      @resource = Puppet::Type.type(:file).new :path => @path
       @sel = property.new :resource => @resource
+      allow(@sel).to receive(:normalize_selinux_category).with("s0").and_return("s0")
+      allow(@sel).to receive(:normalize_selinux_category).with(nil).and_return(nil)
     end
 
     it "retrieve on #{param} should return :absent if the file isn't statable" do
@@ -50,13 +52,13 @@ require 'spec_helper'
     end
 
     it "should handle no default gracefully" do
-      expect(@sel).to receive(:get_selinux_default_context).with(@path, :file).and_return(nil)
+      expect(@sel).to receive(:get_selinux_default_context).with(@path).and_return(nil)
       expect(@sel.default).to be_nil
     end
 
     it "should be able to detect matchpathcon defaults" do
       allow(@sel).to receive(:debug)
-      expect(@sel).to receive(:get_selinux_default_context).with(@path, :file).and_return("user_u:role_r:type_t:s0")
+      expect(@sel).to receive(:get_selinux_default_context).with(@path).and_return("user_u:role_r:type_t:s0")
       expectedresult = case param
         when :seluser; "user_u"
         when :selrole; "role_r"

data/spec/unit/type/file/source_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 require 'uri'
 require 'puppet/network/http_pool'
-#require 'puppet/network/resolver'
 
 describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
   include PuppetSpec::Files
@@ -264,7 +263,7 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
           expect(@resource[:owner]).to eq(100)
           expect(@resource[:group]).to eq(200)
-          expect(@resource[:mode]).to eq("0173")
+          expect(@resource[:mode]).to eq("173")
 
           # Metadata calls it checksum and checksum_type, we call it content and checksum.
           expect(@resource[:content]).to eq(@metadata.checksum)
@@ -281,7 +280,7 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
           expect(@resource[:owner]).to eq(1)
           expect(@resource[:group]).to eq(2)
-          expect(@resource[:mode]).to eq('0173')
+          expect(@resource[:mode]).to eq('173')
           expect(@resource[:content]).not_to eq(@metadata.checksum)
           expect(@resource[:checksum]).not_to eq(@metadata.checksum_type.to_sym)
         end
@@ -318,7 +317,7 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
             expect(@resource[:owner]).to eq(100)
             expect(@resource[:group]).to eq(200)
-            expect(@resource[:mode]).to eq("0173")
+            expect(@resource[:mode]).to eq("173")
           end
 
           it "copies the remote owner" do
@@ -336,7 +335,7 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
           it "copies the remote mode" do
             @source.copy_source_values
 
-            expect(@resource[:mode]).to eq("0173")
+            expect(@resource[:mode]).to eq("173")
           end
         end
 

data/spec/unit/type/file_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'spec_helper'
 
 describe Puppet::Type.type(:file) do
@@ -133,6 +134,10 @@ describe Puppet::Type.type(:file) do
   end
 
   describe "the backup parameter" do
+    it 'should be disabled by default' do
+      expect(file[:backup]).to eq(nil)
+    end
+
     [false, 'false', :false].each do |value|
       it "should disable backup if the value is #{value.inspect}" do
         file[:backup] = value
@@ -344,6 +349,12 @@ describe Puppet::Type.type(:file) do
   end
 
   describe "#flush" do
+    it "should flush all properties that respond to :flush" do
+      file[:source] = File.expand_path(__FILE__)
+      expect(file.parameter(:source)).to receive(:flush)
+      file.flush
+    end
+
     it "should reset its stat reference" do
       FileUtils.touch(path)
       stat1 = file.stat
@@ -768,7 +779,7 @@ describe Puppet::Type.type(:file) do
     it "should set the checksum parameter based on the metadata" do
       allow(file).to receive(:perform_recursion).and_return([@first])
       allow(@resource).to receive(:[]=)
-      expect(@resource).to receive(:[]=).with(:checksum, "md5")
+      expect(@resource).to receive(:[]=).with(:checksum, "sha256")
       file.recurse_remote("first" => @resource)
     end
 
@@ -804,7 +815,7 @@ describe Puppet::Type.type(:file) do
       allow(file).to receive(:perform_recursion).and_return([@first])
 
       allow(file).to receive(:[]=)
-      expect(file). to receive(:[]=).with(:checksum, "md5")
+      expect(file). to receive(:[]=).with(:checksum, "sha256")
 
       file.recurse_remote("first" => @resource)
     end
@@ -922,7 +933,7 @@ describe Puppet::Type.type(:file) do
     end
 
     it "should fail if it can't backup the file" do
-      # Default: file[:backup] = true
+      file[:backup] = true
       allow(file).to receive(:stat).and_return(double('stat', :ftype => 'file'))
       allow(file).to receive(:perform_backup).and_return(false)
 
@@ -931,7 +942,7 @@ describe Puppet::Type.type(:file) do
 
     describe "backing up directories" do
       it "should not backup directories if backup is true and force is false" do
-        # Default: file[:backup] = true
+        file[:backup] = true
         file[:force] = false
         allow(file).to receive(:stat).and_return(double('stat', :ftype => 'directory'))
 
@@ -941,7 +952,7 @@ describe Puppet::Type.type(:file) do
       end
 
       it "should backup directories if backup is true and force is true" do
-        # Default: file[:backup] = true
+        file[:backup] = true
         file[:force] = true
         allow(file).to receive(:stat).and_return(double('stat', :ftype => 'directory'))
 
@@ -968,7 +979,7 @@ describe Puppet::Type.type(:file) do
     end
 
     it "should remove a directory if backup is true and force is true" do
-      # Default: file[:backup] = true
+      file[:backup] = true
       file[:force] = true
       allow(file).to receive(:stat).and_return(double('stat', :ftype => 'directory'))
 
@@ -1000,6 +1011,7 @@ describe Puppet::Type.type(:file) do
     end
 
     it "should fail if the file is not a directory, link, file, fifo, socket, or is unknown" do
+      file[:backup] = 'puppet'
       allow(file).to receive(:stat).and_return(double('stat', :ftype => 'blockSpecial'))
 
       expect(file).to receive(:warning).with("Could not back up file of type blockSpecial")

data/spec/unit/type/group_spec.rb

@@ -60,12 +60,9 @@ describe Puppet::Type.type(:group) do
   end
 
   it "delegates the existence check to its provider" do
-    provider = @class.provide(:testing) do
-      def exists?
-        true
-      end
-    end
+    provider = @class.provide(:testing) {}
     provider_instance = provider.new
+    expect(provider_instance).to receive(:exists?).and_return(true)
 
     type = @class.new(:name => "group", :provider => provider_instance)
 
@@ -80,24 +77,20 @@ describe Puppet::Type.type(:group) do
         def members
           []
         end
-
-        def members_insync?(current, should)
-          current == should
-        end
-
-        def members_to_s(values)
-          values.map { |v| "#{v} ()" }.join(', ')
-        end
       end
     end
     let (:provider_instance) { provider.new }
     let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
 
     it "insync? calls members_insync?" do
+      expect(provider_instance).to receive(:members_insync?).with(['user1'], ['user1']).and_return(true)
       expect(type.property(:members).insync?(['user1'])).to be_truthy
     end
 
     it "is_to_s and should_to_s call members_to_s" do
+      expect(provider_instance).to receive(:members_to_s).with(['user1', 'user2']).and_return("user1 (), user2 ()")
+      expect(provider_instance).to receive(:members_to_s).with(['user1']).and_return("user1 ()")
+
       expect(type.property(:members).is_to_s('user1')).to eq('user1 ()')
       expect(type.property(:members).should_to_s('user1,user2')).to eq('user1 (), user2 ()')
     end

data/spec/unit/type/package_spec.rb

@@ -349,7 +349,7 @@ describe Puppet::Type.type(:package) do
         end
       end
 
-      [:purged, :absent, :held].each do |state|
+      [:purged, :absent].each do |state|
         it "should not reinstall if it should be #{state.to_s} and reinstall_on_refresh is true" do
           @package[:ensure] = state
           allow(@provider).to receive(:reinstallable?).and_return(true)

data/spec/unit/type/resources_spec.rb

@@ -6,9 +6,6 @@ Puppet::Type.newtype(:purgeable_test) do
   newparam(:name) {}
 end
 Puppet::Type.type(:purgeable_test).provide(:purgeable_test) do
-  def self.instances
-    []
-  end
 end
 
 resources = Puppet::Type.type(:resources)
@@ -49,16 +46,19 @@ describe resources do
     end
 
     it "cannot be set to true for a resource type that does not accept ensure" do
-      allow(instance.resource_type).to receive(:validproperty?).with(:ensure).and_return(false)
-      expect { instance[:purge] = 'yes' }.to raise_error Puppet::Error, /Purging is only supported on types that accept 'ensure'/
+      allow(instance.resource_type).to receive(:respond_to?).and_return(true)
+      allow(instance.resource_type).to receive(:validproperty?).and_return(false)
+      expect { instance[:purge] = 'yes' }.to raise_error Puppet::Error
     end
 
     it "cannot be set to true for a resource type that does not have instances" do
-      allow(instance.resource_type).to receive(:respond_to?).with(:instances).and_return(false)
-      expect { instance[:purge] = 'yes' }.to raise_error Puppet::Error, /Purging resources of type file is not supported/
+      allow(instance.resource_type).to receive(:respond_to?).and_return(false)
+      allow(instance.resource_type).to receive(:validproperty?).and_return(true)
+      expect { instance[:purge] = 'yes' }.to raise_error Puppet::Error
     end
 
     it "can be set to true for a resource type that has instances and can accept ensure" do
+      allow(instance.resource_type).to receive(:respond_to?).and_return(true)
       allow(instance.resource_type).to receive(:validproperty?).and_return(true)
       expect { instance[:purge] = 'yes' }.to_not raise_error
     end