puppet 6.4.0-x86-mingw32 → 6.4.1-x86-mingw32

data/spec/unit/network/http/api/master/v3/authorization_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::Network::HTTP::API::Master::V3::Authorization do
       :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
     })
 
-    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
 path /v3/environments
 method find
 allow *
@@ -39,7 +39,7 @@ allow *
       :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
     })
 
-    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
 path /v3/environments
 method find
 auth any

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -175,7 +175,7 @@ describe Puppet::Network::HTTP::API::Master::V3::Environment do
   it "uses code_id from the catalog if it differs from the request" do
     request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
 
-    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('67890')
+    allow_any_instance_of(Puppet::Resource::Catalog).to receive(:code_id).and_return('67890')
 
     subject.call(request, response)
 

data/spec/unit/network/http/api/master/v3/environments_spec.rb

@@ -33,11 +33,11 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    conf_stub = stub 'conf_stub'
-    conf_stub.expects(:environment_timeout).returns(Float::INFINITY)
+    conf_stub = double('conf_stub')
+    expect(conf_stub).to receive(:environment_timeout).and_return(Float::INFINITY)
     environment = Puppet::Node::Environment.create(:production, [])
     env_loader = Puppet::Environments::Static.new(environment)
-    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
+    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
     handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
@@ -47,11 +47,11 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    conf_stub = stub 'conf_stub'
-    conf_stub.expects(:environment_timeout).returns(1)
+    conf_stub = double('conf_stub')
+    expect(conf_stub).to receive(:environment_timeout).and_return(1)
     environment = Puppet::Node::Environment.create(:production, [])
     env_loader = Puppet::Environments::Static.new(environment)
-    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
+    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
     handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
@@ -59,5 +59,4 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
-
 end

data/spec/unit/network/http/api_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet_spec/handler'
 require 'puppet/network/http'

data/spec/unit/network/http/compression_spec.rb

@@ -1,9 +1,8 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "http compression" do
   let(:data)            { "uncompresseddata" }
-  let(:response)        { stub 'response' }
+  let(:response)        { double('response') }
   let(:compressed_zlib) { Zlib::Deflate.deflate(data) }
   let(:compressed_gzip) do
     str = StringIO.new
@@ -14,13 +13,13 @@ describe "http compression" do
   end
 
   def stubs_response_with(response, content_encoding, body)
-    response.stubs(:[]).with('content-encoding').returns(content_encoding)
-    response.stubs(:body).returns(body)
+    allow(response).to receive(:[]).with('content-encoding').and_return(content_encoding)
+    allow(response).to receive(:body).and_return(body)
   end
 
   describe "when zlib is not available" do
     before(:each) do
-      Puppet.features.stubs(:zlib?).returns false
+      allow(Puppet.features).to receive(:zlib?).and_return(false)
 
       require 'puppet/network/http/compression'
       class HttpUncompressor
@@ -39,12 +38,12 @@ describe "http compression" do
     end
 
     it "should not tamper the body" do
-      response = stub 'response', :body => data
+      response = double('response', :body => data)
       expect(@uncompressor.uncompress_body(response)).to eq(data)
     end
 
     it "should yield an identity uncompressor" do
-      response = stub 'response'
+      response = double('response')
       @uncompressor.uncompress(response) { |u|
         expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
       }
@@ -169,19 +168,19 @@ describe "http compression" do
 
       it "should close the underlying adapter" do
         stubs_response_with(response, 'identity', data)
-        adapter = stub_everything 'adapter'
-        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
+        adapter = double('adapter')
+        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
 
-        adapter.expects(:close)
+        expect(adapter).to receive(:close)
         uncompressor.uncompress(response) { |u| }
       end
 
       it "should close the underlying adapter if the yielded block raises" do
         stubs_response_with(response, 'identity', data)
-        adapter = stub_everything 'adapter'
-        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
+        adapter = double('adapter')
+        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
 
-        adapter.expects(:close)
+        expect(adapter).to receive(:close)
         expect {
           uncompressor.uncompress(response) { |u| raise ArgumentError, "whoops" }
         }.to raise_error(ArgumentError, "whoops")
