puppet 6.25.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/transaction/additional_resource_generator_spec.rb

@@ -33,6 +33,10 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
 
       newparam(:code)
 
+      def respond_to?(method_name)
+        method_name == self[:kind] || super
+      end
+
       def eval_generate
         eval_code
       end
@@ -93,6 +97,8 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
     end
   end
 
+
+
   after(:each) do
     Puppet::Type.rmtype(:gen_empty)
     Puppet::Type.rmtype(:eval_after)
@@ -308,13 +314,13 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
 
     it "sets resources_failed_to_generate to true if resource#eval_generate raises an exception" do
       catalog = compile_to_ral(<<-MANIFEST)
-        generator { thing: }
+        notify { 'hello': }
       MANIFEST
 
-      allow(catalog.resource("Generator[thing]")).to receive(:eval_generate).and_raise(RuntimeError)
+      allow(catalog.resource("Notify[hello]")).to receive(:eval_generate).and_raise(RuntimeError)
       relationship_graph = relationship_graph_for(catalog)
       generator = Puppet::Transaction::AdditionalResourceGenerator.new(catalog, relationship_graph, prioritizer)
-      generator.eval_generate(catalog.resource("Generator[thing]"))
+      generator.eval_generate(catalog.resource("Notify[hello]"))
 
       expect(generator.resources_failed_to_generate).to be_truthy
     end

data/spec/unit/transaction/event_manager_spec.rb

@@ -152,9 +152,6 @@ describe Puppet::Transaction::EventManager do
 
       @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
       @event = Puppet::Transaction::Event.new(:name => :event, :resource => @resource)
-
-      @resource.class.send(:define_method, :callback1) {}
-      @resource.class.send(:define_method, :callback2) {}
     end
 
     it "should call the required callback once for each set of associated events" do
@@ -181,7 +178,7 @@ describe Puppet::Transaction::EventManager do
 
       allow(@resource).to receive(:callback1)
 
-      @manager.process_events(@resource)
+      @manager.process_events(@resource) #x
 
       expect(@transaction.resource_status(@resource).events.length).to eq(1)
     end
@@ -214,11 +211,9 @@ describe Puppet::Transaction::EventManager do
         @event2 = Puppet::Transaction::Event.new(:name => :event, :resource => @resource)
         @event2.status = "success"
         expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event, @event2])
-        @resource.class.send(:define_method, :callback1) {}
       end
 
       it "should call the callback" do
-
         expect(@resource).to receive(:callback1)
 
         @manager.process_events(@resource)
@@ -230,7 +225,6 @@ describe Puppet::Transaction::EventManager do
         allow(@event).to receive(:status).and_return("noop")
         allow(@resource).to receive(:event).and_return(Puppet::Transaction::Event.new)
         expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
-        @resource.class.send(:define_method, :callback1) {}
       end
 
       it "should log" do
@@ -260,7 +254,6 @@ describe Puppet::Transaction::EventManager do
         allow(@resource).to receive(:event).and_return(Puppet::Transaction::Event.new)
         allow(@resource).to receive(:noop?).and_return(true)
         expect(@manager).to receive(:queued_events).with(@resource).and_yield(:callback1, [@event])
-        @resource.class.send(:define_method, :callback1) {}
       end
 
       it "should log" do
@@ -286,7 +279,7 @@ describe Puppet::Transaction::EventManager do
 
     describe "and the callback fails" do
       before do
-        @resource.class.send(:define_method, :callback1) { raise "a failure" }
+        expect(@resource).to receive(:callback1).and_raise("a failure")
 
         expect(@manager).to receive(:queued_events).and_yield(:callback1, [@event])
       end
@@ -330,12 +323,16 @@ describe Puppet::Transaction::EventManager do
 
   describe "when queueing then processing events for a given resource" do
     before do
