puppet 4.2.0 → 4.3.0

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
@@ -287,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" },
@@ -1734,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/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

data/spec/unit/transaction/additional_resource_generator_spec.rb

@@ -52,6 +52,48 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
     end
   end
 
+  Puppet::Type.newtype(:autorequire) do
+    newparam(:name) do
+      isnamevar
+    end
+
+    autorequire(:notify) do
+      self[:name]
+    end
+  end
+
+  Puppet::Type.newtype(:gen_auto) do
+    newparam(:name) do
+      isnamevar
+    end
+
+    newparam(:eval_after) do
+    end
+
+    def generate()
+      [ Puppet::Type.type(:autorequire).new(:name => self[:eval_after]) ]
+    end
+  end
+
+  Puppet::Type.newtype(:empty) do
+    newparam(:name) do
+      isnamevar
+    end
+  end
+
+  Puppet::Type.newtype(:gen_empty) do
+    newparam(:name) do
+      isnamevar
+    end
+
+    newparam(:eval_after) do
+    end
+
+    def generate()
+      [ Puppet::Type.type(:empty).new(:name => self[:eval_after], :require => "Notify[#{self[:eval_after]}]") ]
+    end
+  end
+
   context "when applying eval_generate" do
     it "should add the generated resources to the catalog" do
       catalog = compile_to_ral(<<-MANIFEST)
@@ -368,13 +410,44 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
                          "Notify[after]"))
     end
 
-    def relationships_after_generating(manifest, resource_to_generate)
-      catalog = compile_to_ral(manifest)
-      relationship_graph = relationship_graph_for(catalog)
+    it "runs autorequire on the generated resource" do
+      graph = relationships_after_generating(<<-MANIFEST, 'Gen_auto[thing]')
+        gen_auto { thing:
+          eval_after => hello,
+        }
 
-      generate_resources_in(catalog, relationship_graph, resource_to_generate)
+        notify { hello: }
+        notify { goodbye: }
+      MANIFEST
 
-      relationship_graph
+      expect(order_resources_traversed_in(graph)).to(
+        include_in_order("Gen_auto[thing]",
+                         "Notify[hello]",
+                         "Autorequire[hello]",
+                         "Notify[goodbye]"))
+    end
+
+    it "evaluates metaparameters on the generated resource" do
+      graph = relationships_after_generating(<<-MANIFEST, 'Gen_empty[thing]')
+        gen_empty { thing:
+          eval_after => hello,
+        }
+
+        notify { hello: }
+        notify { goodbye: }
+      MANIFEST
+
+      expect(order_resources_traversed_in(graph)).to(
+        include_in_order("Gen_empty[thing]",
+                         "Notify[hello]",
+                         "Empty[hello]",
+                         "Notify[goodbye]"))
+    end
+
+    def relationships_after_generating(manifest, resource_to_generate)
+      catalog = compile_to_ral(manifest)
+      generate_resources_in(catalog, nil, resource_to_generate)
+      relationship_graph_for(catalog)
     end
 
     def generate_resources_in(catalog, relationship_graph, resource_to_generate)

data/spec/unit/transaction/report_spec.rb

@@ -404,6 +404,16 @@ describe Puppet::Transaction::Report do
     expect(error_report.render).to validate_against('api/schemas/report.json')
   end
 
+  it "can make a round trip through yaml" do
+    report = generate_report
+
+    yaml_output = report.render(:yaml)
+    tripped = Puppet::Transaction::Report.convert_from(:yaml, yaml_output)
+
+    expect(yaml_output).to match(/^--- /)
+    expect_equivalent_reports(tripped, report)
+  end
+
   def expect_equivalent_reports(tripped, report)
     expect(tripped.host).to eq(report.host)
     expect(tripped.time.to_i).to eq(report.time.to_i)
@@ -451,13 +461,26 @@ describe Puppet::Transaction::Report do
       expect(status.skipped).to eq(expected.skipped)
       expect(status.change_count).to eq(expected.change_count)
       expect(status.out_of_sync_count).to eq(expected.out_of_sync_count)
-      expect(status.events).to eq(expected.events)
+      expect(status.events.map(&:to_data_hash)).to eq(expected.events.map(&:to_data_hash))
     end
   end
 
   def generate_report
