puppet 5.0.0 → 6.0.0

data/spec/unit/parser/environment_compiler_spec.rb

@@ -9,25 +9,36 @@ describe "Application instantiation" do
   let(:env) { Puppet::Node::Environment.create(:testing, []) }
   let(:node) { Puppet::Node.new('test', :environment => env) }
   let(:loaders) { Puppet::Pops::Loaders.new(env) }
+  let(:logs) { [] }
+  let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+  def compile_collect_log(string)
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compile_to_catalog(string, Puppet::Node.new('other', :environment => env))
+    end
+  end
 
   def compile_to_env_catalog(string, code_id=nil)
     Puppet[:code] = string
     Puppet::Parser::EnvironmentCompiler.compile(env, code_id).filter { |r| r.virtual? }
   end
 
-  around :each do |example|
+  before(:each) do
     Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
     Puppet::Parser::EnvironmentCompiler.any_instance.stubs(:loaders).returns(loaders)
-    Puppet.override(:loaders => loaders, :current_environment => env) do
-      Puppet::Type.newtype :cap, :is_capability => true do
-        newparam :name
-        newparam :host
-      end
-      example.run
-      Puppet::Type.rmtype(:cap)
+    Puppet.push_context({:loaders => loaders, :current_environment => env})
+    Puppet::Type.newtype :cap, :is_capability => true do
+      newparam :name
+      newparam :host
     end
   end
 
+  after(:each) do
+    Puppet::Type.rmtype(:cap)
+    Puppet.pop_context()
+  end
+
   MANIFEST = <<-EOS
       define prod($host) {
         notify { "host ${host}":}
@@ -481,19 +492,19 @@ EOS
   describe "in the environment catalog" do
     it "does not fail if there is no site expression" do
       expect {
-      catalog = compile_to_env_catalog(<<-EOC).to_resource
-        notify { 'ignore me':}
-      EOC
+        compile_to_env_catalog(<<-EOC).to_resource
+          notify { 'ignore me':}
+        EOC
       }.to_not raise_error()
     end
 
     it "ignores usage of hiera_include() at topscope for classification" do
-      Puppet.expects(:debug).with(regexp_matches /Ignoring hiera_include/)
+      Puppet.expects(:debug).with(regexp_matches(/Ignoring hiera_include/))
 
       expect {
-        catalog = compile_to_env_catalog(<<-EOC).to_resource
-        hiera_include('classes')
-        site { }
+        compile_to_env_catalog(<<-EOC).to_resource
+          hiera_include('classes')
+          site { }
         EOC
       }.to_not raise_error()
 
@@ -589,8 +600,8 @@ EOS
 
       it "fails if there are non component resources in the site" do
         expect {
-        catalog = compile_to_env_catalog(MANIFEST_WITH_ILLEGAL_RESOURCE).to_resource
-        }.to raise_error(/Only application components can appear inside a site - Notify\[fail me\] is not allowed at line 20/)
+          compile_to_env_catalog(MANIFEST_WITH_ILLEGAL_RESOURCE).to_resource
+        }.to raise_error(/Only application components can appear inside a site - Notify\[fail me\] is not allowed \(line: 20\)/)
       end
     end
 
@@ -683,4 +694,31 @@ EOS
       }.to raise_error(Puppet::Error, /maps component P\[one\] to multiple nodes/)
     end
   end
+
+  describe "site containing a resource named 'plan'" do
+    it 'finds an application named plan' do
+      expect {compile_collect_log(<<-PUPPET)}.not_to raise_error
+        define plan::node_file() {
+          file { "/tmp/plans/${name}.txt":
+            content => "this is ${name}.txt",
+          }
+        }
+        Plan::Node_file produces Node_file {}
+        application plan() {
+          plan::node_file { "node_file_${name}":
+            export => Node_file["node_file_${name}"]
+          }
+        }
+        site {
+          plan { "test":
+            nodes       => {
+              Node["test.example.com"] => Plan::Node_file["node_file_plan_test"],
+            }
+          }
+        }
+        PUPPET
+
+      expect(warnings).to include(/Use of future reserved word: 'plan'/)
+    end
+  end
 end

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -77,7 +77,7 @@ describe 'function for dynamically creating resources' do
     it 'should pick up and pass on file and line information' do
       # mock location as the compile_to_catalog sets Puppet[:code} which does not
       # have file/line support.
