puppet 6.0.7-x86-mingw32 → 6.0.8-x86-mingw32

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"
@@ -31,7 +30,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
@@ -55,10 +54,10 @@ describe Puppet::Network::Resolver 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([])
 
       resolver.each_srv_record(@test_a_hostname) do |hostname, port, remaining|
         raise Exception.new("host with no records passed block")
@@ -76,10 +75,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)
 
       resolver.each_srv_record(@test_srv_domain) do |hostname, port|
         expected_priority = order.keys.min
@@ -104,15 +103,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)
 
       resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -145,15 +144,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)
 
       resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -200,7 +199,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 = resolver.find_weighted_server(records)
           seen[server] += 1
         end
@@ -215,10 +214,10 @@ describe Puppet::Network::Resolver do
 
   describe "caching records" do
     it "should query DNS when no cache entry exists, then retrieve the cached value" do
-      @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).once
+      ).and_return(@test_records).once
 
       fetched_servers = []
       resolver.each_srv_record(@test_srv_domain) do |server, port|
@@ -226,7 +225,7 @@ describe Puppet::Network::Resolver do
       end
 
       cached_servers = []
-      resolver.expects(:expired?).returns false
+      expect(resolver).to receive(:expired?).and_return(false)
       resolver.each_srv_record(@test_srv_domain) do |server, port|
         cached_servers << server
       end
@@ -242,10 +241,10 @@ describe Puppet::Network::Resolver do
         ttl_record2.instance_variable_set(:@ttl, 20)
         records = [ttl_record1, ttl_record2]
 
-        @dns_mock_object.expects(:getresources).with(
+        expect(@dns_mock_object).to receive(:getresources).with(
           "_x-puppet._tcp.#{@test_srv_domain}",
           @rr_type
-        ).returns(records)
+        ).and_return(records)
       end
 
       it "should save the shortest TTL among records for a service" do
@@ -259,7 +258,7 @@ describe Puppet::Network::Resolver do
           expect(server).to match(/puppet.*domain\.com/)
         end
 
-        resolver.expects(:expired?).with(:puppet).returns false
+        expect(resolver).to receive(:expired?).with(:puppet).and_return(false)
         # Load from cache
         resolver.each_srv_record(@test_srv_domain) do |server, port|
           expect(server).to match(/puppet.*domain\.com/)
@@ -267,11 +266,11 @@ describe Puppet::Network::Resolver do
 
         new_record = Resolv::DNS::Resource::IN::SRV.new(0, 20, 8140, "new.domain.com")
         new_record.instance_variable_set(:@ttl, 10)
-        @dns_mock_object.expects(:getresources).with(
+        expect(@dns_mock_object).to receive(:getresources).with(
           "_x-puppet._tcp.#{@test_srv_domain}",
           @rr_type
-        ).returns([new_record])
-        resolver.expects(:expired?).with(:puppet).returns true
+        ).and_return([new_record])
+        expect(resolver).to receive(:expired?).with(:puppet).and_return(true)
         # Refresh from DNS
         resolver.each_srv_record(@test_srv_domain) do |server, port|
           expect(server).to eq("new.domain.com")

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/node/environment_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
@@ -112,7 +111,7 @@ describe Puppet::Node::Environment do
 
     describe "when managing known resource types" do
       before do
-        env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
+        allow(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
       end
 
       it "creates a resource type collection if none exists" do
@@ -124,13 +123,13 @@ describe Puppet::Node::Environment do
       end
 
       it "performs the initial import when creating a new collection" do
-        env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
+        expect(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
         env.known_resource_types
       end
 
       it "generates a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
-        old_type_collection.stubs(:parse_failed?).returns true
+        allow(old_type_collection).to receive(:parse_failed?).and_return(true)
 
         env.check_for_reparse
 
@@ -171,7 +170,7 @@ describe Puppet::Node::Environment do
       end
 
       context "when disable_per_environment_manifest is true" do
-        let(:config) { mock('config') }
+        let(:config) { double('config') }
         let(:global_modulepath) { ["/global/modulepath"] }
         let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, global_modulepath) }
 
@@ -180,12 +179,12 @@ describe Puppet::Node::Environment do
         end
 
         def assert_manifest_conflict(expectation, envconf_manifest_value)
-          config.expects(:setting).with(:manifest).returns(
-            mock('setting', :value => envconf_manifest_value)
+          expect(config).to receive(:setting).with(:manifest).and_return(
+            double('setting', :value => envconf_manifest_value)
           )
           environment = Puppet::Node::Environment.create(:directory, [], '/default/manifests/site.pp')
           loader = Puppet::Environments::Static.new(environment)
-          loader.stubs(:get_conf).returns(envconf)
+          allow(loader).to receive(:get_conf).and_return(envconf)
 
           Puppet.override(:environments => loader) do
             if expectation
@@ -404,7 +403,7 @@ describe Puppet::Node::Environment do
           it "creates modules with the correct environment" do
             PuppetSpec::Modules.generate_files('foo', first_modulepath)
 
-            env.modules.each do |mod| 
+            env.modules.each do |mod|
               expect(mod.environment).to eq(env)
             end
           end
@@ -419,7 +418,7 @@ describe Puppet::Node::Environment do
               }
             )
 
-            Puppet.expects(:log_exception).with(is_a(Puppet::Module::MissingMetadata))
+            expect(Puppet).to receive(:log_exception).with(be_a(Puppet::Module::MissingMetadata))
 
             env.modules
           end
@@ -431,7 +430,7 @@ describe Puppet::Node::Environment do
       let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
       before(:each) do
-        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
         Puppet.push_context({:loaders => loaders, :current_environment => env})
       end
 
@@ -495,9 +494,9 @@ describe Puppet::Node::Environment do
 
   describe "managing module translations" do
     it "creates a new text domain the first time we try to use the text domain" do
-      Puppet::GettextConfig.expects(:reset_text_domain).with(env.name)
-      Puppet::ModuleTranslations.expects(:load_from_modulepath)
-      Puppet::GettextConfig.expects(:clear_text_domain)
+      expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
+      expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
+      expect(Puppet::GettextConfig).to receive(:clear_text_domain)
 
       env.with_text_domain do; end
     end
@@ -505,7 +504,7 @@ describe Puppet::Node::Environment do
     it "uses the existing text domain once it has been created" do
       env.with_text_domain do; end
 
-      Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
+      expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
       env.with_text_domain do; end
     end