puppet 4.10.0 → 5.0.0

data/spec/unit/application/face_base_spec.rb

@@ -341,9 +341,9 @@ describe Puppet::Application::FaceBase do
         end
       end
 
-      it "should render a non-trivially-keyed Hash with using pretty printed PSON" do
+      it "should render a non-trivially-keyed Hash with using pretty printed JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        expect(app.render(hash, {})).to eq(PSON.pretty_generate(hash).chomp)
+        expect(app.render(hash, {})).to eq(JSON.pretty_generate(hash).chomp)
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -356,7 +356,7 @@ describe Puppet::Application::FaceBase do
         expect(app.render(hash, {})).to eq <<EOT
 5      5
 6.0    6
-four   #{object.to_pson.chomp}
+four   #{object.to_json.chomp}
 one    1
 three  {}
 two    []
@@ -406,7 +406,7 @@ EOT
         json = app.render({ :one => 1, :two => 2 }, {})
         expect(json).to match(/"one":\s*1\b/)
         expect(json).to match(/"two":\s*2\b/)
-        expect(PSON.parse(json)).to eq({ "one" => 1, "two" => 2 })
+        expect(JSON.parse(json)).to eq({ "one" => 1, "two" => 2 })
       end
     end
 
@@ -421,8 +421,8 @@ EOT
       expect { app.run }.to exit_with(1)
     end
 
-    it "should work if asked to render a NetworkHandler format" do
-      app.command_line.stubs(:args).returns %w{count_args a b c --render-as pson}
+    it "should work if asked to render json" do
+      app.command_line.stubs(:args).returns %w{count_args a b c --render-as json}
       expect {
         expect { app.run }.to exit_with(0)
       }.to have_printed(/3/)

data/spec/unit/application/master_spec.rb

@@ -13,7 +13,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
     Puppet::Util::Log.stubs(:newdestination)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
-    Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.stubs(:terminus_class=)
     Puppet::Node::Facts.indirection.stubs(:cache_class=)
     Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
@@ -206,10 +205,27 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
         @master.setup
       end
+    end
 
+    it "should not set Puppet[:node_cache_terminus] by default" do
+      # This is normally called early in the application lifecycle but in our
+      # spec testing we don't actually do a full application initialization so
+      # we call it here to validate the (possibly) overridden settings are as we
+      # expect
+      @master.initialize_app_defaults
+      @master.setup
 
+      expect(Puppet[:node_cache_terminus]).to be(nil)
     end
 
+    it "should honor Puppet[:node_cache_terminus] by setting the cache_class to its value" do
+      # PUP-6060 - ensure we honor this value if specified
+      @master.initialize_app_defaults
+      Puppet[:node_cache_terminus] = 'plain'
+      @master.setup
+
+      expect(Puppet::Node.indirection.cache_class).to eq(:plain)
+    end
   end
 
   describe "when running" do
@@ -244,15 +260,15 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         expect { @master.compile }.to exit_with 0
       end
 
-      it "should convert the catalog to a pure-resource catalog and use 'PSON::pretty_generate' to pretty-print the catalog" do
+      it "should convert the catalog to a pure-resource catalog and use 'JSON::pretty_generate' to pretty-print the catalog" do
         catalog = Puppet::Resource::Catalog.new
-        PSON.stubs(:pretty_generate)
+        JSON.stubs(:pretty_generate)
         Puppet::Resource::Catalog.indirection.expects(:find).returns catalog
 
         catalog.expects(:to_resource).returns("rescat")
 
         @master.options[:node] = "foo"
-        PSON.expects(:pretty_generate).with('rescat', :allow_nan => true, :max_nesting => false)
+        JSON.expects(:pretty_generate).with('rescat', :allow_nan => true, :max_nesting => false)
 
         expect { @master.compile }.to exit_with 0
       end
@@ -339,7 +355,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       end
 
       it "should log a deprecation notice when running a WEBrick server" do
