puppet 6.19.1-universal-darwin → 7.0.0-universal-darwin

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -18,7 +18,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
     describe "when servicing a save request" do
       it "should return a result whose content is empty" do
         bucket_file = Puppet::FileBucket::File.new('stuff')
-        result = Puppet::FileBucket::File.indirection.save(bucket_file, "md5/c13d88cb4cb02003daedb8a84e5d272a")
+        result = Puppet::FileBucket::File.indirection.save(bucket_file, "sha256/35bafb1ce99aef3ab068afbaabae8f21fd9b9f02d3a9442e364fa92c0b3eeef0")
         expect(result.contents).to be_empty
       end
 
@@ -34,12 +34,14 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
         children.each { |child| Process.wait(child) }
 
-        paths = File.read("#{Puppet[:bucketdir]}/9/8/b/f/7/d/8/c/98bf7d8c15784f0a3d63204441e1e2aa/paths").lines.to_a
+        paths = File.read("#{Puppet[:bucketdir]}/d/1/b/2/a/5/9/f/d1b2a59fbea7e20077af9f91b27e95e865061b270be03ff539ab3b73587882e8/paths").lines.to_a
         expect(paths.length).to eq(1)
         expect(Puppet::FileBucket::File.indirection.head("#{bucket_file.checksum_type}/#{bucket_file.checksum_data}/testing")).to be_truthy
       end
 
       it "fails if the contents collide with existing contents" do
+        Puppet[:digest_algorithm] = 'md5'
+
         # This is the shortest known MD5 collision (little endian). See https://eprint.iacr.org/2010/643.pdf
         first_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
                           0x6503cf04,0x854f709e,0xfb0fc034,0x874c9c65,
@@ -66,7 +68,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       context "when the contents file exists but is corrupted and does not match the expected checksum" do
         let(:original_contents) { "a file that will get corrupted" }
         let(:bucket_file) { Puppet::FileBucket::File.new(original_contents) }
-        let(:contents_file) { "#{Puppet[:bucketdir]}/8/e/6/4/f/8/5/d/8e64f85dd54a412f65edabcafe44d491/contents" }
+        let(:contents_file) { "#{Puppet[:bucketdir]}/7/7/4/1/0/2/7/9/77410279bb789b799c2f38bf654b46a509dd27ddad6e47a6684805e9ba390bce/contents" }
 
         before(:each) do
           # Ensure we're starting with a clean slate - no pre-existing backup

data/spec/unit/indirector/file_content/rest_spec.rb

@@ -57,8 +57,4 @@ describe Puppet::Indirector::FileContent::Rest do
 
     described_class.indirection.find("puppet://example.com:8140/:mount/path/to/file")
   end
-
-  it "should use the :fileserver SRV service" do
-    expect(Puppet::Indirector::FileContent::Rest.srv_service).to eq(:fileserver)
-  end
 end

data/spec/unit/indirector/file_metadata/rest_spec.rb

@@ -113,8 +113,4 @@ describe Puppet::Indirector::FileMetadata::Rest do
       model.indirection.search("puppet://example.com:8140/:mount/path/to/dir")
     end
   end
-
-  it "should use the :fileserver SRV service" do
-    expect(Puppet::Indirector::FileMetadata::Rest.srv_service).to eq(:fileserver)
-  end
 end

data/spec/unit/indirector/file_server_spec.rb

@@ -246,7 +246,7 @@ describe Puppet::Indirector::FileServer do
   end
 
   describe "when checking authorization" do
-    let(:mount) { double('mount', :empty? => nil, :globalallow? => nil) }
+    let(:mount) { double('mount') }
     let(:request) { Puppet::Indirector::Request.new(:myind, :mymethod, uri, :environment => "myenv") }
 
     before(:each) do
@@ -282,21 +282,7 @@ describe Puppet::Indirector::FileServer do
     end
 
     it "should return true when no auth directives are defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(true)
-      allow(mount).to receive(:globalallow?).and_return(nil)
       expect(terminus).to be_authorized(request)
     end
-
-    it "should return true when a global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(true)
-      expect(terminus).to be_authorized(request)
-    end
-
-    it "should return false when a non-global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(false)
-      expect(terminus).not_to be_authorized(request)
-    end
   end
 end

