puppet 6.11.1-x86-mingw32 → 6.16.0-x86-mingw32

data/spec/unit/context/trusted_information_spec.rb

@@ -90,6 +90,23 @@ describe Puppet::Context::TrustedInformation, :unless => RUBY_PLATFORM == 'java'
 
       expect(trusted.external).to eq(external_data)
     end
+
+    it 'does not run the trusted external command when creating a trusted context' do
+      Puppet[:trusted_external_command] = '/usr/bin/generate_data.sh'
+
+      expect(Puppet::Util::Execution).to receive(:execute).never
+      Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
+    end
+
+    it 'only runs the trusted external command the first time it is invoked' do
+      Puppet[:trusted_external_command] = '/usr/bin/generate_data.sh'
+
+      expect(Puppet::Util::Execution).to receive(:execute).with(['/usr/bin/generate_data.sh', 'cert name'], anything).and_return(JSON.dump(external_data)).once
+
+      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
+      trusted.external
+      trusted.external
+    end
   end
 
   context "when local" do

data/spec/unit/daemon_spec.rb

@@ -32,13 +32,17 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
   let(:pidfile) { double("PidFile", :lock => true, :unlock => true, :file_path => 'fake.pid') }
   let(:scheduler) { RecordingScheduler.new }
 
-  let(:daemon) { Puppet::Daemon.new(pidfile, scheduler) }
+  let(:daemon) { Puppet::Daemon.new(agent, pidfile, scheduler) }
 
   before(:each) do
     allow(Signal).to receive(:trap)
     allow(daemon).to receive(:close_streams).and_return(nil)
   end
 
+  it "should fail when no agent is provided" do
+    expect { Puppet::Daemon.new(nil, pidfile, scheduler) }.to raise_error(Puppet::DevError)
+  end
+
   it "should reopen the Log logs when told to reopen logs" do
     expect(Puppet::Util::Log).to receive(:reopen)
     daemon.reopen_logs
@@ -72,65 +76,21 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       allow(daemon).to receive(:set_signal_traps)
     end
 
-    it "should fail if it has neither agent nor server" do
-      expect { daemon.start }.to raise_error(Puppet::DevError)
-    end
-
     it "should create its pidfile" do
       expect(pidfile).to receive(:lock).and_return(true)
-
-      daemon.agent = agent
       daemon.start
     end
 
     it "should fail if it cannot lock" do
       expect(pidfile).to receive(:lock).and_return(false)
-      daemon.agent = agent
-
       expect { daemon.start }.to raise_error(RuntimeError, "Could not create PID file: #{pidfile.file_path}")
     end
 
-    it "should start its server if one is configured" do
-      daemon.server = server
-
-      expect(server).to receive(:start)
-
-      daemon.start
-    end
-
     it "disables the reparse of configs if the filetimeout is 0" do
       Puppet[:filetimeout] = 0
-      daemon.agent = agent
-
       daemon.start
-
       expect(scheduler.jobs[0]).not_to be_enabled
     end
-
-    it "disables the agent run when there is no agent" do
-      Puppet[:filetimeout] = 0
-      daemon.server = server
-
-      daemon.start
-
-      expect(scheduler.jobs[1]).not_to be_enabled
-    end
-
-    it "waits for the server to shutdown when there is one" do
-      daemon.server = server
-
-      expect(server).to receive(:wait_for_shutdown)
-
-      daemon.start
-    end
-
-    it "waits for the server to shutdown when there is one" do
-      daemon.server = server
-
-      expect(server).to receive(:wait_for_shutdown)
-
-      daemon.start
-    end
   end
 
   describe "when stopping" do
@@ -146,14 +106,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       without_warnings { Puppet::Application = Puppet::Application.superclass }
     end
 
-    it "should stop its server if one is configured" do
-      expect(server).to receive(:stop)
-
-      daemon.server = server
-
-      expect { daemon.stop }.to exit_with 0
-    end
-
     it 'should request a stop from Puppet::Application' do
       expect(Puppet::Application).to receive(:stop!)
       expect { daemon.stop }.to exit_with 0
@@ -161,7 +113,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
 
     it "should remove its pidfile" do
       expect(pidfile).to receive(:unlock)
-
       expect { daemon.stop }.to exit_with 0
     end
 
@@ -188,8 +139,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       expect(agent).to receive(:run).with({:splay => false}).and_raise(Puppet::LockError, 'Failed to aquire lock')
       expect(Puppet).to receive(:notice).with('Not triggering already-running agent')
 
