puppet 4.1.0 → 4.10.0

data/spec/unit/transaction/report_spec.rb

@@ -52,6 +52,42 @@ describe Puppet::Transaction::Report do
     expect(report.transaction_uuid).to eq("some transaction uuid")
   end
 
+  it "should be able to set code_id" do
+    report = Puppet::Transaction::Report.new("inspect")
+    report.code_id = "some code id"
+    expect(report.code_id).to eq("some code id")
+  end
+
+  it "should be able to set catalog_uuid" do
+    report = Puppet::Transaction::Report.new("inspect")
+    report.catalog_uuid = "some catalog uuid"
+    expect(report.catalog_uuid).to eq("some catalog uuid")
+  end
+
+  it "should be able to set cached_catalog_status" do
+    report = Puppet::Transaction::Report.new("inspect")
+    report.cached_catalog_status = "explicitly_requested"
+    expect(report.cached_catalog_status).to eq("explicitly_requested")
+  end
+
+  it "should set noop to true if Puppet[:noop] is true" do
+    Puppet[:noop] = true
+    report = Puppet::Transaction::Report.new("apply")
+    expect(report.noop).to be_truthy
+  end
+
+  it "should set noop to false if Puppet[:noop] is false" do
+    Puppet[:noop] = false
+    report = Puppet::Transaction::Report.new("apply")
+    expect(report.noop).to be_falsey
+  end
+
+  it "should set noop to false if Puppet[:noop] is unset" do
+    Puppet[:noop] = nil
+    report = Puppet::Transaction::Report.new("apply")
+    expect(report.noop).to be_falsey
+  end
+
   it "should take 'environment' as an argument" do
     expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").environment).to eq("some environment")
   end
@@ -62,6 +98,17 @@ describe Puppet::Transaction::Report do
     expect(report.environment).to eq("some environment")
   end
 
+  it "should be able to set resources_failed_to_generate" do
+    report = Puppet::Transaction::Report.new("apply")
+    report.resources_failed_to_generate = true
+    expect(report.resources_failed_to_generate).to be_truthy
+  end
+
+  it "resources_failed_to_generate should not be true by default" do
+    report = Puppet::Transaction::Report.new("apply")
+    expect(report.resources_failed_to_generate).to be_falsey
+  end
+
   it "should not include whits" do
     Puppet::FileBucket::File.indirection.stubs(:save)
 
@@ -200,7 +247,6 @@ describe Puppet::Transaction::Report do
       end
     end
 
-
     [:time, :resources, :changes, :events].each do |type|
       it "should add #{type} metrics" do
         @report.finalize_report
@@ -235,6 +281,12 @@ describe Puppet::Transaction::Report do
         @report.finalize_report
         expect(@report.status).to eq('failed')
       end
+
+      it "should mark the report as 'failed' if resources_failed_to_generate" do
+        @report.resources_failed_to_generate = true
+        @report.finalize_report
+        expect(@report.status).to eq('failed')
+      end
     end
 
     describe "for changes" do
@@ -316,6 +368,50 @@ describe Puppet::Transaction::Report do
         end
       end
     end
+
+    describe "for noop events" do
+      it "should have 'noop_pending == false' when no events are available" do
+        add_statuses(3)
+        @report.finalize_report
+        expect(@report.noop_pending).to be_falsey
+      end
+
+      it "should have 'noop_pending == false' when no 'noop' events are available" do
+        add_statuses(3) do |status|
+          ['success', 'audit'].each do |status_name|
+            event = Puppet::Transaction::Event.new
+            event.status = status_name
+            status.add_event(event)
+          end
+        end
+        @report.finalize_report
+        expect(@report.noop_pending).to be_falsey
+      end
+
+      it "should have 'noop_pending == true' when 'noop' events are available" do
+        add_statuses(3) do |status|
+          ['success', 'audit', 'noop'].each do |status_name|
+            event = Puppet::Transaction::Event.new
+            event.status = status_name
+            status.add_event(event)
+          end
+        end
+        @report.finalize_report
+        expect(@report.noop_pending).to be_truthy
+      end
+
+      it "should have 'noop_pending == true' when 'noop' and 'failure' events are available" do
+        add_statuses(3) do |status|
+          ['success', 'failure', 'audit', 'noop'].each do |status_name|
+            event = Puppet::Transaction::Event.new
+            event.status = status_name
+            status.add_event(event)
+          end
+        end
+        @report.finalize_report
+        expect(@report.noop_pending).to be_truthy
+      end
+    end
   end
 
   describe "when producing a summary" do
