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

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
@@ -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
@@ -430,8 +429,11 @@ describe Puppet::Node::Environment do
     describe "when performing initial import" do
       let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
+      before(:each) do
+        allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
+      end
+
       around :each do |example|
-        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
         Puppet.override(:loaders => loaders, :current_environment => env) do
           example.run
           Puppet::Pops::Loaders.clear
@@ -494,9 +496,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
@@ -504,7 +506,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
 

data/spec/unit/node/facts_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/node/facts'
 require 'matchers/json'
@@ -85,14 +83,14 @@ describe Puppet::Node::Facts, "when indirecting" do
 
   describe "when indirecting" do
     before do
-      @indirection = stub 'indirection', :request => mock('request'), :name => :facts
+      @indirection = double('indirection', :request => double('request'), :name => :facts)
 
       @facts = Puppet::Node::Facts.new("me", "one" => "two")
     end
 
     it "should redirect to the specified fact store for storage" do
-      Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
-      @indirection.expects(:save)
+      allow(Puppet::Node::Facts).to receive(:indirection).and_return(@indirection)
+      expect(@indirection).to receive(:save)
       Puppet::Node::Facts.indirection.save(@facts)
     end
 
@@ -177,7 +175,7 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       it "should generate properly formatted json" do
-        Time.stubs(:now).returns(@timestamp)
+        allow(Time).to receive(:now).and_return(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
         result = JSON.parse(facts.to_json)
@@ -188,7 +186,7 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       it "should generate valid facts data against the facts schema" do
-        Time.stubs(:now).returns(@timestamp)
+        allow(Time).to receive(:now).and_return(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
 

data/spec/unit/node_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet_spec/files'
@@ -11,7 +10,6 @@ describe Puppet::Node do
   let(:env_loader) { Puppet::Environments::Static.new(environment) }
 
   describe "when managing its environment" do
-
     it "provides an environment instance" do
       expect(Puppet::Node.new("foo", :environment => environment).environment.name).to eq(:bar)
     end
@@ -132,7 +130,6 @@ describe Puppet::Node do
     it "errors if name is nil" do
       expect { Puppet::Node.from_data_hash({ })}.to raise_error(ArgumentError, /No name provided in serialized data/)
     end
-
   end
 
   describe "when converting to json" do
@@ -271,18 +268,18 @@ describe Puppet::Node, "when merging facts" do
     let(:facts) { Puppet::Node::Facts.new(@node.name, "foo" => "bar") }
 
     it "accepts facts to merge with the node" do
-      @node.expects(:merge).with({ 'foo' => 'bar' })
+      expect(@node).to receive(:merge).with({ 'foo' => 'bar' })
       @node.fact_merge(facts)
     end
 
     it "will not query the facts indirection if facts are supplied" do
-      Puppet::Node::Facts.indirection.expects(:find).never
+      expect(Puppet::Node::Facts.indirection).not_to receive(:find)
       @node.fact_merge(facts)
     end
   end
 
   it "recovers with a Puppet::Error if something is thrown from the facts indirection" do
-    Puppet::Node::Facts.indirection.expects(:find).raises "something bad happened in the indirector"
+    expect(Puppet::Node::Facts.indirection).to receive(:find).and_raise("something bad happened in the indirector")
     expect { @node.fact_merge }.to raise_error(Puppet::Error, /Could not retrieve facts for testnode: something bad happened in the indirector/)
   end
 
@@ -300,7 +297,7 @@ describe Puppet::Node, "when merging facts" do
 
   it "warns when a parameter value is not updated" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
-    Puppet.expects(:warning).with('The node parameter \'one\' for node \'testnode\' was already set to \'a\'. It could not be set to \'b\'')
+    expect(Puppet).to receive(:warning).with('The node parameter \'one\' for node \'testnode\' was already set to \'a\'. It could not be set to \'b\'')
     @node.merge "one" => "b"
   end
 
@@ -374,9 +371,7 @@ describe Puppet::Node, "when merging facts" do
     end
 
     context "when a node is initialized from new" do
-
       context "when a node is initialzed with an environment" do
-
         it "adds the environment to the list of parameters" do
           Puppet[:environment] = "one"
           @node = Puppet::Node.new("testnode", :environment => "one")
@@ -398,7 +393,6 @@ describe Puppet::Node, "when merging facts" do
       end
 
       context "when a node is initialized without an environment" do
-
         it "it perfers an environment name to an environment fact" do
           @node = Puppet::Node.new("testnode")
           @node.environment_name = "one"

data/spec/unit/other/selinux_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/type/selboolean'
@@ -33,7 +32,7 @@ end
 describe Puppet::Type.type(:selboolean), " when manipulating booleans" do
   before :each do
     provider_class = Puppet::Type::Selboolean.provider(Puppet::Type::Selboolean.providers[0])
-    Puppet::Type::Selboolean.stubs(:defaultprovider).returns provider_class
+    allow(Puppet::Type::Selboolean).to receive(:defaultprovider).and_return(provider_class)
 
     @bool = Puppet::Type::Selboolean.new(
       :name => "foo",
@@ -67,7 +66,7 @@ end
 describe Puppet::Type.type(:selmodule), " when checking policy modules" do
   before :each do
     provider_class = Puppet::Type::Selmodule.provider(Puppet::Type::Selmodule.providers[0])
-    Puppet::Type::Selmodule.stubs(:defaultprovider).returns provider_class
+    allow(Puppet::Type::Selmodule).to receive(:defaultprovider).and_return(provider_class)
 
     @module = Puppet::Type::Selmodule.new(
       :name => "foo",

data/spec/unit/parameter/boolean_spec.rb

@@ -1,10 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 require 'puppet/parameter/boolean'
 
 describe Puppet::Parameter::Boolean do
-  let (:resource) { mock('resource') }
+  let (:resource) { double('resource') }
   describe "after initvars" do
     before { described_class.initvars }
     it "should have the correct value_collection" do

data/spec/unit/parameter/package_options_spec.rb

@@ -1,10 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parameter/package_options'
 
 describe Puppet::Parameter::PackageOptions do
-  let (:resource) { mock('resource') }
+  let (:resource) { double('resource') }
   let (:param)    { described_class.new(:resource => resource) }
   let (:arg)      { '/S' }
   let (:key)      { 'INSTALLDIR' }

data/spec/unit/parameter/path_spec.rb

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

data/spec/unit/parameter/value_collection_spec.rb

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

data/spec/unit/parameter/value_spec.rb

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

data/spec/unit/parameter_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parameter'
@@ -9,8 +8,9 @@ describe Puppet::Parameter do
       @name = :foo
     end
     @class.initvars
-    @resource = mock 'resource'
-    @resource.stub_everything
+    @resource = double('resource')
+    allow(@resource).to receive(:expects)
+    allow(@resource).to receive(:pathbuilder)
     @parameter = @class.new :resource => @resource
   end
 
@@ -27,13 +27,13 @@ describe Puppet::Parameter do
 
   [:line, :file, :version].each do |data|
     it "should return its resource's #{data} as its #{data}" do
-      @resource.expects(data).returns "foo"
+      expect(@resource).to receive(data).and_return("foo")
       expect(@parameter.send(data)).to eq("foo")
     end
   end
 
   it "should return the resource's tags plus its name as its tags" do
-    @resource.expects(:tags).returns %w{one two}
+    expect(@resource).to receive(:tags).and_return(%w{one two})
     expect(@parameter.tags).to eq(%w{one two foo})
   end
 
@@ -47,12 +47,12 @@ describe Puppet::Parameter do
     end
 
     it "should validate the value" do
-      @parameter.expects(:validate).with("foo")
+      expect(@parameter).to receive(:validate).with("foo")
       @parameter.value = "foo"
     end
 
     it "should munge the value and use any result as the actual value" do
-      @parameter.expects(:munge).with("foo").returns "bar"
+      expect(@parameter).to receive(:munge).with("foo").and_return("bar")
       @parameter.value = "foo"
       expect(@parameter.value).to eq("bar")
     end
@@ -149,8 +149,8 @@ describe Puppet::Parameter do
 
   describe "when logging" do
     it "should use its resource's log level and the provided message" do
-      @resource.expects(:[]).with(:loglevel).returns :notice
-      @parameter.expects(:send_log).with(:notice, "mymessage")
+      expect(@resource).to receive(:[]).with(:loglevel).and_return(:notice)
+      expect(@parameter).to receive(:send_log).with(:notice, "mymessage")
       @parameter.log "mymessage"
     end
   end

data/spec/unit/parser/ast/block_expression_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/parser/ast/block_expression'
 
@@ -16,9 +15,9 @@ describe 'Puppet::Parser::AST::BlockExpression' do
     StackDepthAST.new({})
   end
 
-  def sequence_probe(name, sequence)
-    probe = mock("Sequence Probe #{name}")
-    probe.expects(:safeevaluate).in_sequence(sequence)
+  def sequence_probe(name)
+    probe = double("Sequence Probe #{name}")
+    expect(probe).to receive(:safeevaluate).ordered
     probe
   end
 
@@ -57,10 +56,9 @@ describe 'Puppet::Parser::AST::BlockExpression' do
   end
 
   it "evaluates sequenced children in order" do
-    evaluation_order = sequence("Child evaluation order")
-    expr1 = block_of([sequence_probe("Step 1", evaluation_order)])
-    expr2 = block_of([sequence_probe("Step 2", evaluation_order)])
-    expr3 = block_of([sequence_probe("Step 3", evaluation_order)])
+    expr1 = block_of([sequence_probe("Step 1")])
+    expr2 = block_of([sequence_probe("Step 2")])
+    expr3 = block_of([sequence_probe("Step 3")])
 
     expr1.sequence_with(expr2).sequence_with(expr3).evaluate(NO_SCOPE)
   end

data/spec/unit/parser/ast/leaf_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Parser::AST::Leaf do
@@ -6,14 +5,14 @@ describe Puppet::Parser::AST::Leaf do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
     @scope   = Puppet::Parser::Scope.new(compiler)
-    @value = stub 'value'
+    @value = double('value')
     @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
   end
 
   describe "when converting to string" do
     it "should transform its value to string" do
-      value = stub 'value', :is_a? => true
-      value.expects(:to_s)
+      value = double('value', :is_a? => true)
+      expect(value).to receive(:to_s)
       Puppet::Parser::AST::Leaf.new( :value => value ).to_s
     end
   end
@@ -23,7 +22,7 @@ describe Puppet::Parser::AST::Leaf do
   end
 
   it "should delegate match to ==" do
-    @value.expects(:==).with("value")
+    expect(@value).to receive(:==).with("value")
 
     @leaf.match("value")
   end
@@ -39,14 +38,14 @@ describe Puppet::Parser::AST::Regex do
 
   describe "when initializing" do
     it "should create a Regexp with its content when value is not a Regexp" do
-      Regexp.expects(:new).with("/ab/")
+      expect(Regexp).to receive(:new).with("/ab/")
 
       Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should not create a Regexp with its content when value is a Regexp" do
       value = Regexp.new("/ab/")
-      Regexp.expects(:new).with("/ab/").never
+      expect(Regexp).not_to receive(:new).with("/ab/")
 
       Puppet::Parser::AST::Regex.new :value => value
     end
@@ -61,11 +60,11 @@ describe Puppet::Parser::AST::Regex do
   end
 
   it 'should return the PRegexpType#regexp_to_s_with_delimiters with to_s' do
-    regex = stub 'regex'
-    Regexp.stubs(:new).returns(regex)
+    regex = double('regex')
+    allow(Regexp).to receive(:new).and_return(regex)
 
     val = Puppet::Parser::AST::Regex.new :value => '/ab/'
-    Puppet::Pops::Types::PRegexpType.expects(:regexp_to_s_with_delimiters)
+    expect(Puppet::Pops::Types::PRegexpType).to receive(:regexp_to_s_with_delimiters)
 
     val.to_s
   end
@@ -74,7 +73,7 @@ describe Puppet::Parser::AST::Regex do
     regex = Regexp.new("/ab/")
     val = Puppet::Parser::AST::Regex.new :value => regex
 
-    regex.expects(:match).with("value")
+    expect(regex).to receive(:match).with("value")
 
     val.match("value")
   end
@@ -86,8 +85,8 @@ describe Puppet::Parser::AST::HostName do
     compiler = Puppet::Parser::Compiler.new(node)
     @scope   = Puppet::Parser::Scope.new(compiler)
     @value   = 'value'
-    @value.stubs(:to_s).returns(@value)
-    @value.stubs(:downcase).returns(@value)
+    allow(@value).to receive(:to_s).and_return(@value)
+    allow(@value).to receive(:downcase).and_return(@value)
     @host = Puppet::Parser::AST::HostName.new(:value => @value)
   end
 
@@ -100,16 +99,16 @@ describe Puppet::Parser::AST::HostName do
   end
 
   it "should stringify the value" do
-    value = stub 'value', :=~ => false
+    value = double('value', :=~ => false)
 
-    value.expects(:to_s).returns("test")
+    expect(value).to receive(:to_s).and_return("test")
 
     Puppet::Parser::AST::HostName.new(:value => value)
   end
 
   it "should downcase the value" do
-    value = stub 'value', :=~ => false
-    value.stubs(:to_s).returns("UPCASED")
+    value = double('value', :=~ => false)
+    allow(value).to receive(:to_s).and_return("UPCASED")
     host = Puppet::Parser::AST::HostName.new(:value => value)
 
     host.value == "upcased"
@@ -120,18 +119,18 @@ describe Puppet::Parser::AST::HostName do
   end
 
   it "should delegate eql? to the underlying value if it is an HostName" do
-    @value.expects(:eql?).with("value")
+    expect(@value).to receive(:eql?).with("value")
     @host.eql?("value")
   end
 
   it "should delegate eql? to the underlying value if it is not an HostName" do
-    value = stub 'compared', :is_a? => true, :value => "value"
-    @value.expects(:eql?).with("value")
+    value = double('compared', :is_a? => true, :value => "value")
+    expect(@value).to receive(:eql?).with("value")
     @host.eql?(value)
   end
 
   it "should delegate hash to the underlying value" do
-    @value.expects(:hash)
+    expect(@value).to receive(:hash)
     @host.hash
   end
 end