puppet 4.0.0 → 4.5.0

data/spec/unit/configurer_spec.rb

@@ -369,12 +369,34 @@ describe Puppet::Configurer do
       expect(report.environment).to eq("second_env")
     end
 
-    it "should clear the global caches" do
-      $env_module_directories = false
+    it "sends the transaction uuid in a catalog request" do
+      @agent.instance_variable_set(:@transaction_uuid, 'aaa')
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => 'aaa'))
+      @agent.run
+    end
 
+    it "sets the static_catalog query param to true in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:static_catalog => true))
       @agent.run
+    end
 
-      expect($env_module_directories).to eq(nil)
+    it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything,
+        has_entries(:checksum_type => 'md5.sha256'))
+      @agent.run
+    end
+
+    it "sets the checksum_type query param to the supported_checksum_types setting in a catalog request" do
+      # Regenerate the agent to pick up the new setting
+      Puppet[:supported_checksum_types] = ['sha256']
+      @agent = Puppet::Configurer.new
+      @agent.stubs(:init_storage)
+      @agent.stubs(:download_plugins)
+      @agent.stubs(:send_report)
+      @agent.stubs(:save_last_run_summary)
+
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:checksum_type => 'sha256'))
+      @agent.run
     end
 
     describe "when not using a REST terminus for catalogs" do
@@ -531,19 +553,55 @@ describe Puppet::Configurer do
       Puppet::Node.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => anything)).twice
       @agent.run
     end
+
+    it "sends an explicitly configured environment request" do
+      Puppet.settings.expects(:set_by_config?).with(:environment).returns(true)
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => Puppet[:environment])).twice
+      @agent.run
+    end
+
+    it "does not send a configured_environment when using the default" do
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => nil)).twice
+      @agent.run
+    end
+  end
+
+  def expects_new_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+  end
+
+  def expects_cached_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+  end
+
+  def expects_fallback_to_cached_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+  end
+
+  def expects_fallback_to_new_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+  end
+
+  def expects_neither_new_or_cached_catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
   end
 
   describe "when retrieving a catalog" do
     before do
       Puppet.settings.stubs(:use).returns(true)
       @agent.stubs(:facts_for_uploading).returns({})
+      @agent.stubs(:download_plugins)
 
-      @catalog = Puppet::Resource::Catalog.new
+      # retrieve a catalog in the current environment, so we don't try to converge unexpectedly
+      @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
 
       # this is the default when using a Configurer instance
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
-
-      @agent.stubs(:convert_catalog).returns @catalog
     end
 
     describe "and configured to only retrieve a catalog from the cache" do
@@ -552,18 +610,123 @@ describe Puppet::Configurer do
       end
 
       it "should first look in the cache for a catalog" do
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+        expects_cached_catalog_only(@catalog)
 
         expect(@agent.retrieve_catalog({})).to eq(@catalog)
       end
 