+    event_hash = {
+      :audited => false,
+      :property => 'message',
+      :previous_value => 'absent',
+      :desired_value => 'a resource',
+      :historical_value => nil,
+      :message => "defined 'message' as 'a resource'",
+      :name => :message_changed,
+      :status => 'success',
+    }
+    event = Puppet::Transaction::Event.new(event_hash)
+
     status = Puppet::Resource::Status.new(Puppet::Type.type(:notify).new(:title => "a resource"))
     status.changed = true
+    status.add_event(event)
 
     report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")

data/spec/unit/transaction_spec.rb

@@ -721,6 +721,13 @@ describe Puppet::Transaction, " when determining tags" do
     expect(@transaction).to be_tagged("one::two")
   end
 
+  it "should tag one::two only as 'one::two' and not 'one', 'two', and 'one::two'" do
+    @transaction.tags = "one::two"
+    expect(@transaction).to be_tagged("one::two")
+    expect(@transaction).to_not be_tagged("one")
+    expect(@transaction).to_not be_tagged("two")
+  end
+
   it "should accept a comma-delimited string" do
     @transaction.tags = "one, two"
     expect(@transaction).to be_tagged("one")

data/spec/unit/type/exec_spec.rb

@@ -396,16 +396,24 @@ describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should fail if timeout is exceeded" do
-        ruby_path = Puppet::Util::Execution.ruby_path()
+      describe 'when timeout is exceeded' do
+        subject do
+          ruby_path = Puppet::Util::Execution.ruby_path()
+          Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 1'", :timeout => '0.1')
+        end
 
-        ## Leaving this commented version in here because it fails on windows, due to what appears to be
-        ##  an assumption about hash iteration order in lib/puppet/type.rb#hash2resource, where
-        ##  resource[]= will overwrite the namevar with ":name" if the iteration is in the wrong order
-        #sleep_exec = Puppet::Type.type(:exec).new(:name => 'exec_spec sleep command', :command => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
-        sleep_exec = Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
+        context 'on POSIX', :unless => Puppet.features.microsoft_windows? do
+          it 'sends a SIGTERM and raises a Puppet::Error' do
+            Process.expects(:kill).at_least_once
+            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+          end
+        end
 
-        expect { sleep_exec.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+        context 'on Windows', :if => Puppet.features.microsoft_windows? do
+          it 'raises a Puppet::Error' do
+            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+          end
+        end
       end
 
       it "should convert timeout to a float" do

data/spec/unit/type/host_spec.rb

@@ -68,15 +68,15 @@ describe host do
     end
 
     it "should not accept malformed IPv4 addresses like 192.168.0.300" do
-      expect { @class.new(:name => "foo", :ip => '192.168.0.300') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '192.168.0.300') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     it "should reject over-long IPv4 addresses" do
-      expect { @class.new(:name => "foo", :ip => '10.10.10.10.10') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '10.10.10.10.10') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     it "should not accept malformed IP addresses like 2001:0dg8:85a3:08d3:1319:8a2e:0370:7344" do
-      expect { @class.new(:name => "foo", :ip => '2001:0dg8:85a3:08d3:1319:8a2e:0370:7344') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '2001:0dg8:85a3:08d3:1319:8a2e:0370:7344') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     # Assorted, annotated IPv6 passes.
@@ -598,7 +598,7 @@ describe host do
      "::2222:3333:4444:5555:6666:7777:8888:",
     ].each do |ip|
       it "should reject #{ip.inspect} as an IPv6 address" do
-        expect { @class.new(:name => "foo", :ip => ip) }.to raise_error
+        expect { @class.new(:name => "foo", :ip => ip) }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
       end
     end
 

data/spec/unit/type/package_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:package) do
   before do
+    Process.stubs(:euid).returns 0
     Puppet::Util::Storage.stubs(:store)
   end
 

data/spec/unit/type/tidy_spec.rb

@@ -66,7 +66,7 @@ describe tidy do
       end
 
       it "should not allow arbitrary values" do
-        expect { @tidy[:recurse] = "whatever" }.to raise_error
+        expect { @tidy[:recurse] = "whatever" }.to raise_error(Puppet::ResourceError, /Parameter recurse failed/)
       end
     end
 
