puppet 5.5.22 → 6.0.0

data/spec/unit/transaction/persistence_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'yaml'
@@ -13,7 +14,7 @@ describe Puppet::Transaction::Persistence do
 
   describe "when loading from file" do
     before do
-      allow(Puppet.settings).to receive(:use).and_return(true)
+      Puppet.settings.stubs(:use).returns(true)
     end
 
     describe "when the file/directory does not exist" do
@@ -47,7 +48,7 @@ describe Puppet::Transaction::Persistence do
         property = "my"
         value = "something"
 
-        expect(Puppet).not_to receive(:err)
+        Puppet.expects(:err).never
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.set_system_value(resource, property, value)
@@ -61,7 +62,7 @@ describe Puppet::Transaction::Persistence do
         test_yaml = {"resources"=>{"a"=>"b"}}
         write_state_file(test_yaml.to_yaml)
 
-        expect(Puppet).not_to receive(:err)
+        Puppet.expects(:err).never
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -72,7 +73,7 @@ describe Puppet::Transaction::Persistence do
       it "should initialize with a clear internal state if the file does not contain valid YAML" do
         write_state_file('{ invalid')
 
-        expect(Puppet).to receive(:err).with(/Transaction store file .* is corrupt/)
+        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -83,7 +84,7 @@ describe Puppet::Transaction::Persistence do
       it "should initialize with a clear internal state if the file does not contain a hash of data" do
         write_state_file("not_a_hash")
 
-        expect(Puppet).to receive(:err).with(/Transaction store file .* is valid YAML but not returning a hash/)
+        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is valid YAML but not returning a hash/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -94,10 +95,10 @@ describe Puppet::Transaction::Persistence do
       it "should raise an error if the file does not contain valid YAML and cannot be renamed" do
         write_state_file('{ invalid')
 
-        expect(File).to receive(:rename).and_raise(SystemCallError)
+        File.expects(:rename).raises(SystemCallError)
 
-        expect(Puppet).to receive(:err).with(/Transaction store file .* is corrupt/)
-        expect(Puppet).to receive(:err).with(/Unable to rename/)
+        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
+        Puppet.expects(:err).with(regexp_matches(/Unable to rename/))
 
         persistence = Puppet::Transaction::Persistence.new
         expect { persistence.load }.to raise_error(Puppet::Error, /Could not rename/)
@@ -106,9 +107,9 @@ describe Puppet::Transaction::Persistence do
       it "should attempt to rename the file if the file is corrupted" do
         write_state_file('{ invalid')
 
-        expect(File).to receive(:rename).at_least(:once)
+        File.expects(:rename).at_least_once
 
-        expect(Puppet).to receive(:err).with(/Transaction store file .* is corrupt/)
+        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -118,7 +119,7 @@ describe Puppet::Transaction::Persistence do
         FileUtils.rm_f(@tmpfile)
         Dir.mkdir(@tmpfile)
 
