puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/unit/util/posix_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/posix'
@@ -11,38 +12,6 @@ describe Puppet::Util::POSIX do
     @posix = PosixTest.new
   end
 
-  describe '.groups_of' do
-    let(:mock_groups) do
-      [
-        ['group1', ['user1', 'user2']],
-        ['group2', ['user2']],
-        ['group1', ['user1', 'user2']],
-        ['group3', ['user1']],
-        ['group4', ['user2']]
-      ].map do |(name, members)|
-        group_struct = double("Group #{name}")
-        allow(group_struct).to receive(:name).and_return(name)
-        allow(group_struct).to receive(:mem).and_return(members)
-
-        group_struct
-      end
-    end
-
-    before(:each) do
-      etc_stub = receive(:group)
-      mock_groups.each do |mock_group|
-        etc_stub = etc_stub.and_yield(mock_group)
-      end
-      allow(Puppet::Etc).to etc_stub
-    end
-
-    it 'returns the groups of the given user' do
-      expect(Puppet::Util::POSIX.groups_of('user1')).to eql(
-        ['group1', 'group3']
-      )
-    end
-  end
-
   [:group, :gr].each do |name|
     it "should return :gid as the field for #{name}" do
       expect(@posix.idfield(name)).to eq(:gid)
@@ -73,7 +42,7 @@ describe Puppet::Util::POSIX do
 
   describe "when retrieving a posix field" do
     before do
-      @thing = double('thing', :field => "asdf")
+      @thing = stub 'thing', :field => "asdf"
     end
 
     it "should fail if no id was passed" do
@@ -83,23 +52,23 @@ describe Puppet::Util::POSIX do
     describe "and the id is an integer" do
       it "should log an error and return nil if the specified id is greater than the maximum allowed ID" do
         Puppet[:maximum_uid] = 100
-        expect(Puppet).to receive(:err)
+        Puppet.expects(:err)
 
         expect(@posix.get_posix_field("asdf", "bar", 200)).to be_nil
       end
 
       it "should use the method return by :methodbyid and return the specified field" do
-        expect(Etc).to receive(:getgrgid).and_return(@thing)
+        Etc.expects(:getgrgid).returns @thing
 
-        expect(@thing).to receive(:field).and_return("myval")
+        @thing.expects(:field).returns "myval"
 
         expect(@posix.get_posix_field(:gr, :field, 200)).to eq("myval")
       end
 
       it "should return nil if the method throws an exception" do
-        expect(Etc).to receive(:getgrgid).and_raise(ArgumentError)
+        Etc.expects(:getgrgid).raises ArgumentError
 
-        expect(@thing).not_to receive(:field)
+        @thing.expects(:field).never
 
         expect(@posix.get_posix_field(:gr, :field, 200)).to be_nil
       end
@@ -107,17 +76,17 @@ describe Puppet::Util::POSIX do
 
     describe "and the id is not an integer" do
       it "should use the method return by :methodbyid and return the specified field" do
-        expect(Etc).to receive(:getgrnam).and_return(@thing)
+        Etc.expects(:getgrnam).returns @thing
 
-        expect(@thing).to receive(:field).and_return("myval")
+        @thing.expects(:field).returns "myval"
 
         expect(@posix.get_posix_field(:gr, :field, "asdf")).to eq("myval")
       end
 
       it "should return nil if the method throws an exception" do
-        expect(Etc).to receive(:getgrnam).and_raise(ArgumentError)
+        Etc.expects(:getgrnam).raises ArgumentError
 
-        expect(@thing).not_to receive(:field)
+        @thing.expects(:field).never
 
         expect(@posix.get_posix_field(:gr, :field, "asdf")).to be_nil
       end
@@ -126,32 +95,32 @@ describe Puppet::Util::POSIX do
 
   describe "when returning the gid" do
     before do
-      allow(@posix).to receive(:get_posix_field)
+      @posix.stubs(:get_posix_field)
     end
 
     describe "and the group is an integer" do
       it "should convert integers specified as a string into an integer" do
-        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100)
+        @posix.expects(:get_posix_field).with(:group, :name, 100)
 
         @posix.gid("100")
       end
 
       it "should look up the name for the group" do
-        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100)
+        @posix.expects(:get_posix_field).with(:group, :name, 100)
 
         @posix.gid(100)
       end
 
       it "should return nil if the group cannot be found" do
