puppet 4.0.0 → 4.5.0

data/spec/unit/resource_spec.rb

@@ -315,7 +315,10 @@ describe Puppet::Resource do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { :a => 1 } }
       let(:port) { Puppet::Parser::AST::Leaf.new(:value => '80') }
-      let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
+
+      def inject_and_set_defaults(resource, scope)
+        resource.resource_type.set_resource_parameters(resource, scope)
+      end
 
       before do
         environment.known_resource_types.add(apache)
@@ -325,68 +328,118 @@ describe Puppet::Resource do
         scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
-      context "when no value is provided" do
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope)
-        end
+      context 'with a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
 
-        it "should query the data_binding terminus using a namespaced key" do
-          Puppet::DataBinding.indirection.expects(:find).with(
-            'apache::port', all_of(has_key(:environment), has_key(:variables)))
-          resource.set_default_parameters(scope)
-        end
+        context "when no value is provided" do
+          let(:resource) do
+            Puppet::Parser::Resource.new("class", "apache", :scope => scope)
+          end
 
-        it "should use the value from the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).returns('443')
+          it "should query the data_binding terminus using a namespaced key" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with(
+              'apache::port', all_of(has_key(:environment), has_key(:variables)))
+            inject_and_set_defaults(resource, scope)
+          end
 
-          resource.set_default_parameters(scope)
+          it "should use the value from the data_binding terminus" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
 
-          expect(resource[:port]).to eq('443')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should use the default value if the data_binding terminus returns nil" do
-          Puppet::DataBinding.indirection.expects(:find).returns(nil)
+            expect(resource[:port]).to eq('443')
+          end
 
-          resource.set_default_parameters(scope)
+          it 'should use the default value if no value is found using the data_binding terminus' do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).throws(:no_such_key)
 
-          expect(resource[:port]).to eq('80')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should fail with error message about data binding on a hiera failure" do
-          Puppet::DataBinding.indirection.expects(:find).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
-          expect {
-            resource.set_default_parameters(scope)
-          }.to raise_error(Puppet::Error, /Error from DataBinding 'hiera' while looking up 'apache::port':.*Forgettabotit/)
-        end
+            expect(resource[:port]).to eq('80')
+          end
 
-      end
+          it 'should use the default value if an undef value is found using the data_binding terminus' do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
 
-      context "when a value is provided" do
-        let(:port_parameter) do
-          Puppet::Parser::Resource::Param.new(
-            { :name => 'port', :value => '8080' }
-          )
-        end
+            inject_and_set_defaults(resource, scope)
+
+            expect(resource[:port]).to eq('80')
+          end
 
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-            :parameters => [port_parameter])
+          it "should fail with error message about data binding on a hiera failure" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+            expect {
+              inject_and_set_defaults(resource, scope)
+            }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
+          end
         end
 
-        it "should not query the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          resource.set_default_parameters(scope)
+        context "when a value is provided" do
+          let(:port_parameter) do
+            Puppet::Parser::Resource::Param.new(
+              { :name => 'port', :value => '8080' }
+            )
+          end
+
+          let(:resource) do
+            Puppet::Parser::Resource.new("class", "apache", :scope => scope,
+              :parameters => [port_parameter])
+          end
+
+          it "should not query the data_binding terminus" do
+            Puppet::DataBinding.indirection.expects(:find).never
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should not query the injector" do
+            compiler.injector.expects(:find).never
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should use the value provided" do
+            Puppet::DataBinding.indirection.expects(:find).never
+            expect(resource.set_default_parameters(scope)).to eq([])
+            expect(resource[:port]).to eq('8080')
+          end
+
+          it "should use the value from the data_binding terminus when provided value is undef" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
+
+            rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
+              :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+
+            rs.resource_type.set_resource_parameters(rs, scope)
+            expect(rs[:port]).to eq('443')
+          end
         end
+      end
+
+      context 'without a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => nil }) }
+        let(:resource) { Puppet::Parser::Resource.new("class", "apache", :scope => scope) }
+
+        it "should use the value from the data_binding terminus" do
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
+
+          inject_and_set_defaults(resource, scope)
 
-        it "should not query the injector" do
-          compiler.injector.expects(:find).never
-          resource.set_default_parameters(scope)
+          expect(resource[:port]).to eq('443')
         end
 
