puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

data/spec/unit/functions/new_spec.rb

@@ -174,19 +174,6 @@ describe 'the new function' do
           )).to have_resource("Notify[Integer, #{result}]")
         end
       end
-
-      { '0x0G'  => :error,
-        '08'    => :error,
-        '10F'   => :error,
-        '0B2'   => :error,
-      }.each do |str, result|
-        it "errors when given a non Integer compliant string '#{str}'" do
-          expect{compile_to_catalog(<<-"MANIFEST"
-            $x = Integer.new("#{str}")
-          MANIFEST
-        )}.to raise_error(Puppet::Error, /invalid value|cannot be converted to Integer/)
-        end
-      end
     end
 
     context "when radix is explicitly set to 'default' it" do
@@ -320,8 +307,6 @@ describe 'the new function' do
       { "10"     => 10,
         "010"    => 10,
         "00010"  => 10,
-        "08"     => 8,
-        "0008"   => 8,
       }.each do |str, result|
         it "produces #{result} from the string '#{str}'" do
           expect(compile_to_catalog(<<-"MANIFEST"

data/spec/unit/functions/require_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
@@ -6,6 +7,7 @@ require 'matchers/resource'
 require 'matchers/include_in_order'
 require 'unit/functions/shared'
 
+
 describe 'The "require" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers
@@ -79,4 +81,5 @@ describe 'The "require" function' do
   it_should_behave_like 'all functions transforming relative to absolute names', :require
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :require
   it_should_behave_like 'an inclusion function, when --tasks is on,', :require
+
 end

data/spec/unit/functions/shared.rb

@@ -2,19 +2,19 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
   before(:each) do
     # mock that the class 'myclass' exists which are needed for the 'require' functions
     # as it checks the existence of the required class
-    @klass = double('class', :name => "myclass")
-    allow(@scope.environment.known_resource_types).to receive(:find_hostclass).and_return(@klass)
+    @klass = stub 'class', :name => "myclass"
+    @scope.environment.known_resource_types.stubs(:find_hostclass).returns(@klass)
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
-    allow(@scope).to receive(:resource).and_return(@resource)
+    @scope.stubs(:resource).returns @resource
   end
 
   it 'accepts a Class[name] type' do
-    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
     @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
   end
 
   it 'accepts a Resource[class, name] type' do
-    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
     @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
   end
 
@@ -45,6 +45,7 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
 end
 
 shared_examples_for 'an inclusion function, regardless of the type of class reference,' do |function|
+
     it "and #{function} a class absolutely, even when a relative namespaced class of the same name is present" do
       catalog = compile_to_catalog(<<-MANIFEST)
         class foo {
@@ -80,6 +81,7 @@ shared_examples_for 'an inclusion function, regardless of the type of class refe
       MANIFEST
       expect(catalog.classes).to include('foo','bar')
     end
+
 end
 
 shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
@@ -92,3 +94,4 @@ shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
     end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
   end
 end
+

data/spec/unit/functions/versioncmp_spec.rb

@@ -3,6 +3,7 @@ require 'puppet/pops'
 require 'puppet/loaders'
 
 describe "the versioncmp function" do
+
   before(:each) do
     loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.push_context({:loaders => loaders}, "test-examples")
@@ -27,7 +28,7 @@ describe "the versioncmp function" do
   end
 
   it "should call Puppet::Util::Package.versioncmp (included in scope)" do
-    expect(Puppet::Util::Package).to receive(:versioncmp).with('1.2', '1.3').and_return(-1)
+    Puppet::Util::Package.expects(:versioncmp).with('1.2', '1.3').returns(-1)
 
     expect(versioncmp('1.2', '1.3')).to eq(-1)
   end

data/spec/unit/functions4_spec.rb

@@ -210,12 +210,12 @@ describe 'the 4x function api' do
     end
 
     it 'a function can not be created with parameters declared after a repeated parameter' do
-      expect { create_function_with_param_after_repeated }.to raise_error(ArgumentError,
+      expect { create_function_with_param_after_repeated }.to raise_error(ArgumentError, 
         /function 't1'.*Parameters cannot be added after a repeated parameter/)
     end
 
     it 'a function can not be created with required parameters declared after optional ones' do
-      expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError,
+      expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 
         /function 't1'.*A required parameter cannot be added after an optional parameter/)
     end
 
@@ -464,7 +464,7 @@ describe 'the 4x function api' do
           # evaluate a puppet call
           source = "testing::test(10) |$x| { $x+1 }"
           program = parser.parse_string(source, __FILE__)
-          expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(the_loader)
+          Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns(the_loader)
           expect(parser.evaluate(scope, program)).to eql(11)
         end
       end
@@ -538,7 +538,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error,
           /value returned from function 'test' has wrong type, expects a String value, got Integer/)
       end
@@ -560,7 +560,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eql(10)
       end
 
@@ -579,7 +579,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error, /parameter 'x' references an unresolved type 'MyAlias'/)
       end
 
@@ -601,7 +601,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test([10,20])', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq([10,20])
       end
 
@@ -624,7 +624,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string("testing::test({'x' => [10,20]})", __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq({'x' => [10,20]})
       end
 
@@ -646,12 +646,13 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string("testing::test({'x' => {'y' => 'n'}})", __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq({'x' => {'y' => 'n'}})
       end
     end
   end
 
+
   def create_noargs_function_class
     Puppet::Functions.create_function('test') do
       def test()

data/spec/unit/gettext/config_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::GettextConfig do
   end
 
   before(:each) do
-    allow(Puppet::GettextConfig).to receive(:gettext_loaded?).and_return(true)
+    Puppet::GettextConfig.stubs(:gettext_loaded?).returns true
   end
 
   after(:each) do
@@ -29,7 +29,7 @@ describe Puppet::GettextConfig do
 
   describe 'setting and getting the locale' do
     it 'should return "en" when gettext is unavailable' do
-      allow(Puppet::GettextConfig).to receive(:gettext_loaded?).and_return(false)
+      Puppet::GettextConfig.stubs(:gettext_loaded?).returns(false)
 
       expect(Puppet::GettextConfig.current_locale).to eq('en')
     end
@@ -67,7 +67,7 @@ describe Puppet::GettextConfig do
 
     context 'when given a valid locale file location' do
       it 'should return true' do
-        expect(Puppet::GettextConfig).to receive(:add_repository_to_domain).with('puppet', local_path, :po, anything)
+        Puppet::GettextConfig.expects(:add_repository_to_domain).with('puppet', local_path, :po, anything)
 
         expect(Puppet::GettextConfig.load_translations('puppet', local_path, :po)).to be true
       end
@@ -88,7 +88,7 @@ describe Puppet::GettextConfig do
     end
 
     it 'should add puppet translations to the default text domain' do
-      expect(Puppet::GettextConfig).to receive(:load_translations).with('puppet', local_path, :po, Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN).and_return(true)
+      Puppet::GettextConfig.expects(:load_translations).with('puppet', local_path, :po, Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN).returns(true)
 
       Puppet::GettextConfig.create_default_text_domain
       expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN)

data/spec/unit/gettext/module_loading_spec.rb

@@ -16,7 +16,7 @@ describe Puppet::ModuleTranslations do
       :metadata => {
         :author => 'foo'
       },
-      :environment => double("environment"))
+      :environment => mock("environment"))
     }
 
     let(:module_b) { PuppetSpec::Modules.create(
@@ -25,13 +25,13 @@ describe Puppet::ModuleTranslations do
       :metadata => {
         :author => 'foo'
       },
-      :environment => double("environment"))
+      :environment => mock("environment"))
     }
 
     it "should attempt to load translations only for modules that have them" do
