Merge pull request puppetlabs#1123 from puppetlabs/master

(maint) - Merge PRs mistakenly merged into master into main

Author: sanfrancrisko

lib/puppet/parser/functions/defined_with_params.rb

@@ -48,16 +48,32 @@
     title = nil
   end
 
-  resource = findresource(type, title)
-  if resource
+  resources = if title.empty?
+                catalog.resources.select { |r| r.type == type }
+              else
+                [findresource(type, title)]
+              end
+
+  resources.compact.each do |res|
+    # If you call this from within a defined type, it will find itself
+    next if res.to_s == resource.to_s
+
     matches = params.map do |key, value|
       # eql? avoids bugs caused by monkeypatching in puppet
-      resource_is_undef = resource[key].eql?(:undef) || resource[key].nil?
+      res_is_undef = res[key].eql?(:undef) || res[key].nil?
       value_is_undef = value.eql?(:undef) || value.nil?
-      (resource_is_undef && value_is_undef) || (resource[key] == value)
+      found_match = (res_is_undef && value_is_undef) || (res[key] == value)
+
+      Puppet.debug("Matching resource is #{res}") if found_match
+
+      found_match
     end
     ret = params.empty? || !matches.include?(false)
+
+    break if ret
   end
-  Puppet.debug("Resource #{reference} was not determined to be defined")
+
+  Puppet.debug("Resource #{reference} was not determined to be defined") unless ret
+
   ret
 end

spec/functions/defined_with_params_spec.rb

@@ -63,13 +63,55 @@
 
   describe 'when passed a defined type' do
     let :pre_condition do
-      'define test::deftype() { } test::deftype { "foo": }'
+      <<-PRECOND
+        define test::deftype(
+          Optional $port = undef
+        ) { }
+
+        test::deftype { "foo": }
+        test::deftype { "baz": port => 100 }
+        test::deftype { "adv": port => 200 }
+        test::deftype { "adv2": port => 200 }
+
+        # Unsure how to stub this out below properly
+        if defined_with_params(Test::Deftype, { 'port' => 200 }) {
+          notify { 'Duplicate found somewhere': }
+        }
+        if defined_with_params(Test::Deftype, { 'port' => 'nope' }) {
+          notify { 'Should not find me': }
+        }
+      PRECOND
     end
 
     it { is_expected.to run.with_params('Test::Deftype[foo]', {}).and_return(true) }
     it { is_expected.to run.with_params('Test::Deftype[bar]', {}).and_return(false) }
     it { is_expected.to run.with_params(Puppet::Resource.new('Test::Deftype[foo]'), {}).and_return(true) }
-    it { is_expected.to run.with_params(Puppet::Resource.new('Test::Deftype[bar]'), {}).and_return(false) }
+    it {
+      is_expected.to run.with_params(Puppet::Resource.new('Test::Deftype[bar]'), {}).and_return(false)
+
+      expect(catalogue.resource('Notify[Duplicate found somewhere]')).not_to be_nil
+      expect(catalogue.resource('Notify[Should not find me]')).to be_nil
+    }
+  end
+
+  describe 'when called from within a defined type looking for a defined type of the same type' do
+    let :pre_condition do
+      <<-PRECOND
+        define test::deftype(
+          Optional $port = undef
+        ) {
+          if defined_with_params(Test::Deftype, { 'port' => $port }) {
+            fail('Ruh Roh Shaggy')
+          }
+        }
+
+        test::deftype { 'foo': }
+        test::deftype { 'bar': port => 200 }
+      PRECOND
+    end
+
+    # Testing to make sure that the internal logic handles this case via the pre_condition
+    it { is_expected.to run.with_params('NoOp[noop]', {}).and_return(false) }
   end
 
   describe 'when passed a class' do