puppet 7.20.0-x64-mingw32 → 7.21.0-x64-mingw32

data/spec/integration/application/agent_spec.rb

@@ -897,4 +897,103 @@ describe "puppet agent", unless: Puppet::Util::Platform.jruby? do
       end
     end
   end
+
+  context "legacy facts" do
+    let(:mod_dir) { tmpdir('module_dir') }
+    let(:custom_dir) { File.join(mod_dir, 'lib') }
+    let(:external_dir) { File.join(mod_dir, 'facts.d') }
+
+    before(:each) do
+      # don't stub facter behavior, since we're relying on
+      # `Facter.resolve` to omit legacy facts
+      Puppet::Node::Facts.indirection.terminus_class = :facter
+
+      facter_dir = File.join(custom_dir, 'facter')
+      FileUtils.mkdir_p(facter_dir)
+      File.write(File.join(facter_dir, 'custom.rb'), <<~END)
+        Facter.add(:custom) { setcode { 'a custom value' } }
+      END
+
+      FileUtils.mkdir_p(external_dir)
+      File.write(File.join(external_dir, 'external.json'), <<~END)
+        {"external":"an external value"}
+      END
+
+      # avoid pluginsync'ing contents
+      FileUtils.mkdir_p(Puppet[:vardir])
+      FileUtils.cp_r(custom_dir, Puppet[:vardir])
+      FileUtils.cp_r(external_dir, Puppet[:vardir])
+    end
+
+    def mounts
+      {
+        # the server needs to provide metadata that matches what the agent has
+        # so that the agent doesn't delete them during pluginsync
+        file_metadatas: -> (req, res) {
+          path = case req.path
+                 when /pluginfacts/
+                   external_dir
+                 when /plugins/
+                   custom_dir
+                 else
+                   raise "Unknown mount #{req.path}"
+                 end
+          request = Puppet::FileServing::Metadata.indirection.request(
+            :search, path, nil, recurse: true
+          )
+          data = Puppet::FileServing::Metadata.indirection.terminus(:file).search(request)
+          res.body = formatter.render(data)
+          res['Content-Type'] = formatter.mime
+        },
+        catalog: -> (req, res) {
+          data = CGI.unescape(req.query['facts'])
+          facts = Puppet::Node::Facts.convert_from('json', data)
+          node.fact_merge(facts)
+
+          catalog = compile_to_catalog(<<~MANIFEST, node)
+            notify { "legacy $osfamily": }
+            notify { "custom ${facts['custom']}": }
+            notify { "external ${facts['external']}": }
+          MANIFEST
+
+          res.body = formatter.render(catalog)
+          res['Content-Type'] = formatter.mime
+        }
+      }
+    end
+
+    it "includes legacy facts by default" do
+      server.start_server(mounts: mounts) do |port|
+        Puppet[:serverport] = port
+
+        agent.command_line.args << '--test'
+        expect {
+          agent.run
+        }.to exit_with(2)
+          .and output(
+            match(/defined 'message' as 'legacy [A-Za-z]+'/)
+              .and match(/defined 'message' as 'custom a custom value'/)
+              .and match(/defined 'message' as 'external an external value'/)
+          ).to_stdout
+      end
+    end
+
+    it "can exclude legacy facts" do
+      server.start_server(mounts: mounts) do |port|
+        Puppet[:serverport] = port
+        Puppet[:include_legacy_facts] = false
+
+        agent.command_line.args << '--test'
+        expect {
+          agent.run
+        }.to exit_with(2)
+          .and output(
+            match(/defined 'message' as 'legacy '/)
+              .and match(/defined 'message' as 'custom a custom value'/)
+              .and match(/defined 'message' as 'external an external value'/)
+            ).to_stdout
+          .and output(/Warning: Unknown variable: 'osfamily'/).to_stderr
+      end
+    end
+  end
 end

data/spec/integration/application/lookup_spec.rb

@@ -91,6 +91,61 @@ describe 'lookup' do
       expect_lookup_with_output(0, /--- value from per node data/)
     end
 
