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

data/spec/unit/ssl/inventory_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/inventory'
@@ -28,31 +27,35 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
     before do
       Puppet[:cert_inventory] = cert_inventory
 
-      Puppet::FileSystem.stubs(:exist?).with(cert_inventory).returns true
+      allow(Puppet::FileSystem).to receive(:exist?).with(cert_inventory).and_return(true)
 
       @inventory = @class.new
 
-      @cert = mock 'cert'
+      @cert = double('cert')
     end
 
     describe "and creating the inventory file" do
       it "re-adds all of the existing certificates" do
         inventory_file = StringIO.new
-        Puppet.settings.setting(:cert_inventory).stubs(:open).yields(inventory_file)
+        allow(Puppet.settings.setting(:cert_inventory)).to receive(:open).and_yield(inventory_file)
 
         cert1 = Puppet::SSL::Certificate.new("cert1")
-        cert1.content = stub 'cert1',
+        cert1.content = double(
+          'cert1',
           :serial => 2,
           :not_before => Time.now,
           :not_after => Time.now,
-          :subject => "/CN=smocking"
+          :subject => "/CN=smocking",
+        )
         cert2 = Puppet::SSL::Certificate.new("cert2")
-        cert2.content = stub 'cert2',
+        cert2.content = double(
+          'cert2',
           :serial => 3,
           :not_before => Time.now,
           :not_after => Time.now,
-          :subject => "/CN=mocking bird"
-        Puppet::SSL::Certificate.indirection.expects(:search).with("*").returns [cert1, cert2]
+          :subject => "/CN=mocking bird",
+        )
+        expect(Puppet::SSL::Certificate.indirection).to receive(:search).with("*").and_return([cert1, cert2])
 
         @inventory.rebuild
 
@@ -62,9 +65,8 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
     end
 
     describe "and adding a certificate" do
-
       it "should use the Settings to write to the file" do
-        Puppet.settings.setting(:cert_inventory).expects(:open).with('a:UTF-8')
+        expect(Puppet.settings.setting(:cert_inventory)).to receive(:open).with('a:UTF-8')
 
         @inventory.add(@cert)
       end
@@ -74,9 +76,9 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
         cert.content = @cert
 
         fh = StringIO.new
-        Puppet.settings.setting(:cert_inventory).expects(:open).with('a:UTF-8').yields(fh)
+        expect(Puppet.settings.setting(:cert_inventory)).to receive(:open).with('a:UTF-8').and_yield(fh)
 
-        @inventory.expects(:format).with(@cert).returns "myformat"
+        expect(@inventory).to receive(:format).with(@cert).and_return("myformat")
 
         @inventory.add(@cert)
 
@@ -85,14 +87,16 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
 
       it "can use UTF-8 in the CN per RFC 5280" do
         cert = Puppet::SSL::Certificate.new("mycert")
-        cert.content = stub 'cert',
+        cert.content = double(
+          'cert',
           :serial => 1,
           :not_before => Time.now,
           :not_after => Time.now,
-          :subject => "/CN=#{mixed_utf8}"
+          :subject => "/CN=#{mixed_utf8}",
+        )
 
         fh = StringIO.new
-        Puppet.settings.setting(:cert_inventory).expects(:open).with('a:UTF-8').yields(fh)
+        expect(Puppet.settings.setting(:cert_inventory)).to receive(:open).with('a:UTF-8').and_yield(fh)
 
         @inventory.add(cert)
 
@@ -102,7 +106,7 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
 
     describe "and formatting a certificate" do
       before do
-        @cert = stub 'cert', :not_before => Time.now, :not_after => Time.now, :subject => "mycert", :serial => 15
+        @cert = double('cert', :not_before => Time.now, :not_after => Time.now, :subject => "mycert", :serial => 15)
       end
 
       it "should print the serial number as a 4 digit hex number in the first field" do
@@ -110,13 +114,13 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
       end
 
       it "should print the not_before date in '%Y-%m-%dT%H:%M:%S%Z' format in the second field" do
