puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

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

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
@@ -6,13 +5,13 @@ require 'puppet/network/http/connection'
 
 describe Puppet::Network::HTTP::NoCachePool do
   let(:site) { Puppet::Network::HTTP::Site.new('https', 'rubygems.org', 443) }
-  let(:verifier) { stub('verifier', :setup_connection => nil) }
+  let(:verifier) { double('verifier', :setup_connection => nil) }
 
   it 'yields a started connection' do
-    http  = stub('http', start: nil, finish: nil)
+    http  = double('http', start: nil, finish: nil)
 
     factory = Puppet::Network::HTTP::Factory.new
-    factory.stubs(:create_connection).returns(http)
+    allow(factory).to receive(:create_connection).and_return(http)
     pool = Puppet::Network::HTTP::NoCachePool.new(factory)
 
     expect { |b|
@@ -21,11 +20,11 @@ describe Puppet::Network::HTTP::NoCachePool do
   end
 
   it 'yields a new connection each time' do
-    http1  = stub('http1', start: nil, finish: nil)
-    http2  = stub('http2', start: nil, finish: nil)
+    http1  = double('http1', start: nil, finish: nil)
+    http2  = double('http2', start: nil, finish: nil)
 
     factory = Puppet::Network::HTTP::Factory.new
-    factory.stubs(:create_connection).returns(http1).then.returns(http2)
+    allow(factory).to receive(:create_connection).and_return(http1, http2)
     pool = Puppet::Network::HTTP::NoCachePool.new(factory)
 
     expect { |b|

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'openssl'
@@ -22,7 +21,7 @@ describe Puppet::Network::HTTP::Pool do
   let(:ssl_context) { Puppet::SSL::SSLContext.new }
   let(:verifier) do
     v = Puppet::SSL::Verifier.new(site.host, ssl_context)
-    v.stubs(:setup_connection => nil)
+    allow(v).to receive(:setup_connection)
     v
   end
 
@@ -49,7 +48,7 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   def create_connection(site)
-    stub(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
+    double(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
   end
 
   context 'when yielding a connection' do
@@ -105,7 +104,7 @@ describe Puppet::Network::HTTP::Pool do
       pool = create_pool
       pool.release(site, verifier, conn)
 
-      pool.expects(:release).with(site, verifier, conn).never
+      expect(pool).not_to receive(:release).with(site, verifier, conn)
 
       pool.with_connection(site, verifier) do |c|
         raise IOError, 'connection reset'
@@ -140,33 +139,33 @@ describe Puppet::Network::HTTP::Pool do
     context 'when releasing connections' do
       it 'releases HTTP connections' do
         conn = create_connection(site)
-        conn.expects(:use_ssl?).returns(false)
+        expect(conn).to receive(:use_ssl?).and_return(false)
 
         pool = create_pool_with_connections(site, conn)
-        pool.expects(:release).with(site, verifier, conn)
+        expect(pool).to receive(:release).with(site, verifier, conn)
 
         pool.with_connection(site, verifier) {|c| }
       end
 
       it 'releases secure HTTPS connections' do
         conn = create_connection(site)
-        conn.expects(:use_ssl?).returns(true)
-        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_PEER)
+        expect(conn).to receive(:use_ssl?).and_return(true)
+        expect(conn).to receive(:verify_mode).and_return(OpenSSL::SSL::VERIFY_PEER)
 
         pool = create_pool_with_connections(site, conn)
-        pool.expects(:release).with(site, verifier, conn)
+        expect(pool).to receive(:release).with(site, verifier, conn)
 
         pool.with_connection(site, verifier) {|c| }
       end
 
       it 'closes insecure HTTPS connections' do
         conn = create_connection(site)
-        conn.expects(:use_ssl?).returns(true)
-        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_NONE)
+        expect(conn).to receive(:use_ssl?).and_return(true)
+        expect(conn).to receive(:verify_mode).and_return(OpenSSL::SSL::VERIFY_NONE)
 
         pool = create_pool_with_connections(site, conn)
 
-        pool.expects(:release).with(site, verifier, conn).never
+        expect(pool).not_to receive(:release).with(site, verifier, conn)
 
         pool.with_connection(site, verifier) {|c| }
       end
@@ -177,8 +176,8 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a new connection if the pool is empty' do
       conn = create_connection(site)
       pool = create_pool
-      pool.factory.expects(:create_connection).with(site).returns(conn)
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
+      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -187,7 +186,7 @@ describe Puppet::Network::HTTP::Pool do
       conn = create_connection(site)
       pool = create_pool_with_connections(site, conn)
 
-      pool.factory.expects(:create_connection).never
+      expect(pool.factory).not_to receive(:create_connection)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -197,8 +196,8 @@ describe Puppet::Network::HTTP::Pool do
       pool = create_pool_with_connections(different_site, different_conn)
 
       conn = create_connection(site)
-      pool.factory.expects(:create_connection).with(site).returns(conn)
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
+      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -206,13 +205,13 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a new connection if the ssl contexts are different' do
       old_conn = create_connection(site)
       pool = create_pool_with_connections(site, old_conn)
-      pool.stubs(:setsockopts)
+      allow(pool).to receive(:setsockopts)
 
       new_conn = create_connection(site)
-      pool.factory.stubs(:create_connection).with(site).returns(new_conn)
+      allow(pool.factory).to receive(:create_connection).with(site).and_return(new_conn)
 
       new_verifier = Puppet::SSL::Verifier.new(site.host, Puppet::SSL::SSLContext.new)
-      new_verifier.stubs(:setup_connection)
+      allow(new_verifier).to receive(:setup_connection)
 
       # 'equal' tests that it's the same object
       expect(pool.borrow(site, new_verifier)).to eq(new_conn)
@@ -221,9 +220,9 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a cached connection if the ssl contexts are the same' do
       old_conn = create_connection(site)
       pool = create_pool_with_connections(site, old_conn)
-      pool.stubs(:setsockopts)
+      allow(pool).to receive(:setsockopts)
 
-      pool.factory.expects(:create_connection).never
+      expect(pool.factory).not_to receive(:create_connection)
 
       # 'equal' tests that it's the same object
       new_verifier = Puppet::SSL::Verifier.new(site.host, ssl_context)
@@ -232,18 +231,18 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'returns started connections' do
       conn = create_connection(site)
-      conn.expects(:start)
+      expect(conn).to receive(:start)
 
       pool = create_pool
-      pool.factory.expects(:create_connection).with(site).returns(conn)
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
+      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
 
     it "doesn't start a cached connection" do
       conn = create_connection(site)
-      conn.expects(:start).never
+      expect(conn).not_to receive(:start)
 
       pool = create_pool_with_connections(site, conn)
       pool.borrow(site, verifier)
@@ -259,24 +258,24 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'finishes expired connections' do
       conn = create_connection(site)
-      conn.expects(:finish)
+      expect(conn).to receive(:finish)
 
       pool = create_pool_with_expired_connections(site, conn)
-      pool.factory.expects(:create_connection => stub('conn', :start => nil))
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).and_return(double('conn', :start => nil))
+      expect(pool).to receive(:setsockopts)
 
       pool.borrow(site, verifier)
     end
 
     it 'logs an exception if it fails to close an expired connection' do
-      Puppet.expects(:log_exception).with(is_a(IOError), "Failed to close connection for #{site}: read timeout")
+      expect(Puppet).to receive(:log_exception).with(be_a(IOError), "Failed to close connection for #{site}: read timeout")
 
       conn = create_connection(site)
-      conn.expects(:finish).raises(IOError, 'read timeout')
+      expect(conn).to receive(:finish).and_raise(IOError, 'read timeout')
 
       pool = create_pool_with_expired_connections(site, conn)
-      pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
-      pool.expects(:setsockopts)
+      expect(pool.factory).to receive(:create_connection).and_return(double('open_conn', :start => nil))
+      expect(pool).to receive(:setsockopts)
 
       pool.borrow(site, verifier)
     end
@@ -320,7 +319,7 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'closes all cached connections' do
       conn = create_connection(site)
-      conn.expects(:finish)
+      expect(conn).to receive(:finish)
 
       pool = create_pool_with_connections(site, conn)
       pool.close

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

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

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/handler'
@@ -17,14 +15,14 @@ describe Puppet::Network::HTTP::Response do
 
   context "when passed a response body" do
     it "passes the status code and body to the handler" do
-      handler.expects(:set_response).with(response, body_utf8, 200)
+      expect(handler).to receive(:set_response).with(response, body_utf8, 200)
 
       subject.respond_with(200, 'application/json', body_utf8)
     end
 
     it "accepts a File body" do
       file = tmpfile('response_spec')
-      handler.expects(:set_response).with(response, file, 200)
+      expect(handler).to receive(:set_response).with(response, file, 200)
 
       subject.respond_with(200, 'application/octet-stream', file)
     end
@@ -32,14 +30,14 @@ describe Puppet::Network::HTTP::Response do
 
   context "when passed a content type" do
     it "accepts a mime string" do
-      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
 
       subject.respond_with(200, 'application/json', body_utf8)
     end
 
     it "accepts a format object" do
       formatter = Puppet::Network::FormatHandler.format(:json)
-      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
 
       subject.respond_with(200, formatter, body_utf8)
     end
@@ -51,7 +49,7 @@ describe Puppet::Network::HTTP::Response do
         body_binary = [0xDEADCAFE].pack('L')
 
         formatter = Puppet::Network::FormatHandler.format(:binary)
-        handler.expects(:set_content_type).with(response, 'application/octet-stream')
+        expect(handler).to receive(:set_content_type).with(response, 'application/octet-stream')
 
         subject.respond_with(200, formatter, body_binary)
       end
@@ -63,14 +61,14 @@ describe Puppet::Network::HTTP::Response do
       it "sets the charset to UTF-8 for content already in that format" do
         body_pem = "BEGIN CERTIFICATE".encode('UTF-8')
 
-        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
 
         subject.respond_with(200, formatter, body_pem)
       end
 
       it "encodes the content to UTF-8 for content not already in UTF-8" do
-        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
-        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
 
         subject.respond_with(200, formatter, body_shift_jis)
       end
@@ -86,14 +84,14 @@ describe Puppet::Network::HTTP::Response do
       let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
 
       it "sets the charset to UTF-8 for content already in that format" do
-        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
 
         subject.respond_with(200, formatter, body_utf8)
       end
 
       it "encodes the content to UTF-8 for content not already in UTF-8" do
-        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
-        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
+        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
 
         subject.respond_with(200, formatter, body_shift_jis)
       end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector_testing'