puppet 6.18.0-universal-darwin → 6.21.1-universal-darwin

data/spec/unit/face/config_spec.rb

@@ -138,7 +138,7 @@ trace = true
       Puppet[:log_level] = 'info'
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
       expect {
-        subject.set('foo', 'bar')
+        subject.set('certname', 'bar')
       }.to output("\e[1;33mResolving settings from section 'main' in environment 'production'\e[0m\n").to_stderr
     end
 
@@ -146,19 +146,19 @@ trace = true
       Puppet[:log_level] = 'info'
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
       expect {
-        subject.set('foo', 'bar', {:section => "baz"})
+        subject.set('certname', 'bar', {:section => "baz"})
       }.to output("\e[1;33mResolving settings from section 'baz' in environment 'production'\e[0m\n").to_stderr
     end
 
     it "writes to the correct puppet config file" do
       expect(Puppet::FileSystem).to receive(:open).with(path, anything, anything)
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
     end
 
     it "creates a config file if one does not exist" do
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
       expect(Puppet::FileSystem).to receive(:touch).with(path)
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
     end
 
     it "sets the supplied config/value in the default section (main)" do
@@ -167,8 +167,8 @@ trace = true
       manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
       allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
 
-      expect(manipulator).to receive(:set).with("main", "foo", "bar")
-      subject.set('foo', 'bar')
+      expect(manipulator).to receive(:set).with("main", "certname", "bar")
+      subject.set('certname', 'bar')
     end
 
     it "sets the value in the supplied section" do
@@ -177,8 +177,8 @@ trace = true
       manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
       allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
 
-      expect(manipulator).to receive(:set).with("baz", "foo", "bar")
-      subject.set('foo', 'bar', {:section => "baz"})
+      expect(manipulator).to receive(:set).with("baz", "certname", "bar")
+      subject.set('certname', 'bar', {:section => "baz"})
     end
 
     it "does not duplicate an existing default section when a section is not specified" do
@@ -190,15 +190,48 @@ trace = true
       myfile = StringIO.new(contents)
       allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myfile)
 
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
 
-      expect(myfile.string).to match(/foo = bar/)
+      expect(myfile.string).to match(/certname = bar/)
       expect(myfile.string).not_to match(/main.*main/)
     end
 
     it "opens the file with UTF-8 encoding" do
       expect(Puppet::FileSystem).to receive(:open).with(path, nil, 'r+:UTF-8')
-      subject.set('foo', 'bar')
+      subject.set('certname', 'bar')
+    end
+
+    it "sets settings into the [server] section when setting [master] section settings" do
+      initial_contents = <<~CONFIG
+        [master]
+        node_terminus = none
+        reports = log
+      CONFIG
+
+      myinitialfile = StringIO.new(initial_contents)
+      allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myinitialfile)
+
+      expect {
+        subject.set('node_terminus', 'exec', {:section => 'master'})
+      }.to output("Deleted setting from 'master': 'node_terminus = none', and adding it to 'server' section\n").to_stdout
+
+      expect(myinitialfile.string).to match(<<~CONFIG)
+        [master]
+        reports = log
+        [server]
+        node_terminus = exec
+      CONFIG
+    end
+
+    it "setting [master] section settings, sets settings into [server] section instead" do
+      myinitialfile = StringIO.new("")
+      allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myinitialfile)
+      subject.set('node_terminus', 'exec', {:section => 'master'})
+
+      expect(myinitialfile.string).to match(<<~CONFIG)
+        [server]
+        node_terminus = exec
+      CONFIG
     end
   end
 
@@ -249,6 +282,24 @@ trace = true
       expect(Puppet).to receive(:warning).with("No setting found in configuration file for section 'main' setting name 'setting'")
       subject.delete('setting', {:section => 'main'})
     end
+
+    ['master', 'server'].each do |section|
+      describe "when deleting from [#{section}] section" do
+        it "deletes section values from both [server] and [master] sections" do
+          allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
+          config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+          manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+          allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
+
+          expect(manipulator).to receive(:delete).with('master', 'setting').and_return('setting=value')
+          expect(manipulator).to receive(:delete).with('server', 'setting').and_return('setting=value')
+          expect {
+            subject.delete('setting', {:section => section})
+          }.to output(/Deleted setting from 'master': 'setting'\nDeleted setting from 'server': 'setting'\n/).to_stdout
+        end
+      end
+    end
+
   end
 
   shared_examples_for :config_printing_a_section do |section|

data/spec/unit/face/node_spec.rb