-        @cert.not_before.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "before_time"
+        expect(@cert.not_before).to receive(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').and_return("before_time")
 
         expect(@inventory.format(@cert).split[1]).to eq("before_time")
       end
 
       it "should print the not_after date in '%Y-%m-%dT%H:%M:%S%Z' format in the third field" do
-        @cert.not_after.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "after_time"
+        expect(@cert.not_after).to receive(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').and_return("after_time")
 
         expect(@inventory.format(@cert).split[2]).to eq("after_time")
       end
@@ -137,12 +141,12 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
 
     describe "and finding serial numbers" do
       it "should return an empty array if the inventory file is missing" do
-        Puppet::FileSystem.expects(:exist?).with(cert_inventory).returns false
+        expect(Puppet::FileSystem).to receive(:exist?).with(cert_inventory).and_return(false)
         expect(@inventory.serials(:whatever)).to be_empty
       end
 
       it "should return the all the serial numbers from the lines matching the provided name" do
-        File.expects(:readlines).with(cert_inventory, :encoding => Encoding::UTF_8).returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n", "0x002 blah blah /CN=me\n"]
+        expect(File).to receive(:readlines).with(cert_inventory, :encoding => Encoding::UTF_8).and_return(["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n", "0x002 blah blah /CN=me\n"])
 
         expect(@inventory.serials("me")).to eq([15, 2])
       end

data/spec/unit/ssl/key_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/key'
@@ -63,36 +62,36 @@ describe Puppet::SSL::Key do
 
     it "should be able to read keys from disk" do
       path = "/my/path"
-      Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding::ASCII).returns("my key")
-      key = mock 'key'
-      OpenSSL::PKey::RSA.expects(:new).returns(key)
+      expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my key")
+      key = double('key')
+      expect(OpenSSL::PKey::RSA).to receive(:new).and_return(key)
       expect(@key.read(path)).to equal(key)
       expect(@key.content).to equal(key)
     end
 
     it "should not try to use the provided password file if the file does not exist" do
-      Puppet::FileSystem.stubs(:exist?).returns false
+      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
       @key.password_file = "/path/to/password"
 
       path = "/my/path"
 
-      Puppet::FileSystem.stubs(:read).with(path, :encoding => Encoding::ASCII).returns("my key")
-      OpenSSL::PKey::RSA.expects(:new).with("my key", nil).returns(mock('key'))
-      Puppet::FileSystem.expects(:read).with("/path/to/password", :encoding => Encoding::BINARY).never
+      allow(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my key")
+      expect(OpenSSL::PKey::RSA).to receive(:new).with("my key", nil).and_return(double('key'))
+      expect(Puppet::FileSystem).not_to receive(:read).with("/path/to/password", :encoding => Encoding::BINARY)
 
       @key.read(path)
     end
 
     it "should read the key with the password retrieved from the password file if one is provided" do
-      Puppet::FileSystem.stubs(:exist?).returns true
+      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
       @key.password_file = "/path/to/password"
 
       path = "/my/path"
-      Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding::ASCII).returns("my key")
-      Puppet::FileSystem.expects(:read).with("/path/to/password", :encoding => Encoding::BINARY).returns("my password")
+      expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my key")
+      expect(Puppet::FileSystem).to receive(:read).with("/path/to/password", :encoding => Encoding::BINARY).and_return("my password")
 
-      key = mock 'key'
-      OpenSSL::PKey::RSA.expects(:new).with("my key", "my password").returns(key)
+      key = double('key')
+      expect(OpenSSL::PKey::RSA).to receive(:new).with("my key", "my password").and_return(key)
       expect(@key.read(path)).to equal(key)
       expect(@key.content).to equal(key)
     end
@@ -102,14 +101,14 @@ describe Puppet::SSL::Key do
     end
 
     it "should convert the key to pem format when converted to a string" do
-      key = mock 'key', :to_pem => "pem"
+      key = double('key', :to_pem => "pem")
       @key.content = key
       expect(@key.to_s).to eq("pem")
     end
 
     it "should have a :to_text method that it delegates to the actual key" do
-      real_key = mock 'key'
-      real_key.expects(:to_text).returns "keytext"
+      real_key = double('key')
+      expect(real_key).to receive(:to_text).and_return("keytext")
       @key.content = real_key
       expect(@key.to_text).to eq("keytext")
     end
@@ -119,43 +118,43 @@ describe Puppet::SSL::Key do
     before do
       @instance = @class.new("test")
 
-      @key = mock 'key'
+      @key = double('key')
     end
 
     it "should create an instance of OpenSSL::PKey::RSA" do
-      OpenSSL::PKey::RSA.expects(:new).returns(@key)
+      expect(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
 
       @instance.generate
     end
 
     it "should create the private key with the keylength specified in the settings" do
       Puppet[:keylength] = 513
-      OpenSSL::PKey::RSA.expects(:new).with(513).returns(@key)
+      expect(OpenSSL::PKey::RSA).to receive(:new).with(513).and_return(@key)
 
       @instance.generate
     end
 
     it "should set the content to the generated key" do
-      OpenSSL::PKey::RSA.stubs(:new).returns(@key)
+      allow(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
       @instance.generate
       expect(@instance.content).to equal(@key)
     end
 
     it "should return the generated key" do
-      OpenSSL::PKey::RSA.stubs(:new).returns(@key)
+      allow(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
       expect(@instance.generate).to equal(@key)
     end
 
     it "should return the key in pem format" do
       @instance.generate
-      @instance.content.expects(:to_pem).returns "my normal key"
+      expect(@instance.content).to receive(:to_pem).and_return("my normal key")
       expect(@instance.to_s).to eq("my normal key")
     end
 
     describe "with a password file set" do
       it "should return a nil password if the password file does not exist" do
-        Puppet::FileSystem.expects(:exist?).with("/path/to/pass").returns false
-        Puppet::FileSystem.expects(:read).with("/path/to/pass", :encoding => Encoding::BINARY).never
+        expect(Puppet::FileSystem).to receive(:exist?).with("/path/to/pass").and_return(false)
+        expect(Puppet::FileSystem).not_to receive(:read).with("/path/to/pass", :encoding => Encoding::BINARY)
 
         @instance.password_file = "/path/to/pass"
 
@@ -163,8 +162,8 @@ describe Puppet::SSL::Key do
       end
 
       it "should return the contents of the password file as its password" do
-        Puppet::FileSystem.expects(:exist?).with("/path/to/pass").returns true
-        Puppet::FileSystem.expects(:read).with("/path/to/pass", :encoding => Encoding::BINARY).returns "my password"
+        expect(Puppet::FileSystem).to receive(:exist?).with("/path/to/pass").and_return(true)
+        expect(Puppet::FileSystem).to receive(:read).with("/path/to/pass", :encoding => Encoding::BINARY).and_return("my password")
 
         @instance.password_file = "/path/to/pass"
 
@@ -173,14 +172,14 @@ describe Puppet::SSL::Key do
 
       it "should export the private key to text using the password" do
         @instance.password_file = "/path/to/pass"
-        @instance.stubs(:password).returns "my password"
+        allow(@instance).to receive(:password).and_return("my password")
 
-        OpenSSL::PKey::RSA.expects(:new).returns(@key)
+        expect(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
         @instance.generate
 
-        cipher = mock 'cipher'
-        OpenSSL::Cipher::DES.expects(:new).with(:EDE3, :CBC).returns cipher
-        @key.expects(:export).with(cipher, "my password").returns "my encrypted key"
+        cipher = double('cipher')
+        expect(OpenSSL::Cipher::DES).to receive(:new).with(:EDE3, :CBC).and_return(cipher)
+        expect(@key).to receive(:export).with(cipher, "my password").and_return("my encrypted key")
 
         expect(@instance.to_s).to eq("my encrypted key")
       end

data/spec/unit/ssl/validator_spec.rb

@@ -3,7 +3,7 @@ require 'puppet/ssl'
 
 describe Puppet::SSL::Validator::DefaultValidator do
   let(:ssl_context) do
-    mock('OpenSSL::X509::StoreContext')
+    double('OpenSSL::X509::StoreContext')
   end
 
   let(:ssl_configuration) do
@@ -13,10 +13,10 @@ describe Puppet::SSL::Validator::DefaultValidator do
   end
 
   let(:ssl_host) do
-    stub('ssl_host',
-         :ssl_store => nil,
-         :certificate => stub('cert', :content => nil),
-         :key => stub('key', :content => nil))
+    double('ssl_host',
+           :ssl_store => nil,
+           :certificate => double('cert', :content => nil),
+           :key => double('key', :content => nil))
   end
 
   subject do
@@ -25,15 +25,15 @@ describe Puppet::SSL::Validator::DefaultValidator do
   end
 
   before :each do
-    ssl_configuration.stubs(:read_file).
+    allow(ssl_configuration).to receive(:read_file).
       with(Puppet[:localcacert]).
-      returns(root_ca)
+      and_return(root_ca)
   end
 
   describe '#call' do
     before :each do
-      ssl_context.stubs(:current_cert).returns(*cert_chain_in_callback_order)
-      ssl_context.stubs(:chain).returns(cert_chain)
+      allow(ssl_context).to receive(:current_cert).and_return(*cert_chain_in_callback_order)
+      allow(ssl_context).to receive(:chain).and_return(cert_chain)
     end
 
     context 'When pre-verification is not OK' do
@@ -42,31 +42,31 @@ describe Puppet::SSL::Validator::DefaultValidator do
         let(:code) { OpenSSL::X509::V_ERR_INVALID_CA }
 
         it 'rejects the connection' do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
-          ssl_context.stubs(:error).returns(code)
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
+          allow(ssl_context).to receive(:error).and_return(code)
 
           expect(subject.call(false, ssl_context)).to eq(false)
         end
 
         it 'makes the error available via #verify_errors' do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
-          ssl_context.stubs(:error).returns(code)
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
+          allow(ssl_context).to receive(:error).and_return(code)
 
           subject.call(false, ssl_context)
           expect(subject.verify_errors).to eq(["Something went wrong for #{root_subject}"])
         end
 
         it 'uses a generic message if error_string is nil' do
-          ssl_context.stubs(:error_string).returns(nil)
-          ssl_context.stubs(:error).returns(code)
+          allow(ssl_context).to receive(:error_string).and_return(nil)
+          allow(ssl_context).to receive(:error).and_return(code)
 
           subject.call(false, ssl_context)
           expect(subject.verify_errors).to eq(["OpenSSL error #{code} for #{root_subject}"])
         end
 
         it 'uses 0 for nil error codes' do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
-          ssl_context.stubs(:error).returns(nil)
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
+          allow(ssl_context).to receive(:error).and_return(nil)
 
           subject.call(false, ssl_context)
           expect(subject.verify_errors).to eq(["Something went wrong for #{root_subject}"])
@@ -74,12 +74,12 @@ describe Puppet::SSL::Validator::DefaultValidator do
 
         context "when CRL is not yet valid" do
           before :each do
-            ssl_context.stubs(:error_string).returns("CRL is not yet valid")
-            ssl_context.stubs(:error).returns(OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID)
+            allow(ssl_context).to receive(:error_string).and_return("CRL is not yet valid")
+            allow(ssl_context).to receive(:error).and_return(OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID)
           end
 
           it 'rejects nil CRL' do
-            ssl_context.stubs(:current_crl).returns(nil)
+            allow(ssl_context).to receive(:current_crl).and_return(nil)
 
             expect(subject.call(false, ssl_context)).to eq(false)
             expect(subject.verify_errors).to eq(["CRL is not yet valid"])
@@ -89,7 +89,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
             crl = OpenSSL::X509::CRL.new
             crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
             crl.last_update = Time.now + 24 * 60 * 60
-            ssl_context.stubs(:current_crl).returns(crl)
+            allow(ssl_context).to receive(:current_crl).and_return(crl)
 
             subject.call(false, ssl_context)
             expect(subject.verify_errors).to eq(["CRL is not yet valid for /CN=Puppet CA: puppetmaster.example.com"])
@@ -99,7 +99,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
             crl = OpenSSL::X509::CRL.new
             crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
             crl.last_update = Time.now + 24 * 60 * 60
-            ssl_context.stubs(:current_crl).returns(crl)
+            allow(ssl_context).to receive(:current_crl).and_return(crl)
 
             expect(subject.call(false, ssl_context)).to eq(false)
           end
@@ -108,7 +108,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
             crl = OpenSSL::X509::CRL.new
             crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
             crl.last_update = Time.now + 10
-            ssl_context.stubs(:current_crl).returns(crl)
+            allow(ssl_context).to receive(:current_crl).and_return(crl)
 
             expect(subject.call(false, ssl_context)).to eq(true)
           end
@@ -119,7 +119,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
     context 'When pre-verification is OK' do
       context 'and the ssl_context is in an error state' do
         before :each do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
         end
 
         it 'does not make the error available via #verify_errors' do
@@ -145,9 +145,9 @@ describe Puppet::SSL::Validator::DefaultValidator do
 
       context 'and the chain is invalid' do
         before :each do
-          ssl_configuration.stubs(:read_file).
+          allow(ssl_configuration).to receive(:read_file).
             with(Puppet[:localcacert]).
-            returns(agent_ca)
+            and_return(agent_ca)
         end
 
         it 'is true for each CA certificate in the chain' do
@@ -166,7 +166,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
 
       context 'an error is raised inside of #call' do
         before :each do
-          ssl_context.expects(:current_cert).raises(StandardError, "BOOM!")
+          expect(ssl_context).to receive(:current_cert).and_raise(StandardError, "BOOM!")
         end
 
         it 'is false' do
@@ -183,24 +183,24 @@ describe Puppet::SSL::Validator::DefaultValidator do
 
   describe '#setup_connection' do
     it 'updates the connection for verification' do
-      subject.stubs(:ssl_certificates_are_present?).returns(true)
-      connection = mock('Net::HTTP')
+      allow(subject).to receive(:ssl_certificates_are_present?).and_return(true)
+      connection = double('Net::HTTP')
 
-      connection.expects(:cert_store=).with(ssl_host.ssl_store)
-      connection.expects(:ca_file=).with(ssl_configuration.ca_auth_file)
-      connection.expects(:cert=).with(ssl_host.certificate.content)
-      connection.expects(:key=).with(ssl_host.key.content)
-      connection.expects(:verify_callback=).with(subject)
-      connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      expect(connection).to receive(:cert_store=).with(ssl_host.ssl_store)
+      expect(connection).to receive(:ca_file=).with(ssl_configuration.ca_auth_file)
+      expect(connection).to receive(:cert=).with(ssl_host.certificate.content)
+      expect(connection).to receive(:key=).with(ssl_host.key.content)
+      expect(connection).to receive(:verify_callback=).with(subject)
+      expect(connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
 
       subject.setup_connection(connection)
     end
 
     it 'does not perform verification if certificate files are missing' do
-      subject.stubs(:ssl_certificates_are_present?).returns(false)
-      connection = mock('Net::HTTP')
+      allow(subject).to receive(:ssl_certificates_are_present?).and_return(false)
+      connection = double('Net::HTTP')
 
-      connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      expect(connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
 
       subject.setup_connection(connection)
     end
@@ -216,7 +216,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
 
     context 'when the peer presents a valid chain' do
       before :each do
-        subject.stubs(:has_authz_peer_cert).returns(true)
+        allow(subject).to receive(:has_authz_peer_cert).and_return(true)
       end
 
       it 'is true' do
@@ -226,7 +226,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
 
     context 'when the peer presents an invalid chain' do
       before :each do
-        subject.stubs(:has_authz_peer_cert).returns(false)
+        allow(subject).to receive(:has_authz_peer_cert).and_return(false)
       end
 
       it 'is false' do