@@ -376,6 +472,12 @@ describe Puppet::Transaction::Report do
       report.add_times('config_retrieval', 1.0)
       expect(report.to_yaml_properties).not_to include('@external_times')
     end
+
+    it "should not include @resources_failed_to_generate" do
+      report = Puppet::Transaction::Report.new("apply")
+      report.resources_failed_to_generate = true
+      expect(report.to_yaml_properties).not_to include('@resources_failed_to_generate')
+    end
   end
 
   it "defaults to serializing to pson" do
@@ -404,11 +506,24 @@ describe Puppet::Transaction::Report do
     expect(error_report.render).to validate_against('api/schemas/report.json')
   end
 
+  it "can make a round trip through yaml" do
+    report = generate_report
+
+    yaml_output = report.render(:yaml)
+    tripped = Puppet::Transaction::Report.convert_from(:yaml, yaml_output)
+
+    expect(yaml_output).to match(/^--- /)
+    expect_equivalent_reports(tripped, report)
+  end
+
   def expect_equivalent_reports(tripped, report)
     expect(tripped.host).to eq(report.host)
     expect(tripped.time.to_i).to eq(report.time.to_i)
     expect(tripped.configuration_version).to eq(report.configuration_version)
     expect(tripped.transaction_uuid).to eq(report.transaction_uuid)
+    expect(tripped.code_id).to eq(report.code_id)
+    expect(tripped.catalog_uuid).to eq(report.catalog_uuid)
+    expect(tripped.cached_catalog_status).to eq(report.cached_catalog_status)
     expect(tripped.report_format).to eq(report.report_format)
     expect(tripped.puppet_version).to eq(report.puppet_version)
     expect(tripped.kind).to eq(report.kind)
@@ -451,17 +566,34 @@ describe Puppet::Transaction::Report do
       expect(status.skipped).to eq(expected.skipped)
       expect(status.change_count).to eq(expected.change_count)
       expect(status.out_of_sync_count).to eq(expected.out_of_sync_count)
-      expect(status.events).to eq(expected.events)
+      expect(status.events.map(&:to_data_hash)).to eq(expected.events.map(&:to_data_hash))
     end
   end
 
   def generate_report
+    event_hash = {
+      :audited => false,
+      :property => 'message',
+      :previous_value => 'absent',
+      :desired_value => 'a resource',
+      :historical_value => nil,
+      :message => "defined 'message' as 'a resource'",
+      :name => :message_changed,
+      :status => 'success',
+    }
+    event = Puppet::Transaction::Event.new(event_hash)
+
     status = Puppet::Resource::Status.new(Puppet::Type.type(:notify).new(:title => "a resource"))
     status.changed = true
+    status.add_event(event)
 
     report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
     report.add_times("timing", 4)
+    report.code_id = "some code id"
+    report.catalog_uuid = "some catalog uuid"
+    report.cached_catalog_status = "not_used"
+    report.master_used = "test:000"
     report.add_resource_status(status)
     report.finalize_report
     report
@@ -475,6 +607,10 @@ describe Puppet::Transaction::Report do
     report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
     report.add_times("timing", 4)
+    report.code_id = "some code id"
+    report.catalog_uuid = "some catalog uuid"
+    report.cached_catalog_status = "not_used"
+    report.master_used = "test:000"
     report.add_resource_status(status)
     report.finalize_report
     report

data/spec/unit/transaction/resource_harness_spec.rb

@@ -418,50 +418,94 @@ describe Puppet::Transaction::ResourceHarness do
     end
   end
 
