puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/type/file/content_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true do
@@ -11,7 +12,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
 
   before do
     File.open(filename, 'w') {|f| f.write "initial file content"}
-    allow(described_class).to receive(:standalone?).and_return(false)
+    described_class.stubs(:standalone?).returns(false)
   end
 
   around do |example|
@@ -29,7 +30,9 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     end
 
     it "should not use the content from the source if the source is set" do
-      expect(resource).not_to receive(:parameter).with(:source)
+      source = mock 'source'
+
+      resource.expects(:parameter).never.with(:source).returns source
 
       expect(content.actual_content).to be_nil
     end
@@ -39,8 +42,8 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     let(:content) { described_class.new(:resource => resource) }
 
     before do
-      allow_any_instance_of(Puppet::Type.type(:file)).to receive(:file).and_return('my/file.pp')
-      allow_any_instance_of(Puppet::Type.type(:file)).to receive(:line).and_return(5)
+      Puppet::Type.type(:file).any_instance.stubs(:file).returns('my/file.pp')
+      Puppet::Type.type(:file).any_instance.stubs(:line).returns 5
     end
 
     it "should make the actual content available via an attribute" do
@@ -85,21 +88,21 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     let(:content) { described_class.new(:resource => resource) }
 
     it "should return :absent if the file does not exist" do
-      expect(resource).to receive(:stat).and_return(nil)
+      resource.expects(:stat).returns nil
 
       expect(content.retrieve).to eq(:absent)
     end
 
     it "should not manage content on directories" do
-      stat = double('stat', :ftype => "directory")
-      expect(resource).to receive(:stat).and_return(stat)
+      stat = mock 'stat', :ftype => "directory"
+      resource.expects(:stat).returns stat
 
       expect(content.retrieve).to be_nil
     end
 
     it "should not manage content on links" do
-      stat = double('stat', :ftype => "link")
-      expect(resource).to receive(:stat).and_return(stat)
+      stat = mock 'stat', :ftype => "link"
+      resource.expects(:stat).returns stat
 
       expect(content.retrieve).to be_nil
     end
@@ -107,20 +110,20 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     it "should always return the checksum as a string" do
       resource[:checksum] = :mtime
 
-      stat = double('stat', :ftype => "file")
-      expect(resource).to receive(:stat).and_return(stat)
+      stat = mock 'stat', :ftype => "file"
+      resource.expects(:stat).returns stat
 
       time = Time.now
-      expect(resource.parameter(:checksum)).to receive(:mtime_file).with(resource[:path]).and_return(time)
+      resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
 
       expect(content.retrieve).to eq("{mtime}#{time}")
     end
 
     with_digest_algorithms do
       it "should return the checksum of the file if it exists and is a normal file" do
-        stat = double('stat', :ftype => "file")
-        expect(resource).to receive(:stat).and_return(stat)
-        expect(resource.parameter(:checksum)).to receive("#{digest_algorithm}_file".intern).with(resource[:path]).and_return("mysum")
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
+        resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
 
         expect(content.retrieve).to eq("{#{digest_algorithm}}mysum")
       end
@@ -140,7 +143,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       end
 
       it "should return true if the resource shouldn't be a regular file" do
-        expect(resource).to receive(:should_be_file?).and_return(false)
+        resource.expects(:should_be_file?).returns false
         content.should = "foo"
         expect(content).to be_safe_insync("whatever")
       end
@@ -148,10 +151,10 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       it "should warn that no content will be synced to links when ensure is :present" do
         resource[:ensure] = :present
         resource[:content] = 'foo'
-        allow(resource).to receive(:should_be_file?).and_return(false)
-        allow(resource).to receive(:stat).and_return(double("stat", :ftype => "link"))
+        resource.stubs(:should_be_file?).returns false
+        resource.stubs(:stat).returns mock("stat", :ftype => "link")
 
-        expect(resource).to receive(:warning).with(/Ensure set to :present but file type is/)
+        resource.expects(:warning).with {|msg| msg =~ /Ensure set to :present but file type is/}
 
         content.insync? :present
       end
@@ -162,7 +165,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       end
 
       it "should return false if the file should be a file but is not present" do