@@ -190,7 +189,7 @@ describe "http compression" do
 
     describe "zlib adapter" do
       it "should initialize the underlying inflater with gzip/zlib header parsing" do
-        Zlib::Inflate.expects(:new).with(15+32)
+        expect(Zlib::Inflate).to receive(:new).with(15 + 32)
 
         Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
@@ -203,7 +202,7 @@ describe "http compression" do
 
       it "should try a 'regular' inflater on Zlib::DataError" do
         inflater = Zlib::Inflate.new(15 + 32)
-        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
 
         expect(adapter.uncompress(compressed_zlib)).to eq(data)
@@ -211,25 +210,25 @@ describe "http compression" do
 
       it "should raise the error the second time" do
         inflater = Zlib::Inflate.new(15 + 32)
-        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
 
         expect { adapter.uncompress("this is not compressed data") }.to raise_error(Zlib::DataError, /incorrect header check/)
       end
 
       it "should finish and close the stream" do
-        inflater = stub 'inflater'
-        inflater.expects(:finish)
-        inflater.expects(:close)
+        inflater = double('inflater')
+        expect(inflater).to receive(:finish)
+        expect(inflater).to receive(:close)
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
 
         adapter.close
       end
 
       it "should close the stream even if finish raises" do
-        inflater = stub 'inflater'
-        inflater.expects(:finish).raises(Zlib::BufError)
-        inflater.expects(:close)
+        inflater = double('inflater')
+        expect(inflater).to receive(:finish).and_raise(Zlib::BufError)
+        expect(inflater).to receive(:close)
 
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
         expect {

data/spec/unit/network/http/connection_spec.rb

@@ -1,11 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http/connection'
 require 'puppet_spec/validators'
 require 'puppet/test_ca'
 
 describe Puppet::Network::HTTP::Connection do
-
   let (:host) { "me" }
   let (:port) { 54321 }
   subject { Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator) }
@@ -55,7 +53,7 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "accepts a verifier" do
-        verifier = Puppet::SSL::Verifier.new('fqdn', stub('ssl_context'))
+        verifier = Puppet::SSL::Verifier.new('fqdn', double('ssl_context'))
         conn = Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true, :verifier => verifier)
 
         expect(conn.verifier).to eq(verifier)
@@ -80,7 +78,10 @@ describe Puppet::Network::HTTP::Connection do
       :request_post => "param: value" }.each do |method,body|
       context "##{method}" do
         it "should yield to the block" do
-          Net::HTTP.any_instance.stubs(method).yields.returns(httpok)
+          allow_any_instance_of(Net::HTTP).to receive(method) do |_, *_, &block|
+            block.call()
+            httpok
+          end
 
           block_executed = false
           subject.send(method, "/foo", body) do |response|
@@ -101,7 +102,7 @@ describe Puppet::Network::HTTP::Connection do
     let (:httpredirection) do
       response = Net::HTTPFound.new('1.1', 302, 'Moved Temporarily')
       response['location'] = "#{other_site.addr}/#{other_path}"
-      response.stubs(:read_body).returns("This resource has moved")
+      allow(response).to receive(:read_body).and_return("This resource has moved")
       response
     end
 
@@ -111,24 +112,23 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should redirect to the final resource location" do
-      http = stub('http')
-      http.stubs(:request).returns(httpredirection).then.returns(httpok)
+      http = double('http')
+      allow(http).to receive(:request).and_return(httpredirection, httpok)
 
-      seq = sequence('redirection')
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http).in_sequence(seq)
-      pool.expects(:with_connection).with(other_site, anything).yields(http).in_sequence(seq)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http).ordered
+      expect(pool).to receive(:with_connection).with(other_site, anything).and_yield(http).ordered
 
       conn = create_connection(site, :verify => verify)
       conn.get('/foo')
     end
 
     def expects_redirection(conn, &block)
-      http = stub('http')
-      http.stubs(:request).returns(httpredirection)
+      http = double('http')
+      allow(http).to receive(:request).and_return(httpredirection)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
       pool
     end
 