-        Puppet.expects(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppetlabs.com/deprecate-rack-webrick-servers for more information.")
+        Puppet.expects(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
 
         @master.main
       end
@@ -378,7 +394,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         end
 
         it "should log a deprecation notice" do
-          Puppet.expects(:deprecation_warning).with("The Rack Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppetlabs.com/deprecate-rack-webrick-servers for more information.")
+          Puppet.expects(:deprecation_warning).with("The Rack Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
 
           @master.main
         end

data/spec/unit/application/resource_spec.rb

@@ -2,6 +2,7 @@
 require 'spec_helper'
 
 require 'puppet/application/resource'
+require 'puppet_spec/character_encoding'
 
 describe Puppet::Application::Resource do
   include PuppetSpec::Files
@@ -50,7 +51,7 @@ describe Puppet::Application::Resource do
       # provider is a parameter that should always be available
       @resource_app.extra_params = [ :provider ]
 
-      expect { @resource_app.main }.to have_printed /provider\s+=>/
+      expect { @resource_app.main }.to have_printed(/provider\s+=>/)
     end
   end
 
@@ -88,6 +89,7 @@ describe Puppet::Application::Resource do
 
       @res = stub_everything "resource"
       @res.stubs(:prune_parameters).returns(@res)
+      @res.stubs(:to_manifest).returns("resource")
       @report = stub_everything "report"
 
       @resource_app.stubs(:puts)
@@ -129,6 +131,25 @@ describe Puppet::Application::Resource do
     end
   end
 
+  describe "when printing output" do
+    it "should ensure all values to be printed are in the external encoding" do
+      resources = [
+        Puppet::Type.type(:user).new(:name => "\u2603".force_encoding(Encoding::UTF_8)).to_resource,
+        Puppet::Type.type(:user).new(:name => "Jos\xE9".force_encoding(Encoding::ISO_8859_1)).to_resource
+      ]
+      Puppet::Resource.indirection.expects(:search).with('user/', {}).returns(resources)
+      @resource_app.command_line.stubs(:args).returns(['user'])
+
+      # All of our output should be in external encoding
+      @resource_app.expects(:puts).with { |args| expect(args.encoding).to eq(Encoding::ISO_8859_1) }
+
+      # This would raise an error if we weren't handling it
+      PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
+        expect { @resource_app.main }.not_to raise_error
+      end
+    end
+  end
+
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)
@@ -154,4 +175,21 @@ describe Puppet::Application::Resource do
       @resource_app.main
     end
   end
+
+  describe 'when handling a custom type' do
+    it 'the Puppet::Pops::Loaders instance is available' do
+      Puppet::Type.newtype(:testing) do
+        newparam(:name) do
+          isnamevar
+        end
+        def self.instances
+          fail('Loader not found') unless Puppet::Pops::Loaders.find_loader(nil).is_a?(Puppet::Pops::Loader::Loader)
+          @instances ||= [new(:name => name)]
+        end
+      end
+      @resource_app.command_line.stubs(:args).returns(['testing', 'hello'])
+      @resource_app.expects(:puts).with { |args| expect(args).to eql("testing { 'hello':\n}") }
+      expect { @resource_app.main }.not_to raise_error
+    end
+  end
 end

data/spec/unit/application_spec.rb

@@ -65,12 +65,6 @@ describe Puppet::Application do
         @klass.find("ThisShallNeverEverEverExist")
       }.to raise_error(LoadError)
     end
-
-    it "#12114: should prevent File namespace collisions" do
-      # have to require the file face once, then the second time around it would fail
-      expect(@klass.find("File")).to eq(Puppet::Application::File)
-      expect(@klass.find("File")).to eq(Puppet::Application::File)
-    end
   end
 
   describe "#available_application_names" do

data/spec/unit/capability_spec.rb

@@ -9,7 +9,6 @@ describe 'Capability types' do
   let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
   around :each do |example|
-    Puppet[:app_management] = true
     Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
     Puppet.override(:loaders => loaders, :current_environment => env) do
       Puppet::Type.newtype :cap, :is_capability => true do
@@ -19,7 +18,6 @@ describe 'Capability types' do
       example.run
       Puppet::Type.rmtype(:cap)
     end
-    Puppet[:app_management] = false
   end
 
   context 'annotations' do
@@ -402,10 +400,8 @@ test { one: hostname => "ahost", export => Cap[two] }
         ensure => directory
       }
 