-        it "should use the value provided" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          expect(resource.set_default_parameters(scope)).to eq([])
-          expect(resource[:port]).to eq('8080')
+        it "should use an undef value from the data_binding terminus" do
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
+
+          inject_and_set_defaults(resource, scope)
+
+          expect(resource[:port]).to be_nil
         end
       end
     end
@@ -428,11 +481,11 @@ describe Puppet::Resource do
     end
 
     it "should fail if invalid parameters are used" do
-      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error
+      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error(Puppet::Error, /no parameter named 'nosuchparam'/)
     end
 
     it "should fail if the resource type cannot be resolved" do
-      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to raise_error
+      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to raise_error(ArgumentError, /Invalid resource type/)
     end
   end
 
@@ -657,6 +710,20 @@ describe Puppet::Resource do
       )
     end
 
+    it "should escape internal single quotes in a title" do
+      singlequote_resource = Puppet::Resource.new("one::two", "/my/file'b'a'r",
+        :parameters => {
+          :ensure => 'present',
+        }
+      )
+      expect(singlequote_resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+        one::two { '/my/file\\'b\\'a\\'r':
+          ensure => 'present',
+        }
+      HEREDOC
+
+    end
+
     it "should align, sort and add trailing commas to attributes with ensure first" do
       expect(@resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
         one::two { '/my/file':

data/spec/unit/settings/environment_conf_spec.rb

@@ -39,6 +39,19 @@ describe Puppet::Settings::EnvironmentConf do
       expect(envconf.environment_timeout).to eq(180)
     end
 
+    it "reads a static_catalogs from config" do
+      setup_environment_conf(config, :static_catalogs => true)
+
+      expect(envconf.static_catalogs).to eq(true)
+    end
+
+    it "can retrieve untruthy settings" do
+      Puppet[:static_catalogs] = true
+      setup_environment_conf(config, :static_catalogs => false)
+
+      expect(envconf.static_catalogs).to eq(false)
+    end
+
     it "can retrieve raw settings" do
       setup_environment_conf(config, :manifest => 'manifest.pp')
 
@@ -64,10 +77,14 @@ describe Puppet::Settings::EnvironmentConf do
       expect(envconf.config_version).to be_nil
     end
 
-    it "returns a defult of 0 for environment_timeout when config has none" do
+    it "returns a default of 0 for environment_timeout when config has none" do
       expect(envconf.environment_timeout).to eq(0)
     end
 
+    it "returns default of true for static_catalogs when config has none" do
+      expect(envconf.static_catalogs).to eq(true)
+    end
+
     it "can still retrieve raw setting" do
       expect(envconf.raw_setting(:manifest)).to be_nil
     end

data/spec/unit/settings/file_setting_spec.rb

@@ -169,6 +169,12 @@ describe Puppet::Settings::FileSetting do
       expect(resource.title).to eq(@basepath)
     end
 
+    it "should have a working directory with a root directory not called dev", :if => Puppet.features.microsoft_windows? do
+      # Although C:\Dev\.... is a valid path on Windows, some other code may regard it as a path to be ignored.  e.g. /dev/null resolves to C:\dev\null on Windows.
+      path = File.expand_path('somefile')
+      expect(path).to_not match(/^[A-Z]:\/dev/i)
+    end
+
     it "should fully qualified returned files if necessary (#795)" do
       @settings.stubs(:value).with(:myfile, nil, false).returns "myfile"
       path = File.expand_path('myfile')
@@ -295,4 +301,35 @@ describe Puppet::Settings::FileSetting do
       expect(filesetting.munge(':memory:')).to eq(':memory:')
     end
   end
+
+  context "when opening", :unless => Puppet.features.microsoft_windows? do
+    let(:path) do
+      tmpfile('file_setting_spec')
+    end
+
+    let(:setting) do
+      settings = mock("settings", :value => path)
+      FileSetting.new(:name => :mysetting, :desc => "creates a file", :settings => settings)
+    end
+
+    it "creates a file with mode 0640" do
+      setting.mode = '0640'
+
+      expect(File).to_not be_exist(path)
+      setting.open('w')
+
+      expect(File).to be_exist(path)
+      expect(Puppet::FileSystem.stat(path).mode & 0777).to eq(0640)
+    end
+
+    it "preserves the mode of an existing file" do
+      setting.mode = '0640'
+
+      Puppet::FileSystem.touch(path)
+      Puppet::FileSystem.chmod(0644, path)
+      setting.open('w')
+
+      expect(Puppet::FileSystem.stat(path).mode & 0777).to eq(0644)
+    end
+  end
 end

data/spec/unit/settings_spec.rb

@@ -44,7 +44,7 @@ describe Puppet::Settings do
     it "should not allow specification of default values associated with a section as an array" do
       expect {
         @settings.define_settings(:section, :myvalue => ["defaultval", "my description"])
-      }.to raise_error
+      }.to raise_error(ArgumentError, /setting definition for 'myvalue' is not a hash!/)
     end
 
     it "should not allow duplicate parameter specifications" do
@@ -118,6 +118,17 @@ describe Puppet::Settings do
 
       expect(@settings.preferred_run_mode).to eq(:master)
     end
+
+    it "creates ancestor directories for all required app settings" do
+      # initialize_app_defaults is called in spec_helper, before we even
+      # get here, but call it here to make it explicit what we're trying
+      # to do.
+      @settings.initialize_app_defaults(default_values)
+
+      Puppet::Settings::REQUIRED_APP_SETTINGS.each do |key|
+        expect(File).to exist(File.dirname(Puppet[key]))
+      end
+    end
   end
 
   describe "#call_hooks_deferred_to_application_initialization" do
@@ -276,6 +287,95 @@ describe Puppet::Settings do
       expect(@settings.set_by_cli?(:myval)).to be_falsey
     end
 
+    it "should find no configured settings by default" do
+      expect(@settings.set_by_config?(:myval)).to be_falsey
+    end
+
+    it "should identify configured settings in memory" do
+      @settings.instance_variable_get(:@value_sets)[:memory].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should identify configured settings from CLI" do
+      @settings.instance_variable_get(:@value_sets)[:cli].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should not identify configured settings from environment by default" do
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).never
+      expect(@settings.set_by_config?(:manifest)).to be_falsey
+    end
+
+    it "should identify configured settings from environment by when an environment is specified" do
+      foo = mock('environment', :manifest => 'foo')
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).returns(foo)
+      expect(@settings.set_by_config?(:manifest, Puppet[:environment])).to be_truthy
+    end
+
+    it "should identify configured settings from the preferred run mode" do
+      user_config_text = "[#{@settings.preferred_run_mode}]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should identify configured settings from the specified run mode" do
+      user_config_text = "[master]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval, nil, :master)).to be_truthy
+    end
+
+    it "should not identify configured settings from an unspecified run mode" do
+      user_config_text = "[zaz]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_falsey
+    end
+
+    it "should identify configured settings from the main section" do
+      user_config_text = "[main]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
     it "should clear the cache when setting getopt-specific values" do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
