puppet 4.0.0 → 4.10.0

data/spec/unit/settings/ini_file_spec.rb

@@ -4,6 +4,13 @@ require 'stringio'
 require 'puppet/settings/ini_file'
 
 describe Puppet::Settings::IniFile do
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ𠜎
+
   it "preserves the file when no changes are made" do
     original_config = <<-CONFIG
     # comment
@@ -27,6 +34,16 @@ describe Puppet::Settings::IniFile do
     expect(config_fh.string).to eq "[the_section]\nname = value\n"
   end
 
+  it "adds a UTF-8 name and value to an empty file" do
+    config_fh = a_config_file_containing("")
+
+    Puppet::Settings::IniFile.update(config_fh) do |config|
+      config.set("the_section", mixed_utf8, mixed_utf8.reverse)
+    end
+
+    expect(config_fh.string).to eq "[the_section]\n#{mixed_utf8} = #{mixed_utf8.reverse}\n"
+  end
+
   it "does not add a [main] section to a file when it isn't needed" do
     config_fh = a_config_file_containing(<<-CONF)
     [section]
@@ -45,6 +62,22 @@ name = value
     CONF
   end
 
+  it "can update values within a UTF-8 section of an existing file" do
+    config_fh = a_config_file_containing(<<-CONF)
+    [#{mixed_utf8}]
+    foo = default
+    CONF
+
+    Puppet::Settings::IniFile.update(config_fh) do |config|
+      config.set(mixed_utf8, 'foo', 'bar')
+    end
+
+    expect(config_fh.string).to eq(<<-CONF)
+    [#{mixed_utf8}]
+    foo = bar
+    CONF
+  end
+
   it "preserves comments when writing a new name and value" do
     config_fh = a_config_file_containing("# this is a comment")
 
@@ -75,6 +108,29 @@ name = value
     CONFIG
   end
 
+  it "updates existing UTF-8 name / values in place" do
+    config_fh = a_config_file_containing(<<-CONFIG)
+    # this is the preceding comment
+     [section]
+    ascii = foo
+    #{mixed_utf8} = bar
+    # this is the trailing comment
+    CONFIG
+
+    Puppet::Settings::IniFile.update(config_fh) do |config|
+      config.set("section", "ascii", mixed_utf8)
+      config.set("section", mixed_utf8, mixed_utf8.reverse)
+    end
+
+    expect(config_fh.string).to eq <<-CONFIG
+    # this is the preceding comment
+     [section]
+    ascii = #{mixed_utf8}
+    #{mixed_utf8} = #{mixed_utf8.reverse}
+    # this is the trailing comment
+    CONFIG
+  end
+
   it "updates only the value in the selected section" do
     config_fh = a_config_file_containing(<<-CONFIG)
     [other_section]
@@ -179,6 +235,7 @@ updated = new
   end
 
   def a_config_file_containing(text)
-    StringIO.new(text)
+    # set_encoding required for Ruby 1.9.3 as ASCII is the default
+    StringIO.new(text).set_encoding(Encoding::UTF_8)
   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
@@ -1275,8 +1375,21 @@ describe Puppet::Settings do
     end
 
     describe "when adding users and groups to the catalog" do
+      before :all do
+        # when this spec is run in isolation to build a settings catalog
+        # it will not be able to autorequire and load types for the first time
+        # on Windows with microsoft_windows? stubbed to false, because
+        # Puppet::Util.path_to_uri is called to generate a URI to load code
+        # and it manipulates the path based on OS
+        # so instead we forcefully "prime" the cached types
+        Puppet::Type.type(:user).new(:name => 'foo')
+        Puppet::Type.type(:group).new(:name => 'bar')
+        Puppet::Type.type(:file).new(:name => Dir.pwd) # appropriate for OS
+      end
+
       before do
         Puppet.features.stubs(:root?).returns true
+        # stubbed to false, as Windows catalogs don't add users / groups
         Puppet.features.stubs(:microsoft_windows?).returns false
 
         @settings.define_settings :foo,
@@ -1723,7 +1836,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/base_spec.rb

@@ -45,6 +45,15 @@ describe Puppet::SSL::Certificate do
     end
   end
 
+  describe "when initializing wrapped class from a file with #read" do
+    it "should open the file with ASCII encoding" do
+      path = '/foo/bar/cert'
+      Puppet::SSL::Base.stubs(:valid_certname).returns(true)
+      Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding::ASCII).returns("bar")
+      @base.read(path)
+    end
+  end
+
   describe "#digest_algorithm" do
     let(:content) { stub 'content' }
     let(:base) {

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

@@ -125,8 +125,8 @@ describe Puppet::SSL::CertificateAuthority::Interface do
       it "should call :generate on the CA for each host specified" do
         @applier = @class.new(:generate, :to => %w{host1 host2})
 
-        @ca.expects(:generate).with("host1", {})
-        @ca.expects(:generate).with("host2", {})
+        @ca.expects(:generate).with() {|*args| args.first == "host1" }
+        @ca.expects(:generate).with() {|*args| args.first == "host2" }
 
         @applier.apply(@ca)
       end
@@ -156,23 +156,79 @@ describe Puppet::SSL::CertificateAuthority::Interface do
     end
 
     describe ":sign" do
+      before do
+        @csr1 = Puppet::SSL::CertificateRequest.new 'baz'
+      end
+
+      describe "when run in interactive mode" do
+        before do
+          Puppet::SSL::CertificateRequest.indirection.stubs(:find).with("csr1").returns @csr1
+
+          @ca.stubs(:waiting?).returns(%w{csr1})
+          @ca.stubs(:check_internal_signing_policies).returns(true)
+        end
+
+        it "should prompt before signing cert" do
+          @applier = @class.new(:sign, :to => :all, :interactive => true)
+          @applier.stubs(:format_host).returns("(host info)")
+
+          @applier.expects(:puts).
+            with("Signing Certificate Request for:\n(host info)")
+
+          STDOUT.expects(:print).with("Sign Certificate Request? [y/N] ")
+
+          STDIN.stubs(:gets).returns('y')
+          @ca.expects(:sign).with("csr1", {})
+
+          @applier.apply(@ca)
+        end
+
+        it "a yes answer can be assumed via options" do
+          @applier = @class.new(:sign, :to => :all, :interactive => true, :yes => true)
+          @applier.stubs(:format_host).returns("(host info)")
+
+          @applier.expects(:puts).
+            with("Signing Certificate Request for:\n(host info)")
+
+          STDOUT.expects(:print).with("Sign Certificate Request? [y/N] ")
+
+          @applier.expects(:puts).
+            with("Assuming YES from `-y' or `--assume-yes' flag")
+
+          @ca.expects(:sign).with("csr1", {})
+
+          @applier.apply(@ca)
+        end
+      end
+
       describe "and an array of names was provided" do
+        before do
+          Puppet::SSL::CertificateRequest.indirection.stubs(:find).with("host1").returns @csr1
+          Puppet::SSL::CertificateRequest.indirection.stubs(:find).with("host2").returns @csr1
+        end
+
         let(:applier) { @class.new(:sign, @options.merge(:to => %w{host1 host2})) }
 
         it "should sign the specified waiting certificate requests" do
           @options = {:allow_dns_alt_names => false}
+          applier.stubs(:format_host).returns("")
+          applier.stubs(:puts)
+          @ca.stubs(:check_internal_signing_policies).returns(true)
 
-          @ca.expects(:sign).with("host1", false)
-          @ca.expects(:sign).with("host2", false)
+          @ca.expects(:sign).with("host1", @options)
+          @ca.expects(:sign).with("host2", @options)
 
           applier.apply(@ca)
         end
 
         it "should sign the certificate requests with alt names if specified" do
           @options = {:allow_dns_alt_names => true}
+          applier.stubs(:format_host).returns("")
+          applier.stubs(:puts)
+          @ca.stubs(:check_internal_signing_policies).returns(true)
 
-          @ca.expects(:sign).with("host1", true)
-          @ca.expects(:sign).with("host2", true)
+          @ca.expects(:sign).with("host1", @options)
+          @ca.expects(:sign).with("host2", @options)
 
           applier.apply(@ca)
         end
@@ -181,11 +237,16 @@ describe Puppet::SSL::CertificateAuthority::Interface do
       describe "and :all was provided" do
         it "should sign all waiting certificate requests" do
           @ca.stubs(:waiting?).returns(%w{cert1 cert2})
+          Puppet::SSL::CertificateRequest.indirection.stubs(:find).with("cert1").returns @csr1
+          Puppet::SSL::CertificateRequest.indirection.stubs(:find).with("cert2").returns @csr1
+          @ca.stubs(:check_internal_signing_policies).returns(true)
 
-          @ca.expects(:sign).with("cert1", nil)
-          @ca.expects(:sign).with("cert2", nil)
+          @ca.expects(:sign).with("cert1", {})
+          @ca.expects(:sign).with("cert2", {})
 
           @applier = @class.new(:sign, :to => :all)
+          @applier.stubs(:format_host).returns("")
+          @applier.stubs(:puts)
           @applier.apply(@ca)
         end
 
@@ -199,18 +260,33 @@ describe Puppet::SSL::CertificateAuthority::Interface do
     end
 
     describe ":list" do
+      let(:signed_alt_names) { [] }
+      let(:request_alt_names) { [] }
+      let(:custom_attrs) { [] }
+      let(:ext_requests) { [] }
+      let(:custom_exts) { [] }
+
       before :each do
         @cert = Puppet::SSL::Certificate.new 'foo'
         @csr = Puppet::SSL::CertificateRequest.new 'bar'
 
-        @cert.stubs(:subject_alt_names).returns []
-        @csr.stubs(:subject_alt_names).returns []
+        @cert.stubs(:subject_alt_names).returns signed_alt_names
+        @cert.stubs(:custom_extensions).returns custom_exts
+
+        @csr.stubs(:subject_alt_names).returns request_alt_names
+        @csr.stubs(:custom_attributes).returns custom_attrs
+        @csr.stubs(:request_extensions).returns ext_requests
 
         Puppet::SSL::Certificate.indirection.stubs(:find).returns @cert
         Puppet::SSL::CertificateRequest.indirection.stubs(:find).returns @csr
 
         @digest = mock("digest")
         @digest.stubs(:to_s).returns("(fingerprint)")
+
+        @expiration = mock('time')
+        @expiration.stubs(:iso8601).returns("(expiration)")
+        @cert.stubs(:expiration).returns(@expiration)
+
         @ca.expects(:waiting?).returns %w{host1 host2 host3}
         @ca.expects(:list).returns(%w{host4 host5 host6}).at_most(1)
         @csr.stubs(:digest).returns @digest
@@ -293,6 +369,96 @@ describe Puppet::SSL::CertificateAuthority::Interface do
           applier.apply(@ca)
         end
       end
+
+      describe "with custom attrbutes and extensions" do
+        let(:custom_attrs) { [{'oid' => 'customAttr', 'value' => 'attrValue'}] }
+        let(:ext_requests) { [{'oid' => 'customExt', 'value' => 'reqExtValue'}] }
+        let(:custom_exts) {  [{'oid' => 'extName', 'value' => 'extValue'}] }
+        let(:signed_alt_names) { ["DNS:puppet", "DNS:puppet.example.com"] }
+
+        before do
+          @ca.unstub(:waiting?)
+          @ca.unstub(:list)
+          @ca.expects(:waiting?).returns %w{ext3}
+          @ca.expects(:list).returns(%w{ext1 ext2}).at_most(1)
+
+          @ca.stubs(:verify).with("ext2").
+            raises(Puppet::SSL::CertificateAuthority::CertificateVerificationError.new(23),
+                   "certificate revoked")
+
+          Puppet::SSL::Certificate.indirection.stubs(:find).returns @cert
+          Puppet::SSL::CertificateRequest.indirection.stubs(:find).returns @csr
+        end
+
+        describe "using legacy format" do
+          it "should append astrisks to end of line to denote additional information available" do
+            applier = @class.new(:list, :to => %w{ext1 ext2 ext3})
+
+            applier.expects(:puts).with(<<-OUTPUT.chomp)
+  "ext3" (fingerprint) **
++ "ext1" (fingerprint) (alt names: "DNS:puppet", "DNS:puppet.example.com") **
+- "ext2" (fingerprint) (certificate revoked)
+              OUTPUT
+
+            applier.apply(@ca)
+          end
+
+          it "should append attributes and extensions to end of line when running :verbose" do
+            applier = @class.new(:list, :to => %w{ext1 ext2 ext3}, :verbose => true)
+
+            applier.expects(:puts).with(<<-OUTPUT.chomp)
+  "ext3" (fingerprint) (customAttr: "attrValue", customExt: "reqExtValue")
++ "ext1" (fingerprint) (expiration) (alt names: "DNS:puppet", "DNS:puppet.example.com", extName: "extValue")
+- "ext2" (fingerprint) (certificate revoked)
+              OUTPUT
+
+            applier.apply(@ca)
+          end
+        end
+
+        describe "using line-wise format" do
+          it "use the same format as :verbose legacy format" do
+            applier = @class.new(:list, :to => %w{ext1 ext2 ext3}, :format => :machine)
+
+            applier.expects(:puts).with(<<-OUTPUT.chomp)
+  "ext3" (fingerprint) (customAttr: "attrValue", customExt: "reqExtValue")
++ "ext1" (fingerprint) (expiration) (alt names: "DNS:puppet", "DNS:puppet.example.com", extName: "extValue")
+- "ext2" (fingerprint) (certificate revoked)
+              OUTPUT
+
+            applier.apply(@ca)
+          end
+        end
+
+        describe "using human friendly format" do
+          it "should break attributes and extensions to separate lines" do
+            applier = @class.new(:list, :to => %w{ext1 ext2 ext3}, :format => :human)
+
+            applier.expects(:puts).with(<<-OUTPUT)
+  "ext3"
+  (fingerprint)
+    Status: Request Pending
+    Extensions:
+      customAttr: "attrValue"
+      customExt: "reqExtValue"
+
++ "ext1"
+  (fingerprint)
+    Status: Signed
+    Expiration: (expiration)
+    Extensions:
+      alt names: "DNS:puppet", "DNS:puppet.example.com"
+      extName: "extValue"
+
+- "ext2"
+  (fingerprint)
+    Status: Invalid - (certificate revoked)
+OUTPUT
+
+            applier.apply(@ca)
+          end
+        end
+      end
     end
 
     describe ":print" do
@@ -332,9 +498,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