-        expect(Puppet).to receive(:warning).with(/Transaction store file .* is not a file/)
+        Puppet.expects(:warning).with(regexp_matches(/Transaction store file .* is not a file/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -146,7 +147,7 @@ describe Puppet::Transaction::Persistence do
       Dir.mkdir(Puppet[:transactionstorefile])
       persistence = Puppet::Transaction::Persistence.new
 
-      if Puppet.features.microsoft_windows?
+      if Puppet::Util::Platform.windows?
         expect do
           persistence.save
         end.to raise_error do |error|
@@ -177,7 +178,7 @@ describe Puppet::Transaction::Persistence do
 
   describe "when checking if persistence is enabled" do
     let(:mock_catalog) do
-      double()
+      mock
     end
 
     let (:persistence) do
@@ -194,25 +195,25 @@ describe Puppet::Transaction::Persistence do
 
     it "should not be enabled when not running in agent mode" do
       Puppet.settings.preferred_run_mode = :user
-      allow(mock_catalog).to receive(:host_config?).and_return(true)
+      mock_catalog.stubs(:host_config?).returns(true)
       expect(persistence.enabled?(mock_catalog)).to be false
     end
 
     it "should not be enabled when the catalog is not the host catalog" do
       Puppet.settings.preferred_run_mode = :agent
-      allow(mock_catalog).to receive(:host_config?).and_return(false)
+      mock_catalog.stubs(:host_config?).returns(false)
       expect(persistence.enabled?(mock_catalog)).to be false
     end
 
     it "should not be enabled outside of agent mode and the catalog is not the host catalog" do
       Puppet.settings.preferred_run_mode = :user
-      allow(mock_catalog).to receive(:host_config?).and_return(false)
+      mock_catalog.stubs(:host_config?).returns(false)
       expect(persistence.enabled?(mock_catalog)).to be false
     end
 
     it "should be enabled in agent mode and when the catalog is the host catalog" do
       Puppet.settings.preferred_run_mode = :agent
-      allow(mock_catalog).to receive(:host_config?).and_return(true)
+      mock_catalog.stubs(:host_config?).returns(true)
       expect(persistence.enabled?(mock_catalog)).to be true
     end
   end

data/spec/unit/transaction/report_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet'
@@ -9,7 +10,7 @@ describe Puppet::Transaction::Report do
   include PuppetSpec::Files
 
   before do
-    allow(Puppet::Util::Storage).to receive(:store)
+    Puppet::Util::Storage.stubs(:store)
   end
 
   it "should set its host name to the node_name_value" do
@@ -23,7 +24,7 @@ describe Puppet::Transaction::Report do
   end
 
   it "should create an initialization timestamp" do
-    expect(Time).to receive(:now).and_return("mytime")
+    Time.expects(:now).returns "mytime"
     expect(Puppet::Transaction::Report.new.time).to eq("mytime")
   end
 
@@ -115,7 +116,7 @@ describe Puppet::Transaction::Report do
   end
 
   it "should not include whits" do
-    allow(Puppet::FileBucket::File.indirection).to receive(:save)
+    Puppet::FileBucket::File.indirection.stubs(:save)
 
     filename = tmpfile('whit_test')
     file = Puppet::Type.type(:file).new(:path => filename)
@@ -166,7 +167,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should add each status to its status list" do
-      status = double('status', :resource => "foo")
+      status = stub 'status', :resource => "foo"
       @report.add_resource_status status
       expect(@report.resource_statuses["foo"]).to equal(status)
     end
@@ -174,11 +175,11 @@ describe Puppet::Transaction::Report do
 
   describe "when using the indirector" do
     it "should redirect :save to the indirection" do
-      allow(Facter).to receive(:value).and_return("eh")
-      @indirection = double('indirection', :name => :report)
-      allow(Puppet::Transaction::Report).to receive(:indirection).and_return(@indirection)
+      Facter.stubs(:value).returns("eh")
+      @indirection = stub 'indirection', :name => :report
+      Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
       report = Puppet::Transaction::Report.new
-      expect(@indirection).to receive(:save)
+      @indirection.expects(:save)
       Puppet::Transaction::Report.indirection.save(report)
     end
 
@@ -188,7 +189,7 @@ describe Puppet::Transaction::Report do
 
     it "should delegate its name attribute to its host method" do
       report = Puppet::Transaction::Report.new
-      expect(report).to receive(:host).and_return("me")
+      report.expects(:host).returns "me"
       expect(report.name).to eq("me")
     end
   end
@@ -454,7 +455,7 @@ describe Puppet::Transaction::Report do
 
   describe "when producing a summary" do
     before do
-      allow(Benchmark).to receive(:realtime).and_return(5.05683418)
+      Benchmark.stubs(:realtime).returns(5.05683418)
       resource = Puppet::Type.type(:notify).new(:name => "testing")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
@@ -473,7 +474,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should include the last run time in the raw summary hash" do
-      allow(Time).to receive(:now).and_return(Time.utc(2010,11,10,12,0,24))
+      Time.stubs(:now).returns(Time.utc(2010,11,10,12,0,24))
       expect(@report.raw_summary["time"]["last_run"]).to eq(1289390424)
     end
 
@@ -644,16 +645,21 @@ Version:
   end
 
   def generate_report
+    # An Event cannot contain rich data - thus its "to_data_hash" stringifies the result.
+    # (This means it cannot be deserialized with intact data types).
+    # Here it is simulated that the values are after stringification.
+    stringifier = Puppet::Pops::Serialization::ToStringifiedConverter
     event_hash = {
       :audited => false,
-      :property => 'message',
-      :previous_value => SemanticPuppet::VersionRange.parse('>=1.0.0'),
-      :desired_value => SemanticPuppet::VersionRange.parse('>=1.2.0'),
-      :historical_value => nil,
-      :message => "defined 'message' as 'a resource'",
-      :name => :message_changed,
-      :status => 'success',
+      :property => stringifier.convert('message'),
+      :previous_value => stringifier.convert(SemanticPuppet::VersionRange.parse('>=1.0.0')),
+      :desired_value => stringifier.convert(SemanticPuppet::VersionRange.parse('>=1.2.0')),
+      :historical_value => stringifier.convert(nil),
+      :message => stringifier.convert("defined 'message' as 'a resource'"),
+      :name => :message_changed, # the name 
+      :status => stringifier.convert('success'),
     }
+
     event = Puppet::Transaction::Event.new(event_hash)
 
     status = Puppet::Resource::Status.new(Puppet::Type.type(:notify).new(:title => "a resource"))

data/spec/unit/transaction/resource_harness_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/transaction/resource_harness'
@@ -6,15 +7,15 @@ describe Puppet::Transaction::ResourceHarness do
   include PuppetSpec::Files
 
   before do
-    @mode_750 = Puppet.features.microsoft_windows? ? '644' : '750'
-    @mode_755 = Puppet.features.microsoft_windows? ? '644' : '755'
+    @mode_750 = Puppet::Util::Platform.windows? ? '644' : '750'
+    @mode_755 = Puppet::Util::Platform.windows? ? '644' : '755'
     path = make_absolute("/my/file")
 
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
     @resource = Puppet::Type.type(:file).new :path => path
     @harness = Puppet::Transaction::ResourceHarness.new(@transaction)
     @current_state = Puppet::Resource.new(:file, path)
-    allow(@resource).to receive(:retrieve).and_return(@current_state)
+    @resource.stubs(:retrieve).returns @current_state
   end
 
   it "should accept a transaction at initialization" do
@@ -23,7 +24,7 @@ describe Puppet::Transaction::ResourceHarness do
   end
 
   it "should delegate to the transaction for its relationship graph" do
-    expect(@transaction).to receive(:relationship_graph).and_return("relgraph")
+    @transaction.expects(:relationship_graph).returns "relgraph"
     expect(Puppet::Transaction::ResourceHarness.new(@transaction).relationship_graph).to eq("relgraph")
   end
 
@@ -37,14 +38,14 @@ describe Puppet::Transaction::ResourceHarness do
     end
 
     it "retrieves the current state of the resource" do
-      expect(@resource).to receive(:retrieve).and_return(@current_state)
+      @resource.expects(:retrieve).returns @current_state
 
       @harness.evaluate(@resource)
     end
 
     it "produces a failure status for the resource when an error occurs" do
       the_message = "retrieve failed in testing"
-      expect(@resource).to receive(:retrieve).and_raise(ArgumentError.new(the_message))
+      @resource.expects(:retrieve).raises(ArgumentError.new(the_message))
 
       status = @harness.evaluate(@resource)
 
@@ -172,10 +173,6 @@ describe Puppet::Transaction::ResourceHarness do
           def insync?(value)
             @resource.behaviors[:ensure_insync?]
           end
-
-          def should_to_s(value)
-            (@resource.behaviors[:on_should_to_s] || proc { "'#{value}'" }).call
-          end
         end
 
         newparam(:name) do
@@ -269,27 +266,13 @@ describe Puppet::Transaction::ResourceHarness do
 
       expect(status.events).to be_empty
     end
-
-    it "ensure errors in message still get a log entry" do
-      resource = an_ensurable_resource_reacting_as(:ensure_insync? => false, :on_ensure => proc { raise StandardError }, :on_should_to_s => proc { raise StandardError }, :present? => true)
-
-      status = @harness.evaluate(resource)
-
-      expect(status.events.length).to eq(2)
-      testing_errors = status.events.find_all { |x| x.name.to_s == "Testing_created" }
-      resource_errors = status.events.find_all { |x| x.name.to_s == "resource_error" }
-      expect(testing_errors.length).to eq(1)
-      expect(resource_errors.length).to eq(1)
-      expect(testing_errors[0].message).not_to be_nil
-      expect(resource_errors[0].message).not_to eq("Puppet::Util::Log requires a message")
-    end
   end
 
   describe "when a caught error occurs" do
     before :each do
       stub_provider = make_stub_provider
       resource = stub_provider.new :name => 'name', :foo => 1, :bar => 2
-      expect(resource).not_to receive(:err)
+      resource.expects(:err).never
       @status = @harness.evaluate(resource)
     end
 
@@ -308,7 +291,7 @@ describe Puppet::Transaction::ResourceHarness do
     before :each do
       stub_provider = make_stub_provider
       @resource = stub_provider.new :name => 'name', :baz => 1
-      expect(@resource).not_to receive(:err)
+      @resource.expects(:err).never
     end
 
     it "should log and pass the exception through" do
@@ -322,7 +305,7 @@ describe Puppet::Transaction::ResourceHarness do
     before :each do
       stub_provider = make_stub_provider
       @resource = stub_provider.new :name => 'name', :brillig => 1
-      expect(@resource).not_to receive(:err)
+      @resource.expects(:err).never
     end
 
     it "should record a failure event" do
@@ -337,7 +320,7 @@ describe Puppet::Transaction::ResourceHarness do
     before :each do
       stub_provider = make_stub_provider
       @resource = stub_provider.new :name => 'name', :slithy => 1
-      expect(@resource).not_to receive(:err)
+      @resource.expects(:err).never
     end
 
     it "should log and pass the exception through" do
@@ -351,7 +334,7 @@ describe Puppet::Transaction::ResourceHarness do
     it "should not call insync? on parameters that are merely audited" do
       stub_provider = make_stub_provider
       resource = stub_provider.new :name => 'name', :audit => ['foo']
-      expect(resource.property(:foo)).not_to receive(:insync?)
+      resource.property(:foo).expects(:insync?).never
       status = @harness.evaluate(resource)
 
       expect(status.events).to be_empty
@@ -361,7 +344,7 @@ describe Puppet::Transaction::ResourceHarness do
       test_file = tmpfile('foo')
       File.open(test_file, 'w').close
       resource = Puppet::Type.type(:file).new :path => test_file, :audit => ['group'], :backup => false
-      expect(resource).not_to receive(:err) # make sure no exceptions get swallowed
+      resource.expects(:err).never # make sure no exceptions get swallowed
 
       status = @harness.evaluate(resource)
 
@@ -387,9 +370,11 @@ describe Puppet::Transaction::ResourceHarness do
       # set up the sequence of stubs; yeah, this is pretty
       # brittle, so this might need to be adjusted if the
       # resource_harness logic changes
-      expect(resource).to receive(:retrieve).and_return(current_from_filesystem)
-      allow(Puppet::Util::Storage).to receive(:cache).with(resource).
-        and_return(historical_from_state_yaml, current_from_filesystem, current_from_filesystem)
+      resource.expects(:retrieve).returns(current_from_filesystem)
+      Puppet::Util::Storage.stubs(:cache).with(resource).
+        returns(historical_from_state_yaml).then.
+        returns(current_from_filesystem).then.
+        returns(current_from_filesystem)
 
       # there should be an audit change recorded, since the two
       # timestamps differ by at least 1 microsecond
@@ -418,9 +403,11 @@ describe Puppet::Transaction::ResourceHarness do
       # set up the sequence of stubs; yeah, this is pretty
       # brittle, so this might need to be adjusted if the
       # resource_harness logic changes
-      expect(resource).to receive(:retrieve).and_return(current_from_filesystem)
-      allow(Puppet::Util::Storage).to receive(:cache).with(resource).
-        and_return(historical_from_state_yaml, current_from_filesystem, current_from_filesystem)
+      resource.expects(:retrieve).returns(current_from_filesystem)
+      Puppet::Util::Storage.stubs(:cache).with(resource).
+        returns(historical_from_state_yaml).then.
+        returns(current_from_filesystem).then.
+        returns(current_from_filesystem)
 
       # there should be no audit change recorded, despite the
       # slight difference in the two timestamps
@@ -471,19 +458,19 @@ describe Puppet::Transaction::ResourceHarness do
         end
 
         it "redacts notices when a parameter is newly audited" do
-          expect(resource.property(:content)).to receive(:notice).with("audit change: newly-recorded value [redacted]")
+          resource.property(:content).expects(:notice).with("audit change: newly-recorded value [redacted]")
           @harness.evaluate(resource)
         end
 
         it "redacts event messages for sensitive properties" do
-          allow(Puppet::Util::Storage).to receive(:cache).with(resource).and_return({:content => "historical world"})
+          Puppet::Util::Storage.stubs(:cache).with(resource).returns({:content => "historical world"})
           status = @harness.evaluate(resource)
           sync_event = status.events[0]
           expect(sync_event.message).to eq 'changed [redacted] to [redacted] (previously recorded value was [redacted])'
         end
 
         it "redacts audit event messages for sensitive properties when simulating noop changes" do
-          allow(Puppet::Util::Storage).to receive(:cache).with(resource).and_return({:content => "historical world"})
+          Puppet::Util::Storage.stubs(:cache).with(resource).returns({:content => "historical world"})
           resource[:noop] = true
           status = @harness.evaluate(resource)
           sync_event = status.events[0]
@@ -491,7 +478,7 @@ describe Puppet::Transaction::ResourceHarness do
         end
 
         it "redacts event contents for sensitive properties" do
-          allow(Puppet::Util::Storage).to receive(:cache).with(resource).and_return({:content => "historical world"})
+          Puppet::Util::Storage.stubs(:cache).with(resource).returns({:content => "historical world"})
           status = @harness.evaluate(resource)
           sync_event = status.events[0]
           expect(sync_event.historical_value).to eq '[redacted]'
@@ -530,7 +517,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should warn and return nil if the resource has no catalog" do
       @resource.catalog = nil
-      expect(@resource).to receive(:warning)
+      @resource.expects(:warning)
 
       expect(@harness.schedule(@resource)).to be_nil
     end
@@ -541,7 +528,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should fail if the named schedule cannot be found" do
       @resource[:schedule] = "whatever"
-      expect(@resource).to receive(:fail)
+      @resource.expects(:fail)
       @harness.schedule(@resource)
     end
 
@@ -571,13 +558,13 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should return the result of matching the schedule with the cached 'checked' time if a schedule is set" do
       t = Time.now
-      expect(@harness).to receive(:cached).with(@resource, :checked).and_return(t)
+      @harness.expects(:cached).with(@resource, :checked).returns(t)
 
       sched = Puppet::Type.type(:schedule).new(:name => "sched")
       @catalog.add_resource(sched)
       @resource[:schedule] = "sched"
 
-      expect(sched).to receive(:match?).with(t.to_i).and_return("feh")
+      sched.expects(:match?).with(t.to_i).returns "feh"
 
       expect(@harness.scheduled?(@resource)).to eq("feh")
     end
@@ -585,7 +572,7 @@ describe Puppet::Transaction::ResourceHarness do
 
   it "should be able to cache data in the Storage module" do
     data = {}
-    expect(Puppet::Util::Storage).to receive(:cache).with(@resource).and_return(data)
+    Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     @harness.cache(@resource, :foo, "something")
 
     expect(data[:foo]).to eq("something")
@@ -593,33 +580,7 @@ describe Puppet::Transaction::ResourceHarness do
 
   it "should be able to retrieve data from the cache" do
     data = {:foo => "other"}
-    expect(Puppet::Util::Storage).to receive(:cache).with(@resource).and_return(data)
+    Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     expect(@harness.cached(@resource, :foo)).to eq("other")
   end
-
-  describe "successful event message" do
-    let(:test_file) do
-      tmpfile('foo').tap do |path|
-        File.open(path, 'w') { |fh| fh.write("old contents") }
-      end
-    end
-
-    let(:resource) do
-      Puppet::Type.type(:file).new(:path => test_file, :backup => false, :content => "hello world")
-    end
-
-    it "contains (corrective) when corrective change" 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\)/)
-    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]+'$/)
-    end
-  end
 end