puppet 7.34.0-universal-darwin → 8.0.1-universal-darwin

data/spec/integration/application/module_spec.rb

@@ -0,0 +1,230 @@
+# coding: utf-8
+require 'spec_helper'
+require 'puppet/forge'
+require 'puppet_spec/https'
+
+describe 'puppet module', unless: Puppet::Util::Platform.jruby? do
+  include PuppetSpec::Files
+  include_context "https client"
+
+  let(:app) { Puppet::Application[:module] }
+  let(:wrong_hostname) { 'localhost' }
+  let(:server) { PuppetSpec::HTTPSServer.new }
+  let(:ssl_provider) { Puppet::SSL::SSLProvider.new }
+
+  let(:release_response) { File.read(fixtures('unit/forge/bacula-releases.json')) }
+  let(:release_tarball) { File.binread(fixtures('unit/forge/bacula.tar.gz')) }
+  let(:target_dir) { tmpdir('bacula') }
+
+  before :each do
+    SemanticPuppet::Dependency.clear_sources
+  end
+
+  it 'installs a module' do
+    # create a temp cacert bundle
+    ssl_file = tmpfile('systemstore')
+    File.write(ssl_file, server.ca_cert)
+
+    response_proc = -> (req, res) {
+      if req.path == '/v3/releases'
+        res['Content-Type'] = 'application/json'
+        res.body = release_response
+      else
+        res['Content-Type'] = 'application/octet-stream'
+        res.body = release_tarball
+      end
+      res.status = 200
+    }
+
+    # 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
+      server.start_server(response_proc: response_proc) do |port|
+        Puppet[:module_repository] = "https://127.0.0.1:#{port}"
+
+        # On Windows, CP437 encoded output can't be matched against UTF-8 regexp,
+        # so encode the regexp to the external encoding and match against that.
+        app.command_line.args = ['install', 'puppetlabs-bacula', '--target-dir', target_dir]
+        expect {
+          app.run
+        }.to exit_with(0)
+         .and output(Regexp.new("└── puppetlabs-bacula".encode(Encoding.default_external))).to_stdout
+      end
+    end
+  end
+
+  it 'returns a valid exception when there is an SSL verification problem' do
+    server.start_server do |port|
+      Puppet[:module_repository] = "https://#{wrong_hostname}:#{port}"
+
+      expect {
+        app.command_line.args = ['install', 'puppetlabs-bacula', '--target-dir', target_dir]
+        app.run
+      }.to exit_with(1)
+       .and output(%r{Notice: Downloading from https://#{wrong_hostname}:#{port}}).to_stdout
+       .and output(%r{Unable to verify the SSL certificate}).to_stderr
+    end
+  end
+
+  it 'prints the complete URL it tried to connect to' do
+    response_proc = -> (req, res) { res.status = 404 }
+
+    # create a temp cacert bundle
+    ssl_file = tmpfile('systemstore')
+    File.write(ssl_file, server.ca_cert)
+
+    Puppet::Util.withenv("SSL_CERT_FILE" => ssl_file) do
+      server.start_server(response_proc: response_proc) do |port|
+        Puppet[:module_repository] = "https://127.0.0.1:#{port}/bogus_test/puppet"
+
+        expect {
+          app.command_line.args = ['install', 'puppetlabs-bacula']
+          app.run
+        }.to exit_with(1)
+         .and output(%r{Notice: Downloading from https://127.0.0.1:#{port}}).to_stdout
+         .and output(%r{https://127.0.0.1:#{port}/bogus_test/puppet/v3/releases}).to_stderr
+      end
+    end
+  end
+
+  context 'install' do
+    it 'lists a module in a non-default directory environment' do
+      Puppet.initialize_settings(['-E', 'direnv'])
+      Puppet[:color] = false
+      Puppet[:environmentpath] = File.join(my_fixture_dir, 'environments')
+
+      expect {
+        app.command_line.args = ['list']
+        app.run
+      }.to exit_with(0)
+       .and output(Regexp.new("└── pmtacceptance-nginx".encode(Encoding.default_external), Regexp::MULTILINE)).to_stdout
+    end
+  end
+
+  context 'changes' do
+    let(:tmp) { tmpdir('module_changes') }
+
+    before :each do
+      Puppet.initialize_settings(['-E', 'direnv'])
+      Puppet[:color] = false
+    end
+
+    def use_local_fixture
+      Puppet[:environmentpath] = File.join(my_fixture_dir, 'environments')
+    end
+
+    def create_working_copy
+      Puppet[:environmentpath] = File.join(tmp, 'environments')
+      FileUtils.cp_r(File.join(my_fixture_dir, 'environments'), tmp)
+    end
+
+    it 'reports an error when the install path is invalid' do
+      use_local_fixture
+
+      pattern = Regexp.new([
+        %Q{.*Error: Could not find a valid module at "#{tmp}/nginx".*},
+        %Q{.*Error: Try 'puppet help module changes' for usage.*},
+      ].join("\n"), Regexp::MULTILINE)
+
+      expect {
+        app.command_line.args = ['changes', File.join(tmp, 'nginx')]
+        app.run
+      }.to exit_with(1)
+       .and output(pattern).to_stderr
+    end
+
+    it 'reports when checksums are missing from metadata.json' do
+      create_working_copy
+
+      # overwrite checksums in metadata.json
+      nginx_dir = File.join(tmp, 'environments', 'direnv', 'modules', 'nginx')
+      File.write(File.join(nginx_dir, 'metadata.json'), <<~END)
+        {
+          "name": "pmtacceptance/nginx",
+          "version": "0.0.1"
+        }
+      END
+
+      pattern = Regexp.new([
+        %Q{.*Error: No file containing checksums found.*},
+        %Q{.*Error: Try 'puppet help module changes' for usage.*},
+      ].join("\n"), Regexp::MULTILINE)
+
+      expect {
+        app.command_line.args = ['changes', nginx_dir]
+        app.run
+      }.to exit_with(1)
+        .and output(pattern).to_stderr
+    end
+
+    it 'reports module not found when metadata.json is missing' do
+      create_working_copy
+
+      # overwrite checksums in metadata.json
+      nginx_dir = File.join(tmp, 'environments', 'direnv', 'modules', 'nginx')
+      File.unlink(File.join(nginx_dir, 'metadata.json'))
+
+      pattern = Regexp.new([
+        %Q{.*Error: Could not find a valid module at.*},
+        %Q{.*Error: Try 'puppet help module changes' for usage.*},
+      ].join("\n"), Regexp::MULTILINE)
+
+      expect {
+        app.command_line.args = ['changes', nginx_dir]
+        app.run
+      }.to exit_with(1)
+        .and output(pattern).to_stderr
+    end
+
+    it 'reports when a file is modified' do
+      create_working_copy
+
+      # overwrite README so checksum doesn't match
+      nginx_dir = File.join(tmp, 'environments', 'direnv', 'modules', 'nginx')
+      File.write(File.join(nginx_dir, 'README'), '')
+
+      pattern = Regexp.new([
+        %Q{.*Warning: 1 files modified.*},
+      ].join("\n"), Regexp::MULTILINE)
+
+      expect {
+        app.command_line.args = ['changes', nginx_dir]
+        app.run
+      }.to exit_with(0)
+        .and output(%r{README}).to_stdout
+        .and output(pattern).to_stderr
+    end
+
+    it 'reports when a file is missing' do
+      create_working_copy
+
+      # delete README so checksum doesn't match
+      nginx_dir = File.join(tmp, 'environments', 'direnv', 'modules', 'nginx')
+      File.unlink(File.join(nginx_dir, 'README'))
+
+      # odd that it says modified
+      pattern = Regexp.new([
+        %Q{.*Warning: 1 files modified.*},
+      ].join("\n"), Regexp::MULTILINE)
+
+      expect {
+        app.command_line.args = ['changes', nginx_dir]
+        app.run
+      }.to exit_with(0)
+        .and output(%r{README}).to_stdout
+        .and output(pattern).to_stderr
+    end
+
+    it 'reports when there are no changes' do
+      use_local_fixture
+
+      nginx_dir = File.join(Puppet[:environmentpath], 'direnv', 'modules', 'nginx')
+
+      expect {
+        app.command_line.args = ['changes', nginx_dir]
+        app.run
+      }.to exit_with(0)
+        .and output(/No modified files/).to_stdout
+    end
+  end
+end

data/spec/integration/application/plugin_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet_spec/puppetserver'
+
+describe "puppet plugin", unless: Puppet::Util::Platform.jruby? do
+  include_context "https client"
+
+  let(:server) { PuppetSpec::Puppetserver.new }
+  let(:plugin) { Puppet::Application[:plugin] }
+  let(:response_body) { "[{\"path\":\"/etc/puppetlabs/code/environments/production/modules\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-03-06 20:14:25 UTC\"},\"type\":\"directory\",\"destination\":null}]" }
+
+  it "downloads from plugins, pluginsfacts and locales mounts when i18n is enabled" do
+    Puppet[:disable_i18n] = false
+    current_version_handler = -> (req, res) {
+      res['X-Puppet-Version'] = Puppet.version
+      res['Content-Type'] = 'application/json'
+      res.body = response_body
+    }
+
+    server.start_server(mounts: {file_metadatas: current_version_handler}) do |port|
+      Puppet[:serverport] = port
+      expect {
+        plugin.command_line.args << 'download'
+        plugin.run
+      }.to exit_with(0)
+       .and output(matching(
+         "Downloaded these plugins: #{Regexp.escape(Puppet[:pluginfactdest])}, #{Regexp.escape(Puppet[:plugindest])}, #{Regexp.escape(Puppet[:localedest])}"
+       )).to_stdout
+    end
+  end
+
+  it "downloads from plugins, pluginsfacts but no locales mounts when i18n is disabled" do
+    Puppet[:disable_i18n] = true
+
+    current_version_handler = -> (req, res) {
+      res['X-Puppet-Version'] = Puppet.version
+      res['Content-Type'] = 'application/json'
+      res.body = response_body
+    }
+
+    server.start_server(mounts: {file_metadatas: current_version_handler}) do |port|
+      Puppet[:serverport] = port
+      expect {
+        plugin.command_line.args << 'download'
+        plugin.run
+      }.to exit_with(0)
+       .and output(matching(
+         "Downloaded these plugins: #{Regexp.escape(Puppet[:pluginfactdest])}, #{Regexp.escape(Puppet[:plugindest])}"
+       )).to_stdout
+    end
+  end
+
+  it "downloads from plugins and pluginsfacts from older puppetservers" do
+    no_locales_handler = -> (req, res) {
+      res['X-Puppet-Version'] = '5.3.3' # locales mount was added in 5.3.4
+      res['Content-Type'] = 'application/json'
+      res.body = response_body
+    }
+
+    server.start_server(mounts: {file_metadatas: no_locales_handler}) do |port|
+      Puppet[:serverport] = port
+      expect {
+        plugin.command_line.args << 'download'
+        plugin.run
+      }.to exit_with(0)
+       .and output(matching(
+         "Downloaded these plugins: #{Regexp.escape(Puppet[:pluginfactdest])}, #{Regexp.escape(Puppet[:plugindest])}"
+       )).to_stdout
+    end
+  end
+
+  it "downloads from an environment that doesn't exist locally" do
+    requested_environment = nil
+
+    current_version_handler = -> (req, res) {
+      res['X-Puppet-Version'] = Puppet.version
+      res['Content-Type'] = 'application/json'
+      res.body = response_body
+      requested_environment = req.query['environment']
+    }
+
+    server.start_server(mounts: {file_metadatas: current_version_handler}) do |port|
+      Puppet[:environment] = 'doesnotexistontheagent'
+      Puppet[:serverport] = port
+      expect {
+        plugin.command_line.args << 'download'
+        plugin.run
+      }.to exit_with(0)
+       .and output(matching("Downloaded these plugins")).to_stdout
+
+      expect(requested_environment).to eq('doesnotexistontheagent')
+    end
+  end
+
+  context "pluginsync for external facts uses source permissions to preserve fact executable-ness" do
+    before :all do
+      WebMock.enable!
+    end
+
+    after :all do
+      WebMock.disable!
+    end
+
+    before :each do
+      metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":420,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/(plugins|locales)}).to_return(status: 200, body: metadata, headers: {'Content-Type' => 'application/json'})
+
+      # response retains owner/group/mode due to source_permissions => use
+      facts_metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":500,\"group\":500,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(status: 200, body: facts_metadata, headers: {'Content-Type' => 'application/json'})
+    end
+
+    it "processes a download request resulting in no changes" do
+      # Create these so there are no changes
+      Puppet::FileSystem.mkpath(Puppet[:plugindest])
+      Puppet::FileSystem.mkpath(Puppet[:localedest])
+
+      # /opt/puppetlabs/puppet/cache/facts.d will be created based on our umask.
+      # If the mode on disk is not 0755, then the mode from the metadata response
+      # (493 => 0755) will be applied, resulting in "plugins were downloaded"
+      # message. Enforce a umask so the results are consistent.
+      Puppet::FileSystem.mkpath(Puppet[:pluginfactdest])
+      Puppet::FileSystem.chmod(0755, Puppet[:pluginfactdest])
+
+      app = Puppet::Application[:plugin]
+      app.command_line.args << 'download'
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(/No plugins downloaded/).to_stdout
+    end
+
+    it "updates the facts.d mode", unless: Puppet::Util::Platform.windows? do
+      Puppet::FileSystem.mkpath(Puppet[:pluginfactdest])
+      Puppet::FileSystem.chmod(0775, Puppet[:pluginfactdest])
+
+      app = Puppet::Application[:plugin]
+      app.command_line.args << 'download'
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(/Downloaded these plugins: .*facts\.d/).to_stdout
+    end
+  end
+end

data/spec/integration/application/resource_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+describe "puppet resource", unless: Puppet::Util::Platform.jruby? do
+  include PuppetSpec::Files
+
+  let(:resource) { Puppet::Application[:resource] }
+
+  context 'when given an invalid environment' do
+    before { Puppet[:environment] = 'badenv' }
+
+    it 'falls back to the default environment' do
+      Puppet[:log_level] = 'debug'
+
+      expect {
+        resource.run
+      }.to exit_with(1)
+       .and output(/Debug: Specified environment 'badenv' does not exist on the filesystem, defaulting to 'production'/).to_stdout
+       .and output(/Error: Could not run: You must specify the type to display/).to_stderr
+    end
+
+    it 'lists resources' do
+      resource.command_line.args = ['file', Puppet[:confdir]]
+
+      expect {
+        resource.run
+      }.to output(/file { '#{Puppet[:confdir]}':/).to_stdout
+    end
+
+    it 'lists types from the default environment' do
+      begin
+      modulepath = File.join(Puppet[:codedir], 'modules', 'test', 'lib', 'puppet', 'type')
+      FileUtils.mkdir_p(modulepath)
+      File.write(File.join(modulepath, 'test_resource_spec.rb'), 'Puppet::Type.newtype(:test_resource_spec)')
+      resource.command_line.args = ['--types']
+
+      expect {
+        resource.run
+      }.to exit_with(0).and output(/test_resource_spec/).to_stdout
+      ensure
+        Puppet::Type.rmtype(:test_resource_spec)
+      end
+    end
+  end
+
+
+  context 'when handling file and tidy types' do
+    let!(:dir) { dir_containing('testdir', 'testfile' => 'contents') }
+
+    it 'does not raise when generating file resources' do
+      resource.command_line.args = ['file', dir, 'ensure=directory', 'recurse=true']
+
+      expect {
+        resource.run
+      }.to output(/ensure.+=> 'directory'/).to_stdout
+    end
+
+    it 'correctly cleans up a given path' do
+      resource.command_line.args = ['tidy', dir, 'rmdirs=true', 'recurse=true']
+
+      expect {
+        resource.run
+      }.to output(/Notice: \/File\[#{dir}\]\/ensure: removed/).to_stdout
+
+      expect(Puppet::FileSystem.exist?(dir)).to be false
+    end
+  end
+end

data/spec/integration/application/ssl_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "puppet ssl", unless: Puppet::Util::Platform.jruby? do
+  context "print" do
+    it 'translates custom oids to their long name' do
+      basedir = File.expand_path("#{__FILE__}/../../../fixtures/ssl")
+      # registering custom oids changes global state, so shell out
+      output =
+        %x{puppet ssl show \
+           --certname oid \
+           --localcacert #{basedir}/ca.pem \
+           --hostcrl #{basedir}/crl.pem \
+           --hostprivkey #{basedir}/oid-key.pem \
+           --hostcert #{basedir}/oid.pem \
+           --trusted_oid_mapping_file #{basedir}/trusted_oid_mapping.yaml 2>&1
+        }
+      expect(output).to match(/Long name:/)
+    end
+  end
+end

data/spec/integration/configurer_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+require 'puppet_spec/network'
+require 'puppet/configurer'
+
+describe Puppet::Configurer do
+  include PuppetSpec::Files
+  include PuppetSpec::Network
+
+  describe "when running" do
+    before(:each) do
+      @catalog = Puppet::Resource::Catalog.new("testing", Puppet.lookup(:environments).get(Puppet[:environment]))
+      @catalog.add_resource(Puppet::Type.type(:notify).new(:title => "testing"))
+
+      # Make sure we don't try to persist the local state after the transaction ran,
+      # because it will fail during test (the state file is in a not-existing directory)
+      # and we need the transaction to be successful to be able to produce a summary report
+      @catalog.host_config = false
+
+      @configurer = Puppet::Configurer.new
+    end
+
+    it "should send a transaction report with valid data" do
+      allow(@configurer).to receive(:save_last_run_summary)
+      expect(Puppet::Transaction::Report.indirection).to receive(:save) do |report, x|
+        expect(report.time).to be_a(Time)
+        expect(report.logs.length).to be > 0
+      end.twice
+
+      Puppet[:report] = true
+
+      @configurer.run :catalog => @catalog
+    end
+
+    it "should save a correct last run summary" do
+      report = Puppet::Transaction::Report.new
+      allow(Puppet::Transaction::Report.indirection).to receive(:save)
+
+      Puppet[:lastrunfile] = tmpfile("lastrunfile")
+      Puppet.settings.setting(:lastrunfile).mode = 0666
+      Puppet[:report] = true
+
+      # We only record integer seconds in the timestamp, and truncate
+      # backwards, so don't use a more accurate timestamp in the test.
+      # --daniel 2011-03-07
+      t1 = Time.now.tv_sec
+      @configurer.run :catalog => @catalog, :report => report
+      t2 = Time.now.tv_sec
+
+      # sticky bit only applies to directories in windows
+      file_mode = Puppet::Util::Platform.windows? ? '666' : '100666'
+
+      expect(Puppet::FileSystem.stat(Puppet[:lastrunfile]).mode.to_s(8)).to eq(file_mode)
+
+      summary = Puppet::Util::Yaml.safe_load_file(Puppet[:lastrunfile])
+
+      expect(summary).to be_a(Hash)
+      %w{time changes events resources}.each do |key|
+        expect(summary).to be_key(key)
+      end
+      expect(summary["time"]).to be_key("notify")
+      expect(summary["time"]["last_run"]).to be_between(t1, t2)
+    end
+
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true and environment is valid" do
+      expect(@configurer).to receive(:valid_server_environment?).and_return(true)
+      Puppet[:ignore_plugin_errors] = false
+
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = true
+
+      report = Puppet::Transaction::Report.new
+      expect_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate).and_raise(Puppet::Error, 'Failed to retrieve: some file')
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
+
+      @configurer.run(pluginsync: true, report: report)
+      expect(report.cached_catalog_status).to eq('on_failure')
+    end
+
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true and environment is invalid" do
+      expect(@configurer).to receive(:valid_server_environment?).and_return(false)
+      Puppet[:ignore_plugin_errors] = false
+
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = true
+
+      report = Puppet::Transaction::Report.new
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_raise(Puppet::Error, 'Cannot compile remote catalog')
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
+
+      @configurer.run(pluginsync: true, report: report)
+      expect(report.cached_catalog_status).to eq('on_failure')
+    end
+
+    describe 'resubmitting facts' do
+      context 'when resubmit_facts is set to false' do
+        it 'should not send data' do
+          expect(@configurer).to receive(:resubmit_facts).never
+
+          @configurer.run(catalog: @catalog)
+        end
+      end
+
+      context 'when resubmit_facts is set to true' do
+        let(:test_facts) { Puppet::Node::Facts.new('configurer.test', {test_fact: 'test value'}) }
+
+        before(:each) do
+          Puppet[:resubmit_facts] = true
+
+          allow(@configurer).to receive(:find_facts).and_return(test_facts)
+        end
+
+        it 'uploads facts as application/json' do
+          stub_request(:put, "https://puppet:8140/puppet/v3/facts/configurer.test?environment=production").
+            with(
+              body: hash_including(
+                {
+                  "name" => "configurer.test",
+                  "values" => {"test_fact" => 'test value',},
+                }),
+              headers: {
+                'Accept'=>acceptable_content_types_string,
+                'Content-Type'=>'application/json',
+              })
+
+          @configurer.run(catalog: @catalog)
+        end
+
+        it 'logs errors that occur during fact generation' do
+          allow(@configurer).to receive(:find_facts).and_raise('error generating facts')
+          expect(Puppet).to receive(:log_exception).with(instance_of(RuntimeError),
+                                                         /^Failed to submit facts/)
+
+          @configurer.run(catalog: @catalog)
+        end
+
+        it 'logs errors that occur during fact submission' do
+          stub_request(:put, "https://puppet:8140/puppet/v3/facts/configurer.test?environment=production").to_return(status: 502)
+          expect(Puppet).to receive(:log_exception).with(Puppet::HTTP::ResponseError,
+                                                         /^Failed to submit facts/)
+
+          @configurer.run(catalog: @catalog)
+        end
+
+        it 'records time spent resubmitting facts' do
+          report = Puppet::Transaction::Report.new
+
+          stub_request(:put, "https://puppet:8140/puppet/v3/facts/configurer.test?environment=production").
+            with(
+              body: hash_including({
+                "name" => "configurer.test",
+                "values" => {"test_fact": "test value"},
+              }),
+              headers: {
+                'Accept'=>acceptable_content_types_string,
+                'Content-Type'=>'application/json',
+              }).to_return(status: 200)
+
+          @configurer.run(catalog: @catalog, report: report)
+
+          expect(report.metrics['time'].values).to include(["resubmit_facts", anything, Numeric])
+        end
+      end
+    end
+  end
+end