-      expect(module_a).to receive(:has_translations?).and_return(false)
-      expect(module_b).to receive(:has_translations?).and_return(true)
-      expect(Puppet::GettextConfig).to receive(:load_translations).with("foo-mod_b", File.join(modpath, "mod_b", "locales"), :po).and_return(true)
+      module_a.expects(:has_translations?).returns(false)
+      module_b.expects(:has_translations?).returns(true)
+      Puppet::GettextConfig.expects(:load_translations).with("foo-mod_b", File.join(modpath, "mod_b", "locales"), :po).returns(true)
 
       Puppet::ModuleTranslations.load_from_modulepath([module_a, module_b])
     end
@@ -44,8 +44,8 @@ describe Puppet::ModuleTranslations do
     }
 
     it "should attempt to load translations for the current locale" do
-      expect(Puppet::GettextConfig).to receive(:current_locale).and_return("ja")
-      expect(Puppet::GettextConfig).to receive(:load_translations).with("foo-mod_a", File.join(vardir, "locales"), :po).and_return(true)
+      Puppet::GettextConfig.expects(:current_locale).returns("ja")
+      Puppet::GettextConfig.expects(:load_translations).with("foo-mod_a", File.join(vardir, "locales"), :po).returns(true)
 
       Puppet::ModuleTranslations.load_from_vardir(vardir)
     end

