puppet 5.5.12-x86-mingw32 → 5.5.13-x86-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'
@@ -37,7 +36,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
@@ -46,7 +45,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
@@ -55,7 +54,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
@@ -64,7 +63,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)
@@ -73,7 +72,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(:verify) { stub('verify', :setup_connection => nil) }
+  let(:verify) { double('verify', :setup_connection => nil) }
 
   it 'yields a connection' do
-    http  = stub('http')
+    http  = double('http')
 
     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')
-    http2  = stub('http2')
+    http1  = double('http1')
+    http2  = double('http2')
 
     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'
@@ -20,7 +19,7 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   let(:verify) do
-    stub('verify', :setup_connection => nil)
+    double('verify', :setup_connection => nil)
   end
 
   def create_pool
@@ -46,7 +45,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
@@ -102,7 +101,7 @@ describe Puppet::Network::HTTP::Pool do
       pool = create_pool
       pool.release(site, conn)
 
-      pool.expects(:release).with(site, conn).never
+      expect(pool).not_to receive(:release).with(site, conn)
 
       pool.with_connection(site, verify) do |c|
         raise IOError, 'connection reset'
@@ -137,33 +136,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, conn)
+        expect(pool).to receive(:release).with(site, conn)
 
         pool.with_connection(site, verify) {|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, conn)
+        expect(pool).to receive(:release).with(site, conn)
 
         pool.with_connection(site, verify) {|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, conn).never
+        expect(pool).not_to receive(:release).with(site, conn)
 
         pool.with_connection(site, verify) {|c| }
       end
@@ -174,8 +173,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, verify)).to eq(conn)
     end
@@ -184,7 +183,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, verify)).to eq(conn)
     end
@@ -194,26 +193,26 @@ 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, verify)).to eq(conn)
     end
 
     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, verify)).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, verify)
@@ -229,24 +228,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, verify)
     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, verify)
     end
@@ -290,7 +289,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/rack/rest_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 require 'puppet/network/http/rack/rest'
@@ -9,12 +8,10 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
   end
 
   describe "when serving a request" do
-    before :all do
-      @model_class = stub('indirected model class')
-      Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
-    end
-
     before :each do
+      @model_class = double('indirected model class')
+      allow(Puppet::Indirector::Indirection).to receive(:model).with(:foo).and_return(@model_class)
+
       @response = Rack::Response.new
       @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
     end
@@ -89,35 +86,35 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       end
 
       it "should set the response's content-type header when setting the content type" do
-        @header = mock 'header'
-        @response.expects(:header).returns @header
-        @header.expects(:[]=).with('Content-Type', "mytype")
+        @header = double('header')
+        expect(@response).to receive(:header).and_return(@header)
+        expect(@header).to receive(:[]=).with('Content-Type', "mytype")
 
         @handler.set_content_type(@response, "mytype")
       end
 
       it "should set the status and write the body when setting the response for a request" do
-        @response.expects(:status=).with(400)
-        @response.expects(:write).with("mybody")
+        expect(@response).to receive(:status=).with(400)
+        expect(@response).to receive(:write).with("mybody")
 
         @handler.set_response(@response, "mybody", 400)
       end
 
       describe "when result is a File" do
         before :each do
-          stat = stub 'stat', :size => 100
-          @file = stub 'file', :stat => stat, :path => "/tmp/path"
-          @file.stubs(:is_a?).with(File).returns(true)
+          stat = double('stat', :size => 100)
+          @file = double('file', :stat => stat, :path => "/tmp/path")
+          allow(@file).to receive(:is_a?).with(File).and_return(true)
         end
 
         it "should set the Content-Length header as a string" do
-          @response.expects(:[]=).with("Content-Length", '100')
+          expect(@response).to receive(:[]=).with("Content-Length", '100')
 
           @handler.set_response(@response, @file, 200)
         end
 
         it "should return a RackFile adapter as body" do
-          @response.expects(:body=).with { |val| val.is_a?(Puppet::Network::HTTP::RackREST::RackFile) }
+          expect(@response).to receive(:body=).with(be_a(Puppet::Network::HTTP::RackREST::RackFile))
 
           @handler.set_response(@response, @file, 200)
         end
@@ -125,18 +122,18 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
 
       it "should ensure the body has been read on success" do
         req = mk_req('/production/report/foo', :method => 'PUT')
-        req.body.expects(:read).at_least_once
+        expect(req.body).to receive(:read).at_least(:once)
 
-        Puppet::Transaction::Report.stubs(:save)
+        allow(Puppet::Transaction::Report).to receive(:save)
 
         @handler.process(req, @response)
       end
 
       it "should ensure the body has been partially read on failure" do
         req = mk_req('/production/report/foo')
-        req.body.expects(:read).with(1)
+        expect(req.body).to receive(:read).with(1)
 
-        @handler.stubs(:headers).raises(StandardError)
+        allow(@handler).to receive(:headers).and_raise(StandardError)
 
         @handler.process(req, @response)
       end
@@ -270,14 +267,14 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => nil)
-        @handler.expects(:resolve_node).returns("host.domain.com")
+        expect(@handler).to receive(:resolve_node).and_return("host.domain.com")
         expect(@handler.params(req)[:node]).to eq("host.domain.com")
       end
 
       it "should resolve the node name with an ip address look-up if a certificate without a CN is present" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "O=no CN")
-        @handler.expects(:resolve_node).returns("host.domain.com")
+        expect(@handler).to receive(:resolve_node).and_return("host.domain.com")
         expect(@handler.params(req)[:node]).to eq("host.domain.com")
       end
 
@@ -286,7 +283,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         Puppet[:ssl_client_verify_header] = "verify_header"
         req = mk_req('/', "dn_header" => "O=no CN", "verify_header" => 'SUCCESS')
 
-        @handler.expects(:resolve_node).returns("host.domain.com")
+        expect(@handler).to receive(:resolve_node).and_return("host.domain.com")
 
         expect(@handler.params(req)[:authenticated]).to be_falsey
       end
@@ -296,8 +293,8 @@ end
 
 describe Puppet::Network::HTTP::RackREST::RackFile do
   before(:each) do
-    stat = stub 'stat', :size => 100
-    @file = stub 'file', :stat => stat, :path => "/tmp/path"
+    stat = double('stat', :size => 100)
+    @file = double('file', :stat => stat, :path => "/tmp/path")
     @rackfile = Puppet::Network::HTTP::RackREST::RackFile.new(@file)
   end
 
@@ -306,7 +303,7 @@ describe Puppet::Network::HTTP::RackREST::RackFile do
   end
 
   it "should yield file chunks by chunks" do
-    @file.expects(:read).times(3).with(8192).returns("1", "2", nil)
+    expect(@file).to receive(:read).exactly(3).times.with(8192).and_return("1", "2", nil)
     i = 1
     @rackfile.each do |chunk|
       expect(chunk.to_i).to eq(i)
@@ -319,7 +316,7 @@ describe Puppet::Network::HTTP::RackREST::RackFile do
   end
 
   it "should delegate close to File close" do
-    @file.expects(:close)
+    expect(@file).to receive(:close)
     @rackfile.close
   end
 end