puppet 6.16.0 → 7.0.0

data/spec/integration/provider/service/init_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-test_title = 'Integration Tests for Puppet::Type::Service::Provider::Init'
-
-describe test_title, unless: Puppet::Util::Platform.jruby? do
-  let(:provider) { Puppet::Type.type(:service).provider(:init) }
-
-  describe "when running on FreeBSD" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('FreeBSD')
-      allow(Facter).to receive(:value).with(:osfamily).and_return('FreeBSD')
-    end
-
-    it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
-      expect(provider.defpath).to eq(["/etc/rc.d", "/usr/local/etc/rc.d"])
-    end
-  end
-
-  describe "when running on HP-UX" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('HP-UX')
-    end
-
-    it "should set its default path to include /sbin/init.d" do
-      expect(provider.defpath).to eq("/sbin/init.d")
-    end
-  end
-
-  describe "when running on Archlinux" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Archlinux')
-    end
-
-    it "should set its default path to include /etc/rc.d" do
-      expect(provider.defpath).to eq("/etc/rc.d")
-    end
-  end
-
-  describe "when not running on FreeBSD, HP-UX or Archlinux" do
-    before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
-    end
-
-    it "should set its default path to include /etc/init.d" do
-      expect(provider.defpath).to eq("/etc/init.d")
-    end
-  end
-end

data/spec/integration/provider/service/systemd_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-test_title = 'Integration Tests for Puppet::Type::Service::Provider::Systemd'
-
-describe test_title, unless: Puppet::Util::Platform.jruby? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:systemd) }
-
-  # TODO: Unfortunately there does not seem a way to stub the executable
-  #       checks in the systemd provider because they happen at load time.
-
-  it "should be considered suitable if /proc/1/comm is present and contains 'systemd'",
-    :if => File.exist?('/proc/1/comm') && Puppet::FileSystem.read('/proc/1/comm').include?('systemd') do
-    expect(provider_class).to be_suitable
-  end
-
-  it "should not be considered suitable if /proc/1/comm is present it does not contain 'systemd'",
-    :if => File.exist?('/proc/1/comm') && !Puppet::FileSystem.read('/proc/1/comm').include?('systemd') do
-    expect(provider_class).not_to be_suitable
-  end
-
-  it "should not be considered suitable if /proc/1/comm is absent",
-    :if => !File.exist?('/proc/1/comm') do
-    expect(provider_class).not_to be_suitable
-  end
-end

data/spec/integration/provider/service/windows_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-test_title = 'Integration Tests for Puppet::Type::Service::Provider::Windows'
-
-describe test_title, '(integration)', :if => Puppet::Util::Platform.windows? do
-  let(:provider_class) { Puppet::Type.type(:service).provider(:windows) }
-
-  require 'puppet/util/windows'
-
-  before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-  end
-
-  context 'should return valid values when querying a service that does not exist' do
-    let(:service) do
-      Puppet::Type.type(:service).new(:name => 'foobarservice1234')
-    end
-
-    it "with :false when asked if enabled" do
-      expect(service.provider.enabled?).to eql(:false)
-    end
-
-    it "with :stopped when asked about status" do
-      expect(service.provider.status).to eql(:stopped)
-    end
-  end
-
-  context 'should return valid values when querying a service that does exist' do
-    let(:service) do
-      # This service should be ubiquitous across all supported Windows platforms
-      Puppet::Type.type(:service).new(:name => 'lmhosts')
-    end
-
-    it "with a valid enabled? value when asked if enabled" do
-      expect([:true, :false, :manual]).to include(service.provider.enabled?)
-    end
-
-    it "with a valid status when asked about status" do
-      expect([
-        :running,
-        :'continue pending',
-        :'pause pending',
-        :paused,
-        :running,
-        :'start pending',
-        :'stop pending',
-        :stopped]).to include(service.provider.status)
-    end
-  end
-end

