puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/parser/functions/tag_spec.rb

@@ -1,10 +1,7 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "the 'tag' function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
@@ -17,7 +14,7 @@ describe "the 'tag' function" do
 
   it "should tag the resource with any provided tags" do
     resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
-    expect(@scope).to receive(:resource).and_return(resource)
+    @scope.expects(:resource).returns resource
 
     @scope.function_tag ["one", "two"]
 

data/spec/unit/parser/functions/tagged_spec.rb

@@ -1,10 +1,7 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "the 'tagged' function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
@@ -24,7 +21,7 @@ describe "the 'tagged' function" do
 
   it 'should be case-insensitive' do
     resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
-    allow(@scope).to receive(:resource).and_return(resource)
+    @scope.stubs(:resource).returns resource
     @scope.function_tag ["one"]
 
     expect(@scope.function_tagged(['One'])).to eq(true)
@@ -32,7 +29,7 @@ describe "the 'tagged' function" do
 
   it 'should check if all specified tags are included' do
     resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
-    allow(@scope).to receive(:resource).and_return(resource)
+    @scope.stubs(:resource).returns resource
     @scope.function_tag ["one"]
 
     expect(@scope.function_tagged(['one', 'two'])).to eq(false)

data/spec/unit/parser/functions/template_spec.rb

@@ -1,31 +1,27 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "the template function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end
 
   it "concatenates outputs for multiple templates" do
-    tw1 = double("template_wrapper1")
-    tw2 = double("template_wrapper2")
-    allow(Puppet::Parser::TemplateWrapper).to receive(:new).and_return(tw1,tw2)
-    allow(tw1).to receive(:file=).with("1")
-    allow(tw2).to receive(:file=).with("2")
-    allow(tw1).to receive(:result).and_return("result1")
-    allow(tw2).to receive(:result).and_return("result2")
+    tw1 = stub_everything "template_wrapper1"
+    tw2 = stub_everything "template_wrapper2"
+    Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw1,tw2)
+    tw1.stubs(:file=).with("1")
+    tw2.stubs(:file=).with("2")
+    tw1.stubs(:result).returns("result1")
+    tw2.stubs(:result).returns("result2")
 
     expect(scope.function_template(["1","2"])).to eq("result1result2")
   end
 
   it "raises an error if the template raises an error" do
-    tw = double('template_wrapper')
-    allow(tw).to receive(:file=).with("1")
-    allow(Puppet::Parser::TemplateWrapper).to receive(:new).and_return(tw)
-    allow(tw).to receive(:result).and_raise
+    tw = stub_everything 'template_wrapper'
+    Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
+    tw.stubs(:result).raises
 
     expect {
       scope.function_template(["1"])
@@ -90,8 +86,8 @@ describe "the template function" do
   end
 
   def eval_template(content)
-    allow(Puppet::FileSystem).to receive(:read_preserve_line_endings).with("template").and_return(content)
-    allow(Puppet::Parser::Files).to receive(:find_template).and_return("template")
+    Puppet::FileSystem.stubs(:read_preserve_line_endings).with("template").returns(content)
+    Puppet::Parser::Files.stubs(:find_template).returns("template")
     scope.function_template(['template'])
   end
 end

data/spec/unit/parser/functions/versioncmp_spec.rb

@@ -1,10 +1,7 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "the versioncmp function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
@@ -24,7 +21,7 @@ describe "the versioncmp function" do
   end
 
   it "should call Puppet::Util::Package.versioncmp (included in scope)" do
-    expect(Puppet::Util::Package).to receive(:versioncmp).with("1.2", "1.3").and_return(-1)
+    Puppet::Util::Package.expects(:versioncmp).with("1.2", "1.3").returns(-1)
 
     @scope.function_versioncmp(["1.2", "1.3"])
   end

data/spec/unit/parser/functions_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Parser::Functions do
@@ -26,7 +27,7 @@ describe Puppet::Parser::Functions do
 
     it "should warn if the function already exists" do
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
-      expect(Puppet).to receive(:warning)
+      Puppet.expects(:warning)
 
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
     end
@@ -47,8 +48,33 @@ describe Puppet::Parser::Functions do
   end
 
   describe "when calling function to test function existence" do
+    before :each do
+      Puppet[:strict] = :error
+    end
+
+    it "emits a deprecation warning when loading all 3.x functions" do
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:loadall)
+      Puppet::Parser::Functions.autoloader.loadall
+
+      expect(@logs.map(&:to_s)).to include(/The method 'Puppet::Parser::Functions.autoloader#loadall' is deprecated in favor of using 'Scope#call_function/)
+    end
+
+    it "emits a deprecation warning when loading a single 3.x function" do
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:load)
+      Puppet::Parser::Functions.autoloader.load('beatles')
+
+      expect(@logs.map(&:to_s)).to include(/The method 'Puppet::Parser::Functions.autoloader#load\("beatles"\)' is deprecated in favor of using 'Scope#call_function'/)
+    end
+
+    it "emits a deprecation warning when checking if a 3x function is loaded" do
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:loaded?).returns(false)
+      Puppet::Parser::Functions.autoloader.loaded?('beatles')
+
+      expect(@logs.map(&:to_s)).to include(/The method 'Puppet::Parser::Functions.autoloader#loaded\?\(\"beatles\"\)' is deprecated in favor of using 'Scope#call_function'/)
+    end
+
     it "should return false if the function doesn't exist" do
