puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

data/spec/unit/network/http_pool_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
@@ -51,22 +50,22 @@ describe Puppet::Network::HttpPool do
         ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
 
         Puppet[:ssl_client_ca_auth] = ca_cert_file
-        Puppet::FileSystem.stubs(:exist?).with(ca_cert_file).returns(true)
+        allow(Puppet::FileSystem).to receive(:exist?).with(ca_cert_file).and_return(true)
       end
 
       def setup_standard_hostcert
         host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
-        Puppet::FileSystem.stubs(:exist?).with(host_cert_file).returns(true)
+        allow(Puppet::FileSystem).to receive(:exist?).with(host_cert_file).and_return(true)
 
         Puppet[:hostcert] = host_cert_file
       end
 
       def setup_standard_ssl_host
-        cert = stub('cert', :content => 'real_cert')
-        key  = stub('key',  :content => 'real_key')
-        host = stub('host', :certificate => cert, :key => key, :ssl_store => stub('store'))
+        cert = double('cert', :content => 'real_cert')
+        key  = double('key',  :content => 'real_key')
+        host = double('host', :certificate => cert, :key => key, :ssl_store => double('store'))
 
-        Puppet::SSL::Host.stubs(:localhost).returns(host)
+        allow(Puppet::SSL::Host).to receive(:localhost).and_return(host)
       end
 
       before do
@@ -78,14 +77,24 @@ describe Puppet::Network::HttpPool do
       it 'enables peer verification by default' do
         response = Net::HTTPOK.new('1.1', 200, 'body')
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true)
-        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER) }.returns(response)
+        expect(conn).to receive(:execute_request) do |http, _|
+          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+
+          response
+        end
+
         conn.get('/')
       end
 
       it 'can disable peer verification' do
         response = Net::HTTPOK.new('1.1', 200, 'body')
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true, false)
-        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE) }.returns(response)
+        expect(conn).to receive(:execute_request) do |http, _|
+          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+
+          response
+        end
+
         conn.get('/')
       end
     end

data/spec/unit/network/http_spec.rb

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

data/spec/unit/network/resolver_spec.rb

@@ -1,11 +1,10 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/resolver'
 
 describe Puppet::Network::Resolver do
   before do
-    @dns_mock_object = mock('dns')
-    Resolv::DNS.stubs(:new).returns(@dns_mock_object)
+    @dns_mock_object = double('dns')
+    allow(Resolv::DNS).to receive(:new).and_return(@dns_mock_object)
 
     @rr_type         = Resolv::DNS::Resource::IN::SRV
     @test_srv_domain = "domain.com"
@@ -24,7 +23,7 @@ describe Puppet::Network::Resolver do
 
   describe 'when the domain is not known' do
     before :each do
-      @dns_mock_object.stubs(:getresources).returns(@test_records)
+      allow(@dns_mock_object).to receive(:getresources).and_return(@test_records)
     end
 
     describe 'because domain is nil' do
@@ -47,10 +46,10 @@ describe Puppet::Network::Resolver do
   describe "when resolving a host without SRV records" do
     it "should not yield anything" do
       # No records returned for a DNS entry without any SRV records
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_a_hostname}",
         @rr_type
-      ).returns([])
+      ).and_return([])
 
       Puppet::Network::Resolver.each_srv_record(@test_a_hostname) do |hostname, port, remaining|
         raise Exception.new("host with no records passed block")
@@ -68,10 +67,10 @@ describe Puppet::Network::Resolver do
         2 => ["puppet4.domain.com"]
       }
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(@test_records)
+      ).and_return(@test_records)
 
       Puppet::Network::Resolver.each_srv_record(@test_srv_domain) do |hostname, port|
         expected_priority = order.keys.min
@@ -96,15 +95,15 @@ describe Puppet::Network::Resolver do
         2 => ["puppet4.domain.com"]
       }
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet-report._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns([])
+      ).and_return([])
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(@test_records)
+      ).and_return(@test_records)
 
       Puppet::Network::Resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -137,15 +136,15 @@ describe Puppet::Network::Resolver do
         Resolv::DNS::Resource::IN::SRV.new(4,         1,      8140, "puppet4.bad.domain.com")
       ]
 
