puppet 5.5.12 → 5.5.13

data/spec/unit/provider_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 def existing_command
@@ -149,13 +148,13 @@ describe Puppet::Provider do
     # otherwise is to assign it to a constant, and that hurts more here in
     # testing world. --daniel 2012-01-29
     a = Class.new(Puppet::Provider).new(res)
-    a.class.stubs(:name).returns "Puppet::Provider::Notify::A"
+    allow(a.class).to receive(:name).and_return("Puppet::Provider::Notify::A")
 
     b = Class.new(Puppet::Provider).new(res)
-    b.class.stubs(:name).returns "Puppet::Provider::Notify::B"
+    allow(b.class).to receive(:name).and_return("Puppet::Provider::Notify::B")
 
     c = Class.new(Puppet::Provider).new(res)
-    c.class.stubs(:name).returns "Puppet::Provider::Notify::C"
+    allow(c.class).to receive(:name).and_return("Puppet::Provider::Notify::C")
 
     [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
       expect(this.sort).to eq([a, b, c])
@@ -281,7 +280,7 @@ describe Puppet::Provider do
 
     describe "regex matches" do
       it "should match a singular regex" do
-        Facter.expects(:value).with(:osfamily).at_least_once.returns "solaris"
+        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
 
         one = type.provide(:one) do
           defaultfor :osfamily => /solaris/
@@ -291,7 +290,7 @@ describe Puppet::Provider do
       end
 
       it "should not match a non-matching regex " do
-        Facter.expects(:value).with(:osfamily).at_least_once.returns "redhat"
+        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("redhat")
 
         one = type.provide(:one) do
           defaultfor :osfamily => /solaris/
@@ -302,8 +301,8 @@ describe Puppet::Provider do
 
       it "should allow a mix of regex and string" do
 
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns "fedora"
-        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "24"
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
+        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
 
         one = type.provide(:one) do
           defaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => /^2[2-9]$/
@@ -327,14 +326,14 @@ describe Puppet::Provider do
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for the first defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os1
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for the last defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os2
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -351,23 +350,23 @@ describe Puppet::Provider do
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for a more specific, but matching, defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os2
-        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "42"
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
+        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a more specific, but matching, defaultfor with regex" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os3
-        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "42"
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os3)
+        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a less specific, but matching, defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os1
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -391,8 +390,8 @@ describe Puppet::Provider do
     end
 
     it "should consider two defaults to be higher specificity than one default" do
-      Facter.expects(:value).with(:osfamily).at_least_once.returns "solaris"
-      Facter.expects(:value).with(:operatingsystemrelease).at_least_once.returns "5.10"
+      expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
+      expect(Facter).to receive(:value).with(:operatingsystemrelease).at_least(:once).and_return("5.10")
 
       one = type.provide(:one) do
         defaultfor :osfamily => "solaris"
@@ -459,7 +458,7 @@ describe Puppet::Provider do
       subject.commands :testing => "puppet-bug-1197"
       expect(subject.command(:testing)).to be_nil
 
-      subject.stubs(:which).with("puppet-bug-1197").returns("/puppet-bug-1197")
+      allow(subject).to receive(:which).with("puppet-bug-1197").and_return("/puppet-bug-1197")
       expect(subject.command(:testing)).to eq("/puppet-bug-1197")
 
       # Ideally, we would also test that `suitable?` returned the right thing
@@ -495,43 +494,43 @@ describe Puppet::Provider do
 
   context "execution" do
     before :each do
-      Puppet.expects(:deprecation_warning).never
+      expect(Puppet).not_to receive(:deprecation_warning)
     end
 
     it "delegates instance execute to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execute).with("a_command", { :option => "value" })
+      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
 
       provider.new.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates class execute to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execute).with("a_command", { :option => "value" })
+      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
 
       provider.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates instance execpipe to Puppet::Util::Execution" do
       block = Proc.new { }
-      Puppet::Util::Execution.expects(:execpipe).with("a_command", true, block)
+      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
 
       provider.new.send(:execpipe, "a_command", true, block)
     end
 
     it "delegates class execpipe to Puppet::Util::Execution" do
       block = Proc.new { }
