puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/context/trusted_information_spec.rb

@@ -1,213 +0,0 @@
-require 'spec_helper'
-require 'puppet/certificate_factory'
-
-require 'puppet/context/trusted_information'
-
-describe Puppet::Context::TrustedInformation, :unless => RUBY_PLATFORM == 'java' do
-  let(:key) { OpenSSL::PKey::RSA.new(Puppet[:keylength]) }
-
-  let(:csr) do
-    csr = Puppet::SSL::CertificateRequest.new("csr")
-    csr.generate(key, :extension_requests => {
-      '1.3.6.1.4.1.15.1.2.1' => 'Ignored CSR extension',
-
-      '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',
-    })
-    csr
-  end
-
-  let(:cert) do
-    cert = Puppet::SSL::Certificate.from_instance(Puppet::CertificateFactory.build('ca', csr, csr.content, 1))
-
-    # The cert must be signed so that it can be successfully be DER-decoded later
-    signer = Puppet::SSL::CertificateSigner.new
-    signer.sign(cert.content, key)
-    cert
-  end
-
-  let(:external_data) {
-    {
-      'string' => 'a',
-      'integer' => 1,
-      'boolean' => true,
-      'hash' => { 'one' => 'two' },
-      'array' => ['b', 2, {}]
-    }
-  }
-
-  def allow_external_trusted_data(certname, data)
-    command = 'generate_data.sh'
-    Puppet[:trusted_external_command] = command
-    # The expand_path bit is necessary b/c :trusted_external_command is a
-    # file_or_directory setting, and file_or_directory settings automatically
-    # expand the given path.
-    allow(Puppet::Util::Execution).to receive(:execute).with([File.expand_path(command), certname], anything).and_return(JSON.dump(data))
-  end
-
-  it "defaults external to an empty hash" do
-    trusted = Puppet::Context::TrustedInformation.new(false, 'ignored', nil)
-
-    expect(trusted.external).to eq({})
-  end
-
-  context "when remote" do
-    it "has no cert information when it isn't authenticated" do
-      trusted = Puppet::Context::TrustedInformation.remote(false, 'ignored', nil)
-
-      expect(trusted.authenticated).to eq(false)
-      expect(trusted.certname).to be_nil
-      expect(trusted.extensions).to eq({})
-    end
-
-    it "is remote and has certificate information when it is authenticated" do
-      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
-
-      expect(trusted.authenticated).to eq('remote')
-      expect(trusted.certname).to eq('cert name')
-      expect(trusted.extensions).to eq({
-        '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
-      expect(Puppet).to receive(:info).once.with("TrustedInformation expected a certificate, but none was given.")
-
-      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', nil)
-
-      expect(trusted.authenticated).to eq('remote')
-      expect(trusted.certname).to eq('cert name')
-      expect(trusted.extensions).to eq({})
-    end
-
-    it 'contains external trusted data' do
-      allow_external_trusted_data('cert name', external_data)
-
-      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', nil)
-
-      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
-      command = 'generate_data.sh'
-      Puppet[:trusted_external_command] = command
-
-      # See allow_external_trusted_data to understand why expand_path is necessary
-      expect(Puppet::Util::Execution).to receive(:execute).with([File.expand_path(command), '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
-    it "is authenticated local with the nodes clientcert" do
-      node = Puppet::Node.new('testing', :parameters => { 'clientcert' => 'cert name' })
-
-      trusted = Puppet::Context::TrustedInformation.local(node)
-
-      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
-      trusted = Puppet::Context::TrustedInformation.local(nil)
-
-      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
-
-    it 'contains external trusted data' do
-      allow_external_trusted_data('cert name', external_data)
-
-      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', nil)
-
-      expect(trusted.external).to eq(external_data)
-    end
-  end
-
-  it "converts itself to a hash" do
-    trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
-
-    expect(trusted.to_h).to eq({
-      'authenticated' => 'remote',
-      'certname' => 'cert name',
-      '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,
-      'external' => {},
-    })
-  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',
-      'external' => {},
-    })
-  end
-
-  it "freezes the hash" do
-    trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
-
-    expect(trusted.to_h).to be_deeply_frozen
-  end
-
-  matcher :be_deeply_frozen do
-    match do |actual|
-      unfrozen_items(actual).empty?
-    end
-
-    failure_message do |actual|
-      "expected all items to be frozen but <#{unfrozen_items(actual).join(', ')}> was not"
-    end
-
-    define_method :unfrozen_items do |actual|
-      unfrozen = []
-      stack = [actual]
-      while item = stack.pop
-        if !item.frozen?
-          unfrozen.push(item)
-        end
-
-        case item
-        when Hash
-          stack.concat(item.keys)
-          stack.concat(item.values)
-        when Array
-          stack.concat(item)
-        end
-      end
-
-      unfrozen
-    end
-  end
-end

data/spec/unit/context_spec.rb

@@ -1,217 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Context do
-  let(:context) { Puppet::Context.new({ :testing => "value" }) }
-
-  describe "with additional context" do
-    before :each do
-      context.push("a" => 1)
-    end
-
-    it "allows rebinding values in a nested context" do
-      inner = nil
-      context.override("a" => 2) do
-        inner = context.lookup("a")
-      end
-
-      expect(inner).to eq(2)
-    end
-
-    it "outer bindings are available in an overridden context" do
-      inner_a = nil
-      inner_b = nil
-      context.override("b" => 2) do
-        inner_a = context.lookup("a")
-        inner_b = context.lookup("b")
-      end
-
-      expect(inner_a).to eq(1)
-      expect(inner_b).to eq(2)
-    end
-
-    it "overridden bindings do not exist outside of the override" do
-      context.override("a" => 2) do
-      end
-
-      expect(context.lookup("a")).to eq(1)
-    end
-
-    it "overridden bindings do not exist outside of the override even when leaving via an error" do
-      begin
-        context.override("a" => 2) do
-          raise "this should still cause the bindings to leave"
-        end
-      rescue
-      end
-
-      expect(context.lookup("a")).to eq(1)
-    end
-  end
-
-  context "a rollback" do
-    it "returns to the mark" do
-      context.push("a" => 1)
-      context.mark("start")
-      context.push("a" => 2)
-      context.push("a" => 3)
-      context.pop
-
-      context.rollback("start")
-
-      expect(context.lookup("a")).to eq(1)
-    end
-
-    it "rolls back to the mark across a scoped override" do
-      context.push("a" => 1)
-      context.mark("start")
-      context.override("a" => 3) do
-
-        context.rollback("start")
-
-        expect(context.lookup("a")).to eq(1)
-      end
-      expect(context.lookup("a")).to eq(1)
-    end
-
-    it "fails to rollback to an unknown mark" do
-      expect do
-        context.rollback("unknown")
-      end.to raise_error(Puppet::Context::UnknownRollbackMarkError)
-    end
-
-    it "does not allow the same mark to be set twice" do
-      context.mark("duplicate")
-      expect do
-        context.mark("duplicate")
-      end.to raise_error(Puppet::Context::DuplicateRollbackMarkError)
-    end
-  end
-
-  context "with multiple threads" do
-    it "a value pushed in another thread is not seen in the original thread" do
-      context.push(a: 1)
-      t = Thread.new do
-        context.push(a: 2, b: 5)
-      end
-      t.join
-
-      expect(context.lookup(:a)).to eq(1)
-      expect{ context.lookup(:b) }.to raise_error(Puppet::Context::UndefinedBindingError)
-    end
-
-    it "pops on a different thread do not interfere" do
-      context.push(a: 1)
-      t = Thread.new do
-        context.pop
-      end
-      t.join
-
-      # Raises exception if the binding we pushed has already been popped
-      context.pop
-    end
-
-    it "a mark in one thread is not seen in another thread" do
-      t = Thread.new do
-        context.push(b: 2)
-        context.mark('point b')
-      end
-      t.join
-
-      expect { context.rollback('point b') }.to raise_error(Puppet::Context::UnknownRollbackMarkError)
-    end
-  end
-end
-
-
-describe Puppet::Context::EmptyStack do
-  let(:empty_stack) { Puppet::Context::EmptyStack.new }
-
-  it "raises undefined binding on lookup" do
-    expect { empty_stack.lookup("a") }.to raise_error(Puppet::Context::UndefinedBindingError)
-  end
-
-  it "calls a provided block for a default value when none is found" do
-    expect(empty_stack.lookup("a") { "default" }).to eq("default")
-  end
-
-  it "raises an error when trying to pop" do
-    expect { empty_stack.pop }.to raise_error(Puppet::Context::StackUnderflow)
-  end
-
-  it "returns a stack when something is pushed" do
-    stack = empty_stack.push(a: 1)
-    expect(stack).to be_a(Puppet::Context::Stack)
-  end
-
-  it "returns a new stack with no bindings when pushed nil" do
-    stack = empty_stack.push(nil)
-    expect(stack).not_to be(empty_stack)
-    expect(stack.pop).to be(empty_stack)
-  end
-end
-
-describe Puppet::Context::Stack do
-  let(:empty_stack) { Puppet::Context::EmptyStack.new }
-
-  context "a stack with depth of 1" do
-    let(:stack) { empty_stack.push(a: 1) }
-
-    it "returns the empty stack when popped" do
-      expect(stack.pop).to be(empty_stack)
-    end
-
-    it "calls a provided block for a default value when none is found" do
-      expect(stack.lookup("a") { "default" }).to eq("default")
-    end
-
-    it "returns a new but equivalent stack when pushed nil" do
-      stackier = stack.push(nil)
-      expect(stackier).not_to be(stack)
-      expect(stackier.pop).to be(stack)
-      expect(stackier.bindings).to eq(stack.bindings)
-    end
-  end
-
-  context "a stack with more than 1 element" do
-    let(:level_one) { empty_stack.push(a: 1, c: 4) }
-    let(:level_two) { level_one.push(b: 2, c: 3) }
-
-    it "falls back to lower levels on lookup" do
-      expect(level_two.lookup(:c)).to eq(3)
-      expect(level_two.lookup(:a)).to eq(1)
-      expect{ level_two.lookup(:d) }.to raise_error(Puppet::Context::UndefinedBindingError)
-    end
-
-    it "the parent is immutable" do
-      expect(level_one.lookup(:c)).to eq(4)
-      expect{ level_one.lookup(:b) }.to raise_error(Puppet::Context::UndefinedBindingError)
-    end
-  end
-
-  context 'supports lazy entries' do
-    it 'by evaluating a bound proc' do
-      stack = empty_stack.push(a: lambda { || 'yay' })
-      expect(stack.lookup(:a)).to eq('yay')
-    end
-
-    it 'by memoizing the bound value' do
-      original = 'yay'
-      stack = empty_stack.push(:a => lambda {|| tmp = original; original = 'no'; tmp})
-      expect(stack.lookup(:a)).to eq('yay')
-      expect(original).to eq('no')
-      expect(stack.lookup(:a)).to eq('yay')
-    end
-
-    it 'the bound value is memoized only at the top level of the stack' do
-      # I'm just characterizing the current behavior here
-
-      original = 'yay'
-      stack = empty_stack.push(:a => lambda {|| tmp = original; original = 'no'; tmp})
-      stack_two = stack.push({})
-      expect(stack.lookup(:a)).to eq('yay')
-      expect(original).to eq('no')
-      expect(stack.lookup(:a)).to eq('yay')
-      expect(stack_two.lookup(:a)).to eq('no')
-    end
-  end
-end

data/spec/unit/daemon_spec.rb

@@ -1,193 +0,0 @@
-require 'spec_helper'
-require 'puppet/daemon'
-require 'puppet/agent'
-require 'puppet/configurer'
-
-def without_warnings
-  flag = $VERBOSE
-  $VERBOSE = nil
-  yield
-  $VERBOSE = flag
-end
-
-describe Puppet::Daemon, :unless => Puppet::Util::Platform.windows? do
-  include PuppetSpec::Files
-
-  class RecordingScheduler
-    attr_reader :jobs
-
-    def run_loop(jobs)
-      @jobs = jobs
-    end
-  end
-
-  let(:agent) { Puppet::Agent.new(Puppet::Configurer, false) }
-  let(:server) { double("Server", :start => nil, :wait_for_shutdown => nil) }
-
-  let(:pidfile) { double("PidFile", :lock => true, :unlock => true, :file_path => 'fake.pid') }
-  let(:scheduler) { RecordingScheduler.new }
-
-  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
-  end
-
-  describe "when setting signal traps" do
-    [:INT, :TERM].each do |signal|
-      it "logs a notice and exits when sent #{signal}" do
-        allow(Signal).to receive(:trap).with(signal).and_yield
-        expect(Puppet).to receive(:notice).with("Caught #{signal}; exiting")
-        expect(daemon).to receive(:stop)
-
-        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
-        allow(Signal).to receive(:trap).with(signal).and_yield
-        expect(Puppet).to receive(:notice).with("Caught #{signal}; storing #{method}")
-
-        daemon.set_signal_traps
-
-        expect(daemon.signals).to eq([method])
-      end
-    end
-  end
-
-  describe "when starting" do
-    before do
-      allow(daemon).to receive(:set_signal_traps)
-    end
-
-    it "should create its pidfile" do
-      expect(pidfile).to receive(:lock).and_return(true)
-      daemon.start
-    end
-
-    it "should fail if it cannot lock" do
-      expect(pidfile).to receive(:lock).and_return(false)
-      expect { daemon.start }.to raise_error(RuntimeError, "Could not create PID file: #{pidfile.file_path}")
-    end
-
-    it "disables the reparse of configs if the filetimeout is 0" do
-      Puppet[:filetimeout] = 0
-      daemon.start
-      expect(scheduler.jobs[0]).not_to be_enabled
-    end
-  end
-
-  describe "when stopping" do
-    before do
-      allow(Puppet::Util::Log).to receive(:close_all)
-      # to make the global safe to mock, set it to a subclass of itself,
-      # then restore it in an after pass
-      without_warnings { Puppet::Application = Class.new(Puppet::Application) }
-    end
-
-    after do
-      # restore from the superclass so we lose the stub garbage
-      without_warnings { Puppet::Application = Puppet::Application.superclass }
-    end
-
-    it 'should request a stop from Puppet::Application' do
-      expect(Puppet::Application).to receive(:stop!)
-      expect { daemon.stop }.to exit_with 0
-    end
-
-    it "should remove its pidfile" do
-      expect(pidfile).to receive(:unlock)
-      expect { daemon.stop }.to exit_with 0
-    end
-
-    it "should close all logs" do
-      expect(Puppet::Util::Log).to receive(:close_all)
-      expect { daemon.stop }.to exit_with 0
-    end
-
-    it "should exit unless called with ':exit => false'" do
-      expect { daemon.stop }.to exit_with 0
-    end
-
-    it "should not exit if called with ':exit => false'" do
-      daemon.stop :exit => false
-    end
-  end
-
-  describe "when reloading" do
-    it "should do nothing if the agent is running" 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.reload
-    end
-
-    it "should run the agent if one is available and it is not running" do
-      expect(agent).to receive(:run).with({:splay => false})
-      expect(Puppet).not_to receive(:notice).with('Not triggering already-running agent')
-
-      daemon.reload
-    end
-  end
-
-  describe "when restarting" do
-    before do
-      without_warnings { Puppet::Application = Class.new(Puppet::Application) }
-    end
-
-    after do
-      without_warnings { Puppet::Application = Puppet::Application.superclass }
-    end
-
-    it 'should set Puppet::Application.restart!' do
-      expect(Puppet::Application).to receive(:restart!)
-      allow(daemon).to receive(:reexec)
-      daemon.restart
-    end
-
-    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(daemon).to receive(:reexec)
-      daemon.restart
-    end
-  end
-
-  describe "when reexecing it self" do
-    before do
-      allow(daemon).to receive(:exec)
-      allow(daemon).to receive(:stop)
-    end
-
-    it "should fail if no argv values are available" do
-      expect(daemon).to receive(:argv).and_return(nil)
-      expect { daemon.reexec }.to raise_error(Puppet::DevError)
-    end
-
-    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
-end

data/spec/unit/data_binding_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-require 'puppet/data_binding'
-
-describe Puppet::DataBinding do
-  describe "when indirecting" do
-    it "should default to the 'hiera' data_binding terminus" do
-      Puppet::DataBinding.indirection.reset_terminus_class
-      expect(Puppet::DataBinding.indirection.terminus_class).to eq(:hiera)
-    end
-  end
-end