puppet 4.0.0.rc1-x64-mingw32 → 4.0.0-x64-mingw32

data/spec/fixtures/unit/functions/lookup/environments/production/modules/bca/lib/puppet/functions/bca/data.rb

@@ -0,0 +1,9 @@
+Puppet::Functions.create_function(:'bca::data') do
+  def data()
+    { 'bca::b' => 'module_bca_b',
+      'bca::c' => 'module_bca_c',
+      'bca::e' => { 'k1' => 'module_bca_e1', 'k2' => 'module_bca_e2' },
+      'bca::f' => { 'k1' => { 's1' => 'module_bca_f11', 's3' => 'module_bca_f13' },  'k2' => { 's1' => 'module_bca_f21', 's2' => 'module_bca_f22' }},
+    }
+  end
+end

data/spec/fixtures/unit/functions/lookup/environments/production/modules/bca/manifests/init.pp

@@ -0,0 +1,2 @@
+class bca {
+}

data/spec/fixtures/unit/functions/lookup/environments/production/modules/no_provider/manifests/init.pp

@@ -0,0 +1,2 @@
+class no_provider {
+}

data/spec/integration/provider/yumrepo_spec.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet/file_bucket/dipper'
+require 'puppet_spec/files'
+require 'puppet_spec/compiler'
+
+describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
+  :unless => Puppet.features.microsoft_windows? do
+  include PuppetSpec::Files
+  include PuppetSpec::Compiler
+
+  before :each do
+    # Don't backup to filebucket
+    Puppet::FileBucket::Dipper.any_instance.stubs(:backup)
+    # We don't want to execute anything
+    described_class.stubs(:filetype).
+      returns Puppet::Util::FileType::FileTypeFlat
+
+    @yumrepo_dir  = tmpdir('yumrepo_integration_specs')
+    @yumrepo_file = tmpfile('yumrepo_file', @yumrepo_dir)
+    @yumrepo_conf_file = tmpfile('yumrepo_conf_file', @yumrepo_dir)
+    # this mocks the reposdir logic in the provider and thus won't test for
+    # issues like PUP-2916. Cover these types of issues in acceptance
+    described_class.stubs(:reposdir).returns [@yumrepo_dir]
+    described_class.stubs(:repofiles).returns [@yumrepo_conf_file]
+  end
+
+  after :each do
+    # yumrepo provider class
+    described_class.clear
+  end
+
+  let(:type_under_test) { :yumrepo }
+
+  describe 'when managing a yumrepo file it...' do
+    let(:super_creative) { 'my.super.creati.ve' }
+    let(:manifest) {
+      "#{type_under_test} { '#{super_creative}':
+                    baseurl => 'http://#{super_creative}',
+                    target  => '#{@yumrepo_file}' }"
+    }
+    let(:expected_match) { "\[#{super_creative}\]\nbaseurl=http:\/\/my\.super\.creati\.ve" }
+
+    it 'should create a new yumrepo file with mode 0644 and yumrepo entry' do
+      apply_with_error_check(manifest)
+      expect_file_mode(File.join(@yumrepo_dir, super_creative + '.repo'), "644")
+      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
+        to match(expected_match + "\n")
+    end
+
+    it 'should remove a managed yumrepo entry' do
+      apply_with_error_check(manifest)
+      manifest = "#{type_under_test} { '#{super_creative}':
+                    ensure => absent,
+                    target  => '#{@yumrepo_file}' }"
+      apply_with_error_check(manifest)
+      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
+        to be_empty
+    end
+
+    it 'should update a managed yumrepo entry' do
+      apply_with_error_check(manifest)
+      manifest = "#{type_under_test} { '#{super_creative}':
+                    baseurl => 'http://#{super_creative}.updated',
+                    target  => '#{@yumrepo_file}' }"
+      apply_with_error_check(manifest)
+      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
+        to match(expected_match + ".updated\n")
+    end
+
+    it 'should create all properties of a yumrepo entry' do
+      manifest = "#{type_under_test} { '#{super_creative}':
+                    baseurl => 'http://#{super_creative}',
+                    target  => '#{@yumrepo_file}' }"
+      apply_with_error_check(manifest)
+      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
+        to match("\[#{super_creative}\]")
+    end
+
+    # The unit-tests cover all properties
+    #   and we have to hard-code the "should" values here.
+    # Puppet::Type.type(:yumrepo).validproperties contains the full list
+    #   but we can't get the property "should" values from the yumrepo-type
+    #   without having an instance of type, which is what yumrepo defines...
+    #   Just cover the most probable used properties.
+    properties = {"bandwidth"      => "42M",
+                  "baseurl"        => "http://er0ck",
+                  "cost"           => "42",
+                  "enabled"        => "YeS",
+                  "exclude"        => "er0ckSet2.0",
+                  "failovermethod" => "roundrobin",
+                  "include"        => "https://er0ck",
+                  "mirrorlist"     => "https://er0ckMirr0r.co",
+                  "priority"       => "99",
+                  "retries"        => "413189",
+                  "timeout"        => "666"
+    }
+
+    it "should create an entry with various properties" do
+      manifest = "#{type_under_test} { '#{super_creative}':
+                          target  => '#{@yumrepo_file}',\n"
+      properties.each do |property_key, property_value|
+        manifest << "#{property_key} => '#{property_value}',\n"
+      end
+      manifest << "}"
+      apply_with_error_check(manifest)
+      file_lines = File.read(File.join(@yumrepo_dir, super_creative + '.repo'))
+      properties.each do |property_key, property_value|
+        expect(file_lines).to match(/^#{property_key}=#{Regexp.escape(property_value)}$/)
+      end
+    end
+
+    ##puppet resource yumrepo
+    it "should fetch the yumrepo entries from resource face" do
+      @resource_app = Puppet::Application[:resource]
+      @resource_app.preinit
+      @resource_app.command_line.stubs(:args).
+        returns([type_under_test, super_creative])
+
+      @resource_app.expects(:puts).with  do |args|
+        expect(args).to match(/#{super_creative}/)
+      end
+      @resource_app.main
+    end
+  end
+end

data/spec/unit/application/device_spec.rb

@@ -126,7 +126,6 @@ describe Puppet::Application::Device do
   describe "during setup" do
     before :each do
       @device.options.stubs(:[])
-      Puppet.stubs(:info)
       Puppet[:libdir] = "/dev/null/lib"
       Puppet::SSL::Host.stubs(:ca_location=)
       Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
@@ -271,6 +270,7 @@ describe Puppet::Application::Device do
     before :each do
       @device.options.stubs(:[]).with(:fingerprint).returns(false)
       Puppet.stubs(:notice)
+      @device.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
       @device.options.stubs(:[]).with(:client)
       Puppet::Util::NetworkDevice::Config.stubs(:devices).returns({})
     end
@@ -283,7 +283,7 @@ describe Puppet::Application::Device do
     it "should get the device list" do
       device_hash = stub_everything 'device hash'
       Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
-      @device.main
+      expect { @device.main }.to exit_with 1
     end
 
     it "should exit if the device list is empty" do
@@ -296,8 +296,8 @@ describe Puppet::Application::Device do
         Puppet[:confdir] = make_absolute("/dummy")
         Puppet[:certname] = "certname"
         @device_hash = {
-          "device1" => OpenStruct.new(:name => "device1", :url => "url", :provider => "cisco"),
-          "device2" => OpenStruct.new(:name => "device2", :url => "url", :provider => "cisco"),
+          "device1" => OpenStruct.new(:name => "device1", :url => "ssh://user:pass@testhost", :provider => "cisco"),
+          "device2" => OpenStruct.new(:name => "device2", :url => "https://user:pass@testhost/some/path", :provider => "rest"),
         }
         Puppet::Util::NetworkDevice::Config.stubs(:devices).returns(@device_hash)
         Puppet.stubs(:[]=)
@@ -310,38 +310,76 @@ describe Puppet::Application::Device do
 
       it "should set vardir to the device vardir" do
         Puppet.expects(:[]=).with(:vardir, make_absolute("/dummy/devices/device1"))
-        @device.main
+        expect { @device.main }.to exit_with 1
       end
 
       it "should set confdir to the device confdir" do
         Puppet.expects(:[]=).with(:confdir, make_absolute("/dummy/devices/device1"))
-        @device.main
+        expect { @device.main }.to exit_with 1
       end
 
       it "should set certname to the device certname" do
         Puppet.expects(:[]=).with(:certname, "device1")
         Puppet.expects(:[]=).with(:certname, "device2")
-        @device.main
+        expect { @device.main }.to exit_with 1
       end
 
       it "should make sure all the required folders and files are created" do
         Puppet.settings.expects(:use).with(:main, :agent, :ssl).twice
-        @device.main
+        expect { @device.main }.to exit_with 1
       end
 
       it "should initialize the device singleton" do
         Puppet::Util::NetworkDevice.expects(:init).with(@device_hash["device1"]).then.with(@device_hash["device2"])
-        @device.main
+        expect { @device.main }.to exit_with 1
+      end
+
+      it "should print the device url scheme, host, and port" do
+        Puppet.expects(:info).with "starting applying configuration to device1 at ssh://testhost"
+        Puppet.expects(:info).with "starting applying configuration to device2 at https://testhost:443/some/path"
+        expect { @device.main }.to exit_with 1
       end
 
       it "should setup the SSL context" do
         @device.expects(:setup_host).twice
-        @device.main
+        expect { @device.main }.to exit_with 1
       end
 
       it "should launch a configurer for this device" do
         @configurer.expects(:run).twice
-        @device.main
+        expect { @device.main }.to exit_with 1
+      end
+
+      it "exits 1 when configurer raises error" do
+        @configurer.stubs(:run).raises(Puppet::Error).then.returns(0)
+        expect { @device.main }.to exit_with 1
+      end
+
+      it "exits 0 when run happens without puppet errors but with failed run" do
+        @configurer.stubs(:run).returns(6,2)
+        expect { @device.main }.to exit_with 0
+      end
+
+      it "exits 2 when --detailed-exitcodes and successful runs" do
+        @device.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+        @configurer.stubs(:run).returns(0,2)
+        expect { @device.main }.to exit_with 2
+      end
+
+      it "exits 1 when --detailed-exitcodes and failed parse" do
+        @configurer = stub_everything 'configurer'
+        Puppet::Configurer.stubs(:new).returns(@configurer)
+        @device.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+        @configurer.stubs(:run).returns(6,1)
+        expect { @device.main }.to exit_with 7
+      end
+
+      it "exits 6 when --detailed-exitcodes and failed run" do
+        @configurer = stub_everything 'configurer'
+        Puppet::Configurer.stubs(:new).returns(@configurer)
+        @device.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+        @configurer.stubs(:run).returns(6,2)
+        expect { @device.main }.to exit_with 6
       end
 
       [:vardir, :confdir].each do |setting|
@@ -369,7 +407,7 @@ describe Puppet::Application::Device do
           end
 
 
-          @device.main
+          expect { @device.main }.to exit_with 1
 
           expect(found_devices).to eq(all_devices)
         end
@@ -399,7 +437,7 @@ describe Puppet::Application::Device do
         end
 
 
-        @device.main
+        expect { @device.main }.to exit_with 1
 
         # make sure that we were called with each of the defined devices
         expect(found_devices).to eq(all_devices)
@@ -408,7 +446,7 @@ describe Puppet::Application::Device do
       it "should expire all cached attributes" do
         Puppet::SSL::Host.expects(:reset).twice
 
-        @device.main
+        expect { @device.main }.to exit_with 1
       end
     end
   end

data/spec/unit/functions/lookup_spec.rb

@@ -67,198 +67,198 @@ describe "when performing lookup" do
 
   context 'using normal parameters' do
     it 'can lookup value provided by the environment' do
-      resources = assemble_and_compile('${r}', "'a'")
+      resources = assemble_and_compile('${r}', "'abc::a'")
       expect(resources).to include('env_a')
     end
 
     it 'can lookup value provided by the module' do
-      resources = assemble_and_compile('${r}', "'b'")
+      resources = assemble_and_compile('${r}', "'abc::b'")
       expect(resources).to include('module_b')
     end
 
     it 'can lookup value provided in global scope' do
-      Hiera.any_instance.expects(:lookup).with('a', any_parameters).returns('global_a')
-      resources = assemble_and_compile('${r}', "'a'")
+      Hiera.any_instance.expects(:lookup).with('abc::a', any_parameters).returns('global_a')
+      resources = assemble_and_compile('${r}', "'abc::a'")
       expect(resources).to include('global_a')
     end
 
     it 'will stop at first found name when several names are provided' do
-      resources = assemble_and_compile('${r}', "['b', 'a']")
+      resources = assemble_and_compile('${r}', "['abc::b', 'abc::a']")
       expect(resources).to include('module_b')
     end
 
     it 'can lookup value provided by the module that is overriden by environment' do
-      resources = assemble_and_compile('${r}', "'c'")
+      resources = assemble_and_compile('${r}', "'abc::c'")
       expect(resources).to include('env_c')
     end
 
     it "can 'unique' merge values provided by both the module and the environment" do
-      resources = assemble_and_compile('${r[0]}_${r[1]}', "'c'", 'Array[String]', "'unique'")
+      resources = assemble_and_compile('${r[0]}_${r[1]}', "'abc::c'", 'Array[String]', "'unique'")
       expect(resources).to include('env_c_module_c')
     end
 
     it "can 'hash' merge values provided by the environment only" do
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'d'", 'Hash[String,String]', "'hash'")
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::d'", 'Hash[String,String]', "'hash'")
       expect(resources).to include('env_d1_env_d2_env_d3')
     end
 
     it "can 'hash' merge values provided by both the environment and the module" do
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'e'", 'Hash[String,String]', "'hash'")
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "'hash'")
       expect(resources).to include('env_e1_module_e2_env_e3')
     end
 
     it "can 'hash' merge values provided by global, environment, and module" do
-      Hiera.any_instance.expects(:lookup).with('e', any_parameters).returns({ 'k1' => 'global_e1' })
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'e'", 'Hash[String,String]', "'hash'")
+      Hiera.any_instance.expects(:lookup).with('abc::e', any_parameters).returns({ 'k1' => 'global_e1' })
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "'hash'")
       expect(resources).to include('global_e1_module_e2_env_e3')
     end
 
     it "can pass merge parameter in the form of a hash with a 'strategy=>unique'" do