-        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
-        expect(@posix).not_to receive(:search_posix_field)
+        @posix.expects(:get_posix_field).once.returns nil
+        @posix.expects(:search_posix_field).never
 
         expect(@posix.gid(100)).to be_nil
       end
 
       it "should use the found name to look up the id" do
-        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("asdf")
-        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(100)
+        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
+        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
 
         expect(@posix.gid(100)).to eq(100)
       end
@@ -159,10 +128,10 @@ describe Puppet::Util::POSIX do
       # LAK: This is because some platforms have a broken Etc module that always return
       # the same group.
       it "should use :search_posix_field if the discovered id does not match the passed-in id" do
-        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("asdf")
-        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(50)
+        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
+        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 50
 
-        expect(@posix).to receive(:search_posix_field).with(:group, :gid, 100).and_return("asdf")
+        @posix.expects(:search_posix_field).with(:group, :gid, 100).returns "asdf"
 
         expect(@posix.gid(100)).to eq("asdf")
       end
@@ -170,30 +139,30 @@ describe Puppet::Util::POSIX do
 
     describe "and the group is a string" do
       it "should look up the gid for the group" do
-        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf")
+        @posix.expects(:get_posix_field).with(:group, :gid, "asdf")
 
         @posix.gid("asdf")
       end
 
       it "should return nil if the group cannot be found" do
-        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
-        expect(@posix).not_to receive(:search_posix_field)
+        @posix.expects(:get_posix_field).once.returns nil
+        @posix.expects(:search_posix_field).never
 
         expect(@posix.gid("asdf")).to be_nil
       end
 
       it "should use the found gid to look up the nam" do
-        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(100)
-        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("asdf")
+        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
+        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "asdf"
 
         expect(@posix.gid("asdf")).to eq(100)
       end
 
       it "should use :search_posix_field if the discovered name does not match the passed-in name" do
-        expect(@posix).to receive(:get_posix_field).with(:group, :gid, "asdf").and_return(100)
-        expect(@posix).to receive(:get_posix_field).with(:group, :name, 100).and_return("boo")
+        @posix.expects(:get_posix_field).with(:group, :gid, "asdf").returns 100
+        @posix.expects(:get_posix_field).with(:group, :name, 100).returns "boo"
 
-        expect(@posix).to receive(:search_posix_field).with(:group, :gid, "asdf").and_return("asdf")
+        @posix.expects(:search_posix_field).with(:group, :gid, "asdf").returns "asdf"
 
         expect(@posix.gid("asdf")).to eq("asdf")
       end
@@ -202,32 +171,32 @@ describe Puppet::Util::POSIX do
 
   describe "when returning the uid" do
     before do
-      allow(@posix).to receive(:get_posix_field)
+      @posix.stubs(:get_posix_field)
     end
 
     describe "and the group is an integer" do
       it "should convert integers specified as a string into an integer" do
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100)
+        @posix.expects(:get_posix_field).with(:passwd, :name, 100)
 
         @posix.uid("100")
       end
 
       it "should look up the name for the group" do
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100)
+        @posix.expects(:get_posix_field).with(:passwd, :name, 100)
 
         @posix.uid(100)
       end
 
       it "should return nil if the group cannot be found" do
-        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
-        expect(@posix).not_to receive(:search_posix_field)
+        @posix.expects(:get_posix_field).once.returns nil
+        @posix.expects(:search_posix_field).never
 
         expect(@posix.uid(100)).to be_nil
       end
 
       it "should use the found name to look up the id" do
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("asdf")
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(100)
+        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
+        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
 
         expect(@posix.uid(100)).to eq(100)
       end
@@ -235,10 +204,10 @@ describe Puppet::Util::POSIX do
       # LAK: This is because some platforms have a broken Etc module that always return
       # the same group.
       it "should use :search_posix_field if the discovered id does not match the passed-in id" do
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("asdf")
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(50)
+        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
+        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 50
 
-        expect(@posix).to receive(:search_posix_field).with(:passwd, :uid, 100).and_return("asdf")
+        @posix.expects(:search_posix_field).with(:passwd, :uid, 100).returns "asdf"
 
         expect(@posix.uid(100)).to eq("asdf")
       end
@@ -246,30 +215,30 @@ describe Puppet::Util::POSIX do
 
     describe "and the group is a string" do
       it "should look up the uid for the group" do
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf")
+        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf")
 
         @posix.uid("asdf")
       end
 
       it "should return nil if the group cannot be found" do