@@ -15,13 +15,6 @@ describe Puppet::Face[:node, '0.0.1'] do
   end
 
   describe 'when running #clean' do
-    before :each do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
-      allow(Puppet::Node).to receive(:terminus_class=)
-      allow(Puppet::Node).to receive(:cache_class=)
-    end
-
     it 'should invoke #cleanup' do
       expect(subject).to receive(:cleanup).with('hostname')
       subject.clean('hostname')
@@ -30,10 +23,6 @@ describe Puppet::Face[:node, '0.0.1'] do
 
   describe "clean action" do
     before :each do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
-      allow(Puppet::Node).to receive(:terminus_class=)
-      allow(Puppet::Node).to receive(:cache_class=)
       allow(subject).to receive(:cleanup)
     end
 
@@ -74,9 +63,9 @@ describe Puppet::Face[:node, '0.0.1'] do
           subject.clean('hostname')
         end
 
-        it "should run in master mode" do
+        it "should run in server mode" do
           subject.clean('hostname')
-          expect(Puppet.run_mode).to be_master
+          expect(Puppet.run_mode).to be_server
         end
 
         it "should set node cache as yaml" do

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -87,7 +87,6 @@ describe Puppet::FileServing::Configuration::Parser do
     before do
       @mount = double('testmount', :name => "one", :validate => true)
       expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(@mount)
-      allow(@parser).to receive(:add_modules_mount)
     end
 
     it "should set the mount path to the path attribute from that section" do

data/spec/unit/file_serving/metadata_spec.rb

@@ -266,9 +266,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('bar')
       FileUtils.touch(path)
 
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path, :use).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path).and_raise(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -2,13 +2,20 @@ require 'spec_helper'
 
 require 'puppet/file_serving/terminus_helper'
 
+class Puppet::FileServing::TestHelper
+  include Puppet::FileServing::TerminusHelper
+
+  attr_reader :model
+
+  def initialize(model)
+    @model = model
+  end
+end
+
 describe Puppet::FileServing::TerminusHelper do
   before do
-    @helper = Object.new
-    @helper.extend(Puppet::FileServing::TerminusHelper)
-
     @model = double('model')
-    allow(@helper).to receive(:model).and_return(@model)
+    @helper = Puppet::FileServing::TestHelper.new(@model)
 
     @request = double('request', :key => "url", :options => {})
 

data/spec/unit/file_system_spec.rb

@@ -872,8 +872,7 @@ describe "Puppet::FileSystem" do
 
             # regardless of slash direction, return value is drive letter
             expanded = Puppet::FileSystem.expand_path(slash)
-            expect(expanded).to eq(ENV['SystemDrive'] + File::SEPARATOR)
-            expect(expanded).to eq(File.expand_path(slash))
+            expect(expanded).to match(/^[a-z]:/i)
           end
         end
 

data/spec/unit/forge/module_release_spec.rb

@@ -22,13 +22,8 @@ describe Puppet::Forge::ModuleRelease do
   let(:uri) { " "}
   let(:release) { Puppet::Forge::ModuleRelease.new(ssl_repository, JSON.parse(release_json)) }
 
-  let(:mock_file) {
-    mock_io = StringIO.new
-    allow(mock_io).to receive(:path).and_return('/dev/null')
-    mock_io
-  }
-
-  let(:mock_dir) { '/tmp' }
+  let(:mock_file) { double('file', path: '/dev/null') }
+  let(:mock_dir) { tmpdir('dir') }
 
   let(:destination) { tmpfile('forge_module_release') }
 

data/spec/unit/functions/inline_epp_spec.rb

@@ -1,8 +1,10 @@
-
 require 'spec_helper'
 
+require 'puppet_spec/compiler'
+
 describe "the inline_epp function" do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
@@ -73,6 +75,29 @@ describe "the inline_epp function" do
     expect(eval_template("string was: <%= $string %>")).to eq("string was: the string value")
   end
 
+  context "when using Sensitive" do
+    it "returns an unwrapped sensitive value as a String" do
+      expect(eval_and_collect_notices(<<~END)).to eq(["opensesame"])
+        notice(inline_epp("<%= Sensitive('opensesame').unwrap %>"))
+      END
+    end
+
+    it "rewraps a sensitive value" do
+      # note entire result is redacted, not just sensitive part
+      expect(eval_and_collect_notices(<<~END)).to eq(["Sensitive [value redacted]"])
+        notice(inline_epp("This is sensitive <%= Sensitive('opensesame') %>"))
+      END
+    end
+
+    it "can be double wrapped" do
+      catalog = compile_to_catalog(<<~END)
+        notify { 'title':
+          message => Sensitive(inline_epp("<%= Sensitive('opensesame') %>"))
+        }
+      END
+      expect(catalog.resource(:notify, 'title')['message']).to eq('opensesame')
+    end
+  end
 
   def eval_template_with_args(content, args_hash)
     epp_function.call(scope, content, args_hash)

data/spec/unit/http/resolver_spec.rb

@@ -43,9 +43,25 @@ describe Puppet::HTTP::Resolver do
       expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
     end
 
-    it 'logs unsuccessful HTTP 500 responses' do
-      Puppet[:log_level] = "debug"
+    it 'includes extra http headers' do
+      Puppet[:http_extra_headers] = 'region:us-west'
+
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master")
+        .with(headers: {'Region' => 'us-west'})
+
+      subject.resolve(session, :ca)
+    end
+
+    it 'uses the provided ssl context during resolution' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 200)
+
+      other_ctx = Puppet::SSL::SSLContext.new
+      expect(client).to receive(:connect).with(URI("https://ca.example.com:8141/status/v1/simple/master"), options: {ssl_context: other_ctx}).and_call_original
+
+      subject.resolve(session, :ca, ssl_context: other_ctx)
+    end
 
