puppet 6.19.0 → 6.22.1

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_spec.rb

@@ -112,8 +112,8 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 
   it "should pass any provided options to the indirection during initialization" do
-    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
-    @indirection = @thingie.indirects :first, :some => :options
+    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:doc => 'some docs', :indirected_class => 'Thingie'})
+    @indirection = @thingie.indirects :first, :doc => 'some docs'
   end
 
   it "should extend the class to handle serialization" do

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -247,6 +247,21 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :success
           graph_should_include 'pmtacceptance-mysql', nil => v('0.8.0')
         end
+
+        context 'with an already installed dependency' do
+          before { preinstall('pmtacceptance-stdlib', '2.6.0') }
+
+          def options
+            super.merge(:version => '0.7.0')
+          end
+
+          it 'installs given version without errors and does not change version of dependency' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-mysql', nil => v('0.7.0')
+            expect(subject[:error]).to be_nil
+            graph_should_include 'pmtacceptance-stdlib', v('2.6.0') => v('2.6.0')
+          end
+        end
       end
 
       context 'with a --version that cannot satisfy' do
@@ -258,6 +273,20 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :failure
         end
 
+        it 'prints a detailed error containing the modules that would not be satisfied' do
+          graph = double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql'])
+          exception = SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph)
+          allow(exception).to receive(:respond_to?).and_return(true)
+          allow(exception).to receive(:unsatisfied).and_return('pmtacceptance-mysql')
+          allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
+
+          expect(subject[:error]).to include(:multiline)
+          expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+          expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+          expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
+          expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+        end
+
         context 'with --ignore-dependencies' do
           def options
             super.merge(:ignore_dependencies => true)
@@ -278,6 +307,43 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
             graph_should_include 'pmtacceptance-mysql', nil => v('2.1.0')
           end
         end
+
+        context 'with an already installed dependency' do
+          let(:graph) {
+            double(SemanticPuppet::Dependency::Graph,
+              :dependencies => {
+                'pmtacceptance-mysql' => {
+                  :version => '2.1.0'
+                }
+              },
+              :modules => ['pmtacceptance-mysql'],
+              :unsatisfied => 'pmtacceptance-stdlib'
+            )
+          }
+
+          let(:unsatisfiable_graph_exception) { SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph) }
+
+          before do
+            allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(unsatisfiable_graph_exception)
+            allow(unsatisfiable_graph_exception).to receive(:respond_to?).and_return(true)
+            allow(unsatisfiable_graph_exception).to receive(:unsatisfied).and_return(graph.unsatisfied)
+
+            preinstall('pmtacceptance-stdlib', '2.6.0')
+          end
+
+          def options
+            super.merge(:version => '2.1.0')
+          end
+
+          it 'fails to install and outputs a multiline error containing the versions, expectations and workaround' do
+            expect(subject).to include :result => :failure
+            expect(subject[:error]).to include(:multiline)
+            expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (v2.1.0)")
+            expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+            expect(subject[:error][:multiline]).to include("pmtacceptance-stdlib, installed: 2.6.0, expected: >= 2.2.1")
+            expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+          end
+        end
       end
     end
 

data/spec/unit/network/authconfig_spec.rb

@@ -6,9 +6,6 @@ describe Puppet::Network::DefaultAuthProvider do
   before :each do
     allow(Puppet::FileSystem).to receive(:stat).and_return(double('stat', :ctime => :now))
     allow(Time).to receive(:now).and_return(Time.now)
-
-    allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:exists?).and_return(true)
-    # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do

data/spec/unit/network/formats_spec.rb

@@ -534,4 +534,45 @@ EOT
       end
     end
   end
