puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

data/spec/unit/resource/capability_finder_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require_relative '../pops/parser/parser_rspec_helper'
 require 'puppet/resource/capability_finder'
@@ -6,12 +5,16 @@ require 'puppet/resource/capability_finder'
 describe Puppet::Resource::CapabilityFinder do
   context 'when PuppetDB is not configured' do
     it 'should error' do
-      Puppet::Util.expects(:const_defined?).with('Puppetdb').returns false
+      expect(Puppet::Util).to receive(:const_defined?).with('Puppetdb').and_return(false)
       expect { Puppet::Resource::CapabilityFinder.find('production', nil, nil) }.to raise_error(/PuppetDB is not available/)
     end
   end
 
   context 'when PuppetDB is configured' do
+    before(:each) do
+      allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
+    end
+
     around(:each) do |example|
       mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
       if mock_pdb
@@ -20,7 +23,6 @@ describe Puppet::Resource::CapabilityFinder do
         end
       end
       begin
-        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
         Puppet.override(:loaders => loaders, :current_environment => env) do
           make_cap_type
           example.run
@@ -36,7 +38,7 @@ describe Puppet::Resource::CapabilityFinder do
     let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
     let(:response_body) { [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}] }
-    let(:response) { stub('response', :body => response_body.to_json) }
+    let(:response) { double('response', :body => response_body.to_json) }
 
     def make_cap_type
       Puppet::Type.newtype :cap, :is_capability => true do
@@ -47,8 +49,8 @@ describe Puppet::Resource::CapabilityFinder do
 
     describe "when query_puppetdb method is available" do
       it 'should call use the query_puppetdb method if available' do
-        Puppet::Util::Puppetdb.expects(:query_puppetdb).returns(response_body)
-        Puppet::Util::Puppetdb::Http.expects(:action).never
+        expect(Puppet::Util::Puppetdb).to receive(:query_puppetdb).and_return(response_body)
+        expect(Puppet::Util::Puppetdb::Http).not_to receive(:action)
 
         result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
@@ -57,11 +59,11 @@ describe Puppet::Resource::CapabilityFinder do
 
     describe "when query_puppetdb method is unavailable" do
       before :each do
-        Puppet::Util::Puppetdb.stubs(:respond_to?).with(:query_puppetdb).returns false
+        allow(Puppet::Util::Puppetdb).to receive(:respond_to?).with(:query_puppetdb).and_return(false)
       end
 
       it 'should call Puppet::Util::PuppetDB::Http.action' do
-        Puppet::Util::Puppetdb::Http.expects(:action).returns(response)
+        expect(Puppet::Util::Puppetdb::Http).to receive(:action).and_return(response)
         result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
       end
@@ -73,14 +75,14 @@ describe Puppet::Resource::CapabilityFinder do
 
       it 'should search for the resource without including code_id or environment' do
         resources = [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}]
-        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
 
         result = Puppet::Resource::CapabilityFinder.find('production', code_id, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
       end
 
       it 'should return nil if no resource is found' do
-        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns []
+        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return([])
 
         result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
         expect(result).to be_nil
@@ -93,7 +95,7 @@ describe Puppet::Resource::CapabilityFinder do
         end
 
         before :each do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
         end
 
         it 'should return the resource matching environment' do
@@ -114,30 +116,30 @@ describe Puppet::Resource::CapabilityFinder do
         end
 
         before :each do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
         end
 
         it 'should return the resource matching code_id' do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"chost"}}]
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"chost"}}])
 
           result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
           expect(result['host']).to eq('chost')
         end
 
         it 'should fail if no resource matches code_id' do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns []
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([])
 
           expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::Error, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if multiple resources match code_id' do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return(resources)
 
           expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if no code_id was specified' do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', nil, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', nil, capability).and_return(resources)
           expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
       end

data/spec/unit/resource/catalog_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -11,7 +10,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
   before do
     @basepath = make_absolute("/somepath")
     # stub this to not try to create state.yaml
-    Puppet::Util::Storage.stubs(:store)
+    allow(Puppet::Util::Storage).to receive(:store)
   end
 
   it "should support json, pson, dot, yaml" do
@@ -71,11 +70,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     Puppet[:classfile] = File.expand_path("/class/file")
 
-    fh = mock 'filehandle'
+    fh = double('filehandle')
     classfile = Puppet.settings.setting(:classfile)