-      @catalog = Puppet::Resource::Catalog.new
-      @target = Puppet::Type.type(:exec).new(name: 'target', path: ENV['PATH'])
-      @resource = Puppet::Type.type(:exec).new(name: 'resource', path: ENV['PATH'], notify: @target)
-      @catalog.add_resource(@resource, @target)
+      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
+      @manager = Puppet::Transaction::EventManager.new(@transaction)
 
-      @manager = Puppet::Transaction::EventManager.new(Puppet::Transaction.new(@catalog, nil, nil))
+      @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
+      @target = Puppet::Type.type(:file).new :path => make_absolute("/your/file")
+
+      @graph = allow('graph')
+      allow(@graph).to receive(:matching_edges).and_return([])
+      allow(@graph).to receive(:matching_edges).with(anything, @resource).and_return([double('edge', :target => @target, :callback => :refresh)])
+      allow(@manager).to receive(:relationship_graph).and_return(@graph)
 
       @event  = Puppet::Transaction::Event.new(:name => :notify, :resource => @target)
       @event2 = Puppet::Transaction::Event.new(:name => :service_start, :resource => @target, :invalidate_refreshes => true)

data/spec/unit/transaction/report_spec.rb

@@ -675,7 +675,6 @@ Version:
     report.code_id = "some code id"
     report.catalog_uuid = "some catalog uuid"
     report.cached_catalog_status = "not_used"
-    report.master_used = "test:000"
     report.server_used = "test:000"
     report.add_resource_status(status)
     report.transaction_completed = true
@@ -694,7 +693,6 @@ Version:
     report.code_id = "some code id"
     report.catalog_uuid = "some catalog uuid"
     report.cached_catalog_status = "not_used"
-    report.master_used = "test:000"
     report.server_used = "test:000"
     report.add_resource_status(status)
     report.transaction_completed = true

data/spec/unit/transaction/resource_harness_spec.rb

@@ -612,14 +612,14 @@ describe Puppet::Transaction::ResourceHarness do
       allow_any_instance_of(Puppet::Transaction::Event).to receive(:corrective_change).and_return(true)
       status = @harness.evaluate(resource)
       sync_event = status.events[0]
-      expect(sync_event.message).to match(/content changed '{md5}[0-9a-f]+' to '{md5}[0-9a-f]+' \(corrective\)/)
+      expect(sync_event.message).to match(/content changed '{sha256}[0-9a-f]+' to '{sha256}[0-9a-f]+' \(corrective\)/)
     end
 
     it "contains no modifier when intentional change" do
       allow_any_instance_of(Puppet::Transaction::Event).to receive(:corrective_change).and_return(false)
       status = @harness.evaluate(resource)
       sync_event = status.events[0]
-      expect(sync_event.message).to match(/content changed '{md5}[0-9a-f]+' to '{md5}[0-9a-f]+'$/)
+      expect(sync_event.message).to match(/content changed '{sha256}[0-9a-f]+' to '{sha256}[0-9a-f]+'$/)
     end
   end
 end

data/spec/unit/transaction_spec.rb

@@ -20,19 +20,6 @@ describe Puppet::Transaction do
     transaction
   end
 
-  before(:all) do
-    Puppet::Type.newtype(:transaction_generator) do
-      newparam(:name) { isnamevar }
-
-      def generate
-      end
-    end
-  end
-
-  after(:all) do
-    Puppet::Type.rmtype(:transaction_generator)
-  end
-
   before do
     @basepath = make_absolute("/what/ever")
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, Puppet::Graph::SequentialPrioritizer.new)
@@ -336,9 +323,9 @@ describe Puppet::Transaction do
   describe "when generating resources before traversal" do
     let(:catalog) { Puppet::Resource::Catalog.new }
     let(:transaction) { Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new) }
-    let(:generator) { Puppet::Type.type(:transaction_generator).new :title => "generator" }
+    let(:generator) { Puppet::Type.type(:notify).new :title => "generator" }
     let(:generated) do
-      %w[a b c].map { |name| Puppet::Type.type(:transaction_generator).new(:name => name) }
+      %w[a b c].map { |name| Puppet::Type.type(:notify).new(:name => name) }
     end
 
     before :each do