-      daemon.agent = agent
-
       daemon.reload
     end
 
@@ -197,8 +146,6 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
       expect(agent).to receive(:run).with({:splay => false})
       expect(Puppet).not_to receive(:notice).with('Not triggering already-running agent')
 
-      daemon.agent = agent
-
       daemon.reload
     end
   end
@@ -220,15 +167,11 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
 
     it "should reexec itself if no agent is available" do
       expect(daemon).to receive(:reexec)
-
       daemon.restart
     end
 
     it "should reexec itself if the agent is not running" do
-      expect(agent).to receive(:running?).and_return(false)
-      daemon.agent = agent
       expect(daemon).to receive(:reexec)
-
       daemon.restart
     end
   end
@@ -247,14 +190,12 @@ describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
     it "should shut down without exiting" do
       daemon.argv = %w{foo}
       expect(daemon).to receive(:stop).with(:exit => false)
-
       daemon.reexec
     end
 
     it "should call 'exec' with the original executable and arguments" do
       daemon.argv = %w{foo}
       expect(daemon).to receive(:exec).with($0 + " foo")
-
       daemon.reexec
     end
   end

data/spec/unit/defaults_spec.rb

@@ -139,7 +139,7 @@ describe "Defaults" do
       let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
 
       it 'includes user and system modules' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(installdir)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
 
         expect(
           Puppet.default_basemodulepath
@@ -147,7 +147,7 @@ describe "Defaults" do
       end
 
       it 'includes user modules if installdir fact is missing' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(nil)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
 
         expect(
           Puppet.default_basemodulepath
@@ -167,7 +167,7 @@ describe "Defaults" do
       let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
 
       it 'includes the default vendormoduledir' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(installdir)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
 
         expect(
           Puppet.default_vendormoduledir
@@ -175,10 +175,44 @@ describe "Defaults" do
       end
 
       it 'is nil if installdir fact is missing' do
-        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(nil)
+        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
 
         expect(Puppet.default_vendormoduledir).to be_nil
       end
     end
   end
+
+  describe "facterng" do
+    it "defaults to false" do
+      expect(Puppet[:facterng]).to be_falsey
+    end
+
+    it "raises an exception if facter-ng could not be loaded" do
+      allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_raise(LoadError)
+
+      expect{ Puppet.settings[:facterng] = true }.to raise_exception ArgumentError, 'facter-ng could not be loaded'
+    end
+
+    context 'set logger' do
+      before do
+        @original_facter = Object.const_get(:Facter)
+
+        Object.send(:remove_const, :Facter)
+        Object.const_set(:Facter, Module.new)
+
+        allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_return(true)
+        allow(Facter).to receive(:respond_to?).and_return(false)
+      end
+
+      after do
+        Object.const_set(:Facter, @original_facter)
+      end
+
+      it 'calls setup_facter_logging!' do
+        allow(Puppet::Util::Logging).to receive(:setup_facter_logging!).and_return(true)
+        Puppet.settings[:facterng] = true
+        expect(Puppet::Util::Logging).to have_received(:setup_facter_logging!).once
+      end
+    end
+  end
 end

data/spec/unit/environments_spec.rb

@@ -13,20 +13,29 @@ describe Puppet::Environments do
   before(:each) do
     Puppet.settings.initialize_global_settings
     Puppet[:environment_timeout] = "unlimited"
+    Puppet[:versioned_environment_dirs] = true
   end
 
   let(:directory_tree) do
-    FS::MemoryFile.a_directory(File.expand_path("envdir"), [
-      FS::MemoryFile.a_regular_file_containing("ignored_file", ''),
-      FS::MemoryFile.a_directory("an_environment", [
-        FS::MemoryFile.a_missing_file("environment.conf"),
+    FS::MemoryFile.a_directory(File.expand_path("top_level_dir"), [
+      FS::MemoryFile.a_directory("envdir", [
+        FS::MemoryFile.a_regular_file_containing("ignored_file", ''),
+        FS::MemoryFile.a_directory("an_environment", [
+          FS::MemoryFile.a_missing_file("environment.conf"),
+          FS::MemoryFile.a_directory("modules"),
+          FS::MemoryFile.a_directory("manifests"),
+        ]),
+        FS::MemoryFile.a_directory("another_environment", [
+          FS::MemoryFile.a_missing_file("environment.conf"),
+        ]),
+        FS::MemoryFile.a_missing_file("doesnotexist"),
+        FS::MemoryFile.a_symlink("symlinked_environment", File.expand_path(File.join("top_level_dir", "versioned_env")))]),
+      FS::MemoryFile.a_directory("versioned_env", [
+        FS::MemoryFile.a_regular_file_containing("environment.conf", ''),
         FS::MemoryFile.a_directory("modules"),
         FS::MemoryFile.a_directory("manifests"),
       ]),
-      FS::MemoryFile.a_directory("another_environment", [
-        FS::MemoryFile.a_missing_file("environment.conf"),
-      ]),
-      FS::MemoryFile.a_missing_file("doesnotexist"),
+      FS::MemoryFile.a_missing_file("missing")
     ])
   end
 
@@ -38,22 +47,27 @@ describe Puppet::Environments do
       global_path_2 = FS::MemoryFile.a_directory(global_path_2_location)
 
       loader_from(:filesystem => [directory_tree, global_path_1, global_path_2],
-                  :directory => directory_tree,
+                  :directory => directory_tree.children.first,
                   :modulepath => [global_path_1_location, global_path_2_location]) do |loader|
         expect(loader.list).to include_in_any_order(
           environment(:an_environment).
-            with_manifest("#{FS.path_string(directory_tree)}/an_environment/manifests").
-            with_modulepath(["#{FS.path_string(directory_tree)}/an_environment/modules",
+            with_manifest("#{FS.path_string(directory_tree)}/envdir/an_environment/manifests").
+            with_modulepath(["#{FS.path_string(directory_tree)}/envdir/an_environment/modules",
                              global_path_1_location,
                              global_path_2_location]),
-          environment(:another_environment))
+          environment(:another_environment),
+          environment(:symlinked_environment).
+            with_manifest("#{FS.path_string(directory_tree)}/versioned_env/manifests").
+            with_modulepath(["#{FS.path_string(directory_tree)}/versioned_env/modules",
+                             global_path_1_location,
+                             global_path_2_location]))
       end
     end
 
     it "has search_paths" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
-        expect(loader.search_paths).to eq(["file://#{directory_tree}"])
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.search_paths).to eq(["file://#{directory_tree.children.first}"])
       end
     end
 
@@ -77,16 +91,38 @@ describe Puppet::Environments do
       end
     end
 
+    it "proceeds with non-existant env dir" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.last) do |loader|
+        expect(loader.list).to eq([])
+      end
+    end
+
     it "gets a particular environment" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
+                  :directory => directory_tree.children.first) do |loader|
         expect(loader.get("an_environment")).to environment(:an_environment)
       end
     end
 
+    it "gets a symlinked environment" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.get("symlinked_environment")).to environment(:symlinked_environment)
+      end
+    end
+
+    it "ignores symlinked environments when `:versioned_environment_dirs` is false" do
+      Puppet[:versioned_environment_dirs] = false
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.get("symlinked_environment")).to be_nil
+      end
+    end
+
     it "raises error when environment not found" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
+                  :directory => directory_tree.children.first) do |loader|
         expect do
           loader.get!("doesnotexist")
         end.to raise_error(Puppet::Environments::EnvironmentNotFound)
@@ -95,7 +131,7 @@ describe Puppet::Environments do
 
     it "returns nil if an environment can't be found" do
       loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
+                  :directory => directory_tree.children.first) do |loader|
         expect(loader.get("doesnotexist")).to be_nil
       end
     end
@@ -404,7 +440,7 @@ config_version=$vardir/random/scripts
       context "custom cache expiration service" do
         it "consults the custom service to expire the cache" do
           loader_from(:filesystem => [directory_tree],
-                      :directory => directory_tree) do |loader|
+                      :directory => directory_tree.children.first) do |loader|
             service = ReplayExpirationService.new([true])
             using_expiration_service(service) do
 