-      Puppet::Pops::PuppetStack.expects(:stacktrace).once.returns([['test.pp', 1234]])
+      Puppet::Pops::PuppetStack.expects(:top_of_stack).once.returns(['test.pp', 1234])
       catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
       r = catalog.resource(:file, "/etc/foo")
       expect(r.file).to eq('test.pp')
@@ -324,6 +324,15 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog('include foo')
       }.to raise_error(Puppet::Error, /Syntax error at.*/)
     end
+
+    it 'is not available when --tasks is on' do
+      Puppet[:tasks] = true
+      expect do
+        compile_to_catalog(<<-MANIFEST)
+          create_resources('class', {'bar'=>{}}, {'one' => 'two'})
+        MANIFEST
+      end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+    end
   end
 
   def collect_notices(code)

data/spec/unit/parser/functions/digest_spec.rb

@@ -1,11 +1,7 @@
-#!/usr/bin/env rspec
+#!/usr/bin/env ruby
 require 'spec_helper'
 
 describe "the digest function", :uses_checksums => true do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     n = Puppet::Node.new('unnamed')
     c = Puppet::Parser::Compiler.new(n)

data/spec/unit/parser/functions/fail_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the 'fail' parser function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let :scope do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
@@ -23,6 +19,6 @@ describe "the 'fail' parser function" do
   end
 
   it "should join arguments into a string in the error" do
-    expect { scope.function_fail(["hello", "world"]) }.to raise_error /hello world/
+    expect { scope.function_fail(["hello", "world"]) }.to raise_error(/hello world/)
   end
 end

data/spec/unit/parser/functions/file_spec.rb

@@ -5,10 +5,6 @@ require 'puppet_spec/files'
 describe "the 'file' function" do
   include PuppetSpec::Files
 
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end

data/spec/unit/parser/functions/fqdn_rand_spec.rb

@@ -38,6 +38,30 @@ describe "the fqdn_rand function" do
     expect(val1).not_to eql(val2)
   end
 
+  it "should return a specific value with given set of inputs on non-fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns false
+
+    expect(fqdn_rand(3000, :host => 'dummy.fqdn.net')).to eql(338)
+  end
+
+  it "should return a specific value with given set of inputs on fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+
+    expect(fqdn_rand(3000, :host => 'dummy.fqdn.net')).to eql(278)
+  end
+
+  it "should return a specific value with given seed on a non-fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns false
+
+    expect(fqdn_rand(5000, :extra_identifier => ['expensive job 33'])).to eql(3374)
+  end
+
+  it "should return a specific value with given seed on a fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+
+    expect(fqdn_rand(5000, :extra_identifier => ['expensive job 33'])).to eql(2389)
+  end
+
   def fqdn_rand(max, args = {})
     host = args[:host] || '127.0.0.1'
     extra = args[:extra_identifier] || []

data/spec/unit/parser/functions/generate_spec.rb

@@ -4,10 +4,6 @@ require 'spec_helper'
 describe "the generate function" do
   include PuppetSpec::Files
 
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end
@@ -34,7 +30,7 @@ describe "the generate function" do
     expect { scope.function_generate([File.expand_path('/com mand')]) }.to raise_error(Puppet::ParseError)
   end
 
-  it "should not accept a command containing '..'" do
+  it "should not accept a command containing '..'", :unless => RUBY_PLATFORM == 'java' do
     command = File.expand_path("/command/../")
     expect { scope.function_generate([command]) }.to raise_error(Puppet::ParseError)
   end
@@ -45,7 +41,7 @@ describe "the generate function" do
     expect(scope.function_generate([command])).to eq('yay')
   end
 
-  describe "on Windows", :if => Puppet.features.microsoft_windows? do
+  describe "on Windows", :if => Puppet::Util::Platform.windows? do
     it "should accept the tilde in the path" do
       command = "C:/DOCUME~1/ADMINI~1/foo.bat"
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
@@ -91,37 +87,39 @@ describe "the generate function" do
     end
   end
 