@@ -611,115 +598,81 @@ describe Puppet::Transaction do
       transaction.prefetch_if_necessary(resource)
     end
 
-    it "should not rescue SystemExit without future_features flag" do
-      Puppet.settings[:future_features] = false
-      expect(resource.provider.class).to receive(:prefetch).and_raise(SystemExit, "SystemMessage")
-      expect { transaction.prefetch_if_necessary(resource) }.to raise_error(SystemExit, "SystemMessage")
-    end
-
-    it "should not rescue SystemExit with future_features flag" do
-      Puppet.settings[:future_features] = true
+    it "should not rescue SystemExit" do
       expect(resource.provider.class).to receive(:prefetch).and_raise(SystemExit, "SystemMessage")
       expect { transaction.prefetch_if_necessary(resource) }.to raise_error(SystemExit, "SystemMessage")
     end
 
-    it "should rescue LoadError without future_features flag" do
-      Puppet.settings[:future_features] = false
-      expect(resource.provider.class).to receive(:prefetch).and_raise(LoadError, "LoadMessage")
-      expect { transaction.prefetch_if_necessary(resource) }.not_to raise_error
-    end
-
-    it "should rescue LoadError with future_features flag" do
-      Puppet.settings[:future_features] = true
+    it "should mark resources as failed when prefetching raises LoadError" do
       expect(resource.provider.class).to receive(:prefetch).and_raise(LoadError, "LoadMessage")
-      expect { transaction.prefetch_if_necessary(resource) }.not_to raise_error
+      transaction.prefetch_if_necessary(resource)
+      expect(transaction.prefetched_providers[:package][:pkgng]).to be_truthy
     end
 
-    describe "and prefetching fails" do
+    describe "and prefetching raises Puppet::Error" do
       before :each do
         expect(resource.provider.class).to receive(:prefetch).and_raise(Puppet::Error, "message")
       end
 
-      context "without future_features flag" do
-        before :each do
-          Puppet.settings[:future_features] = false
-        end
-
-        it "should not rescue prefetch executions" do
-          expect { transaction.prefetch_if_necessary(resource) }.to raise_error(Puppet::Error)
-        end
+      it "should rescue prefetch executions" do
+        transaction.prefetch_if_necessary(resource)
 
-        it "should log the exception during prefetch" do
-          expect(Puppet).to receive(:log_exception).with(anything, "Could not prefetch package provider 'pkgng': message")
-          expect { transaction.prefetch_if_necessary(resource) }.to raise_error(Puppet::Error, "message")
-        end
+        expect(transaction.prefetched_providers[:package][:pkgng]).to be_truthy
       end
 
-      context "with future_features flag" do
-        before :each do
-          Puppet.settings[:future_features] = true
-        end
+      it "should mark resources as failed", :unless => RUBY_PLATFORM == 'java' do
+        transaction.evaluate
 
-        it "should rescue prefetch executions" do
-          transaction.prefetch_if_necessary(resource)
+        expect(transaction.resource_status(resource).failed?).to be_truthy
+      end
 
-          expect(transaction.prefetched_providers[:package][:pkgng]).to be_truthy
-        end
+      it "should mark a provider that has failed prefetch" do
+        transaction.prefetch_if_necessary(resource)
 
-        it "should mark resources as failed", :unless => RUBY_PLATFORM == 'java' do
-          transaction.evaluate
+        expect(transaction.prefetch_failed_providers[:package][:pkgng]).to be_truthy
+      end
 
-          expect(transaction.resource_status(resource).failed?).to be_truthy
+      describe "and new resources are generated" do
+        let(:generator) { Puppet::Type.type(:notify).new :title => "generator" }
+        let(:generated) do
+          %w[a b c].map { |name| Puppet::Type.type(:package).new :title => "foo", :name => name, :provider => :apt }
         end
 