data/spec/integration/reference/providers_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/reference'
-
-reference = Puppet::Util::Reference.reference(:providers)
-
-describe reference do
-  it "should exist" do
-    expect(reference).not_to be_nil
-  end
-
-  it "should be able to be rendered as markdown" do
-    # We have a :confine block that calls execute in our upstart provider, which fails
-    # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
-    # This is only an issue if you're running these unit tests on a platform where upstart
-    # is a default provider, like Ubuntu trusty.
-    allow(Puppet::Util::Execution).to receive(:execute)
-
-    reference.to_markdown
-  end
-end

data/spec/integration/reports_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/reports'
-
-describe Puppet::Reports, " when using report types" do
-  before do
-    allow(Puppet.settings).to receive(:use)
-  end
-
-  it "should load report types as modules" do
-    expect(Puppet::Reports.report(:store)).to be_instance_of(Module)
-  end
-end

data/spec/integration/ssl/certificate_request_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/ssl/certificate_request'
-
-describe Puppet::SSL::CertificateRequest do
-  include PuppetSpec::Files
-
-  before do
-    # Get a safe temporary file
-    dir = tmpdir("csr_integration_testing")
-
-    Puppet.settings[:confdir] = dir
-    Puppet.settings[:vardir] = dir
-
-    @csr = Puppet::SSL::CertificateRequest.new("luke.madstop.com")
-
-    @key = OpenSSL::PKey::RSA.new(512)
-
-    # This is necessary so the terminus instances don't lie around.
-    Puppet::SSL::CertificateRequest.indirection.termini.clear
-  end
-
-  it "should be able to generate CSRs" do
-    @csr.generate(@key)
-  end
-
-  it "should be able to save CSRs" do
-    Puppet::SSL::CertificateRequest.indirection.save(@csr)
-  end
-
-  it "should be able to find saved certificate requests via the Indirector" do
-    @csr.generate(@key)
-    Puppet::SSL::CertificateRequest.indirection.save(@csr)
-
-    expect(Puppet::SSL::CertificateRequest.indirection.find("luke.madstop.com")).to be_instance_of(Puppet::SSL::CertificateRequest)
-  end
-
-  it "should save the completely CSR when saving" do
-    @csr.generate(@key)
-    Puppet::SSL::CertificateRequest.indirection.save(@csr)
-
-    expect(Puppet::SSL::CertificateRequest.indirection.find("luke.madstop.com").content.to_s).to eq(@csr.content.to_s)
-  end
-end

data/spec/integration/ssl/host_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'puppet/test_ca'
-
-require 'puppet/ssl/host'
-
-describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
-  include PuppetSpec::Files
-
-  before do
-    # Get a safe temporary file
-    dir = tmpdir("host_integration_testing")
-
-    Puppet.settings[:confdir] = dir
-    Puppet.settings[:vardir] = dir
-    Puppet.settings.use :main, :ssl
-
-    @host = Puppet::SSL::Host.new("luke.madstop.com")
-    allow(@host).to receive(:submit_certificate_request)
-
-    @ca = Puppet::TestCa.new
-    Puppet::Util.replace_file(Puppet[:localcacert], 0644) do |f|
-      f.write(@ca.ca_cert.to_s)
-    end
-    Puppet::Util.replace_file(Puppet[:hostcrl], 0644) do |f|
-      f.write(@ca.ca_crl.to_s)
-    end
-  end
-
-  describe "when managing its key" do
-    it "should be able to generate and save a key" do
-      @host.generate_key
-    end
-
-    it "should save the key such that the Indirector can find it" do
-      @host.generate_key
-
-      expect(Puppet::SSL::Key.indirection.find(@host.name).content.to_s).to eq(@host.key.to_s)
-    end
-
-    it "should save the private key into the :privatekeydir" do
-      @host.generate_key
-      expect(File.read(File.join(Puppet.settings[:privatekeydir], "luke.madstop.com.pem"))).to eq(@host.key.to_s)
-    end
-  end
-
-  describe "when managing its certificate request" do
-    it "should be able to generate and save a certificate request" do
-      @host.generate_certificate_request
-    end
-
-    it "should save the certificate request such that the Indirector can find it" do
-      @host.generate_certificate_request
-
-      expect(Puppet::SSL::CertificateRequest.indirection.find(@host.name).content.to_s).to eq(@host.certificate_request.to_s)
-    end
-
-    it "should save the private certificate request into the :privatekeydir" do
-      @host.generate_certificate_request
-      expect(File.read(File.join(Puppet.settings[:requestdir], "luke.madstop.com.pem"))).to eq(@host.certificate_request.to_s)
-    end
-  end
-
-  it "should pass the verification of its own SSL store", :unless => Puppet.features.microsoft_windows? do
-    @host.generate_certificate_request
-    cert = @ca.sign(@host.certificate_request.content)
-    Puppet::Util.replace_file(File.join(Puppet[:certdir], "#{@host.name}.pem"), 0644) do |f|
-      f.write(cert)
-    end
-
-    expect(@host.ssl_store.verify(@host.certificate.content)).to be_truthy
-  end
-end

