puppet 6.17.0-x86-mingw32 → 6.18.0-x86-mingw32

data/spec/integration/file_serving/content_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_serving/content'
-
-describe Puppet::FileServing::Content do
-  it_should_behave_like "a file_serving model"
-end

data/spec/integration/file_serving/fileset_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_serving/fileset'
-
-describe Puppet::FileServing::Fileset do
-  it "should be able to recurse on a single file" do
-    @path = Tempfile.new("fileset_integration")
-
-    fileset = Puppet::FileServing::Fileset.new(@path.path)
-    expect { fileset.files }.not_to raise_error
-  end
-end

data/spec/integration/file_serving/metadata_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_serving/metadata'
-
-describe Puppet::FileServing::Metadata do
-  it_should_behave_like "a file_serving model"
-end
-

data/spec/integration/file_serving/terminus_helper_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_serving/terminus_helper'
-
-class TerminusHelperIntegrationTester
-  include Puppet::FileServing::TerminusHelper
-  def model
-    Puppet::FileServing::Metadata
-  end
-end
-
-describe Puppet::FileServing::TerminusHelper do
-  it "should be able to recurse on a single file" do
-    @path = Tempfile.new("fileset_integration")
-    request = Puppet::Indirector::Request.new(:metadata, :find, @path.path, nil, :recurse => true)
-
-    tester = TerminusHelperIntegrationTester.new
-    expect { tester.path2instances(request, @path.path) }.not_to raise_error
-  end
-end

data/spec/integration/file_system/uniquefile_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::FileSystem::Uniquefile do
-  describe "#open_tmp on Windows", :if => Puppet::Util::Platform.windows? do
-    describe "with UTF8 characters" do
-      include PuppetSpec::Files
-
-      let(: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" }
-      let(:temp_rune_utf8) { tmpdir(rune_utf8) }
-
-      it "should use UTF8 characters in TMP,TEMP,TMPDIR environment variable" do
-        # Set the temporary environment variables to the UTF8 temp path
-        Puppet::Util::Windows::Process.set_environment_variable('TMPDIR', temp_rune_utf8)
-        Puppet::Util::Windows::Process.set_environment_variable('TMP', temp_rune_utf8)
-        Puppet::Util::Windows::Process.set_environment_variable('TEMP', temp_rune_utf8)
-
-        # Create a unique file
-        filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
-          File.dirname(file.path)
-        end
-
-        expect(filename).to eq(temp_rune_utf8)
-      end
-    end
-  end
-end

data/spec/integration/module_tool/forge_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'puppet/forge'
-require 'puppet_spec/https'
-
-describe Puppet::Forge, unless: Puppet::Util::Platform.jruby? do
-  include PuppetSpec::Files
-  include_context "https client"
-
-  let(:wrong_hostname) { 'localhost' }
-  let(:server) { PuppetSpec::HTTPSServer.new }
-  let(:ssl_provider) { Puppet::SSL::SSLProvider.new }
-
-  let(:http_response) do
-    File.read(fixtures('unit/forge/bacula.json'))
-  end
-
-  let(:release_response) do
-    releases = JSON.parse(http_response)
-    releases['results'] = []
-    JSON.dump(releases)
-  end
-
-  it 'fetching module release entries' do
-    # create a temp cacert bundle
-    ssl_file = tmpfile('systemstore')
-    File.write(ssl_file, server.ca_cert)
-
-    # override path to system cacert bundle, this must be done before
-    # the SSLContext is created and the call to X509::Store.set_default_paths
-    Puppet::Util.withenv("SSL_CERT_FILE" => ssl_file) do
-      response_proc = -> (req, res) {
-        res.status = 200
-        res.body = release_response
-      }
-
-      server.start_server(response_proc: response_proc) do |port|
-        forge = described_class.new("https://127.0.0.1:#{port}")
-        forge.fetch('bacula')
-      end
-    end
-  end
-
-  it 'returns a valid exception when there is an SSL verification problem' do
-    server.start_server do |port|
-      forge = described_class.new("https://#{wrong_hostname}:#{port}")
-      expect {
-        forge.fetch('mymodule')
-      }.to raise_error Puppet::Forge::Errors::SSLVerifyError, %r{^Unable to verify the SSL certificate at https://#{wrong_hostname}}
-    end
-  end
-end

data/spec/integration/module_tool/tar/mini_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool'
-require 'puppet_spec/files'
-
-describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? && Puppet.features.zlib?) do
-  let(:minitar)    { described_class.new }
-
-  describe "Extracts tars with long and short pathnames" do
-    let (:sourcetar) { File.expand_path('../../../../fixtures/module.tar.gz', __FILE__) }
-
-    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
-    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
-
-    it "unpacks a tar with a short path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
-    end
-
-    it "unpacks a tar with a long path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
-    end
-  end
-end

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