-  describe "when applying changes" do
-    it "should not apply changes if allow_changes?() returns false" do
-      test_file = tmpfile('foo')
-      resource = Puppet::Type.type(:file).new :path => test_file, :backup => false, :ensure => :file
-      resource.expects(:err).never # make sure no exceptions get swallowed
-      @harness.expects(:allow_changes?).with(resource).returns false
-      status = @harness.evaluate(resource)
-      expect(Puppet::FileSystem.exist?(test_file)).to eq(false)
-    end
-  end
+  describe "handling sensitive properties" do
+    describe 'when syncing' do
+      let(:test_file) do
+        tmpfile('foo').tap do |path|
+          File.open(path, 'w') { |fh| fh.write("goodbye world") }
+        end
+      end
 
-  describe "when determining whether the resource can be changed" do
-    before do
-      @resource.stubs(:purging?).returns true
-      @resource.stubs(:deleting?).returns true
-    end
+      let(:resource) do
+        Puppet::Type.type(:file).new(:path => test_file, :backup => false, :content => "hello world").tap do |r|
+          r.parameter(:content).sensitive = true
+        end
+      end
 
-    it "should be true if the resource is not being purged" do
-      @resource.expects(:purging?).returns false
-      expect(@harness).to be_allow_changes(@resource)
-    end
+      it "redacts event messages for sensitive properties" do
+        status = @harness.evaluate(resource)
+        sync_event = status.events[0]
+        expect(sync_event.message).to eq 'changed [redacted] to [redacted]'
+      end
 
-    it "should be true if the resource is not being deleted" do
-      @resource.expects(:deleting?).returns false
-      expect(@harness).to be_allow_changes(@resource)
-    end
+      it "redacts event contents for sensitive properties" do
+        status = @harness.evaluate(resource)
+        sync_event = status.events[0]
+        expect(sync_event.previous_value).to eq '[redacted]'
+        expect(sync_event.desired_value).to eq '[redacted]'
+      end
 
-    it "should be true if the resource has no dependents" do
-      @harness.relationship_graph.expects(:dependents).with(@resource).returns []
-      expect(@harness).to be_allow_changes(@resource)
-    end
+      it "redacts event messages for sensitive properties when simulating noop changes" do
+        resource[:noop] = true
+        status = @harness.evaluate(resource)
+        sync_event = status.events[0]
+        expect(sync_event.message).to eq 'current_value [redacted], should be [redacted] (noop)'
+      end
 
-    it "should be true if all dependents are being deleted" do
-      dep = stub 'dependent', :deleting? => true
-      @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
-      @resource.expects(:purging?).returns true
-      expect(@harness).to be_allow_changes(@resource)
+      describe 'auditing' do
+        before do
+          resource[:audit] = ['content']
+        end
+
+        it "redacts notices when a parameter is newly audited" do
+          resource.property(:content).expects(:notice).with("audit change: newly-recorded value [redacted]")
+          @harness.evaluate(resource)
+        end
+
+        it "redacts event messages for sensitive properties" do
+          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
+          Puppet::Util::Storage.stubs(:cache).with(resource).returns({:content => "historical world"})
+          resource[:noop] = true
+          status = @harness.evaluate(resource)
+          sync_event = status.events[0]
+          expect(sync_event.message).to eq 'current_value [redacted], should be [redacted] (noop) (previously recorded value was [redacted])'
+        end
+
+        it "redacts event contents for sensitive properties" do
+          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]'
+        end
+      end
     end
 
-    it "should be false if the resource's dependents are not being deleted" do
-      dep = stub 'dependent', :deleting? => false, :ref => "myres"
-      @resource.expects(:warning)
-      @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
-      expect(@harness).not_to be_allow_changes(@resource)
+    describe 'handling errors' do
+      it "redacts event messages generated when syncing a param raises a StandardError" do
+        stub_provider = make_stub_provider
+        resource = stub_provider.new :name => 'name', :bar => 1
+        resource.parameter(:bar).sensitive = true
+        status = @harness.evaluate(resource)
+
+        error_event = status.events[0]
+        expect(error_event.message).to eq "change from [redacted] to [redacted] failed: bar"
+      end
+
+      it "redacts event messages generated when syncing a param raises an Exception" do
+        stub_provider = make_stub_provider
+        resource = stub_provider.new :name => 'name', :baz => 1
+        resource.parameter(:baz).sensitive = true
+
+        expect { @harness.evaluate(resource) }.to raise_error(Exception, 'baz')
+
+        expect(@logs.first.message).to eq "change from [redacted] to [redacted] failed: baz"
+      end
     end
   end
 

