puppet 6.0.7-x64-mingw32 → 6.0.8-x64-mingw32

data/spec/unit/face/generate_spec.rb

@@ -126,7 +126,7 @@ describe Puppet::Face[:generate, :current] do
       end
 
       it 'sets pcore as the default format' do
-        Puppet::Generate::Type.expects(:find_inputs).with(:pcore).returns([])
+        expect(Puppet::Generate::Type).to receive(:find_inputs).with(:pcore).and_return([])
         genface.types()
       end
 
@@ -135,8 +135,8 @@ describe Puppet::Face[:generate, :current] do
         # (There is no way to call the original when mocking expected parameters).
         input1 = Puppet::Generate::Type::Input.new(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore)
         input2 = Puppet::Generate::Type::Input.new(m1, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore)
-        Puppet::Generate::Type::Input.expects(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).returns(input1)
-        Puppet::Generate::Type::Input.expects(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).returns(input2)
+        expect(Puppet::Generate::Type::Input).to receive(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).and_return(input1)
+        expect(Puppet::Generate::Type::Input).to receive(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).and_return(input2)
         genface.types
       end
 
@@ -224,7 +224,6 @@ describe Puppet::Face[:generate, :current] do
   end
 
   def from_an_interactive_terminal
-    STDIN.stubs(:tty?).returns(true)
+    allow(STDIN).to receive(:tty?).and_return(true)
   end
-
 end

data/spec/unit/face/help_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -50,7 +49,7 @@ describe Puppet::Face[:help, '0.0.1'] do
   context 'rendering has an error' do
     it 'raises an ArgumentError if the face raises a StandardError' do
       face = Puppet::Face[:module, :current]
-      face.stubs(:short_description).raises(StandardError, 'whoops')
+      allow(face).to receive(:short_description).and_raise(StandardError, 'whoops')
 
       expect {
         subject.help(:module)
@@ -59,7 +58,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
     it 'raises an ArgumentError if the face raises a LoadError' do
       face = Puppet::Face[:module, :current]
-      face.stubs(:short_description).raises(LoadError, 'cannot load such file -- yard')
+      allow(face).to receive(:short_description).and_raise(LoadError, 'cannot load such file -- yard')
 
       expect {
         subject.help(:module)
@@ -69,7 +68,7 @@ describe Puppet::Face[:help, '0.0.1'] do
     context 'with face actions' do
       it 'returns an error if we can not get an action for the module' do
         face = Puppet::Face[:module, :current]
-        face.stubs(:get_action).returns(nil)
+        allow(face).to receive(:get_action).and_return(nil)
 
         expect {subject.help('module', 'list')}.to raise_error(ArgumentError, /Unable to load action list from Puppet::Face/)
       end
@@ -135,7 +134,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
   context 'deprecated faces' do
     it 'prints a deprecation warning for deprecated faces' do
-      Puppet::Face[:module, :current].stubs(:deprecated?).returns(true)
+      allow(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
       expect(Puppet::Face[:help, :current].help(:module)).to match(/Warning: 'puppet module' is deprecated/)
     end
   end
@@ -143,7 +142,7 @@ describe Puppet::Face[:help, '0.0.1'] do
   context '#all_application_summaries' do
     it 'appends a deprecation warning for deprecated faces' do
       # Stub the module face as deprecated
-      Puppet::Face[:module, :current].expects(:deprecated?).returns(true)
+      expect(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
       Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
         expect(summary).to match(/Deprecated/) if appname == 'module'
       end
@@ -190,7 +189,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
     context 'rendering has an error' do
       it 'raises an ArgumentError if a legacy application raises a StandardError' do
-        Puppet::Application[appname].class.any_instance.stubs(:help).raises(StandardError, 'whoops')
+        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(StandardError, 'whoops')
 
         expect {
           subject.help(appname)
@@ -198,7 +197,7 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
 
       it 'raises an ArgumentError if a legacy application raises a LoadError' do
-        Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, 'cannot load such file -- yard')
+        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(LoadError, 'cannot load such file -- yard')
 
         expect {
           subject.help(appname)

data/spec/unit/face/key_spec.rb

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

data/spec/unit/face/man_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -20,7 +19,7 @@ describe Puppet::Face[:man, '0.0.1'] do
   end
 
   it 'raises an ArgumentError when given to many arguments' do
-    subject.stubs(:print_man_help)
+    allow(subject).to receive(:print_man_help)
     expect { subject.man(:man, 'cert', 'extra') }.to raise_error(ArgumentError)
   end
 end

data/spec/unit/face/module/install_spec.rb

@@ -6,15 +6,13 @@ describe "puppet module install" do
   include PuppetSpec::Files
 
   describe "action" do
-    let(:name)        { stub(:name) }
+    let(:name)        { double(:name) }
     let(:target_dir)  { tmpdir('module install face action') }
     let(:options)     { { :target_dir => target_dir } }
 
     it 'should invoke the Installer app' do
-      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
-      Puppet::ModuleTool::Applications::Installer.expects(:run).with do |*args|
-        mod, target, opts = args
-
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
+      expect(Puppet::ModuleTool::Applications::Installer).to receive(:run) do |mod, target, opts|
         expect(mod).to eql(name)
         expect(opts).to eql(options)
         expect(target).to be_a(Puppet::ModuleTool::InstallDirectory)

data/spec/unit/face/module/list_spec.rb

@@ -207,12 +207,7 @@ describe "puppet module list" do
         }]
       })
 
-      warning_expectations = [
-        regexp_matches(/Missing dependency 'puppetlabs-dependable'/),
-        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
-      ]
-
-      Puppet.expects(:warning).with(all_of(*warning_expectations))
+      expect(Puppet).to receive(:warning).with(match(/Missing dependency 'puppetlabs-dependable'/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
 
       console_output(:tree => true)
     end
@@ -227,12 +222,7 @@ describe "puppet module list" do
         }]
       })
 
-      warning_expectations = [
-        regexp_matches(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/),
-        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
-      ]
-
-      Puppet.expects(:warning).with(all_of(*warning_expectations))
+      expect(Puppet).to receive(:warning).with(match(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
 
       console_output(:tree => true)
     end

data/spec/unit/face/module/search_spec.rb

@@ -13,12 +13,14 @@ describe "puppet module search" do
   describe Puppet::Application::Module do
     subject do
       app = Puppet::Application::Module.new
-      app.stubs(:action).returns(Puppet::Face.find_action(:module, :search))
+      allow(app).to receive(:action).and_return(Puppet::Face.find_action(:module, :search))
       app
     end
 
-    before { subject.render_as = :console }
-    before { Puppet::Util::Terminal.stubs(:width).returns(100) }
+    before do
+      subject.render_as = :console
+      allow(Puppet::Util::Terminal).to receive(:width).and_return(100)
+    end
 
     it 'should output nothing when receiving an empty dataset' do
       expect(subject.render({:answers => [], :result => :success}, ['apache', {}])).to eq("No results found for 'apache'.")
@@ -166,7 +168,7 @@ describe "puppet module search" do
           ]
         }
 
-        Puppet::Util::Terminal.expects(:width).returns(width)
+        expect(Puppet::Util::Terminal).to receive(:width).and_return(width)
         result = subject.render(results, ['apache', {}])
         expect(result.lines.sort_by(&:length).last.chomp.length).to be <= width
         expect(result).to eq(expectation)
@@ -183,13 +185,13 @@ describe "puppet module search" do
     end
 
     it "should accept the --module_repository option" do
-      forge = mock("Puppet::Forge")
-      searcher = mock("Searcher")
+      forge = double("Puppet::Forge")
+      searcher = double("Searcher")
       options[:module_repository] = "http://forge.example.com"
 
-      Puppet::Forge.expects(:new).with("http://forge.example.com").returns(forge)
-      Puppet::ModuleTool::Applications::Searcher.expects(:new).with("puppetlabs-apache", forge, has_entries(options)).returns(searcher)
-      searcher.expects(:run)
+      expect(Puppet::Forge).to receive(:new).with("http://forge.example.com").and_return(forge)
+      expect(Puppet::ModuleTool::Applications::Searcher).to receive(:new).with("puppetlabs-apache", forge, hash_including(options)).and_return(searcher)
+      expect(searcher).to receive(:run)
 
       subject.search("puppetlabs-apache", options)
     end

data/spec/unit/face/module/uninstall_spec.rb

@@ -10,10 +10,8 @@ describe "puppet module uninstall" do
     let(:options) { Hash.new }
 
     it 'should invoke the Uninstaller app' do
-      args = [ name, options ]
-
-      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
-      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
+      expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with(name, options)
 
       Puppet::Face[:module, :current].uninstall(name, options)
     end
@@ -22,10 +20,8 @@ describe "puppet module uninstall" do
       let(:name) { 'module/name' }
 
       it 'should invoke the Uninstaller app' do
-        args = [ 'module-name', options ]
-
-        Puppet::ModuleTool.expects(:set_option_defaults).with(options)
-        Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
+        expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
+        expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with('module-name', options)
 
         Puppet::Face[:module, :current].uninstall(name, options)
       end

data/spec/unit/face/node_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -10,32 +9,32 @@ describe Puppet::Face[:node, '0.0.1'] do
         "cached_facts" => ['hostname'],
         "cached_node"  => ['hostname'],
         "reports"      => ['hostname'],
-      }.each { |k, v| subject.expects("clean_#{k}".to_sym).with(*v) }
+      }.each { |k, v| expect(subject).to receive("clean_#{k}".to_sym).with(*v) }
       subject.cleanup('hostname')
     end
   end
 
   describe 'when running #clean' do
     before :each do
-      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
-      Puppet::Node::Facts.indirection.stubs(:cache_class=)
-      Puppet::Node.stubs(:terminus_class=)
-      Puppet::Node.stubs(:cache_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
+      allow(Puppet::Node).to receive(:terminus_class=)
+      allow(Puppet::Node).to receive(:cache_class=)
     end
 
     it 'should invoke #cleanup' do
-      subject.expects(:cleanup).with('hostname', nil)
+      expect(subject).to receive(:cleanup).with('hostname')
       subject.clean('hostname')
     end
   end
 
   describe "clean action" do
     before :each do
-      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
-      Puppet::Node::Facts.indirection.stubs(:cache_class=)
-      Puppet::Node.stubs(:terminus_class=)
-      Puppet::Node.stubs(:cache_class=)
-      subject.stubs(:cleanup)
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
+      allow(Puppet::Node).to receive(:terminus_class=)
+      allow(Puppet::Node).to receive(:cache_class=)
+      allow(subject).to receive(:cleanup)
     end
 
     it "should have a clean action" do
@@ -63,14 +62,14 @@ describe Puppet::Face[:node, '0.0.1'] do
     context "clean action" do
       subject { Puppet::Face[:node, :current] }
       before :each do
-        Puppet::Util::Log.stubs(:newdestination)
-        Puppet::Util::Log.stubs(:level=)
+        allow(Puppet::Util::Log).to receive(:newdestination)
+        allow(Puppet::Util::Log).to receive(:level=)
       end
 
       describe "during setup" do
         it "should set facts terminus and cache class to yaml" do
-          Puppet::Node::Facts.indirection.expects(:terminus_class=).with(:yaml)
-          Puppet::Node::Facts.indirection.expects(:cache_class=).with(:yaml)
+          expect(Puppet::Node::Facts.indirection).to receive(:terminus_class=).with(:yaml)
+          expect(Puppet::Node::Facts.indirection).to receive(:cache_class=).with(:yaml)
 
           subject.clean('hostname')
         end
@@ -81,8 +80,8 @@ describe Puppet::Face[:node, '0.0.1'] do
         end
 
         it "should set node cache as yaml" do
-          Puppet::Node.indirection.expects(:terminus_class=).with(:yaml)
-          Puppet::Node.indirection.expects(:cache_class=).with(:yaml)
+          expect(Puppet::Node.indirection).to receive(:terminus_class=).with(:yaml)
+          expect(Puppet::Node.indirection).to receive(:cache_class=).with(:yaml)
 
           subject.clean('hostname')
         end
@@ -90,13 +89,13 @@ describe Puppet::Face[:node, '0.0.1'] do
 
       describe "when cleaning certificate", :if => Puppet.features.puppetserver_ca? do
         it "should call the CA CLI gem's clean action" do
-          Puppetserver::Ca::Action::Clean.any_instance.expects(:run).with({ 'certnames' => ['hostname'] }).returns(0)
+          expect_any_instance_of(Puppetserver::Ca::Action::Clean).to receive(:run).with({ 'certnames' => ['hostname'] }).and_return(0)
           subject.clean_cert('hostname')
         end
 
         it "should not call the CA CLI gem's clean action if the gem is missing" do
-          Puppet.features.expects(:puppetserver_ca?).returns(false)
-          Puppetserver::Ca::Action::Clean.any_instance.expects(:run).never
+          expect(Puppet.features).to receive(:puppetserver_ca?).and_return(false)
+          expect_any_instance_of(Puppetserver::Ca::Action::Clean).not_to receive(:run)
           subject.clean_cert("hostname")
         end
       end
@@ -104,7 +103,7 @@ describe Puppet::Face[:node, '0.0.1'] do
       describe "when cleaning cached facts" do
         it "should destroy facts" do
           @host = 'node'
-          Puppet::Node::Facts.indirection.expects(:destroy).with(@host)
+          expect(Puppet::Node::Facts.indirection).to receive(:destroy).with(@host)
 
           subject.clean_cached_facts(@host)
         end
@@ -112,14 +111,14 @@ describe Puppet::Face[:node, '0.0.1'] do
 
       describe "when cleaning cached node" do
         it "should destroy the cached node" do
-          Puppet::Node.indirection.expects(:destroy).with(@host)
+          expect(Puppet::Node.indirection).to receive(:destroy).with(@host)
           subject.clean_cached_node(@host)
         end
       end
 
       describe "when cleaning archived reports" do
         it "should tell the reports to remove themselves" do
-          Puppet::Transaction::Report.indirection.stubs(:destroy).with(@host)
+          allow(Puppet::Transaction::Report.indirection).to receive(:destroy).with(@host)
 
           subject.clean_reports(@host)
         end

data/spec/unit/face/parser_spec.rb

@@ -226,11 +226,11 @@ describe Puppet::Face[:parser, :current] do
   end
 
   def from_an_interactive_terminal
-    STDIN.stubs(:tty?).returns(true)
+    allow(STDIN).to receive(:tty?).and_return(true)
   end
 
   def from_a_piped_input_of(contents)
-    STDIN.stubs(:tty?).returns(false)
-    STDIN.stubs(:read).returns(contents)
+    allow(STDIN).to receive(:tty?).and_return(false)
+    allow(STDIN).to receive(:read).and_return(contents)
   end
 end

data/spec/unit/face/plugin_spec.rb

@@ -1,9 +1,7 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
 describe Puppet::Face[:plugin, :current] do
-
   let(:pluginface) { described_class }
   let(:action) { pluginface.get_action(:download) }
 
@@ -18,22 +16,38 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, external facts, and locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
       pluginface.download
+      expect(receive_count).to eq(3)
     end
 
     it "renders 'No plugins downloaded' if nothing was downloaded" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
       result = pluginface.download
+      expect(receive_count).to eq(3)
       expect(render(result)).to eq('No plugins downloaded.')
     end
 
     it "renders comma separate list of downloaded file names" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        receive_count += 1
+        case receive_count
+        when 1
+          %w[/a]
+        when 2
+          %w[/b]
+        when 3
+          %w[/c]
+        end
+      end
 
       result = pluginface.download
+      expect(receive_count).to eq(3)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
     end
   end
@@ -45,15 +59,21 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1}.and_return([])
 
       pluginface.download
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        receive_count += 1
+        receive_count == 1 ? %w[/a] : %w[/b]
+      end
 
       result = pluginface.download
+      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end
@@ -66,15 +86,22 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
       pluginface.download
+      expect(receive_count).to eq(2)
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        receive_count += 1
+        receive_count == 1 ? %w[/a] : %w[/b]
+      end
 
       result = pluginface.download
+      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end