puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

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

@@ -18,13 +18,15 @@ describe Puppet::Node::Ldap do
     let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
 
     it "should convert the hostname into a search filter" do
-      entry = stub 'entry', :dn => 'cn=mynode.domain.com,ou=hosts,dc=madstop,dc=com', :vals => %w{}, :to_hash => {}
+      node_indirection.stubs(:ldap_entry_to_hash).returns({})
+      entry = stub 'entry', :dn => 'cn=mynode.domain.com,ou=hosts,dc=madstop,dc=com', :vals => %w{}
       node_indirection.expects(:ldapsearch).with("(&(objectclass=puppetClient)(cn=#{nodename}))").yields entry
       node_indirection.name2hash(nodename)
     end
 
     it "should convert any found entry into a hash" do
-      entry = stub 'entry', :dn => 'cn=mynode.domain.com,ou=hosts,dc=madstop,dc=com', :vals => %w{}, :to_hash => {}
+      node_indirection.stubs(:ldap_entry_to_hash).returns({})
+      entry = stub 'entry', :dn => 'cn=mynode.domain.com,ou=hosts,dc=madstop,dc=com', :vals => %w{}
       node_indirection.expects(:ldapsearch).with("(&(objectclass=puppetClient)(cn=#{nodename}))").yields entry
       myhash = {"myhash" => true}
       node_indirection.expects(:entry2hash).with(entry).returns myhash
@@ -34,7 +36,8 @@ describe Puppet::Node::Ldap do
     # This heavily tests our entry2hash method, so we don't have to stub out the stupid entry information any more.
     describe "when an ldap entry is found" do
       before do
-        @entry = stub 'entry', :dn => 'cn=mynode,ou=hosts,dc=madstop,dc=com', :vals => %w{}, :to_hash => {}
+        @entry = stub 'entry', :dn => 'cn=mynode,ou=hosts,dc=madstop,dc=com', :vals => %w{}
+        node_indirection.stubs(:ldap_entry_to_hash).returns({})
         node_indirection.stubs(:ldapsearch).yields @entry
       end
 
@@ -56,7 +59,7 @@ describe Puppet::Node::Ldap do
       end
 
       it "should deduplicate class values" do
-        @entry.stubs(:to_hash).returns({})
+        node_indirection.stubs(:ldap_entry_to_hash).returns({})
         node_indirection.stubs(:class_attributes).returns(%w{one two})
         @entry.stubs(:vals).with("one").returns(%w{a b})
         @entry.stubs(:vals).with("two").returns(%w{b c})
@@ -64,7 +67,7 @@ describe Puppet::Node::Ldap do
       end
 
       it "should add the entry's environment to the hash" do
-        @entry.stubs(:to_hash).returns("environment" => %w{production})
+        node_indirection.stubs(:ldap_entry_to_hash).returns(:environment => %w{production})
         expect(node_indirection.entry2hash(@entry)[:environment]).to eq("production")
       end
 
@@ -77,37 +80,37 @@ describe Puppet::Node::Ldap do
 
       it "should not add the stacked parameter as a normal parameter" do
         @entry.stubs(:vals).with("puppetvar").returns(%w{one=two three=four})
-        @entry.stubs(:to_hash).returns("puppetvar" => %w{one=two three=four})
+        node_indirection.stubs(:ldap_entry_to_hash).returns("puppetvar" => %w{one=two three=four})
         expect(node_indirection.entry2hash(@entry)[:parameters]["puppetvar"]).to be_nil
       end
 
       it "should add all other attributes as parameters in the hash" do
-        @entry.stubs(:to_hash).returns("foo" => %w{one two})
+        node_indirection.stubs(:ldap_entry_to_hash).returns("foo" => %w{one two})
         expect(node_indirection.entry2hash(@entry)[:parameters]["foo"]).to eq(%w{one two})
       end
 
       it "should return single-value parameters as strings, not arrays" do
