puppet 4.9.4 → 4.10.0

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -35,6 +35,8 @@ describe 'loaders' do
   let(:dependent_modules_with_metadata) { config_dir('dependent_modules_with_metadata') }
   let(:no_modules) { config_dir('no_modules') }
   let(:user_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/user/metadata.json') }
+  let(:usee_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/usee/metadata.json') }
+  let(:usee2_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/usee2/metadata.json') }
 
   let(:empty_test_env) { environment_for() }
 
@@ -45,11 +47,11 @@ describe 'loaders' do
     let(:pp_resources) { config_dir('pp_resources') }
     let(:environments) { Puppet::Environments::Directories.new(my_fixture_dir, []) }
     let(:env) { Puppet::Node::Environment.create(:'pp_resources', [File.join(pp_resources, 'modules')]) }
-    let(:scope) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)).newscope(nil) }
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
     let(:loader) { Puppet::Pops::Loaders.loaders.find_loader(nil) }
     around(:each) do |example|
-      Puppet.override(:environments => environments, :current_environment => scope.environment, :global_scope => scope) do
-        Puppet.override(:loaders => Puppet::Pops::Loaders.new(env)) do
+      Puppet.override(:environments => environments) do
+        Puppet.override(:loaders => compiler.loaders) do
           example.run
         end
       end
@@ -145,6 +147,8 @@ describe 'loaders' do
 
     it 'loader allows loading a function more than once' do
       File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns ''
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
 
       env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
@@ -204,6 +208,8 @@ describe 'loaders' do
 
     it 'all dependent modules are visible' do
       File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -221,6 +227,8 @@ describe 'loaders' do
         case_number = from_idx * 3 + called_idx + 1
         it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
           File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
@@ -239,6 +247,8 @@ describe 'loaders' do
 
         it "can not call #{desc[:called]} from #{desc[:from]} if dependency is missing in existing metadata.json" do
           File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => []).to_pson
