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

data/spec/unit/parser/scope_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/scope'
@@ -71,8 +70,8 @@ describe Puppet::Parser::Scope do
   end
 
   it "should be able to retrieve class scopes by object" do
-    klass = mock 'ast_class'
-    klass.expects(:name).returns("myname")
+    klass = double('ast_class')
+    expect(klass).to receive(:name).and_return("myname")
     @scope.class_set "myname", "myscope"
     expect(@scope.class_scope(klass)).to eq("myscope")
   end
@@ -93,7 +92,7 @@ describe Puppet::Parser::Scope do
 
   it "should get its environment from its compiler" do
     env = Puppet::Node::Environment.create(:testing, [])
-    compiler = stub 'compiler', :environment => env, :is_a? => true
+    compiler = double('compiler', :environment => env, :is_a? => true)
     scope = Puppet::Parser::Scope.new(compiler)
     expect(scope.environment).to equal(env)
   end
@@ -146,7 +145,7 @@ describe Puppet::Parser::Scope do
     it "should extend itself with its environment's Functions module as well as the default" do
       env = Puppet::Node::Environment.create(:myenv, [])
       root = Puppet.lookup(:root_environment)
-      compiler = stub 'compiler', :environment => env, :is_a? => true
+      compiler = double('compiler', :environment => env, :is_a? => true)
 
       scope = Puppet::Parser::Scope.new(compiler)
       expect(scope.singleton_class.ancestors).to be_include(Puppet::Parser::Functions.environment_module(env))
@@ -224,22 +223,22 @@ describe Puppet::Parser::Scope do
     end
 
     it "warns and return nil for non found unqualified variable" do
-      Puppet.expects(:warn_once)
+      expect(Puppet).to receive(:warn_once)
       expect(@scope["santa_clause"]).to be_nil
     end
 
     it "warns once for a non found variable" do
-      Puppet.expects(:send_log).with(:warning, is_a(String)).once
+      expect(Puppet).to receive(:send_log).with(:warning, be_a(String)).once
       expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
     end
 
     it "warns and return nil for non found qualified variable" do
-      Puppet.expects(:warn_once)
+      expect(Puppet).to receive(:warn_once)
       expect(@scope["north_pole::santa_clause"]).to be_nil
     end
 
     it "does not warn when a numeric variable is missing - they always exist" do
-      Puppet.expects(:warn_once).never
+      expect(Puppet).not_to receive(:warn_once)
       expect(@scope["1"]).to be_nil
     end
 
@@ -261,13 +260,13 @@ describe Puppet::Parser::Scope do
         catalog = Puppet::Resource::Catalog.new
         catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => Puppet::Parser::Scope.new(@compiler)))
 
-        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source'), :catalog => catalog).evaluate
+        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => double('source'), :catalog => catalog).evaluate
 
         @scope.class_scope(klass)
       end
 
       it "should be able to look up explicitly fully qualified variables from compiler's top scope" do
-        Puppet.expects(:deprecation_warning).never
+        expect(Puppet).not_to receive(:deprecation_warning)
         other_scope = @scope.compiler.topscope
 
         other_scope["othervar"] = "otherval"
@@ -276,7 +275,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up explicitly fully qualified variables from other scopes" do
-        Puppet.expects(:deprecation_warning).never
+        expect(Puppet).not_to receive(:deprecation_warning)
         other_scope = create_class_scope("other")
 
         other_scope["var"] = "otherval"
@@ -285,7 +284,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up deeply qualified variables" do
-        Puppet.expects(:deprecation_warning).never
+        expect(Puppet).not_to receive(:deprecation_warning)
         other_scope = create_class_scope("other::deep::klass")
 
         other_scope["var"] = "otherval"