data/spec/unit/transaction_spec.rb

@@ -327,6 +327,44 @@ describe Puppet::Transaction do
     end
   end
 
+  describe "after resource traversal" do
+    let(:catalog) { Puppet::Resource::Catalog.new }
+    let(:prioritizer) { Puppet::Graph::RandomPrioritizer.new }
+    let(:report) { Puppet::Transaction::Report.new("apply") }
+    let(:transaction) { Puppet::Transaction.new(catalog, report, prioritizer) }
+    let(:generator) { Puppet::Transaction::AdditionalResourceGenerator.new(catalog, nil, prioritizer) }
+
+    before :each do
+      generator = Puppet::Transaction::AdditionalResourceGenerator.new(catalog, nil, prioritizer)
+      Puppet::Transaction::AdditionalResourceGenerator.stubs(:new).returns(generator)
+    end
+
+    it "should should query the generator for whether resources failed to generate" do
+      relationship_graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
+      catalog.stubs(:relationship_graph).returns(relationship_graph)
+
+      sequence = sequence(:traverse_first)
+      relationship_graph.expects(:traverse).in_sequence(sequence)
+      generator.expects(:resources_failed_to_generate).in_sequence(sequence)
+
+      transaction.evaluate
+    end
+
+    it "should report that resources failed to generate" do
+      generator.expects(:resources_failed_to_generate).returns(true)
+      report.expects(:resources_failed_to_generate=).with(true)
+
+      transaction.evaluate
+    end
+
+    it "should not report that resources failed to generate if none did" do
+      generator.expects(:resources_failed_to_generate).returns(false)
+      report.expects(:resources_failed_to_generate=).never
+
+      transaction.evaluate
+    end
+  end
+
   describe "when performing pre-run checks" do
     let(:resource) { Puppet::Type.type(:notify).new(:title => "spec") }
     let(:transaction) { transaction_with_resource(resource) }
@@ -365,6 +403,11 @@ describe Puppet::Transaction do
       expect(@transaction).to be_skip(@resource)
     end
 
+    it "should skip resources tagged with the skip tags" do
+      @transaction.stubs(:skip_tags?).returns(true)
+      expect(@transaction).to be_skip(@resource)
+    end
+
     it "should skip unscheduled resources" do
       @transaction.stubs(:scheduled?).returns(false)
       expect(@transaction).to be_skip(@resource)
@@ -721,6 +764,13 @@ describe Puppet::Transaction, " when determining tags" do
     expect(@transaction).to be_tagged("one::two")
   end
 
+  it "should tag one::two only as 'one::two' and not 'one', 'two', and 'one::two'" do
+    @transaction.tags = "one::two"
+    expect(@transaction).to be_tagged("one::two")
+    expect(@transaction).to_not be_tagged("one")
+    expect(@transaction).to_not be_tagged("two")
+  end
+
   it "should accept a comma-delimited string" do
     @transaction.tags = "one, two"
     expect(@transaction).to be_tagged("one")

data/spec/unit/type/exec_spec.rb

@@ -67,7 +67,12 @@ describe Puppet::Type.type(:exec) do
 
       it "should report a failure" do
         expect { exec_tester('false', 1).refresh }.
-          to raise_error(Puppet::Error, /^false returned 1 instead of/)
+          to raise_error(Puppet::Error, /^'false' returned 1 instead of/)
+      end
+
+      it "should redact sensitive commands on failure" do
+        expect { exec_tester('false', 1, :sensitive_parameters => [:command]).refresh }.
+            to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
       end
 
       it "should not report a failure if the exit status is specified in a returns array" do