data/spec/unit/graph/rb_tree_map_spec.rb

@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
 require 'puppet/graph'

data/spec/unit/graph/relationship_graph_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/graph'
 
@@ -396,6 +397,6 @@ describe Puppet::Graph::RelationshipGraph do
   end
 
   def stub_vertex(name)
-    double("vertex #{name}", :ref => name)
+    stub "vertex #{name}", :ref => name
   end
 end

data/spec/unit/graph/simple_graph_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/graph'
 
@@ -336,35 +337,35 @@ describe Puppet::Graph::SimpleGraph do
 
     it "should report one-vertex loops" do
       add_edges :a => :a
-      expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[a\]\)/)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[a\]\)/))
       cycle = @graph.report_cycles_in_graph.first
       expect_cycle_to_include(cycle, :a)
     end
 
     it "should report two-vertex loops" do
       add_edges :a => :b, :b => :a
-      expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/))
       cycle = @graph.report_cycles_in_graph.first
       expect_cycle_to_include(cycle, :a, :b)
     end
 
     it "should report multi-vertex loops" do
       add_edges :a => :b, :b => :c, :c => :a
-      expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[c\] => Notify\[a\]\)/)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[c\] => Notify\[a\]\)/))
       cycle = @graph.report_cycles_in_graph.first
       expect_cycle_to_include(cycle, :a, :b, :c)
     end
 
     it "should report when a larger tree contains a small cycle" do
       add_edges :a => :b, :b => :a, :c => :a, :d => :c
-      expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/))
       cycle = @graph.report_cycles_in_graph.first
       expect_cycle_to_include(cycle, :a, :b)
     end
 
     it "should succeed on trees with no cycles" do
       add_edges :a => :b, :b => :e, :c => :a, :d => :c
-      expect(Puppet).not_to receive(:err)
+      Puppet.expects(:err).never
       expect(@graph.report_cycles_in_graph).to be_nil
     end
 
@@ -468,14 +469,14 @@ describe Puppet::Graph::SimpleGraph do
     end
 
     it "should only write when graphing is enabled" do
-      expect(File).not_to receive(:open).with(@file)
+      File.expects(:open).with(@file).never
       Puppet[:graph] = false
       @graph.write_graph(@name)
     end
 
     it "should write a dot file based on the passed name" do
-      expect(File).to receive(:open).with(@file, "w:UTF-8").and_yield(double("file", :puts => nil))
-      expect(@graph).to receive(:to_dot).with("name" => @name.to_s.capitalize)
+      File.expects(:open).with(@file, "w:UTF-8").yields(stub("file", :puts => nil))
+      @graph.expects(:to_dot).with("name" => @name.to_s.capitalize)
       Puppet[:graph] = true
       @graph.write_graph(@name)
     end
@@ -503,7 +504,7 @@ describe Puppet::Graph::SimpleGraph do
       # because indexing a String with a non-Integer throws an exception (and none of
       # these tests need anything meaningful from []).
       resource = "a"
