puppet 7.28.0-x86-mingw32 → 7.29.1-x86-mingw32

data/spec/unit/util/monkey_patches_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/monkey_patches'
-
-describe Symbol do
-  after :all do
-    $unique_warnings.delete('symbol_comparison') if $unique_warnings
-  end
-
-  it 'should have an equal? that is not true for a string with same letters' do
-    symbol = :undef
-    expect(symbol).to_not equal('undef')
-  end
-
-  it "should have an eql? that is not true for a string with same letters" do
-    symbol = :undef
-    expect(symbol).to_not eql('undef')
-  end
-
-  it "should have an == that is not true for a string with same letters" do
-    symbol = :undef
-    expect(symbol == 'undef').to_not be(true)
-  end
-
-  it "should return self from #intern" do
-    symbol = :foo
-    expect(symbol).to equal symbol.intern
-  end
-end
-
-describe OpenSSL::SSL::SSLContext do
-  it 'disables SSLv2 via the SSLContext#options bitmask' do
-    expect(subject.options & OpenSSL::SSL::OP_NO_SSLv2).to eq(OpenSSL::SSL::OP_NO_SSLv2)
-  end
-
-  it 'disables SSLv3 via the SSLContext#options bitmask' do
-    expect(subject.options & OpenSSL::SSL::OP_NO_SSLv3).to eq(OpenSSL::SSL::OP_NO_SSLv3)
-  end
-
-  it 'explicitly disable SSLv2 ciphers using the ! prefix so they cannot be re-added' do
-    cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-    if cipher_str
-      expect(cipher_str.split(':')).to include('!SSLv2')
-    end
-  end
-
-  it 'does not exclude SSLv3 ciphers shared with TLSv1' do
-    cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-    if cipher_str
-      expect(cipher_str.split(':')).not_to include('!SSLv3')
-    end
-  end
-
-  it 'sets parameters on initialization' do
-    expect_any_instance_of(described_class).to receive(:set_params)
-    subject
-  end
-
-  it 'has no ciphers with version SSLv2 enabled' do
-    ciphers = subject.ciphers.select do |name, version, bits, alg_bits|
-      /SSLv2/.match(version)
-    end
-    expect(ciphers).to be_empty
-  end
-end
-
-
-describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
-  let(:store)    { described_class.new }
-  let(:cert)     { OpenSSL::X509::Certificate.new(File.read(my_fixture('x509.pem'))) }
-  let(:samecert) { cert.dup() }
-
-  def with_root_certs(certs)
-    expect(Puppet::Util::Windows::RootCerts).to receive(:instance).and_return(certs)
-  end
-
-  it "adds a root cert to the store" do
-    with_root_certs([cert])
-
-    store.set_default_paths
-  end
-
-  it "doesn't warn when calling set_default_paths multiple times" do
-    with_root_certs([cert])
-    expect(store).not_to receive(:warn)
-
-    store.set_default_paths
-    store.set_default_paths
-  end
-
-  it "ignores duplicate root certs" do
-    # prove that even though certs have identical contents, their hashes differ
-    expect(cert.hash).to_not eq(samecert.hash)
-    with_root_certs([cert, samecert])
-
-    expect(store).to receive(:add_cert).with(cert).once
-    expect(store).not_to receive(:add_cert).with(samecert)
-
-    store.set_default_paths
-  end
-
-  # openssl 1.1.1 ignores duplicate certs
-  # https://github.com/openssl/openssl/commit/c0452248ea1a59a41023a4765ef7d9825e80a62b
-  if OpenSSL::OPENSSL_VERSION_NUMBER < 0x10101000
-    it "warns when adding a certificate that already exists" do
-      with_root_certs([cert])
-      store.add_cert(cert)
-
-      expect(store).to receive(:warn).with('Failed to add CN=Microsoft Root Certificate Authority,DC=microsoft,DC=com')
-
-      store.set_default_paths
-    end
-  else
-    it "doesn't warn when adding a duplicate cert" do
-      with_root_certs([cert])
-      store.add_cert(cert)
-
-      expect(store).not_to receive(:warn)
-
-      store.set_default_paths
-    end
-  end
-
-  it "raises when adding an invalid certificate" do
-    with_root_certs(['notacert'])
-
-    expect {
-      store.set_default_paths
-    }.to raise_error(TypeError)
-  end
-end
-
-describe SecureRandom do
-  it 'generates a properly formatted uuid' do
-    expect(SecureRandom.uuid).to match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)
-  end
-end