-      Puppet::Util::Execution.expects(:execpipe).with("a_command", true, block)
+      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
 
       provider.send(:execpipe, "a_command", true, block)
     end
 
     it "delegates instance execfail to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execfail).with("a_command", "an exception to raise")
+      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
 
       provider.new.send(:execfail, "a_command", "an exception to raise")
     end
 
     it "delegates class execfail to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execfail).with("a_command", "an exception to raise")
+      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
 
       provider.send(:execfail, "a_command", "an exception to raise")
     end
@@ -755,16 +754,17 @@ describe Puppet::Provider do
 
   def expect_command_executed(name, path, *args)
     command = Puppet::Provider::Command.new(name, path, Puppet::Util, Puppet::Util::Execution)
-    command.expects(:execute).with(*args)
+    args = [no_args] if args.empty?
+    expect(command).to receive(:execute).with(*args)
     command
   end
 
   def allow_creation_of(command, environment = {})
-      Puppet::Provider::Command.stubs(:new).with(command.name, command.executable, Puppet::Util, Puppet::Util::Execution, { :failonfail => true, :combine => true, :custom_environment => environment }).returns(command)
+      allow(Puppet::Provider::Command).to receive(:new).with(command.name, command.executable, Puppet::Util, Puppet::Util::Execution, { :failonfail => true, :combine => true, :custom_environment => environment }).and_return(command)
   end
 
   def file_exists_and_is_executable(path)
-    FileTest.expects(:file?).with(path).returns(true)
-    FileTest.expects(:executable?).with(path).returns(true)
+    expect(FileTest).to receive(:file?).with(path).and_return(true)
+    expect(FileTest).to receive(:executable?).with(path).and_return(true)
   end
 end

data/spec/unit/puppet_pal_2pec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 
@@ -390,8 +389,8 @@ describe 'Puppet Pal' do
       end
 
       {  nil      => Puppet::Error,
-        '0xWAT'   => Puppet::ParseErrorWithIssue, 
-        '$0 = 1'  => Puppet::ParseErrorWithIssue, 
+        '0xWAT'   => Puppet::ParseErrorWithIssue,
+        '$0 = 1'  => Puppet::ParseErrorWithIssue,
         'else 32' => Puppet::ParseErrorWithIssue,
       }.each_pair do |input, error_class|
         it "'parse_string' raises an error for invalid input: '#{input}'" do
@@ -517,7 +516,7 @@ describe 'Puppet Pal' do
 
     # TODO: there is something amiss with the metadata wrt dependencies - when metadata is present there is an error
     #       that dependencies could not be resolved. Metadata is therefore commented out.