-        expect(@posix).to receive(:get_posix_field).once.and_return(nil)
-        expect(@posix).not_to receive(:search_posix_field)
+        @posix.expects(:get_posix_field).once.returns nil
+        @posix.expects(:search_posix_field).never
 
         expect(@posix.uid("asdf")).to be_nil
       end
 
       it "should use the found uid to look up the nam" do
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(100)
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("asdf")
+        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
+        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "asdf"
 
         expect(@posix.uid("asdf")).to eq(100)
       end
 
       it "should use :search_posix_field if the discovered name does not match the passed-in name" do
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :uid, "asdf").and_return(100)
-        expect(@posix).to receive(:get_posix_field).with(:passwd, :name, 100).and_return("boo")
+        @posix.expects(:get_posix_field).with(:passwd, :uid, "asdf").returns 100
+        @posix.expects(:get_posix_field).with(:passwd, :name, 100).returns "boo"
 
-        expect(@posix).to receive(:search_posix_field).with(:passwd, :uid, "asdf").and_return("asdf")
+        @posix.expects(:search_posix_field).with(:passwd, :uid, "asdf").returns "asdf"
 
         expect(@posix.uid("asdf")).to eq("asdf")
       end

data/spec/unit/util/profiler/object_counts_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require 'puppet/util/profiler'
 
-describe Puppet::Util::Profiler::ObjectCounts do
+describe Puppet::Util::Profiler::ObjectCounts, unless: Puppet::Util::Platform.jruby? do
+  # ObjectSpace is not enabled by default on JRuby
   it "reports the changes in the system object counts" do
     profiler = Puppet::Util::Profiler::ObjectCounts.new(nil, nil)
 

data/spec/unit/util/rdoc_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/rdoc'
@@ -6,48 +7,48 @@ require 'rdoc/rdoc'
 describe Puppet::Util::RDoc do
   describe "when generating RDoc HTML documentation" do
     before :each do
-      @rdoc = double('rdoc')
-      allow(RDoc::RDoc).to receive(:new).and_return(@rdoc)
+      @rdoc = stub_everything 'rdoc'
+      RDoc::RDoc.stubs(:new).returns(@rdoc)
     end
 
     it "should tell RDoc to generate documentation using the Puppet generator" do
-      expect(@rdoc).to receive(:document).with(include("--fmt").and(include("puppet")))
+      @rdoc.expects(:document).with { |args| args.include?("--fmt") and args.include?("puppet") }
 
       Puppet::Util::RDoc.rdoc("output", [])
     end
 
     it "should tell RDoc to be quiet" do
-      expect(@rdoc).to receive(:document).with(include("--quiet"))
+      @rdoc.expects(:document).with { |args| args.include?("--quiet") }
 
       Puppet::Util::RDoc.rdoc("output", [])
     end
 
     it "should pass charset to RDoc" do
-      expect(@rdoc).to receive(:document).with(include("--charset").and(include("utf-8")))
+      @rdoc.expects(:document).with { |args| args.include?("--charset") and args.include?("utf-8") }
 
       Puppet::Util::RDoc.rdoc("output", [], "utf-8")
     end
 
     it "should tell RDoc to use the given outputdir" do
-      expect(@rdoc).to receive(:document).with(include("--op").and(include("myoutputdir")))
+      @rdoc.expects(:document).with { |args| args.include?("--op") and args.include?("myoutputdir") }
 
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end
 
     it "should tell RDoc to exclude all files under any modules/<mod>/files section" do
-      expect(@rdoc).to receive(:document).with(include("--exclude").and(include("/modules/[^/]*/files/.*$")))
+      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/files/.*$") }
 
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end
 
     it "should tell RDoc to exclude all files under any modules/<mod>/templates section" do
-      expect(@rdoc).to receive(:document).with(include("--exclude").and(include("/modules/[^/]*/templates/.*$")))
+      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/templates/.*$") }
 
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end
 
     it "should give all the source directories to RDoc" do
-      expect(@rdoc).to receive(:document).with(include("sourcedir"))
+      @rdoc.expects(:document).with { |args| args.include?("sourcedir") }
 
       Puppet::Util::RDoc.rdoc("output", ["sourcedir"])
     end

data/spec/unit/util/reference_spec.rb

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

data/spec/unit/util/resource_template_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/resource_template'
@@ -5,52 +6,51 @@ require 'puppet/util/resource_template'
 describe Puppet::Util::ResourceTemplate do
   describe "when initializing" do
     it "should fail if the template does not exist" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/template").and_return(false)