-      if !defined(File["${same_dir}"]) {
-        file { $same_dir:
-          ensure => directory
-        }
+      file { $same_dir:
+        ensure => directory
       }
     PUPPET
 

data/spec/unit/configurer/fact_handler_spec.rb

@@ -69,28 +69,84 @@ describe Puppet::Configurer::FactHandler do
     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))
+  context "when serializing" do
+    facts_with_special_characters = [
+      { :hash => { 'afact' => 'a+b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Bb' + '%22%7D' },
+      { :hash => { 'afact' => 'a b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%20b' + '%22%7D' },
+      { :hash => { 'afact' => 'a&b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%26b' + '%22%7D' },
+      { :hash => { 'afact' => 'a*b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Ab' + '%22%7D' },
+      { :hash => { 'afact' => 'a=b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%3Db' + '%22%7D' },
+      # different UTF-8 widths
+      # 1-byte A
+      # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+      # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+      # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+      { :hash => { 'afact' => "A\u06FF\u16A0\u{2070E}" }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'A%DB%BF%E1%9A%A0%F0%A0%9C%8E' + '%22%7D' },
+    ]
+
+    context "as pson" do
+      before :each do
+        Puppet[:preferred_serialization_format] = 'pson'
+      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 = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
+
+        expect(text).to include('%22values%22%3A%7B%22my_name_fact%22%3A%22other_node_name%22%7D')
+        expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
+      end
+
+      facts_with_special_characters.each do |test_fact|
+        it "should properly accept the fact #{test_fact[:hash]}" do
+          facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
+          Puppet::Node::Facts.indirection.save(facts)
+          text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
+
+          to_upload = facthandler.facts_for_uploading
+          expect(to_upload).to eq({:facts_format => :pson, :facts => text})
+          expect(text).to include(test_fact[:encoded])
+
+          # this is not sufficient to test whether these values are sent via HTTP GET or HTTP POST in actual catalog request
+          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+        end
+      end
+    end
 
-    expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
-  end
+    context "as json" do
+      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 = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:json))
+
+        expect(text).to include('%22values%22%3A%7B%22my_name_fact%22%3A%22other_node_name%22%7D')
+        expect(facthandler.facts_for_uploading).to eq({:facts_format => 'application/json', :facts => text})
+      end
+
+      facts_with_special_characters.each do |test_fact|
+        it "should properly accept the fact #{test_fact[:hash]}" do
+          facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
+          Puppet::Node::Facts.indirection.save(facts)
+          text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:json))
+
+          to_upload = facthandler.facts_for_uploading
+          expect(to_upload).to eq({:facts_format => 'application/json', :facts => text})
+          expect(text).to include(test_fact[:encoded])
+
+          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+        end
+      end
+    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)
+    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')
+      # prefer URI.unescape but validate CGI also works
+      encoded_facts = facthandler.facts_for_uploading[:facts]
+      expect(URI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
+      expect(CGI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
+    end
   end
-
 end
-

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -14,29 +14,23 @@ describe Puppet::Configurer::PluginHandler do
     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 => [])
 
-    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)
 
-      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
-
-      pluginhandler.download_plugins(environment)
-    end
+    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])
+  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)
+    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
+    expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
   end
 end

data/spec/unit/configurer_spec.rb

@@ -117,7 +117,7 @@ describe Puppet::Configurer do
     end
 
     it "should initialize a transaction report if one is not provided" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns report
 
       @agent.run
@@ -127,14 +127,14 @@ describe Puppet::Configurer do
       Puppet[:node_name_fact] = 'my_name_fact'
       @facts.values = {'my_name_fact' => 'node_name_from_fact'}
 
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
 
       @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")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.stubs(:new).returns report
       @catalog.expects(:apply).with{|options| options[:report] == report}
 
