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

data/spec/unit/resource/status_spec.rb

@@ -1,6 +1,4 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
-
 require 'puppet/resource/status'
 
 describe Puppet::Resource::Status do
@@ -11,7 +9,7 @@ describe Puppet::Resource::Status do
   let(:status) { Puppet::Resource::Status.new(resource) }
 
   before do
-    resource.stubs(:pathbuilder).returns(containment_path)
+    allow(resource).to receive(:pathbuilder).and_return(containment_path)
   end
 
   it "should compute type and title correctly" do
@@ -43,7 +41,7 @@ describe Puppet::Resource::Status do
   end
 
   it "should set its source description to the resource's path" do
-    resource.expects(:path).returns "/my/path"
+    expect(resource).to receive(:path).and_return("/my/path")
     expect(Puppet::Resource::Status.new(resource).source_description).to eq("/my/path")
   end
 
@@ -53,7 +51,7 @@ describe Puppet::Resource::Status do
 
   [:file, :line].each do |attr|
     it "should copy the resource's #{attr}" do
-      resource.expects(attr).returns "foo"
+      expect(resource).to receive(attr).and_return("foo")
       expect(Puppet::Resource::Status.new(resource).send(attr)).to eq("foo")
     end
   end
@@ -66,7 +64,7 @@ describe Puppet::Resource::Status do
   end
 
   it "should always convert the resource to a string" do
-    resource.expects(:to_s).returns "foo"
+    expect(resource).to receive(:to_s).and_return("foo")
     expect(Puppet::Resource::Status.new(resource).resource).to eq("foo")
   end
 
@@ -111,8 +109,8 @@ describe Puppet::Resource::Status do
 
   it "fails and records a failure event with a given exception" do
     error = StandardError.new("the message")
-    resource.expects(:log_exception).with(error, "Could not evaluate: the message")
-    status.expects(:fail_with_event).with("the message")
+    expect(resource).to receive(:log_exception).with(error, "Could not evaluate: the message")
+    expect(status).to receive(:fail_with_event).with("the message")
 
     status.failed_because(error)
   end

data/spec/unit/resource/type_collection_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/resource/type_collection'
@@ -15,8 +14,8 @@ describe Puppet::Resource::TypeCollection do
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
-    @code.expects(:add).with "foo"
-    @code.expects(:add).with "bar"
+    expect(@code).to receive(:add).with("foo")
+    expect(@code).to receive(:add).with("bar")
     @code << "foo" << "bar"
   end
 
@@ -97,39 +96,40 @@ describe Puppet::Resource::TypeCollection do
 
     it "should not attempt to import anything when the type is already defined" do
       @code.add @type
-      @code.loader.expects(:import).never
+      expect(@code.loader).not_to receive(:import)
       expect(@code.find_hostclass("ns::klass")).to equal(@type)
     end
 
     describe "that need to be loaded" do
       it "should use the loader to load the files" do
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
+        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "klass")
         @code.find_hostclass("klass")
       end
+
       it "should use the loader to load the files" do
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
+        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.find_hostclass("ns::klass")
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
+        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.find_hostclass("ns::klass")
       end
 
       it "should use the class returned by the loader" do
-        @code.loader.expects(:try_load_fqname).returns(:klass)
-        @code.expects(:hostclass).with("ns::klass").returns(false)
+        expect(@code.loader).to receive(:try_load_fqname).and_return(:klass)
+        expect(@code).to receive(:hostclass).with("ns::klass").and_return(false)
         expect(@code.find_hostclass("ns::klass")).to eq(:klass)
       end
 
       it "should return nil if the name isn't found" do
-        @code.loader.stubs(:try_load_fqname).returns(nil)
+        allow(@code.loader).to receive(:try_load_fqname).and_return(nil)
         expect(@code.find_hostclass("Ns::Klass")).to be_nil
       end
 
       it "already-loaded names at broader scopes should not shadow autoloaded names" do
         @code.add Puppet::Resource::Type.new(:hostclass, "bar")
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
+        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "foo::bar").and_return(:foobar)
         expect(@code.find_hostclass("foo::bar")).to eq(:foobar)
       end
 
