puppet 7.24.0-universal-darwin → 8.0.1-universal-darwin

data/spec/integration/http/client_spec.rb

@@ -53,7 +53,7 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
         expect {
           client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: alt_context})
         }.to raise_error(Puppet::SSL::CertVerifyError,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                         %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
       end
     end
 
@@ -170,7 +170,7 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
         expect {
           client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: system_context})
         }.to raise_error(Puppet::SSL::CertVerifyError,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                         %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
       end
     end
   end

data/spec/integration/network/formats_spec.rb

@@ -43,7 +43,7 @@ describe Puppet::Network::FormatHandler.format(:s) do
   end
 end
 
-describe Puppet::Network::FormatHandler.format(:pson) do
+describe Puppet::Network::FormatHandler.format(:pson), if: Puppet.features.pson? do
   before do
     @pson = Puppet::Network::FormatHandler.format(:pson)
   end

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

@@ -32,7 +32,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
         it "should find the file metadata with expected checksum" do
           request = a_request_that_finds(Puppet::IndirectorProxy.new("modules/lib/file.rb", "file_metadata"),
-                                         {:accept_header => 'unknown, text/pson'},
+                                         {:accept_header => 'unknown, application/json'},
                                          {:environment => 'production', :checksum_type => checksum_type})
           handler.call(request, response)
           resp = Puppet::Util::Json.load(response.body)
@@ -43,7 +43,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
         it "should search for the file metadata with expected checksum" do
           request = a_request_that_searches(Puppet::IndirectorProxy.new("modules/lib", "file_metadata"),
-                                            {:accept_header => 'unknown, text/pson'},
+                                            {:accept_header => 'unknown, application/json'},
                                             {:environment => 'production', :checksum_type => checksum_type, :recurse => 'yes'})
           handler.call(request, response)
           resp = Puppet::Util::Json.load(response.body)

data/spec/integration/network/http_pool_spec.rb

@@ -77,7 +77,7 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
           expect {
             http.get('/')
           }.to raise_error(Puppet::Error,
-                           %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                           %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
         end
       end
 
@@ -219,7 +219,7 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
         expect {
           http.get('/')
         }.to raise_error(Puppet::Error,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                         %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
       end
     end
 

data/spec/integration/node/facts_spec.rb

@@ -30,9 +30,9 @@ describe Puppet::Node::Facts do
     it "should be able to delegate to the :facter terminus" do
       allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:facter)
 
-      expect(Facter).to receive(:to_hash).and_return("facter_hash")
+      expect(Facter).to receive(:resolve).and_return({1 => 2})
       facts = Puppet::Node::Facts.new("me")
-      expect(Puppet::Node::Facts).to receive(:new).with("me", "facter_hash").and_return(facts)
+      expect(Puppet::Node::Facts).to receive(:new).with("me", {1 => 2}).and_return(facts)
 
       expect(Puppet::Node::Facts.indirection.find("me")).to equal(facts)
     end

data/spec/integration/parser/compiler_spec.rb

@@ -158,7 +158,7 @@ describe Puppet::Parser::Compiler do
     it 'makes $settings::strict available as string' do
       node = Puppet::Node.new("testing")
       catalog = compile_to_catalog(<<-MANIFEST, node)
-          notify { 'test': message => $settings::strict == 'warning' }
+          notify { 'test': message => $settings::strict == 'error' }
       MANIFEST
       expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
     end
@@ -174,7 +174,7 @@ describe Puppet::Parser::Compiler do
     it 'makes all server settings available as $settings::all_local hash' do
       node = Puppet::Node.new("testing")
       catalog = compile_to_catalog(<<-MANIFEST, node)
-          notify { 'test': message => $settings::all_local['strict'] == 'warning' }
+          notify { 'test': message => $settings::all_local['strict'] == 'error' }
       MANIFEST
       expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
     end
@@ -693,8 +693,19 @@ describe Puppet::Parser::Compiler do
         end.to raise_error(/Illegal variable name/)
       end
 
-      it 'a missing variable as default value becomes undef' do
-        # strict variables not on
+      it 'a missing variable as default causes an evaluation error' do
+        # strict mode on by default for 8.x
+        expect {
+          compile_to_catalog(<<-MANIFEST)
+          class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
+            include a
+          MANIFEST
+        }.to raise_error(/Evaluation Error: Unknown variable: 'x'/)
+      end
+
+      it 'a missing variable as default value becomes undef when strict mode is off' do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         catalog = compile_to_catalog(<<-MANIFEST)
         class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
           include a

data/spec/integration/parser/conditionals_spec.rb

@@ -68,6 +68,9 @@ describe "Evaluation of Conditionals" do
     end
 
     it "evaluates undefined variables as false" do
+      # strict mode is off so behavior this test is trying to check isn't stubbed out
+      Puppet[:strict_variables] = false
+      Puppet[:strict] = :warning
       catalog = compile_to_catalog(<<-CODE)
       if $undef_var {
       } else {

data/spec/integration/parser/scope_spec.rb

@@ -276,6 +276,9 @@ describe "Two step scoping for variables" do
 
     ['a:.b', '::a::b'].each do |ref|
       it "does not resolve a qualified name on the form #{ref} against top scope" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         expect_the_message_not_to_be("from topscope") do <<-"MANIFEST"
               class c {
                 notify { 'something': message => "$#{ref}" }
@@ -297,6 +300,9 @@ describe "Two step scoping for variables" do
 
     ['a:.b', '::a::b'].each do |ref|
       it "does not resolve a qualified name on the form #{ref} against node scope" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         expect_the_message_not_to_be("from node") do <<-MANIFEST
               class c {
                 notify { 'something': message => "$a::b" }
@@ -626,8 +632,9 @@ describe "Two step scoping for variables" do
       end
     end
 
-    it "finds nil when the only set variable is in the dynamic scope" do
-      expect_the_message_to_be(nil) do <<-MANIFEST
+    it "raises an evaluation error when the only set variable is in the dynamic scope" do
+      expect {
+        compile_to_catalog(<<-MANIFEST)
             node default {
               include baz
             }
@@ -641,7 +648,7 @@ describe "Two step scoping for variables" do
               include bar
             }
         MANIFEST
-      end
+      }.to raise_error(/Evaluation Error: Unknown variable: 'var'./)
     end
 
     it "ignores the value in the dynamic scope for a defined type" do

data/spec/integration/type/file_spec.rb

@@ -1710,11 +1710,11 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
   describe "when using validate_cmd" do
     test_cmd = '/bin/test'
-    if Puppet.runtime[:facter].value(:osfamily) == 'Debian'
+    if Puppet.runtime[:facter].value('os.family') == 'Debian'
       test_cmd = '/usr/bin/test'
     end
 
-    if Puppet.runtime[:facter].value(:operatingsystem) == 'Darwin'
+    if Puppet.runtime[:facter].value('os.name') == 'Darwin'
       stat_cmd = "stat -f '%Lp'"
     else
       stat_cmd = "stat --format=%a"

data/spec/integration/type/package_spec.rb

@@ -21,19 +21,19 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
     when 'Darwin'
       :pkgdmg
     when 'RedHat'
-      if ['2.1', '3', '4'].include?(Puppet.runtime[:facter].value(:lsbdistrelease))
+      if ['2.1', '3', '4'].include?(Puppet.runtime[:facter].value('os.distro.release.full'))
         :up2date
       else
         :yum
       end
     when 'Fedora'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '22') >= 0
+      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.major'), '22') >= 0
         :dnf
       else
         :yum
       end
     when 'Suse'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '10') >= 0
+      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.major'), '10') >= 0
         :zypper
       else
         :rug
@@ -54,8 +54,8 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
   end
 
   it "should choose the correct provider each platform" do
-    unless default_provider = provider_name(Puppet.runtime[:facter].value(:operatingsystem))
-      pending("No default provider specified in this test for #{Puppet.runtime[:facter].value(:operatingsystem)}")
+    unless default_provider = provider_name(Puppet.runtime[:facter].value('os.name'))
+      pending("No default provider specified in this test for #{Puppet.runtime[:facter].value('os.name')}")
     end
     expect(Puppet::Type.type(:package).defaultprovider.name).to eq(default_provider)
   end

data/spec/integration/util_spec.rb

@@ -96,7 +96,7 @@ describe Puppet::Util do
       Puppet::FileSystem.touch(filepath)
 
       path = [utf8, "c:\\windows\\system32", "c:\\windows"].join(File::PATH_SEPARATOR)
-      Puppet::Util.withenv( { "PATH" => path } , :windows) do
+      Puppet::Util.withenv("PATH" => path) do
         expect(Puppet::Util.which(filename)).to eq(filepath)
       end
     end

data/spec/lib/puppet_spec/network.rb

@@ -33,6 +33,24 @@ module PuppetSpec::Network
     { :environment => "production" }
   end
 
+  def acceptable_content_types
+    types = ['application/json']
+    types << 'application/x-msgpack' if Puppet.features.msgpack?
+    types << 'text/pson' if Puppet.features.pson?
+    types
+  end
+
+  def acceptable_content_types_string
+    acceptable_content_types.join(', ')
+  end
+
+  def acceptable_catalog_content_types
+    types = %w[application/vnd.puppet.rich+json application/json]
+    types.concat(%w[application/vnd.puppet.rich+msgpack application/x-msgpack]) if Puppet.features.msgpack?
+    types << 'text/pson' if Puppet.features.pson?
+    types
+  end
+
   def master_url_prefix
     "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3"
   end

data/spec/shared_examples/rhel_package_provider.rb

@@ -69,7 +69,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
         allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
         allow(provider).to receive(:which).with("rpm").and_return("/bin/rpm")
         expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).and_return(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most(:once)
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('6')
+        allow(Facter).to receive(:value).with('os.release.major').and_return('6')
       end
 
       it "should call #{provider_name} install for :installed" do
@@ -81,7 +81,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
       if provider_name == 'yum'
         context 'on el-5' do
           before(:each) do
-            allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('5')
+            allow(Facter).to receive(:value).with('os.release.major').and_return('5')
           end
 
           it "should catch #{provider_name} install failures when status code is wrong" do

data/spec/unit/application/device_spec.rb

@@ -482,10 +482,10 @@ describe Puppet::Application::Device do
         end
 
         it "retrieves facts" do
-          indirection_fact_values = {"operatingsystem"=>"cisco_ios","clientcert"=>"3750"}
+          indirection_fact_values = {"os"=> {"name" => "cisco_ios"},"clientcert"=>"3750"}
           indirection_facts = Puppet::Node::Facts.new("nil", indirection_fact_values)
           expect(Puppet::Node::Facts.indirection).to receive(:find).with(nil, anything()).and_return(indirection_facts)
-          expect(device).to receive(:puts).with(/name.*3750.*\n.*values.*\n.*operatingsystem.*cisco_ios/)
+          expect(device).to receive(:puts).with(/name.*3750.*\n.*values.*\n.*os.*\n.*name.*cisco_ios/)
           expect { device.main }.to exit_with 0
         end
       end

data/spec/unit/application/lookup_spec.rb

@@ -503,6 +503,9 @@ Searching for "a"
       include PuppetSpec::Files
 
       it "is unaffected by global variables unless '--compile' is used" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         lookup.options[:node] = node
         lookup.options[:render_as] = :s
         allow(lookup.command_line).to receive(:args).and_return(['c'])
@@ -673,6 +676,9 @@ Searching for "a"
       let(:node) { Puppet::Node.new("testnode", :facts => facts, :environment => 'puppet_func_provider') }
 
       it "works OK in the absense of '--compile'" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         lookup.options[:node] = node
         allow(lookup.command_line).to receive(:args).and_return(['c'])
         lookup.options[:render_as] = :s

data/spec/unit/application/resource_spec.rb

@@ -129,22 +129,24 @@ describe Puppet::Application::Resource do
   end
 
   describe "when printing output" do
-    it "should not emit puppet class tags when printing yaml" do
-      Puppet::Type.newtype(:stringify) do
-        ensurable
-        newparam(:name, isnamevar: true)
-        newproperty(:string)
-      end
+    Puppet::Type.newtype(:stringify) do
+      ensurable
+      newparam(:name, isnamevar: true)
+      newproperty(:string)
+    end
 
-      Puppet::Type.type(:stringify).provide(:stringify) do
-        def exists?
-          true
-        end
+    Puppet::Type.type(:stringify).provide(:stringify) do
+      def exists?
+        true
+      end
 
-        def string
-          Puppet::Util::Execution::ProcessOutput.new('test', 0)
-        end
+      def string
+        Puppet::Util::Execution::ProcessOutput.new('test', 0)
       end
+    end
+    
+    it "should not emit puppet class tags when printing yaml when strict mode is off" do
+      Puppet[:strict] = :warning
 
       @resource_app.options[:to_yaml] = true
       allow(@resource_app.command_line).to receive(:args).and_return(['stringify', 'hello', 'ensure=present', 'string=asd'])
@@ -158,6 +160,13 @@ describe Puppet::Application::Resource do
       expect { @resource_app.main }.not_to raise_error
     end
 
+    it "should raise an error when printing yaml by default" do
+      @resource_app.options[:to_yaml] = true
+      allow(@resource_app.command_line).to receive(:args).and_return(['stringify', 'hello', 'ensure=present', 'string=asd'])
+      expect { @resource_app.main }.to raise_error( Puppet::PreformattedError,
+        /Stringify\[hello\]\['string'\] contains a Puppet::Util::Execution::ProcessOutput value. It will be converted to the String 'test'/)
+    end
+
     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,

data/spec/unit/configurer/fact_handler_spec.rb

@@ -79,7 +79,7 @@ describe Puppet::Configurer::FactHandler do
       { :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
+    context "as pson", if: Puppet.features.pson? do
       before :each do
         Puppet[:preferred_serialization_format] = 'pson'
       end

data/spec/unit/confine_spec.rb

@@ -84,16 +84,16 @@ describe Puppet::Confine do
   describe "when requiring" do
     it "does not cache failed requires when always_retry_plugins is true" do
       Puppet[:always_retry_plugins] = true
-      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').twice.and_raise(LoadError)
-      Puppet::Confine.test(:osfamily)
-      Puppet::Confine.test(:osfamily)
+      expect(Puppet::Confine).to receive(:require).with('puppet/confine/os.family').twice.and_raise(LoadError)
+      Puppet::Confine.test('os.family')
+      Puppet::Confine.test('os.family')
     end
 
     it "caches failed requires when always_retry_plugins is false" do
       Puppet[:always_retry_plugins] = false
-      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').once.and_raise(LoadError)
-      Puppet::Confine.test(:osfamily)
-      Puppet::Confine.test(:osfamily)
+      expect(Puppet::Confine).to receive(:require).with('puppet/confine/os.family').once.and_raise(LoadError)
+      Puppet::Confine.test('os.family')
+      Puppet::Confine.test('os.family')
     end
   end
 end

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -35,6 +35,7 @@ describe "when using a hiera data provider" do
     node = Puppet::Node.new("testnode", :facts => facts, :environment => environment)
     compiler = Puppet::Parser::Compiler.new(node)
     compiler.topscope['domain'] = 'example.com'
+    compiler.topscope['my_fact'] = 'server3'
     block_given? ? compiler.compile { |catalog| yield(compiler); catalog } : compiler.compile
   end
 
@@ -164,6 +165,7 @@ describe "when using a hiera data provider" do
     expect(extract_notifications(compiler.compile)).to include('server2')
 
     compiler = Puppet::Parser::Compiler.new(node)
+    compiler.topscope['my_fact'] = 'server3'
     expect(extract_notifications(compiler.compile)).to include('In name.yaml')
   end
 

data/spec/unit/defaults_spec.rb

@@ -209,4 +209,12 @@ describe "Defaults" do
       expect(Puppet.default_cadir).to eq(cadir)
     end
   end
+
+  describe "#preferred_serialization_format" do
+    it 'raises if PSON is not available', unless: Puppet.features.pson? do
+      expect {
+        Puppet.settings[:preferred_serialization_format] = "pson"
+      }.to raise_error(Puppet::Settings::ValidationError, "The 'puppet-pson' gem must be installed to use the PSON serialization format.")
+    end
+  end
 end

data/spec/unit/external/pson_spec.rb

@@ -1,9 +1,7 @@
 # Encoding: UTF-8
 require 'spec_helper'
 
-require 'puppet/external/pson/common'
-
-describe PSON do
+describe 'PSON', if: Puppet.features.pson? do
   {
     'foo' => '"foo"',
     1 => '1',

data/spec/unit/face/epp_face_spec.rb

@@ -311,8 +311,8 @@ describe Puppet::Face[:epp, :current] do
 
     it "facts can be overridden" do
       expect(eppface.render({
-        :facts => {'operatingsystem' => 'Merwin'},
-        :e     => '<%= $facts[operatingsystem] %>', 
+        :facts => {'os' => {'name' => 'Merwin'} },
+        :e     => '<%= $facts[os][name] %>',
       })).to eql("Merwin")
     end
 

data/spec/unit/file_bucket/dipper_spec.rb

@@ -104,8 +104,8 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
           # Diff without the context
           # Lines we need to see match 'Content' instead of trimming diff output filter out
           # surrounding noise...or hard code the check values
-          if Puppet.runtime[:facter].value(:osfamily) == 'Solaris' &&
-            Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemrelease), '11.0') >= 0
+          if Puppet.runtime[:facter].value('os.family') == 'Solaris' &&
+            Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.full'), '11.0') >= 0
             # Use gdiff on Solaris
             diff12 = Puppet::Util::Execution.execute("gdiff -uN #{file1} #{file2}| grep Content")
             diff21 = Puppet::Util::Execution.execute("gdiff -uN #{file2} #{file1}| grep Content")

data/spec/unit/file_serving/metadata_spec.rb

@@ -21,9 +21,9 @@ describe Puppet::FileServing::Metadata do
     expect(Puppet::FileServing::Metadata.default_format).to eq(:json)
   end
 
-  it "should support json, pson, yaml" do
-    # msgpack is optional, so using include instead of eq
-    expect(Puppet::FileServing::Metadata.supported_formats).to include(:json, :pson, :yaml)
+  it "should support json and yaml" do
+    # msgpack and pson are optional, so using include instead of eq
+    expect(Puppet::FileServing::Metadata.supported_formats).to include(:json, :yaml)
   end
 
   it "should support deserialization" do

data/spec/unit/file_serving/mount/file_spec.rb

@@ -3,8 +3,8 @@ require 'puppet/file_serving/mount/file'
 
 module FileServingMountTesting
   def stub_facter(hostname)
-    allow(Facter).to receive(:value).with("hostname").and_return(hostname.sub(/\..+/, ''))
-    allow(Facter).to receive(:value).with("domain").and_return(hostname.sub(/^[^.]+\./, ''))
+    allow(Facter).to receive(:value).with("networking.hostname").and_return(hostname.sub(/\..+/, ''))
+    allow(Facter).to receive(:value).with("networking.domain").and_return(hostname.sub(/^[^.]+\./, ''))
   end
 end
 

data/spec/unit/functions/epp_spec.rb

@@ -18,7 +18,13 @@ describe "the epp function" do
       expect(eval_template("all your base <%= $what::is %> to us")).to eq("all your base are belong to us")
     end
 
-    it "get nil accessing a variable that does not exist" do
+    it "gets error accessing a variable that does not exist" do
+      expect { eval_template("<%= $kryptonite == undef %>")}.to raise_error(/Evaluation Error: Unknown variable: 'kryptonite'./)
+    end
+
+    it "get nil accessing a variable that does not exist when strict mode is off" do
+      Puppet[:strict_variables] = false
+      Puppet[:strict] = :warning
       expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
     end
 

data/spec/unit/functions/hiera_spec.rb

@@ -161,7 +161,7 @@ describe 'when calling' do
     with_scope { |scope| the_func.call(scope, *args, &block) }
   end
 
-  context 'hiera' do
+  context 'hiera', :if => Puppet.features.hiera? do
     it 'should require a key argument' do
       expect { func([]) }.to raise_error(ArgumentError)
     end
@@ -195,7 +195,7 @@ describe 'when calling' do
       expect(func('datasources', nil, 'the_override')).to eql(['the_override', 'first', 'second'])
     end
 
-    it 'a hiera v3 scope is used' do
+    it 'a hiera v3 scope is used', :if => Puppet.features.hiera? do
       expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['-- testing --', '-- mod::foo --', '-- mod/foo --', '-- mod --', '-- mod --'])
       class testing () {
          notice(hiera('class_name'))
@@ -266,7 +266,7 @@ describe 'when calling' do
     end
   end
 
-  context 'hiera_array' do
+  context 'hiera_array', :if => Puppet.features.hiera? do
     let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_array') }
 
     it 'should require a key argument' do
@@ -299,7 +299,7 @@ describe 'when calling' do
     end
   end
 
-  context 'hiera_hash' do
+  context 'hiera_hash', :if => Puppet.features.hiera? do
     let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_hash') }
 
     it 'should require a key argument' do
@@ -336,7 +336,7 @@ describe 'when calling' do
     end
   end
 
-  context 'hiera_include' do
+  context 'hiera_include', :if => Puppet.features.hiera? do
     let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_include') }
 
     it 'should require a key argument' do
@@ -365,7 +365,7 @@ describe 'when calling' do
     end
   end
 
-  context 'with custom backend and merge_behavior declared in hiera.yaml' do
+  context 'with custom backend and merge_behavior declared in hiera.yaml', :if => Puppet.features.hiera? do
     let(:merge_behavior) { 'deeper' }
 
     let(:hiera_yaml) do
@@ -468,7 +468,7 @@ describe 'when calling' do
       end
     end
 
-    context 'hiera_array' do
+    context 'hiera_array', :if => Puppet.features.hiera? do
       let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_array') }
 
       it 'declared merge_behavior is ignored' do

data/spec/unit/functions/inline_epp_spec.rb

@@ -16,7 +16,13 @@ describe "the inline_epp function" do
       expect(eval_template("all your base <%= $what %> to us")).to eq("all your base are belong to us")
     end
 
-    it "get nil accessing a variable that does not exist" do
+    it "gets error accessing a variable that does not exist" do
+      expect { eval_template("<%= $kryptonite == undef %>")}.to raise_error(/Evaluation Error: Unknown variable: 'kryptonite'./)
+    end
+
+    it "get nil accessing a variable that does not exist when strict mode is off" do
+      Puppet[:strict_variables] = false
+      Puppet[:strict] = :warning
       expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
     end