data/spec/unit/util/multi_match_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/multi_match'
-
-describe "The Puppet::Util::MultiMatch" do
-  let(:not_nil) { Puppet::Util::MultiMatch::NOT_NIL }
-  let(:mm) { Puppet::Util::MultiMatch }
-
-  it "matches against not nil" do
-    expect(not_nil === 3).to be(true)
-  end
-
-  it "matches against multiple values" do
-    expect(mm.new(not_nil, not_nil) === [3, 3]).to be(true)
-  end
-
-  it "matches each value using ===" do
-    expect(mm.new(3, 3.14) === [Integer, Float]).to be(true)
-  end
-
-  it "matches are commutative" do
-    expect(mm.new(3, 3.14) === mm.new(Integer, Float)).to be(true)
-    expect(mm.new(Integer, Float) === mm.new(3, 3.14)).to be(true)
-  end
-
-  it "has TUPLE constant for match of array of two non nil values" do
-    expect(mm::TUPLE === [3, 3]).to be(true)
-  end
-
-  it "has TRIPLE constant for match of array of two non nil values" do
-    expect(mm::TRIPLE === [3, 3, 3]).to be(true)
-  end
-
-  it "considers length of array of values when matching" do
-    expect(mm.new(not_nil, not_nil) === [6, 6, 6]).to be(false)
-    expect(mm.new(not_nil, not_nil) === [6]).to be(false)
-  end
-
-end

data/spec/unit/util/network_device/config_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/network_device/config'
-
-describe Puppet::Util::NetworkDevice::Config do
-  include PuppetSpec::Files
-
-  before(:each) do
-    Puppet[:deviceconfig] = tmpfile('deviceconfig')
-  end
-
-  describe "when parsing device" do
-    let(:config) { Puppet::Util::NetworkDevice::Config.new }
-
-    def write_device_config(*lines)
-      File.open(Puppet[:deviceconfig], 'w') {|f| f.puts lines}
-    end
-
-    it "should skip comments" do
-      write_device_config('  # comment')
-
-      expect(config.devices).to be_empty
-    end
-
-    it "should increment line number even on commented lines" do
-      write_device_config('  # comment','[router.puppetlabs.com]')
-
-      expect(config.devices).to be_include('router.puppetlabs.com')
-    end
-
-    it "should skip blank lines" do
-      write_device_config('  ')
-
-      expect(config.devices).to be_empty
-    end
-
-    it "should produce the correct line number" do
-      write_device_config('  ', '[router.puppetlabs.com]')
-
-      expect(config.devices['router.puppetlabs.com'].line).to eq(2)
-    end
-
-    it "should throw an error if the current device already exists" do
-      write_device_config('[router.puppetlabs.com]', '[router.puppetlabs.com]')
-
-    end
-
-    it "should accept device certname containing dashes" do
-      write_device_config('[router-1.puppetlabs.com]')
-
-      expect(config.devices).to include('router-1.puppetlabs.com')
-    end
-
-    it "should create a new device for each found device line" do
-      write_device_config('[router.puppetlabs.com]', '[swith.puppetlabs.com]')
-
-      expect(config.devices.size).to eq(2)
-    end
-
-    it "should parse the device type" do
-      write_device_config('[router.puppetlabs.com]', 'type cisco')
-
-      expect(config.devices['router.puppetlabs.com'].provider).to eq('cisco')
-    end
-
-    it "should parse the device url" do
-      write_device_config('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/')
-
-      expect(config.devices['router.puppetlabs.com'].url).to eq('ssh://test/')
-    end
-
-    it "should error with a malformed device url" do
-      write_device_config('[router.puppetlabs.com]', 'type cisco', 'url ssh://test node/')
-
-      expect { config.devices['router.puppetlabs.com'] }.to raise_error Puppet::Error
-    end
-
-    it "should parse the debug mode" do
-      write_device_config('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/', 'debug')
-
-      expect(config.devices['router.puppetlabs.com'].options).to eq({ :debug => true })
-    end
-
-    it "should set the debug mode to false by default" do
-      write_device_config('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/')
-
-      expect(config.devices['router.puppetlabs.com'].options).to eq({ :debug => false })
-    end
-  end
-
-end

data/spec/unit/util/network_device/transport/base_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/network_device/transport/base'
-
-describe Puppet::Util::NetworkDevice::Transport::Base do
-  class TestTransport < Puppet::Util::NetworkDevice::Transport::Base
-  end
-
-  before(:each) do
-    @transport = TestTransport.new
-  end
-
-  describe "when sending commands" do
-    it "should send the command to the telnet session" do
-      expect(@transport).to receive(:send).with("line")
-      @transport.command("line")
-    end
-
-    it "should expect an output matching the given prompt" do
-      expect(@transport).to receive(:expect).with(/prompt/)
-      @transport.command("line", :prompt => /prompt/)
-    end
-
-    it "should expect an output matching the default prompt" do
-      @transport.default_prompt = /defprompt/
-      expect(@transport).to receive(:expect).with(/defprompt/)
-      @transport.command("line")
-    end
-
-    it "should yield telnet output to the given block" do
-      expect(@transport).to receive(:expect).and_yield("output")
-      @transport.command("line") { |out| expect(out).to eq("output") }
-    end
-
-    it "should return telnet output to the caller" do
-      expect(@transport).to receive(:expect).and_return("output")
-      expect(@transport.command("line")).to eq("output")
-    end
-  end
-end

