puppet 5.5.12 → 5.5.13

data/spec/unit/file_serving/terminus_selector_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/terminus_selector'
@@ -8,56 +7,56 @@ describe Puppet::FileServing::TerminusSelector do
     @object = Object.new
     @object.extend(Puppet::FileServing::TerminusSelector)
 
-    @request = stub 'request', :key => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil
+    @request = double('request', :key => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil)
   end
 
   describe "when being used to select termini" do
     it "should return :file if the request key is fully qualified" do
-      @request.expects(:key).returns File.expand_path('/foo')
+      expect(@request).to receive(:key).and_return(File.expand_path('/foo'))
       expect(@object.select(@request)).to eq(:file)
     end
 
     it "should return :file if the URI protocol is set to 'file'" do
-      @request.expects(:protocol).returns "file"
+      expect(@request).to receive(:protocol).and_return("file")
       expect(@object.select(@request)).to eq(:file)
     end
 
     it "should return :http if the URI protocol is set to 'http'" do
-      @request.expects(:protocol).returns "http"
+      expect(@request).to receive(:protocol).and_return("http")
       expect(@object.select(@request)).to eq :http
     end
 
     it "should return :http if the URI protocol is set to 'https'" do
-      @request.expects(:protocol).returns "https"
+      expect(@request).to receive(:protocol).and_return("https")
       expect(@object.select(@request)).to eq :http
     end
 
     it "should fail when a protocol other than :puppet, :http(s) or :file is used" do
-      @request.stubs(:protocol).returns "ftp"
+      allow(@request).to receive(:protocol).and_return("ftp")
       expect { @object.select(@request) }.to raise_error(ArgumentError)
     end
 
     describe "and the protocol is 'puppet'" do
       before do
-        @request.stubs(:protocol).returns "puppet"
+        allow(@request).to receive(:protocol).and_return("puppet")
       end
 
       it "should choose :rest when a server is specified" do
-        @request.stubs(:protocol).returns "puppet"
-        @request.expects(:server).returns "foo"
+        allow(@request).to receive(:protocol).and_return("puppet")
+        expect(@request).to receive(:server).and_return("foo")
         expect(@object.select(@request)).to eq(:rest)
       end
 
       # This is so a given file location works when bootstrapping with no server.
       it "should choose :rest when default_file_terminus is rest" do
-        @request.stubs(:protocol).returns "puppet"
+        allow(@request).to receive(:protocol).and_return("puppet")
         Puppet[:server] = 'localhost'
         expect(@object.select(@request)).to eq(:rest)
       end
 
       it "should choose :file_server when default_file_terminus is file_server and no server is specified on the request" do
-        @request.expects(:protocol).returns "puppet"
-        @request.expects(:server).returns nil
+        expect(@request).to receive(:protocol).and_return("puppet")
+        expect(@request).to receive(:server).and_return(nil)
         Puppet[:default_file_terminus] = 'file_server'
         expect(@object.select(@request)).to eq(:file_server)
       end

data/spec/unit/file_system/uniquefile_spec.rb

@@ -49,8 +49,8 @@ describe Puppet::FileSystem::Uniquefile do
   it "propagates lock creation failures" do
     # use an arbitrary exception so as not accidentally collide
     # with the ENOENT that occurs when trying to call rmdir