@@ -76,13 +76,13 @@ describe tidy do
       end
 
       it "should object if matches is given with recurse is not specified" do
-        expect { @tidy[:matches] = '*.doh' }.to raise_error
+        expect { @tidy[:matches] = '*.doh' }.to raise_error(Puppet::ResourceError, /Parameter matches failed/)
       end
       it "should object if matches is given and recurse is 0" do
-        expect { @tidy[:recurse] = 0; @tidy[:matches] = '*.doh' }.to raise_error
+        expect { @tidy[:recurse] = 0; @tidy[:matches] = '*.doh' }.to raise_error(Puppet::ResourceError, /Parameter matches failed/)
       end
       it "should object if matches is given and recurse is false" do
-        expect { @tidy[:recurse] = false; @tidy[:matches] = '*.doh' }.to raise_error
+        expect { @tidy[:recurse] = false; @tidy[:matches] = '*.doh' }.to raise_error(Puppet::ResourceError, /Parameter matches failed/)
       end
       it "should not object if matches is given and recurse is > 0" do
         expect { @tidy[:recurse] = 1; @tidy[:matches] = '*.doh' }.not_to raise_error

data/spec/unit/type/user_spec.rb

@@ -344,13 +344,20 @@ describe Puppet::Type.type(:user) do
     end
   end
 
-  describe "when managing comment on Ruby 1.9", :if => String.method_defined?(:encode) do
-    it "should force value encoding to ASCII-8BIT" do
-      value = 'abcd™'
-      expect(value.encoding).to eq(Encoding::UTF_8)
-      user = described_class.new(:name => 'foo', :comment => value)
-      expect(user[:comment].encoding).to eq(Encoding::ASCII_8BIT)
-      expect(user[:comment]).to eq(value.force_encoding(Encoding::ASCII_8BIT))
+  describe "when managing comment" do
+    before :each do
+      @value = 'abcd™'
+      expect(@value.encoding).to eq(Encoding::UTF_8)
+      @user = described_class.new(:name => 'foo', :comment => @value)
+    end
+
+    it "should be converted to ASCII_8BIT for ruby 1.9 / 2.0", :if => RUBY_VERSION < "2.1.0" && String.method_defined?(:encode) do
+      expect(@user[:comment].encoding).to eq(Encoding::ASCII_8BIT)
+      expect(@user[:comment]).to eq(@value.force_encoding(Encoding::ASCII_8BIT))
+    end
+
+    it "must not be converted for ruby >= 2.1", :if => RUBY_VERSION >= "2.1.0" do
+      expect(@user[:comment].encoding).to eq(Encoding::UTF_8)
     end
   end
 

data/spec/unit/type/vlan_spec.rb

@@ -38,7 +38,7 @@ describe Puppet::Type.type(:vlan) do
     end
 
     it "should fail if vlan name is not a number" do
-      expect { Puppet::Type.type(:vlan).new(:name => "notanumber", :ensure => :present) }.to raise_error
+      expect { Puppet::Type.type(:vlan).new(:name => "notanumber", :ensure => :present) }.to raise_error(Puppet::ResourceError, /Parameter name failed on Vlan/)
     end
   end
 end

data/spec/unit/type_spec.rb

@@ -522,7 +522,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should fail if any invalid attributes have been provided" do
-      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /Invalid parameter/)
+      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /no parameter named 'nosuchattr'/)
     end
 
     context "when an attribute fails validation" do

data/spec/unit/util/ldap/generator_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::Util::Ldap::Generator do
   end
 
   it "should require a parameter name at initialization" do
-    expect { Puppet::Util::Ldap::Generator.new }.to raise_error
+    expect { Puppet::Util::Ldap::Generator.new }.to raise_error(ArgumentError, /wrong number of arguments/)
   end
 
   it "should always return its name as a string" do

data/spec/unit/util/network_device/cisco/device_spec.rb

@@ -133,7 +133,7 @@ describe Puppet::Util::NetworkDevice::Cisco::Device do
     describe "when entering enable password" do
       it "should raise an error if no enable password has been set" do
         @cisco.enable_password = nil