@@ -301,12 +300,12 @@ describe Puppet::Parser::Scope do
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         newclass("other::deep::klass")
-        Puppet.expects(:warn_once)
+        expect(Puppet).to receive(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
-        Puppet.expects(:warn_once)
+        expect(Puppet).to receive(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
@@ -315,7 +314,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that has not been evaluated" do
-        @scope.stubs(:warning)
+        allow(@scope).to receive(:warning)
         newclass("other::deep::klass")
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
@@ -537,10 +536,10 @@ describe Puppet::Parser::Scope do
 
   describe "when setting ephemeral vars from matches" do
     before :each do
-      @match = stub 'match', :is_a? => true
-      @match.stubs(:[]).with(0).returns("this is a string")
-      @match.stubs(:captures).returns([])
-      @scope.stubs(:setvar)
+      @match = double('match', :is_a? => true)
+      allow(@match).to receive(:[]).with(0).and_return("this is a string")
+      allow(@match).to receive(:captures).and_return([])
+      allow(@scope).to receive(:setvar)
     end
 
     it "should accept only MatchData" do
@@ -551,27 +550,32 @@ describe Puppet::Parser::Scope do
 
     it "should set $0 with the full match" do
       # This is an internal impl detail test
-      @scope.expects(:new_match_scope).with { |*arg| arg[0][0] == "this is a string" }
+      expect(@scope).to receive(:new_match_scope) do |arg|
+        expect(arg[0]).to eq("this is a string")
+      end
       @scope.ephemeral_from(@match)
     end
 
     it "should set every capture as ephemeral var" do
       # This is an internal impl detail test
-      @match.stubs(:[]).with(1).returns(:capture1)
-      @match.stubs(:[]).with(2).returns(:capture2)
-      @scope.expects(:new_match_scope).with { |*arg| arg[0][1] == :capture1 && arg[0][2] == :capture2 }
+      allow(@match).to receive(:[]).with(1).and_return(:capture1)
+      allow(@match).to receive(:[]).with(2).and_return(:capture2)
+      expect(@scope).to receive(:new_match_scope) do |arg|
+        expect(arg[1]).to eq(:capture1)
+        expect(arg[2]).to eq(:capture2)
+      end
 
       @scope.ephemeral_from(@match)
     end
 
     it "should shadow previous match variables" do
       # This is an internal impl detail test
-      @match.stubs(:[]).with(1).returns(:capture1)
-      @match.stubs(:[]).with(2).returns(:capture2)
+      allow(@match).to receive(:[]).with(1).and_return(:capture1)
+      allow(@match).to receive(:[]).with(2).and_return(:capture2)
 
-      @match2 = stub 'match', :is_a? => true
-      @match2.stubs(:[]).with(1).returns(:capture2_1)
-      @match2.stubs(:[]).with(2).returns(nil)
+      @match2 = double('match', :is_a? => true)
+      allow(@match2).to receive(:[]).with(1).and_return(:capture2_1)
+      allow(@match2).to receive(:[]).with(2).and_return(nil)
       @scope.ephemeral_from(@match)
       @scope.ephemeral_from(@match2)
       expect(@scope.lookupvar('2')).to eq(nil)
@@ -586,13 +590,13 @@ describe Puppet::Parser::Scope do
 
   describe "when managing defaults" do
     it "should be able to set and lookup defaults" do
-      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
       @scope.define_settings(:mytype, param)
       expect(@scope.lookupdefaults(:mytype)).to eq({:myparam => param})
     end
 
     it "should fail if a default is already defined and a new default is being defined" do
-      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
       @scope.define_settings(:mytype, param)
       expect {
         @scope.define_settings(:mytype, param)
@@ -600,20 +604,20 @@ describe Puppet::Parser::Scope do
     end
 
     it "should return multiple defaults at once" do
-      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
       @scope.define_settings(:mytype, param1)
-      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
+      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => double("source"))
       @scope.define_settings(:mytype, param2)
 
       expect(@scope.lookupdefaults(:mytype)).to eq({:myparam => param1, :other => param2})
     end
 
     it "should look up defaults defined in parent scopes" do
-      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
+      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
       @scope.define_settings(:mytype, param1)
 
       child_scope = @scope.newscope
-      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
+      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => double("source"))
       child_scope.define_settings(:mytype, param2)
 
       expect(child_scope.lookupdefaults(:mytype)).to eq({:myparam => param1, :other => param2})

data/spec/unit/parser/templatewrapper_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/parser/templatewrapper'
 
@@ -6,20 +5,20 @@ describe Puppet::Parser::TemplateWrapper do
   let(:known_resource_types) { Puppet::Resource::TypeCollection.new("env") }
   let(:scope) do
     compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-    compiler.environment.stubs(:known_resource_types).returns known_resource_types
+    allow(compiler.environment).to receive(:known_resource_types).and_return(known_resource_types)
     Puppet::Parser::Scope.new compiler
   end
 
   let(:tw) { Puppet::Parser::TemplateWrapper.new(scope) }
 
   it "fails if a template cannot be found" do
-    Puppet::Parser::Files.expects(:find_template).returns nil
+    expect(Puppet::Parser::Files).to receive(:find_template).and_return(nil)
 
     expect { tw.file = "fake_template" }.to raise_error(Puppet::ParseError)
   end
 
   it "stringifies as template[<filename>] for a file based template" do
-    Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
+    allow(Puppet::Parser::Files).to receive(:find_template).and_return("/tmp/fake_template")
     tw.file = "fake_template"
     expect(tw.to_s).to eql("template[/tmp/fake_template]")
   end
@@ -47,19 +46,19 @@ describe Puppet::Parser::TemplateWrapper do
   end
 
   it "provides the defined classes with #classes" do
-    catalog = mock 'catalog', :classes => ["class1", "class2"]
-    scope.expects(:catalog).returns( catalog )
+    catalog = double('catalog', :classes => ["class1", "class2"])
+    expect(scope).to receive(:catalog).and_return(catalog)
     expect(tw.classes).to eq(["class1", "class2"])
   end
 
   it "provides all the tags with #all_tags" do
-    catalog = mock 'catalog', :tags => ["tag1", "tag2"]
-    scope.expects(:catalog).returns( catalog )
+    catalog = double('catalog', :tags => ["tag1", "tag2"])
+    expect(scope).to receive(:catalog).and_return(catalog)
     expect(tw.all_tags).to eq(["tag1","tag2"])
   end
 
   it "provides the tags defined in the current scope with #tags" do
-    scope.expects(:tags).returns( ["tag1", "tag2"] )
+    expect(scope).to receive(:tags).and_return(["tag1", "tag2"])
     expect(tw.tags).to eq(["tag1","tag2"])
   end
 
@@ -91,10 +90,10 @@ describe Puppet::Parser::TemplateWrapper do
 
   def given_a_template_file(name, contents)
     full_name = "/full/path/to/#{name}"
-    Puppet::Parser::Files.stubs(:find_template).
+    allow(Puppet::Parser::Files).to receive(:find_template).
       with(name, anything()).
-      returns(full_name)
-    Puppet::FileSystem.stubs(:read_preserve_line_endings).with(full_name).returns(contents)
+      and_return(full_name)
+    allow(Puppet::FileSystem).to receive(:read_preserve_line_endings).with(full_name).and_return(contents)
 
     full_name
   end

data/spec/unit/parser/type_loader_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parser/type_loader'
@@ -37,15 +36,14 @@ describe Puppet::Parser::TypeLoader do
     end
 
     it "should attempt to import each generated name" do
-      loader.expects(:import_from_modules).with("foo/bar").returns([])
-      loader.expects(:import_from_modules).with("foo").returns([])
+      expect(loader).to receive(:import_from_modules).with("foo/bar").and_return([])
+      expect(loader).to receive(:import_from_modules).with("foo").and_return([])
       loader.try_load_fqname(:hostclass, "foo::bar")
     end
 
     it "should attempt to load each possible name going from most to least specific" do
-      path_order = sequence('path')
       ['foo/bar/baz', 'foo/bar', 'foo'].each do |path|
-        Puppet::Parser::Files.expects(:find_manifests_in_modules).with(path, anything).returns([nil, []]).in_sequence(path_order)
+        expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with(path, anything).and_return([nil, []]).ordered
       end
 
       loader.try_load_fqname(:hostclass, 'foo::bar::baz')
@@ -53,37 +51,37 @@ describe Puppet::Parser::TypeLoader do
   end
 
   describe "when importing" do
-    let(:stub_parser) { stub 'Parser', :file= => nil, :parse => empty_hostclass }
+    let(:stub_parser) { double('Parser', :file= => nil, :parse => empty_hostclass) }
 
     before(:each) do
-      Puppet::Parser::ParserFactory.stubs(:parser).with(anything).returns(stub_parser)
+      allow(Puppet::Parser::ParserFactory).to receive(:parser).and_return(stub_parser)
     end
 
     it "should find all manifests matching the file or pattern" do
-      Puppet::Parser::Files.expects(:find_manifests_in_modules).with("myfile", anything).returns ["modname", %w{one}]
+      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with("myfile", anything).and_return(["modname", %w{one}])
       loader.import("myfile", "/path")
     end
 
     it "should pass the environment when looking for files" do
-      Puppet::Parser::Files.expects(:find_manifests_in_modules).with(anything, loader.environment).returns ["modname", %w{one}]
+      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with(anything, loader.environment).and_return(["modname", %w{one}])
       loader.import("myfile", "/path")
     end
 
     it "should fail if no files are found" do
-      Puppet::Parser::Files.expects(:find_manifests_in_modules).returns [nil, []]
+      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).and_return([nil, []])
       expect { loader.import("myfile", "/path") }.to raise_error(/No file\(s\) found for import/)
     end
 
     it "should parse each found file" do