@@ -142,7 +142,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 0)
 
       pool = expects_redirection(conn)
-      pool.expects(:with_connection).with(other_site, anything).never
+      expect(pool).not_to receive(:with_connection).with(other_site, anything)
 
       expects_limit_exceeded(conn)
     end
@@ -151,7 +151,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 1)
 
       pool = expects_redirection(conn)
-      pool.expects(:with_connection).with(other_site, anything).once
+      expect(pool).to receive(:with_connection).with(other_site, anything).once
 
       expects_limit_exceeded(conn)
     end
@@ -160,14 +160,14 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 3)
 
       pool = expects_redirection(conn)
-      pool.expects(:with_connection).with(other_site, anything).times(3)
+      expect(pool).to receive(:with_connection).with(other_site, anything).exactly(3).times
 
       expects_limit_exceeded(conn)
     end
   end
 
   context "when response indicates an overloaded server" do
-    let(:http) { stub('http') }
+    let(:http) { double('http') }
     let(:site) { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let(:verify) { Puppet::SSL::Validator.no_validator }
     let(:httpunavailable) { Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable') }
@@ -186,10 +186,10 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should return a 503 response if Retry-After is not set" do
-      http.stubs(:request).returns(httpunavailable)
+      allow(http).to receive(:request).and_return(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
 
       result = subject.get('/foo')
 
@@ -198,10 +198,10 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should return a 503 response if Retry-After is not convertible to an Integer or RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'foo'
-      http.stubs(:request).returns(httpunavailable)
+      allow(http).to receive(:request).and_return(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
 
       result = subject.get('/foo')
 
@@ -210,12 +210,12 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep and retry if Retry-After is an Integer" do
       httpunavailable['Retry-After'] = '42'
-      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).twice.yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
-      ::Kernel.expects(:sleep).with(42)
+      expect(::Kernel).to receive(:sleep).with(42)
 
       result = subject.get('/foo')
 
@@ -224,15 +224,15 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep and retry if Retry-After is an RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'Wed, 13 Apr 2005 15:18:05 GMT'
-      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
 
       now = DateTime.new(2005, 4, 13, 8, 17, 5, '-07:00')
-      DateTime.stubs(:now).returns(now)
+      allow(DateTime).to receive(:now).and_return(now)
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).twice.yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
-      ::Kernel.expects(:sleep).with(60)
+      expect(::Kernel).to receive(:sleep).with(60)
 
       result = subject.get('/foo')
 
@@ -241,13 +241,13 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep for no more than the Puppet runinterval" do
       httpunavailable['Retry-After'] = '60'
-      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
       Puppet[:runinterval] = 30
 
       pool = Puppet.lookup(:http_pool)
-      pool.expects(:with_connection).with(site, anything).twice.yields(http)
+      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
 
-      ::Kernel.expects(:sleep).with(30)
+      expect(::Kernel).to receive(:sleep).with(30)
 
       subject.get('/foo')
     end
@@ -284,17 +284,17 @@ describe Puppet::Network::HTTP::Connection do
   end
 
   def expect_request_with_basic_auth
-    Net::HTTP.any_instance.expects(:request).with do |request|
+    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
       expect(request['authorization']).to match(/^Basic/)
-    end.returns(httpok)
+    end.and_return(httpok)
   end
 
   it "sets HTTP User-Agent header" do
     puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
 
-    Net::HTTP.any_instance.expects(:request).with do |request|
+    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
       expect(request['User-Agent']).to eq(puppet_ua)
-    end.returns(httpok)
+    end.and_return(httpok)
 
     subject.get('/path')
   end

data/spec/unit/network/http/factory_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/util/http_proxy'
@@ -38,7 +37,7 @@ describe Puppet::Network::HTTP::Factory do
   it 'creates a connection supporting at least HTTP 1.1' do
     conn = create_connection(site)
 
-    expect(any_of(conn.class.version_1_1?, conn.class.version_1_1?)).to be_truthy
+    expect(conn.class.version_1_1? || conn.class.version_1_2?).to be_truthy
   end
 
   context "proxy settings" do
@@ -47,7 +46,7 @@ describe Puppet::Network::HTTP::Factory do
 
     it "should not set a proxy if the value is 'none'" do
       Puppet[:http_proxy_host] = 'none'
-      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
@@ -56,7 +55,7 @@ describe Puppet::Network::HTTP::Factory do
     it 'should not set a proxy if a no_proxy env var matches the destination' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
-      Puppet::Util::HttpProxy.expects(:no_proxy?).returns true
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(true)
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
@@ -65,7 +64,7 @@ describe Puppet::Network::HTTP::Factory do
 
     it 'sets proxy_address' do
       Puppet[:http_proxy_host] = proxy_host
-      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
       conn = create_connection(site)
 
       expect(conn.proxy_address).to eq(proxy_host)
@@ -74,7 +73,7 @@ describe Puppet::Network::HTTP::Factory do
     it 'sets proxy address and port' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
-      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
+      expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
       conn = create_connection(site)
 
       expect(conn.proxy_port).to eq(proxy_port)

data/spec/unit/network/http/handler_spec.rb

@@ -1,12 +1,8 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/handler'
-
 require 'puppet/indirector_testing'
-
 require 'puppet/network/authorization'
-
 require 'puppet/network/http'
 
 describe Puppet::Network::HTTP::Handler do
@@ -84,7 +80,7 @@ describe Puppet::Network::HTTP::Handler do
         Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise error}))
 
       # Stacktraces should be included in logs