-      resources = assemble_and_compile('${r[0]}_${r[1]}', "'c'", 'Array[String]', "{strategy => 'unique'}")
+      resources = assemble_and_compile('${r[0]}_${r[1]}', "'abc::c'", 'Array[String]', "{strategy => 'unique'}")
       expect(resources).to include('env_c_module_c')
     end
 
     it "can pass merge parameter in the form of a hash with 'strategy=>hash'" do
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'e'", 'Hash[String,String]', "{strategy => 'hash'}")
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "{strategy => 'hash'}")
       expect(resources).to include('env_e1_module_e2_env_e3')
     end
 
     it "can pass merge parameter in the form of a hash with a 'strategy=>deep'" do
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'e'", 'Hash[String,String]', "{strategy => 'deep'}")
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "{strategy => 'deep'}")
       expect(resources).to include('env_e1_module_e2_env_e3')
     end
 
     it "will fail unless merge in the form of a hash contains a 'strategy'" do
       expect do
-        assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'e'", 'Hash[String,String]', "{merge_key => 'hash'}")
+        assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "{merge_key => 'hash'}")
       end.to raise_error(Puppet::ParseError, /hash given as 'merge' must contain the name of a strategy/)
     end
 
     it 'will raise an exception when value is not found for single key and no default is provided' do
       expect do
