puppet 5.0.0 → 6.0.0

data/spec/integration/application/apply_spec.rb

@@ -7,6 +7,8 @@ describe "apply" do
 
   before :each do
     Puppet[:reports] = "none"
+    # Let exceptions be raised instead of exiting
+    Puppet::Application.any_instance.stubs(:exit_on_fail).yields
   end
 
   describe "when applying provided catalogs" do
@@ -255,7 +257,7 @@ end
     expect(@logs.map(&:to_s)).to include(/{environment =>.*/)
   end
 
-  it "applies a given file even when an ENC is configured", :if => !Puppet.features.microsoft_windows? do
+  it "applies a given file even when an ENC is configured", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
     manifest = file_containing("manifest.pp", "notice('specific manifest applied')")
     enc = script_containing('enc_script',
       :windows => '@echo classes: []' + "\n" + '@echo environment: special',
@@ -376,7 +378,7 @@ end
     # External node script execution will fail, likely due to the tampering
     # with the basic file descriptors.
     # Workaround: Define a log destination and merely inspect logs.
-    context "with an ENC" do
+    context "with an ENC", :unless => RUBY_PLATFORM == 'java' do
       let(:logdest) { tmpfile('logdest') }
       let(:args) { ['-e', execute, '--logdest', logdest ] }
       let(:enc) do
@@ -406,7 +408,7 @@ end
     end
   end
 
-  context 'when compiling a provided catalog with rich data and then applying from file' do
+  context 'when applying from file' do
     include PuppetSpec::Compiler
 
     let(:env_dir) { tmpdir('environments') }
@@ -460,23 +462,27 @@ class amod::bad_type {
     let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'spec', 'modules')]) }
     let(:node) { Puppet::Node.new('test', :environment => env) }
 
-    around(:each) do |example|
+    before(:each) do
       Puppet[:rich_data] = rich_data
-      Puppet.override(:loaders => Puppet::Pops::Loaders.new(env)) { example.run }
+      Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+    end
+
+    after(:each) do
+      Puppet.pop_context()
     end
 
-    context 'and rich_data is set to false during compile' do
+    context 'and the file is not serialized with rich_data' do
       it 'will notify a string that is the result of Regexp#inspect (from Runtime3xConverter)' do
         catalog = compile_to_catalog(execute, node)
         apply = Puppet::Application[:apply]
         apply.options[:catalog] = file_containing('manifest', catalog.to_json)
-        apply.expects(:apply_catalog).with do |catalog|
-          catalog.resource(:notify, 'rx')['message'].is_a?(String)
-          catalog.resource(:notify, 'bin')['message'].is_a?(String)
-          catalog.resource(:notify, 'ver')['message'].is_a?(String)
-          catalog.resource(:notify, 'vrange')['message'].is_a?(String)
-          catalog.resource(:notify, 'tspan')['message'].is_a?(String)
-          catalog.resource(:notify, 'tstamp')['message'].is_a?(String)
+        apply.expects(:apply_catalog).with do |cat|
+          expect(cat.resource(:notify, 'rx')['message']).to be_a(String)
+          expect(cat.resource(:notify, 'bin')['message']).to be_a(String)
+          expect(cat.resource(:notify, 'ver')['message']).to be_a(String)
+          expect(cat.resource(:notify, 'vrange')['message']).to be_a(String)
+          expect(cat.resource(:notify, 'tspan')['message']).to be_a(String)
+          expect(cat.resource(:notify, 'tstamp')['message']).to be_a(String)
         end
         apply.run
       end