+      it "should not make a node request or pluginsync when a cached catalog is successfully retrieved" do
+        Puppet::Node.indirection.expects(:find).never
+        expects_cached_catalog_only(@catalog)
+        @agent.expects(:download_plugins).never
+
+        @agent.run
+      end
+
+      it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
+        Puppet::Node.indirection.expects(:find).returns nil
+        expects_fallback_to_new_catalog(@catalog)
+        @agent.expects(:download_plugins)
+
+        @agent.run
+      end
+
+      it "should set its cached_catalog_status to 'explicitly_requested'" do
+        expects_cached_catalog_only(@catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
+      end
+
+      it "should set its cached_catalog_status to 'explicitly requested' if the cached catalog is from a different environment" do
+        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        expects_cached_catalog_only(cached_catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
+      end
+
       it "should compile a new catalog if none is found in the cache" do
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+        expects_fallback_to_new_catalog(@catalog)
 
         expect(@agent.retrieve_catalog({})).to eq(@catalog)
       end
+
+      it "should set its cached_catalog_status to 'not_used' if no catalog is found in the cache" do
+        expects_fallback_to_new_catalog(@catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+      end
+
+      it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
+        Puppet::Node.indirection.expects(:find).returns(nil)
+        expects_neither_new_or_cached_catalog
+
+        @agent.run
+      end
+
+      it "should return the cached catalog when the environment doesn't match" do
+        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        expects_cached_catalog_only(cached_catalog)
+
+        Puppet.expects(:info).with("Using cached catalog from environment 'second_env'")
+        expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+      end
+    end
+
+    describe "and strict environment mode is set" do
+      before do
+        @catalog.stubs(:to_ral).returns(@catalog)
+        @catalog.stubs(:write_class_file)
+        @catalog.stubs(:write_resource_file)
+        @agent.stubs(:send_report)
+        @agent.stubs(:save_last_run_summary)
+        Puppet.settings[:strict_environment_mode] = true
+      end
+
+      it "should not make a node request" do
+        Puppet::Node.indirection.expects(:find).never
+
+        @agent.run
+      end
+
+      it "should return nil when the catalog's environment doesn't match the agent specified environment" do
+        @agent.instance_variable_set(:@environment, 'second_env')
+        expects_new_catalog_only(@catalog)
+
+        Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+        expect(@agent.run).to be_nil
+      end
+
+      it "should not return nil when the catalog's environment matches the agent specified environment" do
+        @agent.instance_variable_set(:@environment, 'production')
+        expects_new_catalog_only(@catalog)
+
+        expect(@agent.run).to eq(0)
+      end
+
+      describe "and a cached catalog is explicitly requested" do
+        before do
+          Puppet.settings[:use_cached_catalog] = true
+        end
+
+        it "should return nil when the cached catalog's environment doesn't match the agent specified environment" do
+          @agent.instance_variable_set(:@environment, 'second_env')
+          expects_cached_catalog_only(@catalog)
+
+          Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+          expect(@agent.run).to be_nil
+        end
+
+        it "should proceed with the cached catalog if its environment matchs the local environment" do
+          Puppet.settings[:use_cached_catalog] = true
+          @agent.instance_variable_set(:@environment, 'production')
+          expects_cached_catalog_only(@catalog)
+
+          expect(@agent.run).to eq(0)
+        end
+      end
     end
 
     it "should use the Catalog class to get its catalog" do
@@ -572,6 +735,13 @@ describe Puppet::Configurer do
       @agent.retrieve_catalog({})
     end
 
+    it "should set its cached_catalog_status to 'not_used' when downloading a new catalog" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
     it "should use its node_name_value to retrieve the catalog" do
       Facter.stubs(:value).returns "eh"
       Puppet.settings[:node_name_value] = "myhost.domain.com"
@@ -587,17 +757,21 @@ describe Puppet::Configurer do
     end
 
     it "should log and return the cached catalog when no catalog can be retrieved from the server" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-
-      Puppet.expects(:notice)
+      expects_fallback_to_cached_catalog(@catalog)
 
+      Puppet.expects(:info).with("Using cached catalog from environment 'production'")
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
+    it "should set its cached_catalog_status to 'on_failure' when no catalog can be retrieved from the server" do
+      expects_fallback_to_cached_catalog(@catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
+
     it "should not look in the cache for a catalog if one is returned from the server" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+      expects_new_catalog_only(@catalog)
 
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
@@ -609,72 +783,141 @@ describe Puppet::Configurer do
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
+    it "should set its cached_catalog_status to 'on_failure' when retrieving the remote catalog throws an exception" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
+
     it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
       Puppet[:usecacheonfailure] = false
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
 
-      Puppet.expects(:warning)
+      Puppet.expects(:warning).with('Not using cache on failed catalog')
 
       expect(@agent.retrieve_catalog({})).to be_nil
     end
 
-    it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
+    it "should set its cached_catalog_status to 'not_used' if no catalog can be retrieved from the server and :usecacheonfailure is disabled or fails to retrieve a catalog" do
+      Puppet[:usecacheonfailure] = false
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
-      expect(@agent.retrieve_catalog({})).to be_nil
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
     end
 
-    it "should convert the catalog before returning" do
-      Puppet::Resource::Catalog.indirection.stubs(:find).returns @catalog
+    it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
+      expects_neither_new_or_cached_catalog
 
-      @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
-      expect(@agent.retrieve_catalog({})).to eq("converted catalog")
+      expect(@agent.retrieve_catalog({})).to be_nil
     end
 
-    it "should return nil if there is an error while retrieving the catalog" do
-      Puppet::Resource::Catalog.indirection.expects(:find).at_least_once.raises "eh"
+    it "should return nil if its cached catalog environment doesn't match server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.instance_variable_set(:@node_environment, 'production')
 
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      Puppet.expects(:err).with("Not using cached catalog because its environment 'second_env' does not match 'production'")
       expect(@agent.retrieve_catalog({})).to be_nil
     end
+
+    it "should set its cached_catalog_status to 'not_used' if the cached catalog environment doesn't match server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.instance_variable_set(:@node_environment, 'production')
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
+    it "should return its cached catalog if the environment matches the server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
+      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+    end
+
+    it "should set its cached_catalog_status to 'on_failure' if the cached catalog environment matches server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
+      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
   end
 
   describe "when converting the catalog" do
     before do
       Puppet.settings.stubs(:use).returns(true)
 
-      @catalog = Puppet::Resource::Catalog.new
-      @oldcatalog = stub 'old_catalog', :to_ral => @catalog
+      catalog.stubs(:to_ral).returns ral_catalog
     end
 
-    it "should convert the catalog to a RAL-formed catalog" do
-      @oldcatalog.expects(:to_ral).returns @catalog
+    let (:catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
+    let (:ral_catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
 
-      expect(@agent.convert_catalog(@oldcatalog, 10)).to equal(@catalog)
+    it "should convert the catalog to a RAL-formed catalog" do
+      expect(@agent.convert_catalog(catalog, 10)).to equal(ral_catalog)
     end
 
     it "should finalize the catalog" do
-      @catalog.expects(:finalize)
+      ral_catalog.expects(:finalize)
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should record the passed retrieval time with the RAL catalog" do
-      @catalog.expects(:retrieval_duration=).with 10
+      ral_catalog.expects(:retrieval_duration=).with 10
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's class file" do
-      @catalog.expects(:write_class_file)
+      ral_catalog.expects(:write_class_file)
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's resource file" do
-      @catalog.expects(:write_resource_file)
+      ral_catalog.expects(:write_resource_file)
+
+      @agent.convert_catalog(catalog, 10)
+    end
+  end
+
+  describe "when determining whether to pluginsync" do
+    it "should default to Puppet[:pluginsync] when explicitly set by the commandline" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_cli?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should default to Puppet[:pluginsync] when explicitly set by config" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_config?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should be true if use_cached_catalog is false" do
+      Puppet.settings[:use_cached_catalog] = false
+
+      expect(described_class).to be_should_pluginsync
+    end
+
+    it "should be false if use_cached_catalog is true" do
+      Puppet.settings[:use_cached_catalog] = true
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      expect(described_class).not_to be_should_pluginsync
     end
   end
 end

data/spec/unit/context/trusted_information_spec.rb

@@ -47,6 +47,8 @@ describe Puppet::Context::TrustedInformation do
         '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
         '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
       })
+      expect(trusted.hostname).to eq('cert name')
+      expect(trusted.domain).to be_nil
     end
 
     it "is remote but lacks certificate information when it is authenticated" do
@@ -69,6 +71,8 @@ describe Puppet::Context::TrustedInformation do
       expect(trusted.authenticated).to eq('local')
       expect(trusted.certname).to eq('cert name')
       expect(trusted.extensions).to eq({})
+      expect(trusted.hostname).to eq('cert name')
+      expect(trusted.domain).to be_nil
     end
 
     it "is authenticated local with no clientcert when there is no node" do
@@ -77,6 +81,8 @@ describe Puppet::Context::TrustedInformation do
       expect(trusted.authenticated).to eq('local')
       expect(trusted.certname).to be_nil
       expect(trusted.extensions).to eq({})
+      expect(trusted.hostname).to be_nil
+      expect(trusted.domain).to be_nil
     end
   end
 
@@ -89,7 +95,24 @@ describe Puppet::Context::TrustedInformation do
       'extensions' => {
         '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
         '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
-      }
+      },
+      'hostname' => 'cert name',
+      'domain' => nil
+    })
+  end
+
+  it "extracts domain and hostname from certname" do
+    trusted = Puppet::Context::TrustedInformation.remote(true, 'hostname.domain.long', cert)
+
+    expect(trusted.to_h).to eq({
+      'authenticated' => 'remote',
+      'certname' => 'hostname.domain.long',
+      'extensions' => {
+        '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
+        '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
+      },
+      'hostname' => 'hostname',
+      'domain' => 'domain.long'
     })
   end
 

data/spec/unit/daemon_spec.rb

@@ -45,15 +45,24 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
   end
 
   describe "when setting signal traps" do
-    signals = {:INT => :stop, :TERM => :stop }
-    signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}) unless Puppet.features.microsoft_windows?
-    signals.each do |signal, method|
-      it "should log and call #{method} when it receives #{signal}" do
-        Signal.expects(:trap).with(signal).yields
+    [:INT, :TERM].each do |signal|
+      it "logs a notice and exits when sent #{signal}" do
+        Signal.stubs(:trap).with(signal).yields
+        Puppet.expects(:notice).with("Caught #{signal}; exiting")
+        daemon.expects(:stop)
 