-        assemble_and_compile('${r}', "'x'")
-      end.to raise_error(Puppet::ParseError, /did not find a value for the name 'x'/)
+        assemble_and_compile('${r}', "'abc::x'")
+      end.to raise_error(Puppet::ParseError, /did not find a value for the name 'abc::x'/)
     end
 
     it 'can lookup an undef value' do
-      resources = assemble_and_compile('${r}', "'n'")
+      resources = assemble_and_compile('${r}', "'abc::n'")
       expect(resources).to include('no_value')
     end
 
     it 'will not replace an undef value with a given default' do
-      resources = assemble_and_compile('${r}', "'n'", 'undef', 'undef', '"default_n"')
+      resources = assemble_and_compile('${r}', "'abc::n'", 'undef', 'undef', '"default_n"')
       expect(resources).to include('no_value')
     end
 
     it 'will not accept a succesful lookup of an undef value when the type rejects it' do
       expect do
-        assemble_and_compile('${r}', "'n'", 'String')
+        assemble_and_compile('${r}', "'abc::n'", 'String')
       end.to raise_error(Puppet::ParseError, /found value has wrong type/)
     end
 
     it 'will raise an exception when value is not found for array key and no default is provided' do
       expect do
-        assemble_and_compile('${r}', "['x', 'y']")
-      end.to raise_error(Puppet::ParseError, /did not find a value for any of the names \['x', 'y'\]/)
+        assemble_and_compile('${r}', "['abc::x', 'abc::y']")
+      end.to raise_error(Puppet::ParseError, /did not find a value for any of the names \['abc::x', 'abc::y'\]/)
     end
 
     it 'can lookup and deep merge shallow values provided by the environment only' do
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'d'", 'Hash[String,String]', "'deep'")
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::d'", 'Hash[String,String]', "'deep'")
       expect(resources).to include('env_d1_env_d2_env_d3')
     end
 
     it 'can lookup and deep merge shallow values provided by both the module and the environment' do
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'e'", 'Hash[String,String]', "'deep'")
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "'deep'")
       expect(resources).to include('env_e1_module_e2_env_e3')
     end
 
     it 'can lookup and deep merge deep values provided by global, environment, and module' do