@@ -146,9 +146,9 @@ describe Puppet::Resource::TypeCollection do
 
         it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
           Puppet[:ignoremissingtypes] = true
-          @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
+          expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass").and_return(nil)
           expect(@code.find_hostclass("ns::klass")).to be_nil
-          Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
+          expect(Puppet).to receive(:debug).at_least(:once).with(/Not attempting to load hostclass/)
           expect(@code.find_hostclass("ns::klass")).to be_nil
         end
       end
@@ -255,7 +255,6 @@ describe Puppet::Resource::TypeCollection do
 
         expect(@loader.find_hostclass("::bar")).to eq(nil)
     end
-
   end
 
   it "should be able to find nodes" do
@@ -312,7 +311,7 @@ describe Puppet::Resource::TypeCollection do
     it "should default to the current time" do
       time = Time.now
 
-      Time.stubs(:now).returns time
+      allow(Time).to receive(:now).and_return(time)
       expect(@code.version).to eq(time.to_i)
     end
 
@@ -320,15 +319,15 @@ describe Puppet::Resource::TypeCollection do
       let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
 
       it "should use the output of the environment's config_version setting if one is provided" do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(["/my/foo"])
-          .returns Puppet::Util::Execution::ProcessOutput.new("output\n", 0)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("output\n", 0))
         expect(@code.version).to be_instance_of(String)
         expect(@code.version).to eq("output")
       end
 
       it "should raise a puppet parser error if executing config_version fails" do
-        Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
+        expect(Puppet::Util::Execution).to receive(:execute).and_raise(Puppet::ExecutionFailure.new("msg"))
 
         expect { @code.version }.to raise_error(Puppet::ParseError)
       end

data/spec/unit/resource/type_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource/type'
 require 'puppet/pops'
@@ -197,7 +196,7 @@ describe Puppet::Resource::Type do
 
     before(:each) do
       compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-      @scope = Puppet::Parser::Scope.new(compiler, :source => stub("source"))
+      @scope = Puppet::Parser::Scope.new(compiler, :source => double("source"))
       @resource = Puppet::Parser::Resource.new(:foo, "bar", :scope => @scope)
       @type = Puppet::Resource::Type.new(:definition, "foo")
       @resource.environment.known_resource_types.add @type
@@ -433,7 +432,7 @@ describe Puppet::Resource::Type do
     end
 
     it "should set its caller module name in the scope if available" do
-      @scope.expects(:parent_module_name).returns "mycaller"
+      expect(@scope).to receive(:parent_module_name).and_return("mycaller")
 
       @type.set_resource_parameters(@resource, @scope)
 
@@ -472,8 +471,8 @@ describe Puppet::Resource::Type do
     end
 
     it "should cache a reference to the parent type" do
-      @krt.stubs(:hostclass).with("foo::bar").returns nil
-      @krt.expects(:hostclass).with("bar").once.returns @parent
+      allow(@krt).to receive(:hostclass).with("foo::bar").and_return(nil)
+      expect(@krt).to receive(:hostclass).with("bar").once.and_return(@parent)
       @child.parent_type(@scope)
       @child.parent_type
     end
@@ -518,18 +517,18 @@ describe Puppet::Resource::Type do
       @type = Puppet::Resource::Type.new(:node, /f(\w)o(.*)$/)
       match = @type.match('foo')
 
-      code = stub 'code'
-      @type.stubs(:code).returns code
+      code = double('code')
+      allow(@type).to receive(:code).and_return(code)
 
-      subscope = stub 'subscope', :compiler => @compiler
-      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
+      subscope = double('subscope', :compiler => @compiler)
+      expect(@scope).to receive(:newscope).with(:source => @type, :resource => @resource).and_return(subscope)
 