-      Puppet.expects(:err).with("Server Error: the sky is falling!\na.rb\nb.rb")
+      expect(Puppet).to receive(:err).with("Server Error: the sky is falling!\na.rb\nb.rb")
 
       req = a_request("GET", "/vtest/foo")
       res = {}
@@ -107,8 +103,8 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     before do
-      handler.stubs(:check_authorization)
-      handler.stubs(:warn_if_near_expiration)
+      allow(handler).to receive(:check_authorization)
+      allow(handler).to receive(:warn_if_near_expiration)
     end
 
     it "should setup a profiler when the puppet-profiling header exists" do
@@ -117,13 +113,8 @@ describe Puppet::Network::HTTP::Handler do
 
       p = PuppetSpec::HandlerProfiler.new
 
-      Puppet::Util::Profiler.expects(:add_profiler).with { |profiler|
-        profiler.is_a? Puppet::Util::Profiler::WallClock
-      }.returns(p)
-
-      Puppet::Util::Profiler.expects(:remove_profiler).with { |profiler|
-        profiler == p
-      }
+      expect(Puppet::Util::Profiler).to receive(:add_profiler).with(be_a(Puppet::Util::Profiler::WallClock)).and_return(p)
+      expect(Puppet::Util::Profiler).to receive(:remove_profiler).with(p)
 
       handler.process(request, response)
     end
@@ -132,7 +123,7 @@ describe Puppet::Network::HTTP::Handler do
       request = a_request
       request[:params] = { }
 
-      Puppet::Util::Profiler.expects(:add_profiler).never
+      expect(Puppet::Util::Profiler).not_to receive(:add_profiler)
 
       handler.process(request, response)
     end
@@ -159,19 +150,19 @@ describe Puppet::Network::HTTP::Handler do
 
   describe "when resolving node" do
     it "should use a look-up from the ip address" do
-      Resolv.expects(:getname).with("1.2.3.4").returns("host.domain.com")
+      expect(Resolv).to receive(:getname).with("1.2.3.4").and_return("host.domain.com")
 
       handler.resolve_node(:ip => "1.2.3.4")
     end
 
     it "should return the look-up result" do
-      Resolv.stubs(:getname).with("1.2.3.4").returns("host.domain.com")
+      allow(Resolv).to receive(:getname).with("1.2.3.4").and_return("host.domain.com")
 
       expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("host.domain.com")
     end
 
     it "should return the ip address if resolving fails" do
-      Resolv.stubs(:getname).with("1.2.3.4").raises(RuntimeError, "no such host")
+      allow(Resolv).to receive(:getname).with("1.2.3.4").and_raise(RuntimeError, "no such host")
 
       expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("1.2.3.4")
     end