-      Hiera.any_instance.expects(:lookup).with('f', any_parameters).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
-      resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'f'", 'Hash[String,Hash[String,String]]', "'deep'")
+      Hiera.any_instance.expects(:lookup).with('abc::f', any_parameters).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
+      resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'abc::f'", 'Hash[String,Hash[String,String]]', "'deep'")
       expect(resources).to include('global_f11_env_f12_module_f13_env_f21_module_f22_global_f23')
     end
 
     it 'will propagate resolution_type :array to Hiera when merge == \'unique\''  do
-      Hiera.any_instance.expects(:lookup).with('c', anything, anything, anything, :array).returns(['global_c'])
-      resources = assemble_and_compile('${r[0]}_${r[1]}_${r[2]}', "'c'", 'Array[String]', "'unique'")
+      Hiera.any_instance.expects(:lookup).with('abc::c', anything, anything, anything, :array).returns(['global_c'])
+      resources = assemble_and_compile('${r[0]}_${r[1]}_${r[2]}', "'abc::c'", 'Array[String]', "'unique'")
       expect(resources).to include('global_c_env_c_module_c')
     end
 
     it 'will propagate a Hash resolution_type with :behavior => :native to Hiera when merge == \'hash\''  do
-      Hiera.any_instance.expects(:lookup).with('e', anything, anything, anything, { :behavior => :native }).returns({ 'k1' => 'global_e1' })
-      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'e'", 'Hash[String,String]', "{strategy => 'hash'}")
+      Hiera.any_instance.expects(:lookup).with('abc::e', anything, anything, anything, { :behavior => :native }).returns({ 'k1' => 'global_e1' })
+      resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "{strategy => 'hash'}")
       expect(resources).to include('global_e1_module_e2_env_e3')
     end
 
     it 'will propagate a Hash resolution_type with :behavior => :deeper to Hiera when merge == \'deep\''  do
