puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

data/spec/unit/settings/environment_conf_spec.rb

@@ -39,6 +39,19 @@ describe Puppet::Settings::EnvironmentConf do
       expect(envconf.environment_timeout).to eq(180)
     end
 
+    it "reads a static_catalogs from config" do
+      setup_environment_conf(config, :static_catalogs => true)
+
+      expect(envconf.static_catalogs).to eq(true)
+    end
+
+    it "can retrieve untruthy settings" do
+      Puppet[:static_catalogs] = true
+      setup_environment_conf(config, :static_catalogs => false)
+
+      expect(envconf.static_catalogs).to eq(false)
+    end
+
     it "can retrieve raw settings" do
       setup_environment_conf(config, :manifest => 'manifest.pp')
 
@@ -64,10 +77,14 @@ describe Puppet::Settings::EnvironmentConf do
       expect(envconf.config_version).to be_nil
     end
 
-    it "returns a defult of 0 for environment_timeout when config has none" do
+    it "returns a default of 0 for environment_timeout when config has none" do
       expect(envconf.environment_timeout).to eq(0)
     end
 
+    it "returns default of true for static_catalogs when config has none" do
+      expect(envconf.static_catalogs).to eq(true)
+    end
+
     it "can still retrieve raw setting" do
       expect(envconf.raw_setting(:manifest)).to be_nil
     end

data/spec/unit/ssl/certificate_revocation_list_spec.rb

@@ -105,14 +105,14 @@ describe Puppet::SSL::CertificateRevocationList do
     end
 
     it "returns the last update time in UTC" do
-      # http://tools.ietf.org/html/rfc5280#section-5.1.2.4
+      # https://tools.ietf.org/html/rfc5280#section-5.1.2.4
       thisUpdate = @crl.generate(@cert, @key).last_update
       expect(thisUpdate).to be_utc
       expects_time_close_to_now(thisUpdate)
     end
 
     it "returns the next update time in UTC 5 years from now" do
-      # http://tools.ietf.org/html/rfc5280#section-5.1.2.5
+      # https://tools.ietf.org/html/rfc5280#section-5.1.2.5
       nextUpdate = @crl.generate(@cert, @key).next_update
       expect(nextUpdate).to be_utc
       expects_time_close_to_five_years(nextUpdate)
@@ -179,7 +179,7 @@ describe Puppet::SSL::CertificateRevocationList do
     end
 
     it "adds a non-critical CRL reason specifying key compromise by default" do
-      # http://tools.ietf.org/html/rfc5280#section-5.3.1
+      # https://tools.ietf.org/html/rfc5280#section-5.3.1
       serial = 1
       @crl.revoke(serial, @key)
 

data/spec/unit/transaction/report_spec.rb

@@ -52,6 +52,24 @@ 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 take 'environment' as an argument" do
     expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").environment).to eq("some environment")
   end
@@ -419,6 +437,9 @@ describe Puppet::Transaction::Report do
     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)
@@ -485,6 +506,9 @@ 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.add_resource_status(status)
     report.finalize_report
     report
@@ -498,6 +522,9 @@ 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.add_resource_status(status)
     report.finalize_report
     report

data/spec/unit/transaction/resource_harness_spec.rb

@@ -418,53 +418,6 @@ 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 "when determining whether the resource can be changed" do
-    before do
-      @resource.stubs(:purging?).returns true
-      @resource.stubs(:deleting?).returns true
-    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 "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 "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 "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)
-    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)
-    end
-  end
-
   describe "when finding the schedule" do
     before do
       @catalog = Puppet::Resource::Catalog.new

data/spec/unit/transaction_spec.rb

@@ -365,6 +365,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)

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

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