-      @dns_mock_object.expects(:getresources).with(
+      expect(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet-report._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(@test_records)
+      ).and_return(@test_records)
 
-      @dns_mock_object.stubs(:getresources).with(
+      allow(@dns_mock_object).to receive(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).returns(bad_records)
+      ).and_return(bad_records)
 
       Puppet::Network::Resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -192,7 +191,7 @@ describe Puppet::Network::Resolver do
         end
 
         total_weight.times do |n|
-          Kernel.expects(:rand).once.with(total_weight).returns(n)
+          expect(Kernel).to receive(:rand).once.with(total_weight).and_return(n)
           server = Puppet::Network::Resolver.find_weighted_server(records)
           seen[server] += 1
         end

data/spec/unit/network/rights_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/rights'
@@ -118,58 +117,58 @@ describe Puppet::Network::Rights do
 
   describe "when checking if right is allowed" do
     before :each do
-      @right.stubs(:right).returns(nil)
+      allow(@right).to receive(:right).and_return(nil)
 
-      @pathacl = stub 'pathacl', :"<=>" => 1, :line => 0, :file => 'dummy'
-      Puppet::Network::Rights::Right.stubs(:new).returns(@pathacl)
+      @pathacl = double('pathacl', :"<=>" => 1, :line => 0, :file => 'dummy')
+      allow(Puppet::Network::Rights::Right).to receive(:new).and_return(@pathacl)
     end
 
     it "should delegate to is_forbidden_and_why?" do
-      @right.expects(:is_forbidden_and_why?).with("namespace", :node => "host.domain.com", :ip => "127.0.0.1").returns(nil)
+      expect(@right).to receive(:is_forbidden_and_why?).with("namespace", :node => "host.domain.com", :ip => "127.0.0.1").and_return(nil)
 
       @right.allowed?("namespace", "host.domain.com", "127.0.0.1")
     end
 
     it "should return true if is_forbidden_and_why? returns nil" do
-      @right.stubs(:is_forbidden_and_why?).returns(nil)
+      allow(@right).to receive(:is_forbidden_and_why?).and_return(nil)
       expect(@right.allowed?("namespace", :args)).to be_truthy
     end
 
     it "should return false if is_forbidden_and_why? returns an AuthorizationError" do
-      @right.stubs(:is_forbidden_and_why?).returns(Puppet::Network::AuthorizationError.new("forbidden"))
+      allow(@right).to receive(:is_forbidden_and_why?).and_return(Puppet::Network::AuthorizationError.new("forbidden"))
       expect(@right.allowed?("namespace", :args1, :args2)).to be_falsey
     end
 
     it "should pass the match? return to allowed?" do
       @right.newright("/path/to/there")
 
-      @pathacl.expects(:match?).returns(:match)
-      @pathacl.expects(:allowed?).with { |node,ip,h| h[:match] == :match }.returns(true)
+      expect(@pathacl).to receive(:match?).and_return(:match)
+      expect(@pathacl).to receive(:allowed?).with(anything, anything, hash_including(match: :match)).and_return(true)
 
       expect(@right.is_forbidden_and_why?("/path/to/there", {})).to eq(nil)
     end
 
     describe "with path acls" do
       before :each do
-        @long_acl = stub 'longpathacl', :name => "/path/to/there", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("/path/to/there", 0, nil).returns(@long_acl)
+        @long_acl = double('longpathacl', :name => "/path/to/there", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("/path/to/there", 0, nil).and_return(@long_acl)
 
-        @short_acl = stub 'shortpathacl', :name => "/path/to", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("/path/to", 0, nil).returns(@short_acl)
+        @short_acl = double('shortpathacl', :name => "/path/to", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("/path/to", 0, nil).and_return(@short_acl)
 
-        @long_acl.stubs(:"<=>").with(@short_acl).returns(0)
-        @short_acl.stubs(:"<=>").with(@long_acl).returns(0)
+        allow(@long_acl).to receive(:"<=>").with(@short_acl).and_return(0)
+        allow(@short_acl).to receive(:"<=>").with(@long_acl).and_return(0)
       end
 
       it "should select the first match" do
         @right.newright("/path/to", 0)
         @right.newright("/path/to/there", 0)
 
-        @long_acl.stubs(:match?).returns(true)
-        @short_acl.stubs(:match?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@short_acl).to receive(:match?).and_return(true)
 
-        @short_acl.expects(:allowed?).returns(true)
-        @long_acl.expects(:allowed?).never
+        expect(@short_acl).to receive(:allowed?).and_return(true)
+        expect(@long_acl).not_to receive(:allowed?)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -178,11 +177,11 @@ describe Puppet::Network::Rights do
         @right.newright("/path/to/there", 0, nil)
         @right.newright("/path/to", 0, nil)
 
-        @long_acl.stubs(:match?).returns(true)
-        @short_acl.stubs(:match?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@short_acl).to receive(:match?).and_return(true)
 
-        @long_acl.expects(:allowed?).returns(:dunno)
-        @short_acl.expects(:allowed?).returns(true)
+        expect(@long_acl).to receive(:allowed?).and_return(:dunno)
+        expect(@short_acl).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -191,11 +190,11 @@ describe Puppet::Network::Rights do
         @right.newright("/path/to/there", 0)
         @right.newright("/path/to", 0)
 
-        @long_acl.stubs(:match?).returns(false)
-        @short_acl.stubs(:match?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(false)
+        allow(@short_acl).to receive(:match?).and_return(true)
 
-        @long_acl.expects(:allowed?).never
-        @short_acl.expects(:allowed?).returns(true)
+        expect(@long_acl).not_to receive(:allowed?)
+        expect(@short_acl).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -203,8 +202,8 @@ describe Puppet::Network::Rights do
       it "should not raise an AuthorizationError if allowed" do
         @right.newright("/path/to/there", 0)
 
-        @long_acl.stubs(:match?).returns(true)
-        @long_acl.stubs(:allowed?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@long_acl).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -212,8 +211,8 @@ describe Puppet::Network::Rights do
       it "should raise an AuthorizationError if the match is denied" do
         @right.newright("/path/to/there", 0, nil)
 
-        @long_acl.stubs(:match?).returns(true)
-        @long_acl.stubs(:allowed?).returns(false)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@long_acl).to receive(:allowed?).and_return(false)
 
         expect(@right.is_forbidden_and_why?("/path/to/there", {})).to be_instance_of(Puppet::Network::AuthorizationError)
       end
@@ -225,25 +224,25 @@ describe Puppet::Network::Rights do
 
     describe "with regex acls" do
       before :each do
-        @regex_acl1 = stub 'regex_acl1', :name => "/files/(.*)/myfile", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("~ /files/(.*)/myfile", 0, nil).returns(@regex_acl1)
+        @regex_acl1 = double('regex_acl1', :name => "/files/(.*)/myfile", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("~ /files/(.*)/myfile", 0, nil).and_return(@regex_acl1)
 
-        @regex_acl2 = stub 'regex_acl2', :name => "/files/(.*)/myfile/", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("~ /files/(.*)/myfile/", 0, nil).returns(@regex_acl2)
+        @regex_acl2 = double('regex_acl2', :name => "/files/(.*)/myfile/", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("~ /files/(.*)/myfile/", 0, nil).and_return(@regex_acl2)
 
-        @regex_acl1.stubs(:"<=>").with(@regex_acl2).returns(0)
-        @regex_acl2.stubs(:"<=>").with(@regex_acl1).returns(0)
+        allow(@regex_acl1).to receive(:"<=>").with(@regex_acl2).and_return(0)
+        allow(@regex_acl2).to receive(:"<=>").with(@regex_acl1).and_return(0)
       end
 
       it "should select the first match" do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        @regex_acl1.stubs(:match?).returns(true)
-        @regex_acl2.stubs(:match?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(true)
+        allow(@regex_acl2).to receive(:match?).and_return(true)
 
-        @regex_acl1.expects(:allowed?).returns(true)
-        @regex_acl2.expects(:allowed?).never
+        expect(@regex_acl1).to receive(:allowed?).and_return(true)
+        expect(@regex_acl2).not_to receive(:allowed?)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -252,11 +251,11 @@ describe Puppet::Network::Rights do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        @regex_acl1.stubs(:match?).returns(true)
-        @regex_acl2.stubs(:match?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(true)
+        allow(@regex_acl2).to receive(:match?).and_return(true)
 
-        @regex_acl1.expects(:allowed?).returns(:dunno)
-        @regex_acl2.expects(:allowed?).returns(true)
+        expect(@regex_acl1).to receive(:allowed?).and_return(:dunno)
+        expect(@regex_acl2).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -265,11 +264,11 @@ describe Puppet::Network::Rights do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        @regex_acl1.stubs(:match?).returns(false)
-        @regex_acl2.stubs(:match?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(false)
+        allow(@regex_acl2).to receive(:match?).and_return(true)
 
-        @regex_acl1.expects(:allowed?).never
-        @regex_acl2.expects(:allowed?).returns(true)
+        expect(@regex_acl1).not_to receive(:allowed?)
+        expect(@regex_acl2).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -277,8 +276,8 @@ describe Puppet::Network::Rights do
       it "should not raise an AuthorizationError if allowed" do
         @right.newright("~ /files/(.*)/myfile", 0)
 
-        @regex_acl1.stubs(:match?).returns(true)
-        @regex_acl1.stubs(:allowed?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(true)
+        allow(@regex_acl1).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -425,13 +424,13 @@ describe Puppet::Network::Rights do
       end
 
       it "should interpolate allow/deny patterns with the given match" do
-        @acl.expects(:interpolate).with(:match)
+        expect(@acl).to receive(:interpolate).with(:match)
 
         @acl.allowed?("me","127.0.0.1", { :method => :save, :match => :match, :authenticated => true })
       end
 
       it "should reset interpolation after the match" do
-        @acl.expects(:reset_interpolation)
+        expect(@acl).to receive(:reset_interpolation)
 
         @acl.allowed?("me","127.0.0.1", { :method => :save, :match => :match, :authenticated => true })
       end

data/spec/unit/network/server_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/server'
 
@@ -8,9 +7,9 @@ describe Puppet::Network::Server do
   let(:server) { Puppet::Network::Server.new(address, port) }
 
   before do
-    @mock_http_server = mock('http server')
-    Puppet.settings.stubs(:use)
-    Puppet::Network::HTTP::WEBrick.stubs(:new).returns(@mock_http_server)
+    @mock_http_server = double('http server')
+    allow(Puppet.settings).to receive(:use)
+    allow(Puppet::Network::HTTP::WEBrick).to receive(:new).and_return(@mock_http_server)
   end
 
   describe "when initializing" do
@@ -23,12 +22,12 @@ describe Puppet::Network::Server do
     end
 
     it "should use the :main setting section" do
-      Puppet.settings.expects(:use).with { |*args| args.include?(:main) }
+      expect(Puppet.settings).to receive(:use) { |*sections| expect(sections).to include(:main) }
       Puppet::Network::Server.new(address, port)
     end
 
     it "should use the :application setting section" do
-      Puppet.settings.expects(:use).with { |*args| args.include?(:application) }
+      expect(Puppet.settings).to receive(:use) { |*sections| expect(sections).to include(:application) }
 
       Puppet::Network::Server.new(address, port)
     end
@@ -36,7 +35,7 @@ describe Puppet::Network::Server do
 
   describe "when not yet started" do
     before do
-      @mock_http_server.stubs(:listen)
+      allow(@mock_http_server).to receive(:listen)
     end
 
     it "should indicate that it is not listening" do
@@ -54,8 +53,8 @@ describe Puppet::Network::Server do
 
   describe "when server is on" do
     before do
-      @mock_http_server.stubs(:listen)
-      @mock_http_server.stubs(:unlisten)
+      allow(@mock_http_server).to receive(:listen)
+      allow(@mock_http_server).to receive(:unlisten)
       server.start
     end
 
@@ -75,20 +74,20 @@ describe Puppet::Network::Server do
   describe "when server is being started" do
     it "should cause the HTTP server to listen" do
       server = Puppet::Network::Server.new(address, port)
-      @mock_http_server.expects(:listen).with(address, port)
+      expect(@mock_http_server).to receive(:listen).with(address, port)
       server.start
     end
   end
 
   describe "when server is being stopped" do
     before do
-      @mock_http_server.stubs(:listen)
-      server.stubs(:http_server).returns(@mock_http_server)
+      allow(@mock_http_server).to receive(:listen)
+      allow(server).to receive(:http_server).and_return(@mock_http_server)
       server.start
     end
 
     it "should cause the HTTP server to stop listening" do
-      @mock_http_server.expects(:unlisten)
+      expect(@mock_http_server).to receive(:unlisten)
       server.stop
     end
   end