data/spec/unit/indirector/node/json_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'puppet/node'
+require 'puppet/indirector/node/json'
+
+describe Puppet::Node::Json do
+  describe '#save' do
+    subject(:indirection) { described_class.indirection }
+
+    let(:env) { Puppet::Node::Environment.create(:testing, []) }
+    let(:node) { Puppet::Node.new('node_name', :environment => env) }
+    let(:file) { File.join(Puppet[:client_datadir], "node", "node_name.json") }
+
+    before do
+      indirection.terminus_class = :json
+    end
+
+    it 'saves the instance of the node as JSON to disk' do
+      indirection.save(node)
+      json = Puppet::FileSystem.read(file, :encoding => 'bom|utf-8')
+      content = Puppet::Util::Json.load(json)
+      expect(content["name"]).to eq('node_name')
+    end
+
+    context 'when node cannot be saved' do
+      it 'raises Errno::EISDIR' do
+        FileUtils.mkdir_p(file)
+        expect {
+          indirection.save(node)
+         }.to raise_error(Errno::EISDIR, /node_name.json/)
+      end
+    end
+  end
+end

data/spec/{integration/indirector/report/yaml.rb → unit/indirector/report/json_spec.rb}

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 require 'puppet/transaction/report'
-require 'puppet/indirector/report/yaml'
+require 'puppet/indirector/report/json'
 
-describe Puppet::Transaction::Report::Yaml do
+describe Puppet::Transaction::Report::Json do
+  include PuppetSpec::Files
   describe '#save' do
     subject(:indirection) { described_class.indirection }
 
@@ -17,19 +18,17 @@ describe Puppet::Transaction::Report::Yaml do
     let(:file) { request.path(:me) }
 
     before do
-      indirection.terminus_class = :yaml
-    end
+      Puppet[:lastrunreport] = File.join(Puppet[:statedir], "last_run_report.json")
 
-    it 'is saves a report' do
-      indirection.save(report)
+      indirection.terminus_class = :json
     end
 
-    it 'saves the instance of the report as YAML to disk' do
+    it 'saves the instance of the report as JSON to disk' do
+
       indirection.save(report)
-      content = Puppet::Util::Yaml.safe_load_file(
-        Puppet[:lastrunreport], [Puppet::Transaction::Report]
-      )
-      expect(content.host).to eq(certname)
+      json = Puppet::FileSystem.read(Puppet[:lastrunreport], :encoding => 'bom|utf-8')
+      content = Puppet::Util::Json.load(json)
+      expect(content["host"]).to eq(certname)
     end
 
     it 'allows mode overwrite' do
@@ -37,8 +36,7 @@ describe Puppet::Transaction::Report::Yaml do
       indirection.save(report)
 
       if Puppet::Util::Platform.windows?
-        require 'puppet/util/windows/security'
-        mode = Puppet::Util::Windows::Security.get_mode(file)
+        mode = File.stat(file).mode
       else
         mode = Puppet::FileSystem.stat(file).mode
       end
@@ -62,21 +60,12 @@ describe Puppet::Transaction::Report::Yaml do
       end
     end
 
-    context 'when repport is invalid' do
-      it 'logs error' do
-        expect(Puppet).to receive(:send_log).with(:err, /Could not save yaml ziggy: can't dump anonymous class/)
-
-        report.configuration_version = Class.new
-        indirection.save(report)
-      end
-    end
-
     context 'when report cannot be saved' do
-      it 'raises Errno::EISDIR' do
+      it 'raises Error' do
         FileUtils.mkdir_p(file)
         expect {
           indirection.save(report)
-         }.to raise_error(Errno::EISDIR, /last_run_report.yaml/)
+         }.to raise_error(Errno::EISDIR, /last_run_report.json/)
       end
     end
   end

data/spec/unit/indirector/report/rest_spec.rb

@@ -20,21 +20,6 @@ describe Puppet::Transaction::Report::Rest do
     { body: formatter.render(["store", "http"]), headers: {'Content-Type' => formatter.mime } }
   end
 
-  it "should use the :report_server setting in preference to :server" do
-    Puppet.settings[:server] = "server"
-    Puppet.settings[:report_server] = "report_server"
-    expect(Puppet::Transaction::Report::Rest.server).to eq("report_server")
-  end
-
-  it "should have a value for report_server and report_port" do
-    expect(Puppet::Transaction::Report::Rest.server).not_to be_nil
-    expect(Puppet::Transaction::Report::Rest.port).not_to be_nil
-  end
-
-  it "should use the :report SRV service" do
-    expect(Puppet::Transaction::Report::Rest.srv_service).to eq(:report)
-  end
-
   it "saves a report " do
     stub_request(:put, uri)
       .to_return(status: 200, **report_response)
@@ -77,7 +62,7 @@ describe Puppet::Transaction::Report::Rest do
 
       stub_request(:put, uri)
         .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