-        @entry.stubs(:to_hash).returns("foo" => %w{one})
+        node_indirection.stubs(:ldap_entry_to_hash).returns("foo" => %w{one})
         expect(node_indirection.entry2hash(@entry)[:parameters]["foo"]).to eq("one")
       end
 
       it "should convert 'true' values to the boolean 'true'" do
-        @entry.stubs(:to_hash).returns({"one" => ["true"]})
+        node_indirection.stubs(:ldap_entry_to_hash).returns({"one" => ["true"]})
         expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq(true)
       end
 
       it "should convert 'false' values to the boolean 'false'" do
-        @entry.stubs(:to_hash).returns({"one" => ["false"]})
+        node_indirection.stubs(:ldap_entry_to_hash).returns({"one" => ["false"]})
         expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq(false)
       end
 
       it "should convert 'true' values to the boolean 'true' inside an array" do
-        @entry.stubs(:to_hash).returns({"one" => ["true", "other"]})
+        node_indirection.stubs(:ldap_entry_to_hash).returns({"one" => ["true", "other"]})
         expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq([true, "other"])
       end
 
       it "should convert 'false' values to the boolean 'false' inside an array" do
-        @entry.stubs(:to_hash).returns({"one" => ["false", "other"]})
+        node_indirection.stubs(:ldap_entry_to_hash).returns({"one" => ["false", "other"]})
         expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq([false, "other"])
       end
 

data/spec/unit/indirector/rest_spec.rb

@@ -723,49 +723,6 @@ describe Puppet::Indirector::REST do
     end
   end
 