-        expect(resource).to receive(:should_be_file?).and_return(true)
+        resource.expects(:should_be_file?).returns true
         content.should = "foo"
 
         expect(content).not_to be_safe_insync(:absent)
@@ -170,7 +173,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
 
       describe "and the file exists" do
         before do
-          allow(resource).to receive(:stat).and_return(double("stat"))
+          resource.stubs(:stat).returns mock("stat")
           content.should = "some content"
         end
 
@@ -188,27 +191,27 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
 
         describe "showing the diff" do
           it "doesn't show the diff when #show_diff? is false" do
-            expect(content).to receive(:show_diff?).and_return(false)
-            expect(content).not_to receive(:diff)
+            content.expects(:show_diff?).returns false
+            content.expects(:diff).never
             expect(content).not_to be_safe_insync("other content")
           end
 
           describe "and #show_diff? is true" do
             before do
-              expect(content).to receive(:show_diff?).and_return(true)
+              content.expects(:show_diff?).returns true
               resource[:loglevel] = "debug"
             end
 
             it "prints the diff" do
-              expect(content).to receive(:diff).and_return("my diff").once
-              expect(content).to receive(:debug).with("\nmy diff").once
+              content.expects(:diff).returns("my diff").once
+              content.expects(:debug).with("\nmy diff").once
               expect(content).not_to be_safe_insync("other content")
             end
 
             it "redacts the diff when the property is sensitive" do
               content.sensitive = true
-              expect(content).not_to receive(:diff)
-              expect(content).to receive(:debug).with("[diff redacted]").once
+              content.expects(:diff).returns("my diff").never
+              content.expects(:debug).with("[diff redacted]").once
               expect(content).not_to be_safe_insync("other content")
             end
           end
@@ -263,10 +266,10 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
         it "should warn that no content will be synced to links when ensure is :present" do
           resource[:ensure] = :present
           resource[:content] = 'foo'
-          allow(resource).to receive(:should_be_file?).and_return(false)
-          allow(resource).to receive(:stat).and_return(double("stat", :ftype => "link"))
+          resource.stubs(:should_be_file?).returns false
+          resource.stubs(:stat).returns mock("stat", :ftype => "link")
 
-          expect(resource).to receive(:warning).with(/Ensure set to :present but file type is/)
+          resource.expects(:warning).with {|msg| msg =~ /Ensure set to :present but file type is/}
 
           content.insync? :present
         end
@@ -275,17 +278,17 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
 
     describe "and :replace is false" do
       before do
-        allow(resource).to receive(:replace?).and_return(false)
+        resource.stubs(:replace?).returns false
       end
 
       it "should be insync if the file exists and the content is different" do
-        allow(resource).to receive(:stat).and_return(double('stat'))
+        resource.stubs(:stat).returns mock('stat')
 
         expect(content).to be_safe_insync("whatever")
       end
 
       it "should be insync if the file exists and the content is right" do
-        allow(resource).to receive(:stat).and_return(double('stat'))
+        resource.stubs(:stat).returns mock('stat')
 
         expect(content).to be_safe_insync("something")
       end
@@ -303,7 +306,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
         before do
           @new_resource = Puppet::Type.type(:file).new :ensure => :file, :path => filename, :catalog => catalog,
             :content => CHECKSUM_PLAINTEXT, :checksum => checksum_type
-          allow(@new_resource).to receive(:stat).and_return(double('stat'))
+          @new_resource.stubs(:stat).returns mock('stat')
         end
 
         it "should return false if the sum for the current contents are different from the desired content" do
@@ -348,25 +351,25 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     let(:content) { described_class.new(:resource => resource) }
 
     before do
-      allow(resource).to receive(:[]).with(:path).and_return("/boo")
-      allow(resource).to receive(:stat).and_return("eh")
+      resource.stubs(:[]).with(:path).returns "/boo"
+      resource.stubs(:stat).returns "eh"
     end
 
     it "should use the file's :write method to write the content" do
-      expect(resource).to receive(:write).with(content)
+      resource.expects(:write).with(content)
 
       content.sync
     end
 
     it "should return :file_changed if the file already existed" do