+                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
       expect {
         described_class.indirection.save(report)
@@ -89,7 +74,7 @@ describe Puppet::Transaction::Report::Rest do
 
       stub_request(:put, uri)
         .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
+                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
       expect {
         described_class.indirection.save(report)

data/spec/unit/indirector/report/yaml_spec.rb

@@ -4,14 +4,6 @@ require 'puppet/transaction/report'
 require 'puppet/indirector/report/yaml'
 
 describe Puppet::Transaction::Report::Yaml do
-  it "should be a subclass of the Yaml terminus" do
-    expect(Puppet::Transaction::Report::Yaml.superclass).to equal(Puppet::Indirector::Yaml)
-  end
-
-  it "should have documentation" do
-    expect(Puppet::Transaction::Report::Yaml.doc).not_to be_nil
-  end
-
   it "should be registered with the report indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:report)
     expect(Puppet::Transaction::Report::Yaml.indirection).to equal(indirection)
@@ -24,4 +16,76 @@ describe Puppet::Transaction::Report::Yaml do
   it "should unconditionally save/load from the --lastrunreport setting" do
     expect(subject.path(:me)).to eq(Puppet[:lastrunreport])
   end
+
+  describe '#save' do
+    subject(:indirection) { described_class.indirection }
+
+    let(:request) { described_class.new }
+    let(:certname) { 'ziggy' }
+    let(:report) do
+      report = Puppet::Transaction::Report.new
+      report.host = certname
+      report
+    end
+    let(:file) { request.path(:me) }
+
+    before do
+      indirection.terminus_class = :yaml
+    end
+
+    it 'saves the instance of the report as YAML to disk' do
+      indirection.save(report)
+      content = Puppet::Util::Yaml.safe_load_file(
+        Puppet[:lastrunreport], [Puppet::Transaction::Report]
+      )
+      expect(content.host).to eq(certname)
+    end
+
+    it 'allows mode overwrite' do
+      Puppet.settings.setting(:lastrunreport).mode = '0644'
+      indirection.save(report)
+
+      if Puppet::Util::Platform.windows?
+        mode = File.stat(file).mode
+      else
+        mode = Puppet::FileSystem.stat(file).mode
+      end
+
+      expect(mode & 07777).to eq(0644)
+    end
+
+    context 'when mode is invalid' do
+      before do
+        Puppet.settings.setting(:lastrunreport).mode = '9999'
+      end
+
+      after do
+        Puppet.settings.setting(:lastrunreport).mode = '0644'
+      end
+
+      it 'raises Puppet::DevError ' do
+        expect{
+          indirection.save(report)
+        }.to raise_error(Puppet::DevError, "replace_file mode: 9999 is invalid")
+      end
+    end
+
+    context 'when repport is invalid' do
+      it 'logs error' do
+        expect(Puppet).to receive(:send_log).with(:err, /Could not save yaml ziggy: can't dump anonymous class/)
+
+        report.configuration_version = Class.new
+        indirection.save(report)
+      end
+    end
+
+    context 'when report cannot be saved' do
+      it 'raises Error' do
+        FileUtils.mkdir_p(file)
+        expect {
+          indirection.save(report)
+        }.to raise_error(Errno::EISDIR, /last_run_report.yaml/)
+      end
+    end
+  end
 end

data/spec/unit/indirector/request_spec.rb

@@ -271,229 +271,6 @@ describe Puppet::Indirector::Request do
     expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node]).to eq('foo')
   end
 
-  describe "when building a query string from its options" do
-    def a_request_with_options(options)
-      Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
-    end
-
-    def the_parsed_query_string_from(request)
-      CGI.parse(request.query_string.sub(/^\?/, ''))
-    end
-
-    it "should return an empty query string if there are no options" do
-      request = a_request_with_options(nil)
-
-      expect(request.query_string).to eq("")
-    end
-
-    it "should return an empty query string if the options are empty" do
-      request = a_request_with_options({})
-
-      expect(request.query_string).to eq("")
-    end
-
-    it "should include all options in the query string, separated by '&'" do
-      request = a_request_with_options(:one => "two", :three => "four")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["two"],
-        "three" => ["four"]
-      })
-    end
-
-    it "should ignore nil options" do
-      request = a_request_with_options(:one => "two", :three => nil)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["two"]
-      })
-    end
-
-    it "should convert 'true' option values into strings" do
-      request = a_request_with_options(:one => true)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["true"]
-      })
-    end
-
-    it "should convert 'false' option values into strings" do
-      request = a_request_with_options(:one => false)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["false"]
-      })
-    end
-
-    it "should convert to a string all option values that are integers" do
-      request = a_request_with_options(:one => 50)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["50"]
-      })
-    end
-
-    it "should convert to a string all option values that are floating point numbers" do
-      request = a_request_with_options(:one => 1.2)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["1.2"]
-      })
-    end
-
-    it "should CGI-escape all option values that are strings" do
-      request = a_request_with_options(:one => "one two")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one two"]
-      })
-    end
-
-    it "should convert an array of values into multiple entries for the same key" do
-      request = a_request_with_options(:one => %w{one two})
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one", "two"]
-      })
-    end
-
-    it "should stringify simple data types inside an array" do
-      request = a_request_with_options(:one => ['one', nil])
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one"]
-      })
-    end
-
-    it "should error if an array contains another array" do
-      request = a_request_with_options(:one => ['one', ["not allowed"]])
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-
-    it "should error if an array contains illegal data" do
-      request = a_request_with_options(:one => ['one', { :not => "allowed" }])
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-
-    it "should convert to a string and CGI-escape all option values that are symbols" do
-      request = a_request_with_options(:one => :"sym bol")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["sym bol"]
-      })
-    end
-
-    it "should fail if options other than booleans or strings are provided" do
-      request = a_request_with_options(:one => { :one => :two })
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-  end
-
-  context '#do_request' do
-    before :each do
-      @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
-    end
-
-    context 'when not using SRV records' do
-      before :each do
-        Puppet.settings[:use_srv_records] = false
-      end
-
-      it "yields the request with the default server and port when no server or port were specified on the original request" do
-        count = 0
-        rval = @request.do_request(:puppet, 'puppet.example.com', '90210') do |got|
-          count += 1
-          expect(got.server).to eq('puppet.example.com')
-          expect(got.port).to   eq('90210')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-
-        expect(rval).to eq('Block return value')
-      end
-    end
-
-    context 'when using SRV records' do
-      before :each do
-        Puppet.settings[:use_srv_records] = true
-        Puppet.settings[:srv_domain]      = 'example.com'
-      end
-
-      it "yields the request with the original server and port unmodified" do
-        @request.server = 'puppet.example.com'
-        @request.port   = '90210'
-
-        count = 0
-        rval = @request.do_request do |got|
-          count += 1
-          expect(got.server).to eq('puppet.example.com')
-          expect(got.port).to   eq('90210')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-
-        expect(rval).to eq('Block return value')
-      end
-
-      context "when SRV returns servers" do
-        before :each do
-          @dns_mock = double('dns')
-          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
-
-          @port = 7205
-          @target = 'example.com'
-          record = Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @target)
-          record.instance_variable_set(:@ttl, 10)
-          @srv_records = [record]
-
-          expect(@dns_mock).to receive(:getresources).
-            with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
-            and_return(@srv_records)
-        end
-
-        it "yields a request using the server and port from the SRV record" do
-          count = 0
-          rval = @request.do_request do |got|
-            count += 1
-            expect(got.server).to eq('example.com')
-            expect(got.port).to eq(7205)
-
-            @block_return
-          end
-          expect(count).to eq(1)
-
-          expect(rval).to eq(@block_return)
-        end
-
-        it "should fall back to the default server when the block raises a SystemCallError" do
-          count = 0
-          second_pass = nil
-
-          rval = @request.do_request(:puppet, 'puppet', 8140) do |got|
-            count += 1
-
-            if got.server == 'example.com' then
-              raise SystemCallError, "example failure"
-            else
-              second_pass = got
-            end
-
-            @block_return
-          end
-
-          expect(second_pass.server).to eq('puppet')
-          expect(second_pass.port).to   eq(8140)
-          expect(count).to eq(2)
-
-          expect(rval).to eq(@block_return)
-        end
-      end
-    end
-  end
-
   describe "#remote?" do
     def request(options = {})
       Puppet::Indirector::Request.new('node', 'find', 'localhost', nil, options)
@@ -515,45 +292,4 @@ describe Puppet::Indirector::Request do
       expect(request(:node => 'example.com', :ip => '127.0.0.1')).to be_remote
     end
   end
-
-  describe "failover" do
-    it "should use the provided failover host and port" do
-      Puppet.override(:server => 'myhost', :serverport => 666) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to eq('myhost')
-          expect(request.port).to eq(666)
-        end
-      end
-    end
-
-    it "should not use raw settings when failover fails" do
-      Puppet.override(:server => nil, :serverport => nil) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to be_nil
-          expect(request.port).to be_nil
-          expect(Puppet.settings[:server]).not_to be_nil
-          expect(Puppet.settings[:serverport]).not_to be_nil
-        end
-      end
-    end
-
-    it "should use server_list when set and failover has not occured" do
-      Puppet.settings[:server_list] = [['myhost',666]]
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq('myhost')
-        expect(request.port).to eq(666)
-      end
-    end
-
-    it "should use server when server_list is not set" do
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq(Puppet.settings[:server])
-        expect(request.port).to eq(Puppet.settings[:serverport])
-      end
-    end
-  end
 end