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

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums => true do
@@ -18,7 +19,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
     let(:checksum_value) { described_class.new(:resource => resource) }
 
     it "should not compute a checksum if source is absent" do
-      expect(resource).not_to receive(:stat)
+      resource.expects(:stat).never
       expect(checksum_value.retrieve).to be_nil
     end
 
@@ -28,21 +29,21 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       end
 
       it "should return :absent if the target does not exist" do
-        expect(resource).to receive(:stat).and_return(nil)
+        resource.expects(:stat).returns nil
 
         expect(checksum_value.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(checksum_value.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(checksum_value.retrieve).to be_nil
       end
@@ -50,11 +51,11 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       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(checksum_value.retrieve).to eq(time.to_s)
       end
@@ -62,9 +63,9 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
     with_digest_algorithms do
       it "should return the checksum of the target 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"
         resource[:source] = source_file
 
         expect(checksum_value.retrieve).to eq("mysum")
@@ -95,7 +96,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         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
           checksum_value.should = "foo"
           expect(checksum_value).to be_safe_insync("whatever")
         end
@@ -106,7 +107,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         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
           checksum_value.should = "foo"
 
           expect(checksum_value).not_to be_safe_insync(:absent)
@@ -114,7 +115,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
         describe "and the file exists" do
           before do
-            allow(resource).to receive(:stat).and_return(double("stat"))
+            resource.stubs(:stat).returns mock("stat")
             checksum_value.should = "somechecksum"
           end
 
@@ -134,19 +135,19 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
             describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
               before do
                 Puppet[:show_diff] = cfg
-                allow(resource).to receive(:show_diff?).and_return(param)
+                resource.stubs(:show_diff?).returns param
                 resource[:loglevel] = "debug"
               end
 
               if cfg and param
                 it "should display a diff" do
-                  expect(checksum_value).to receive(:diff).and_return("my diff").once
-                  expect(checksum_value).to receive(:debug).with("\nmy diff").once
+                  checksum_value.expects(:diff).returns("my diff").once
+                  checksum_value.expects(:debug).with("\nmy diff").once
                   expect(checksum_value).not_to be_safe_insync("otherchecksum")
                 end
               else
                 it "should not display a diff" do
-                  expect(checksum_value).not_to receive(:diff)
+                  checksum_value.expects(:diff).never
                   expect(checksum_value).not_to be_safe_insync("otherchecksum")
                 end
               end
@@ -201,17 +202,17 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
       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 checksum_value is different" do
-          allow(resource).to receive(:stat).and_return(double('stat'))
+          resource.stubs(:stat).returns mock('stat')
 
           expect(checksum_value).to be_safe_insync("whatever")
         end
 
         it "should be insync if the file exists and the checksum_value is right" do
-          allow(resource).to receive(:stat).and_return(double('stat'))
+          resource.stubs(:stat).returns mock('stat')
 
           expect(checksum_value).to be_safe_insync("something")
         end
@@ -230,7 +231,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         before do
           @new_resource = Puppet::Type.type(:file).new :ensure => :file, :path => path, :catalog => catalog,
             :checksum_value => checksum, :checksum => checksum_type, :source => source_file
-          allow(@new_resource).to receive(:stat).and_return(double('stat'))
+          @new_resource.stubs(:stat).returns mock('stat')
         end
 
         it "should return false if the current checksum_value is different from the desired checksum_value" do
@@ -248,12 +249,12 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
     let(:checksum_value) { 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 raise if source is absent" do
-      expect(resource).not_to receive(:write)
+      resource.expects(:write).never
 
       expect { checksum_value.sync }.to raise_error "checksum_value#sync should not be called without a source parameter"
     end
@@ -264,20 +265,20 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       end
 
       it "should use the file's :write method to write the checksum_value" do
-        expect(resource).to receive(:write).with(resource.parameter(:source))
+        resource.expects(:write).with(resource.parameter(:source))
 
         checksum_value.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(checksum_value.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(checksum_value.sync).to eq(:file_created)
       end
     end

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
@@ -74,7 +77,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       end
     end
 
-    it "should convert the value to ASCII-8BIT", :if => "".respond_to?(:encode) do
+    it "should convert the value to ASCII-8BIT" do
       content.should= "Let's make a \u{2603}"
 
       expect(content.actual_content).to eq("Let's make a \xE2\x98\x83".force_encoding(Encoding::ASCII_8BIT))
@@ -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,33 +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")
-              expect(content).to receive(:debug).with("\nmy diff")
-              expect(content).not_to be_safe_insync("other content")
-            end
-
-            it "prints binary file notice if diff is not valid encoding" do
-              expect(content).to receive(:diff).and_return("\xc7\xd1\xfc\x84")
-              expect(content).to receive(:debug).with(/\nBinary files #{filename} and .* differ/)
+              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]")
+              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
@@ -269,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
@@ -281,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
@@ -309,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
@@ -354,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
@@ -383,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
@@ -414,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