puppet 4.4.0-universal-darwin

data/spec/unit/configurer/downloader_spec.rb

@@ -0,0 +1,228 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/configurer/downloader'
+
+describe Puppet::Configurer::Downloader do
+  require 'puppet_spec/files'
+  include PuppetSpec::Files
+
+  let(:path)   { Puppet[:plugindest] }
+  let(:source) { 'puppet://puppet/plugins' }
+
+  it "should require a name" do
+    expect { Puppet::Configurer::Downloader.new }.to raise_error(ArgumentError)
+  end
+
+  it "should require a path and a source at initialization" do
+    expect { Puppet::Configurer::Downloader.new("name") }.to raise_error(ArgumentError)
+  end
+
+  it "should set the name, path and source appropriately" do
+    dler = Puppet::Configurer::Downloader.new("facts", "path", "source")
+    expect(dler.name).to eq("facts")
+    expect(dler.path).to eq("path")
+    expect(dler.source).to eq("source")
+  end
+
+  def downloader(options = {})
+    options[:name] ||= "facts"
+    options[:path] ||= path
+    options[:source_permissions] ||= :ignore
+    Puppet::Configurer::Downloader.new(options[:name], options[:path], source, options[:ignore], options[:environment], options[:source_permissions])
+  end
+
+  def generate_file_resource(options = {})
+    dler = downloader(options)
+    dler.file
+  end
+
+  describe "when creating the file that does the downloading" do
+    it "should create a file instance with the right path and source" do
+      file = generate_file_resource(:path => path, :source => source)
+
+      expect(file[:path]).to eq(path)
+      expect(file[:source]).to eq([source])
+    end
+
+    it "should tag the file with the downloader name" do
+      name = "mydownloader"
+      file = generate_file_resource(:name => name)
+
+      expect(file[:tag]).to eq([name])
+    end
+
+    it "should always recurse" do
+      file = generate_file_resource
+
+      expect(file[:recurse]).to be_truthy
+    end
+
+    it "should follow links by default" do
+      file = generate_file_resource
+
+      expect(file[:links]).to eq(:follow)
+    end
+
+    it "should always purge" do
+      file = generate_file_resource
+
+      expect(file[:purge]).to be_truthy
+    end
+
+    it "should never be in noop" do
+      file = generate_file_resource
+
+      expect(file[:noop]).to be_falsey
+    end
+
+    it "should set source_permissions to ignore by default" do
+      file = generate_file_resource
+
+      expect(file[:source_permissions]).to eq(:ignore)
+    end
+
+    describe "on POSIX", :if => Puppet.features.posix? do
+      it "should allow source_permissions to be overridden" do
+        file = generate_file_resource(:source_permissions => :use)
+
+        expect(file[:source_permissions]).to eq(:use)
+      end
+
+      it "should always set the owner to the current UID" do
+        Process.expects(:uid).returns 51
+
+        file = generate_file_resource(:path => '/path')
+        expect(file[:owner]).to eq(51)
+      end
+
+      it "should always set the group to the current GID" do
+        Process.expects(:gid).returns 61
+
+        file = generate_file_resource(:path => '/path')
+        expect(file[:group]).to eq(61)
+      end
+    end
+
+    describe "on Windows", :if => Puppet.features.microsoft_windows? do
+      it "should omit the owner" do
+        file = generate_file_resource(:path => 'C:/path')
+
+        expect(file[:owner]).to be_nil
+      end
+
+      it "should omit the group" do
+        file = generate_file_resource(:path => 'C:/path')
+
+        expect(file[:group]).to be_nil
+      end
+    end
+
+    it "should always force the download" do
+      file = generate_file_resource
+
+      expect(file[:force]).to be_truthy
+    end
+
+    it "should never back up when downloading" do
+      file = generate_file_resource
+
+      expect(file[:backup]).to be_falsey
+    end
+
+    it "should support providing an 'ignore' parameter" do
+      file = generate_file_resource(:ignore => '.svn')
+
+      expect(file[:ignore]).to eq(['.svn'])
+    end
+
+    it "should split the 'ignore' parameter on whitespace" do
+      file = generate_file_resource(:ignore => '.svn CVS')
+
+      expect(file[:ignore]).to eq(['.svn', 'CVS'])
+    end
+  end
+
+  describe "when creating the catalog to do the downloading" do
+    before do
+      @path = make_absolute("/download/path")
+      @dler = Puppet::Configurer::Downloader.new("foo", @path, make_absolute("source"))
+    end
+
+    it "should create a catalog and add the file to it" do
+      catalog = @dler.catalog
+      expect(catalog.resources.size).to eq(1)
+      expect(catalog.resources.first.class).to eq(Puppet::Type::File)
+      expect(catalog.resources.first.name).to eq(@path)
+    end
+
+    it "should specify that it is not managing a host catalog" do
+      expect(@dler.catalog.host_config).to eq(false)
+    end
+
+  end
+
+  describe "when downloading" do
+    before do
+      @dl_name = tmpfile("downloadpath")
+      source_name = tmpfile("source")
+      File.open(source_name, 'w') {|f| f.write('hola mundo') }
+      env = Puppet::Node::Environment.remote('foo')
+      @dler = Puppet::Configurer::Downloader.new("foo", @dl_name, source_name, Puppet[:pluginsignore], env)
+    end
+
+    it "should not skip downloaded resources when filtering on tags" do
+      Puppet[:tags] = 'maytag'
+      @dler.evaluate
+
+      expect(Puppet::FileSystem.exist?(@dl_name)).to be_truthy
+    end
+
+    it "should log that it is downloading" do
+      Puppet.expects(:info)
+
+      @dler.evaluate
+    end
+
+    it "should return all changed file paths" do
+      trans = mock 'transaction'
+
+      catalog = mock 'catalog'
+      @dler.expects(:catalog).returns(catalog)
+      catalog.expects(:apply).yields(trans)
+
+      resource = mock 'resource'
+      resource.expects(:[]).with(:path).returns "/changed/file"
+
+      trans.expects(:changed?).returns([resource])
+
+      expect(@dler.evaluate).to eq(%w{/changed/file})
+    end
+
+    it "should yield the resources if a block is given" do
+      trans = mock 'transaction'
+
+      catalog = mock 'catalog'
+      @dler.expects(:catalog).returns(catalog)
+      catalog.expects(:apply).yields(trans)
+
+      resource = mock 'resource'
+      resource.expects(:[]).with(:path).returns "/changed/file"
+
+      trans.expects(:changed?).returns([resource])
+
+      yielded = nil
+      @dler.evaluate { |r| yielded = r }
+      expect(yielded).to eq(resource)
+    end
+
+    it "should catch and log exceptions" do
+      Puppet.expects(:err)
+      # The downloader creates a new catalog for each apply, and really the only object
+      # that it is possible to stub for the purpose of generating a puppet error
+      Puppet::Resource::Catalog.any_instance.stubs(:apply).raises(Puppet::Error, "testing")
+
+      expect { @dler.evaluate }.not_to raise_error
+    end
+  end
+end