+          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           expect { catalog = compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
         end
@@ -247,6 +257,8 @@ describe 'loaders' do
 
     it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
       File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(Usee::Zero, 0)
         notice(ok)
@@ -263,6 +275,8 @@ describe 'loaders' do
 
     it "a type can reference a type alias from another module when other module has it declared in init.pp" do
       File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(Usee::One, 1)
@@ -272,6 +286,8 @@ describe 'loaders' do
 
     it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
       File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(User::WithUseeZero, [0])
         notice(ok)
@@ -280,6 +296,8 @@ describe 'loaders' do
 
     it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
       File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(User::WithUseeOne, [1])

data/spec/unit/pops/loaders/module_loaders_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/pops'
 require 'puppet/loaders'
+require 'puppet_spec/compiler'
 
 describe 'FileBased module loader' do
   include PuppetSpec::Files
@@ -92,4 +93,64 @@ describe 'FileBased module loader' do
   def typed_name(type, name)
     Puppet::Pops::Loader::TypedName.new(type, name)
   end
+
+  context 'module function and class using a module type alias' do
+    include PuppetSpec::Compiler
+
+    let(:modules) do
+      {
+        'mod' => {
+          'functions' => {
+            'afunc.pp' => <<-PUPPET.unindent
+              function mod::afunc(Mod::Analias $v) {
+                notice($v)
+              }
+          PUPPET
+          },
+          'types' => {
+            'analias.pp' => <<-PUPPET.unindent
+               type Mod::Analias = Enum[a,b]
+               PUPPET
+          },
+          'manifests' => {
+            'init.pp' => <<-PUPPET.unindent
+              class mod(Mod::Analias $v) {
+                notify { $v: }
+              }
+              PUPPET
+          }
+        }
+      }
+    end
+
+    let(:testing_env) do
+      {
+        'testing' => {
+          'modules' => modules
+        }
+      }
+    end
+
+    let(:environments_dir) { Puppet[:environmentpath] }
+
+    let(:testing_env_dir) do
+      dir_contained_in(environments_dir, testing_env)
+      env_dir = File.join(environments_dir, 'testing')
+      PuppetSpec::Files.record_tmp(env_dir)
+      env_dir
+    end
+
+    let(:env) { Puppet::Node::Environment.create(:testing, [File.join(testing_env_dir, 'modules')]) }
+    let(:node) { Puppet::Node.new('test', :environment => env) }
+
+    # The call to mod:afunc will load the function, and as a consequence, make an attempt to load
+    # the parameter type Mod::Analias. That load in turn, will trigger the Runtime3TypeLoader which
+    # will load the manifests in Mod. The init.pp manifest also references the Mod::Analias parameter
+    # which results in a recursive call to the same loader. This test asserts that this recursive
+    # call is handled OK.
+    # See PUP-7391 for more info.
+    it 'should handle a recursive load' do
+      expect(eval_and_collect_notices("mod::afunc('b')", node)).to eql(['b'])
+    end
+  end
 end

data/spec/unit/pops/lookup/context_spec.rb

@@ -172,10 +172,6 @@ describe 'Puppet::Pops::Lookup::Context' do
       context 'and multiple compilations' do
 
         before(:each) { Puppet.settings[:environment_timeout] = 'unlimited' }
-        after(:each) do
-          Puppet.settings[:environment_timeout] = 0
-          Puppet.lookup(:environments).clear_all
-        end
 
         it 'will reuse cached_file_data and not call block again' do
 
@@ -206,7 +202,7 @@ describe 'Puppet::Pops::Lookup::Context' do
           expect(logs.uniq.size).to eql(1)
         end
 
-        it 'will invalidate cache if file changes' do
+        it 'will invalidate cache if file changes size' do
           code = <<-PUPPET.unindent
             $ctx = Puppet::LookupContext.new(nil)
             $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
@@ -220,12 +216,64 @@ describe 'Puppet::Pops::Lookup::Context' do
             Puppet[:code] = code
             Puppet::Parser::Compiler.compile(node)
 
-            # Change contents!
-            File.write(data_path, "b: value b\n")
+            # Change content size!
+            File.write(data_path, "a: value is now A\n")
+            Puppet::Parser::Compiler.compile(node)
+          end
+          logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
+          expect(logs).to eql(["{parsed => a: value a\n}", "{parsed => a: value is now A\n}"])
+        end
+
+        it 'will invalidate cache if file changes mtime' do
+          old_mtime = Puppet::FileSystem.stat(data_path).mtime
+
+          code = <<-PUPPET.unindent
+            $ctx = Puppet::LookupContext.new(nil)
+            $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
+              { 'parsed' => $content }
+            }
+            notice($yaml_data)
+          PUPPET
+
+          logs = []
+          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+            Puppet[:code] = code
+            Puppet::Parser::Compiler.compile(node)
+
+            # Write content with the same size
+            File.write(data_path, "a: value b\n")
+
+            # Ensure mtime is at least 1 second ahead
+            FileUtils.touch(data_path, :mtime => old_mtime + 1)
+
+            Puppet::Parser::Compiler.compile(node)
+          end
+          logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
+          expect(logs).to eql(["{parsed => a: value a\n}", "{parsed => a: value b\n}"])
+        end
+
+        it 'will invalidate cache if file changes inode' do
+          code = <<-PUPPET.unindent
+              $ctx = Puppet::LookupContext.new(nil)
+              $yaml_data = $ctx.cached_file_data('#{data_path}') |$content| {
+                { 'parsed' => $content }
+              }
+              notice($yaml_data)
+          PUPPET
+
+          logs = []
+          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+            Puppet[:code] = code
+            Puppet::Parser::Compiler.compile(node)
+
+            # Change inode!
+            File.delete(data_path);
+            # Write content with the same size
+            File.write(data_path, "a: value b\n")
             Puppet::Parser::Compiler.compile(node)
           end
           logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
-          expect(logs).to eql(["{parsed => a: value a\n}", "{parsed => b: value b\n}"])
+          expect(logs).to eql(["{parsed => a: value a\n}", "{parsed => a: value b\n}"])
         end
       end
     end

data/spec/unit/pops/lookup/lookup_spec.rb

@@ -176,12 +176,30 @@ describe 'The lookup API' do
         {
           'hiera.yaml' => <<-YAML.unindent,
             version: 5
+            hierarchy:
+              - name: Common
+                path: common.yaml
+              - name: More
+                path: more.yaml
             YAML
           'data' => {
-            'common.yaml' => <<-YAML.unindent
+            'common.yaml' => <<-YAML.unindent,
               a: a (from other global)
               d: d (from other global)
+              mixed_adapter_hash:
+                a:
+                  ab: value a.ab (from other common global)
+                  ad: value a.ad (from other common global)
               mod::e: mod::e (from other global)
+              lookup_options:
+                mixed_adapter_hash:
+                  merge: deep
+              YAML
+            'more.yaml' => <<-YAML.unindent
+              mixed_adapter_hash:
+                a:
+                  aa: value a.aa (from other more global)
+                  ac: value a.ac (from other more global)
               YAML
           }
         }