-    Puppet::FileSystem::Uniquefile.stubs(:mkdir).raises 'arbitrary failure'
-    Puppet::FileSystem::Uniquefile.expects(:rmdir).never
+    allow(Puppet::FileSystem::Uniquefile).to receive(:mkdir).and_raise('arbitrary failure')
+    expect(Puppet::FileSystem::Uniquefile).not_to receive(:rmdir)
 
     expect {
       Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
@@ -59,10 +59,10 @@ describe Puppet::FileSystem::Uniquefile do
 
   it "only removes lock files that exist" do
     # prevent the .lock directory from being created
-    Puppet::FileSystem::Uniquefile.stubs(:mkdir) { }
+    allow(Puppet::FileSystem::Uniquefile).to receive(:mkdir)
 
     # and expect cleanup to be skipped
-    Puppet::FileSystem::Uniquefile.expects(:rmdir).never
+    expect(Puppet::FileSystem::Uniquefile).not_to receive(:rmdir)
 
     Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
   end

data/spec/unit/file_system_spec.rb

@@ -330,7 +330,7 @@ describe "Puppet::FileSystem" do
     end
 
     it "should fall back to stat when trying to lstat a file" do
-      Puppet::Util::Windows::File.expects(:stat).with(Puppet::FileSystem.assert_path(file))
+      expect(Puppet::Util::Windows::File).to receive(:stat).with(Puppet::FileSystem.assert_path(file))
 
       Puppet::FileSystem.lstat(file)
     end
@@ -809,7 +809,7 @@ describe "Puppet::FileSystem" do
       describe 'on non-Windows', :unless => Puppet::Util::Platform.windows? do
         it 'should produce the same results as the Ruby File.expand_path' do
           # on Windows this may be 8.3 style, but not so on other platforms
-          # only done since ::File.expects(:expand_path).with(path).at_least_once
+          # only done since expect(::File).to receive(:expand_path).with(path).at_least(:once)
           # cannot be used since it will cause a stack overflow
           path = tmpdir('foobar')
 

data/spec/unit/forge/errors_spec.rb

@@ -41,7 +41,7 @@ Could not connect to http://fake.com:1111
 
   describe 'ResponseError' do
     subject { Puppet::Forge::Errors::ResponseError }
-    let(:response) { stub(:body => '{}', :code => '404', :message => "not found") }
+    let(:response) { double(:body => '{}', :code => '404', :message => "not found") }
 
     context 'without message' do
       let(:exception) { subject.new(:uri => 'http://fake.com:1111', :response => response, :input => 'user/module') }

data/spec/unit/forge/forge_spec.rb

@@ -22,7 +22,7 @@ describe Puppet::Forge do
   let (:mixed_utf8_query_param) { "foo + A\u06FF\u16A0\u{2070E}" } # Aۿᚠ
   let (:mixed_utf8_query_param_encoded) { "foo%20%2B%20A%DB%BF%E1%9A%A0%F0%A0%9C%8E"}
   let (:empty_json) { '{ "results": [], "pagination" : { "next" : null } }' }
-  let (:ok_response) { stub('response', :code => '200', :body => empty_json) }
+  let (:ok_response) { double('response', :code => '200', :body => empty_json) }
 
   describe "making a" do
     before :each do
@@ -30,14 +30,13 @@ describe Puppet::Forge do
     end
 
     context "search request" do
-
       it "includes any defined module_groups, ensuring to only encode them once in the URI" do
         Puppet[:module_groups] = 'base+pe'
 
         # ignores Puppet::Forge::Repository#read_response, provides response to search
         performs_an_http_request(ok_response) do |http|
           encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}&module_groups=base%20pe"
-          http.expects(:request).with(responds_with(:path, encoded_uri))
+          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
         end
 
         forge.search(mixed_utf8_query_param)
@@ -47,7 +46,7 @@ describe Puppet::Forge do
         # ignores Puppet::Forge::Repository#read_response, provides response to search
         performs_an_http_request(ok_response) do |http|
           encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}"
-          http.expects(:request).with(responds_with(:path, encoded_uri))
+          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
         end
 
         forge.search(mixed_utf8_query_param)
@@ -64,7 +63,7 @@ describe Puppet::Forge do
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
           encoded_uri = "/v3/releases?module=#{module_name}&sort_by=version&exclude_fields=#{exclusions}&module_groups=base%20pe"
-          http.expects(:request).with(responds_with(:path, encoded_uri))
+          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
         end
 
         forge.fetch(module_name)
@@ -77,7 +76,7 @@ describe Puppet::Forge do
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
           encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version&exclude_fields=#{exclusions}"
-          http.expects(:request).with(responds_with(:path, encoded_uri))
+          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
         end
 
         forge.fetch(module_name)
@@ -96,17 +95,17 @@ describe Puppet::Forge do
   end
 
   def mock_proxy(port, proxy_args, result, &block)
-    http = mock("http client")
-    proxy = mock("http proxy")
-    proxy_class = mock("http proxy class")
+    http = double("http client")
+    proxy = double("http proxy")
+    proxy_class = double("http proxy class")
 
-    Net::HTTP.expects(:Proxy).with(*proxy_args).returns(proxy_class)
-    proxy_class.expects(:new).with(host, port).returns(proxy)
+    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
+    expect(proxy_class).to receive(:new).with(host, port).and_return(proxy)
 
-    proxy.expects(:open_timeout=)
-    proxy.expects(:read_timeout=)
+    expect(proxy).to receive(:open_timeout=)
+    expect(proxy).to receive(:read_timeout=)
 