-  let :command do
-    script_containing('function_generate',
-      :windows => '@echo off' + "\n" + 'echo a-%1 b-%2',
-      :posix   => '#!/bin/sh' + "\n" + 'echo a-$1 b-$2')
-  end
+  describe "function_generate", :unless => RUBY_PLATFORM == 'java' do
+    let :command do
+      script_containing('function_generate',
+        :windows => '@echo off' + "\n" + 'echo a-%1 b-%2',
+        :posix   => '#!/bin/sh' + "\n" + 'echo a-$1 b-$2')
+    end
 
-  after :each do
-    File.delete(command) if Puppet::FileSystem.exist?(command)
-  end
+    after :each do
+      File.delete(command) if Puppet::FileSystem.exist?(command)
+    end
 
-  it "returns the output as a String" do
-    expect(scope.function_generate([command]).class).to eq(String)
-  end
+    it "returns the output as a String" do
+      expect(scope.function_generate([command]).class).to eq(String)
+    end
 
-  it "should call generator with no arguments" do
-    expect(scope.function_generate([command])).to eq("a- b-\n")
-  end
+    it "should call generator with no arguments" do
+      expect(scope.function_generate([command])).to eq("a- b-\n")
+    end
 
-  it "should call generator with one argument" do
-    expect(scope.function_generate([command, 'one'])).to eq("a-one b-\n")
-  end
+    it "should call generator with one argument" do
+      expect(scope.function_generate([command, 'one'])).to eq("a-one b-\n")
+    end
 
-  it "should call generator with wo arguments" do
-    expect(scope.function_generate([command, 'one', 'two'])).to eq("a-one b-two\n")
-  end
+    it "should call generator with wo arguments" do
+      expect(scope.function_generate([command, 'one', 'two'])).to eq("a-one b-two\n")
+    end
 
-  it "should fail if generator is not absolute" do
-    expect { scope.function_generate(['boo']) }.to raise_error(Puppet::ParseError)
-  end
+    it "should fail if generator is not absolute" do
+      expect { scope.function_generate(['boo']) }.to raise_error(Puppet::ParseError)
+    end
 
-  it "should fail if generator fails" do
-    expect { scope.function_generate(['/boo']) }.to raise_error(Puppet::ParseError)
+    it "should fail if generator fails" do
+      expect { scope.function_generate(['/boo']) }.to raise_error(Puppet::ParseError)
+    end
   end
 end

data/spec/unit/parser/functions/inline_template_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the inline_template function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let(:node) { Puppet::Node.new('localhost') }
   let(:compiler) { Puppet::Parser::Compiler.new(node) }
   let(:scope) { Puppet::Parser::Scope.new(compiler) }
@@ -28,6 +24,13 @@ describe "the inline_template function" do
     expect(inline_template("string was: <%= @string %>")).to eq("string was: this is a variable")
   end
 
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect {
+      inline_template("<%= lookupvar('myvar') %>")
+    }.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
+
   def inline_template(*templates)
     scope.function_inline_template(templates)
   end

data/spec/unit/parser/functions/realize_spec.rb

@@ -58,4 +58,13 @@ describe "the realize function" do
       realize([])
     EOM
   end
+
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        realize([])
+      MANIFEST
+    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
 end

data/spec/unit/parser/functions/regsubst_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the regsubst function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)

data/spec/unit/parser/functions/scanf_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the scanf function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let(:node) { Puppet::Node.new('localhost') }
   let(:compiler) { Puppet::Parser::Compiler.new(node) }
   let(:scope) { Puppet::Parser::Scope.new(compiler) }

data/spec/unit/parser/functions/split_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the split function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)

data/spec/unit/parser/functions/sprintf_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the sprintf function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
@@ -44,4 +40,30 @@ describe "the sprintf function" do
     expect(result).to(eql("<overlong:  027   0XBEEF (foo     )>"))
   end
 