data/spec/unit/util/network_device_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-require 'ostruct'
-require 'puppet/util/network_device'
-
-describe Puppet::Util::NetworkDevice do
-  before(:each) do
-    @device = OpenStruct.new(:name => "name", :provider => "test", :url => "telnet://admin:password@127.0.0.1", :options => { :debug => false })
-  end
-
-  after(:each) do
-    Puppet::Util::NetworkDevice.teardown
-  end
-
-  class Puppet::Util::NetworkDevice::Test
-    class Device
-      def initialize(device, options)
-      end
-    end
-  end
-
-  describe "when initializing the remote network device singleton" do
-    it "should create a network device instance" do
-      allow(Puppet::Util::NetworkDevice).to receive(:require)
-      expect(Puppet::Util::NetworkDevice::Test::Device).to receive(:new).with("telnet://admin:password@127.0.0.1", {:debug => false})
-      Puppet::Util::NetworkDevice.init(@device)
-    end
-
-    it "should raise an error if the remote device instance can't be created" do
-      allow(Puppet::Util::NetworkDevice).to receive(:require).and_raise("error")
-      expect { Puppet::Util::NetworkDevice.init(@device) }.to raise_error(RuntimeError, /Can't load test for name/)
-    end
-
-    it "should let caller to access the singleton device" do
-      device = double('device')
-      allow(Puppet::Util::NetworkDevice).to receive(:require)
-      expect(Puppet::Util::NetworkDevice::Test::Device).to receive(:new).and_return(device)
-      Puppet::Util::NetworkDevice.init(@device)
-
-      expect(Puppet::Util::NetworkDevice.current).to eq(device)
-    end
-  end
-end

data/spec/unit/util/package/version/debian_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/package/version/debian'
-
-describe Puppet::Util::Package::Version::Debian do
-  context "when creating new version should fail" do
-    it "if is parsing symbols" do
-      expect { described_class.parse(:absent) }.to raise_error(described_class::ValidationFailure)
-    end
-  end
-  context "when creating new version" do
-    it "is parsing basic version" do
-      v = described_class.parse('1:20191210.1-0ubuntu0.19.04.2')
-      expect(v.epoch).to eql(1)
-      expect(v.upstream_version).to eql('20191210.1')
-      expect(v.debian_revision).to eql('0ubuntu0.19.04.2')
-    end
-
-    it "is parsing no epoch basic version" do
-      v = described_class.parse('20191210.1-0ubuntu0.19.04.2')
-      expect(v.epoch).to eql(0)
-      expect(v.upstream_version).to eql('20191210.1')
-      expect(v.debian_revision).to eql('0ubuntu0.19.04.2')
-    end
-
-    it "is parsing no debian revision basic version" do
-      v = described_class.parse('2.42.1+19.04')
-      expect(v.epoch).to eql(0)
-      expect(v.upstream_version).to eql('2.42.1+19.04')
-      expect(v.debian_revision).to eql(nil)
-    end
-
-    it "is parsing no epoch complex version" do
-      v = described_class.parse('3.32.2+git20190711-2ubuntu1~19.04.1')
-      expect(v.epoch).to eql(0)
-      expect(v.upstream_version).to eql('3.32.2+git20190711')
-      expect(v.debian_revision).to eql('2ubuntu1~19.04.1')
-    end
-
-    it "is parsing even more complex version" do
-      v = described_class.parse('5:1.0.0+git-20190109.133f4c4-0ubuntu2')
-      expect(v.epoch).to eql(5)
-      expect(v.upstream_version).to eql('1.0.0+git-20190109.133f4c4')
-      expect(v.debian_revision).to eql('0ubuntu2')
-    end
-  end
-  context "when comparing two versions" do
-    it "epoch has precedence" do
-      first = described_class.parse('9:99-99')
-      second = described_class.parse('10:01-01')
-      expect(first < second).to eql(true)
-    end
-    it "handles equals letters-only versions" do
-      lower = described_class.parse('abd-def')
-      higher = described_class.parse('abd-def')
-      expect(lower == higher).to eql(true)
-    end
-    it "shorter version is smaller" do
-      lower = described_class.parse('abd-de')
-      higher = described_class.parse('abd-def')
-      expect(lower < higher).to eql(true)
-    end
-    it "shorter version is smaller even with digits" do
-      lower = described_class.parse('a1b2d-d3e')
-      higher = described_class.parse('a1b2d-d3ef')
-      expect(lower < higher).to eql(true)
-    end
-    it "shorter version is smaller when number is less" do
-      lower = described_class.parse('a1b2d-d9')
-      higher = described_class.parse('a1b2d-d13')
-      expect(lower < higher).to eql(true)
-    end
-    it "handles ~ version" do
-      lower = described_class.parse('a1b2d-d10~')
-      higher = described_class.parse('a1b2d-d10')
-      expect(lower < higher).to eql(true)
-    end
-    it "handles letters versus -" do
-      lower = described_class.parse('a1b2d-d1a')
-      higher = described_class.parse('a1b2d-d1-')
-      expect(lower < higher).to eql(true)
-    end
-  end
-end