-    #       Dependency based visibility is probably something that we should remove... 
+    #       Dependency based visibility is probably something that we should remove...
     let(:modules) {
       {
         'a' => {
@@ -927,7 +926,7 @@ describe 'Puppet Pal' do
         testing_env_dir # creates the structure
         other_modules1 = File.join(environments_dir, 'other_env1/modules')
         other_modules2 = File.join(environments_dir, 'other_env2/modules')
-        result = Puppet::Pal.in_environment('pal_env', envpath: environments_dir, 
+        result = Puppet::Pal.in_environment('pal_env', envpath: environments_dir,
           pre_modulepath: [other_modules1],
           post_modulepath: [other_modules2],
           facts: node_facts

data/spec/unit/puppet_pal_spec.rb

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

data/spec/unit/puppet_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 require 'puppet_spec/files'
@@ -39,8 +38,8 @@ describe Puppet do
   end
 
   it 'should propagate --modulepath to base environment' do
-    Puppet::Node::Environment.expects(:create).with(
-      is_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    expect(Puppet::Node::Environment).to receive(:create).with(
+      be_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -50,8 +49,8 @@ describe Puppet do
   end
 
   it 'empty modulepath does not override basemodulepath' do
-    Puppet::Node::Environment.expects(:create).with(
-      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    expect(Puppet::Node::Environment).to receive(:create).with(
+      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -61,8 +60,8 @@ describe Puppet do
   end
 
   it 'nil modulepath does not override basemodulepath' do
-    Puppet::Node::Environment.expects(:create).with(
-      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    expect(Puppet::Node::Environment).to receive(:create).with(
+      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -87,7 +86,7 @@ describe Puppet do
 
   context "newtype" do
     it "should issue a deprecation warning" do
-      subject.expects(:deprecation_warning).with("Creating sometype via Puppet.newtype is deprecated and will be removed in a future release. Use Puppet::Type.newtype instead.")
+      expect(subject).to receive(:deprecation_warning).with("Creating sometype via Puppet.newtype is deprecated and will be removed in a future release. Use Puppet::Type.newtype instead.")
       subject.newtype("sometype")
     end
   end

data/spec/unit/relationship_spec.rb

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

data/spec/unit/reports/http_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/reports'
 
@@ -8,19 +7,19 @@ describe processor do
   subject { Puppet::Transaction::Report.new.extend(processor) }
 
   describe "when setting up the connection" do
-    let(:http) { stub_everything "http" }
+    let(:http) { double("http") }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
-      http.expects(:post).returns(httpok)
+      expect(http).to receive(:post).and_return(httpok)
     end
 
     it "configures the connection for ssl when using https" do
       Puppet[:reporturl] = 'https://testing:8080/the/path'
 
-      Puppet::Network::HttpPool.expects(:http_instance).with(
+      expect(Puppet::Network::HttpPool).to receive(:http_instance).with(
         'testing', 8080, true
-      ).returns http
+      ).and_return(http)
 
       subject.process
     end
@@ -28,26 +27,26 @@ describe processor do
     it "does not configure the connectino for ssl when using http" do
       Puppet[:reporturl] = "http://testing:8080/the/path"
 
-      Puppet::Network::HttpPool.expects(:http_instance).with(
+      expect(Puppet::Network::HttpPool).to receive(:http_instance).with(
         'testing', 8080, false
-      ).returns http
+      ).and_return(http)
 
       subject.process
     end
   end
 
   describe "when making a request" do
-    let(:connection) { stub_everything "connection" }
+    let(:connection) { double("connection") }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
     let(:options) { {:metric_id => [:puppet, :report, :http]} }
 
     before :each do
-      Puppet::Network::HttpPool.expects(:http_instance).returns(connection)
+      expect(Puppet::Network::HttpPool).to receive(:http_instance).and_return(connection)
     end
 
     it "should use the path specified by the 'reporturl' setting" do
       report_path = URI.parse(Puppet[:reporturl]).path
-      connection.expects(:post).with(report_path, anything, anything, options).returns(httpok)
+      expect(connection).to receive(:post).with(report_path, anything, anything, options).and_return(httpok)
 
       subject.process
     end
@@ -55,24 +54,24 @@ describe processor do
     it "should use the username and password specified by the 'reporturl' setting" do
       Puppet[:reporturl] = "https://user:pass@myhost.mydomain:1234/report/upload"
 
-      connection.expects(:post).with(anything, anything, anything,
-                                     {:metric_id => [:puppet, :report, :http],
-                                      :basic_auth => {
-                                        :user => 'user',
-                                        :password => 'pass'
-                                      }}).returns(httpok)
+      expect(connection).to receive(:post).with(anything, anything, anything,
+                                                {:metric_id => [:puppet, :report, :http],
+                                                 :basic_auth => {
+                                                   :user => 'user',
+                                                   :password => 'pass'
+                                                 }}).and_return(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      connection.expects(:post).with(anything, subject.to_yaml, anything, options).returns(httpok)
+      expect(connection).to receive(:post).with(anything, subject.to_yaml, anything, options).and_return(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), options).returns(httpok)
+      expect(connection).to receive(:post).with(anything, anything, hash_including("Content-Type" => "application/x-yaml"), options).and_return(httpok)
 
       subject.process
     end
@@ -81,9 +80,9 @@ describe processor do
       if code.to_i >= 200 and code.to_i < 300
         it "should succeed on http code #{code}" do
           response = klass.new('1.1', code, '')
-          connection.expects(:post).returns(response)
+          expect(connection).to receive(:post).and_return(response)
 
-          Puppet.expects(:err).never
+          expect(Puppet).not_to receive(:err)
           subject.process
         end
       end
@@ -91,13 +90,12 @@ describe processor do
       if code.to_i >= 300 && ![301, 302, 307].include?(code.to_i)
         it "should log error on http code #{code}" do
           response = klass.new('1.1', code, '')
-          connection.expects(:post).returns(response)
+          expect(connection).to receive(:post).and_return(response)
 
-          Puppet.expects(:err)
+          expect(Puppet).to receive(:err)
           subject.process
         end
       end
     end
-
   end
 end

data/spec/unit/reports/store_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/reports'
@@ -24,7 +23,7 @@ describe processor do
     end
 
     it "should write the report to the file in YAML" do
-      Time.stubs(:now).returns(Time.utc(2011,01,06,12,00,00))
+      allow(Time).to receive(:now).and_return(Time.utc(2011,01,06,12,00,00))
       @report.process
 
       expect(File.read(File.join(Puppet[:reportdir], @report.host, "201101061200.yaml"))).to eq(@report.to_yaml)
@@ -32,14 +31,14 @@ describe processor do
 
     it "rejects invalid hostnames" do
       @report.host = ".."
-      Puppet::FileSystem.expects(:exist?).never
+      expect(Puppet::FileSystem).not_to receive(:exist?)
       expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
     end
   end
 
   describe "::destroy" do
     it "rejects invalid hostnames" do
-      Puppet::FileSystem.expects(:unlink).never
+      expect(Puppet::FileSystem).not_to receive(:unlink)
       expect { processor.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
     end
   end

data/spec/unit/reports_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/reports'
@@ -17,11 +16,11 @@ describe Puppet::Reports do
   end
 
   it "should provide a method for returning documentation for all reports" do
-    Puppet::Reports.expects(:loaded_instances).with(:report).returns([:one, :two])
-    one = mock 'one', :doc => "onedoc"
-    two = mock 'two', :doc => "twodoc"
-    Puppet::Reports.expects(:report).with(:one).returns(one)
-    Puppet::Reports.expects(:report).with(:two).returns(two)
+    expect(Puppet::Reports).to receive(:loaded_instances).with(:report).and_return([:one, :two])
+    one = double('one', :doc => "onedoc")
+    two = double('two', :doc => "twodoc")
+    expect(Puppet::Reports).to receive(:report).with(:one).and_return(one)
+    expect(Puppet::Reports).to receive(:report).with(:two).and_return(two)
 
     doc = Puppet::Reports.reportdocs
     expect(doc.include?("onedoc")).to be_truthy
@@ -29,17 +28,16 @@ describe Puppet::Reports do
   end
 end
 
-
 describe Puppet::Reports, " when loading report types" do
   it "should use the instance loader to retrieve report types" do
-    Puppet::Reports.expects(:loaded_instance).with(:report, :myreporttype)
+    expect(Puppet::Reports).to receive(:loaded_instance).with(:report, :myreporttype)
     Puppet::Reports.report(:myreporttype)
   end
 end
 
 describe Puppet::Reports, " when registering report types" do
   it "should evaluate the supplied block as code for a module" do
-    Puppet::Reports.expects(:genmodule).returns(Module.new)
+    expect(Puppet::Reports).to receive(:genmodule).and_return(Module.new)
     Puppet::Reports.register_report(:testing) { }
   end
 
@@ -54,17 +52,17 @@ describe Puppet::Reports, " when registering report types" do
   end
 
   it "should extend the report type with the Puppet::Util::Docs module" do
-    mod = stub 'module', :define_method => true
+    mod = double('module', :define_method => true)
 
-    Puppet::Reports.expects(:genmodule).with { |name, options, block| options[:extend] == Puppet::Util::Docs }.returns(mod)
+    expect(Puppet::Reports).to receive(:genmodule).with(anything, hash_including(extend: Puppet::Util::Docs)).and_return(mod)
     Puppet::Reports.register_report(:testing) { }
   end
 
   it "should define a :report_name method in the module that returns the name of the report" do
-    mod = mock 'module'
-    mod.expects(:define_method).with(:report_name)
+    mod = double('module')
+    expect(mod).to receive(:define_method).with(:report_name)
 
-    Puppet::Reports.expects(:genmodule).returns(mod)
+    expect(Puppet::Reports).to receive(:genmodule).and_return(mod)
     Puppet::Reports.register_report(:testing) { }
   end
 end