+  it 'does not attempt to mutate its arguments' do
+    args = ['%d', 1].freeze
+    expect { @scope.function_sprintf(args) }.to_not raise_error
+  end
+
+  it 'support named arguments in a hash with string keys' do
+    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2}])
+    expect(result).to eq("1 : 2.000000")
+  end
+
+  it 'raises a key error if a key is not present' do
+    expect do
+      @scope.function_sprintf(["%<foo>d : %<zanzibar>f", {'foo' => 1, 'bar' => 2}])
+    end.to raise_error(KeyError, /key<zanzibar> not found/)
+  end
+
+  it 'a hash with string keys that is output formats as strings' do
+    result = @scope.function_sprintf(["%s", {'foo' => 1, 'bar' => 2}])
+    expect(result).to eq("{\"foo\"=>1, \"bar\"=>2}")
+  end
+
+  it 'named arguments hash with non string keys are tolerated' do
+    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2, 1 => 2, [1] => 2, false => true, {} => {}}])
+    expect(result).to eq("1 : 2.000000")
+  end
+
 end

data/spec/unit/parser/functions/tag_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the 'tag' function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
@@ -25,4 +21,11 @@ describe "the 'tag' function" do
     expect(resource).to be_tagged("one")
     expect(resource).to be_tagged("two")
   end
+
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect do
+      @scope.function_tag(['one', 'two'])
+    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
 end

data/spec/unit/parser/functions/tagged_spec.rb

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe "the 'tagged' function" do
+  before :each do
+    node     = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    @scope   = Puppet::Parser::Scope.new(compiler)
+  end
+
+  it "should exist" do
+    expect(Puppet::Parser::Functions.function(:tagged)).to eq("function_tagged")
+  end
+
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect do
+      @scope.function_tagged(['one', 'two'])
+    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
+
+  it 'should be case-insensitive' do
+    resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
+    @scope.stubs(:resource).returns resource
+    @scope.function_tag ["one"]
+
+    expect(@scope.function_tagged(['One'])).to eq(true)
+  end
+
+  it 'should check if all specified tags are included' do
+    resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
+    @scope.stubs(:resource).returns resource
+    @scope.function_tag ["one"]
+
+    expect(@scope.function_tagged(['one', 'two'])).to eq(false)
+  end
+end