-      expect(resource).to receive(:stat).and_return("something")
-      allow(resource).to receive(:write)
+      resource.expects(:stat).returns "something"
+      resource.stubs(:write)
       expect(content.sync).to eq(:file_changed)
     end
 
     it "should return :file_created if the file did not exist" do
-      expect(resource).to receive(:stat).and_return(nil)
-      allow(resource).to receive(:write)
+      resource.expects(:stat).returns nil
+      resource.stubs(:write)
       expect(content.sync).to eq(:file_created)
     end
   end
@@ -377,30 +380,30 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     let(:fh) { File.open(filename, 'wb') }
 
     before do
-      allow_any_instance_of(Puppet::Type.type(:file)).to receive(:file).and_return('my/file.pp')
-      allow_any_instance_of(Puppet::Type.type(:file)).to receive(:line).and_return(5)
+      Puppet::Type.type(:file).any_instance.stubs(:file).returns('my/file.pp')
+      Puppet::Type.type(:file).any_instance.stubs(:line).returns 5
     end
 
     it "should attempt to read from the filebucket if no actual content nor source exists" do
       content.should = "{md5}foo"
-      allow_any_instance_of(content.resource.bucket.class).to receive(:getfile).and_return("foo")
+      content.resource.bucket.class.any_instance.stubs(:getfile).returns "foo"
       content.write(fh)
       fh.close
     end
 
     describe "from actual content" do
       before(:each) do
-        allow(content).to receive(:actual_content).and_return("this is content")
+        content.stubs(:actual_content).returns("this is content")
       end
 
       it "should write to the given file handle" do
-        fh = double('filehandle')
-        expect(fh).to receive(:print).with("this is content")
+        fh = mock 'filehandle'
+        fh.expects(:print).with("this is content")
         content.write(fh)
       end
 
       it "should return the current checksum value" do
-        expect(resource.parameter(:checksum)).to receive(:sum_stream).and_return("checksum")
+        resource.parameter(:checksum).expects(:sum_stream).returns "checksum"
         expect(content.write(fh)).to eq("checksum")
       end
     end
@@ -408,26 +411,26 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     describe "from a file bucket" do
       it "should fail if a file bucket cannot be retrieved" do
         content.should = "{md5}foo"
-        expect(content.resource).to receive(:bucket).and_return(nil)
+        content.resource.expects(:bucket).returns nil
         expect { content.write(fh) }.to raise_error(Puppet::Error)
       end
 
       it "should fail if the file bucket cannot find any content" do
         content.should = "{md5}foo"
-        bucket = double('bucket')
-        expect(content.resource).to receive(:bucket).and_return(bucket)
-        expect(bucket).to receive(:getfile).with("foo").and_raise("foobar")
+        bucket = stub 'bucket'
+        content.resource.expects(:bucket).returns bucket
+        bucket.expects(:getfile).with("foo").raises "foobar"
         expect { content.write(fh) }.to raise_error(Puppet::Error)
       end
 
       it "should write the returned content to the file" do
         content.should = "{md5}foo"
-        bucket = double('bucket')
-        expect(content.resource).to receive(:bucket).and_return(bucket)
-        expect(bucket).to receive(:getfile).with("foo").and_return("mycontent")
+        bucket = stub 'bucket'
+        content.resource.expects(:bucket).returns bucket
+        bucket.expects(:getfile).with("foo").returns "mycontent"
 
-        fh = double('filehandle')
-        expect(fh).to receive(:print).with("mycontent")
+        fh = mock 'filehandle'
+        fh.expects(:print).with("mycontent")
         content.write(fh)
       end
     end

data/spec/unit/type/file/ctime_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:ctime) do

data/spec/unit/type/file/ensure_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/type/file/ensure'
 
@@ -14,14 +15,14 @@ describe Puppet::Type::File::Ensure do
 
   describe "when retrieving the current state" do
     it "should return :absent if the file does not exist" do
-      expect(resource).to receive(:stat).and_return(nil)
+      resource.expects(:stat).returns nil
 
       expect(property.retrieve).to eq(:absent)
     end
 
     it "should return the current file type if the file exists" do