data/spec/integration/ssl/key_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/ssl/key'
-
-describe Puppet::SSL::Key, unless: Puppet::Util::Platform.jruby? do
-  include PuppetSpec::Files
-
-  # different UTF-8 widths
-  # 1-byte A
-  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
-  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
-  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ܎
-
-  before do
-    # Get a safe temporary file
-    dir = tmpdir('key_integration_testing')
-
-    Puppet.settings[:confdir] = dir
-    Puppet.settings[:vardir] = dir
-
-    # This is necessary so the terminus instances don't lie around.
-    # and so that Puppet::SSL::Key.indirection.save may be used
-    Puppet::SSL::Key.indirection.termini.clear
-  end
-
-  describe 'with a custom user-specified passfile' do
-
-    before do
-      # write custom password file to where Puppet expects
-      password_file = tmpfile('passfile')
-      Puppet[:passfile] = password_file
-      Puppet::FileSystem.open(password_file, nil, 'w:UTF-8') { |f| f.print(mixed_utf8) }
-    end
-
-    it 'should use the configured password file if it is not the CA key' do
-      key = Puppet::SSL::Key.new('test')
-      expect(key.password_file).to eq(Puppet[:passfile])
-      expect(key.password).to eq(mixed_utf8.force_encoding(Encoding::BINARY))
-    end
-
-    it "should be able to read an existing private key given the correct password" do
-      key_name = 'test'
-      # use OpenSSL APIs to generate a private key
-      private_key = OpenSSL::PKey::RSA.generate(512)
-
-      # stash it in Puppets private key directory
-      FileUtils.mkdir_p(Puppet[:privatekeydir])
-      pem_path = File.join(Puppet[:privatekeydir], "#{key_name}.pem")
-      Puppet::FileSystem.open(pem_path, nil, 'w:UTF-8') do |f|
-        # with password protection enabled
-        pem = private_key.to_pem(OpenSSL::Cipher::DES.new(:EDE3, :CBC), mixed_utf8)
-        f.print(pem)
-      end
-
-      # indirector loads existing .pem off disk instead of replacing it
-      host = Puppet::SSL::Host.new(key_name)
-      host.key
-
-      # newly loaded host private key matches the manually created key
-      # Private-Key: (512 bit) style data
-      expect(host.key.content.to_text).to eq(private_key.to_text)
-      # -----BEGIN RSA PRIVATE KEY-----
-      expect(host.key.content.to_s).to eq(private_key.to_s)
-      expect(host.key.password).to eq(mixed_utf8.force_encoding(Encoding::BINARY))
-    end
-
-    it 'should export the private key to PEM using the password' do
-      key_name = 'test'
-
-      # uses specified :passfile when writing the private key
-      key = Puppet::SSL::Key.new(key_name)
-      key.generate
-      Puppet::SSL::Key.indirection.save(key)
-
-      # indirector writes file here
-      pem_path = File.join(Puppet[:privatekeydir], "#{key_name}.pem")
-
-      # note incorrect password is an error
-      expect do
-        Puppet::FileSystem.open(pem_path, nil, 'r:ASCII') do |f|
-          OpenSSL::PKey::RSA.new(f.read, 'invalid_password')
-        end
-      end.to raise_error(OpenSSL::PKey::RSAError)
-
-      # but when specifying the correct password
-      reloaded_key = nil
-      Puppet::FileSystem.open(pem_path, nil, 'r:ASCII') do |f|
-        reloaded_key = OpenSSL::PKey::RSA.new(f.read, mixed_utf8)
-      end
-
-      # the original key matches the manually reloaded key
-      # Private-Key: (512 bit) style data
-      expect(key.content.to_text).to eq(reloaded_key.to_text)
-      # -----BEGIN RSA PRIVATE KEY-----
-      expect(key.content.to_s).to eq(reloaded_key.to_s)
-    end
-  end
-end