-  describe '#handle_response' do
-    # There are multiple request types to choose from, this may not be the one I want for this situation
-    let(:response) { mock_response(200, 'body') }
-    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
-    let(:instance) { model.new('the thing', 'some contents') }
-    let(:request) { save_request(instance.name, instance) }
-
-    before :each do
-      terminus.stubs(:network).returns(connection)
-    end
-
-    it 'adds server_agent_version to the context if not already set' do
-      Puppet.expects(:push_context).with(:server_agent_version => Puppet.version)
-      terminus.handle_response(request, response)
-    end
-
-    it 'does not add server_agent_version to the context if it is already set' do
-      Puppet.override(:server_agent_version => "5.3.4") do
-        Puppet.expects(:push_context).never
-        terminus.handle_response(request, response)
-      end
-    end
-
-    it 'downgrades to pson and emits a warning' do
-      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns('4.2.8')
-      Puppet[:preferred_serialization_format] = 'other'
-
-      Puppet.expects(:warning).with('Downgrading to PSON for future requests')
-
-      terminus.handle_response(request, response)
-
-      expect(Puppet[:preferred_serialization_format]).to eq('pson')
-    end
-
-    it 'preserves the set serialization format' do
-      Puppet[:preferred_serialization_format] = 'other'
-
-      expect(Puppet[:preferred_serialization_format]).to eq('other')
-
-      terminus.handle_response(request, response)
-    end
-  end
-
   context 'dealing with SRV settings' do
     [
       :destroy,

data/spec/unit/interface/action_spec.rb

@@ -644,4 +644,37 @@ describe Puppet::Interface::Action do
       expect(subject.get_default_action).to eq(action)
     end
   end
+
+  context "when deprecating a face action" do
+    let :face do
+      Puppet::Interface.new(:foo, '1.0.0') do
+        action :bar do
+          option "--bar"
+          when_invoked do |options| options end
+        end
+      end
+    end
+
+    let :action do face.get_action :bar end
+
+    describe "#deprecate" do
+      it "should set the deprecated value to true" do
+        expect(action).not_to be_deprecated
+        action.deprecate
+        expect(action).to be_deprecated
+      end
+    end
+
+    describe "#deprecated?" do
+      it "should return a nil (falsey) value by default" do
+        expect(action.deprecated?).to be_falsey
+      end
+
+      it "should return true if the action has been deprecated" do
+        expect(action).not_to be_deprecated
+        action.deprecate
+        expect(action).to be_deprecated
+      end
+    end
+  end
 end

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

@@ -429,4 +429,11 @@ symlinkfile
 
     it_behaves_like "a packagable module"
   end
+
+  context 'when in FIPS mode...' do
+    it 'module builder refuses to run' do
+      Facter.stubs(:value).with(:fips_enabled).returns(true)
+      expect { builder.run }.to raise_error(/Module building is prohibited in FIPS mode/)
+    end 
+  end
 end

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

@@ -366,6 +366,14 @@ describe Puppet::ModuleTool::Applications::Installer do
         end
       end
     end
+
+    context 'when in FIPS mode...' do
+      it 'module installer refuses to run' do
+        Facter.stubs(:value).with(:fips_enabled).returns(true)
+        expect {application.run}.to raise_error(/Module install is prohibited in FIPS mode./)
+      end 
+    end
+
   end
 
 end

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

@@ -162,4 +162,12 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
       end
     end
   end
+
+  context 'when in FIPS mode...' do
+    it 'module uninstaller refuses to run' do
+      Facter.stubs(:value).with(:fips_enabled).returns(true)
+      expect {application.run}.to raise_error(/Module uninstall is prohibited in FIPS mode/)
+    end 
+  end
+
 end

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

@@ -327,5 +327,11 @@ describe Puppet::ModuleTool::Applications::Upgrader do
         end
       end
     end
+    context 'when in FIPS mode...' do
+      it 'module unpgrader refuses to run' do
+        Facter.stubs(:value).with(:fips_enabled).returns(true)
+        expect { application.run }.to raise_error(/Module upgrade is prohibited in FIPS mode/)
+      end 
+    end
   end
 end

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

@@ -291,7 +291,7 @@ describe Puppet::Network::HTTP::Connection do
       expect(result.code).to eq(503)
     end
 
-    it "should return a 503 response if Retry-After is not convertable to an Integer or RFC 2822 Date" do
+    it "should return a 503 response if Retry-After is not convertible to an Integer or RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'foo'
       http.stubs(:request).returns(httpunavailable)
 

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

@@ -78,49 +78,42 @@ describe Puppet::Network::HTTP::Factory do
 
       expect(conn.proxy_port).to eq(proxy_port)
     end
-  end
-
-  context 'socket timeouts' do
-    it 'sets open timeout' do
-      Puppet[:http_connect_timeout] = "10s"
-      conn = create_connection(site)
-
-      expect(conn.open_timeout).to eq(10)
-    end
-
-    it 'sets read timeout' do
-      Puppet[:http_read_timeout] = "2m"
-      conn = create_connection(site)
-
-      expect(conn.read_timeout).to eq(120)
-    end
-  end
 
-  it "disables ruby's http_keepalive_timeout on Ruby 2" do
-    skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
-    conn = create_connection(site)
+    context 'socket timeouts' do
+      it 'sets open timeout' do
+        Puppet[:http_connect_timeout] = "10s"
+        conn = create_connection(site)
 
-    expect(conn.keep_alive_timeout).to eq(2147483647)
-  end
+        expect(conn.open_timeout).to eq(10)
+      end
 
-  context 'source address' do
-    it 'defaults to system-defined' do
-      skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
-      conn = create_connection(site)
+      it 'sets read timeout' do
+        Puppet[:http_read_timeout] = "2m"
+        conn = create_connection(site)
 
-      expect(conn.local_host).to be(nil)
+        expect(conn.read_timeout).to eq(120)
+      end
     end
 
-    it 'sets the local_host address' do
-      Puppet[:sourceaddress] = "127.0.0.1"
-      if RUBY_VERSION.to_i >= 2
+    context 'source address' do
+      it 'defaults to system-defined' do
+        skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
         conn = create_connection(site)
 
-        expect(conn.local_host).to eq('127.0.0.1')
-      else
-        expect {
-          create_connection(site)
-        }.to raise_error(ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP.")
+        expect(conn.local_host).to be(nil)
+      end
+
+      it 'sets the local_host address' do
+        Puppet[:sourceaddress] = "127.0.0.1"
+        if RUBY_VERSION.to_i >= 2
+          conn = create_connection(site)
+
+          expect(conn.local_host).to eq('127.0.0.1')
+        else
+          expect {
+            create_connection(site)
+          }.to raise_error(ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP.")
+        end
       end
     end
   end

data/spec/unit/parser/compiler_spec.rb

@@ -279,14 +279,6 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.topscope['wat']).to eq('this is how the sausage is made')
     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
-      expect(@compiler.topscope['environment']).to eq('testing')
-    end
-
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)

data/spec/unit/parser/environment_compiler_spec.rb

@@ -9,6 +9,15 @@ describe "Application instantiation" do
   let(:env) { Puppet::Node::Environment.create(:testing, []) }
   let(:node) { Puppet::Node.new('test', :environment => env) }
   let(:loaders) { Puppet::Pops::Loaders.new(env) }
+  let(:logs) { [] }
+  let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+  def compile_collect_log(string)
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compile_to_catalog(string, Puppet::Node.new('other', :environment => env))
+    end
+  end
 
   def compile_to_env_catalog(string, code_id=nil)
     Puppet[:code] = string
@@ -683,4 +692,31 @@ EOS
       }.to raise_error(Puppet::Error, /maps component P\[one\] to multiple nodes/)
     end
   end