-      subscope.expects(:with_guarded_scope).yields
-      subscope.expects(:ephemeral_from).with(match, nil, nil).returns subscope
-      code.expects(:safeevaluate).with(subscope)
+      expect(subscope).to receive(:with_guarded_scope).and_yield
+      expect(subscope).to receive(:ephemeral_from).with(match, nil, nil).and_return(subscope)
+      expect(code).to receive(:safeevaluate).with(subscope)
 
       # Just to keep the stub quiet about intermediate calls
-      @type.expects(:set_resource_parameters).with(@resource, subscope)
+      expect(@type).to receive(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
     end
@@ -546,17 +545,17 @@ describe Puppet::Resource::Type do
     end
 
     it "should set all of its parameters in a subscope" do
-      subscope = stub 'subscope', :compiler => @compiler
-      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
-      @type.expects(:set_resource_parameters).with(@resource, subscope)
+      subscope = double('subscope', :compiler => @compiler)
+      expect(@scope).to receive(:newscope).with(:source => @type, :resource => @resource).and_return(subscope)
+      expect(@type).to receive(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should not create a subscope for the :main class" do
-      @resource.stubs(:title).returns(:main)
-      @type.expects(:subscope).never
-      @type.expects(:set_resource_parameters).with(@resource, @scope)
+      allow(@resource).to receive(:title).and_return(:main)
+      expect(@type).not_to receive(:subscope)
+      expect(@type).to receive(:set_resource_parameters).with(@resource, @scope)
 
       @type.evaluate_code(@resource)
     end
@@ -573,15 +572,15 @@ describe Puppet::Resource::Type do
     end
 
     it "should evaluate the AST code if any is provided" do
-      code = stub 'code'
-      @type.stubs(:code).returns code
-      code.expects(:safeevaluate).with kind_of(Puppet::Parser::Scope)
+      code = double('code')
+      allow(@type).to receive(:code).and_return(code)
+      expect(code).to receive(:safeevaluate).with(kind_of(Puppet::Parser::Scope))
 
       @type.evaluate_code(@resource)
     end
 
     it "should noop if there is no code" do
-      @type.expects(:code).returns nil
+      expect(@type).to receive(:code).and_return(nil)
 
       @type.evaluate_code(@resource)
     end
@@ -611,7 +610,7 @@ describe Puppet::Resource::Type do
 
         @type.parent_type(@scope)
 
-        @parent_resource.expects(:evaluate).never
+        expect(@parent_resource).not_to receive(:evaluate)
 
         @type.evaluate_code(@resource)
       end
@@ -651,7 +650,7 @@ describe Puppet::Resource::Type do
 
         @type.parent_type(@scope)
 
-        @parent_resource.expects(:evaluate).never
+        expect(@parent_resource).not_to receive(:evaluate)
 
         @type.evaluate_code(@resource)
       end
@@ -740,14 +739,14 @@ describe Puppet::Resource::Type do
     end
 
     it "should not create a new resource if one already exists" do
-      @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
-      @compiler.catalog.expects(:add_resource).never
+      expect(@compiler.catalog).to receive(:resource).with(:class, "top").and_return("something")
+      expect(@compiler.catalog).not_to receive(:add_resource)
       @top.ensure_in_catalog(@scope)
     end
 
     it "should return the existing resource when not creating a new one" do
-      @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
-      @compiler.catalog.expects(:add_resource).never
+      expect(@compiler.catalog).to receive(:resource).with(:class, "top").and_return("something")
+      expect(@compiler.catalog).not_to receive(:add_resource)
       expect(@top.ensure_in_catalog(@scope)).to eq("something")
     end
 
@@ -805,9 +804,9 @@ describe Puppet::Resource::Type do
         code = Puppet::Resource::TypeCollection.new("env")
         code.add Puppet::Resource::Type.new(:hostclass, "")
         other = Puppet::Resource::Type.new(:hostclass, "")
-        mock = stub
-        mock.expects(:is_definitions_only?).returns(false)
-        other.expects(:code).returns(mock)
+        mock = double()
+        expect(mock).to receive(:is_definitions_only?).and_return(false)
+        expect(other).to receive(:code).and_return(mock)
         expect { code.hostclass("").merge(other) }.to raise_error(Puppet::Error)
       end
 
@@ -816,9 +815,9 @@ describe Puppet::Resource::Type do
         code = Puppet::Resource::TypeCollection.new("env")
         code.add Puppet::Resource::Type.new(:hostclass, "")
         other = Puppet::Resource::Type.new(:hostclass, "")
-        mock = stub
-        mock.expects(:is_definitions_only?).returns(true)
-        other.expects(:code).at_least_once.returns(mock)
+        mock = double()
+        expect(mock).to receive(:is_definitions_only?).and_return(true)
+        expect(other).to receive(:code).at_least(:once).and_return(mock)
         expect { code.hostclass("").merge(other) }.not_to raise_error
       end
     end

data/spec/unit/resource_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource'
 
@@ -8,8 +7,13 @@ describe Puppet::Resource do
   let(:basepath) { make_absolute("/somepath") }
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
-  def expect_lookup(key)
-    Puppet::Pops::Lookup::GlobalDataProvider.any_instance.expects(:unchecked_key_lookup).with(Puppet::Pops::Lookup::LookupKey.new(key), any_parameters)
+  def expect_lookup(key, options = {})
+    expectation = receive(:unchecked_key_lookup).with(Puppet::Pops::Lookup::LookupKey.new(key), any_args)
+    expectation = expectation.and_throw(options[:throws]) if options[:throws]
+    expectation = expectation.and_raise(*options[:raises]) if options[:raises]
+    expectation = expectation.and_return(options[:returns]) if options[:returns]
+
+    expect_any_instance_of(Puppet::Pops::Lookup::GlobalDataProvider).to expectation
   end
 
   [:catalog, :file, :line].each do |attr|
@@ -284,7 +288,7 @@ describe Puppet::Resource do
 
     it "should fail when asked to set default values and it is not a parser resource" do
       environment.known_resource_types.add(
-      Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
       )
       resource = Puppet::Resource.new("default_param", "name", :environment => environment)
       expect { resource.set_default_parameters(scope) }.to raise_error(Puppet::DevError)
@@ -327,9 +331,9 @@ describe Puppet::Resource do
       before do
         environment.known_resource_types.add(apache)
 
-        scope.stubs(:host).returns('host')
-        scope.stubs(:environment).returns(environment)
-        scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
+        allow(scope).to receive(:host).and_return('host')
+        allow(scope).to receive(:environment).and_return(environment)
+        allow(scope).to receive(:facts).and_return(Puppet::Node::Facts.new("facts", fact_values))
       end
 
       context 'with a default value expression' do
@@ -341,14 +345,14 @@ describe Puppet::Resource do
           end
 
           it "should query the data_binding terminus using a namespaced key" do
-            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('lookup_options', throws: :no_such_key)
             expect_lookup('apache::port')
             inject_and_set_defaults(resource, scope)
           end
 
           it "should use the value from the data_binding terminus" do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').returns('443')
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', returns: '443')
 
             inject_and_set_defaults(resource, scope)
 
@@ -356,8 +360,8 @@ describe Puppet::Resource do
           end
 
           it 'should use the default value if no value is found using the data_binding terminus' do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').throws(:no_such_key)
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', throws: :no_such_key)
 
             inject_and_set_defaults(resource, scope)
 
@@ -365,8 +369,8 @@ describe Puppet::Resource do
           end
 
           it 'should use the default value if an undef value is found using the data_binding terminus' do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').returns(nil)
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', returns: nil)
 
             inject_and_set_defaults(resource, scope)
 
@@ -374,8 +378,8 @@ describe Puppet::Resource do
           end
 
           it "should fail with error message about data binding on a hiera failure" do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', raises: [Puppet::DataBinding::LookupError, 'Forgettabotit'])
             expect {
               inject_and_set_defaults(resource, scope)
             }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
@@ -395,19 +399,19 @@ describe Puppet::Resource do
           end
 
           it "should not query the data_binding terminus" do
-            Puppet::DataBinding.indirection.expects(:find).never
+            expect(Puppet::DataBinding.indirection).not_to receive(:find)
             inject_and_set_defaults(resource, scope)
           end
 
           it "should use the value provided" do
-            Puppet::DataBinding.indirection.expects(:find).never
+            expect(Puppet::DataBinding.indirection).not_to receive(:find)
             expect(resource.set_default_parameters(scope)).to eq([])
             expect(resource[:port]).to eq('8080')
           end
 
           it "should use the value from the data_binding terminus when provided value is undef" do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').returns('443')
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', returns: '443')
 
             rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
               :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
@@ -423,8 +427,8 @@ describe Puppet::Resource do
         let(:resource) { Puppet::Parser::Resource.new("class", "apache", :scope => scope) }
 
         it "should use the value from the data_binding terminus" do
-          expect_lookup('lookup_options').throws(:no_such_key)
-          expect_lookup('apache::port').returns('443')
+          expect_lookup('lookup_options', throws: :no_such_key)
+          expect_lookup('apache::port', returns: '443')
 
           inject_and_set_defaults(resource, scope)
 
@@ -432,8 +436,8 @@ describe Puppet::Resource do
         end
 
         it "should use an undef value from the data_binding terminus" do
-          expect_lookup('lookup_options').throws(:no_such_key)
-          expect_lookup('apache::port').returns(nil)
+          expect_lookup('lookup_options', throws: :no_such_key)
+          expect_lookup('apache::port', returns: nil)
 
           inject_and_set_defaults(resource, scope)
 
@@ -533,14 +537,14 @@ describe Puppet::Resource do
 
     it "should set the namevar when asked to set the name" do
       resource = Puppet::Resource.new("user", "bob")
-      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
+      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
       resource[:name] = "bob"
       expect(resource[:myvar]).to eq("bob")
     end
 
     it "should return the namevar when asked to return the name" do
       resource = Puppet::Resource.new("user", "bob")
-      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
+      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
       resource[:myvar] = "test"
       expect(resource[:name]).to eq("test")
     end
@@ -619,7 +623,7 @@ describe Puppet::Resource do
 
     it "should use the title as the namevar to the hash if no namevar is present" do
       resource = Puppet::Resource.new("user", "bob")
-      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
+      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
       expect(resource.to_hash[:myvar]).to eq("bob")
     end
 
@@ -627,7 +631,7 @@ describe Puppet::Resource do
       krt = Puppet::Resource::TypeCollection.new("myenv")
       krt.add Puppet::Resource::Type.new(:definition, :foo)
       resource = Puppet::Resource.new :foo, "bar"
-      resource.stubs(:known_resource_types).returns krt
+      allow(resource).to receive(:known_resource_types).and_return(krt)
       expect(resource.to_hash[:name]).to eq("bar")
     end
   end
@@ -976,11 +980,11 @@ describe Puppet::Resource do
 
   describe "when resolving resources with a catalog" do
     it "should resolve all resources using the catalog" do
-      catalog = mock 'catalog'
+      catalog = double('catalog')
       resource = Puppet::Resource.new("foo::bar", "yay")
       resource.catalog = catalog
 
-      catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
+      expect(catalog).to receive(:resource).with("Foo::Bar[yay]").and_return(:myresource)
 
       expect(resource.resolve).to eq(:myresource)
     end
@@ -988,8 +992,8 @@ describe Puppet::Resource do
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
-      Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
-      Puppet::Type.type(:file).stubs(:title_patterns).returns(
+      allow(Puppet::Type.type(:file)).to receive(:key_attributes).and_return([:myvar, :owner, :path])
+      allow(Puppet::Type.type(:file)).to receive(:title_patterns).and_return(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})