puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/forge_spec.rb

@@ -101,12 +101,16 @@ describe Puppet::Forge do
 
   let(:forge) { Puppet::Forge.new }
 
-  def repository_responds_with(response)
-    Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
+  def repository_responds_with(response, &block)
+    if block_given?
+      allow_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request, &block).and_return(response)
+    else
+      allow_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request).and_return(response)
+    end
   end
 
   it "returns a list of matches from the forge when there are matches for the search term" do
-    repository_responds_with(stub(:body => http_response, :code => '200'))
+    repository_responds_with(double(:body => http_response, :code => '200'))
     expect(forge.search('bacula')).to eq(search_results)
   end
 
@@ -118,7 +122,7 @@ describe Puppet::Forge do
     end
 
     before :each do
-      repository_responds_with(stub(:body => release_response, :code => '200')).with {|uri| uri =~ /module_groups=foo/}
+      repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo/}
       Puppet[:module_groups] = "foo"
     end
 
@@ -141,7 +145,7 @@ describe Puppet::Forge do
 
     context "with space seperator" do
       before :each do
-        repository_responds_with(stub(:body => release_response, :code => '200')).with {|uri| uri =~ /module_groups=foo bar/}
+        repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo bar/}
         Puppet[:module_groups] = "foo bar"
       end
 
@@ -156,7 +160,7 @@ describe Puppet::Forge do
 
     context "with plus seperator" do
       before :each do
-        repository_responds_with(stub(:body => release_response, :code => '200')).with {|uri| uri =~ /module_groups=foo bar/}
+        repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo bar/}
         Puppet[:module_groups] = "foo+bar"
       end
 
@@ -172,10 +176,10 @@ describe Puppet::Forge do
     # See PUP-8008
     context "when there are multiple pages of results" do
       before(:each) do
-        Puppet::Forge::Repository.any_instance.expects(:make_http_request).with {|uri| uri =~ /module_groups=foo bar/ && uri !=~ /offset/ }.returns(stub(:body => first_page, :code => '200'))
+        expect_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request) {|_, uri| uri =~ /module_groups=foo bar/ && uri !=~ /offset/ }.and_return(double(:body => first_page, :code => '200'))
 
         # Request for second page should not have module_groups already encoded
-        Puppet::Forge::Repository.any_instance.expects(:make_http_request).with {|uri| uri =~ /module_groups=foo bar/ && uri =~ /offset=1/ }.returns(stub(:body => last_page, :code => '200'))
+        expect_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request) {|_, uri| uri =~ /module_groups=foo bar/ && uri =~ /offset=1/ }.and_return(double(:body => last_page, :code => '200'))
       end
 
       context "with space seperator" do
@@ -238,7 +242,7 @@ describe Puppet::Forge do
 
   context "when the connection to the forge fails" do
     before :each do
-      repository_responds_with(stub(:body => '{}', :code => '404', :message => "not found"))
+      repository_responds_with(double(:body => '{}', :code => '404', :message => "not found"))
     end
 
     it "raises an error for search" do
@@ -252,7 +256,7 @@ describe Puppet::Forge do
 
   context "when the API responds with an error" do
     before :each do
-      repository_responds_with(stub(:body => '{"error":"invalid module"}', :code => '410', :message => "Gone"))
+      repository_responds_with(double(:body => '{"error":"invalid module"}', :code => '410', :message => "Gone"))
     end
 
     it "raises an error for fetch" do
@@ -266,7 +270,7 @@ describe Puppet::Forge do
       release = response['results'][0]['current_release']
       release['metadata']['dependencies'] = [{'name' => 'broken-garbage >= 1.0.0', 'version_requirement' => 'banana'}]
       response['results'] = [release]
-      repository_responds_with(stub(:body => JSON.dump(response), :code => '200'))
+      repository_responds_with(double(:body => JSON.dump(response), :code => '200'))
     end
 
     it "ignores modules with unparseable dependencies" do

data/spec/unit/functions/binary_file_spec.rb

@@ -33,12 +33,12 @@ describe 'the binary_file function' do
 
   it 'reads an existing file in a module' do
     with_file_content('binary_data') do |name|