+    it "resolves hiera data using a top-level node parameter from enc" do
+      Puppet.settings[:node_terminus] = 'exec'
+      enc = tmpfile('enc.sh')
+      Puppet.settings[:external_nodes] = enc
+      File.write(File.join(env_dir, env_name, 'hiera.yaml'), <<~YAML)
+      ---
+      version: 5
+      hierarchy:
+        - name: "Node parameters"
+          data_hash: yaml_data
+          path: "%{site}.yaml"
+      YAML
+
+      File.write(File.join(env_dir, env_name, 'data', "pdx.yaml"), <<~YAML)
+      ---
+      key: value
+      YAML
+      allow(Puppet::Util::Execution).to receive(:execute).with([enc, fqdn], anything).and_return(<<~YAML)
+      parameters:
+        site: pdx
+      YAML
+      app.command_line.args << 'key' << '--compile'
+      Puppet.initialize_settings(['-E', env_name])
+      expect_lookup_with_output(0, /--- value/)
+    end
+
+    it "prefers the environment specified on the commandline over the enc environment" do
+      Puppet.settings[:node_terminus] = 'exec'
+      enc = tmpfile('enc.sh')
+      Puppet.settings[:external_nodes] = enc
+      File.write(File.join(env_dir, env_name, 'hiera.yaml'), <<~YAML)
+      ---
+      version: 5
+      hierarchy:
+        - name: "Node parameters"
+          data_hash: yaml_data
+          path: "%{site}.yaml"
+      YAML
+
+      File.write(File.join(env_dir, env_name, 'data', "pdx.yaml"), <<~YAML)
+      ---
+      key: value
+      YAML
+      allow(Puppet::Util::Execution).to receive(:execute).with([enc, fqdn], anything).and_return(<<~YAML)
+      ---
+      # return 'someother' environment because it doesn't have any hiera data
+      environment: someother
+      parameters:
+        site: pdx
+      YAML
+      app.command_line.args << 'key' << '--compile'
+      Puppet.initialize_settings(['-E', env_name])
+      expect_lookup_with_output(0, /--- value/)
+    end
+
     it 'loads trusted information from the node certificate' do
       Puppet.settings[:node_terminus] = 'exec'
       expect_any_instance_of(Puppet::Node::Exec).to receive(:find) do |args|

data/spec/unit/agent_spec.rb

@@ -173,7 +173,7 @@ describe Puppet::Agent do
       client = AgentTestClient.new
       expect(AgentTestClient).to receive(:new).and_return(client)
 
-      expect(client).to receive(:run).with(:pluginsync => true, :other => :options)
+      expect(client).to receive(:run).with({:pluginsync => true, :other => :options})
       @agent.run(:other => :options)
     end
 

data/spec/unit/confiner_spec.rb

@@ -24,7 +24,7 @@ describe Puppet::Confiner do
 
   it "should delegate its confine method to its confine collection" do
     allow(@object).to receive(:confine_collection).and_return(coll)
-    expect(coll).to receive(:confine).with(:foo => :bar, :bee => :baz)
+    expect(coll).to receive(:confine).with({:foo => :bar, :bee => :baz})
     @object.confine(:foo => :bar, :bee => :baz)
   end
 

data/spec/unit/http/service/compiler_spec.rb

@@ -592,7 +592,7 @@ describe Puppet::HTTP::Service::Compiler do
       invalid_facts = Puppet::Node::Facts.new(certname, {'invalid_utf8_sequence' => "\xE2\x82".force_encoding('binary')})
       expect {
         subject.put_facts(certname, environment: 'production', facts: invalid_facts)
-      }.to raise_error(Puppet::HTTP::SerializationError, /Failed to serialize Puppet::Node::Facts to json: "\\xE2" from ASCII-8BIT to UTF-8/)
+      }.to raise_error(Puppet::HTTP::SerializationError, /Failed to serialize Puppet::Node::Facts to json: ("\\xE2" from ASCII-8BIT to UTF-8|partial character in source, but hit end)/)
     end
   end
 

data/spec/unit/indirector/facts/facter_spec.rb

@@ -83,6 +83,16 @@ describe Puppet::Node::Facts::Facter do
 
       @facter.find(@request)
     end
+
+    it "can exclude legacy facts" do
+      Puppet[:include_legacy_facts] = false
+
+      facts = Puppet::Node::Facts.new("foo")
+      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      expect(Puppet.runtime[:facter]).to receive(:resolve).with('')
+
+      @facter.find(@request)
+    end
   end
 
   it 'should fail when saving facts' do

data/spec/unit/indirector/indirection_spec.rb

@@ -6,7 +6,7 @@ shared_examples_for "Indirection Delegator" do
   it "should create a request object with the appropriate method name and all of the passed arguments" do
     request = Puppet::Indirector::Request.new(:indirection, :find, "me", nil)
 
-    expect(@indirection).to receive(:request).with(@method, "mystuff", nil, :one => :two).and_return(request)
+    expect(@indirection).to receive(:request).with(@method, "mystuff", nil, {:one => :two}).and_return(request)
 
     allow(@terminus).to receive(@method)
 

