puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/ssl/certificate_factory_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_factory'
@@ -59,7 +58,7 @@ describe Puppet::SSL::CertificateFactory do
     it "should set the default TTL of the certificate to the `ca_ttl` setting" do
       Puppet[:ca_ttl] = 12
       now = Time.now.utc
-      Time.expects(:now).at_least_once.returns(now)
+      expect(Time).to receive(:now).at_least(:once).and_return(now)
       cert = subject.build(:server, csr, issuer, serial)
       expect(cert.not_after.to_i).to eq(now.to_i + 12)
     end
@@ -72,7 +71,7 @@ describe Puppet::SSL::CertificateFactory do
 
     it "should respect a custom TTL for the CA" do
       now = Time.now.utc
-      Time.expects(:now).at_least_once.returns(now)
+      expect(Time).to receive(:now).at_least(:once).and_return(now)
       cert = subject.build(:server, csr, issuer, serial, 12)
       expect(cert.not_after.to_i).to eq(now.to_i + 12)
     end
@@ -96,7 +95,6 @@ describe Puppet::SSL::CertificateFactory do
       )
     end
 
-
     it "should add an extension for the authorityKeyIdentifer" do
       cert = subject.build(:server, csr, issuer, serial)
       ef = OpenSSL::X509::ExtensionFactory.new(issuer, cert)
@@ -140,7 +138,7 @@ describe Puppet::SSL::CertificateFactory do
       csr = Puppet::SSL::CertificateRequest.new(name)
       csr.generate(key)
 