-      mod = mock 'module'
-      mod.stubs(:file).with('myfile').returns(name)
+      mod = double('module')
+      allow(mod).to receive(:file).with('myfile').and_return(name)
       Puppet[:code] = "notify { String(binary_file('mymod/myfile')):}"
       node = Puppet::Node.new('localhost')
       compiler = Puppet::Parser::Compiler.new(node)
-      compiler.environment.stubs(:module).with('mymod').returns(mod)
+      allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
       # Note that the Binary to string produces Base64 encoded version of 'binary_data' which is 'YmluYXJ5X2RhdGE='
       expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[YmluYXJ5X2RhdGE=]")
     end

data/spec/unit/functions/contain_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
@@ -7,7 +6,6 @@ require 'matchers/resource'
 require 'matchers/include_in_order'
 require 'unit/functions/shared'
 
-
 describe 'The "contain" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers

data/spec/unit/functions/defined_spec.rb

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

data/spec/unit/functions/epp_spec.rb

@@ -153,7 +153,7 @@ describe "the epp function" do
     filename = File.join(file_path, "template.epp")
     File.open(filename, "wb+") { |f| f.write(content) }
 
-    Puppet::Parser::Files.stubs(:find_template).returns(filename)
+    allow(Puppet::Parser::Files).to receive(:find_template).and_return(filename)
     epp_function.call(scope, 'template', args_hash)
   end
 
@@ -162,7 +162,7 @@ describe "the epp function" do
     filename = File.join(file_path, "template.epp")
     File.open(filename, "wb+") { |f| f.write(content) }
 
-    Puppet::Parser::Files.stubs(:find_template).returns(filename)
+    allow(Puppet::Parser::Files).to receive(:find_template).and_return(filename)
     epp_function.call(scope, 'template')
   end
 

data/spec/unit/functions/find_file_spec.rb

@@ -42,27 +42,27 @@ describe 'the find_file function' do
 
   it 'finds an existing file in a module' do
     with_file_content('file content') do |name|
-      mod = mock 'module'
-      mod.stubs(:file).with('myfile').returns(name)
+      mod = double('module')
+      allow(mod).to receive(:file).with('myfile').and_return(name)
       Puppet[:code] = "notify { find_file('mymod/myfile'):}"
       node = Puppet::Node.new('localhost')
       compiler = Puppet::Parser::Compiler.new(node)