-      Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", [make_absolute("/one")]]
-      loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
+      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).and_return(["modname", [make_absolute("/one")]])
+      expect(loader).to receive(:parse_file).with(make_absolute("/one")).and_return(Puppet::Parser::AST::Hostclass.new(''))
       loader.import("myfile", "/path")
     end
 
     it "should not attempt to import files that have already been imported" do
       loader = Puppet::Parser::TypeLoader.new(:myenv)
 
-      Puppet::Parser::Files.expects(:find_manifests_in_modules).twice.returns ["modname", %w{/one}]
+      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).twice.and_return(["modname", %w{/one}])
       expect(loader.import("myfile", "/path")).not_to be_empty
 
       expect(loader.import("myfile", "/path")).to be_empty
@@ -175,20 +173,20 @@ describe Puppet::Parser::TypeLoader do
 
   describe "when parsing a file" do
     it "requests a new parser instance for each file" do
-      parser = stub 'Parser', :file= => nil, :parse => empty_hostclass
+      parser = double('Parser', :file= => nil, :parse => empty_hostclass)
 
-      Puppet::Parser::ParserFactory.expects(:parser).twice.returns(parser)
+      expect(Puppet::Parser::ParserFactory).to receive(:parser).twice.and_return(parser)
 
       loader.parse_file("/my/file")
       loader.parse_file("/my/other_file")
     end
 
     it "assigns the parser its file and then parses" do