@@ -486,14 +492,14 @@ class amod::bad_type {
         apply = Puppet::Application[:apply]
         apply.options[:catalog] = file_containing('manifest', json)
         apply.expects(:apply_catalog).with do |catalog|
-          catalog.resource(:notify, 'bogus')['message'].is_a?(String)
+          expect(catalog.resource(:notify, 'bogus')['message']).to be_a(String)
         end
         apply.run
       end
 
       it 'will log a warning that a value of unknown type is converted into a string' do
         logs = []
-        json = Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
           compile_to_catalog('include amod::bad_type', node).to_json
         end
         logs = logs.select { |log| log.level == :warning }.map { |log| log.message }
@@ -502,20 +508,21 @@ class amod::bad_type {
       end
     end
 
-    context 'and rich_data is set to true during compile' do
-      let(:rich_data) { true }
-
+    context 'and the file is serialized with rich_data' do
       it 'will notify a regexp using Regexp#to_s' do
         catalog = compile_to_catalog(execute, node)
         apply = Puppet::Application[:apply]
-        apply.options[:catalog] = file_containing('manifest', catalog.to_json)
-        apply.expects(:apply_catalog).with do |catalog|
-          catalog.resource(:notify, 'rx')['message'].is_a?(Regexp)
-          catalog.resource(:notify, 'bin')['message'].is_a?(Puppet::Pops::Types::PBinaryType::Binary)
-          catalog.resource(:notify, 'ver')['message'].is_a?(SemanticPuppet::Version)
-          catalog.resource(:notify, 'vrange')['message'].is_a?(SemanticPuppet::VersionRange)
-          catalog.resource(:notify, 'tspan')['message'].is_a?(Puppet::Pops::Time::Timespan)
-          catalog.resource(:notify, 'tstamp')['message'].is_a?(Puppet::Pops::Time::Timestamp)
+        serialized_catalog = Puppet.override(rich_data: true) do
+          catalog.to_json
+        end
+        apply.options[:catalog] = file_containing('manifest', serialized_catalog)
+        apply.expects(:apply_catalog).with do |cat|
+          expect(cat.resource(:notify, 'rx')['message']).to be_a(Regexp)
+          expect(cat.resource(:notify, 'bin')['message']).to be_a(Puppet::Pops::Types::PBinaryType::Binary)
+          expect(cat.resource(:notify, 'ver')['message']).to be_a(SemanticPuppet::Version)
+          expect(cat.resource(:notify, 'vrange')['message']).to be_a(SemanticPuppet::VersionRange)
+          expect(cat.resource(:notify, 'tspan')['message']).to be_a(Puppet::Pops::Time::Timespan)
+          expect(cat.resource(:notify, 'tstamp')['message']).to be_a(Puppet::Pops::Time::Timestamp)
         end
         apply.run
       end

data/spec/integration/application/lookup_spec.rb

@@ -90,6 +90,27 @@ describe 'lookup' do
       expect(lookup('a')).to eql('value a')
     end
 
+    context 'uses node_terminus' do
+      require 'puppet/indirector/node/exec'
+      require 'puppet/indirector/node/plain'
+
+      let(:node) { Puppet::Node.new('testnode', :environment => env) }
+
+      it ':plain without --compile' do
+        Puppet.settings[:node_terminus] = 'exec'
+        Puppet::Node::Plain.any_instance.expects(:find).returns(node)
+        Puppet::Node::Exec.any_instance.expects(:find).never
+        expect(lookup('a')).to eql('value a')
+      end
+
+      it 'configured in Puppet settings with --compile' do
+        Puppet.settings[:node_terminus] = 'exec'
+        Puppet::Node::Plain.any_instance.expects(:find).never
+        Puppet::Node::Exec.any_instance.expects(:find).returns(node)
+        expect(lookup('a', :compile => true)).to eql('value a')
+      end
+    end
+
     context 'configured with the wrong environment' do
       let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
       it 'does not find data in non-existing environment' do

data/spec/integration/configurer_spec.rb

@@ -47,14 +47,11 @@ describe Puppet::Configurer do
       t2 = Time.now.tv_sec
 
       # sticky bit only applies to directories in windows
-      file_mode = Puppet.features.microsoft_windows? ? '666' : '100666'
+      file_mode = Puppet::Util::Platform.windows? ? '666' : '100666'
 
       expect(Puppet::FileSystem.stat(Puppet[:lastrunfile]).mode.to_s(8)).to eq(file_mode)
 
-      summary = nil
-      File.open(Puppet[:lastrunfile], "r") do |fd|
-        summary = YAML.load(fd.read)
-      end
+      summary = Puppet::Util::Yaml.safe_load_file(Puppet[:lastrunfile])
 
       expect(summary).to be_a(Hash)
       %w{time changes events resources}.each do |key|

data/spec/integration/data_binding_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'puppet/indirector/hiera'
 
 require 'puppet_spec/compiler'
 

data/spec/integration/defaults_spec.rb

@@ -115,7 +115,7 @@ describe "Puppet defaults" do
     end
   end
 
-  describe "on a Windows-like platform it", :if => Puppet.features.microsoft_windows? do
+  describe "on a Windows-like platform it", :if => Puppet::Util::Platform.windows? do
     let (:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
 
     it "path should not add anything" do
@@ -163,11 +163,6 @@ describe "Puppet defaults" do
     end
   end
 
-  it "should have a :caname setting that defaults to the cert name" do
-    Puppet.settings[:certname] = "foo"
-    expect(Puppet.settings[:ca_name]).to eq("Puppet CA: foo")
-  end
-
   it "should have a 'prerun_command' that defaults to the empty string" do
     expect(Puppet.settings[:prerun_command]).to eq("")
   end
@@ -196,11 +191,11 @@ describe "Puppet defaults" do
   end
 
   describe "daemonize" do
-    it "should default to true", :unless => Puppet.features.microsoft_windows? do
+    it "should default to true", :unless => Puppet::Util::Platform.windows? do
       expect(Puppet.settings[:daemonize]).to eq(true)
     end
 
-    describe "on Windows", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows", :if => Puppet::Util::Platform.windows? do
       it "should default to false" do
         expect(Puppet.settings[:daemonize]).to eq(false)
       end
@@ -212,11 +207,11 @@ describe "Puppet defaults" do
   end
 
   describe "diff" do
-    it "should default to 'diff' on POSIX", :unless => Puppet.features.microsoft_windows? do
+    it "should default to 'diff' on POSIX", :unless => Puppet::Util::Platform.windows? do
       expect(Puppet.settings[:diff]).to eq('diff')
     end
 
-    it "should default to '' on Windows", :if => Puppet.features.microsoft_windows? do
+    it "should default to '' on Windows", :if => Puppet::Util::Platform.windows? do
       expect(Puppet.settings[:diff]).to eq('')
     end
   end

data/spec/integration/faces/config_spec.rb

@@ -57,11 +57,21 @@ rando_key=foobar
   end
 
   context 'when getting / setting UTF8 values' do
+
+    let(:config) { described_class }
+
+    def render(action, result)
+      config.get_action(action).when_rendering(:console).call(result)
+    end
+
+    before :each do
+      subject.stubs(:report_section_and_environment)
+    end
+
     # key must be a defined setting
     ['rando_key', MIXED_UTF8].each do |key|
       it "can change '#{key}' keyed ASCII value to a UTF-8 value and read it back" do
-        key = "rando_key"
-        value = "value#{MIXED_UTF8.reverse}value"
+        value = "value#{key.reverse}value"
 
         # needed for the subject.set to write to correct file
         Puppet.settings.stubs(:which_configuration_file).returns(tmp_config)
@@ -72,8 +82,10 @@ rando_key=foobar
         # instead of the default Puppet.settings (implementation detail)
         Puppet.stubs(:settings).returns(test_settings)
 
-        expect { subject.print() }.to have_printed("#{key} = #{value}")
-        expect { subject.print(key, :section => 'main') }.to have_printed("#{value}")
+        result = subject.print()
+        expect(render(:print, result)).to match(/^#{key} = #{value}$/)
+        result = subject.print(key, :section => 'main')
+        expect(render(:print, result)).to eq("#{value}\n")
       end
     end
   end

data/spec/integration/faces/plugin_spec.rb

@@ -3,6 +3,8 @@ require 'puppet/face'
 require 'puppet/file_serving/metadata'
 require 'puppet/file_serving/content'
 require 'puppet/indirector/memory'
+require 'puppet/indirector/file_metadata'
+require 'puppet/indirector/file_content'
 
 module PuppetFaceIntegrationSpecs
 describe "Puppet plugin face" do
@@ -28,6 +30,7 @@ describe "Puppet plugin face" do
   before do
     FileUtils.mkdir(File.join(Puppet[:vardir], 'lib'))
     FileUtils.mkdir(File.join(Puppet[:vardir], 'facts.d'))
+    FileUtils.mkdir(File.join(Puppet[:vardir], 'locales'))
     @termini_classes = {}
     INDIRECTED_CLASSES.each do |indirected|
       @termini_classes[indirected] = indirected.indirection.terminus_class

data/spec/integration/file_bucket/file_spec.rb

@@ -11,23 +11,6 @@ describe Puppet::FileBucket::File do
       described_class.indirection.terminus(:rest).class.any_instance.stubs(:find)
     end
 
-    describe "when running the master application" do
-      before :each do
-        Puppet::Application[:master].setup_terminuses
-      end
-
-      {
-        "md5/d41d8cd98f00b204e9800998ecf8427e" => :file,
-        "filebucket://puppetmaster:8140/md5/d41d8cd98f00b204e9800998ecf8427e" => :file,
-      }.each do |key, terminus|
-        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
-
-          described_class.indirection.find(key)
-        end
-      end
-    end
-
     describe "when running another application" do
       {
         "md5/d41d8cd98f00b204e9800998ecf8427e" => :file,
@@ -43,12 +26,27 @@ describe Puppet::FileBucket::File do
   end
 
   describe "saving binary files" do
-    let(:binary) { "\xD1\xF2\r\n\x81NuSc\x00".force_encoding(Encoding::ASCII_8BIT) }
+    context "given multiple backups of identical files" do
+      it "does not error given content with binary external encoding" do
+        binary = "\xD1\xF2\r\n\x81NuSc\x00".force_encoding(Encoding::ASCII_8BIT)
+        bucket_file = Puppet::FileBucket::File.new(binary)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+      end
 
-    it "does not error when the same contents are saved twice" do
-      bucket_file = Puppet::FileBucket::File.new(binary)
-      Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
-      Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+      it "also does not error if the content is reported with UTF-8 external encoding" do
+        # PUP-7951 - ensure accurate size comparison across encodings If binary
+        # content arrives as a string with UTF-8 default external encoding, its
+        # character count might be different than the same bytes with binary
+        # external encoding. Ensure our equality comparison does not fail due to this.
+        # As would be the case with our friend snowman:
+        # Unicode snowman \u2603 - \xE2 \x98 \x83
+        # character size 1, if interpreted as UTF-8, 3 "characters" if interpreted as binary
+        utf8 = "\u2603".force_encoding(Encoding::UTF_8)
+        bucket_file = Puppet::FileBucket::File.new(utf8)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+      end
     end
   end
 end

data/spec/integration/file_system/uniquefile_spec.rb

@@ -1,29 +1,26 @@
-require 'spec_helper'
-
-describe Puppet::FileSystem::Uniquefile do
-
-  describe "#open_tmp on Windows", :if => Puppet.features.microsoft_windows? do
-
-    describe "with UTF8 characters" do
-      include PuppetSpec::Files
-
-      let(:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
-      let(:temp_rune_utf8) { tmpdir(rune_utf8) }
-
-      it "should use UTF8 characters in TMP,TEMP,TMPDIR environment variable" do
-        # Set the temporary environment variables to the UTF8 temp path
-        Puppet::Util::Windows::Process.set_environment_variable('TMPDIR', temp_rune_utf8)
-        Puppet::Util::Windows::Process.set_environment_variable('TMP', temp_rune_utf8)
-        Puppet::Util::Windows::Process.set_environment_variable('TEMP', temp_rune_utf8)
-
-        # Create a unique file
-        filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-          File.dirname(file.path)
-        end
-
-        expect(filename).to eq(temp_rune_utf8)
-      end
-    end
-  end
-
-end
+require 'spec_helper'
+
+describe Puppet::FileSystem::Uniquefile do
+  describe "#open_tmp on Windows", :if => Puppet::Util::Platform.windows? do
+    describe "with UTF8 characters" do
+      include PuppetSpec::Files
+
+      let(:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+      let(:temp_rune_utf8) { tmpdir(rune_utf8) }
+
+      it "should use UTF8 characters in TMP,TEMP,TMPDIR environment variable" do
+        # Set the temporary environment variables to the UTF8 temp path
+        Puppet::Util::Windows::Process.set_environment_variable('TMPDIR', temp_rune_utf8)
+        Puppet::Util::Windows::Process.set_environment_variable('TMP', temp_rune_utf8)
+        Puppet::Util::Windows::Process.set_environment_variable('TEMP', temp_rune_utf8)
+
+        # Create a unique file
+        filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
+          File.dirname(file.path)
+        end
+
+        expect(filename).to eq(temp_rune_utf8)
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-
 require 'puppet_spec/files'
 require 'puppet_spec/compiler'
+require 'puppet/indirector/facts/facter'
 
 describe Puppet::Node::Facts::Facter do
   include PuppetSpec::Files
@@ -46,22 +46,12 @@ describe Puppet::Node::Facts::Facter do
     end
 
     it "should resolve external facts" do
-      external_fact = File.join(factdir, 'external')
+      external_fact = File.join(factdir, 'external.json')
 
-      if Puppet.features.microsoft_windows?
-        external_fact += '.bat'
-        File.open(external_fact, 'wb') { |file| file.write(<<-EOF)}
-        @echo foo=bar
-        EOF
-      else
-        File.open(external_fact, 'wb') { |file| file.write(<<-EOF)}
-        #!/bin/sh
-        echo "foo=bar"
+      File.open(external_fact, 'wb') { |file| file.write(<<-EOF)}
+        {"foo": "bar"}
         EOF
 
-        Puppet::FileSystem.chmod(0755, external_fact)
-      end
-
       Puppet.initialize_settings(['--pluginfactdest', factdir])
       apply = Puppet::Application.find(:apply).new(stub('command_line', :subcommand_name => :apply, :args => ['--pluginfactdest', factdir, '-e', 'notify { $foo: }']))
 

data/spec/integration/indirector/file_content/file_server_spec.rb

@@ -57,6 +57,23 @@ describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
     expect(result.content).to eq("1\r\n")
   end
 
+  it "should find file content of tasks in modules" do
+    path = tmpfile("task_file_content")
+    Dir.mkdir(path)
+
+    modpath = File.join(path, "myothermod")
+    FileUtils.mkdir_p(File.join(modpath, "tasks"))
+    file = File.join(modpath, "tasks", "mytask")
+    File.open(file, "wb") { |f| f.write "I'm a task" }
+
+    env = Puppet::Node::Environment.create(:foo, [path])
+    result = Puppet::FileServing::Content.indirection.find("tasks/myothermod/mytask", :environment => env)
+
+    expect(result).not_to be_nil
+    expect(result).to be_instance_of(Puppet::FileServing::Content)
+    expect(result.content).to eq("I'm a task")
+  end
+
   it "should find file content in files when node name expansions are used" do
     Puppet::FileSystem.stubs(:exist?).returns true
     Puppet::FileSystem.stubs(:exist?).with(Puppet[:fileserverconfig]).returns(true)

data/spec/integration/indirector/file_metadata/file_server_spec.rb

@@ -42,6 +42,16 @@ describe Puppet::Indirector::FileMetadata::FileServer, " when finding files" do
     end
   end
 
+  describe "that are tasks in modules" do
+    with_checksum_types("task_file_content", "mymod/tasks/mytask") do
+      it "should return the correct metadata" do
+        env = Puppet::Node::Environment.create(:foo, [env_path])
+        result = Puppet::FileServing::Metadata.indirection.find("tasks/mymod/mytask", :environment => env, :checksum_type => checksum_type)
+        expect_correct_checksum(result, checksum_type, checksum, Puppet::FileServing::Metadata)
+      end
+    end
+  end
+
   describe "when node name expansions are used" do
     with_checksum_types("file_server_testing", "mynode/myfile") do
       it "should return the correct metadata" do

data/spec/integration/network/authconfig_spec.rb

@@ -97,13 +97,13 @@ describe Puppet::Network::AuthConfig do
     it 'should warn about missing path before allow_ip in stanza' do
       expect {
         add_raw_stanza("allow_ip 10.0.0.1\n")
-      }.to raise_error Puppet::ConfigurationError, /Missing or invalid 'path' before right directive at line.*/
+      }.to raise_error Puppet::ConfigurationError, /Missing or invalid 'path' before right directive at \(line: .*\)/
     end
 
     it 'should warn about missing path before allow in stanza' do
       expect {
         add_raw_stanza("allow host.domain.com\n")
-      }.to raise_error Puppet::ConfigurationError, /Missing or invalid 'path' before right directive at line.*/
+      }.to raise_error Puppet::ConfigurationError, /Missing or invalid 'path' before right directive at \(line: .*\)/
     end
 
     it "should support hostname backreferences" do

data/spec/integration/network/http/api/indirected_routes_spec.rb

@@ -1,13 +1,12 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/api/indirected_routes'
-require 'rack/mock' if Puppet.features.rack?
-require 'puppet/network/http/rack/rest'
 require 'puppet/indirector_proxy'
 require 'puppet_spec/files'
 require 'puppet_spec/network'
-require 'json'
+require 'puppet/util/json'
+require 'puppet/file_serving/content'
+require 'puppet/file_serving/metadata'
 
 describe Puppet::Network::HTTP::API::IndirectedRoutes do
   include PuppetSpec::Files
@@ -16,7 +15,10 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
   describe "when running the master application" do
     before :each do
-      Puppet::Application[:master].setup_terminuses
+      Puppet::FileServing::Content.indirection.terminus_class = :file_server
+      Puppet::FileServing::Metadata.indirection.terminus_class = :file_server
+
+      Puppet::FileBucket::File.indirection.terminus_class = :file
     end
 
     describe "using Puppet API to request file metadata" do
@@ -33,7 +35,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
                                          {:accept_header => 'unknown, text/pson'},
                                          {:environment => 'production', :checksum_type => checksum_type})
           handler.call(request, response)
-          resp = JSON.parse(response.body)
+          resp = Puppet::Util::Json.load(response.body)
 
           expect(resp['checksum']['type']).to eq(checksum_type)
           expect(checksum_valid(checksum_type, checksum, resp['checksum']['value'])).to be_truthy
@@ -44,7 +46,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
                                             {:accept_header => 'unknown, text/pson'},
                                             {:environment => 'production', :checksum_type => checksum_type, :recurse => 'yes'})
           handler.call(request, response)
-          resp = JSON.parse(response.body)
+          resp = Puppet::Util::Json.load(response.body)
 
           expect(resp.length).to eq(2)
           file = resp.find {|x| x['relative_path'] == 'file.rb'}
@@ -54,36 +56,5 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
         end
       end
     end
-
-    describe "an error from IndirectedRoutes", :if => Puppet.features.rack? do
-      let(:handler) { Puppet::Network::HTTP::RackREST.new }
-
-      describe "returns json" do
-        it "when a standard error" do
-          response = Rack::Response.new
-          request = Rack::Request.new(
-            Rack::MockRequest.env_for("/puppet/v3/invalid-indirector"))
-
-          handler.process(request, response)
-
-          expect(response.header["Content-Type"]).to match(/json/)
-          resp = JSON.parse(response.body.first)
-          expect(resp["message"]).to match(/The indirection name must be purely alphanumeric/)
-          expect(resp["issue_kind"]).to be_a_kind_of(String)
-        end
-        it "when a server error" do
-          response = Rack::Response.new
-          request = Rack::Request.new(
-            Rack::MockRequest.env_for("/puppet/v3/unknown_indirector"))
-
-          handler.process(request, response)
-
-          expect(response.header["Content-Type"]).to match(/json/)
-          resp = JSON.parse(response.body.first)
-          expect(resp["message"]).to match(/Could not find indirection/)
-          expect(resp["issue_kind"]).to be_a_kind_of(String)
-        end
-      end
-    end
   end
 end

data/spec/integration/node/environment_spec.rb

@@ -141,7 +141,7 @@ describe Puppet::Node::Environment do
       :strict_variables => true
   end
 
-  describe "#extralibs on Windows", :if => Puppet.features.microsoft_windows? do
+  describe "#extralibs on Windows", :if => Puppet::Util::Platform.windows? do
 
     describe "with UTF8 characters in PUPPETLIB" do
       let(:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }

data/spec/integration/node_spec.rb

@@ -25,10 +25,6 @@ describe Puppet::Node do
       expect(Puppet::Node.indirection.find(@name)).to be_nil
     end
 
-    it "should have an ldap terminus" do
-      expect(Puppet::Node.indirection.terminus(:ldap)).not_to be_nil
-    end
-
     it "should be able to use the plain terminus" do
       Puppet::Node.indirection.stubs(:terminus_class).returns :plain
 

data/spec/integration/parser/catalog_spec.rb

@@ -11,12 +11,16 @@ describe "A catalog" do
     let(:node) { Puppet::Node.new('test', :environment => env) }
     let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
-    around :each do |example|
+    before(:each) do
+      Puppet.push_context({:loaders => loaders, :current_environment => env})
+    end
+
+    after(:each) do
+      Puppet.pop_context()
+    end
+
+    before(:each) do
       Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
-      Puppet.override(:loaders => loaders, :current_environment => env) do
-        example.run
-        Puppet::Pops::Loaders.clear
-      end
     end
 
     context "when transmitted to the agent" do
@@ -90,7 +94,7 @@ describe "A catalog" do
   end
 
   def master_catalog_for(manifest)
-    master_catalog = Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest, node))
+    Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest, node))
   end
 
   def master_and_agent_catalogs_for(manifest)