-      csr.stubs(:request_extensions).returns([
+      allow(csr).to receive(:request_extensions).and_return([
         {'oid' => '1.3.6.1.4.1.34380.1.2.1', 'value' => 'some-value'},
         {'oid' => 'pp_uuid', 'value' => 'some-uuid'},
       ])

data/spec/unit/ssl/certificate_request_attributes_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 require 'puppet/ssl/certificate_request_attributes'
 
 describe Puppet::SSL::CertificateRequestAttributes do
-
   let(:expected) do
     {
       "custom_attributes" => {
@@ -33,8 +32,8 @@ describe Puppet::SSL::CertificateRequestAttributes do
 
     context "with an available attributes file" do
       before do
-        Puppet::FileSystem.expects(:exist?).with(csr_attributes_path).returns(true)
-        Puppet::Util::Yaml.expects(:load_file).with(csr_attributes_path, {}).returns(csr_attributes_hash)
+        expect(Puppet::FileSystem).to receive(:exist?).with(csr_attributes_path).and_return(true)
+        expect(Puppet::Util::Yaml).to receive(:load_file).with(csr_attributes_path, {}).and_return(csr_attributes_hash)
       end
 
       it "loads csr attributes from a file when the file is present" do

data/spec/unit/ssl/certificate_request_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_request'
@@ -12,7 +11,6 @@ describe Puppet::SSL::CertificateRequest do
     k
   }
 
-
   it "should be extended with the Indirector module" do
     expect(described_class.singleton_class).to be_include(Puppet::Indirector)
   end
@@ -31,15 +29,15 @@ describe Puppet::SSL::CertificateRequest do
 
   describe "when converting from a string" do
     it "should create a CSR instance with its name set to the CSR subject and its content set to the extracted CSR" do
-      csr = stub 'csr',
+      csr = double('csr',
         :subject => OpenSSL::X509::Name.parse("/CN=Foo.madstop.com"),
-        :is_a? => true
-      OpenSSL::X509::Request.expects(:new).with("my csr").returns(csr)
+        :is_a? => true)
+      expect(OpenSSL::X509::Request).to receive(:new).with("my csr").and_return(csr)
 
-      mycsr = stub 'sslcsr'
-      mycsr.expects(:content=).with(csr)
+      mycsr = double('sslcsr')
+      expect(mycsr).to receive(:content=).with(csr)
 
-      described_class.expects(:new).with("Foo.madstop.com").returns mycsr
+      expect(described_class).to receive(:new).with("Foo.madstop.com").and_return(mycsr)
 
       described_class.from_s("my csr")
     end
@@ -60,9 +58,9 @@ describe Puppet::SSL::CertificateRequest do
 
     it "should be able to read requests from disk" do
       path = "/my/path"
-      Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding::ASCII).returns("my request")
-      my_req = mock 'request'
-      OpenSSL::X509::Request.expects(:new).with("my request").returns(my_req)
+      expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my request")
+      my_req = double('request')
+      expect(OpenSSL::X509::Request).to receive(:new).with("my request").and_return(my_req)
       expect(request.read(path)).to equal(my_req)
       expect(request.content).to equal(my_req)
     end
@@ -77,8 +75,8 @@ describe Puppet::SSL::CertificateRequest do
     end
 
     it "should have a :to_text method that it delegates to the actual key" do
-      real_request = mock 'request'
-      real_request.expects(:to_text).returns "requesttext"
+      real_request = double('request')
+      expect(real_request).to receive(:to_text).and_return("requesttext")
       request.content = real_request
       expect(request.to_text).to eq("requesttext")
     end
@@ -308,26 +306,26 @@ describe Puppet::SSL::CertificateRequest do
 
     it "should verify the generated request using the public key" do
       # Stupid keys don't have a competent == method.
-      OpenSSL::X509::Request.any_instance.expects(:verify).with { |public_key|
+      expect_any_instance_of(OpenSSL::X509::Request).to receive(:verify) do |public_key|
         public_key.to_s == key.content.public_key.to_s
-      }.returns true
+      end.and_return(true)
       request.generate(key)
     end
 
     it "should fail if verification fails" do
-      OpenSSL::X509::Request.any_instance.expects(:verify).with { |public_key|
+      expect_any_instance_of(OpenSSL::X509::Request).to receive(:verify) do |public_key|
         public_key.to_s == key.content.public_key.to_s
-      }.returns false
+      end.and_return(false)
 
-      expect {
+      expect do
         request.generate(key)
-      }.to raise_error(Puppet::Error, /CSR sign verification failed/)
+      end.to raise_error(Puppet::Error, /CSR sign verification failed/)
     end
 
     it "should log the fingerprint" do
-      Puppet::SSL::Digest.any_instance.stubs(:to_hex).returns("FINGERPRINT")
-      Puppet.stubs(:info)
-      Puppet.expects(:info).with { |s| s =~ /FINGERPRINT/ }
+      allow_any_instance_of(Puppet::SSL::Digest).to receive(:to_hex).and_return("FINGERPRINT")
+      allow(Puppet).to receive(:info)
+      expect(Puppet).to receive(:info).with(/FINGERPRINT/)
       request.generate(key)
     end
 
@@ -339,8 +337,8 @@ describe Puppet::SSL::CertificateRequest do
 
     it "should use SHA1 to sign the csr when SHA256 isn't available" do
       csr = OpenSSL::X509::Request.new
-      OpenSSL::Digest.expects(:const_defined?).with("SHA256").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA1").returns(true)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(true)
       signer = Puppet::SSL::CertificateSigner.new
       signer.sign(csr, key.content)
       expect(csr.verify(key.content)).to be_truthy
@@ -350,46 +348,49 @@ describe Puppet::SSL::CertificateRequest do
     # So commenting it out till it is sorted out
     # The problem seems to be with the ability to sign a CSR when using either of
     # these hash algorithms
+    pending "should use SHA512 to sign the csr when SHA256 and SHA1 aren't available" do
+      csr = OpenSSL::X509::Request.new
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA512").and_return(true)
+      signer = Puppet::SSL::CertificateSigner.new
+      signer.sign(csr, key.content)
+      expect(csr.verify(key.content)).to be_truthy
+    end
 
-#    it "should use SHA512 to sign the csr when SHA256 and SHA1 aren't available" do
-#      csr = OpenSSL::X509::Request.new
-#      OpenSSL::Digest.expects(:const_defined?).with("SHA256").returns(false)
-#      OpenSSL::Digest.expects(:const_defined?).with("SHA1").returns(false)
-#      OpenSSL::Digest.expects(:const_defined?).with("SHA512").returns(true)
-#      signer = Puppet::SSL::CertificateSigner.new
-#      signer.sign(csr, key.content)
-#      expect(csr.verify(key.content)).to be_truthy
-#    end
-
-#    it "should use SHA384 to sign the csr when SHA256/SHA1/SHA512 aren't available" do
-#      csr = OpenSSL::X509::Request.new
-#      OpenSSL::Digest.expects(:const_defined?).with("SHA256").returns(false)
-#      OpenSSL::Digest.expects(:const_defined?).with("SHA1").returns(false)
-#      OpenSSL::Digest.expects(:const_defined?).with("SHA512").returns(false)
-#      OpenSSL::Digest.expects(:const_defined?).with("SHA384").returns(true)
-#      signer = Puppet::SSL::CertificateSigner.new
-#      signer.sign(csr, key.content)
-#      expect(csr.verify(key.content)).to be_truthy
-#    end
+    # Attempts to use SHA512 and SHA384 for signing certificates don't seem to work
+    # So commenting it out till it is sorted out
+    # The problem seems to be with the ability to sign a CSR when using either of
+    # these hash algorithms
+    pending "should use SHA384 to sign the csr when SHA256/SHA1/SHA512 aren't available" do
+      csr = OpenSSL::X509::Request.new
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA512").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA384").and_return(true)
+      signer = Puppet::SSL::CertificateSigner.new
+      signer.sign(csr, key.content)
+      expect(csr.verify(key.content)).to be_truthy
+    end
 
     it "should use SHA224 to sign the csr when SHA256/SHA1/SHA512/SHA384 aren't available" do
       csr = OpenSSL::X509::Request.new
-      OpenSSL::Digest.expects(:const_defined?).with("SHA256").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA1").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA512").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA384").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA224").returns(true)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA512").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA384").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA224").and_return(true)
       signer = Puppet::SSL::CertificateSigner.new
       signer.sign(csr, key.content)
       expect(csr.verify(key.content)).to be_truthy
     end
 
     it "should raise an error if neither SHA256/SHA1/SHA512/SHA384/SHA224 are available" do