+    it 'logs unsuccessful HTTP 500 responses' do
       stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: [500, 'Internal Server Error'])
       stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 200)
 
@@ -54,11 +70,15 @@ describe Puppet::HTTP::Resolver do
       expect(@logs.map(&:message)).to include(/Puppet server ca.example.com:8141 is unavailable: 500 Internal Server Error/)
     end
 
-    it 'fails if no servers in server_list are accessible' do
+    it 'cancels resolution if no servers in server_list are accessible' do
       stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 503)
       stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 503)
 
-      expect { subject.resolve(session, :ca) }.to raise_error(Puppet::Error, /^Could not select a functional puppet master from server_list:/)
+      canceled = false
+      canceled_handler = lambda { |cancel| canceled = cancel }
+
+      expect(subject.resolve(session, :ca, canceled_handler: canceled_handler)).to eq(nil)
+      expect(canceled).to eq(true)
     end
 
     it 'cycles through server_list until a valid server is found' do

data/spec/unit/http/service/ca_spec.rb

@@ -38,11 +38,11 @@ describe Puppet::HTTP::Service::Ca do
       subject.get_certificate('ca')
     end
 
-    it 'fallbacks to server and masterport' do
+    it 'fallbacks to server and serverport' do
       Puppet[:ca_server] = nil
       Puppet[:ca_port] = nil
       Puppet[:server] = 'ca2.example.com'
-      Puppet[:masterport] = 8142
+      Puppet[:serverport] = 8142
 
       stub_request(:get, "https://ca2.example.com:8142/puppet-ca/v1/certificate/ca").to_return(body: pem)
 

data/spec/unit/http/service/compiler_spec.rb

@@ -16,7 +16,7 @@ describe Puppet::HTTP::Service::Compiler do
 
   before :each do
     Puppet[:server] = 'compiler.example.com'
-    Puppet[:masterport] = 8140
+    Puppet[:serverport] = 8140
 
     Puppet::Node::Facts.indirection.terminus_class = :memory
   end
@@ -37,7 +37,7 @@ describe Puppet::HTTP::Service::Compiler do
   context 'when routing to the compiler service' do
     it 'defaults the server and port based on settings' do
       Puppet[:server] = 'compiler2.example.com'
-      Puppet[:masterport] = 8141
+      Puppet[:serverport] = 8141
 
       stub_request(:post, "https://compiler2.example.com:8141/puppet/v3/catalog/ziggy?environment=testing")
         .to_return(body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime })
@@ -131,6 +131,26 @@ describe Puppet::HTTP::Service::Compiler do
       subject.post_catalog(certname, environment: 'production', facts: facts, checksum_type: %w[sha256 sha384])
     end
 
+    it 'does not accept msgpack by default' do
+      stub_request(:post, uri)
+        .with(headers: {'Accept' => 'application/vnd.puppet.rich+json, application/json, text/pson'})
+        .to_return(**catalog_response)
+
+      allow(Puppet.features).to receive(:msgpack?).and_return(false)
+
+      subject.post_catalog(certname, environment: environment, facts: facts)
+    end
+
+    it 'accepts msgpack & rich_json_msgpack if the gem is present' do
+      stub_request(:post, uri)
+        .with(headers: {'Accept' => 'application/vnd.puppet.rich+json, application/json, application/vnd.puppet.rich+msgpack, application/x-msgpack, text/pson'})
+        .to_return(**catalog_response)
+
+      allow(Puppet.features).to receive(:msgpack?).and_return(true)
+
+      subject.post_catalog(certname, environment: environment, facts: facts)
+    end
+
     it 'returns a deserialized catalog' do
       stub_request(:post, uri)
         .to_return(**catalog_response)