-      stat = double('stat', :ftype => "directory")
-      expect(resource).to receive(:stat).and_return(stat)
+      stat = mock 'stat', :ftype => "directory"
+      resource.expects(:stat).returns stat
 
       expect(property.retrieve).to eq(:directory)
     end
@@ -30,7 +31,7 @@ describe Puppet::Type::File::Ensure do
   describe "when testing whether :ensure is in sync" do
     it "should always be in sync if replace is 'false' unless the file is missing" do
       property.should = :file
-      expect(resource).to receive(:replace?).and_return(false)
+      resource.expects(:replace?).returns false
       expect(property.safe_insync?(:link)).to be_truthy
     end
 
@@ -88,32 +89,32 @@ describe Puppet::Type::File::Ensure do
 
       it "should accept octal mode as fixnum" do
         resource[:mode] = '0700'
-        expect(resource).to receive(:property_fix)
-        expect(Dir).to receive(:mkdir).with(path, 0700)
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0700)
 
         property.sync
       end
 
       it "should accept octal mode as string" do
         resource[:mode] = "700"
-        expect(resource).to receive(:property_fix)
-        expect(Dir).to receive(:mkdir).with(path, 0700)
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0700)
 
         property.sync
       end
 
       it "should accept octal mode as string with leading zero" do
         resource[:mode] = "0700"
-        expect(resource).to receive(:property_fix)
-        expect(Dir).to receive(:mkdir).with(path, 0700)
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0700)
 
         property.sync
       end
 
       it "should accept symbolic mode" do
         resource[:mode] = "u=rwx,go=x"
-        expect(resource).to receive(:property_fix)
-        expect(Dir).to receive(:mkdir).with(path, 0711)
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0711)
 
         property.sync
       end

data/spec/unit/type/file/group_spec.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:group) do
@@ -17,12 +19,12 @@ describe Puppet::Type.type(:file).attrclass(:group) do
     before :each do
       resource[:group] = ['foos', 'bars']
 
-      allow(resource.provider).to receive(:name2gid).with('foos').and_return(1001)
-      allow(resource.provider).to receive(:name2gid).with('bars').and_return(1002)
+      resource.provider.stubs(:name2gid).with('foos').returns 1001
+      resource.provider.stubs(:name2gid).with('bars').returns 1002
     end
 
     it "should fail if a group's id can't be found by name" do
-      allow(resource.provider).to receive(:name2gid).and_return(nil)
+      resource.provider.stubs(:name2gid).returns nil
 
       expect { group.insync?(5) }.to raise_error(/Could not find group foos/)
     end
@@ -43,13 +45,13 @@ describe Puppet::Type.type(:file).attrclass(:group) do
   %w[is_to_s should_to_s].each do |prop_to_s|
     describe "##{prop_to_s}" do
       it "should use the name of the user if it can find it" do
-        allow(resource.provider).to receive(:gid2name).with(1001).and_return('foos')
+        resource.provider.stubs(:gid2name).with(1001).returns 'foos'
 
         expect(group.send(prop_to_s, 1001)).to eq("'foos'")
       end
 
       it "should use the id of the user if it can't" do
-        allow(resource.provider).to receive(:gid2name).with(1001).and_return(nil)
+        resource.provider.stubs(:gid2name).with(1001).returns nil
 
         expect(group.send(prop_to_s, 1001)).to eq('1001')
       end

data/spec/unit/type/file/mode_spec.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:mode) do
@@ -119,8 +121,8 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
     it "should retrieve the directory mode from the provider" do
       Dir.mkdir(path)
 
-      expect(mode).to receive(:dirmask).with('644').and_return('755')
-      expect(resource.provider).to receive(:mode).and_return('755')
+      mode.expects(:dirmask).with('644').returns '755'
+      resource.provider.expects(:mode).returns '755'
 
       expect(mode.retrieve).to eq('755')
     end
@@ -128,8 +130,8 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
     it "should retrieve the file mode from the provider" do
       FileUtils.touch(path)
 
-      expect(mode).to receive(:dirmask).with('644').and_return('644')
-      expect(resource.provider).to receive(:mode).and_return('644')
+      mode.expects(:dirmask).with('644').returns '644'
+      resource.provider.expects(:mode).returns '644'
 
       expect(mode.retrieve).to eq('644')
     end