-      OpenSSL::Digest.expects(:const_defined?).with("SHA256").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA1").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA512").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA384").returns(false)
-      OpenSSL::Digest.expects(:const_defined?).with("SHA224").returns(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA512").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA384").and_return(false)
+      expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA224").and_return(false)
       expect {
         Puppet::SSL::CertificateSigner.new
       }.to raise_error(Puppet::Error)
@@ -399,14 +400,14 @@ describe Puppet::SSL::CertificateRequest do
   describe "when a CSR is saved" do
     describe "and a CA is available" do
       it "should save the CSR and trigger autosigning" do
-        ca = mock 'ca', :autosign
-        Puppet::SSL::CertificateAuthority.expects(:instance).returns ca
+        ca = double('ca', autosign: nil)
+        expect(Puppet::SSL::CertificateAuthority).to receive(:instance).and_return(ca)
 
         csr = Puppet::SSL::CertificateRequest.new("me")
-        terminus = mock 'terminus'
-        terminus.stubs(:validate)
-        Puppet::SSL::CertificateRequest.indirection.expects(:prepare).returns(terminus)
-        terminus.expects(:save).with { |request| request.instance == csr && request.key == "me" }
+        terminus = double('terminus')
+        allow(terminus).to receive(:validate)
+        expect(Puppet::SSL::CertificateRequest.indirection).to receive(:prepare).and_return(terminus)
+        expect(terminus).to receive(:save) { |request| request.instance == csr && request.key == "me" }
 
         Puppet::SSL::CertificateRequest.indirection.save(csr)
       end
@@ -414,18 +415,16 @@ describe Puppet::SSL::CertificateRequest do
 
     describe "and a CA is not available" do
       it "should save the CSR" do