data/spec/unit/info_service_spec.rb

@@ -33,6 +33,27 @@ describe "Puppet::InfoService" do
         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

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -82,7 +82,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
     expect(minitar).to receive(:find_valid_files).with(reader).and_return([name])
     entry = MockFileStatEntry.new(mode)
-    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name], :fsync => false).
+    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name], {:fsync => false}).
         and_yield(type, name, {:entry => entry})
     entry
   end

data/spec/unit/network/formats_spec.rb

@@ -504,7 +504,7 @@ EOT
 
     context "when rendering face-related objects" do
       it "pretty prints facts" do
-        tm = Time.new("2016-01-27T19:30:00")
+        tm = Time.new(2016, 1, 27, 19, 30, 0)
         values = {
           "architecture" =>  "x86_64",
           "os" => {

data/spec/unit/provider/ldap_spec.rb

@@ -85,7 +85,7 @@ describe Puppet::Provider::Ldap do
       it "should create a provider with the results of the find" do
         expect(@manager).to receive(:find).with("one").and_return("one" => "two")
 
-        expect(@class).to receive(:new).with("one" => "two", :ensure => :present).and_return("myprovider")
+        expect(@class).to receive(:new).with({"one" => "two", :ensure => :present}).and_return("myprovider")
 
         expect(@resource).to receive(:provider=).with("myprovider")
 
@@ -95,7 +95,7 @@ describe Puppet::Provider::Ldap do
       it "should set :ensure to :present in the returned values" do
         expect(@manager).to receive(:find).with("one").and_return("one" => "two")
 
-        expect(@class).to receive(:new).with("one" => "two", :ensure => :present).and_return("myprovider")
+        expect(@class).to receive(:new).with({"one" => "two", :ensure => :present}).and_return("myprovider")
 
         expect(@resource).to receive(:provider=).with("myprovider")
 

data/spec/unit/provider/package/dpkg_spec.rb

@@ -32,7 +32,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(bash_installed_io)
 
       installed = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(installed)
+      expect(described_class).to receive(:new).with({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg}).and_return(installed)
 
       expect(described_class.instances).to eq([installed])
     end
@@ -41,9 +41,9 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(all_installed_io)
 
       bash = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(bash)
+      expect(described_class).to receive(:new).with({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg}).and_return(bash)
       vim = double('vim')
-      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :mark => :none, :status => "installed", :provider => :dpkg).and_return(vim)
+      expect(described_class).to receive(:new).with({:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :mark => :none, :status => "installed", :provider => :dpkg}).and_return(vim)
 
       expect(described_class.instances).to eq([bash, vim])
     end

data/spec/unit/provider/package/pkgutil_spec.rb

@@ -195,7 +195,7 @@ Not in catalog"
       expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
 
       testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
+      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil}).and_return(testpkg)
       expect(described_class.instances).to eq([testpkg])
     end
 
@@ -207,10 +207,10 @@ Not in catalog"
       expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
 
       testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
+      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil}).and_return(testpkg)
 
       aliaspkg = double('pkg2')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil).and_return(aliaspkg)
+      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil}).and_return(aliaspkg)
 
       expect(described_class.instances).to eq([testpkg,aliaspkg])
     end
@@ -223,7 +223,7 @@ Not in catalog"
       expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
 
       testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
+      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil}).and_return(testpkg)
 
       expect(described_class.instances).to eq([testpkg])
     end

data/spec/unit/provider/parsedfile_spec.rb

