Merge pull request #8957 from mhashizume/maint/main/7.x-mergeup-12-1-22

(maint) Manual 7.x -> main mergeup

Author: joshcooper

lib/puppet/info_service/task_information_service.rb

@@ -4,11 +4,19 @@ class Puppet::InfoService::TaskInformationService
   def self.tasks_per_environment(environment_name)
     # get the actual environment object, raise error if the named env doesn't exist
     env = Puppet.lookup(:environments).get!(environment_name)
+
     env.modules.map do |mod|
       mod.tasks.map do |task|
-        {:module => {:name => task.module.name}, :name => task.name, :metadata => task.metadata}
+        # If any task is malformed continue to list other tasks in module
+        begin
+          task.validate
+          {:module => {:name => task.module.name}, :name => task.name, :metadata => task.metadata}
+        rescue Puppet::Module::Task::Error => err
+          Puppet.log_exception(err, 'Failed to validate task')
+          nil
+        end
       end
-    end.flatten
+    end.flatten.compact
   end
 
   def self.task_data(environment_name, module_name, task_name)

lib/puppet/type.rb

@@ -361,7 +361,7 @@ def self.newmetaparam(name, options = {}, &block)
   # @return [Void]
   def copy_metaparams(parameters)
     parameters.each do |name, param|
-      self[name] = param.value if param.metaparam? && !name == :alias
+      self[name] = param.value if param.metaparam? && name != :alias
     end
     nil
   end

lib/puppet/type/tidy.rb

@@ -247,9 +247,10 @@ def mkfile(path)
       :ensure => :absent, :force => true
     }
 
-    parameters[:noop] = self[:noop] unless self[:noop].nil?
+    new_file = Puppet::Type.type(:file).new(parameters)
+    new_file.copy_metaparams(@parameters)
 
-    Puppet::Type.type(:file).new(parameters)
+    new_file
   end
 
   def retrieve

spec/unit/info_service_spec.rb

@@ -33,6 +33,27 @@
         end
       end
 
+      it "returns task data for valid tasks in an environment even if invalid tasks exist" do
+        Puppet.override(:environments => env_loader) do
+          @mod = PuppetSpec::Modules.create(mod_name, modpath, {:environment => env,
+                                                                :tasks => [['atask',
+                                                                            {:name => 'atask.json',
+                                                                             :content => metadata.to_json}],
+                                                                           ['btask',
+                                                                            {:name => 'btask.json',
+                                                                             :content => metadata.to_json}],
+                                                                           ['ctask',
+                                                                            {:name => 'ctask.json',
+                                                                             :content => metadata.to_json}]]})
+          File.write("#{modpath}/#{mod_name}/tasks/atask.json", "NOT JSON")
+
+          expect(Puppet).to receive(:send_log).with(:err, 'Failed to validate task')
+
+          @tasks = Puppet::InfoService.tasks_per_environment(env_name)
+          expect(@tasks.map{|t| t[:name]}).to contain_exactly('test1::btask', 'test1::ctask')
+        end
+      end
+
       it "should throw EnvironmentNotFound if given a nonexistent environment" do
         expect{ Puppet::InfoService.tasks_per_environment('utopia') }.to raise_error(Puppet::Environments::EnvironmentNotFound)
       end

spec/unit/type/tidy_spec.rb

@@ -141,27 +141,20 @@
     describe "and generating files" do
       it "should set the backup on the file if backup is set on the tidy instance" do
         @tidy[:backup] = "whatever"
-        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(backup: "whatever"))
 
-        @tidy.mkfile(@basepath)
+        expect(@tidy.mkfile(@basepath)[:backup]).to eq("whatever")
       end
 
       it "should set the file's path to the tidy's path" do
-        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(path: @basepath))
-
-        @tidy.mkfile(@basepath)
+        expect(@tidy.mkfile(@basepath)[:path]).to eq(@basepath)
       end
 
       it "should configure the file for deletion" do
-        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(ensure: :absent))
-
-        @tidy.mkfile(@basepath)
+        expect(@tidy.mkfile(@basepath)[:ensure]).to eq(:absent)
       end
 
       it "should force deletion on the file" do
-        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(force: true))
-
-        @tidy.mkfile(@basepath)
+        expect(@tidy.mkfile(@basepath)[:force]).to eq(true)
       end
 
       it "should do nothing if the targeted file does not exist" do
@@ -471,6 +464,23 @@
 
       expect(result.values).to all(be_noop)
     end
+
+    it "generates resources whose schedule parameter matches the managed resource's schedule parameter" do
+      @tidy[:recurse] = true
+      @tidy[:schedule] = 'fake_schedule'
+
+      fileset = double('fileset')
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, {:recurse => true, :max_files=>0}).and_return(fileset)
+      expect(fileset).to receive(:files).and_return(%w{. a a/2 a/1 a/3})
+      allow(@tidy).to receive(:tidy?).and_return(true)
+
+      result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
+
+      result.each do |file_resource|
+        expect(file_resource[1][:schedule]).to eq('fake_schedule')
+      end
+
+    end
   end
 
   def lstat_is(path, stat)