data/spec/unit/configurer/fact_handler_spec.rb

@@ -0,0 +1,96 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/configurer'
+require 'puppet/configurer/fact_handler'
+require 'matchers/json'
+
+class FactHandlerTester
+  include Puppet::Configurer::FactHandler
+
+  attr_accessor :environment
+
+  def initialize(environment)
+    self.environment = environment
+  end
+
+  def reload_facter
+    # don't want to do this in tests
+  end
+end
+
+describe Puppet::Configurer::FactHandler do
+  include JSONMatchers
+
+  let(:facthandler) { FactHandlerTester.new('production') }
+
+  before :each do
+    Puppet::Node::Facts.indirection.terminus_class = :memory
+  end
+
+  describe "when finding facts" do
+    it "should use the node name value to retrieve the facts" do
+      foo_facts = Puppet::Node::Facts.new('foo')
+      bar_facts = Puppet::Node::Facts.new('bar')
+      Puppet::Node::Facts.indirection.save(foo_facts)
+      Puppet::Node::Facts.indirection.save(bar_facts)
+      Puppet[:certname] = 'foo'
+      Puppet[:node_name_value] = 'bar'
+
+      expect(facthandler.find_facts).to eq(bar_facts)
+    end
+
+    it "should set the facts name based on the node_name_fact" do
+      facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
+      Puppet::Node::Facts.indirection.save(facts)
+      Puppet[:node_name_fact] = 'my_name_fact'
+
+      expect(facthandler.find_facts.name).to eq('other_node_name')
+    end
+
+    it "should set the node_name_value based on the node_name_fact" do
+      facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
+      Puppet::Node::Facts.indirection.save(facts)
+      Puppet[:node_name_fact] = 'my_name_fact'
+
+      facthandler.find_facts
+
+      expect(Puppet[:node_name_value]).to eq('other_node_name')
+    end
+
+    it "should fail if finding facts fails" do
+      Puppet::Node::Facts.indirection.expects(:find).raises RuntimeError
+
+      expect { facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
+    end
+
+    it "should only load fact plugins once" do
+      Puppet::Node::Facts.indirection.expects(:find).once
+      facthandler.find_facts
+    end
+  end
+
+  it "should serialize and CGI escape the fact values for uploading" do
+    facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
+    Puppet::Node::Facts.indirection.save(facts)
+    text = CGI.escape(facthandler.find_facts.render(:pson))
+
+    expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
+  end
+
+  it "should properly accept facts containing a '+'" do
+    facts = Puppet::Node::Facts.new('foo', 'afact' => 'a+b')
+    Puppet::Node::Facts.indirection.save(facts)
+    text = CGI.escape(facthandler.find_facts.render(:pson))
+
+    expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
+  end
+
+  it "should generate valid facts data against the facts schema" do
+    facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
+    Puppet::Node::Facts.indirection.save(facts)
+
+    expect(CGI.unescape(facthandler.facts_for_uploading[:facts])).to validate_against('api/schemas/facts.json')
+  end
+
+end
+

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -0,0 +1,68 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/configurer'
+require 'puppet/configurer/plugin_handler'
+
+describe Puppet::Configurer::PluginHandler do
+  let(:factory)       { Puppet::Configurer::DownloaderFactory.new }
+  let(:pluginhandler) { Puppet::Configurer::PluginHandler.new(factory) }
+  let(:environment)   { Puppet::Node::Environment.create(:myenv, []) }
+
+  before :each do
+    # PluginHandler#load_plugin has an extra-strong rescue clause
+    # this mock is to make sure that we don't silently ignore errors
+    Puppet.expects(:err).never
+  end
+
+  context "when external facts are supported" do
+    before :each do
+      Puppet.features.stubs(:external_facts?).returns(true)
+    end
+
+    it "downloads plugins and facts" do
+      plugin_downloader = stub('plugin-downloader', :evaluate => [])
+      facts_downloader = stub('facts-downloader', :evaluate => [])
+
+      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
+
+      pluginhandler.download_plugins(environment)
+    end
+
+    it "returns downloaded plugin and fact filenames" do
+      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
+      facts_downloader = stub('facts-downloader', :evaluate => %w[/b])
+
+      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
+
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+    end
+  end
+
+  context "when external facts are not supported" do
+    before :each do
+      Puppet.features.stubs(:external_facts?).returns(false)
+    end
+
+    it "downloads plugins only" do
+      plugin_downloader = stub('plugin-downloader', :evaluate => [])
+
+      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+      factory.expects(:create_plugin_facts_downloader).never
+
+      pluginhandler.download_plugins(environment)
+    end
+
+    it "returns downloaded plugin filenames only" do
+      Puppet.features.stubs(:external_facts?).returns(false)
+
+      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
+      facts_downloader = stub('facts-downloader')
+
+      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a])
+    end
+  end
+end