@@ -0,0 +1,286 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums => true do
+  include PuppetSpec::Files
+  include_context 'with supported checksum types'
+
+  let(:path) { tmpfile('foo_bar') }
+  let(:source_file) { file_containing('temp_foo', 'nothing at all') }
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:catalog) { Puppet::Resource::Catalog.new(:test, environment) }
+  let(:resource) { Puppet::Type.type(:file).new(:path => path, :catalog => catalog) }
+
+  it "should be a property" do
+    expect(described_class.superclass).to eq(Puppet::Property)
+  end
+
+  describe "when retrieving the current checksum_value" do
+    let(:checksum_value) { described_class.new(:resource => resource) }
+
+    it "should not compute a checksum if source is absent" do
+      resource.expects(:stat).never
+      expect(checksum_value.retrieve).to be_nil
+    end
+
+    describe "when using a source" do
+      before do
+        resource[:source] = source_file
+      end
+
+      it "should return :absent if the target does not exist" do
+        resource.expects(:stat).returns nil
+
+        expect(checksum_value.retrieve).to eq(:absent)
+      end
+
+      it "should not manage content on directories" do
+        stat = mock 'stat', :ftype => "directory"
+        resource.expects(:stat).returns stat
+
+        expect(checksum_value.retrieve).to be_nil
+      end
+
+      it "should not manage content on links" do
+        stat = mock 'stat', :ftype => "link"
+        resource.expects(:stat).returns stat
+
+        expect(checksum_value.retrieve).to be_nil
+      end
+
+      it "should always return the checksum as a string" do
+        resource[:checksum] = :mtime
+
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
+
+        time = Time.now
+        resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
+
+        expect(checksum_value.retrieve).to eq(time.to_s)
+      end
+    end
+
+    with_digest_algorithms do
+      it "should return the checksum of the target if it exists and is a normal file" do
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
+        resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
+        resource[:source] = source_file
+
+        expect(checksum_value.retrieve).to eq("mysum")
+      end
+    end
+  end
+
+  describe "when testing whether the checksum_value is in sync" do
+    let(:checksum_value) { described_class.new(:resource => resource) }
+
+    before do
+      resource[:ensure] = :file
+    end
+
+    it "should return true if source is not specified" do
+      checksum_value.should = "foo"
+      expect(checksum_value).to be_safe_insync("whatever")
+    end
+
+    describe "when a source is provided" do
+      before do
+        resource[:source] = source_file
+      end
+
+      with_digest_algorithms do
+        before(:each) do
+          resource[:checksum] = digest_algorithm
+        end
+
+        it "should return true if the resource shouldn't be a regular file" do
+          resource.expects(:should_be_file?).returns false
+          checksum_value.should = "foo"
+          expect(checksum_value).to be_safe_insync("whatever")
+        end
+
+        it "should return false if the current checksum_value is :absent" do
+          checksum_value.should = "foo"
+          expect(checksum_value).not_to be_safe_insync(:absent)
+        end
+
+        it "should return false if the file should be a file but is not present" do
+          resource.expects(:should_be_file?).returns true
+          checksum_value.should = "foo"
+
+          expect(checksum_value).not_to be_safe_insync(:absent)
+        end
+
+        describe "and the file exists" do
+          before do
+            resource.stubs(:stat).returns mock("stat")
+            checksum_value.should = "somechecksum"
+          end
+
+          it "should return false if the current checksum_value is different from the desired checksum_value" do
+            expect(checksum_value).not_to be_safe_insync("otherchecksum")
+          end
+
+          it "should return true if the current checksum_value is the same as the desired checksum_value" do
+            expect(checksum_value).to be_safe_insync("somechecksum")
+          end
+
+          it "should include the diff module" do
+            expect(checksum_value.respond_to?("diff")).to eq(false)
+          end
+
+          [true, false].product([true, false]).each do |cfg, param|
+            describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
+              before do
+                Puppet[:show_diff] = cfg
+                resource.stubs(:show_diff?).returns param
+                resource[:loglevel] = "debug"
+              end
+
+              if cfg and param
+                it "should display a diff" do
+                  checksum_value.expects(:diff).returns("my diff").once
+                  checksum_value.expects(:debug).with("\nmy diff").once
+                  expect(checksum_value).not_to be_safe_insync("otherchecksum")
+                end
+              else
+                it "should not display a diff" do
+                  checksum_value.expects(:diff).never
+                  expect(checksum_value).not_to be_safe_insync("otherchecksum")
+                end
+              end
+            end
+          end
+        end
+      end
+
+      let(:saved_time) { Time.now }
+      [:ctime, :mtime].each do |time_stat|
+        [["older", -1, false], ["same", 0, true], ["newer", 1, true]].each do
+          |compare, target_time, success|
+          describe "with #{compare} target #{time_stat} compared to source" do
+            before do
+              resource[:checksum] = time_stat
+              checksum_value.should = saved_time.to_s
+            end
+
+            it "should return #{success}" do
+              if success
+                expect(checksum_value).to be_safe_insync((saved_time+target_time).to_s)
+              else
+                expect(checksum_value).not_to be_safe_insync((saved_time+target_time).to_s)
+              end
+            end
+          end
+        end
+
+        describe "with #{time_stat}" do
+          before do
+            resource[:checksum] = time_stat
+          end
+
+          it "should not be insync if trying to create it" do
+            checksum_value.should = saved_time.to_s
+            expect(checksum_value).not_to be_safe_insync(:absent)
+          end
+
+          it "should raise an error if checksum_value is not a checksum" do
+            checksum_value.should = "some content"
+            expect {
+              checksum_value.safe_insync?(saved_time.to_s)
+            }.to raise_error(/Resource with checksum_type #{time_stat} didn't contain a date in/)
+          end
+
+          it "should not be insync even if checksum_value is the absent symbol" do
+            checksum_value.should = :absent
+            expect(checksum_value).not_to be_safe_insync(:absent)
+          end
+        end
+      end
+
+      describe "and :replace is false" do
+        before do
+          resource.stubs(:replace?).returns false
+        end
+
+        it "should be insync if the file exists and the checksum_value is different" do
+          resource.stubs(:stat).returns mock('stat')
+
+          expect(checksum_value).to be_safe_insync("whatever")
+        end
+
+        it "should be insync if the file exists and the checksum_value is right" do
+          resource.stubs(:stat).returns mock('stat')
+
+          expect(checksum_value).to be_safe_insync("something")
+        end
+
+        it "should not be insync if the file does not exist" do
+          checksum_value.should = "foo"
+          expect(checksum_value).not_to be_safe_insync(:absent)
+        end
+      end
+    end
+  end
+
+  describe "when testing whether the checksum_value is initialized in the resource and in sync" do
+    CHECKSUM_TYPES_TO_TRY.each do |checksum_type, checksum|
+      describe "sync with checksum type #{checksum_type} and the file exists" do
+        before do
+          @new_resource = Puppet::Type.type(:file).new :ensure => :file, :path => path, :catalog => catalog,
+            :checksum_value => checksum, :checksum => checksum_type, :source => source_file
+          @new_resource.stubs(:stat).returns mock('stat')
+        end
+
+        it "should return false if the current checksum_value is different from the desired checksum_value" do
+          expect(@new_resource.parameters[:checksum_value]).not_to be_safe_insync("abcdef")
+        end
+
+        it "should return true if the current checksum_value is the same as the desired checksum_value" do
+          expect(@new_resource.parameters[:checksum_value]).to be_safe_insync(checksum)
+        end
+      end
+    end
+  end
+
+  describe "when changing the checksum_value" do
+    let(:checksum_value) { described_class.new(:resource => resource) }
+
+    before do
+      resource.stubs(:[]).with(:path).returns "/boo"
+      resource.stubs(:stat).returns "eh"
+    end
+
+    it "should raise if source is absent" do
+      resource.expects(:write).never
+
+      expect { checksum_value.sync }.to raise_error "checksum_value#sync should not be called without a source parameter"
+    end
+
+    describe "when using a source" do
+      before do
+        resource[:source] = source_file
+      end
+
+      it "should use the file's :write method to write the checksum_value" do
+        resource.expects(:write).with(resource.parameter(:source))
+
+        checksum_value.sync
+      end
+
+      it "should return :file_changed if the file already existed" do
+        resource.expects(:stat).returns "something"
+        resource.stubs(:write)
+        expect(checksum_value.sync).to eq(:file_changed)
+      end
+
+      it "should return :file_created if the file did not exist" do
+        resource.expects(:stat).returns nil
+        resource.stubs(:write)
+        expect(checksum_value.sync).to eq(:file_created)
+      end
+    end
+  end
+end