-        it "should mark a provider that has failed prefetch" do
-          transaction.prefetch_if_necessary(resource)
-
-          expect(transaction.prefetch_failed_providers[:package][:pkgng]).to be_truthy
+        before :each do
+          catalog.add_resource generator
+          allow(generator).to receive(:generate).and_return(generated)
+          allow(catalog).to receive(:container_of).and_return(generator)
         end
 
-        describe "and new resources are generated" do
-          let(:generator) { Puppet::Type.type(:transaction_generator).new :title => "generator" }
-          let(:generated) do
-            %w[a b c].map { |name| Puppet::Type.type(:package).new :title => "foo", :name => name, :provider => :apt }
-          end
-
-          before :each do
-            catalog.add_resource generator
-            allow(generator).to receive(:generate).and_return(generated)
-            allow(catalog).to receive(:container_of).and_return(generator)
-          end
-
-          it "should not evaluate resources with a failed provider, even if the prefetch is rescued" do
-            #Only the generator resource should be applied, all the other resources are failed, and skipped.
-            catalog.remove_resource resource2
-            expect(transaction).to receive(:apply).once
+        it "should not evaluate resources with a failed provider, even if the prefetch is rescued" do
+          #Only the generator resource should be applied, all the other resources are failed, and skipped.
+          catalog.remove_resource resource2
+          expect(transaction).to receive(:apply).once
 
-            transaction.evaluate
-          end
+          transaction.evaluate
+        end
 
-          it "should not fail other resources added after the failing resource", :unless => RUBY_PLATFORM == 'java' do
-            new_resource = Puppet::Type.type(:notify).new :name => "baz"
-            catalog.add_resource(new_resource)
+        it "should not fail other resources added after the failing resource", :unless => RUBY_PLATFORM == 'java' do
+          new_resource = Puppet::Type.type(:notify).new :name => "baz"
+          catalog.add_resource(new_resource)
 
-            transaction.evaluate
+          transaction.evaluate
 
-            expect(transaction.resource_status(new_resource).failed?).to be_falsey
-          end
+          expect(transaction.resource_status(new_resource).failed?).to be_falsey
+        end
 
-          it "should fail other resources that require the failing resource" do
-            new_resource = Puppet::Type.type(:notify).new(:name => "baz", :require => resource)
-            catalog.add_resource(new_resource)
+        it "should fail other resources that require the failing resource" do
+          new_resource = Puppet::Type.type(:notify).new(:name => "baz", :require => resource)
+          catalog.add_resource(new_resource)
 
-            catalog.remove_resource resource2
-            expect(transaction).to receive(:apply).once
+          catalog.remove_resource resource2
+          expect(transaction).to receive(:apply).once
 
-            transaction.evaluate
+          transaction.evaluate
 
-            expect(transaction.resource_status(resource).failed?).to be_truthy
-            expect(transaction.resource_status(new_resource).dependency_failed?).to be_truthy
-            expect(transaction.skip?(new_resource)).to be_truthy
-          end
+          expect(transaction.resource_status(resource).failed?).to be_truthy
+          expect(transaction.resource_status(new_resource).dependency_failed?).to be_truthy
+          expect(transaction.skip?(new_resource)).to be_truthy
         end
       end
     end
@@ -793,8 +746,13 @@ describe Puppet::Transaction do
     end
 
     it "should call Selinux.matchpathcon_fini in case Selinux is enabled ", :if => Puppet.features.posix? do
-      selinux = double('selinux', is_selinux_enabled: true, matchpathcon_fini: nil)
-      stub_const('Selinux', selinux)
+      unless defined?(Selinux)
+        module Selinux
+          def self.is_selinux_enabled
+            true
+          end
+        end
+      end
 
       resource = Puppet::Type.type(:file).new(:path => make_absolute("/tmp/foo"))
       transaction = transaction_with_resource(resource)
@@ -836,6 +794,7 @@ describe Puppet::Transaction do
       before do
         @resource = Puppet::Type.type(:notify).new :title => "foobar"
         @catalog.add_resource @resource
+        allow(@transaction).to receive(:add_dynamically_generated_resources)
       end
 
       it 'should stop processing if :stop_processing? is true' do

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