@@ -59,10 +59,10 @@ describe Puppet::Provider::ParsedFile do
         {:name => 'target3_record2'}
       ])
       expect(Puppet).to receive(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
-      expect(provider).to receive(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).and_return('r1')
-      expect(provider).to receive(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).and_return('r2')
-      expect(provider).to receive(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).and_return('r3')
-      expect(provider).to receive(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).and_return('r4')
+      expect(provider).to receive(:new).with({:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present}).and_return('r1')
+      expect(provider).to receive(:new).with({:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present}).and_return('r2')
+      expect(provider).to receive(:new).with({:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present}).and_return('r3')
+      expect(provider).to receive(:new).with({:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present}).and_return('r4')
 
       expect(provider.instances).to eq(%w{r1 r2 r3 r4})
     end

data/spec/unit/reports/store_spec.rb

@@ -15,7 +15,11 @@ describe Puppet::Reports.report(:store) do
     end
 
     let(:report) do
-      report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
+      if RUBY_VERSION < "3.0"
+        report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
+      else
+        report = YAML.unsafe_load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
+      end
       report.extend(described_class)
       report
     end

data/spec/unit/transaction/event_manager_spec.rb

@@ -191,8 +191,8 @@ describe Puppet::Transaction::EventManager do
 
       allow(@resource).to receive(:callback1)
 
-      expect(@resource).to receive(:event).with(:message => "Triggered 'callback1' from 1 event", :status => 'success', :name => 'callback1')
-      expect(@resource).to receive(:event).with(:name => :restarted, :status => "success").and_return("myevent")
+      expect(@resource).to receive(:event).with({:message => "Triggered 'callback1' from 1 event", :status => 'success', :name => 'callback1'})
+      expect(@resource).to receive(:event).with({:name => :restarted, :status => "success"}).and_return("myevent")
       expect(@manager).to receive(:queue_events).with(@resource, ["myevent"])
 
       @manager.process_events(@resource)

data/spec/unit/transaction/report_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-
+require 'puppet_spec/compiler'
 require 'puppet'
 require 'puppet/transaction/report'
 require 'matchers/json'
@@ -7,6 +7,7 @@ require 'matchers/json'
 describe Puppet::Transaction::Report do
   include JSONMatchers
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   before do
     allow(Puppet::Util::Storage).to receive(:store)
@@ -136,6 +137,42 @@ describe Puppet::Transaction::Report do
     expect(report.metrics['time'].values.any? {|metric| metric.first =~ /whit/i}).to be_falsey
   end
 
+  describe "when exclude_unchanged_resources is true" do
+    before do
+      Puppet[:exclude_unchanged_resources] = true
+    end
+
+    let(:test_dir) { tmpdir('unchanged_resources') }
+    let(:test_dir2) { tmpdir('unchanged_resources') }
+    let(:test_file) { tmpfile('some_path')}
+    it 'should still list "changed" resource statuses but remove "unchanged"' do
+      transaction = apply_compiled_manifest(<<-END)
+        notify { "hi": } ~>
+        exec { "/bin/this_command_does_not_exist":
+          command => "#{make_absolute('/bin/this_command_does_not_exist')}",
+          refreshonly => true,
+        }
+        file { '#{test_dir}':
+          ensure => directory
+        }
+        file { 'failing_file':
+          path => '#{test_dir2}',
+          ensure => file
+        }
+        file { 'skipped_file':
+          path => '#{test_file}',
+          require => File[failing_file]
+        }
+      END
+      rs = transaction.report.to_data_hash['resource_statuses']
+      expect(rs["Notify[hi]"]['out_of_sync']).to be true
+      expect(rs["Exec[/bin/this_command_does_not_exist]"]['failed_to_restart']).to be true
+      expect(rs["File[failing_file]"]['failed']).to be true
+      expect(rs["File[skipped_file]"]['skipped']).to be true
+      expect(rs).to_not have_key(["File[#{test_dir}]"])
+    end
+  end
+
   describe "when accepting logs" do
     before do
       @report = Puppet::Transaction::Report.new

data/spec/unit/transaction_spec.rb

@@ -570,7 +570,7 @@ describe Puppet::Transaction do
     end
 
     it "should match resources by name, not title" do
-      expect(resource.provider.class).to receive(:prefetch).with("bar" => resource)
+      expect(resource.provider.class).to receive(:prefetch).with({"bar" => resource})
 
       transaction.prefetch_if_necessary(resource)
     end
@@ -598,7 +598,7 @@ describe Puppet::Transaction do
       catalog.add_resource other
 
       allow(resource.class).to receive(:defaultprovider).and_return(resource.provider.class)
-      expect(resource.provider.class).to receive(:prefetch).with('bar' => resource, 'other' => other)
+      expect(resource.provider.class).to receive(:prefetch).with({'bar' => resource, 'other' => other})
 
       transaction.prefetch_if_necessary(resource)
     end

data/spec/unit/type/file_spec.rb

@@ -516,8 +516,8 @@ describe Puppet::Type.type(:file) do
       it "should pass the already-discovered resources to recurse_remote" do
         file[:source] = File.expand_path(__FILE__)
         allow(child).to receive(:[]).with(:path).and_return(name)
-        allow(file).to receive(:recurse_local).and_return(name => child)
-        expect(file).to receive(:recurse_remote).with(name => child).and_return([])
+        allow(file).to receive(:recurse_local).and_return({name => child})
+        expect(file).to receive(:recurse_remote).with({name => child}).and_return([])
         file.recurse
       end
     end
@@ -526,8 +526,8 @@ describe Puppet::Type.type(:file) do
       it "should use recurse_link" do
         file[:target] = File.expand_path(__FILE__)
         allow(child).to receive(:[]).with(:path).and_return(name)
-        allow(file).to receive(:recurse_local).and_return(name => child)
-        expect(file).to receive(:recurse_link).with(name => child).and_return([])
+        allow(file).to receive(:recurse_local).and_return({name => child})
+        expect(file).to receive(:recurse_link).with({name => child}).and_return([])
         file.recurse
       end
     end

data/spec/unit/type/filebucket_spec.rb

@@ -82,20 +82,20 @@ describe Puppet::Type.type(:filebucket) do
     it "should use any provided path" do
       path = make_absolute("/foo/bar")
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => path
-      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Path => path).and_return(@bucket)
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with({:Path => path}).and_return(@bucket)
       bucket.bucket
     end
 
     it "should use any provided server and port" do
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "myserv", :port => "myport", :path => false
-      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Server => "myserv", :Port => "myport").and_return(@bucket)
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with({:Server => "myserv", :Port => "myport"}).and_return(@bucket)
       bucket.bucket
     end
 
     it "should not try to guess server or port if the path is unset and no server is provided" do
       Puppet.settings[:server] = "myserv"
       Puppet.settings[:server_list] = ['server_list_0', 'server_list_1']