@@ -76,7 +81,12 @@ describe Puppet::Type.type(:exec) do
 
       it "should report a failure if the exit status is not specified in a returns array" do
         expect { exec_tester('false', 1, :returns => [0, 100]).refresh }.
-          to raise_error(Puppet::Error, /^false returned 1 instead of/)
+          to raise_error(Puppet::Error, /^'false' returned 1 instead of/)
+      end
+
+      it "should report redact sensitive commands if the exit status is not specified in a returns array" do
+        expect { exec_tester('false', 1, :returns => [0, 100], :sensitive_parameters => [:command]).refresh }.
+            to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
       end
 
       it "should log the output on success" do
@@ -106,7 +116,19 @@ describe Puppet::Type.type(:exec) do
       it "should log the output on failure" do
         output = "output1\noutput2\n"
         expect { exec_tester('false', 1, :output => output, :logoutput => :on_failure).refresh }.
-          to raise_error(Puppet::Error, /^false returned 1 instead of/)
+          to raise_error(Puppet::Error, /^'false' returned 1 instead of/)
+
+        output.split("\n").each do |line|
+          log = @logs.shift
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
+        end
+      end
+
+      it "should redact the command on failure" do
+        output = "output1\noutput2\n"
+        expect { exec_tester('false', 1, :output => output, :logoutput => :on_failure, :sensitive_parameters => [:command]).refresh }.
+            to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
 
         output.split("\n").each do |line|
           log = @logs.shift
@@ -121,7 +143,22 @@ describe Puppet::Type.type(:exec) do
         expect {
           exec_tester('false', 1, :output => output, :returns => [0, 100],
                :logoutput => :on_failure).refresh
-        }.to raise_error(Puppet::Error, /^false returned 1 instead of/)
+        }.to raise_error(Puppet::Error, /^'false' returned 1 instead of/)
+
+        output.split("\n").each do |line|
+          log = @logs.shift
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
+        end
+      end
+
+      it "should redact the command on failure when returns is specified as an array" do
+        output = "output1\noutput2\n"
+
+        expect {
+          exec_tester('false', 1, :output => output, :returns => [0, 100],
+                      :logoutput => :on_failure, :sensitive_parameters => [:command]).refresh
+        }.to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
 
         output.split("\n").each do |line|
           log = @logs.shift
@@ -396,16 +433,24 @@ describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should fail if timeout is exceeded" do
-        ruby_path = Puppet::Util::Execution.ruby_path()
+      describe 'when timeout is exceeded' do
+        subject do
+          ruby_path = Puppet::Util::Execution.ruby_path()
+          Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 1'", :timeout => '0.1')
+        end
 
-        ## Leaving this commented version in here because it fails on windows, due to what appears to be
-        ##  an assumption about hash iteration order in lib/puppet/type.rb#hash2resource, where
-        ##  resource[]= will overwrite the namevar with ":name" if the iteration is in the wrong order
-        #sleep_exec = Puppet::Type.type(:exec).new(:name => 'exec_spec sleep command', :command => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
-        sleep_exec = Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
+        context 'on POSIX', :unless => Puppet.features.microsoft_windows? do
+          it 'sends a SIGTERM and raises a Puppet::Error' do
+            Process.expects(:kill).at_least_once
+            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+          end
+        end
 
-        expect { sleep_exec.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+        context 'on Windows', :if => Puppet.features.microsoft_windows? do
+          it 'raises a Puppet::Error' do
+            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+          end
+        end
       end
 
       it "should convert timeout to a float" do

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

@@ -76,4 +76,10 @@ describe checksum do
       expect(sum).to eq("something")
     end
   end
+
+  it 'should use values allowed by the supported_checksum_types setting' do
+    values = checksum.value_collection.values.reject {|v| v == :none}.map {|v| v.to_s}
+    Puppet.settings[:supported_checksum_types] = values
+    expect(Puppet.settings[:supported_checksum_types]).to eq(values)
+  end
 end