-      allow(Puppet::Parser::Functions.autoloader).to receive(:load)
+      Puppet::Parser::Functions.autoloader.delegatee.stubs(:load)
 
       expect(Puppet::Parser::Functions.function("name")).to be_falsey
     end
@@ -60,7 +86,7 @@ describe Puppet::Parser::Functions do
     end
 
     it "should try to autoload the function if it doesn't exist yet" do
-      expect(Puppet::Parser::Functions.autoloader).to receive(:load)
+      Puppet::Parser::Functions.autoloader.delegatee.expects(:load)
 
       Puppet::Parser::Functions.function("name")
     end

data/spec/unit/parser/relationship_spec.rb

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

data/spec/unit/parser/resource/param_spec.rb

@@ -14,7 +14,7 @@ describe Puppet::Parser::Resource::Param do
     it "throws an error when instantiated without a name" do
       expect {
         Puppet::Parser::Resource::Param.new(:value => 'foo')
-      }.to raise_error(Puppet::Error, /name is a required option/)
+      }.to raise_error(Puppet::Error, /'name' is a required option/)
     end
 
     it "does not require a value" do

data/spec/unit/parser/resource_spec.rb

@@ -49,24 +49,24 @@ describe Puppet::Parser::Resource do
   end
 
   it "should get its environment from its scope" do
-    scope = double('scope', :source => double("source"))
-    expect(scope).to receive(:environment).and_return("foo").at_least(:once)
-    expect(scope).to receive(:lookupdefaults).and_return({})
+    scope = stub 'scope', :source => stub("source")
+    scope.expects(:environment).returns("foo").at_least_once
+    scope.expects(:lookupdefaults).returns({})
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
   it "should use the scope's environment as its environment" do
-    expect(@scope).to receive(:environment).and_return("myenv").at_least(:once)
+    @scope.expects(:environment).returns("myenv").at_least_once
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment).to eq("myenv")
   end
 
   it "should be isomorphic if it is builtin and models an isomorphic type" do
-    expect(Puppet::Type.type(:file)).to receive(:isomorphic?).and_return(true)
+    Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
     @resource = expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?).to be_truthy
   end
 
   it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
-    expect(Puppet::Type.type(:file)).to receive(:isomorphic?).and_return(false)
+    Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
     @resource = expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?).to be_falsey
   end
 
@@ -81,9 +81,9 @@ describe Puppet::Parser::Resource do
   end
 
   it "should use a Puppet::Resource for converting to a ral resource" do