-    proxy.expects(:start).yields(http).returns(result)
+    expect(proxy).to receive(:start).and_yield(http).and_return(result)
     yield http
 
     proxy

data/spec/unit/forge/module_release_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Forge::ModuleRelease do
 
   let(:mock_file) {
     mock_io = StringIO.new
-    mock_io.stubs(:path).returns('/dev/null')
+    allow(mock_io).to receive(:path).and_return('/dev/null')
     mock_io
   }
 
@@ -28,19 +28,19 @@ describe Puppet::Forge::ModuleRelease do
 
   shared_examples 'a module release' do
     def mock_digest_file_with_md5(md5)
-      Digest::MD5.stubs(:file).returns(stub(:hexdigest => md5))
+      allow(Digest::MD5).to receive(:file).and_return(double(:hexdigest => md5))
     end
 
     describe '#prepare' do
       before :each do
-        release.stubs(:tmpfile).returns(mock_file)
-        release.stubs(:tmpdir).returns(mock_dir)
+        allow(release).to receive(:tmpfile).and_return(mock_file)
+        allow(release).to receive(:tmpdir).and_return(mock_dir)
       end
 
       it 'should call sub methods with correct params' do
-        release.expects(:download).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
-        release.expects(:validate_checksum).with(mock_file, module_md5)
-        release.expects(:unpack).with(mock_file, mock_dir)
+        expect(release).to receive(:download).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
+        expect(release).to receive(:validate_checksum).with(mock_file, module_md5)
+        expect(release).to receive(:unpack).with(mock_file, mock_dir)
 
         release.prepare
       end
@@ -48,7 +48,7 @@ describe Puppet::Forge::ModuleRelease do
 
     describe '#tmpfile' do
       it 'should be opened in binary mode' do
-        Puppet::Forge::Cache.stubs(:base_path).returns(Dir.tmpdir)
+        allow(Puppet::Forge::Cache).to receive(:base_path).and_return(Dir.tmpdir)
         expect(release.send(:tmpfile).binmode?).to be_truthy
       end
     end
@@ -56,14 +56,14 @@ describe Puppet::Forge::ModuleRelease do
     describe '#download' do
       it 'should call make_http_request with correct params' do
         # valid URI comes from file_uri in JSON blob above