@@ -541,22 +577,23 @@ config_version=$vardir/random/scripts
 
   describe "cached loaders" do
     it "lists environments" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
         expect(Puppet::Environments::Cached.new(loader).list).to include_in_any_order(
           environment(:an_environment),
-          environment(:another_environment))
+          environment(:another_environment),
+          environment(:symlinked_environment))
       end
     end
 
     it "has search_paths" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
-        expect(Puppet::Environments::Cached.new(loader).search_paths).to eq(["file://#{directory_tree}"])
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+        expect(Puppet::Environments::Cached.new(loader).search_paths).to eq(["file://#{directory_tree.children.first}"])
       end
     end
 
     context "#get" do
       it "gets an environment" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect(Puppet::Environments::Cached.new(loader).get(:an_environment)).to environment(:an_environment)
         end
       end
@@ -574,7 +611,7 @@ config_version=$vardir/random/scripts
       end
 
       it "returns nil if env not found" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect(Puppet::Environments::Cached.new(loader).get(:doesnotexist)).to be_nil
         end
       end
@@ -582,7 +619,7 @@ config_version=$vardir/random/scripts
 
     context "#get!" do
       it "gets an environment" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect(Puppet::Environments::Cached.new(loader).get!(:an_environment)).to environment(:an_environment)
         end
       end