@@ -224,6 +242,19 @@ describe 'The lookup API' do
         expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, other_invocation)).to eql('not found')
         expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('mod::c (from module)')
       end
+
+      it 'resolves lookup options using the custom adapter' do
+        expect(Lookup.lookup('mixed_adapter_hash', nil, 'not found', true, nil, other_invocation)).to eql(
+          {
+            'a' => {
+              'aa' => 'value a.aa (from other more global)',
+              'ab' => 'value a.ab (from other common global)',
+              'ac' => 'value a.ac (from other more global)',
+              'ad' => 'value a.ad (from other common global)'
+            }
+          }
+        )
+      end
     end
   end
 end

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -412,6 +412,14 @@ describe 'Lexer2' do
     expect(tokens_scanned_from("1 / /./")).to match_tokens2(:NUMBER, :DIV, :REGEX)
   end
 
+  it "should accept newline in a regular expression" do
+    scanned = tokens_scanned_from("/\n.\n/")
+    # Note that strange formatting here is important
+    expect(scanned[0][1][:value]).to eql(/
+.
+/)
+  end
+
   context 'when lexer lexes heredoc' do
     it 'lexes tag, syntax and escapes, margin and right trim' do
       code = <<-CODE

data/spec/unit/pops/types/ruby_generator_spec.rb

@@ -411,6 +411,30 @@ describe 'Puppet Ruby Generator' do
           expect(inst.age).to eql(30)
           expect(inst.another).to be_nil
         end
+
+        it 'two instances with the same attribute values are equal using #eql?' do
+          inst1 = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          expect(inst1.eql?(inst2)).to be_truthy
+        end
+
+        it 'two instances with the same attribute values are equal using #==' do
+          inst1 = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          expect(inst1 == inst2).to be_truthy
+        end
+
+        it 'two instances with the different attribute in super class values are different' do
+          inst1 = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = second.create('Bob Engineer', '42 Cool Street', '12345', 'bob@example.com', 23)
+          expect(inst1 == inst2).to be_falsey
+        end
+
+        it 'two instances with the different attribute in sub class values are different' do
+          inst1 = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@other.com', 23)
+          expect(inst1 == inst2).to be_falsey
+        end
       end
 
       context 'the #from_hash class method' do
@@ -541,6 +565,30 @@ describe 'Puppet Ruby Generator' do
           expect(inst.age).to eql(30)
           expect(inst.another).to be_nil
         end
+
+        it 'two instances with the same attribute values are equal using #eql?' do
+          inst1 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          expect(inst1.eql?(inst2)).to be_truthy
+        end
+
+        it 'two instances with the same attribute values are equal using #==' do
+          inst1 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          expect(inst1 == inst2).to be_truthy
+        end
+
+        it 'two instances with the different attribute in super class values are different' do
+          inst1 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Engineer', '42 Cool Street', '12345', 'bob@example.com', 23)
+          expect(inst1 == inst2).to be_falsey
+        end
+
+        it 'two instances with the different attribute in sub class values are different' do
+          inst1 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+          inst2 = PuppetSpec::RubyGenerator::My::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@other.com', 23)
+          expect(inst1 == inst2).to be_falsey
+        end
       end
 
       context 'the #from_hash class method' do

data/spec/unit/pops/types/type_mismatch_describer_spec.rb

@@ -150,6 +150,15 @@ describe 'the type mismatch describer' do
       /parameter 'arg' expects a match for Enum\['a', 'b'\], got 'c'/))
   end
 
+  it "will include Undef when describing a mismatch against a Variant where one of the types is Undef" do
+    code = <<-CODE
+      define check(Variant[Undef,String,Integer,Hash,Array] $arg) {}
+      check{ x: arg => 2.4 }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a value of type Undef, String, Integer, Hash, or Array/))
+  end
+
   it "will not disclose a Sensitive that doesn't match an enum in a define call" do
     code = <<-CODE
       define check_enums(Enum[a,b] $arg) {}
@@ -196,21 +205,21 @@ describe 'the type mismatch describer' do
     it 'reports a missing block as "expects a block"' do
       callable = parser.parse('Callable[String,String,Callable]')
       args_tuple = parser.parse('Tuple[String,String]')