-        ssl_repository.expects(:make_http_request).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file).returns(stub(:body => '{}', :code => '200'))
+        expect(ssl_repository).to receive(:make_http_request).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file).and_return(double(:body => '{}', :code => '200'))
 
         release.send(:download, "/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
       end
 
       it 'should raise a response error when it receives an error from forge' do
-        ssl_repository.stubs(:make_http_request).returns(stub(:body => '{"errors": ["error"]}', :code => '500', :message => 'server error'))
-        expect { release.send(:download, "/some/path", mock_file)}. to raise_error Puppet::Forge::Errors::ResponseError
+        allow(ssl_repository).to receive(:make_http_request).and_return(double(:body => '{"errors": ["error"]}', :code => '500', :message => 'server error'))
+        expect { release.send(:download, "/some/path", mock_file)}.to raise_error Puppet::Forge::Errors::ResponseError
       end
     end
 
@@ -84,7 +84,7 @@ describe Puppet::Forge::ModuleRelease do
 
     describe '#unpack' do
       it 'should call unpacker with correct params' do
-        Puppet::ModuleTool::Applications::Unpacker.expects(:unpack).with(mock_file.path, mock_dir).returns(true)
+        expect(Puppet::ModuleTool::Applications::Unpacker).to receive(:unpack).with(mock_file.path, mock_dir).and_return(true)
 
         release.send(:unpack, mock_file, mock_dir)
       end
@@ -271,15 +271,15 @@ describe Puppet::Forge::ModuleRelease do
 
     describe '#prepare' do
       before :each do
-        release.stubs(:tmpfile).returns(mock_file)
-        release.stubs(:tmpdir).returns(mock_dir)
-        release.stubs(:download)
-        release.stubs(:validate_checksum)
-        release.stubs(:unpack)
+        allow(release).to receive(:tmpfile).and_return(mock_file)
+        allow(release).to receive(:tmpdir).and_return(mock_dir)
+        allow(release).to receive(:download)
+        allow(release).to receive(:validate_checksum)
+        allow(release).to receive(:unpack)
       end
 
       it 'should emit warning about module deprecation' do
-        Puppet.expects(:warning).with(regexp_matches(/#{Regexp.escape(module_full_name)}.*deprecated/i))
+        expect(Puppet).to receive(:warning).with(/#{Regexp.escape(module_full_name)}.*deprecated/i)
 
         release.prepare
       end

data/spec/unit/forge/repository_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::Forge::Repository do
 
   it "retrieve accesses the cache" do
     path = '/module/foo.tar.gz'
-    repository.cache.expects(:retrieve)
+    expect(repository.cache).to receive(:retrieve)
 
     repository.retrieve(path)
   end
@@ -28,7 +28,7 @@ describe Puppet::Forge::Repository do
     uri  = [ host, path ].join('')
 
     repository = Puppet::Forge::Repository.new(host, agent)
-    repository.cache.expects(:retrieve).with(uri)
+    expect(repository.cache).to receive(:retrieve).with(uri)
 
     repository.retrieve(path)
   end
@@ -42,7 +42,7 @@ describe Puppet::Forge::Repository do
       result = "#{Object.new}"
 
       performs_an_http_request result do |http|
-        http.expects(:request).with(responds_with(:path, "the_path"))
+        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
       end
 
       expect(repository.make_http_request("the_path")).to eq(result)
@@ -52,7 +52,7 @@ describe Puppet::Forge::Repository do
       result = "#{Object.new}"
 
       performs_an_http_request result do |http|
-        http.expects(:request).with(responds_with(:path, "/test/the_path/"))
+        expect(http).to receive(:request).with(have_attributes(path: "/test/the_path/"))
       end
 
       repository = Puppet::Forge::Repository.new('http://fake.com/test', agent)
@@ -63,7 +63,7 @@ describe Puppet::Forge::Repository do
       result = "#{Object.new}"
 
       performs_an_http_request result do |http|
-        http.expects(:request).with(responds_with(:path, "/test/the_path"))
+        expect(http).to receive(:request).with(have_attributes(path: "/test/the_path"))
       end
 
       repository = Puppet::Forge::Repository.new('http://fake.com/test/', agent)
@@ -73,7 +73,7 @@ describe Puppet::Forge::Repository do
     it 'returns the result object from a request with ssl' do
       result = "#{Object.new}"
       performs_an_https_request result do |http|
-        http.expects(:request).with(responds_with(:path, "the_path"))
+        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
       end
 
       expect(ssl_repository.make_http_request("the_path")).to eq(result)
@@ -81,7 +81,7 @@ describe Puppet::Forge::Repository do
 
     it 'return a valid exception when there is an SSL verification problem' do
       performs_an_https_request "#{Object.new}" do |http|
-        http.expects(:request).with(responds_with(:path, "the_path")).raises OpenSSL::SSL::SSLError.new("certificate verify failed")
+        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(OpenSSL::SSL::SSLError.new("certificate verify failed"))
       end
 
       expect { ssl_repository.make_http_request("the_path") }.to raise_error Puppet::Forge::Errors::SSLVerifyError, 'Unable to verify the SSL certificate at https://fake.com'
@@ -89,7 +89,7 @@ describe Puppet::Forge::Repository do
 
     it 'return a valid exception when there is a communication problem' do
       performs_an_http_request "#{Object.new}" do |http|
-        http.expects(:request).with(responds_with(:path, "the_path")).raises SocketError
+        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(SocketError)
       end
 
       expect { repository.make_http_request("the_path") }.
@@ -108,7 +108,7 @@ describe Puppet::Forge::Repository do
     end
 
     it "Does not set Authorization header by default" do
-      Puppet.features.stubs(:pe_license?).returns(false)
+      allow(Puppet.features).to receive(:pe_license?).and_return(false)
       Puppet[:forge_authorization] = nil
       request = repository.get_request_object("the_path")
       expect(request['Authorization']).to eq(nil)
@@ -124,7 +124,7 @@ describe Puppet::Forge::Repository do
     it "encodes the received URI" do
       unescaped_uri = "héllo world !! ç à"
       performs_an_http_request do |http|
-        http.expects(:request).with(responds_with(:path, Puppet::Util.uri_encode(unescaped_uri)))
+        expect(http).to receive(:request).with(have_attributes(path: Puppet::Util.uri_encode(unescaped_uri)))
       end
 
       repository.make_http_request(unescaped_uri)
@@ -138,11 +138,10 @@ describe Puppet::Forge::Repository do
     def performs_an_https_request(result = nil, &block)
       proxy_args = ["proxy", 1234, nil, nil]
       proxy = mock_proxy(443, proxy_args, result, &block)
-      proxy.expects(:use_ssl=).with(true)
-      proxy.expects(:cert_store=)
-      proxy.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      expect(proxy).to receive(:use_ssl=).with(true)
+      expect(proxy).to receive(:cert_store=)
+      expect(proxy).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
     end
-
   end
 
   describe "making a request against an authentiated proxy" do
@@ -154,7 +153,7 @@ describe Puppet::Forge::Repository do
       result = "#{Object.new}"
 
       performs_an_authenticated_http_request result do |http|
-        http.expects(:request).with(responds_with(:path, "the_path"))
+        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
       end
 
       expect(repository.make_http_request("the_path")).to eq(result)
@@ -163,7 +162,7 @@ describe Puppet::Forge::Repository do
     it 'returns the result object from a request with ssl' do
       result = "#{Object.new}"
       performs_an_authenticated_https_request result do |http|
-        http.expects(:request).with(responds_with(:path, "the_path"))
+        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
       end
 
       expect(ssl_repository.make_http_request("the_path")).to eq(result)
@@ -171,7 +170,7 @@ describe Puppet::Forge::Repository do
 
     it 'return a valid exception when there is an SSL verification problem' do
       performs_an_authenticated_https_request "#{Object.new}" do |http|
-        http.expects(:request).with(responds_with(:path, "the_path")).raises OpenSSL::SSL::SSLError.new("certificate verify failed")
+        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(OpenSSL::SSL::SSLError.new("certificate verify failed"))
       end
 
       expect { ssl_repository.make_http_request("the_path") }.to raise_error Puppet::Forge::Errors::SSLVerifyError, 'Unable to verify the SSL certificate at https://fake.com'
@@ -179,7 +178,7 @@ describe Puppet::Forge::Repository do
 
     it 'return a valid exception when there is a communication problem' do
       performs_an_authenticated_http_request "#{Object.new}" do |http|
-        http.expects(:request).with(responds_with(:path, "the_path")).raises SocketError
+        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(SocketError)
       end
 
       expect { repository.make_http_request("the_path") }.
@@ -200,7 +199,7 @@ describe Puppet::Forge::Repository do
     it "encodes the received URI" do
       unescaped_uri = "héllo world !! ç à"
       performs_an_authenticated_http_request do |http|
-        http.expects(:request).with(responds_with(:path, Puppet::Util.uri_encode(unescaped_uri)))
+        expect(http).to receive(:request).with(have_attributes(path: Puppet::Util.uri_encode(unescaped_uri)))
       end
 
       repository.make_http_request(unescaped_uri)
@@ -214,9 +213,9 @@ describe Puppet::Forge::Repository do
     def performs_an_authenticated_https_request(result = nil, &block)
       proxy_args = ["proxy", 1234, 'user1', 'password']
       proxy = mock_proxy(443, proxy_args, result, &block)
-      proxy.expects(:use_ssl=).with(true)
-      proxy.expects(:cert_store=)
-      proxy.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      expect(proxy).to receive(:use_ssl=).with(true)
+      expect(proxy).to receive(:cert_store=)
+      expect(proxy).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
     end
   end
 
@@ -233,17 +232,17 @@ describe Puppet::Forge::Repository do
   end
 
   def mock_proxy(port, proxy_args, result, &block)
-    http = mock("http client")
-    proxy = mock("http proxy")
-    proxy_class = mock("http proxy class")
+    http = double("http client")
+    proxy = double("http proxy")
+    proxy_class = double("http proxy class")
 
-    Net::HTTP.expects(:Proxy).with(*proxy_args).returns(proxy_class)
-    proxy_class.expects(:new).with("fake.com", port).returns(proxy)
+    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
+    expect(proxy_class).to receive(:new).with("fake.com", port).and_return(proxy)
 
-    proxy.expects(:open_timeout=)
-    proxy.expects(:read_timeout=)
+    expect(proxy).to receive(:open_timeout=)
+    expect(proxy).to receive(:read_timeout=)
 
-    proxy.expects(:start).yields(http).returns(result)
+    expect(proxy).to receive(:start).and_yield(http).and_return(result)
     yield http
 
     proxy