data/spec/unit/configurer_spec.rb

@@ -0,0 +1,923 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/configurer'
+
+describe Puppet::Configurer do
+  before do
+    Puppet.settings.stubs(:use).returns(true)
+    @agent = Puppet::Configurer.new
+    @agent.stubs(:init_storage)
+    Puppet::Util::Storage.stubs(:store)
+    Puppet[:server] = "puppetmaster"
+    Puppet[:report] = true
+  end
+
+  it "should include the Fact Handler module" do
+    expect(Puppet::Configurer.ancestors).to be_include(Puppet::Configurer::FactHandler)
+  end
+
+  describe "when executing a pre-run hook" do
+    it "should do nothing if the hook is set to an empty string" do
+      Puppet.settings[:prerun_command] = ""
+      Puppet::Util.expects(:exec).never
+
+      @agent.execute_prerun_command
+    end
+
+    it "should execute any pre-run command provided via the 'prerun_command' setting" do
+      Puppet.settings[:prerun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      @agent.execute_prerun_command
+    end
+
+    it "should fail if the command fails" do
+      Puppet.settings[:prerun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      expect(@agent.execute_prerun_command).to be_falsey
+    end
+  end
+
+  describe "when executing a post-run hook" do
+    it "should do nothing if the hook is set to an empty string" do
+      Puppet.settings[:postrun_command] = ""
+      Puppet::Util.expects(:exec).never
+
+      @agent.execute_postrun_command
+    end
+
+    it "should execute any post-run command provided via the 'postrun_command' setting" do
+      Puppet.settings[:postrun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      @agent.execute_postrun_command
+    end
+
+    it "should fail if the command fails" do
+      Puppet.settings[:postrun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      expect(@agent.execute_postrun_command).to be_falsey
+    end
+  end
+
+  describe "when executing a catalog run" do
+    before do
+      Puppet.settings.stubs(:use).returns(true)
+      @agent.stubs(:download_plugins)
+      Puppet::Node::Facts.indirection.terminus_class = :memory
+      @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
+      Puppet::Node::Facts.indirection.save(@facts)
+
+      @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      @catalog.stubs(:to_ral).returns(@catalog)
+      Puppet::Resource::Catalog.indirection.terminus_class = :rest
+      Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)
+      @agent.stubs(:send_report)
+      @agent.stubs(:save_last_run_summary)
+
+      Puppet::Util::Log.stubs(:close_all)
+    end
+
+    after :all do
+      Puppet::Node::Facts.indirection.reset_terminus_class
+      Puppet::Resource::Catalog.indirection.reset_terminus_class
+    end
+
+    it "should initialize storage" do
+      Puppet::Util::Storage.expects(:load)
+      @agent.run
+    end
+
+    it "downloads plugins when told" do
+      @agent.expects(:download_plugins)
+      @agent.run(:pluginsync => true)
+    end
+
+    it "does not download plugins when told" do
+      @agent.expects(:download_plugins).never
+      @agent.run(:pluginsync => false)
+    end
+
+    it "should carry on when it can't fetch its node definition" do
+      error = Net::HTTPError.new(400, 'dummy server communication error')
+      Puppet::Node.indirection.expects(:find).raises(error)
+      expect(@agent.run).to eq(0)
+    end
+
+    it "applies a cached catalog when it can't connect to the master" do
+      error = Errno::ECONNREFUSED.new('Connection refused - connect(2)')
+
+      Puppet::Node.indirection.expects(:find).raises(error)
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_cache => true)).raises(error)
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_terminus => true)).returns(@catalog)
+
+      expect(@agent.run).to eq(0)
+    end
+
+    it "should initialize a transaction report if one is not provided" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns report
+
+      @agent.run
+    end
+
+    it "should respect node_name_fact when setting the host on a report" do
+      Puppet[:node_name_fact] = 'my_name_fact'
+      @facts.values = {'my_name_fact' => 'node_name_from_fact'}
+
+      report = Puppet::Transaction::Report.new("apply")
+
+      @agent.run(:report => report)
+      expect(report.host).to eq('node_name_from_fact')
+    end
+
+    it "should pass the new report to the catalog" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.stubs(:new).returns report
+      @catalog.expects(:apply).with{|options| options[:report] == report}
+
+      @agent.run
+    end
+
+    it "should use the provided report if it was passed one" do
+      report = Puppet::Transaction::Report.new("apply")
+      @catalog.expects(:apply).with {|options| options[:report] == report}
+
+      @agent.run(:report => report)
+    end
+
+    it "should set the report as a log destination" do
+      report = Puppet::Transaction::Report.new("apply")
+
+      report.expects(:<<).with(instance_of(Puppet::Util::Log)).at_least_once
+
+      @agent.run(:report => report)
+    end
+
+    it "should retrieve the catalog" do
+      @agent.expects(:retrieve_catalog)
+
+      @agent.run
+    end
+
+    it "should log a failure and do nothing if no catalog can be retrieved" do
+      @agent.expects(:retrieve_catalog).returns nil
+
+      Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
+
+      @agent.run
+    end
+
+    it "should apply the catalog with all options to :run" do
+      @agent.expects(:retrieve_catalog).returns @catalog
+
+      @catalog.expects(:apply).with { |args| args[:one] == true }
+      @agent.run :one => true
+    end
+
+    it "should accept a catalog and use it instead of retrieving a different one" do
+      @agent.expects(:retrieve_catalog).never
+
+      @catalog.expects(:apply)
+      @agent.run :one => true, :catalog => @catalog
+    end
+
+    it "should benchmark how long it takes to apply the catalog" do
+      @agent.expects(:benchmark).with(:notice, instance_of(String))
+
+      @agent.expects(:retrieve_catalog).returns @catalog
+
+      @catalog.expects(:apply).never # because we're not yielding
+      @agent.run
+    end
+
+    it "should execute post-run hooks after the run" do
+      @agent.expects(:execute_postrun_command)
+
+      @agent.run
+    end
+
+    it "should send the report" do
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+      @agent.expects(:send_report).with(report)
+
+      expect(report.environment).to eq("test")
+      expect(report.transaction_uuid).to eq("aaaa")
+
+      @agent.run
+    end
+
+    it "should send the transaction report even if the catalog could not be retrieved" do
+      @agent.expects(:retrieve_catalog).returns nil
+
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+      @agent.expects(:send_report).with(report)
+
+      expect(report.environment).to eq("test")
+      expect(report.transaction_uuid).to eq("aaaa")
+
+      @agent.run
+    end
+
+    it "should send the transaction report even if there is a failure" do
+      @agent.expects(:retrieve_catalog).raises "whatever"
+
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+      @agent.expects(:send_report).with(report)
+
+      expect(report.environment).to eq("test")
+      expect(report.transaction_uuid).to eq("aaaa")
+
+      expect(@agent.run).to be_nil
+    end
+
+    it "should remove the report as a log destination when the run is finished" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      @agent.run
+
+      expect(Puppet::Util::Log.destinations).not_to include(report)
+    end
+
+    it "should return the report exit_status as the result of the run" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+      report.expects(:exit_status).returns(1234)
+
+      expect(@agent.run).to eq(1234)
+    end
+
+    it "should send the transaction report even if the pre-run command fails" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      Puppet.settings[:prerun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      @agent.expects(:send_report).with(report)
+
+      expect(@agent.run).to be_nil
+    end
+
+    it "should include the pre-run command failure in the report" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      Puppet.settings[:prerun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      expect(@agent.run).to be_nil
+      expect(report.logs.find { |x| x.message =~ /Could not run command from prerun_command/ }).to be
+    end
+
+    it "should send the transaction report even if the post-run command fails" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      Puppet.settings[:postrun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      @agent.expects(:send_report).with(report)
+
+      expect(@agent.run).to be_nil
+    end
+
+    it "should include the post-run command failure in the report" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      Puppet.settings[:postrun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      report.expects(:<<).with { |log| log.message.include?("Could not run command from postrun_command") }
+
+      expect(@agent.run).to be_nil
+    end
+
+    it "should execute post-run command even if the pre-run command fails" do
+      Puppet.settings[:prerun_command] = "/my/precommand"
+      Puppet.settings[:postrun_command] = "/my/postcommand"
+      Puppet::Util::Execution.expects(:execute).with(["/my/precommand"]).raises(Puppet::ExecutionFailure, "Failed")
+      Puppet::Util::Execution.expects(:execute).with(["/my/postcommand"])
+
+      expect(@agent.run).to be_nil
+    end
+
+    it "should finalize the report" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      report.expects(:finalize_report)
+      @agent.run
+    end
+
+    it "should not apply the catalog if the pre-run command fails" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      Puppet.settings[:prerun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      @catalog.expects(:apply).never()
+      @agent.expects(:send_report)
+
+      expect(@agent.run).to be_nil
+    end
+
+    it "should apply the catalog, send the report, and return nil if the post-run command fails" do
+      report = Puppet::Transaction::Report.new("apply")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+
+      Puppet.settings[:postrun_command] = "/my/command"
+      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+
+      @catalog.expects(:apply)
+      @agent.expects(:send_report)
+
+      expect(@agent.run).to be_nil
+    end
+
+    it "should refetch the catalog if the server specifies a new environment in the catalog" do
+      catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.expects(:retrieve_catalog).returns(catalog).twice
+
+      @agent.run
+    end
+
+    it "should change the environment setting if the server specifies a new environment in the catalog" do
+      @catalog.stubs(:environment).returns("second_env")
+
+      @agent.run
+
+      expect(@agent.environment).to eq("second_env")
+    end
+
+    it "should fix the report if the server specifies a new environment in the catalog" do
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+      @agent.expects(:send_report).with(report)
+
+      @catalog.stubs(:environment).returns("second_env")
+      @agent.stubs(:retrieve_catalog).returns(@catalog)
+
+      @agent.run
+
+      expect(report.environment).to eq("second_env")
+    end
+
+    it "sends the transaction uuid in a catalog request" do
+      @agent.instance_variable_set(:@transaction_uuid, 'aaa')
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => 'aaa'))
+      @agent.run
+    end
+
+    it "sets the static_catalog query param to true in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:static_catalog => true))
+      @agent.run
+    end
+
+    it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything,
+        has_entries(:checksum_type => 'md5.sha256'))
+      @agent.run
+    end
+
+    it "sets the checksum_type query param to the supported_checksum_types setting in a catalog request" do
+      # Regenerate the agent to pick up the new setting
+      Puppet[:supported_checksum_types] = ['sha256']
+      @agent = Puppet::Configurer.new
+      @agent.stubs(:init_storage)
+      @agent.stubs(:download_plugins)
+      @agent.stubs(:send_report)
+      @agent.stubs(:save_last_run_summary)
+
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:checksum_type => 'sha256'))
+      @agent.run
+    end
+
+    describe "when not using a REST terminus for catalogs" do
+      it "should not pass any facts when retrieving the catalog" do
+        Puppet::Resource::Catalog.indirection.terminus_class = :compiler
+        @agent.expects(:facts_for_uploading).never
+        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options|
+          options[:facts].nil?
+        }.returns @catalog
+
+        @agent.run
+      end
+    end
+
+    describe "when using a REST terminus for catalogs" do
+      it "should pass the prepared facts and the facts format as arguments when retrieving the catalog" do
+        Puppet::Resource::Catalog.indirection.terminus_class = :rest
+        @agent.expects(:facts_for_uploading).returns(:facts => "myfacts", :facts_format => :foo)
+        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options|
+          options[:facts] == "myfacts" and options[:facts_format] == :foo
+        }.returns @catalog
+
+        @agent.run
+      end
+    end
+  end
+
+  describe "when sending a report" do
+    include PuppetSpec::Files
+
+    before do
+      Puppet.settings.stubs(:use).returns(true)
+      @configurer = Puppet::Configurer.new
+      Puppet[:lastrunfile] = tmpfile('last_run_file')
+
+      @report = Puppet::Transaction::Report.new("apply")
+      Puppet[:reports] = "none"
+    end
+
+    it "should print a report summary if configured to do so" do
+      Puppet.settings[:summarize] = true
+
+      @report.expects(:summary).returns "stuff"
+
+      @configurer.expects(:puts).with("stuff")
+      @configurer.send_report(@report)
+    end
+
+    it "should not print a report summary if not configured to do so" do
+      Puppet.settings[:summarize] = false
+
+      @configurer.expects(:puts).never
+      @configurer.send_report(@report)
+    end
+
+    it "should save the report if reporting is enabled" do
+      Puppet.settings[:report] = true
+
+      Puppet::Transaction::Report.indirection.expects(:save).with(@report, nil, instance_of(Hash))
+      @configurer.send_report(@report)
+    end
+
+    it "should not save the report if reporting is disabled" do
+      Puppet.settings[:report] = false
+
+      Puppet::Transaction::Report.indirection.expects(:save).with(@report, nil, instance_of(Hash)).never
+      @configurer.send_report(@report)
+    end
+
+    it "should save the last run summary if reporting is enabled" do
+      Puppet.settings[:report] = true
+
+      @configurer.expects(:save_last_run_summary).with(@report)
+      @configurer.send_report(@report)
+    end
+
+    it "should save the last run summary if reporting is disabled" do
+      Puppet.settings[:report] = false
+
+      @configurer.expects(:save_last_run_summary).with(@report)
+      @configurer.send_report(@report)
+    end
+
+    it "should log but not fail if saving the report fails" do
+      Puppet.settings[:report] = true
+
+      Puppet::Transaction::Report.indirection.expects(:save).raises("whatever")
+
+      Puppet.expects(:err)
+      expect { @configurer.send_report(@report) }.not_to raise_error
+    end
+  end
+
+  describe "when saving the summary report file" do
+    include PuppetSpec::Files
+
+    before do
+      Puppet.settings.stubs(:use).returns(true)
+      @configurer = Puppet::Configurer.new
+
+      @report = stub 'report', :raw_summary => {}
+
+      Puppet[:lastrunfile] = tmpfile('last_run_file')
+    end
+
+    it "should write the last run file" do
+      @configurer.save_last_run_summary(@report)
+      expect(Puppet::FileSystem.exist?(Puppet[:lastrunfile])).to be_truthy
+    end
+
+    it "should write the raw summary as yaml" do
+      @report.expects(:raw_summary).returns("summary")
+      @configurer.save_last_run_summary(@report)
+      expect(File.read(Puppet[:lastrunfile])).to eq(YAML.dump("summary"))
+    end
+
+    it "should log but not fail if saving the last run summary fails" do
+      # The mock will raise an exception on any method used.  This should
+      # simulate a nice hard failure from the underlying OS for us.
+      fh = Class.new(Object) do
+        def method_missing(*args)
+          raise "failed to do #{args[0]}"
+        end
+      end.new
+
+      Puppet::Util.expects(:replace_file).yields(fh)
+
+      Puppet.expects(:err)
+      expect { @configurer.save_last_run_summary(@report) }.to_not raise_error
+    end
+
+    it "should create the last run file with the correct mode" do
+      Puppet.settings.setting(:lastrunfile).expects(:mode).returns('664')
+      @configurer.save_last_run_summary(@report)
+
+      if Puppet::Util::Platform.windows?
+        require 'puppet/util/windows/security'
+        mode = Puppet::Util::Windows::Security.get_mode(Puppet[:lastrunfile])
+      else
+        mode = Puppet::FileSystem.stat(Puppet[:lastrunfile]).mode
+      end
+      expect(mode & 0777).to eq(0664)
+    end
+
+    it "should report invalid last run file permissions" do
+      Puppet.settings.setting(:lastrunfile).expects(:mode).returns('892')
+      Puppet.expects(:err).with(regexp_matches(/Could not save last run local report.*892 is invalid/))
+      @configurer.save_last_run_summary(@report)
+    end
+  end
+
+  describe "when requesting a node" do
+    it "uses the transaction uuid in the request" do
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => anything)).twice
+      @agent.run
+    end
+
+    it "sends an explicitly configured environment request" do
+      Puppet.settings.expects(:set_by_config?).with(:environment).returns(true)
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => Puppet[:environment])).twice
+      @agent.run
+    end
+
+    it "does not send a configured_environment when using the default" do
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => nil)).twice
+      @agent.run
+    end
+  end
+
+  def expects_new_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+  end
+
+  def expects_cached_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+  end
+
+  def expects_fallback_to_cached_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+  end
+
+  def expects_fallback_to_new_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+  end
+
+  def expects_neither_new_or_cached_catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+  end
+
+  describe "when retrieving a catalog" do
+    before do
+      Puppet.settings.stubs(:use).returns(true)
+      @agent.stubs(:facts_for_uploading).returns({})
+      @agent.stubs(:download_plugins)
+
+      # retrieve a catalog in the current environment, so we don't try to converge unexpectedly
+      @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+
+      # this is the default when using a Configurer instance
+      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
+    end
+
+    describe "and configured to only retrieve a catalog from the cache" do
+      before do
+        Puppet.settings[:use_cached_catalog] = true
+      end
+
+      it "should first look in the cache for a catalog" do
+        expects_cached_catalog_only(@catalog)
+
+        expect(@agent.retrieve_catalog({})).to eq(@catalog)
+      end
+
+      it "should not make a node request or pluginsync when a cached catalog is successfully retrieved" do
+        Puppet::Node.indirection.expects(:find).never
+        expects_cached_catalog_only(@catalog)
+        @agent.expects(:download_plugins).never
+
+        @agent.run
+      end
+
+      it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
+        Puppet::Node.indirection.expects(:find).returns nil
+        expects_fallback_to_new_catalog(@catalog)
+        @agent.expects(:download_plugins)
+
+        @agent.run
+      end
+
+      it "should set its cached_catalog_status to 'explicitly_requested'" do
+        expects_cached_catalog_only(@catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
+      end
+
+      it "should set its cached_catalog_status to 'explicitly requested' if the cached catalog is from a different environment" do
+        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        expects_cached_catalog_only(cached_catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
+      end
+
+      it "should compile a new catalog if none is found in the cache" do
+        expects_fallback_to_new_catalog(@catalog)
+
+        expect(@agent.retrieve_catalog({})).to eq(@catalog)
+      end
+
+      it "should set its cached_catalog_status to 'not_used' if no catalog is found in the cache" do
+        expects_fallback_to_new_catalog(@catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+      end
+
+      it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
+        Puppet::Node.indirection.expects(:find).returns(nil)
+        expects_neither_new_or_cached_catalog
+
+        @agent.run
+      end
+
+      it "should return the cached catalog when the environment doesn't match" do
+        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        expects_cached_catalog_only(cached_catalog)
+
+        Puppet.expects(:info).with("Using cached catalog from environment 'second_env'")
+        expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+      end
+    end
+
+    describe "and strict environment mode is set" do
+      before do
+        @catalog.stubs(:to_ral).returns(@catalog)
+        @catalog.stubs(:write_class_file)
+        @catalog.stubs(:write_resource_file)
+        @agent.stubs(:send_report)
+        @agent.stubs(:save_last_run_summary)
+        Puppet.settings[:strict_environment_mode] = true
+      end
+
+      it "should not make a node request" do
+        Puppet::Node.indirection.expects(:find).never
+
+        @agent.run
+      end
+
+      it "should return nil when the catalog's environment doesn't match the agent specified environment" do
+        @agent.instance_variable_set(:@environment, 'second_env')
+        expects_new_catalog_only(@catalog)
+
+        Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+        expect(@agent.run).to be_nil
+      end
+
+      it "should not return nil when the catalog's environment matches the agent specified environment" do
+        @agent.instance_variable_set(:@environment, 'production')
+        expects_new_catalog_only(@catalog)
+
+        expect(@agent.run).to eq(0)
+      end
+
+      describe "and a cached catalog is explicitly requested" do
+        before do
+          Puppet.settings[:use_cached_catalog] = true
+        end
+
+        it "should return nil when the cached catalog's environment doesn't match the agent specified environment" do
+          @agent.instance_variable_set(:@environment, 'second_env')
+          expects_cached_catalog_only(@catalog)
+
+          Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+          expect(@agent.run).to be_nil
+        end
+
+        it "should proceed with the cached catalog if its environment matchs the local environment" do
+          Puppet.settings[:use_cached_catalog] = true
+          @agent.instance_variable_set(:@environment, 'production')
+          expects_cached_catalog_only(@catalog)
+
+          expect(@agent.run).to eq(0)
+        end
+      end
+    end
+
+    it "should use the Catalog class to get its catalog" do
+      Puppet::Resource::Catalog.indirection.expects(:find).returns @catalog
+
+      @agent.retrieve_catalog({})
+    end
+
+    it "should set its cached_catalog_status to 'not_used' when downloading a new catalog" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
+    it "should use its node_name_value to retrieve the catalog" do
+      Facter.stubs(:value).returns "eh"
+      Puppet.settings[:node_name_value] = "myhost.domain.com"
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
+
+      @agent.retrieve_catalog({})
+    end
+
+    it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+    end
+
+    it "should log and return the cached catalog when no catalog can be retrieved from the server" do
+      expects_fallback_to_cached_catalog(@catalog)
+
+      Puppet.expects(:info).with("Using cached catalog from environment 'production'")
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+    end
+
+    it "should set its cached_catalog_status to 'on_failure' when no catalog can be retrieved from the server" do
+      expects_fallback_to_cached_catalog(@catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
+
+    it "should not look in the cache for a catalog if one is returned from the server" do
+      expects_new_catalog_only(@catalog)
+
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+    end
+
+    it "should return the cached catalog when retrieving the remote catalog throws an exception" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
+    end
+
+    it "should set its cached_catalog_status to 'on_failure' when retrieving the remote catalog throws an exception" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
+
+    it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
+      Puppet[:usecacheonfailure] = false
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+
+      Puppet.expects(:warning).with('Not using cache on failed catalog')
+
+      expect(@agent.retrieve_catalog({})).to be_nil
+    end
+
+    it "should set its cached_catalog_status to 'not_used' if no catalog can be retrieved from the server and :usecacheonfailure is disabled or fails to retrieve a catalog" do
+      Puppet[:usecacheonfailure] = false
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
+    it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
+      expects_neither_new_or_cached_catalog
+
+      expect(@agent.retrieve_catalog({})).to be_nil
+    end
+
+    it "should return nil if its cached catalog environment doesn't match server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.instance_variable_set(:@node_environment, 'production')
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      Puppet.expects(:err).with("Not using cached catalog because its environment 'second_env' does not match 'production'")
+      expect(@agent.retrieve_catalog({})).to be_nil
+    end
+
+    it "should set its cached_catalog_status to 'not_used' if the cached catalog environment doesn't match server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.instance_variable_set(:@node_environment, 'production')
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
+    it "should return its cached catalog if the environment matches the server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
+      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+    end
+
+    it "should set its cached_catalog_status to 'on_failure' if the cached catalog environment matches server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
+      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
+  end
+
+  describe "when converting the catalog" do
+    before do
+      Puppet.settings.stubs(:use).returns(true)
+
+      catalog.stubs(:to_ral).returns ral_catalog
+    end
+
+    let (:catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
+    let (:ral_catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
+
+    it "should convert the catalog to a RAL-formed catalog" do
+      expect(@agent.convert_catalog(catalog, 10)).to equal(ral_catalog)
+    end
+
+    it "should finalize the catalog" do
+      ral_catalog.expects(:finalize)
+
+      @agent.convert_catalog(catalog, 10)
+    end
+
+    it "should record the passed retrieval time with the RAL catalog" do
+      ral_catalog.expects(:retrieval_duration=).with 10
+
+      @agent.convert_catalog(catalog, 10)
+    end
+
+    it "should write the RAL catalog's class file" do
+      ral_catalog.expects(:write_class_file)
+
+      @agent.convert_catalog(catalog, 10)
+    end
+
+    it "should write the RAL catalog's resource file" do
+      ral_catalog.expects(:write_resource_file)
+
+      @agent.convert_catalog(catalog, 10)
+    end
+  end
+
+  describe "when determining whether to pluginsync" do
+    it "should default to Puppet[:pluginsync] when explicitly set by the commandline" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_cli?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should default to Puppet[:pluginsync] when explicitly set by config" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_config?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should be true if use_cached_catalog is false" do
+      Puppet.settings[:use_cached_catalog] = false
+
+      expect(described_class).to be_should_pluginsync
+    end
+
+    it "should be false if use_cached_catalog is true" do
+      Puppet.settings[:use_cached_catalog] = true
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+  end
+end