puppet 6.14.0-x64-mingw32 → 6.19.0-x64-mingw32

data/spec/integration/application/config_spec.rb

@@ -0,0 +1,74 @@
+# coding: utf-8
+require 'spec_helper'
+require 'puppet/application/config'
+
+#describe "puppet config" do
+describe Puppet::Face[:config, '0.0.1'] 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
+  MIXED_UTF8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ𠜎
+
+  let(:tmp_config) { tmpfile('puppet.conf') }
+  let(:config) { Puppet::Application[:config] }
+
+  def read_utf8(path)
+    File.read(tmp_config, :encoding => 'UTF-8')
+  end
+
+  def write_utf8(path, content)
+    File.write(tmp_config, content, 0, :encoding => 'UTF-8')
+  end
+
+  it "reads a UTF-8 value" do
+    write_utf8(tmp_config, <<~EOF)
+      [main]
+      tags=#{MIXED_UTF8}
+    EOF
+
+    Puppet.initialize_settings(['--config', tmp_config])
+    config.command_line.args = ['print', 'tags' ]
+
+    expect {
+      config.run
+    }.to exit_with(0)
+     .and output("#{MIXED_UTF8}\n").to_stdout
+  end
+
+  it "sets a UTF-8 value" do
+    Puppet.initialize_settings(['--config', tmp_config])
+    config.command_line.args = ['set', 'tags', MIXED_UTF8 ]
+
+    expect {
+      config.run
+    }.to exit_with(0)
+
+    expect(read_utf8(tmp_config)).to eq(<<~EOF)
+      [main]
+      tags = #{MIXED_UTF8}
+    EOF
+  end
+
+  it "deletes a key" do
+    write_utf8(tmp_config, <<~EOF)
+      [main]
+      tags=#{MIXED_UTF8}
+    EOF
+
+    Puppet.initialize_settings(['--config', tmp_config])
+    config.command_line.args = ['delete', 'tags']
+
+    expect {
+      config.run
+    }.to exit_with(0)
+     .and output(/Deleted setting from 'main': 'tags=#{MIXED_UTF8}'/).to_stdout
+
+    expect(read_utf8(tmp_config)).to eq(<<~EOF)
+      [main]
+    EOF
+  end
+end

data/spec/integration/application/doc_spec.rb

@@ -1,14 +1,24 @@
 require 'spec_helper'
-require 'puppet_spec/files'
 require 'puppet/application/doc'
 
 describe Puppet::Application::Doc do
   include PuppetSpec::Files
 