-      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], 'block', nil, nil, false)
+      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], false, 'block')
       expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' expects a block")
     end
 
     it 'reports an unexpected block as "does not expect a block"' do
       callable = parser.parse('Callable[String,String]')
       args_tuple = parser.parse('Tuple[String,String,Callable]')
-      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], nil, nil, nil, false)
+      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'])
       expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' does not expect a block")
     end
 
     it 'reports a block return type mismatch' do
       callable = parser.parse('Callable[[0,0,Callable[ [0,0],String]],Undef]')
       args_tuple = parser.parse('Tuple[Callable[[0,0],Integer]]')
-      dispatch = Functions::Dispatch.new(callable, 'foo', [], 'block', nil, nil, false)
+      dispatch = Functions::Dispatch.new(callable, 'foo', [], false, 'block')
       expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' block return expects a String value, got Integer")
     end
   end

data/spec/unit/pops/types/types_spec.rb

@@ -330,13 +330,12 @@ describe 'Puppet Type System' do
       end
 
       it 'can be normalized in groups, the result is a Variant containing the resulting normalizations' do
-        expect(groups.normalize).to eq(tf.variant(
-          tf.range(8, 28),
-          tf.float_range(10.0, 28.0),
-          tf.enum('a', 'b', 'c'),
-          tf.pattern('a', 'b', 'c'),
-          tf.optional(tf.range(1,20)))
-        )
+        expect(groups.normalize).to eq(tf.optional(
+          tf.variant(
+            tf.range(1, 28),
+            tf.float_range(10.0, 28.0),
+            tf.enum('a', 'b', 'c'),
+            tf.pattern('a', 'b', 'c'))))
       end
     end
 

data/spec/unit/provider/nameservice_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'puppet/provider/nameservice'
-require 'etc'
+require 'puppet/etc'
 
 describe Puppet::Provider::NameService do
 
@@ -123,26 +123,26 @@ describe Puppet::Provider::NameService do
   describe "#listbyname" do
     it "should return a list of users if resource_type is user" do
       described_class.resource_type = Puppet::Type.type(:user)
-      Etc.expects(:setpwent)
-      Etc.stubs(:getpwent).returns *users
-      Etc.expects(:endpwent)
+      Puppet::Etc.expects(:setpwent)
+      Puppet::Etc.stubs(:getpwent).returns *users
+      Puppet::Etc.expects(:endpwent)
       expect(described_class.listbyname).to eq(%w{root foo})
     end
 
     it "should return a list of groups if resource_type is group", :unless => Puppet.features.microsoft_windows? do
       described_class.resource_type = Puppet::Type.type(:group)
-      Etc.expects(:setgrent)
-      Etc.stubs(:getgrent).returns *groups
-      Etc.expects(:endgrent)
+      Puppet::Etc.expects(:setgrent)
+      Puppet::Etc.stubs(:getgrent).returns *groups
+      Puppet::Etc.expects(:endgrent)
       expect(described_class.listbyname).to eq(%w{root bin})
     end
 
     it "should yield if a block given" do
       yield_results = []
       described_class.resource_type = Puppet::Type.type(:user)
-      Etc.expects(:setpwent)
-      Etc.stubs(:getpwent).returns *users
-      Etc.expects(:endpwent)
+      Puppet::Etc.expects(:setpwent)
+      Puppet::Etc.stubs(:getpwent).returns *users
+      Puppet::Etc.expects(:endpwent)
       described_class.listbyname {|x| yield_results << x }
       expect(yield_results).to eq(%w{root foo})
     end
@@ -188,13 +188,13 @@ describe Puppet::Provider::NameService do
     end
 
     it "should return a hash if we can retrieve something" do
-      Etc.expects(:send).with(:getfoonam, 'bob').returns fakeetcobject
+      Puppet::Etc.expects(:send).with(:getfoonam, 'bob').returns fakeetcobject
       provider.expects(:info2hash).with(fakeetcobject).returns(:foo => 'fooval', :bar => 'barval')
       expect(provider.getinfo(true)).to eq({:foo => 'fooval', :bar => 'barval'})
     end
 
     it "should return nil if we cannot retrieve anything" do
-      Etc.expects(:send).with(:getfoonam, 'bob').raises(ArgumentError, "can't find bob")
+      Puppet::Etc.expects(:send).with(:getfoonam, 'bob').raises(ArgumentError, "can't find bob")
       provider.expects(:info2hash).never
       expect(provider.getinfo(true)).to be_nil
     end