data/spec/integration/test/test_helper_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe "Windows UTF8 environment variables", :if => Puppet::Util::Platform.windows? do
-  # The Puppet::Util::Windows::Process class is used to manipulate environment variables as it is known to handle UTF8 characters. Where as the implementation of ENV in ruby does not.
-  # before and end all are used to inject environment variables before the test helper 'before_each_test' function is called
-  # Do not use before and after hooks in these tests as it may have unintended consequences
-
-  before(:all) {
-    @varname = 'test_helper_spec-test_variable'
-    @rune_utf8 = "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7"
-
-    Puppet::Util::Windows::Process.set_environment_variable(@varname, @rune_utf8)
-  }
-  after(:all) {
-    # Need to cleanup this environment variable otherwise it contaminates any subsequent tests
-    Puppet::Util::Windows::Process.set_environment_variable(@varname, nil)
-  }
-
-  it "#after_each_test should preserve UTF8 environment variables" do
-    envhash = Puppet::Util::Windows::Process.get_environment_strings
-    expect(envhash[@varname]).to eq(@rune_utf8)
-    # Change the value in the test to force test_helper to restore the environment
-    ENV[@varname] = 'bad foo'
-
-    # Prematurely trigger the after_each_test method
-    Puppet::Test::TestHelper.after_each_test
-
-    envhash = Puppet::Util::Windows::Process.get_environment_strings
-    expect(envhash[@varname]).to eq(@rune_utf8)
-  end
-end

data/spec/shared_behaviours/file_serving_model.rb

@@ -1,51 +0,0 @@
-shared_examples_for "a file_serving model" do
-  include PuppetSpec::Files
-
-  describe "#indirection" do
-    localpath = PuppetSpec::Files.make_absolute("/etc/sudoers")
-    localurl = "file://" + localpath
-
-    before :each do
-      # Never connect to the network, no matter what
-      allow_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(:find)
-    end
-
-    describe "when running the apply application" do
-      before :each do
-        Puppet[:default_file_terminus] = 'file_server'
-      end
-
-      {
-       localpath => :file,
-       localurl => :file,
-       "puppet:///modules/foo/bar"       => :file_server,
-       "puppet://server/modules/foo/bar" => :rest,
-      }.each do |key, terminus|
-        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
-
-          described_class.indirection.find(key)
-        end
-      end
-    end
-
-    describe "when running another application" do
-      before :each do
-        Puppet[:default_file_terminus] = 'rest'
-      end
-
-      {
-       localpath => :file,
-       localurl => :file,
-       "puppet:///modules/foo/bar"       => :rest,
-       "puppet://server/modules/foo/bar" => :rest,
-      }.each do |key, terminus|
-        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
-
-          described_class.indirection.find(key)
-        end
-      end
-    end
-  end
-end