-      Hiera.any_instance.expects(:lookup).with('f', anything, anything, anything, { :behavior => :deeper }).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
-      resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'f'", 'Hash[String,Hash[String,String]]', "'deep'")
+      Hiera.any_instance.expects(:lookup).with('abc::f', anything, anything, anything, { :behavior => :deeper }).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
+      resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'abc::f'", 'Hash[String,Hash[String,String]]', "'deep'")
       expect(resources).to include('global_f11_env_f12_module_f13_env_f21_module_f22_global_f23')
     end
 
     it 'will propagate a Hash resolution_type with symbolic deep merge options to Hiera'  do
-      Hiera.any_instance.expects(:lookup).with('f', anything, anything, anything, { :behavior => :deeper, :knockout_prefix => '--' }).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
-      resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'f'", 'Hash[String,Hash[String,String]]', "{ 'strategy' => 'deep', 'knockout_prefix' => '--' }")
+      Hiera.any_instance.expects(:lookup).with('abc::f', anything, anything, anything, { :behavior => :deeper, :knockout_prefix => '--' }).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
+      resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'abc::f'", 'Hash[String,Hash[String,String]]', "{ 'strategy' => 'deep', 'knockout_prefix' => '--' }")
       expect(resources).to include('global_f11_env_f12_module_f13_env_f21_module_f22_global_f23')
     end
 
     context 'with provided default' do
       it 'will return default when lookup fails' do