@@ -637,7 +737,7 @@ describe Puppet::Settings do
 
       Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
 
-      Puppet::FileSystem.expects(:read).with(myfile).returns "[main]"
+      Puppet::FileSystem.expects(:read).with(myfile, :encoding => 'utf-8').returns "[main]"
 
       @settings.send(:parse_config_files)
     end
@@ -1723,7 +1823,7 @@ describe Puppet::Settings do
   end
 
   describe "default_certname" do
-    describe "using hostname and domainname" do
+    describe "using hostname and domain" do
       before :each do
         Puppet::Settings.stubs(:hostname_fact).returns("testhostname")
         Puppet::Settings.stubs(:domain_fact).returns("domain.test.")

data/spec/unit/ssl/certificate_authority/interface_spec.rb

@@ -332,9 +332,10 @@ describe Puppet::SSL::CertificateAuthority::Interface do
           @applier.expects(:puts).with "h1"
 
           @ca.expects(:print).with("host2").returns nil
-          Puppet.expects(:err).with { |msg| msg.include?("host2") }
-
-          @applier.apply(@ca)
+    
+	  expect {
+            @applier.apply(@ca)
+	  }.to raise_error(ArgumentError, /Could not find certificate for host2/)
         end
       end
     end

data/spec/unit/ssl/certificate_authority_spec.rb

@@ -777,7 +777,7 @@ describe Puppet::SSL::CertificateAuthority do
       it "should raise an error if the certificate or CSR cannot be found" do
         Puppet::SSL::Certificate.indirection.expects(:find).with("myhost").returns nil
         Puppet::SSL::CertificateRequest.indirection.expects(:find).with("myhost").returns nil
-        expect { @ca.fingerprint("myhost") }.to raise_error
+        expect { @ca.fingerprint("myhost") }.to raise_error(ArgumentError, /Could not find a certificate/)
       end
 
       it "should try to find a CSR if no certificate can be found" do