-        Puppet::SSL::CertificateAuthority.expects(:instance).returns nil
+        expect(Puppet::SSL::CertificateAuthority).to receive(:instance).and_return(nil)
 
         csr = Puppet::SSL::CertificateRequest.new("me")
-        terminus = mock 'terminus'
-        terminus.stubs(:validate)
-        Puppet::SSL::CertificateRequest.indirection.expects(:prepare).returns(terminus)
-        terminus.expects(:save).with { |request| request.instance == csr && request.key == "me" }
+        terminus = double('terminus')
+        allow(terminus).to receive(:validate)
+        expect(Puppet::SSL::CertificateRequest.indirection).to receive(:prepare).and_return(terminus)
+        expect(terminus).to receive(:save) { |request| request.instance == csr && request.key == "me" }
 
         Puppet::SSL::CertificateRequest.indirection.save(csr)
       end
     end
-
-
   end
 end

data/spec/unit/ssl/certificate_revocation_list_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_revocation_list'
@@ -136,7 +135,7 @@ describe Puppet::SSL::CertificateRevocationList do
       @crl = @class.new("crl")
       @crl.generate(@cert, @key)
 
-      Puppet::SSL::CertificateRevocationList.indirection.stubs :save
+      allow(Puppet::SSL::CertificateRevocationList.indirection).to receive(:save)
     end
 
     it "should require a serial number and the CA's private key" do
@@ -157,12 +156,12 @@ describe Puppet::SSL::CertificateRevocationList do
 
     it "should sign the CRL with the CA's private key and a digest instance" do
       digest = Puppet::SSL::CertificateSigner.new.digest
-      @crl.content.expects(:sign).with { |key, signer| key == @key and signer.is_a?(digest) }
+      expect(@crl.content).to receive(:sign).with(@key, be_a(digest))
       @crl.revoke(1, @key)
     end
 
     it "should save the CRL" do
-      Puppet::SSL::CertificateRevocationList.indirection.expects(:save).with(@crl, nil)
+      expect(Puppet::SSL::CertificateRevocationList.indirection).to receive(:save).with(@crl, any_args)
       @crl.revoke(1, @key)
     end
 

data/spec/unit/ssl/certificate_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/certificate'
@@ -34,24 +33,26 @@ describe Puppet::SSL::Certificate do
 
   describe "when converting from a string" do
     it "should create a certificate instance with its name set to the certificate subject and its content set to the extracted certificate" do
-      cert = stub 'certificate',
+      cert = double(
+        'certificate',
         :subject => OpenSSL::X509::Name.parse("/CN=Foo.madstop.com"),
         :is_a? => true
-      OpenSSL::X509::Certificate.expects(:new).with("my certificate").returns(cert)
+      )
+      expect(OpenSSL::X509::Certificate).to receive(:new).with("my certificate").and_return(cert)
 
-      mycert = stub 'sslcert'
-      mycert.expects(:content=).with(cert)
+      mycert = double('sslcert')
+      expect(mycert).to receive(:content=).with(cert)
 
-      @class.expects(:new).with("Foo.madstop.com").returns mycert
+      expect(@class).to receive(:new).with("Foo.madstop.com").and_return(mycert)
 
       @class.from_s("my certificate")
     end
 
     it "should create multiple certificate instances when asked" do
-      cert1 = stub 'cert1'
-      @class.expects(:from_s).with("cert1").returns cert1
-      cert2 = stub 'cert2'
-      @class.expects(:from_s).with("cert2").returns cert2
+      cert1 = double('cert1')
+      expect(@class).to receive(:from_s).with("cert1").and_return(cert1)
+      cert2 = double('cert2')
+      expect(@class).to receive(:from_s).with("cert2").and_return(cert2)
 
       expect(@class.from_multiple_s("cert1\n---\ncert2")).to eq([cert1, cert2])
     end
@@ -67,15 +68,15 @@ describe Puppet::SSL::Certificate do
     end
 
     it "should convert the certificate to pem format" do