-        resources = assemble_and_compile('${r}', "'x'", 'String', 'undef', "'dflt_x'")
+        resources = assemble_and_compile('${r}', "'abc::x'", 'String', 'undef', "'dflt_x'")
         expect(resources).to include('dflt_x')
       end
 
       it 'can precede default parameter with undef as the value_type and undef as the merge type' do
-        resources = assemble_and_compile('${r}', "'x'", 'undef', 'undef', "'dflt_x'")
+        resources = assemble_and_compile('${r}', "'abc::x'", 'undef', 'undef', "'dflt_x'")
         expect(resources).to include('dflt_x')
       end
 
       it 'can use array' do
-        resources = assemble_and_compile('${r[0]}_${r[1]}', "'x'", 'Array[String]', 'undef', "['dflt_x', 'dflt_y']")
+        resources = assemble_and_compile('${r[0]}_${r[1]}', "'abc::x'", 'Array[String]', 'undef', "['dflt_x', 'dflt_y']")
         expect(resources).to include('dflt_x_dflt_y')
       end
 
       it 'can use hash' do
-        resources = assemble_and_compile('${r[a]}_${r[b]}', "'x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 'dflt_y'}")
+        resources = assemble_and_compile('${r[a]}_${r[b]}', "'abc::x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 'dflt_y'}")
         expect(resources).to include('dflt_x_dflt_y')
       end
 
       it 'fails unless default is an instance of value_type' do
         expect do
-          assemble_and_compile('${r[a]}_${r[b]}', "'x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 32}")
+          assemble_and_compile('${r[a]}_${r[b]}', "'abc::x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 32}")
         end.to raise_error(Puppet::ParseError, /default_value value has wrong type/)
       end
     end
 
     context 'with a default block' do
       it 'will be called when lookup fails' do
-        resources = assemble_and_compile_with_block('${r}', "'dflt_x'", "'x'")
+        resources = assemble_and_compile_with_block('${r}', "'dflt_x'", "'abc::x'")
         expect(resources).to include('dflt_x')
       end
 
       it 'will not called when lookup succeeds but the found value is nil' do
-        resources = assemble_and_compile_with_block('${r}', "'dflt_x'", "'n'")
+        resources = assemble_and_compile_with_block('${r}', "'dflt_x'", "'abc::n'")
         expect(resources).to include('no_value')
       end
 
       it 'can use array' do
-        resources = assemble_and_compile_with_block('${r[0]}_${r[1]}', "['dflt_x', 'dflt_y']", "'x'")
+        resources = assemble_and_compile_with_block('${r[0]}_${r[1]}', "['dflt_x', 'dflt_y']", "'abc::x'")
         expect(resources).to include('dflt_x_dflt_y')
       end
 
       it 'can use hash' do
-        resources = assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 'dflt_y'}", "'x'")
+        resources = assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 'dflt_y'}", "'abc::x'")
         expect(resources).to include('dflt_x_dflt_y')
       end
 
       it 'can return undef from block' do
-        resources = assemble_and_compile_with_block('${r}', 'undef', "'x'")
+        resources = assemble_and_compile_with_block('${r}', 'undef', "'abc::x'")
         expect(resources).to include('no_value')
       end
 
       it 'fails unless block returns an instance of value_type' do
         expect do
-          assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 32}", "'x'", 'Hash[String,String]')
+          assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 32}", "'abc::x'", 'Hash[String,String]')
         end.to raise_error(Puppet::ParseError, /default_block value has wrong type/)
       end
 
@@ -276,49 +276,89 @@ describe "when performing lookup" do
 
   context 'when passing a hash as the only parameter' do
     it 'can pass a single name correctly' do
-      resources = assemble_and_compile('${r}', "{name => 'a'}")
+      resources = assemble_and_compile('${r}', "{name => 'abc::a'}")
       expect(resources).to include('env_a')
     end
 
     it 'can pass a an array of names correctly' do
-      resources = assemble_and_compile('${r}', "{name => ['b', 'a']}")
+      resources = assemble_and_compile('${r}', "{name => ['abc::b', 'abc::a']}")
       expect(resources).to include('module_b')
     end
 
     it 'can pass an override map and find values there even though they would be found' do