@@ -140,6 +160,35 @@ describe Puppet::HTTP::Service::Compiler do
       expect(cat.name).to eq(certname)
     end
 
+    it 'deserializes the catalog from msgpack', if: Puppet.features.msgpack? do
+      body = catalog.to_msgpack
+      formatter = Puppet::Network::FormatHandler.format(:msgpack)
+      catalog_response = { body: body, headers: {'Content-Type' => formatter.mime }}
+
+      stub_request(:post, uri)
+        .to_return(**catalog_response)
+
+      _, cat = subject.post_catalog(certname, environment: 'production', facts: facts)
+      expect(cat).to be_a(Puppet::Resource::Catalog)
+      expect(cat.name).to eq(certname)
+    end
+
+    it 'deserializes the catalog from rich msgpack', if: Puppet.features.msgpack? do
+      body = Puppet.override(rich_data: true) do
+        catalog.to_msgpack
+      end
+
+      formatter = Puppet::Network::FormatHandler.format(:rich_data_msgpack)
+      catalog_response = { body: body, headers: {'Content-Type' => formatter.mime }}
+
+      stub_request(:post, uri)
+        .to_return(**catalog_response)
+
+      _, cat = subject.post_catalog(certname, environment: 'production', facts: facts)
+      expect(cat).to be_a(Puppet::Resource::Catalog)
+      expect(cat.name).to eq(certname)
+    end
+
     it 'returns the request response' do
       stub_request(:post, uri)
         .to_return(**catalog_response)

data/spec/unit/http/service/file_server_spec.rb

@@ -12,7 +12,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   before :each do
     Puppet[:server] = 'www.example.com'
-    Puppet[:masterport] = 443
+    Puppet[:serverport] = 443
   end
 
   context 'when making requests' do
@@ -31,7 +31,7 @@ describe Puppet::HTTP::Service::FileServer do
   context 'when routing to the file service' do
     it 'defaults the server and port based on settings' do
       Puppet[:server] = 'file.example.com'
-      Puppet[:masterport] = 8141
+      Puppet[:serverport] = 8141
 
       stub_request(:get, "https://file.example.com:8141/puppet/v3/file_content/:mount/:path?environment=testing")
 

data/spec/unit/http/service/puppetserver_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'puppet/http'
+
+describe Puppet::HTTP::Service::Puppetserver do
+  let(:ssl_context) { Puppet::SSL::SSLContext.new }
+  let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
+  let(:subject) { client.create_session.route_to(:puppetserver) }
+
+  before :each do
+    Puppet[:server] = 'puppetserver.example.com'
+  end
+
+  context 'when making requests' do
+    it 'includes default HTTP headers' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master").with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end.to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+
+    it 'includes extra headers' do
+      Puppet[:http_extra_headers] = 'region:us-west'
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+        .with(headers: {'Region' => 'us-west'})
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when routing to the puppetserver service' do
+    it 'defaults the server and port based on settings' do
+      Puppet[:server] = 'compiler2.example.com'
+      Puppet[:serverport] = 8141
+
+      stub_request(:get, "https://compiler2.example.com:8141/status/v1/simple/master")
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when getting puppetserver status' do
+    let(:url) { "https://puppetserver.example.com:8140/status/v1/simple/master" }
+
+    it 'returns the request response and status' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      resp, status = subject.get_simple_status
+      expect(resp).to be_a(Puppet::HTTP::Response)
+      expect(status).to eq('running')
+    end
+
+    it 'raises a response error if unsuccessful' do
+      stub_request(:get, url).to_return(status: [500, 'Internal Server Error'])
+
+      expect {
+        subject.get_simple_status
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq("Internal Server Error")
+        expect(err.response.code).to eq(500)
+      end
+    end
+
+    it 'accepts an ssl context' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      other_ctx = Puppet::SSL::SSLContext.new
+      expect(client).to receive(:connect).with(URI(url), options: {ssl_context: other_ctx}).and_call_original
+
+      session = client.create_session
+      service = Puppet::HTTP::Service.create_service(client, session, :puppetserver, 'puppetserver.example.com', 8140)
+      service.get_simple_status(ssl_context: other_ctx)
+    end
+  end
+end