+
+  describe ":flat format" do
+    let(:flat) { Puppet::Network::FormatHandler.format(:flat) }
+
+    it "should include a flat format" do
+      expect(flat).to be_an_instance_of Puppet::Network::Format
+    end
+
+    [:intern, :intern_multiple].each do |method|
+      it "should not implement #{method}" do
+        expect { flat.send(method, String, 'blah') }.to raise_error NotImplementedError
+      end
+    end
+
+    context "when rendering arrays" do
+      {
+          []                           => "",
+          [1, 2]                       => "0=1\n1=2\n",
+          ["one"]                      => "0=one\n",
+          [{"one" => 1}, {"two" => 2}] => "0.one=1\n1.two=2\n",
+          [['something', 'for'], ['the', 'test']]  => "0=[\"something\", \"for\"]\n1=[\"the\", \"test\"]\n"
+      }.each_pair do |input, output|
+        it "should render #{input.inspect} as one item per line" do
+          expect(flat.render(input)).to eq(output)
+        end
+      end
+    end
+
+    context "when rendering hashes" do
+      {
+          {}                                   => "",
+          {1 => 2}                             => "1=2\n",
+          {"one" => "two"}                     => "one=two\n",
+          {[1,2] => 3, [2,3] => 5, [3,4] => 7} => "[1, 2]=3\n[2, 3]=5\n[3, 4]=7\n",
+      }.each_pair do |input, output|
+        it "should render #{input.inspect}" do
+          expect(flat.render(input)).to eq(output)
+        end
+      end
+    end
+  end
 end

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -17,7 +17,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    allow(handler).to receive(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
@@ -25,10 +24,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:env_loaders) { Puppet::Environments::Static.new(environment) }
     let(:params) { { :environment => "env" } }
 
-    before do
-      allow(handler).to receive(:handler).and_return("foo")
-    end
-
     around do |example|
       Puppet.override(:environments => env_loaders) do
         example.run
@@ -180,10 +175,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
     let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
-    before do
-      allow(handler).to receive(:handler).and_return("foo")
-    end
-
     it "should include the environment in the query string of the URI" do
       expect(handler.class.request_to_uri(request)).to eq("#{master_url_prefix}/foo/with%20spaces?environment=myenv&foo=bar")
     end

data/spec/unit/network/http/factory_spec.rb

@@ -144,4 +144,23 @@ describe Puppet::Network::HTTP::Factory do
       expect(conn.local_host).to eq('127.0.0.1')
     end
   end
+
+  context 'tls' do
+    it "sets the minimum version to TLS 1.0", if: RUBY_VERSION.to_f >= 2.5 do
+      conn = create_connection(site)
+      expect(conn.min_version).to eq(OpenSSL::SSL::TLS1_VERSION)
+    end
+
+    it "defaults to ciphersuites providing 128 bits of security or greater" do
+      conn = create_connection(site)
+      expect(conn.ciphers).to eq("ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256")
+    end
+
+    it "can be restricted to TLSv1.3 ciphers" do
+      tls13_ciphers = "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"
+      Puppet[:ciphers] = tls13_ciphers
+      conn = create_connection(site)
+      expect(conn.ciphers).to eq(tls13_ciphers)
+    end
+  end
 end

data/spec/unit/network/http/handler_spec.rb

@@ -102,11 +102,6 @@ describe Puppet::Network::HTTP::Handler do
       { :status => 200 }
     end
 
-    before do
-      allow(handler).to receive(:check_authorization)
-      allow(handler).to receive(:warn_if_near_expiration)
-    end
-
     it "should setup a profiler when the puppet-profiling header exists" do
       request = a_request
       request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"

data/spec/unit/parser/compiler_spec.rb

@@ -240,20 +240,9 @@ describe Puppet::Parser::Compiler do
   end
 
   describe "when compiling" do
-    def compile_methods
-      [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
-        :finish, :store, :extract, :evaluate_relationships]
-    end
-
-    # Stub all of the main compile methods except the ones we're specifically interested in.
-    def compile_stub(*except)
-      (compile_methods - except).each { |m| allow(@compiler).to receive(m) }
-    end
-
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.topscope['a']).to eq("b")
       expect(@compiler.topscope['c']).to eq("d")