+
+  describe "site containing a resource named 'plan'" do
+    it 'finds an application named plan' do
+      expect {compile_collect_log(<<-PUPPET)}.not_to raise_error
+        define plan::node_file() {
+          file { "/tmp/plans/${name}.txt":
+            content => "this is ${name}.txt",
+          }
+        }
+        Plan::Node_file produces Node_file {}
+        application plan() {
+          plan::node_file { "node_file_${name}":
+            export => Node_file["node_file_${name}"]
+          }
+        }
+        site {
+          plan { "test":
+            nodes       => {
+              Node["test.example.com"] => Plan::Node_file["node_file_plan_test"],
+            }
+          }
+        }
+        PUPPET
+
+      expect(warnings).to include(/Use of future reserved word: 'plan'/)
+    end
+  end
 end

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -324,6 +324,15 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog('include foo')
       }.to raise_error(Puppet::Error, /Syntax error at.*/)
     end
+
+    it 'is not available when --tasks is on' do
+      Puppet[:tasks] = true
+      expect do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          create_resources('class', {'bar'=>{}}, {'one' => 'two'})
+        MANIFEST
+      end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+    end
   end
 
   def collect_notices(code)

data/spec/unit/parser/functions/inline_template_spec.rb

@@ -28,6 +28,13 @@ describe "the inline_template function" do
     expect(inline_template("string was: <%= @string %>")).to eq("string was: this is a variable")
   end
 
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect {
+      inline_template("<%= lookupvar('myvar') %>")
+    }.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
+
   def inline_template(*templates)
     scope.function_inline_template(templates)
   end

data/spec/unit/parser/functions/realize_spec.rb

@@ -58,4 +58,13 @@ describe "the realize function" do
       realize([])
     EOM
   end
+
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        realize([])
+      MANIFEST
+    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
 end

data/spec/unit/parser/functions/tag_spec.rb

@@ -25,4 +25,11 @@ describe "the 'tag' function" do
     expect(resource).to be_tagged("one")
     expect(resource).to be_tagged("two")
   end
+
+  it 'is not available when --tasks is on' do
+    Puppet[:tasks] = true
+    expect do
+      @scope.function_tag(['one', 'two'])
+    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
 end