-  it "should respect the -o option" do
-    puppetdoc = Puppet::Application[:doc]
-    allow(puppetdoc.command_line).to receive(:args).and_return(['foo', '-o', 'bar'])
-    puppetdoc.parse_options
-    expect(puppetdoc.options[:outputdir]).to eq('bar')
+  let(:app) { Puppet::Application[:doc] }
+
+  it 'lists references' do
+    app.command_line.args = ['-l']
+    expect {
+      app.run
+    }.to exit_with(0)
+     .and output(/configuration - A reference for all settings/).to_stdout
+  end
+
+  it 'generates markdown' do
+    app.command_line.args = ['-r', 'report']
+    expect {
+      app.run
+    }.to exit_with(0)
+     .and output(/# Report Reference/).to_stdout
   end
 end

data/spec/integration/application/filebucket_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet_spec/puppetserver'
+require 'puppet_spec/files'
+
+describe "puppet filebucket", unless: Puppet::Util::Platform.jruby? do
+  include PuppetSpec::Files
+  include_context "https client"
+
+  let(:server) { PuppetSpec::Puppetserver.new }
+  let(:filebucket) { Puppet::Application[:filebucket] }
+  let(:backup_file) { tmpfile('backup_file') }
+  let(:text) { 'some random text' }
+  let(:md5) { Digest::MD5.file(backup_file).to_s }
+
+  before :each do
+    Puppet[:log_level] = 'debug'
+    File.binwrite(backup_file, text)
+  end
+
+  it "backs up to and restores from the local filebucket" do
+    filebucket.command_line.args = ['backup', backup_file, '--local']
+    expect {
+      filebucket.run
+    }.to output(/: #{md5}/).to_stdout
+
+    dest = tmpfile('file_bucket_restore')
+    filebucket.command_line.args = ['restore', dest, md5, '--local']
+    expect {
+      filebucket.run
+    }.to output(/FileBucket read #{md5}/).to_stdout
+
+    expect(FileUtils.compare_file(backup_file, dest)).to eq(true)
+  end
+
+  it "backs up text files to the filebucket server" do
+    server.start_server do |port|
+      Puppet[:serverport] = port
+      expect {
+        filebucket.command_line.args = ['backup', backup_file]
+        filebucket.run
+      }.to output(a_string_matching(
+        %r{Debug: HTTP HEAD https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file\/md5\/#{md5}\/#{File.realpath(backup_file)}\?environment\=production returned 404 Not Found}
+      ).and matching(
+        %r{Debug: HTTP PUT https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file\/md5\/#{md5}\/#{File.realpath(backup_file)}\?environment\=production returned 200 OK}
+      ).and matching(
+        %r{#{backup_file}: #{md5}}
+      )).to_stdout
+
+      expect(File.binread(File.join(server.upload_directory, 'filebucket'))).to eq(text)
+    end
+  end
+
+  it "backs up binary files to the filebucket server" do
+    binary = "\xD1\xF2\r\n\x81NuSc\x00".force_encoding(Encoding::ASCII_8BIT)
+    File.binwrite(backup_file, binary)
+
+    server.start_server do |port|
+      Puppet[:serverport] = port
+      expect {
+        filebucket.command_line.args = ['backup', backup_file]
+        filebucket.run
+      }.to output(a_string_matching(
+        %r{Debug: HTTP HEAD https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file/md5/b10778ecd8b08dff525e367cf15b2622/}
+      ).and matching(
+        %r{Debug: HTTP PUT https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file/md5/b10778ecd8b08dff525e367cf15b2622/}
+      )).to_stdout
+
+      expect(File.binread(File.join(server.upload_directory, 'filebucket'))).to eq(binary)
+    end
+  end
+
+  it "backs up utf-8 encoded files to the filebucket server" do
+    utf8 = "\u2603".force_encoding(Encoding::UTF_8)
+    File.binwrite(backup_file, utf8)
+
+    server.start_server do |port|
+      Puppet[:serverport] = port
+      expect {
+        filebucket.command_line.args = ['backup', backup_file]
+        filebucket.run
+      }.to output(a_string_matching(
+        %r{Debug: HTTP HEAD https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file/md5/48856faf4534a876adeadc72aec53cb2/}
+      ).and matching(
+        %r{Debug: HTTP PUT https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file/md5/48856faf4534a876adeadc72aec53cb2/}
+      )).to_stdout
+
+      expect(File.read(File.join(server.upload_directory, 'filebucket'), encoding: 'utf-8')).to eq(utf8)
+    end
+  end
+
+  it "doesn't attempt to back up file that already exists on the filebucket server" do
+    file_exists_handler = -> (req, res) {
+      res.status = 200
+    }
+
+    server.start_server(mounts: {filebucket: file_exists_handler}) do |port|
+      Puppet[:serverport] = port
+      expect {
+        filebucket.command_line.args = ['backup', backup_file]
+        filebucket.run
+      }.to output(a_string_matching(
+        %r{Debug: HTTP HEAD https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file\/md5\/#{md5}\/#{File.realpath(backup_file)}\?environment\=production returned 200 OK}
+      ).and matching(
+        %r{#{backup_file}: #{md5}}
+      )).to_stdout
+    end
+  end
+
+  it "downloads files from the filebucket server" do
+    get_handler = -> (req, res) {
+      res['Content-Type'] = 'application/octet-stream'
+      res.body = 'something to store'
+    }
+
+    server.start_server(mounts: {filebucket: get_handler}) do |port|
+      Puppet[:serverport] = port
+      expect {
+        filebucket.command_line.args = ['get', 'fac251367c9e083c6b1f0f3181']
+        filebucket.run
+      }.to output(a_string_matching(
+        %r{Debug: HTTP GET https:\/\/127.0.0.1:#{port}\/puppet\/v3\/file_bucket_file\/md5\/fac251367c9e083c6b1f0f3181\?environment\=production returned 200 OK}
+      ).and matching(
+        %r{something to store}
+       )).to_stdout
+    end
+  end
+
+  context 'diff', unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
+    context 'using a remote bucket' do
+      it 'outputs a diff between a local and remote file' do
+        File.binwrite(backup_file, "bar\nbaz")
+
+        get_handler = -> (req, res) {
+          res['Content-Type'] = 'application/octet-stream'
+          res.body = 'foo'
+        }
+
+        server.start_server(mounts: {filebucket: get_handler}) do |port|
+          Puppet[:serverport] = port
+          expect {
+            filebucket.command_line.args = ['diff', 'fac251367c9e083c6b1f0f3181', backup_file, '--remote']
+            filebucket.run
+          }.to output(a_string_matching(
+            /[-<] ?foo/
+          ).and matching(
+            /[+>] ?bar/
+          ).and matching(
+            /[+>] ?baz/
+          )).to_stdout
+        end
+      end
+
+      it 'outputs a diff between two remote files' do
+        get_handler = -> (req, res) {
+          res['Content-Type'] = 'application/octet-stream'
+          res.body = <<~END
+          --- /opt/puppetlabs/server/data/puppetserver/bucket/d/3/b/0/7/3/8/4/d3b07384d113edec49eaa6238ad5ff00/contents\t2020-04-06 21:25:24.892367570 +0000
+          +++ /opt/puppetlabs/server/data/puppetserver/bucket/9/9/b/9/9/9/2/0/99b999207e287afffc86c053e5693247/contents\t2020-04-06 21:26:13.603398063 +0000
+          @@ -1 +1,2 @@
+          -foo
+          +bar
+          +baz
+          END
+        }
+
+        server.start_server(mounts: {filebucket: get_handler}) do |port|
+          Puppet[:serverport] = port
+          expect {
+            filebucket.command_line.args = ['diff', 'd3b07384d113edec49eaa6238ad5ff00', "99b999207e287afffc86c053e5693247", '--remote']
+            filebucket.run
+          }.to output(a_string_matching(
+            /[-<] ?foo/
+          ).and matching(
+            /[+>] ?bar/
+          ).and matching(
+            /[+>] ?baz/
+          )).to_stdout
+        end
+      end
+    end
+
+    context 'using a local bucket' do
+      let(:filea) {
+        f = tmpfile('filea')
+        File.binwrite(f, 'foo')
+        f
+      }
+      let(:fileb) {
+        f = tmpfile('fileb')
+        File.binwrite(f, "bar\nbaz")
+        f
+      }
+      let(:checksuma) { Digest::MD5.file(filea).to_s }
+      let(:checksumb) { Digest::MD5.file(fileb).to_s }
+
+      it 'compares to files stored in a local bucket' do
+        expect {
+          filebucket.command_line.args = ['backup', filea, '--local']
+          filebucket.run
+        }.to output(/#{filea}: #{checksuma}/).to_stdout
+
+        expect{
+          filebucket.command_line.args = ['backup', fileb, '--local']
+          filebucket.run
+        }.to output(/#{fileb}: #{checksumb}\n/).to_stdout
+
+        expect {
+          filebucket.command_line.args = ['diff', checksuma, checksumb, '--local']
+          filebucket.run
+        }.to output(a_string_matching(
+          /[-<] ?foo/
+        ).and matching(
+          /[+>] ?bar/
+        ).and matching(
+          /[+>] ?baz/
+        )).to_stdout
+      end
+
+      it 'compares a file on the filesystem and a file stored in a local bucket' do
+        expect {
+          filebucket.command_line.args = ['backup', filea, '--local']
+          filebucket.run
+        }.to output(/#{filea}: #{checksuma}/).to_stdout
+
+        expect {
+          filebucket.command_line.args = ['diff', checksuma, fileb, '--local']
+          filebucket.run
+        }.to output(a_string_matching(
+          /[-<] ?foo/
+        ).and matching(
+          /[+>] ?bar/
+        ).and matching(
+          /[+>] ?baz/
+        )).to_stdout
+      end
+    end
+  end
+end

data/spec/integration/application/help_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'puppet/application/help'
+
+describe "puppet help" do
+  let(:app) { Puppet::Application[:help] }
+
+  it "generates global help" do
+    expect {
+      app.run
+    }.to exit_with(0)
+     .and output(Regexp.new(Regexp.escape(<<~END), Regexp::MULTILINE)).to_stdout
+
+       Usage: puppet <subcommand> [options] <action> [options]
+
+       Available subcommands:
+     END
+  end
+
+  Puppet::Face.faces.sort.each do |face_name|
+    context "for #{face_name}" do
+      it "generates help" do
+        app.command_line.args = ['help', face_name]
+
+        expect {
+          app.run
+        }.to exit_with(0)
+         .and output(/USAGE: puppet #{face_name} <action>/).to_stdout
+      end
+
+      Puppet::Face[face_name, :current].actions.sort.each do |action_name|
+        it "for action #{action_name}" do
+          app.command_line.args = ['help', face_name, action_name]
+
+          expect {
+            app.run
+          }.to exit_with(0)
+           .and output(/USAGE: puppet #{face_name}/).to_stdout
+        end
+      end
+    end
+  end
+end

data/spec/integration/application/lookup_spec.rb

@@ -90,6 +90,19 @@ describe 'lookup' do
       expect(lookup('a')).to eql('value a')
     end
 
+    it 'loads external facts when running without --node' do
+      expect(Puppet::Util).not_to receive(:skip_external_facts)
+      expect(Facter).not_to receive(:load_external)
+      lookup('a')
+    end
+
+    it 'skip loading of external facts when run with --node' do
+      app.options[:node] = "random_node"
+      expect(Facter).to receive(:load_external).once.with(false)
+      expect(Facter).to receive(:load_external).once.with(true)
+      lookup('a')
+    end
+
     context 'uses node_terminus' do
       require 'puppet/indirector/node/exec'
       require 'puppet/indirector/node/plain'

data/spec/integration/application/module_spec.rb

@@ -0,0 +1,68 @@
+# 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
+end