-      certificate = mock 'certificate', :to_pem => "pem"
+      certificate = double('certificate', :to_pem => "pem")
       @certificate.content = certificate
       expect(@certificate.to_s).to eq("pem")
     end
 
     it "should be able to convert multiple instances to a string" do
       cert2 = @class.new("foo")
-      @certificate.expects(:to_s).returns "cert1"
-      cert2.expects(:to_s).returns "cert2"
+      expect(@certificate).to receive(:to_s).and_return("cert1")
+      expect(cert2).to receive(:to_s).and_return("cert2")
 
       expect(@class.to_multiple_s([@certificate, cert2])).to eq("cert1\n---\ncert2")
 
@@ -83,7 +84,6 @@ describe Puppet::SSL::Certificate do
   end
 
   describe "when managing instances" do
-
     def build_cert(opts)
       key = Puppet::SSL::Key.new('quux')
       key.generate
@@ -142,36 +142,35 @@ describe Puppet::SSL::Certificate do
         cert = build_cert(:dns_alt_names => 'foo')
         expect(cert.custom_extensions).to be_empty
       end
-
     end
 
     it "should return a nil expiration if there is no actual certificate" do
-      @certificate.stubs(:content).returns nil
+      allow(@certificate).to receive(:content).and_return(nil)
 
       expect(@certificate.expiration).to be_nil
     end
 
     it "should use the expiration of the certificate as its expiration date" do
-      cert = stub 'cert'
-      @certificate.stubs(:content).returns cert
+      cert = double('cert')
+      allow(@certificate).to receive(:content).and_return(cert)
 
-      cert.expects(:not_after).returns "sometime"
+      expect(cert).to receive(:not_after).and_return("sometime")
 
       expect(@certificate.expiration).to eq("sometime")
     end
 
     it "should be able to read certificates from disk" do
       path = "/my/path"
-      Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding::ASCII).returns("my certificate")
-      certificate = mock 'certificate'
-      OpenSSL::X509::Certificate.expects(:new).with("my certificate").returns(certificate)
+      expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my certificate")
+      certificate = double('certificate')
+      expect(OpenSSL::X509::Certificate).to receive(:new).with("my certificate").and_return(certificate)
       expect(@certificate.read(path)).to equal(certificate)
       expect(@certificate.content).to equal(certificate)
     end
 
     it "should have a :to_text method that it delegates to the actual key" do
-      real_certificate = mock 'certificate'
-      real_certificate.expects(:to_text).returns "certificatetext"
+      real_certificate = double('certificate')
+      expect(real_certificate).to receive(:to_text).and_return("certificatetext")
       @certificate.content = real_certificate
       expect(@certificate.to_text).to eq("certificatetext")
     end
@@ -185,6 +184,5 @@ describe Puppet::SSL::Certificate do
       expect(exts.find { |ext| ext['oid'] == 'pp_instance_id'}['value']).to eq('i_am_an_id')
       expect(exts.find { |ext| ext['oid'] == 'pp_image_name'}['value']).to eq('i_am_an_image_name')
     end
-
   end
 end

data/spec/unit/ssl/configuration_spec.rb

@@ -1,6 +1,3 @@
-#! /usr/bin/env ruby
-#
-
 require 'spec_helper'
 require 'puppet/ssl/configuration'
 
@@ -51,7 +48,7 @@ describe Puppet::SSL::Configuration do
     end
 
     it "#ca_auth_certificates returns an Array<OpenSSL::X509::Certificate>" do
-      Puppet::FileSystem.expects(:read).with(subject.ca_auth_file, :encoding => Encoding::UTF_8).returns(master_ca_pem + root_ca_pem)
+      expect(Puppet::FileSystem).to receive(:read).with(subject.ca_auth_file, :encoding => Encoding::UTF_8).and_return(master_ca_pem + root_ca_pem)
       certs = subject.ca_auth_certificates
       certs.each { |cert| expect(cert).to be_a_kind_of OpenSSL::X509::Certificate }
     end