-      expect { Puppet::Util::ResourceTemplate.new("/my/template", double('resource')) }.to raise_error(ArgumentError)
+      Puppet::FileSystem.expects(:exist?).with("/my/template").returns false
+      expect { Puppet::Util::ResourceTemplate.new("/my/template", mock('resource')) }.to raise_error(ArgumentError)
     end
 
     it "should not create the ERB template" do
-      expect(ERB).not_to receive(:new)
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/template").and_return(true)
-      Puppet::Util::ResourceTemplate.new("/my/template", double('resource'))
+      ERB.expects(:new).never
+      Puppet::FileSystem.expects(:exist?).with("/my/template").returns true
+      Puppet::Util::ResourceTemplate.new("/my/template", mock('resource'))
     end
   end
 
   describe "when evaluating" do
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Puppet::FileSystem).to receive(:read).and_return("eh")
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Puppet::FileSystem.stubs(:read).returns "eh"
 
-      @template = double('template', :result => nil)
-      allow(ERB).to receive(:new).and_return(@template)
+      @template = stub 'template', :result => nil
+      ERB.stubs(:new).returns @template
 
-      @resource = double('resource')
+      @resource = mock 'resource'
       @wrapper = Puppet::Util::ResourceTemplate.new("/my/template", @resource)
     end
 
     it "should set all of the resource's parameters as instance variables" do
-      expect(@resource).to receive(:to_hash).and_return(:one => "uno", :two => "dos")
-      expect(@template).to receive(:result) do |bind|
-        expect(eval("@one", bind)).to eq("uno")
-        expect(eval("@two", bind)).to eq("dos")
+      @resource.expects(:to_hash).returns(:one => "uno", :two => "dos")
+      @template.expects(:result).with do |bind|
+        eval("@one", bind) == "uno" and eval("@two", bind) == "dos"
       end
       @wrapper.evaluate
     end
 
     it "should create a template instance with the contents of the file" do
-      expect(Puppet::FileSystem).to receive(:read).with("/my/template", :encoding => 'utf-8').and_return("yay")
-      expect(ERB).to receive(:new).with("yay", 0, "-").and_return(@template)
+      Puppet::FileSystem.expects(:read).with("/my/template", :encoding => 'utf-8').returns "yay"
+      ERB.expects(:new).with("yay", 0, "-").returns(@template)
 
-      allow(@wrapper).to receive(:set_resource_variables)
+      @wrapper.stubs :set_resource_variables
 
       @wrapper.evaluate
     end
 
     it "should return the result of the template" do
-      allow(@wrapper).to receive(:set_resource_variables)
+      @wrapper.stubs :set_resource_variables
 
-      expect(@wrapper).to receive(:binding).and_return("mybinding")
-      expect(@template).to receive(:result).with("mybinding").and_return("myresult")
+      @wrapper.expects(:binding).returns "mybinding"
+      @template.expects(:result).with("mybinding").returns "myresult"
       expect(@wrapper.evaluate).to eq("myresult")
     end
   end

data/spec/unit/util/retry_action_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/retry_action'
@@ -22,8 +23,8 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should retry on any exception if no acceptable exceptions given' do
-    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 1) -1) * 0.1) )
-    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 2) -1) * 0.1) )
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 1) -1) * 0.1) )
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 2) -1) * 0.1) )
 
     expect do
       Puppet::Util::RetryAction.retry_action( :retries => 2 ) do
@@ -33,8 +34,8 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should retry on acceptable exceptions' do
-    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 1) -1) * 0.1) )
-    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 2) -1) * 0.1) )
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 1) -1) * 0.1) )
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 2) -1) * 0.1) )
 
     expect do
       Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
@@ -44,7 +45,7 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should not retry on unacceptable exceptions' do
-    expect(Puppet::Util::RetryAction).not_to receive(:sleep)
+    Puppet::Util::RetryAction.expects(:sleep).never
 
     expect do
       Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
@@ -54,7 +55,7 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should succeed if nothing is raised' do
-    expect(Puppet::Util::RetryAction).not_to receive(:sleep)
+    Puppet::Util::RetryAction.expects(:sleep).never
 
     Puppet::Util::RetryAction.retry_action( :retries => 2) do
       true
@@ -63,7 +64,7 @@ describe Puppet::Util::RetryAction do
 
   it 'should succeed if an expected exception is raised retried and succeeds' do
     should_retry = nil
-    expect(Puppet::Util::RetryAction).to receive(:sleep).once
+    Puppet::Util::RetryAction.expects(:sleep).once
 
     Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
       if should_retry