-    Puppet::FileSystem.expects(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").yields fh
+    expect(Puppet::FileSystem).to receive(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").and_yield(fh)
 
-    fh.expects(:puts).with "foo\nbar"
+    expect(fh).to receive(:puts).with("foo\nbar")
 
     @catalog.write_class_file
   end
@@ -98,7 +97,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
   end
 
   it "should include a catalog_uuid" do
-    SecureRandom.stubs(:uuid).returns ("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+    allow(SecureRandom).to receive(:uuid).and_return("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
     catalog = Puppet::Resource::Catalog.new("host")
     expect(catalog.catalog_uuid).to eq("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
   end
@@ -235,15 +234,29 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @original.tag(*%w{one two three})
       @original.add_class(*%w{four five six})
 
-      @r1 = stub_everything 'r1', :ref => "File[/a]"
-      @r1.stubs(:respond_to?).with(:ref).returns(true)
-      @r1.stubs(:copy_as_resource).returns(@r1)
-      @r1.stubs(:is_a?).with(Puppet::Resource).returns(true)
-
-      @r2 = stub_everything 'r2', :ref => "File[/b]"
-      @r2.stubs(:respond_to?).with(:ref).returns(true)
-      @r2.stubs(:copy_as_resource).returns(@r2)
-      @r2.stubs(:is_a?).with(Puppet::Resource).returns(true)
+      @r1 = double(
+        'r1',
+        :ref      => "File[/a]",
+        :[]       => nil,
+        :virtual  => nil,
+        :catalog= => nil,
+      )
+      allow(@r1).to receive(:respond_to?)
+      allow(@r1).to receive(:respond_to?).with(:ref).and_return(true)
+      allow(@r1).to receive(:copy_as_resource).and_return(@r1)
+      allow(@r1).to receive(:is_a?).with(Puppet::Resource).and_return(true)
+
+      @r2 = double(
+        'r2',
+        :ref      => "File[/b]",
+        :[]       => nil,
+        :virtual  => nil,
+        :catalog= => nil,
+      )
+      allow(@r2).to receive(:respond_to?)
+      allow(@r2).to receive(:respond_to?).with(:ref).and_return(true)
+      allow(@r2).to receive(:copy_as_resource).and_return(@r2)
+      allow(@r2).to receive(:is_a?).with(Puppet::Resource).and_return(true)
 
       @resources = [@r1,@r2]
 
@@ -251,13 +264,13 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should transform the catalog to a resource catalog" do
-      @original.expects(:to_catalog).with { |h,b| h == :to_resource }
+      expect(@original).to receive(:to_catalog).with(:to_resource)
 
       @original.filter
     end
 
     it "should scan each catalog resource in turn and apply filtering block" do
-      @resources.each { |r| r.expects(:test?) }
+      @resources.each { |r| expect(r).to receive(:test?) }
       @original.filter do |r|
         r.test?
       end
@@ -321,7 +334,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should set itself as the resource's catalog if it is not a relationship graph" do
-      @one.expects(:catalog=).with(@catalog)
+      expect(@one).to receive(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
@@ -411,14 +424,14 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should remove all resources when asked" do
       @catalog.add_resource @one
       @catalog.add_resource @two
-      @one.expects :remove
-      @two.expects :remove
+      expect(@one).to receive(:remove)
+      expect(@two).to receive(:remove)
       @catalog.clear(true)
     end
 
     it "should support a mechanism for finishing resources" do
-      @one.expects :finish
-      @two.expects :finish
+      expect(@one).to receive(:finish)
+      expect(@two).to receive(:finish)
       @catalog.add_resource @one
       @catalog.add_resource @two
 
@@ -426,7 +439,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should make default resources when finalizing" do
-      @catalog.expects(:make_default_resources)
+      expect(@catalog).to receive(:make_default_resources)
       @catalog.finalize
     end
 
@@ -436,8 +449,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should optionally support an initialization block and should finalize after such blocks" do
-      @one.expects :finish
-      @two.expects :finish
+      expect(@one).to receive(:finish)
+      expect(@two).to receive(:finish)
       Puppet::Resource::Catalog.new("host") do |conf|
         conf.add_resource @one
         conf.add_resource @two
@@ -445,7 +458,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should inform the resource that it is the resource's catalog" do
-      @one.expects(:catalog=).with(@catalog)
+      expect(@one).to receive(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
@@ -528,14 +541,14 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should remove resource aliases when the target resource is removed" do
       @catalog.add_resource @one
       @catalog.alias(@one, "other")
-      @one.expects :remove
+      expect(@one).to receive(:remove)
       @catalog.remove_resource(@one)
       expect(@catalog.resource("notify", "other")).to be_nil
     end
 
     it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
-      resource.expects(:isomorphic?).returns(true)
+      expect(resource).to receive(:isomorphic?).and_return(true)
       @catalog.add_resource(resource)
       expect(@catalog.resource(:file, "other")).to equal(resource)
       expect(@catalog.resource(:file, @basepath+"/something").ref).to eq(resource.ref)
@@ -543,7 +556,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
-      resource.expects(:isomorphic?).returns(false)
+      expect(resource).to receive(:isomorphic?).and_return(false)
       @catalog.add_resource(resource)
       expect(@catalog.resource(:file, resource.title)).to equal(resource)
       # We can't use .should here, because the resources respond to that method.
@@ -552,8 +565,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should provide a method to create additional resources that also registers the resource" do
       args = {:name => "/yay", :ensure => :file}
-      resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
-      Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
+      resource = double('file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay")
+      expect(Puppet::Type.type(:file)).to receive(:new).with(args).and_return(resource)
       @catalog.create_resource :file, args
       expect(@catalog.resource("File[/yay]")).to equal(resource)
     end
@@ -617,20 +630,20 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog = Puppet::Resource::Catalog.new("host")
 
       @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
-      Puppet::Transaction.stubs(:new).returns(@transaction)
-      @transaction.stubs(:evaluate)
-      @transaction.stubs(:for_network_device=)
+      allow(Puppet::Transaction).to receive(:new).and_return(@transaction)
+      allow(@transaction).to receive(:evaluate)
+      allow(@transaction).to receive(:for_network_device=)
 
-      Puppet.settings.stubs(:use)
+      allow(Puppet.settings).to receive(:use)
     end
 
     it "should create and evaluate a transaction" do
-      @transaction.expects(:evaluate)
+      expect(@transaction).to receive(:evaluate)
       @catalog.apply
     end
 
     it "should add a transaction evalution time to the report" do
-      @transaction.report.expects(:add_times).with(:transaction_evaluation, kind_of(Numeric))
+      expect(@transaction.report).to receive(:add_times).with(:transaction_evaluation, kind_of(Numeric))
       @catalog.apply
     end
 
@@ -654,17 +667,17 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should pass supplied tags on to the transaction" do
-      @transaction.expects(:tags=).with(%w{one two})
+      expect(@transaction).to receive(:tags=).with(%w{one two})
       @catalog.apply(:tags => %w{one two})
     end
 
     it "should set ignoreschedules on the transaction if specified in apply()" do
-      @transaction.expects(:ignoreschedules=).with(true)
+      expect(@transaction).to receive(:ignoreschedules=).with(true)
       @catalog.apply(:ignoreschedules => true)
     end
 
     it "should detect transaction failure and report it" do
-      @transaction.stubs(:evaluate).raises(RuntimeError, 'transaction failed.')
+      allow(@transaction).to receive(:evaluate).and_raise(RuntimeError, 'transaction failed.')
       report = Puppet::Transaction::Report.new('apply')
 
       expect { @catalog.apply(:report => report) }.to raise_error(RuntimeError)
@@ -674,31 +687,28 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     describe "host catalogs" do
-
       # super() doesn't work in the setup method for some reason
       before do
         @catalog.host_config = true
-        Puppet::Util::Storage.stubs(:store)
+        allow(Puppet::Util::Storage).to receive(:store)
       end
 
       it "should initialize the state database before applying a catalog" do
-        Puppet::Util::Storage.expects(:load)
+        expect(Puppet::Util::Storage).to receive(:load)
 
         # Short-circuit the apply, so we know we're loading before the transaction
-        Puppet::Transaction.expects(:new).raises ArgumentError
+        expect(Puppet::Transaction).to receive(:new).and_raise(ArgumentError)
         expect { @catalog.apply }.to raise_error(ArgumentError)
       end
 
       it "should sync the state database after applying" do
-        Puppet::Util::Storage.expects(:store)
-        @transaction.stubs :any_failed? => false
+        expect(Puppet::Util::Storage).to receive(:store)
+        allow(@transaction).to receive(:any_failed?).and_return(false)
         @catalog.apply
       end
-
     end
 
     describe "non-host catalogs" do
-
       before do
         @catalog.host_config = false
       end
@@ -710,11 +720,10 @@ describe Puppet::Resource::Catalog, "when compiling" do
       end
 
       it "should never modify the state database" do
-        Puppet::Util::Storage.expects(:load).never
-        Puppet::Util::Storage.expects(:store).never
+        expect(Puppet::Util::Storage).not_to receive(:load)
+        expect(Puppet::Util::Storage).not_to receive(:store)
         @catalog.apply
       end
-
     end
   end
 
@@ -724,7 +733,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should get removed when the catalog is cleaned up" do
-      @catalog.relationship_graph.expects(:clear)
+      expect(@catalog.relationship_graph).to receive(:clear)
 
       @catalog.clear
 
@@ -740,19 +749,18 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should only write when it is a host catalog" do
-      Puppet::FileSystem.expects(:open).with(@file, 0640, "w:UTF-8").never
+      expect(Puppet::FileSystem).not_to receive(:open).with(@file, 0640, "w:UTF-8")
       @catalog.host_config = false
       Puppet[:graph] = true
       @catalog.write_graph(@name)
     end
-
   end
 
   describe "when indirecting" do
     before do
       @real_indirection = Puppet::Resource::Catalog.indirection
 
-      @indirection = stub 'indirection', :name => :catalog
+      @indirection = double('indirection', :name => :catalog)
     end
 
     it "should use the value of the 'catalog_terminus' setting to determine its terminus class" do
@@ -877,7 +885,6 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
         Puppet.pop_context
       end
 
-
       let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
 
       it 'should generate rich value hash for parameter values that are not Data' do
@@ -1012,9 +1019,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
         expect(message['a']).to eql(nil)
         expect(message['b']).to eql(10)
       end
-
     end
-
   end
 end
 
@@ -1045,30 +1050,29 @@ describe Puppet::Resource::Catalog, "when converting to json" do
   end
 
   it "should convert its resources to a JSON-encoded array and store it as the 'resources' data" do
-    one = stub 'one', :to_data_hash => "one_resource", :ref => "Foo[one]"
-    two = stub 'two', :to_data_hash => "two_resource", :ref => "Foo[two]"
+    one = double('one', :to_data_hash => "one_resource", :ref => "Foo[one]")
+    two = double('two', :to_data_hash => "two_resource", :ref => "Foo[two]")
 
-    one.expects(:'[]').with(:alias).returns nil
-    two.expects(:'[]').with(:alias).returns nil
+    expect(one).to receive(:'[]').with(:alias).and_return(nil)
+    expect(two).to receive(:'[]').with(:alias).and_return(nil)
 
     @catalog.add_resource(one)
     @catalog.add_resource(two)
 
     # TODO this should really guarantee sort order
     expect(JSON.parse(@catalog.to_json,:create_additions => false)['resources'].sort).to eq(["one_resource", "two_resource"].sort)
-
   end
 
   it "should convert its edges to a JSON-encoded array and store it as the 'edges' data" do
-    one   = stub 'one',   :to_data_hash => "one_resource",   :ref => 'Foo[one]'
-    two   = stub 'two',   :to_data_hash => "two_resource",   :ref => 'Foo[two]'
-    three = stub 'three', :to_data_hash => "three_resource", :ref => 'Foo[three]'
+    one   = double('one',   :to_data_hash => "one_resource",   :ref => 'Foo[one]')
+    two   = double('two',   :to_data_hash => "two_resource",   :ref => 'Foo[two]')
+    three = double('three', :to_data_hash => "three_resource", :ref => 'Foo[three]')
 
     @catalog.add_edge(one, two)
     @catalog.add_edge(two, three)
 
-    @catalog.edges_between(one, two  )[0].expects(:to_data_hash).returns "one_two_json"
-    @catalog.edges_between(two, three)[0].expects(:to_data_hash).returns "two_three_json"
+    expect(@catalog.edges_between(one, two  )[0]).to receive(:to_data_hash).and_return("one_two_json")
+    expect(@catalog.edges_between(two, three)[0]).to receive(:to_data_hash).and_return("two_three_json")
 
     expect(JSON.parse(@catalog.to_json,:create_additions => false)['edges'].sort).to eq(%w{one_two_json two_three_json}.sort)
   end