-    trans = double('resource', :to_ral => "yay")
+    trans = mock 'resource', :to_ral => "yay"
     @resource = mkresource
-    expect(@resource).to receive(:copy_as_resource).and_return(trans)
+    @resource.expects(:copy_as_resource).returns trans
     expect(@resource.to_ral).to eq("yay")
   end
 
@@ -125,8 +125,8 @@ describe Puppet::Parser::Resource do
   describe "when evaluating" do
     before do
       @catalog = Puppet::Resource::Catalog.new
-      source = double('source')
-      allow(source).to receive(:module_name)
+      source = stub('source')
+      source.stubs(:module_name)
       @scope = Puppet::Parser::Scope.new(@compiler, :source => source)
       @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @scope))
     end
@@ -134,7 +134,7 @@ describe Puppet::Parser::Resource do
     it "should evaluate the associated AST definition" do
       definition = newdefine "mydefine"
       res = Puppet::Parser::Resource.new("mydefine", "whatever", :scope => @scope, :source => @source, :catalog => @catalog)
-      expect(definition).to receive(:evaluate_code).with(res)
+      definition.expects(:evaluate_code).with(res)
 
       res.evaluate
     end
@@ -142,14 +142,14 @@ describe Puppet::Parser::Resource do
     it "should evaluate the associated AST class" do
       @class = newclass "myclass"
       res = Puppet::Parser::Resource.new("class", "myclass", :scope => @scope, :source => @source, :catalog => @catalog)
-      expect(@class).to receive(:evaluate_code).with(res)
+      @class.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
     it "should evaluate the associated AST node" do
       nodedef = newnode("mynode")
       res = Puppet::Parser::Resource.new("node", "mynode", :scope => @scope, :source => @source, :catalog => @catalog)
-      expect(nodedef).to receive(:evaluate_code).with(res)
+      nodedef.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
@@ -314,19 +314,19 @@ describe Puppet::Parser::Resource do
     let(:resource) { Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source) }
 
     it 'should add all defaults available from the scope' do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => param(:owner, 'default', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'default', @source))
 
       expect(resource[:owner]).to eq('default')
     end
 
     it 'should not replace existing parameters with defaults' do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => param(:owner, 'replaced', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
       r = Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source, :parameters => [ param(:owner, 'oldvalue', @source) ])
       expect(r[:owner]).to eq('oldvalue')
     end
 
     it 'should override defaults with new parameters' do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => param(:owner, 'replaced', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
 
       resource.set_parameter(:owner, 'newvalue')
       expect(resource[:owner]).to eq('newvalue')
@@ -336,14 +336,14 @@ describe Puppet::Parser::Resource do
       newparam = param(:owner, 'default', @source)
       other = newparam.dup
       other.value = "other"
-      expect(newparam).to receive(:dup).and_return(other)
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => newparam)
+      newparam.expects(:dup).returns(other)
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => newparam)
 
       expect(resource[:owner]).to eq('other')
     end
 
     it "should tag with value of default parameter named 'tag'" do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:tag => param(:tag, 'the_tag', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:tag => param(:tag, 'the_tag', @source))
 
       expect(resource.tags).to include('the_tag')
     end
@@ -356,7 +356,7 @@ describe Puppet::Parser::Resource do
 
     it "should do nothing if it has already been finished" do
       @resource.finish
-      expect(@resource).not_to receive(:add_scope_tags)
+      @resource.expects(:add_scope_tags).never
       @resource.finish
     end
 
@@ -370,9 +370,9 @@ describe Puppet::Parser::Resource do
 
   describe "when being tagged" do
     before do
-      @scope_resource = double('scope_resource', :tags => %w{srone srtwo})
-      allow(@scope).to receive(:resource).and_return(@scope_resource)
-      @resource = Puppet::Parser::Resource.new("file", "yay", :scope => @scope, :source => double('source'))
+      @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
+      @scope.stubs(:resource).returns @scope_resource
+      @resource = Puppet::Parser::Resource.new("file", "yay", :scope => @scope, :source => mock('source'))
     end
 
     it "should get tagged with the resource type" do