-      allow(resource).to receive(:[])
+      resource.stubs(:[])
       @event = Puppet::Transaction::Event.new(:name => :yay, :resource => resource)
       @none = Puppet::Transaction::Event.new(:name => :NONE, :resource => resource)
 

data/spec/unit/hiera/scope_spec.rb

@@ -90,11 +90,4 @@ describe Hiera::Scope do
       expect(scope.include?("calling_module")).to eq(true)
     end
   end
-
-  describe "#call_function" do
-    it "should delegate a call to call_function to the real scope" do
-      expect(real).to receive(:call_function).once
-      scope.call_function('some_function', [1,2,3])
-    end
-  end
 end

data/spec/unit/hiera_puppet_spec.rb

@@ -16,8 +16,8 @@ describe 'HieraPuppet' do
 
     context "when the hiera_config_file exists" do
       before do
-        expect(Hiera::Config).to receive(:load).and_return(hiera_config_data)
-        expect(HieraPuppet).to receive(:hiera_config_file).and_return(true)
+        Hiera::Config.expects(:load).returns(hiera_config_data)
+        HieraPuppet.expects(:hiera_config_file).returns(true)
       end
 
       it "should return a configuration hash" do
@@ -31,8 +31,8 @@ describe 'HieraPuppet' do
 
     context "when the hiera_config_file does not exist" do
       before do
-        expect(Hiera::Config).not_to receive(:load)
-        expect(HieraPuppet).to receive(:hiera_config_file).and_return(nil)
+        Hiera::Config.expects(:load).never
+        HieraPuppet.expects(:hiera_config_file).returns(nil)
       end
 
       it "should return a configuration hash" do
@@ -59,7 +59,7 @@ describe 'HieraPuppet' do
         pending("This example does not apply to Puppet #{Puppet.version} because it does not have this setting")
       end
 
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:hiera_config]).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).with(Puppet[:hiera_config]).returns(true)
       expect(HieraPuppet.send(:hiera_config_file)).to eq(Puppet[:hiera_config])
     end
 
@@ -75,29 +75,29 @@ describe 'HieraPuppet' do
       end
 
       it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' does not exist" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(false)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
       end
 
       it "should use Puppet.settings[:confdir]/hiera.yaml when '$codedir/hiera.yaml' does not exist and '$confdir/hiera.yaml' exists" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(false)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(conf_hiera_config)
       end
 
       it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' exists" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
       end
 
       it "should return nil when neither '$codedir/hiera.yaml' nor '$confdir/hiera.yaml' exists" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(false)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(false)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(nil)
       end
@@ -109,9 +109,9 @@ describe 'HieraPuppet' do
           explicit_hiera_config = '/an/explicit/hiera.yaml'
         end
         Puppet.settings[:hiera_config] = explicit_hiera_config
-        allow(Puppet::FileSystem).to receive(:exist?).with(explicit_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(explicit_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(explicit_hiera_config)
       end
@@ -126,18 +126,18 @@ describe 'HieraPuppet' do
     end
 
     it "should return the value from Hiera" do
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return('8080')
+      Hiera.any_instance.stubs(:lookup).returns('8080')
       expect(HieraPuppet.lookup('port', nil, scope, nil, :priority)).to eq('8080')
 
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return(['foo', 'bar'])
+      Hiera.any_instance.stubs(:lookup).returns(['foo', 'bar'])
       expect(HieraPuppet.lookup('ntpservers', nil, scope, nil, :array)).to eq(['foo', 'bar'])
 
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return({'uid' => '1000'})
+      Hiera.any_instance.stubs(:lookup).returns({'uid' => '1000'})
       expect(HieraPuppet.lookup('user', nil, scope, nil, :hash)).to eq({'uid' => '1000'})
     end
 
     it "should raise a useful error when the answer is nil" do
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return(nil)
+      Hiera.any_instance.stubs(:lookup).returns(nil)
       expect do
         HieraPuppet.lookup('port', nil, scope, nil, :priority)
       end.to raise_error(Puppet::ParseError,