-      resources = assemble_and_compile('${r}', "{name => 'a', override => { a => 'override_a'}}")
+      resources = assemble_and_compile('${r}', "{name => 'abc::a', override => { abc::a => 'override_a'}}")
       expect(resources).to include('override_a')
     end
 
     it 'can pass an default_values_hash and find values there correctly' do
-      resources = assemble_and_compile('${r}', "{name => 'x', default_values_hash => { x => 'extra_x'}}")
+      resources = assemble_and_compile('${r}', "{name => 'abc::x', default_values_hash => { abc::x => 'extra_x'}}")
       expect(resources).to include('extra_x')
     end
 
     it 'can pass an default_values_hash but not use it when value is found elsewhere' do
-      resources = assemble_and_compile('${r}', "{name => 'a', default_values_hash => { a => 'extra_a'}}")
+      resources = assemble_and_compile('${r}', "{name => 'abc::a', default_values_hash => { abc::a => 'extra_a'}}")
       expect(resources).to include('env_a')
     end
 
     it 'can pass an default_values_hash but not use it when value is found elsewhere even when found value is undef' do
-      resources = assemble_and_compile('${r}', "{name => 'n', default_values_hash => { n => 'extra_n'}}")
+      resources = assemble_and_compile('${r}', "{name => 'abc::n', default_values_hash => { abc::n => 'extra_n'}}")
       expect(resources).to include('no_value')
     end
 
     it 'can pass an override and an default_values_hash and find the override value' do
-      resources = assemble_and_compile('${r}', "{name => 'x', override => { x => 'override_x'}, default_values_hash => { x => 'extra_x'}}")
+      resources = assemble_and_compile('${r}', "{name => 'abc::x', override => { abc::x => 'override_x'}, default_values_hash => { abc::x => 'extra_x'}}")
       expect(resources).to include('override_x')
     end
 
     it 'will raise an exception when value is not found for single key and no default is provided' do
       expect do
-        assemble_and_compile('${r}', "{name => 'x'}")
-      end.to raise_error(Puppet::ParseError, /did not find a value for the name 'x'/)
+        assemble_and_compile('${r}', "{name => 'abc::x'}")
+      end.to raise_error(Puppet::ParseError, /did not find a value for the name 'abc::x'/)
     end
 
     it 'will not raise an exception when value is not found default value is nil' do
-      resources = assemble_and_compile('${r}', "{name => 'x', default_value => undef}")
+      resources = assemble_and_compile('${r}', "{name => 'abc::x', default_value => undef}")
       expect(resources).to include('no_value')
     end
   end
+
+  context 'when accessing from outside a module' do
+    it 'will raise an exception when key in the function provided module data is not prefixed' do
+      Puppet[:code] = "include bad_data\nlookup(bad_data::b)"
+      expect do
+        compiler.compile()
+      end.to raise_error(Puppet::ParseError, /data for module 'bad_data' must use keys qualified with the name of the module/)
+    end
+
+    it 'will resolve global, environment, and module correctly' do
+      Hiera.any_instance.expects(:lookup).with('bca::e', any_parameters).returns({ 'k1' => 'global_e1' })
+      Puppet[:code] = <<-END.gsub(/^ {8}/, '')
+        include bca
+        $r = lookup(bca::e, Hash[String,String], hash)
+        notify { "${r[k1]}_${r[k2]}_${r[k3]}": }
+      END
+      resources = compiler.compile().resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+      expect(resources).to include('global_e1_module_bca_e2_env_bca_e3')
+    end
+
+    it 'will resolve global and environment correctly when module has no provider' do
+      Hiera.any_instance.expects(:lookup).with('no_provider::e', any_parameters).returns({ 'k1' => 'global_e1' })
+      Puppet[:code] = <<-END.gsub(/^ {8}/, '')
+        include no_provider
+        $r = lookup(no_provider::e, Hash[String,String], hash)
+        notify { "${r[k1]}_${r[k2]}_${r[k3]}": }
+      END
+      resources = compiler.compile().resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+      expect(resources).to include('global_e1__env_no_provider_e3') # k2 is missing
+    end
+  end
+
+  context 'when accessing bad data' do
+    it 'will raise an exception when key in the function provided module data is not prefixed' do
+      Puppet[:code] = 'include bad_data'
+      expect do
+        compiler.compile()
+      end.to raise_error(Puppet::ParseError, /data for module 'bad_data' must use keys qualified with the name of the module/)
+    end
+  end
 end