-      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Server => nil, :Port => nil).and_return(@bucket)
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with({:Server => nil, :Port => nil}).and_return(@bucket)
 
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
       bucket.bucket

data/spec/unit/type/resources_spec.rb

@@ -270,6 +270,20 @@ describe resources do
       @catalog = Puppet::Resource::Catalog.new
     end
 
+    context "when the catalog contains a purging resource with an alias" do
+      before do
+        @resource = Puppet::Type.type(:resources).new(:name => "purgeable_test", :purge => true)
+        @catalog.add_resource @resource
+        @catalog.alias(@resource, "purgeable_test_alias")
+      end
+
+      it "should not copy the alias metaparameter" do
+        allow(Puppet::Type.type(:purgeable_test)).to receive(:instances).and_return([@purgee])
+        generated = @resource.generate.first
+        expect(generated[:alias]).to be_nil
+      end
+    end
+
     context "when dealing with non-purging resources" do
       before do
         @resources = Puppet::Type.type(:resources).new(:name => 'purgeable_test')

data/spec/unit/type/tidy_spec.rb

@@ -141,27 +141,20 @@ describe tidy do
     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
@@ -196,7 +189,7 @@ describe tidy do
       end
 
       it "should use a Fileset with default max_files for infinite recursion" do
-        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :max_files=>0).and_return(@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{. one two})
         allow(@tidy).to receive(:tidy?).and_return(false)
 
@@ -205,7 +198,7 @@ describe tidy do
 
       it "should use a Fileset with default max_files for limited recursion" do
         @tidy[:recurse] = 42
-        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :recurselimit => 42, :max_files=>0).and_return(@fileset)
+        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, {:recurse => true, :recurselimit => 42, :max_files=>0}).and_return(@fileset)
         expect(@fileset).to receive(:files).and_return(%w{. one two})
         allow(@tidy).to receive(:tidy?).and_return(false)
 
@@ -215,7 +208,7 @@ describe tidy do
       it "should use a Fileset with max_files for limited recursion" do
         @tidy[:recurse] = 42
         @tidy[:max_files] = 9876
-        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :recurselimit => 42, :max_files=>9876).and_return(@fileset)
+        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, {:recurse => true, :recurselimit => 42, :max_files=>9876}).and_return(@fileset)
         expect(@fileset).to receive(:files).and_return(%w{. one two})
         allow(@tidy).to receive(:tidy?).and_return(false)
 
@@ -428,7 +421,7 @@ describe tidy do
       @tidy[:recurse] = true
       @tidy[:rmdirs] = true
       fileset = double('fileset')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :max_files=>0).and_return(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{. one two one/subone two/subtwo one/subone/ssone})
       allow(@tidy).to receive(:tidy?).and_return(true)
 
@@ -450,7 +443,7 @@ describe tidy do
       @tidy[:recurse] = true
       @tidy[:rmdirs] = true
       fileset = double('fileset')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :max_files=>0).and_return(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)
 
@@ -463,7 +456,7 @@ describe tidy do
       @tidy[:noop] = true
 
       fileset = double('fileset')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :max_files=>0).and_return(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)
 
@@ -471,6 +464,23 @@ describe tidy do
 
       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)