-      compiler.environment.stubs(:module).with('mymod').returns(mod)
+      allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
 
       expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[#{name}]")
     end
   end
 
   it 'returns undef when none of the paths were found' do
-    mod = mock 'module'
-    mod.stubs(:file).with('myfile').returns(nil)
+    mod = double('module')
+    allow(mod).to receive(:file).with('myfile').and_return(nil)
     Puppet[:code] = "notify { String(type(find_file('mymod/myfile', 'nomod/nofile'))):}"
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
     # For a module that does not have the file
-    compiler.environment.stubs(:module).with('mymod').returns(mod)
+    allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
     # For a module that does not exist
-    compiler.environment.stubs(:module).with('nomod').returns(nil)
+    allow(compiler.environment).to receive(:module).with('nomod').and_return(nil)
 
     expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[Undef]")
   end

data/spec/unit/functions/include_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
@@ -7,7 +6,6 @@ require 'matchers/resource'
 require 'matchers/include_in_order'
 require 'unit/functions/shared'
 
-
 describe 'The "include" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers
@@ -128,7 +126,6 @@ describe 'The "include" function' do
     expect(catalog).to_not contain_class("not_contained").in("container")
   end
 
-
   it 'produces an array with a single class references given a single argument' do
     catalog = compile_to_catalog(<<-MANIFEST)
       class a {
@@ -186,5 +183,4 @@ describe 'The "include" function' do
   it_should_behave_like 'all functions transforming relative to absolute names', :include
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :include
   it_should_behave_like 'an inclusion function, when --tasks is on,', :include
-
 end

data/spec/unit/functions/lookup_fixture_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/files'

data/spec/unit/functions/lookup_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/files'
@@ -2072,7 +2071,7 @@ describe "The lookup function" do
         end
 
         it 'provides a sensible error message when the hocon library is not loaded' do
-          Puppet.features.stubs(:hocon?).returns(false)
+          allow(Puppet.features).to receive(:hocon?).and_return(false)
 
           expect { lookup('a') }.to raise_error do |e|
             expect(e.message).to match(/Lookup using Hocon data_hash function is not supported without hocon library/)

data/spec/unit/functions/module_directory_spec.rb

@@ -9,35 +9,35 @@ describe 'the module_directory function' do
   include PuppetSpec::Files
 
   it 'returns first found module from one or more given names' do
-    mod = mock 'module'
-    mod.stubs(:path).returns('expected_path')
+    mod = double('module')
+    allow(mod).to receive(:path).and_return('expected_path')
     Puppet[:code] = "notify { module_directory('one', 'two'):}"
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
-    compiler.environment.stubs(:module).with('one').returns(nil)
-    compiler.environment.stubs(:module).with('two').returns(mod)
+    allow(compiler.environment).to receive(:module).with('one').and_return(nil)
+    allow(compiler.environment).to receive(:module).with('two').and_return(mod)
     expect(compiler.compile()).to have_resource("Notify[expected_path]")
   end
 
   it 'returns first found module from one or more given names in an array' do
-    mod = mock 'module'
-    mod.stubs(:path).returns('expected_path')
+    mod = double('module')
+    allow(mod).to receive(:path).and_return('expected_path')
     Puppet[:code] = "notify { module_directory(['one', 'two']):}"
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
-    compiler.environment.stubs(:module).with('one').returns(nil)
-    compiler.environment.stubs(:module).with('two').returns(mod)
+    allow(compiler.environment).to receive(:module).with('one').and_return(nil)
+    allow(compiler.environment).to receive(:module).with('two').and_return(mod)
     expect(compiler.compile()).to have_resource("Notify[expected_path]")
   end
 
   it 'returns undef when none of the modules were found' do
-    mod = mock 'module'
-    mod.stubs(:path).returns('expected_path')
+    mod = double('module')
+    allow(mod).to receive(:path).and_return('expected_path')
     Puppet[:code] = "notify { String(type(module_directory('one', 'two'))):}"
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
-    compiler.environment.stubs(:module).with('one').returns(nil)
-    compiler.environment.stubs(:module).with('two').returns(nil)
+    allow(compiler.environment).to receive(:module).with('one').and_return(nil)
+    allow(compiler.environment).to receive(:module).with('two').and_return(nil)
     expect(compiler.compile()).to have_resource("Notify[Undef]")
   end
 end

data/spec/unit/functions/require_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
@@ -7,7 +6,6 @@ require 'matchers/resource'
 require 'matchers/include_in_order'
 require 'unit/functions/shared'
 
-
 describe 'The "require" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers
@@ -81,5 +79,4 @@ describe 'The "require" function' do
   it_should_behave_like 'all functions transforming relative to absolute names', :require
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :require
   it_should_behave_like 'an inclusion function, when --tasks is on,', :require
-
 end

data/spec/unit/functions/shared.rb

@@ -2,19 +2,19 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
   before(:each) do
     # mock that the class 'myclass' exists which are needed for the 'require' functions
     # as it checks the existence of the required class
-    @klass = stub 'class', :name => "myclass"
-    @scope.environment.known_resource_types.stubs(:find_hostclass).returns(@klass)
+    @klass = double('class', :name => "myclass")
+    allow(@scope.environment.known_resource_types).to receive(:find_hostclass).and_return(@klass)
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
-    @scope.stubs(:resource).returns @resource
+    allow(@scope).to receive(:resource).and_return(@resource)
   end
 
   it 'accepts a Class[name] type' do
-    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
     @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
   end
 
   it 'accepts a Resource[class, name] type' do
-    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
     @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
   end
 
@@ -45,7 +45,6 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
 end
 
 shared_examples_for 'an inclusion function, regardless of the type of class reference,' do |function|
-
     it "and #{function} a class absolutely, even when a relative namespaced class of the same name is present" do
       catalog = compile_to_catalog(<<-MANIFEST)
         class foo {
@@ -81,7 +80,6 @@ shared_examples_for 'an inclusion function, regardless of the type of class refe
       MANIFEST
       expect(catalog.classes).to include('foo','bar')
     end
-
 end
 
 shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
@@ -94,4 +92,3 @@ shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
     end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
   end
 end
-

data/spec/unit/functions/versioncmp_spec.rb

@@ -3,7 +3,6 @@ require 'puppet/pops'
 require 'puppet/loaders'
 
 describe "the versioncmp function" do
-
   before(:all) do
     loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.push_context({:loaders => loaders}, "test-examples")
@@ -29,7 +28,7 @@ describe "the versioncmp function" do
   end
 
   it "should call Puppet::Util::Package.versioncmp (included in scope)" do
-    Puppet::Util::Package.expects(:versioncmp).with('1.2', '1.3').returns(-1)
+    expect(Puppet::Util::Package).to receive(:versioncmp).with('1.2', '1.3').and_return(-1)
 
     expect(versioncmp('1.2', '1.3')).to eq(-1)
   end

data/spec/unit/functions4_spec.rb

@@ -463,7 +463,7 @@ describe 'the 4x function api' do
         # evaluate a puppet call
         source = "testing::test(10) |$x| { $x+1 }"
         program = parser.parse_string(source, __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns(the_loader)
+        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(the_loader)
         expect(parser.evaluate(scope, program)).to eql(11)
       end
     end
@@ -529,7 +529,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
         expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error,
           /value returned from function 'test' has wrong type, expects a String value, got Integer/)
       end
@@ -551,7 +551,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
         expect(parser.evaluate({}, program)).to eql(10)
       end
 
@@ -570,7 +570,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
         expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error, /parameter 'x' references an unresolved type 'MyAlias'/)
       end
 
@@ -592,7 +592,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test([10,20])', __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
         expect(parser.evaluate({}, program)).to eq([10,20])
       end
 
@@ -615,7 +615,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string("testing::test({'x' => [10,20]})", __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
         expect(parser.evaluate({}, program)).to eq({'x' => [10,20]})
       end
 
@@ -637,13 +637,12 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string("testing::test({'x' => {'y' => 'n'}})", __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
         expect(parser.evaluate({}, program)).to eq({'x' => {'y' => 'n'}})
       end
     end
   end
 
-
   def create_noargs_function_class
     Puppet::Functions.create_function('test') do
       def test()

data/spec/unit/gettext/config_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::GettextConfig do
   end
 
   before(:each) do
-    Puppet::GettextConfig.stubs(:gettext_loaded?).returns true
+    allow(Puppet::GettextConfig).to receive(:gettext_loaded?).and_return(true)
   end
 
   after(:each) do
@@ -29,7 +29,7 @@ describe Puppet::GettextConfig do
 
   describe 'setting and getting the locale' do
     it 'should return "en" when gettext is unavailable' do
-      Puppet::GettextConfig.stubs(:gettext_loaded?).returns(false)
+      allow(Puppet::GettextConfig).to receive(:gettext_loaded?).and_return(false)
 
       expect(Puppet::GettextConfig.current_locale).to eq('en')
     end
@@ -67,7 +67,7 @@ describe Puppet::GettextConfig do
 
     context 'when given a valid locale file location' do
       it 'should return true' do
-        Puppet::GettextConfig.expects(:add_repository_to_domain).with('puppet', local_path, :po, anything)
+        expect(Puppet::GettextConfig).to receive(:add_repository_to_domain).with('puppet', local_path, :po, anything)
 
         expect(Puppet::GettextConfig.load_translations('puppet', local_path, :po)).to be true
       end
@@ -88,7 +88,7 @@ describe Puppet::GettextConfig do
     end
 
     it 'should add puppet translations to the default text domain' do
-      Puppet::GettextConfig.expects(:load_translations).with('puppet', local_path, :po, Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN).returns(true)
+      expect(Puppet::GettextConfig).to receive(:load_translations).with('puppet', local_path, :po, Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN).and_return(true)
 
       Puppet::GettextConfig.create_default_text_domain
       expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN)