puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/face/epp_face_spec.rb

@@ -102,6 +102,7 @@ describe Puppet::Face[:epp, :current] do
     end
   end
 
+
   context "dump" do
     it "prints the AST of a template given with the -e option" do
       expect(eppface.dump({ :e => 'hello world' })).to eq("(lambda (epp (block\n  (render-s 'hello world')\n)))\n")
@@ -375,11 +376,11 @@ goodbye world
   end
 
   def from_an_interactive_terminal
-    allow(STDIN).to receive(:tty?).and_return(true)
+    STDIN.stubs(:tty?).returns(true)
   end
 
   def from_a_piped_input_of(contents)
-    allow(STDIN).to receive(:tty?).and_return(false)
-    allow(STDIN).to receive(:read).and_return(contents)
+    STDIN.stubs(:tty?).returns(false)
+    STDIN.stubs(:read).returns(contents)
   end
 end

data/spec/unit/face/facts_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 require 'puppet/indirector/facts/facter'
@@ -27,35 +28,26 @@ CONF
       # Faces start in :user run mode
       Puppet.settings.preferred_run_mode = :user
 
-      allow(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
-      allow(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
+      facter_terminus.stubs(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
+      rest_terminus.stubs(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
     end
 
     it { is_expected.to be_action :upload }
 
     it "finds facts from terminus_class :facter" do
-      expect(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
+      facter_terminus.expects(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
 
       subject.upload
     end
 
     it "saves facts to terminus_class :rest" do
-      expect(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
+      rest_terminus.expects(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
 
       subject.upload
     end
 
-    it "passes the current environment" do
-      env = Puppet::Node::Environment.remote('qa')
-      expect(model.indirection).to receive(:save).with(anything, nil, :environment => env)
-
-      Puppet.override(:current_environment => env) do
-        subject.upload
-      end
-    end
-
     it "uses settings from the agent section of puppet.conf" do
-      expect(facter_terminus).to receive(:find).with(have_attributes(key: 'puppet.node.test')).and_return(test_data)
+      facter_terminus.expects(:find).with(responds_with(:key, 'puppet.node.test')).returns(test_data)
 
       subject.upload
     end

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
-        expect(Puppet::Generate::Type).to receive(:find_inputs).with(:pcore).and_return([])
+        Puppet::Generate::Type.expects(:find_inputs).with(:pcore).returns([])
         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)
-        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)
+        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)
         genface.types
       end
 
@@ -224,6 +224,7 @@ describe Puppet::Face[:generate, :current] do
   end
 
   def from_an_interactive_terminal
-    allow(STDIN).to receive(:tty?).and_return(true)
+    STDIN.stubs(:tty?).returns(true)
   end
+
 end

data/spec/unit/face/help_spec.rb

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

data/spec/unit/face/key_spec.rb

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

data/spec/unit/face/man_spec.rb

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

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

@@ -6,13 +6,15 @@ describe "puppet module install" do
   include PuppetSpec::Files
 
   describe "action" do
-    let(:name)        { double(:name) }
+    let(:name)        { stub(:name) }
     let(:target_dir)  { tmpdir('module install face action') }
     let(:options)     { { :target_dir => target_dir } }
 
     it 'should invoke the Installer app' do
-      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
-      expect(Puppet::ModuleTool::Applications::Installer).to receive(:run) do |mod, target, opts|
+      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with do |*args|
+        mod, target, opts = args
+
         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,69 +207,14 @@ describe "puppet module list" do
         }]
       })
 
-      expect(Puppet).to receive(:warning).with(match(/Missing dependency 'puppetlabs-dependable'/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
+      warning_expectations = [
+        regexp_matches(/Missing dependency 'puppetlabs-dependable'/),
+        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
+      ]
 
-      console_output(:tree => true)
-    end
-
-    it 'should not warn about dependent module with pre-release version by default' do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 1.0.0",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '1.0.0-rc1' })
-
-      expected = <<-OUTPUT.unindent
-      #{@modpath1}
-      ├── puppetlabs-dependable (\e[0;36mv1.0.0-rc1\e[0m)
-      └── puppetlabs-depender (\e[0;36mv1.0.0\e[0m)
-      #{@modpath2} (no modules installed)
-      OUTPUT
-
-      expect(console_output).to eq(expected)
-    end
-
-    it 'should warn about dependent module with pre-release version by if pre-release is less than given pre-release' do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 1.0.0-rc1",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '1.0.0-rc0' })
+      Puppet.expects(:warning).with(all_of(*warning_expectations))
 
-      expected = <<-OUTPUT.unindent
-      #{@modpath1}
-      ├── puppetlabs-dependable (\e[0;36mv1.0.0-rc0\e[0m)  \e[0;31minvalid\e[0m
-      └── puppetlabs-depender (\e[0;36mv1.0.0\e[0m)
-      #{@modpath2} (no modules installed)
-      OUTPUT
-
-      expect(console_output).to eq(expected)
-    end
-
-    it 'should warn about dependent module with pre-release version when using strict SemVer' do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 1.0.0",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '1.0.0-rc1' })
-
-      expected = <<-OUTPUT.unindent
-      #{@modpath1}
-      ├── puppetlabs-dependable (\e[0;36mv1.0.0-rc1\e[0m)  \e[0;31minvalid\e[0m
-      └── puppetlabs-depender (\e[0;36mv1.0.0\e[0m)
-      #{@modpath2} (no modules installed)
-      OUTPUT
-
-      expect(console_output(:strict_semver => true)).to eq(expected)
+      console_output(:tree => true)
     end
 
     it "should warn about out of range dependencies" do
@@ -282,7 +227,12 @@ describe "puppet module list" do
         }]
       })
 
-      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\)/))
+      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))
 
       console_output(:tree => true)
     end

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

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

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

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

data/spec/unit/face/node_spec.rb

@@ -1,11 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
-describe Puppet::Face[:node, '0.0.1'] do
-  after :all do
-    Puppet::SSL::Host.ca_location = :none
-  end
+require 'puppetserver/ca/cli'
 
+describe Puppet::Face[:node, '0.0.1'] do
   describe '#cleanup' do
     it "should clean everything" do
       {
@@ -13,32 +12,32 @@ describe Puppet::Face[:node, '0.0.1'] do
         "cached_facts" => ['hostname'],
         "cached_node"  => ['hostname'],
         "reports"      => ['hostname'],
-      }.each { |k, v| expect(subject).to receive("clean_#{k}".to_sym).with(*v) }
+      }.each { |k, v| subject.expects("clean_#{k}".to_sym).with(*v) }
       subject.cleanup('hostname')
     end
   end
 
   describe 'when running #clean' do
     before :each do
-      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=)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
+      Puppet::Node::Facts.indirection.stubs(:cache_class=)
+      Puppet::Node.stubs(:terminus_class=)
+      Puppet::Node.stubs(:cache_class=)
     end
 
     it 'should invoke #cleanup' do
-      expect(subject).to receive(:cleanup).with('hostname')
+      subject.expects(:cleanup).with('hostname', nil)
       subject.clean('hostname')
     end
   end
 
   describe "clean action" do
     before :each do
-      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)
+      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)
     end
 
     it "should have a clean action" do
@@ -66,14 +65,14 @@ describe Puppet::Face[:node, '0.0.1'] do
     context "clean action" do
       subject { Puppet::Face[:node, :current] }
       before :each do
-        allow(Puppet::Util::Log).to receive(:newdestination)
-        allow(Puppet::Util::Log).to receive(:level=)
+        Puppet::Util::Log.stubs(:newdestination)
+        Puppet::Util::Log.stubs(:level=)
       end
 
       describe "during setup" do
         it "should set facts terminus and cache class to yaml" do
-          expect(Puppet::Node::Facts.indirection).to receive(:terminus_class=).with(:yaml)
-          expect(Puppet::Node::Facts.indirection).to receive(:cache_class=).with(:yaml)
+          Puppet::Node::Facts.indirection.expects(:terminus_class=).with(:yaml)
+          Puppet::Node::Facts.indirection.expects(:cache_class=).with(:yaml)
 
           subject.clean('hostname')
         end
@@ -84,51 +83,30 @@ describe Puppet::Face[:node, '0.0.1'] do
         end
 
         it "should set node cache as yaml" do
-          expect(Puppet::Node.indirection).to receive(:terminus_class=).with(:yaml)
-          expect(Puppet::Node.indirection).to receive(:cache_class=).with(:yaml)
-
-          subject.clean('hostname')
-        end
+          Puppet::Node.indirection.expects(:terminus_class=).with(:yaml)
+          Puppet::Node.indirection.expects(:cache_class=).with(:yaml)
 
-        it "should manage the certs if the host is a CA" do
-          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(true)
-          expect(Puppet::SSL::Host).to receive(:ca_location=).with(:local)
-          subject.clean('hostname')
-        end
-
-        it "should not manage the certs if the host is not a CA" do
-          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(false)
-          expect(Puppet::SSL::Host).to receive(:ca_location=).with(:none)
           subject.clean('hostname')
         end
       end
 
       describe "when cleaning certificate" do
-        before :each do
-          allow(Puppet::SSL::Host).to receive(:destroy)
-          @ca = double()
-          allow(Puppet::SSL::CertificateAuthority).to receive(:instance).and_return(@ca)
-        end
-
-        it "should send the :destroy order to the ca if we are a CA" do
-          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(true)
-          expect(@ca).to receive(:revoke).with(@host)
-          expect(@ca).to receive(:destroy).with(@host)
-          subject.clean_cert(@host)
+        it "should call the CA CLI gem's clean action" do
+          Puppetserver::Ca::Action::Clean.any_instance.expects(:run).with({ 'certnames' => ['hostname'] }).returns(0)
+          subject.clean_cert('hostname')
         end
 
-        it "should not destroy the certs if we are not a CA" do
-          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(false)
-          expect(@ca).not_to receive(:revoke)
-          expect(@ca).not_to receive(:destroy)
-          subject.clean_cert(@host)
+        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
+          subject.clean_cert("hostname")
         end
       end
 
       describe "when cleaning cached facts" do
         it "should destroy facts" do
           @host = 'node'
-          expect(Puppet::Node::Facts.indirection).to receive(:destroy).with(@host)
+          Puppet::Node::Facts.indirection.expects(:destroy).with(@host)
 
           subject.clean_cached_facts(@host)
         end
@@ -136,14 +114,14 @@ describe Puppet::Face[:node, '0.0.1'] do
 
       describe "when cleaning cached node" do
         it "should destroy the cached node" do
-          expect(Puppet::Node.indirection).to receive(:destroy).with(@host)
+          Puppet::Node.indirection.expects(: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
-          allow(Puppet::Transaction::Report.indirection).to receive(:destroy).with(@host)
+          Puppet::Transaction::Report.indirection.stubs(:destroy).with(@host)
 
           subject.clean_reports(@host)
         end