@@ -600,7 +637,7 @@ config_version=$vardir/random/scripts
       end
 
       it "raises error if environment is not found" do
-        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect do
             Puppet::Environments::Cached.new(loader).get!(:doesnotexist)
           end.to raise_error(Puppet::Environments::EnvironmentNotFound)
@@ -609,9 +646,9 @@ config_version=$vardir/random/scripts
     end
 
     it "gets an environment.conf" do
-      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
         expect(Puppet::Environments::Cached.new(loader).get_conf(:an_environment)).to match_environment_conf(:an_environment).
-          with_env_path(directory_tree).
+          with_env_path(directory_tree.children.first).
           with_global_module_path([])
       end
     end

data/spec/unit/face/facts_spec.rb

@@ -12,9 +12,12 @@ describe Puppet::Face[:facts, '0.0.1'] do
     let(:model) { Puppet::Node::Facts }
     let(:test_data) { model.new('puppet.node.test', {test_fact: 'test value'}) }
     let(:facter_terminus) { model.indirection.terminus(:facter) }
-    let(:rest_terminus) { model.indirection.terminus(:rest) }
 
     before(:each) do
+      Puppet[:facts_terminus] = :memory
+      Puppet::Node::Facts.indirection.save(test_data)
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=).with(:facter)
+
       Puppet.settings.parse_config(<<-CONF)
 [main]
 server=puppet.server.invalid
@@ -26,45 +29,46 @@ CONF
 
       # Faces start in :user run mode
       Puppet.settings.preferred_run_mode = :user
-
-      allow(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
-      allow(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
-    end
-
-    it { is_expected.to be_action :upload }
-
-    it "finds facts from terminus_class :facter" do
-      expect(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
-
-      subject.upload
     end
 
-    it "saves facts to terminus_class :rest" do
-      expect(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
+    it "uploads facts as application/json" do
+      stub_request(:put, 'https://puppet.server.test:8140/puppet/v3/facts/puppet.node.test?environment=*root*')
+        .with(
+          headers: { 'Content-Type' => 'application/json' },
+          body: hash_including(
+            {
+              "name" => "puppet.node.test",
+              "values" => {
+                "test_fact" => "test value"
+              }
+            }
+          )
+        )
 
       subject.upload
     end
 
     it "passes the current environment" do
-      env = Puppet::Node::Environment.remote('qa')
-      expect(model.indirection).to receive(:save).with(anything, nil, :environment => env)
+      stub_request(:put, 'https://puppet.server.test:8140/puppet/v3/facts/puppet.node.test?environment=qa')
 
-      Puppet.override(:current_environment => env) do
+      Puppet.override(:current_environment => Puppet::Node::Environment.remote('qa')) do
         subject.upload
       end
     end
 
-    it "uses settings from the agent section of puppet.conf" do
-      expect(facter_terminus).to receive(:find).with(have_attributes(key: 'puppet.node.test')).and_return(test_data)
+    it "uses settings from the agent section of puppet.conf to resolve the node name" do
+      stub_request(:put, /puppet.node.test/)
 
       subject.upload
     end
 
     it "logs the name of the server that received the upload" do
+      stub_request(:put, 'https://puppet.server.test:8140/puppet/v3/facts/puppet.node.test?environment=*root*')
+
       subject.upload
 
       expect(@logs).to be_any {|log| log.level == :notice &&
-                               log.message =~ /Uploading facts for '.*' to: 'puppet\.server\.test'/}
+                               log.message =~ /Uploading facts for '.*' to 'puppet\.server\.test'/}
     end
   end
 end