-        Puppet.expects(:notice)
+        daemon.set_signal_traps
+      end
+    end
+
+    {:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
+      it "logs a notice and remembers to call #{method} when it receives #{signal}" do
+        Signal.stubs(:trap).with(signal).yields
+        Puppet.expects(:notice).with("Caught #{signal}; storing #{method}")
 
         daemon.set_signal_traps
+
+        expect(daemon.signals).to eq([method])
       end
     end
   end
@@ -176,7 +185,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should do nothing if the agent is running" do
-      agent.expects(:running?).returns true
+      agent.expects(:run).with({:splay => false}).raises Puppet::LockError, 'Failed to aquire lock'
+      Puppet.expects(:notice).with('Not triggering already-running agent')
 
       daemon.agent = agent
 
@@ -184,8 +194,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should run the agent if one is available and it is not running" do
-      agent.expects(:running?).returns false
       agent.expects(:run).with({:splay => false})
+      Puppet.expects(:notice).with('Not triggering already-running agent').never
 
       daemon.agent = agent
 

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -38,15 +38,42 @@ describe "when using function data provider" do
   # The result should be that the data set in the environment wins over those set in the
   # module.
   #
-  it 'it gets data from module and environment functions and combines them with env having higher precedence' do
+  it 'gets data from module and environment functions and combines them with env having higher precedence' do
     Puppet[:code] = 'include abc'
     node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
     compiler = Puppet::Parser::Compiler.new(node)
     catalog = compiler.compile()
+    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]", "Notify[env_test2-ipl]"]
+    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+  end
+
+  it 'gets data from module having a puppet function delivering module data' do
+    Puppet[:code] = 'include xyz'
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
+    compiler = Puppet::Parser::Compiler.new(node)
+    catalog = compiler.compile()
     resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]"]
     expect(resources_in(catalog)).to include(*resources_created_in_fixture)
   end
 
+  it 'gets data from puppet function delivering environment data' do
+    Puppet[:code] = <<-CODE
+      function environment::data() {
+        { 'cls::test1' => 'env_puppet1',
+          'cls::test2' => 'env_puppet2'
+        }
+      }
+      class cls ($test1, $test2) {
+        notify { $test1: }
+        notify { $test2: }
+      }
+      include cls
+    CODE
+    node = Puppet::Node.new('testnode', :facts => Puppet::Node::Facts.new('facts', {}), :environment => 'production')
+    catalog = Puppet::Parser::Compiler.new(node).compile
+    expect(resources_in(catalog)).to include('Notify[env_puppet1]', 'Notify[env_puppet2]')
+  end
+
   it 'raises an error if the environment data function does not return a hash' do
     Puppet[:code] = 'include abc'
     # find the loaders to patch with faulty function