@@ -863,8 +863,10 @@ describe Puppet::SSL::CertificateAuthority do
         @cert.expects(:content).returns "mycert"
 
         @store.expects(:verify).with("mycert").returns false
+        @store.expects(:error)
+        @store.expects(:error_string)
 
-        expect { @ca.verify("me") }.to raise_error
+        expect { @ca.verify("me") }.to raise_error(Puppet::SSL::CertificateAuthority::CertificateVerificationError)
       end
 
       describe "certificate_is_alive?" do
@@ -963,7 +965,7 @@ describe Puppet::SSL::CertificateAuthority do
         @ca.inventory.expects(:serials).with("host").returns []
 
         @ca.crl.expects(:revoke).never
-        expect { @ca.revoke('host') }.to raise_error
+        expect { @ca.revoke('host') }.to raise_error(ArgumentError, /Could not find a serial number for host/)
       end
 
       context "revocation by serial number (#16798)" do

data/spec/unit/ssl/certificate_revocation_list_spec.rb

@@ -105,14 +105,14 @@ describe Puppet::SSL::CertificateRevocationList do
     end
 
     it "returns the last update time in UTC" do
-      # http://tools.ietf.org/html/rfc5280#section-5.1.2.4
+      # https://tools.ietf.org/html/rfc5280#section-5.1.2.4
       thisUpdate = @crl.generate(@cert, @key).last_update
       expect(thisUpdate).to be_utc
       expects_time_close_to_now(thisUpdate)
     end
 
     it "returns the next update time in UTC 5 years from now" do
-      # http://tools.ietf.org/html/rfc5280#section-5.1.2.5
+      # https://tools.ietf.org/html/rfc5280#section-5.1.2.5
       nextUpdate = @crl.generate(@cert, @key).next_update
       expect(nextUpdate).to be_utc
       expects_time_close_to_five_years(nextUpdate)
@@ -179,7 +179,7 @@ describe Puppet::SSL::CertificateRevocationList do
     end
 
     it "adds a non-critical CRL reason specifying key compromise by default" do
-      # http://tools.ietf.org/html/rfc5280#section-5.3.1
+      # https://tools.ietf.org/html/rfc5280#section-5.3.1
       serial = 1
       @crl.revoke(serial, @key)
 

data/spec/unit/ssl/host_spec.rb

@@ -422,7 +422,7 @@ describe Puppet::SSL::Host do
       @key.stubs(:generate)
       Puppet::SSL::Key.indirection.expects(:save).raises "eh"
 
-      expect { @host.generate_key }.to raise_error
+      expect { @host.generate_key }.to raise_error(RuntimeError)
       expect(@host.key).to be_nil
     end
 
@@ -496,7 +496,7 @@ describe Puppet::SSL::Host do
       Puppet::SSL::CertificateRequest.indirection.expects(:prepare).returns(terminus)
       terminus.expects(:save).with { |req| req.instance == @request && req.key == "myname" }.raises "eh"
 
-      expect { @host.generate_certificate_request }.to raise_error
+      expect { @host.generate_certificate_request }.to raise_error(RuntimeError)
 
       expect(@host.instance_eval { @certificate_request }).to be_nil
     end

data/spec/unit/ssl/oids_spec.rb

@@ -25,6 +25,14 @@ describe Puppet::SSL::Oids do
       'pp_department'       => "1.3.6.1.4.1.34380.1.1.15",
       'pp_cluster'          => "1.3.6.1.4.1.34380.1.1.16",
       'pp_provisioner'      => "1.3.6.1.4.1.34380.1.1.17",
+      'pp_region'           => "1.3.6.1.4.1.34380.1.1.18",
+      'pp_datacenter'       => "1.3.6.1.4.1.34380.1.1.19",
+      'pp_zone'             => "1.3.6.1.4.1.34380.1.1.20",
+      'pp_network'          => "1.3.6.1.4.1.34380.1.1.21",
+      'pp_securitypolicy'   => "1.3.6.1.4.1.34380.1.1.22",
+      'pp_cloudplatform'    => "1.3.6.1.4.1.34380.1.1.23",
+      'pp_apptier'          => "1.3.6.1.4.1.34380.1.1.24",
+      'pp_hostname'         => "1.3.6.1.4.1.34380.1.1.25",
       'ppPrivCertExt'       => '1.3.6.1.4.1.34380.1.2',
     }.each_pair do |sn, oid|
       it "defines #{sn} as #{oid}" do