-        expect{ @cisco.enable }.to raise_error
+        expect{ @cisco.enable }.to raise_error(RuntimeError, /Can't issue "enable" to enter privileged/)
       end
 
       it "should send the enable command and expect an enable prompt" do

data/spec/unit/util/network_device/transport/ssh_spec.rb

@@ -65,7 +65,7 @@ describe Puppet::Util::NetworkDevice::Transport::Ssh, :if => Puppet.features.ssh
 
     it "should raise an error if shell channel creation fails" do
       @channel.expects(:send_channel_request).with("shell").yields(@channel, false)
-      expect { @transport.connect }.to raise_error
+      expect { @transport.connect }.to raise_error(RuntimeError, /failed to open ssh shell channel/)
     end
 
     it "should register an on_data and on_extended_data callback" do

data/spec/unit/util/network_device_spec.rb

@@ -35,7 +35,7 @@ describe Puppet::Util::NetworkDevice do
 
     it "should raise an error if the remote device instance can't be created" do
       Puppet::Util::NetworkDevice.stubs(:require).raises("error")
-      expect { Puppet::Util::NetworkDevice.init(@device) }.to raise_error
+      expect { Puppet::Util::NetworkDevice.init(@device) }.to raise_error(RuntimeError, /Can't load test for name/)
     end
 
     it "should let caller to access the singleton device" do

data/spec/unit/util/storage_spec.rb

@@ -188,7 +188,11 @@ describe Puppet::Util::Storage do
       Dir.mkdir(Puppet[:statefile])
       Puppet::Util::Storage.cache(:yayness)
 
-      expect { Puppet::Util::Storage.store }.to raise_error
+      if Puppet.features.microsoft_windows?
+        expect { Puppet::Util::Storage.store }.to raise_error(Puppet::Util::Windows::Error, /Access is denied/)
+      else
+        expect { Puppet::Util::Storage.store }.to raise_error(Errno::EISDIR, /Is a directory/)
+      end
 
       Dir.rmdir(Puppet[:statefile])
     end

data/spec/unit/util/windows/adsi_spec.rb

@@ -183,6 +183,19 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         user.password = 'pwd'
       end
 
+       it "should be able manage a user without a password" do
+        adsi_user.expects(:SetPassword).with('pwd').never
+        adsi_user.expects(:SetInfo).at_least_once
+
+        flagname = "UserFlags"
+        fADS_UF_DONT_EXPIRE_PASSWD = 0x10000
+
+        adsi_user.expects(:Get).with(flagname).returns(0)
+        adsi_user.expects(:Put).with(flagname, fADS_UF_DONT_EXPIRE_PASSWD)
+
+        user.password = nil
+      end
+
       it "should generate the correct URI" do
         Puppet::Util::Windows::SID.stubs(:octet_string_to_sid_object).returns(sid)
         expect(user.uri).to eq("WinNT://testcomputername/#{username},user")

data/spec/unit/util_spec.rb

@@ -229,11 +229,30 @@ describe Puppet::Util do
       (0..256).each {|n| IO.stubs(:new) }
     end
 
-    it "should close all open file descriptors except stdin/stdout/stderr" do
+    it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd exists" do
+      # This is ugly, but I can't really think of a better way to do it without
+      # letting it actually close fds, which seems risky
+      fds = [".", "..","0","1","2","3","5","100","1000"]
+      fds.each do |fd|
+        if fd == '.' || fd == '..'
+          next
+        elsif ['0', '1', '2'].include? fd
+          IO.expects(:new).with(fd.to_i).never
+        else
+          IO.expects(:new).with(fd.to_i).returns mock('io', :close)
+        end
+      end
+
+      Dir.stubs(:foreach).with('/proc/self/fd').multiple_yields(*fds)
+      Puppet::Util.safe_posix_fork
+    end
+
+    it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd doesn't exists" do
       # This is ugly, but I can't really think of a better way to do it without
       # letting it actually close fds, which seems risky
       (0..2).each {|n| IO.expects(:new).with(n).never}
-      (3..256).each {|n| IO.expects(:new).with(n).returns mock('io', :close) }
+      (3..256).each { |n| IO.expects(:new).with(n).returns mock('io', :close)  }
+      Dir.stubs(:foreach).with('/proc/self/fd') { raise Errno::ENOENT }
 
       Puppet::Util.safe_posix_fork
     end