data/spec/unit/parser/functions/template_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the template function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end
@@ -81,6 +77,14 @@ describe "the template function" do
     }.to raise_error(Puppet::ParseError, /undefined method `lookupvar'/)
   end
 
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect {
+      eval_template("<%= lookupvar('myvar') %>")
+    }.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+
+  end
+
   def eval_template(content)
     Puppet::FileSystem.stubs(:read_preserve_line_endings).with("template").returns(content)
     Puppet::Parser::Files.stubs(:find_template).returns("template")

data/spec/unit/parser/functions/versioncmp_spec.rb

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the versioncmp function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)

data/spec/unit/parser/functions_spec.rb

@@ -48,8 +48,33 @@ describe Puppet::Parser::Functions do
   end
 
   describe "when calling function to test function existence" do
+    before :each do
+      Puppet[:strict] = :error
+    end
+
+    it "emits a deprecation warning when loading all 3.x functions" do
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:loadall)
+      Puppet::Parser::Functions.autoloader.loadall
+
+      expect(@logs.map(&:to_s)).to include(/The method 'Puppet::Parser::Functions.autoloader#loadall' is deprecated in favor of using 'Scope#call_function/)
+    end
+
+    it "emits a deprecation warning when loading a single 3.x function" do
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:load)
+      Puppet::Parser::Functions.autoloader.load('beatles')
+
+      expect(@logs.map(&:to_s)).to include(/The method 'Puppet::Parser::Functions.autoloader#load\("beatles"\)' is deprecated in favor of using 'Scope#call_function'/)
+    end
+
+    it "emits a deprecation warning when checking if a 3x function is loaded" do
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:loaded?).returns(false)
+      Puppet::Parser::Functions.autoloader.loaded?('beatles')
+
+      expect(@logs.map(&:to_s)).to include(/The method 'Puppet::Parser::Functions.autoloader#loaded\?\(\"beatles\"\)' is deprecated in favor of using 'Scope#call_function'/)
+    end
+
     it "should return false if the function doesn't exist" do
-      Puppet::Parser::Functions.autoloader.stubs(:load)
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:load)
 
       expect(Puppet::Parser::Functions.function("name")).to be_falsey
     end
@@ -61,7 +86,7 @@ describe Puppet::Parser::Functions do
     end
 
     it "should try to autoload the function if it doesn't exist yet" do
-      Puppet::Parser::Functions.autoloader.expects(:load)
+      Puppet::Parser::Functions.autoloader.delegatee.expects(:load)
 
       Puppet::Parser::Functions.function("name")
     end

data/spec/unit/parser/resource/param_spec.rb

@@ -14,7 +14,7 @@ describe Puppet::Parser::Resource::Param do
     it "throws an error when instantiated without a name" do
       expect {
         Puppet::Parser::Resource::Param.new(:value => 'foo')
-      }.to raise_error(Puppet::Error, /name is a required option/)
+      }.to raise_error(Puppet::Error, /'name' is a required option/)
     end
 
     it "does not require a value" do
@@ -26,7 +26,7 @@ describe Puppet::Parser::Resource::Param do
     it "includes file/line context in errors" do
       expect {
         Puppet::Parser::Resource::Param.new(:file => 'foo.pp', :line => 42)
-      }.to raise_error(Puppet::Error, /foo.pp:42/)
+      }.to raise_error(Puppet::Error, /\(file: foo.pp, line: 42\)/)
     end
   end
 end

data/spec/unit/parser/resource_spec.rb

@@ -177,7 +177,6 @@ describe Puppet::Parser::Resource do
     end
 
     it "should add edges from the class resources to the parent's stage if no stage is specified" do
-      main      = @compiler.catalog.resource(:stage, :main)
       foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, foo_stage)
       @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})

data/spec/unit/parser/scope_spec.rb

@@ -42,6 +42,25 @@ describe Puppet::Parser::Scope do
     expect(@scope.inspect).to eq("Scope(foo::bar)")
   end
 
+  it "should generate a path if there is one on the puppet stack" do
+    result = Puppet::Pops::PuppetStack.stack('/tmp/kansas.pp', 42, @scope, 'inspect', [])
+    expect(result).to eq("Scope(/tmp/kansas.pp, 42)")
+  end
+
+  it "should generate an <env> shortened path if path points into the environment" do
+    env_path = @scope.environment.configuration.path_to_env
+    mocked_path = File.join(env_path, 'oz.pp')
+    result = Puppet::Pops::PuppetStack.stack(mocked_path, 42, @scope, 'inspect', [])
+
+    expect(result).to eq("Scope(<env>/oz.pp, 42)")
+  end
+
+  it "should generate a <module> shortened path if path points into a module" do
+    mocked_path = File.join(@scope.environment.full_modulepath[0], 'mymodule', 'oz.pp')
+    result = Puppet::Pops::PuppetStack.stack(mocked_path, 42, @scope, 'inspect', [])
+    expect(result).to eq("Scope(<module>/mymodule/oz.pp, 42)")
+  end
+
   it "should return a scope for use in a test harness" do
     expect(create_test_scope_for_node("node_name_foo")).to be_a_kind_of(Puppet::Parser::Scope)
   end
@@ -210,7 +229,7 @@ describe Puppet::Parser::Scope do
     end
 
     it "warns once for a non found variable" do
-      Puppet.expects(:warning).once
+      Puppet.expects(:send_log).with(:warning, is_a(String)).once
       expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
     end
 
@@ -275,13 +294,13 @@ describe Puppet::Parser::Scope do
       end
 
       it "should return nil for qualified variables that cannot be found in other classes" do
-        other_scope = create_class_scope("other::deep::klass")
+        create_class_scope("other::deep::klass")
 
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
-        klass = newclass("other::deep::klass")
+        newclass("other::deep::klass")
         Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
@@ -297,7 +316,7 @@ describe Puppet::Parser::Scope do
 
       it "should return nil when asked for a non-string qualified variable from a class that has not been evaluated" do
         @scope.stubs(:warning)
-        klass = newclass("other::deep::klass")
+        newclass("other::deep::klass")
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
     end