-      parser = mock 'parser'
+      parser = double('parser')
 
-      Puppet::Parser::ParserFactory.expects(:parser).returns(parser)
-      parser.expects(:file=).with("/my/file")
-      parser.expects(:parse).returns(empty_hostclass)
+      expect(Puppet::Parser::ParserFactory).to receive(:parser).and_return(parser)
+      expect(parser).to receive(:file=).with("/my/file")
+      expect(parser).to receive(:parse).and_return(empty_hostclass)
 
       loader.parse_file("/my/file")
     end

data/spec/unit/pops/adaptable_spec.rb

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

data/spec/unit/pops/benchmark_spec.rb

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

data/spec/unit/pops/evaluator/access_ops_spec.rb

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

data/spec/unit/pops/evaluator/arithmetic_ops_spec.rb

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

data/spec/unit/pops/evaluator/basic_expressions_spec.rb

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

data/spec/unit/pops/evaluator/collections_ops_spec.rb

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

data/spec/unit/pops/evaluator/comparison_ops_spec.rb

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

data/spec/unit/pops/evaluator/conditionals_spec.rb

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

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -1415,14 +1415,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for non r-value producing define' do
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => "Invalid use of expression. A 'define' expression does not produce a value", :line => 1, :pos => 6))
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => "Invalid use of expression. A 'define' expression does not produce a value", :line => 1, :pos => 6))
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Host Class Definition does not produce a value', :line => 1, :pos => 6))
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Invalid use of expression. A Host Class Definition does not produce a value', :line => 1, :pos => 6))
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
       expect { parser.parse_string("$a = class foo { }", nil) }.to raise_error(/2 errors/)
     end
 
@@ -1436,8 +1436,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for multiple errors with a summary exception' do
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Node Definition does not produce a value', :line => 1, :pos => 6))
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Invalid use of expression. A Node Definition does not produce a value', :line => 1, :pos => 6))
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
       expect { parser.parse_string("$a = node x { }",nil) }.to raise_error(/2 errors/)
     end