puppet 4.3.0 → 4.4.0

data/spec/unit/resource/type_spec.rb

@@ -240,9 +240,26 @@ describe Puppet::Resource::Type do
   end
 
   describe "when setting its parameters in the scope" do
+    let(:parser) { Puppet::Pops::Parser::Parser.new() }
+
+    def wrap3x(expression)
+      Puppet::Parser::AST::PopsBridge::Expression.new(:value => expression.current)
+    end
+
+    def parse_expression(expr_string)
+      wrap3x(parser.parse_string(expr_string))
+    end
+
+    def number_expression(number)
+      wrap3x(Puppet::Pops::Model::Factory.NUMBER(number))
+    end
+
     def variable_expression(name)
-      varexpr = Puppet::Pops::Model::Factory.QNAME(name).var().current
-      Puppet::Parser::AST::PopsBridge::Expression.new(:value => varexpr)
+      wrap3x(Puppet::Pops::Model::Factory.QNAME(name).var())
+    end
+
+    def matchref_expression(number)
+      wrap3x(Puppet::Pops::Model::Factory.NUMBER(number).var())
     end
 
     before do
@@ -272,6 +289,134 @@ describe Puppet::Resource::Type do
       expect(@scope['foo']).to eq('foobar')
     end
 
+    context 'referencing a variable to the left of the default expression' do
+      it 'is possible when the referenced variable uses a default' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(10)
+        expect(@scope['second']).to eq(10)
+      end
+
+      it 'is possible when the referenced variable is given a value' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @resource[:first] = 2
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(2)
+        expect(@scope['second']).to eq(2)
+      end
+
+      it 'is possible when the referenced variable is an array produced by match function' do
+        @type.set_arguments({
+          :first => parse_expression("'hello'.match(/(h)(.*)/)"),
+          :second => parse_expression('$first[0]'),
+          :third => parse_expression('$first[1]')
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(['hello', 'h', 'ello'])
+        expect(@scope['second']).to eq('hello')
+        expect(@scope['third']).to eq('h')
+      end
+
+      it 'does not clobber a given value' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @resource[:first] = 2
+        @resource[:second] = 5
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(2)
+        expect(@scope['second']).to eq(5)
+      end
+    end
+
+    context 'referencing a variable to the right of the default expression' do
+      before :each do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('third'),
+          :third => number_expression(20)
+        })
+      end
+
+      it 'no error is raised when no defaults are evaluated' do
+        @resource[:first] = 1
+        @resource[:second] = 2
+        @resource[:third] = 3
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(1)
+        expect(@scope['second']).to eq(2)
+        expect(@scope['third']).to eq(3)
+      end
+
+      it 'no error is raised unless the referencing default expression is evaluated' do
+        @resource[:second] = 2
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(10)
+        expect(@scope['second']).to eq(2)
+        expect(@scope['third']).to eq(20)
+      end
+
+      it 'fails when the default expression is evaluated' do
+        @resource[:first] = 1
+        expect { @type.set_resource_parameters(@resource, @scope) }.to raise_error(Puppet::Error, 'default expression for $second tries to illegally access not yet evaluated $third')
+      end
+    end
+
+    it 'does not allow a variable to be referenced from its own default expression' do
+      @type.set_arguments({
+        :first => variable_expression('first')
+      })
+      expect { @type.set_resource_parameters(@resource, @scope) }.to raise_error(Puppet::Error, 'default expression for $first tries to illegally access not yet evaluated $first')
+    end
+
+    context 'when using match scope' do
+      it '$n evaluates to undef at the top level' do
+        @type.set_arguments({
+          :first => matchref_expression('0'),
+          :second => matchref_expression('1'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope).not_to include('first')
+        expect(@scope).not_to include('second')
+      end
+
+      it 'a match scope to the left of a parameter is not visible to it' do
+        @type.set_arguments({
+          :first => parse_expression("['hello' =~ /(h)(.*)/, $1, $2]"),
+          :second => matchref_expression('1'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq([true, 'h', 'ello'])
+        expect(@scope['second']).to be_nil
+      end
+
+      it 'match scopes nests per parameter' do
+        @type.set_arguments({
+          :first => parse_expression("['hi' =~ /(h)(.*)/, $1, if 'foo' =~ /f(oo)/ { $1 }, $1, $2]"),
+          :second => matchref_expression('0'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq([true, 'h', 'oo', 'h', 'i'])
+        expect(@scope['second']).to be_nil
+      end
+    end
+
     it "should set each of the resource's parameters as variables in the scope" do
       @type.set_arguments :foo => nil, :boo => nil
       @resource[:foo] = "bar"
@@ -432,10 +577,9 @@ describe Puppet::Resource::Type do
       @scope.expects(:newscope).with(:source => @type, :namespace => '', :resource => @resource).returns subscope
 
       elevel = 876
-      subscope.expects(:ephemeral_level).returns elevel
+      subscope.expects(:with_guarded_scope).yields
       subscope.expects(:ephemeral_from).with(match, nil, nil).returns subscope
       code.expects(:safeevaluate).with(subscope)
-      subscope.expects(:unset_ephemeral_var).with(elevel)
 
       # Just to keep the stub quiet about intermediate calls
       @type.expects(:set_resource_parameters).with(@resource, subscope)
@@ -484,9 +628,7 @@ describe Puppet::Resource::Type do
     it "should evaluate the AST code if any is provided" do
       code = stub 'code'
       @type.stubs(:code).returns code
-      subscope = stub_everything("subscope", :compiler => @compiler)
-      @scope.stubs(:newscope).returns subscope
-      code.expects(:safeevaluate).with subscope
+      code.expects(:safeevaluate).with kind_of(Puppet::Parser::Scope)
 
       @type.evaluate_code(@resource)
     end

data/spec/unit/resource_spec.rb

@@ -315,7 +315,10 @@ describe Puppet::Resource do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { :a => 1 } }
       let(:port) { Puppet::Parser::AST::Leaf.new(:value => '80') }
-      let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
+
+      def inject_and_set_defaults(resource, scope)
+        resource.resource_type.set_resource_parameters(resource, scope)
+      end
 
       before do
         environment.known_resource_types.add(apache)
@@ -325,72 +328,118 @@ describe Puppet::Resource do
         scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
-      context "when no value is provided" do
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope)
-        end
+      context 'with a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
 
-        it "should query the data_binding terminus using a namespaced key" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with(
-            'apache::port', all_of(has_key(:environment), has_key(:variables)))
-          resource.set_default_parameters(scope)
-        end
+        context "when no value is provided" do
+          let(:resource) do
+            Puppet::Parser::Resource.new("class", "apache", :scope => scope)
+          end
 
-        it "should use the value from the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
+          it "should query the data_binding terminus using a namespaced key" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with(
+              'apache::port', all_of(has_key(:environment), has_key(:variables)))
+            inject_and_set_defaults(resource, scope)
+          end
 
-          resource.set_default_parameters(scope)
+          it "should use the value from the data_binding terminus" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
 
-          expect(resource[:port]).to eq('443')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should use the default value if the data_binding terminus returns nil" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
+            expect(resource[:port]).to eq('443')
+          end
 
-          resource.set_default_parameters(scope)
+          it 'should use the default value if no value is found using the data_binding terminus' do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).throws(:no_such_key)
 
-          expect(resource[:port]).to eq('80')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should fail with error message about data binding on a hiera failure" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
-          expect {
-            resource.set_default_parameters(scope)
-          }.to raise_error(Puppet::Error, /Error from DataBinding 'hiera' while looking up 'apache::port':.*Forgettabotit/)
-        end
+            expect(resource[:port]).to eq('80')
+          end
 
-      end
+          it 'should use the default value if an undef value is found using the data_binding terminus' do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
 
-      context "when a value is provided" do
-        let(:port_parameter) do
-          Puppet::Parser::Resource::Param.new(
-            { :name => 'port', :value => '8080' }
-          )
-        end
+            inject_and_set_defaults(resource, scope)
+
+            expect(resource[:port]).to eq('80')
+          end
 
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-            :parameters => [port_parameter])
+          it "should fail with error message about data binding on a hiera failure" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+            expect {
+              inject_and_set_defaults(resource, scope)
+            }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
+          end
         end
 
-        it "should not query the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          resource.set_default_parameters(scope)
+        context "when a value is provided" do
+          let(:port_parameter) do
+            Puppet::Parser::Resource::Param.new(
+              { :name => 'port', :value => '8080' }
+            )
+          end
+
+          let(:resource) do
+            Puppet::Parser::Resource.new("class", "apache", :scope => scope,
+              :parameters => [port_parameter])
+          end
+
+          it "should not query the data_binding terminus" do
+            Puppet::DataBinding.indirection.expects(:find).never
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should not query the injector" do
+            compiler.injector.expects(:find).never
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should use the value provided" do
+            Puppet::DataBinding.indirection.expects(:find).never
+            expect(resource.set_default_parameters(scope)).to eq([])
+            expect(resource[:port]).to eq('8080')
+          end
+
+          it "should use the value from the data_binding terminus when provided value is undef" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
+
+            rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
+              :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+
+            rs.resource_type.set_resource_parameters(rs, scope)
+            expect(rs[:port]).to eq('443')
+          end
         end
+      end
+
+      context 'without a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => nil }) }
+        let(:resource) { Puppet::Parser::Resource.new("class", "apache", :scope => scope) }
+
+        it "should use the value from the data_binding terminus" do
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
 
-        it "should not query the injector" do
-          compiler.injector.expects(:find).never
-          resource.set_default_parameters(scope)
+          inject_and_set_defaults(resource, scope)
+
+          expect(resource[:port]).to eq('443')
         end
 
-        it "should use the value provided" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          expect(resource.set_default_parameters(scope)).to eq([])
-          expect(resource[:port]).to eq('8080')
+        it "should use an undef value from the data_binding terminus" do
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
+
+          inject_and_set_defaults(resource, scope)
+
+          expect(resource[:port]).to be_nil
         end
       end
     end

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