@@ -142,14 +142,14 @@ describe Puppet::Configurer do
     end
 
     it "should use the provided report if it was passed one" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       @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 = Puppet::Transaction::Report.new
 
       report.expects(:<<).with(instance_of(Puppet::Util::Log)).at_least_once
 
@@ -199,8 +199,19 @@ describe Puppet::Configurer do
       @agent.run
     end
 
+    it "should create report with passed transaction_uuid and job_id" do
+      @agent = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, "test_tuuid", "test_jid")
+      @agent.stubs(:init_storage)
+
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
+      Puppet::Transaction::Report.expects(:new).with(anything, anything, 'test_tuuid', 'test_jid').returns(report)
+      @agent.expects(:send_report).with(report)
+
+      @agent.run
+    end
+
     it "should send the report" do
-      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -213,7 +224,7 @@ describe Puppet::Configurer do
     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")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -226,7 +237,7 @@ describe Puppet::Configurer do
     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")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -237,7 +248,7 @@ describe Puppet::Configurer do
     end
 
     it "should remove the report as a log destination when the run is finished" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       @agent.run
@@ -246,7 +257,7 @@ describe Puppet::Configurer do
     end
 
     it "should return the report exit_status as the result of the run" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
       report.expects(:exit_status).returns(1234)
 
@@ -254,7 +265,7 @@ describe Puppet::Configurer do
     end
 
     it "should send the transaction report even if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
@@ -265,7 +276,7 @@ describe Puppet::Configurer do
     end
 
     it "should include the pre-run command failure in the report" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
@@ -276,7 +287,7 @@ describe Puppet::Configurer do
     end
 
     it "should send the transaction report even if the post-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
@@ -287,7 +298,7 @@ describe Puppet::Configurer do
     end
 
     it "should include the post-run command failure in the report" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
@@ -308,7 +319,7 @@ describe Puppet::Configurer do
     end
 
     it "should finalize the report" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       report.expects(:finalize_report)
@@ -316,7 +327,7 @@ describe Puppet::Configurer do
     end
 
     it "should not apply the catalog if the pre-run command fails" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
@@ -329,7 +340,7 @@ describe Puppet::Configurer do
     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")
+      report = Puppet::Transaction::Report.new
       Puppet::Transaction::Report.expects(:new).returns(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
@@ -357,7 +368,7 @@ describe Puppet::Configurer do
     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")
+      report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
@@ -375,6 +386,12 @@ describe Puppet::Configurer do
       @agent.run
     end
 
+    it "sends the transaction uuid in a catalog request" do
+      @agent.instance_variable_set(:@job_id, 'aaa')
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:job_id => '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
@@ -440,7 +457,7 @@ describe Puppet::Configurer do
       @configurer = Puppet::Configurer.new
       Puppet[:lastrunfile] = tmpfile('last_run_file')
 
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
       Puppet[:reports] = "none"
     end
 

data/spec/unit/defaults_spec.rb

@@ -42,36 +42,6 @@ describe "Defaults" do
     end
   end
 
-  describe 'cfacter' do
-
-    before :each do
-      Facter.reset
-    end
-
-    it 'should default to false' do
-      expect(Puppet.settings[:cfacter]).to be_falsey
-    end
-
-    it 'should raise an error if cfacter is not installed' do
-      Puppet.features.stubs(:cfacter?).returns false
-      expect { Puppet.settings[:cfacter] = true }.to raise_exception ArgumentError, 'cfacter version 0.2.0 or later is not installed.'
-    end
-
-    it 'should raise an error if facter has already evaluated facts' do
-      Facter[:facterversion]
-      Puppet.features.stubs(:cfacter?).returns true
-      expect { Puppet.settings[:cfacter] = true }.to raise_exception ArgumentError, 'facter has already evaluated facts.'
-    end
-
-    it 'should initialize cfacter when set to true' do
-      Puppet.features.stubs(:cfacter?).returns true
-      CFacter = mock
-      CFacter.stubs(:initialize)
-      Puppet.settings[:cfacter] = true
-    end
-
-  end
-
   describe 'strict' do
     it 'should accept the valid value :off' do
       expect {Puppet.settings[:strict] = 'off'}.to_not raise_exception