@@ -262,13 +251,11 @@ describe Puppet::Parser::Compiler do
     it "should set node parameters that are of Symbol type as String variables in the top scope" do
       params = {"a" => :b}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.topscope['a']).to eq("b")
     end
 
     it "should set the node's environment as a string variable in top scope" do
-      compile_stub(:set_node_parameters)
       @node.merge({'wat' => 'this is how the sausage is made'})
       @compiler.compile
       expect(@compiler.topscope['environment']).to eq("testing")
@@ -276,7 +263,6 @@ describe Puppet::Parser::Compiler do
     end
 
     it "sets the environment based on node.environment instead of the parameters" do
-      compile_stub(:set_node_parameters)
       @node.parameters['environment'] = "Not actually #{@node.environment.name}"
 
       @compiler.compile
@@ -286,23 +272,21 @@ describe Puppet::Parser::Compiler do
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.catalog.client_version).to eq("2")
       expect(@compiler.catalog.server_version).to eq("3")
     end
 
     it "should evaluate the main class if it exists" do
-      compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
+      @compiler.topscope.source = main_class
+
       expect(main_class).to receive(:evaluate_code).with(be_a(Puppet::Parser::Resource))
-      expect(@compiler.topscope).to receive(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
-      compile_stub(:evaluate_main)
       @compiler.compile
       expect(@known_resource_types.find_hostclass("")).to be_instance_of(Puppet::Resource::Type)
     end
@@ -325,7 +309,7 @@ describe Puppet::Parser::Compiler do
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
-      compile_stub(:evaluate_generators)
+      allow(@compiler).to receive(:fail_on_unevaluated)
       @compiler.compile
     end
 

data/spec/unit/parser/resource_spec.rb

@@ -418,22 +418,27 @@ describe Puppet::Parser::Resource do
   end
 
   describe "when merging overrides" do
+    def resource_type(name)
+      double(name, :child_of? => false)
+    end
+
     before do
-      @source = "source1"
+      @source = resource_type("source1")
       @resource = mkresource :source => @source
       @override = mkresource :source => @source
     end
 
     it "should fail when the override was not created by a parent class" do
-      @override.source = "source2"
-      expect(@override.source).to receive(:child_of?).with("source1").and_return(false)
+      @override.source = resource_type("source2")
+      expect(@override.source).to receive(:child_of?).with(@source).and_return(false)
       expect { @resource.merge(@override) }.to raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
-      @resource.source = "source3"
+      @source3 = resource_type("source3")
+      @resource.source = @source3
       @override.source = @resource.source
-      expect(@override.source).not_to receive(:child_of?).with("source3")
+      expect(@override.source).not_to receive(:child_of?).with(@source3)
       params = {:a => :b, :c => :d}
       expect(@override).to receive(:parameters).and_return(params)
       expect(@resource).to receive(:override_parameter).with(:b)
@@ -442,9 +447,10 @@ describe Puppet::Parser::Resource do
     end
 
     it "should succeed when a parent class created the override" do
-      @resource.source = "source3"
-      @override.source = "source4"
-      expect(@override.source).to receive(:child_of?).with("source3").and_return(true)
+      @source3 = resource_type("source3")
+      @resource.source = @source3
+      @override.source = resource_type("source4")
+      expect(@override.source).to receive(:child_of?).with(@source3).and_return(true)
       params = {:a => :b, :c => :d}
       expect(@override).to receive(:parameters).and_return(params)
       expect(@resource).to receive(:override_parameter).with(:b)

data/spec/unit/parser/templatewrapper_spec.rb

@@ -57,9 +57,10 @@ describe Puppet::Parser::TemplateWrapper do
     expect(tw.all_tags).to eq(["tag1","tag2"])
   end
 
-  it "provides the tags defined in the current scope with #tags" do
-    expect(scope).to receive(:tags).and_return(["tag1", "tag2"])
-    expect(tw.tags).to eq(["tag1","tag2"])
+  it "raises not implemented error" do
+    expect {
+      tw.tags
+    }.to raise_error(NotImplementedError, /Call 'all_tags' instead/)
   end
 
   it "raises error on access to removed in-scope variables via method calls" do