@@ -384,19 +384,19 @@ describe Puppet::Parser::Resource do
     end
 
     it "should get tagged with each name in the title if the title is a qualified class name" do
-      resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => double('source'))
+      resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => mock('source'))
       expect(resource.tags).to be_include("one")
       expect(resource.tags).to be_include("two")
     end
 
     it "should get tagged with each name in the type if the type is a qualified class name" do
-      resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => double('source'))
+      resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => mock('source'))
       expect(resource.tags).to be_include("one")
       expect(resource.tags).to be_include("two")
     end
 
     it "should not get tagged with non-alphanumeric titles" do
-      resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => double('source'))
+      resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => mock('source'))
       expect(resource.tags).not_to be_include("this is a test")
     end
 
@@ -426,34 +426,34 @@ describe Puppet::Parser::Resource do
 
     it "should fail when the override was not created by a parent class" do
       @override.source = "source2"
-      expect(@override.source).to receive(:child_of?).with("source1").and_return(false)
+      @override.source.expects(:child_of?).with("source1").returns(false)
       expect { @resource.merge(@override) }.to raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
       @resource.source = "source3"
       @override.source = @resource.source
-      expect(@override.source).not_to receive(:child_of?).with("source3")
+      @override.source.expects(:child_of?).with("source3").never
       params = {:a => :b, :c => :d}
-      expect(@override).to receive(:parameters).and_return(params)
-      expect(@resource).to receive(:override_parameter).with(:b)
-      expect(@resource).to receive(:override_parameter).with(:d)
+      @override.expects(:parameters).returns(params)
+      @resource.expects(:override_parameter).with(:b)
+      @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should succeed when a parent class created the override" do
       @resource.source = "source3"
       @override.source = "source4"
-      expect(@override.source).to receive(:child_of?).with("source3").and_return(true)
+      @override.source.expects(:child_of?).with("source3").returns(true)
       params = {:a => :b, :c => :d}
-      expect(@override).to receive(:parameters).and_return(params)
-      expect(@resource).to receive(:override_parameter).with(:b)
-      expect(@resource).to receive(:override_parameter).with(:d)
+      @override.expects(:parameters).returns(params)
+      @resource.expects(:override_parameter).with(:b)
+      @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should add new parameters when the parameter is not set" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       @override.set_parameter(:testing, "value")
       @resource.merge(@override)
 
@@ -461,7 +461,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should replace existing parameter values" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       @resource.set_parameter(:testing, "old")
       @override.set_parameter(:testing, "value")
 
@@ -471,7 +471,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should add values to the parameter when the override was created with the '+>' syntax" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "testing", :source => @resource.source)
       param.add = true
 
@@ -490,7 +490,7 @@ describe Puppet::Parser::Resource do
       @resource.  set_parameter(:testing, "old_val_1")
       @resource_2.set_parameter(:testing, "old_val_2")
 
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "new_val", :source => @resource.source)
       param.add = true
       @override.set_parameter(param)
@@ -503,7 +503,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should promote tag overrides to real tags" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :tag, :value => "testing", :source => @resource.source)
 
       @override.set_parameter(param)
@@ -516,7 +516,7 @@ describe Puppet::Parser::Resource do
   end
 
   it "should be able to be converted to a normal resource" do
-    @source = double('scope', :name => "myscope")
+    @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
     expect(@resource).to respond_to(:copy_as_resource)
   end
@@ -634,7 +634,7 @@ describe Puppet::Parser::Resource do
 
   # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
   it "should not include 'undef' parameters when converting itself to a hash" do
-    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => double("source"), :scope => @scope
+    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => @scope
     resource[:owner] = :undef
     resource[:mode] = "755"
     expect(resource.to_hash[:owner]).to be_nil