chef 17.4.38 → 17.5.22

data/spec/unit/resource/archive_file_spec.rb

@@ -17,19 +17,60 @@
 
 require "spec_helper"
 
-describe Chef::Resource::ArchiveFile do
+begin
+  require "ffi-libarchive"
+rescue LoadError
+  module Archive
+    class Reader
+      def close; end
+      def each_entry; end
+      def extract(entry, flags = 0, destination: nil); end
+    end
+  end
+end
+
+# Exclude this test on platforms where ffi-libarchive loading is broken
+describe Chef::Resource::ArchiveFile, :libarchive_loading_broken do
   let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::ArchiveFile.new("foo", run_context) }
+  let(:destination) { Dir.mktmpdir }
+  let(:path) { File.expand_path("/tmp/foo.zip") }
+  let(:resource) do
+    r = Chef::Resource::ArchiveFile.new(path, run_context)
+    r.destination = destination
+    r
+  end
   let(:provider) { resource.provider_for_action(:extract) }
+  let(:entry_time) { Time.new(2021, 5, 25, 2, 2, 0, "-05:00") }
+  let(:older_time) { entry_time - 100 }
+  let(:newer_time) { entry_time + 100 }
+
+  let(:archive_reader) { instance_double("Archive::Reader", close: nil) }
+  let(:archive_entry_1) { instance_double("Archive::Entry", pathname: "folder-1/", mtime: entry_time) }
+  let(:archive_entry_2) { instance_double("Archive::Entry", pathname: "folder-1/file-1.txt", mtime: entry_time) }
+  let(:archive_entry_3) { instance_double("Archive::Entry", pathname: "folder-1/folder-2/", mtime: entry_time) }
+  let(:archive_entry_4) { instance_double("Archive::Entry", pathname: "folder-1/folder-2/file-2.txt", mtime: entry_time) }
+
+  let(:archive_reader_with_strip_components_1) { instance_double("Archive::Reader", close: nil) }
+  let(:archive_entry_2_s1) { instance_double("Archive::Entry", pathname: "file-1.txt", mtime: entry_time) }
+  let(:archive_entry_3_s1) { instance_double("Archive::Entry", pathname: "folder-2/", mtime: entry_time) }
+  let(:archive_entry_4_s1) { instance_double("Archive::Entry", pathname: "folder-2/file-2.txt", mtime: entry_time) }
+
+  let(:archive_reader_with_strip_components_2) { instance_double("Archive::Reader", close: nil) }
+  let(:archive_entry_4_s2) { instance_double("Archive::Entry", pathname: "file-2.txt", mtime: entry_time) }
+
+  before do
+    allow(resource).to receive(:provider_for_action).with(:extract).and_return(provider)
+  end
 
   it "has a resource name of :archive_file" do
     expect(resource.resource_name).to eql(:archive_file)
   end
 
   it "has a name property of path" do
-    expect(resource.path).to match(/.*foo$/)
+    r = Chef::Resource::ArchiveFile.new("my-name", run_context)
+    expect(r.path).to match("my-name")
   end
 
   it "sets the default action as :extract" do
@@ -44,6 +85,376 @@ describe Chef::Resource::ArchiveFile do
     expect(resource.mode).to eql("755")
   end
 
+  it "strip_components property defaults to 0" do
+    expect(resource.strip_components).to eql(0)
+  end
+
+  describe "#action_extract" do
+    before do
+      allow(FileUtils).to receive(:mkdir_p)
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(path).and_return(true)
+      allow(File).to receive(:exist?).with(destination).and_return(true)
+
+      allow(Archive::Reader).to receive(:open_filename).with(path, nil, strip_components: 0).and_return(archive_reader)
+      allow(archive_reader).to receive(:each_entry)
+        .and_yield(archive_entry_1)
+        .and_yield(archive_entry_2)
+        .and_yield(archive_entry_3)
+        .and_yield(archive_entry_4)
+      allow(archive_reader).to receive(:extract).with(archive_entry_1, any_args)
+      allow(archive_reader).to receive(:extract).with(archive_entry_2, any_args)
+      allow(archive_reader).to receive(:extract).with(archive_entry_3, any_args)
+      allow(archive_reader).to receive(:extract).with(archive_entry_4, any_args)
+
+      allow(Archive::Reader).to receive(:open_filename).with(path, nil, strip_components: 1).and_return(archive_reader_with_strip_components_1)
+      allow(archive_reader_with_strip_components_1).to receive(:each_entry)
+        .and_yield(archive_entry_2_s1)
+        .and_yield(archive_entry_3_s1)
+        .and_yield(archive_entry_4_s1)
+      allow(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_2_s1, any_args)
+      allow(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_3_s1, any_args)
+      allow(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_4_s1, any_args)
+
+      allow(Archive::Reader).to receive(:open_filename).with(path, nil, strip_components: 2).and_return(archive_reader_with_strip_components_2)
+      allow(archive_reader_with_strip_components_2).to receive(:each_entry)
+        .and_yield(archive_entry_4_s2)
+      allow(archive_reader_with_strip_components_2).to receive(:extract).with(archive_entry_4_s2, any_args)
+
+      allow(File).to receive(:exist?).with("#{destination}/folder-1").and_return(true)
+      allow(File).to receive(:exist?).with("#{destination}/folder-1/file-1.txt").and_return(true)
+      allow(File).to receive(:exist?).with("#{destination}/folder-1/folder-2").and_return(true)
+      allow(File).to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(true)
+
+      allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+      allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+      allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+      allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+
+      resource.overwrite(true) # Force it to converge
+    end
+
+    context "when destination directory does not exist" do
+      before do
+        allow(File).to receive(:exist?).with(destination).and_return(false)
+      end
+
+      it "creates destination directory" do
+        expect(FileUtils).to receive(:mkdir_p).with(destination, { mode: 493 })
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when destination directory exists" do
+      before do
+        allow(File).to receive(:exist?).with(destination).and_return(true)
+      end
+
+      it "does not create destination directory" do
+        expect(FileUtils).not_to receive(:mkdir_p)
+        resource.run_action(:extract)
+      end
+
+      context "when overwrite is set to false" do
+        before do
+          resource.overwrite(false)
+        end
+
+        context "when files on disk have identical modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+          end
+
+          it "does not extract archive" do
+            expect(provider).not_to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have newer modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(newer_time)
+          end
+
+          it "does not extract archive" do
+            expect(provider).not_to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have older modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(older_time)
+          end
+
+          it "does not extract archive" do
+            expect(provider).not_to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+      end
+
+      context "when overwrite is set to true" do
+        before do
+          resource.overwrite(true)
+        end
+
+        context "when files on disk have identical modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have newer modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(newer_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have older modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(older_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+      end
+
+      context "when overwrite is set to :auto" do
+        before do
+          resource.overwrite(:auto)
+        end
+
+        context "when strip_components is set to 0" do
+          before do
+            resource.strip_components(0)
+          end
+
+          context "when files on disk have identical modified times than what is in the archive" do
+            before do
+              allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+            end
+
+            context "when there is at least one missing files on disk" do
+              before do
+                expect(File).to receive(:exist?).with("#{destination}/folder-1").and_return(false)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/file-1.txt").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "extracts archive" do
+                expect(provider).to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+
+            context "when there are no missing files on disk" do
+              before do
+                expect(File).to receive(:exist?).with("#{destination}/folder-1").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/file-1.txt").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "does not extract archive" do
+                expect(provider).not_to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+          end
+        end
+
+        context "when strip_components is set to 1" do
+          before do
+            resource.strip_components(1)
+          end
+
+          context "when files on disk have identical modified times than what is in the archive" do
+            before do
+              allow(File).to receive(:mtime).with("#{destination}/file-1.txt").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-2").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-2/file-2.txt").and_return(entry_time)
+            end
+
+            context "when there is at least one missing files on disk" do
+              before do
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/file-1.txt")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt")
+                expect(File).to receive(:exist?).with("#{destination}/file-1.txt").and_return(false)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "extracts archive" do
+                expect(provider).to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+
+            context "when there are no missing files on disk" do
+              before do
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/file-1.txt")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt")
+                expect(File).to receive(:exist?).with("#{destination}/file-1.txt").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "does not extract archive" do
+                expect(provider).not_to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+          end
+        end
+
+        context "when files on disk have newer modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(newer_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have older modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(older_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+      end
+    end
+
+    context "when strip_components is set to 0" do
+      before do
+        resource.strip_components(0)
+      end
+
+      it "does not strip any paths" do
+        expect(archive_reader).to receive(:extract).with(archive_entry_1, 4)
+        expect(archive_reader).to receive(:extract).with(archive_entry_2, 4)
+        expect(archive_reader).to receive(:extract).with(archive_entry_3, 4)
+        expect(archive_reader).to receive(:extract).with(archive_entry_4, 4)
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when strip_components is set to 1" do
+      before do
+        resource.strip_components(1)
+      end
+
+      it "strips leading number of paths specified in strip_components" do
+        expect(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_2_s1, 4)
+        expect(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_3_s1, 4)
+        expect(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_4_s1, 4)
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when strip_components is set to 2" do
+      before do
+        resource.strip_components(2)
+      end
+
+      it "strips leading number of paths specified in strip_components" do
+        expect(archive_reader_with_strip_components_2).to receive(:extract).with(archive_entry_4_s2, 4)
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when owner property is set" do
+      before { resource.owner "root" }
+
+      it "chowns all archive file/directory paths" do
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/")
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/file-1.txt")
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/folder-2/")
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/folder-2/file-2.txt")
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when group property is set" do
+      before { resource.group "root" }
+
+      it "chowns all archive file/directory paths" do
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/")
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/file-1.txt")
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/folder-2/")
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/folder-2/file-2.txt")
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when owner and group properties are set" do
+      before do
+        resource.owner "root"
+        resource.group "root"
+      end
+
+      it "chowns all archive file/directory paths" do
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/")
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/file-1.txt")
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/folder-2/")
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/folder-2/file-2.txt")
+        resource.run_action(:extract)
+      end
+    end
+  end
+
   it "mode property throws a deprecation warning if Integers are passed" do
     expect(Chef::Log).to receive(:deprecation)
     resource.mode 755

data/spec/unit/resource/chef_client_scheduled_task_spec.rb

@@ -25,6 +25,11 @@ describe Chef::Resource::ChefClientScheduledTask do
   let(:resource) { Chef::Resource::ChefClientScheduledTask.new("fakey_fakerton", run_context) }
   let(:provider) { resource.provider_for_action(:add) }
 
+  before do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with("COMSPEC").and_return("C:\\Windows\\System32\\cmd.exe")
+  end
+
   it "sets the default action as :add" do
     expect(resource.action).to eql([:add])
   end
@@ -73,11 +78,75 @@ describe Chef::Resource::ChefClientScheduledTask do
     expect(resource.chef_binary_path).to eql("C:/opscode/chef/bin/chef-client")
   end
 
+  context "priority" do
+    it "default value is 7" do
+      expect(resource.priority).to eq(7)
+    end
+
+    it "raise error when priority value less than 0" do
+      expect { resource.priority(-1) }.to raise_error(Chef::Exceptions::ValidationFailed, "Option priority's value -1 should be in range of 0 to 10!")
+    end
+
+    it "raise error when priority values is greater than 10" do
+      expect { resource.priority 11 }.to raise_error(Chef::Exceptions::ValidationFailed, "Option priority's value 11 should be in range of 0 to 10!")
+    end
+  end
+
   it "supports :add and :remove actions" do
     expect { resource.action :add }.not_to raise_error
     expect { resource.action :remove }.not_to raise_error
   end
 
+  it "expects use_consistent_splay to be true when set" do
+    resource.use_consistent_splay = true
+    expect(resource.use_consistent_splay).to eql(true)
+  end
+
+  context "when configured to use a consistent splay" do
+    before do
+      node.automatic_attrs[:shard_seed] = nil
+      allow(node).to receive(:name).and_return("test_node")
+      resource.config_directory = "C:/chef" # Allows local unit testing on nix flavors
+      resource.use_consistent_splay = true
+    end
+
+    it "sleeps the same amount each time based on splay before running the task" do
+      expect(provider.full_command).to eql("C:\\Windows\\System32\\cmd.exe /c \"C:/windows/system32/windowspowershell/v1.0/powershell.exe Start-Sleep -s 272 && C:/opscode/chef/bin/chef-client -L C:/chef/log/client.log -c C:/chef/client.rb\"")
+    end
+  end
+
+  describe "#consistent_splay_command" do
+    context "when use_consistent_splay is false" do
+      it "returns nil" do
+        expect(provider.consistent_splay_command).to eql(nil)
+      end
+    end
+
+    context "when use_consistent_splay is true" do
+      before do
+        resource.use_consistent_splay true
+        allow(provider).to receive(:splay_sleep_time).and_return(222)
+      end
+
+      it "returns a powershell sleep command to be appended to the chef client run command" do
+        expect(provider.consistent_splay_command).to eql("C:/windows/system32/windowspowershell/v1.0/powershell.exe Start-Sleep -s 222 && ")
+      end
+    end
+  end
+
+  describe "#splay_sleep_time" do
+    it "uses shard_seed attribute if present" do
+      node.automatic_attrs[:shard_seed] = "73399073"
+      expect(provider.splay_sleep_time(300)).to satisfy { |v| v >= 0 && v <= 300 }
+    end
+
+    it "uses a hex conversion of a md5 hash of the splay if present" do
+      node.automatic_attrs[:shard_seed] = nil
+      allow(node).to receive(:name).and_return("test_node")
+      expect(provider.splay_sleep_time(300)).to satisfy { |v| v >= 0 && v <= 300 }
+    end
+  end
+
   describe "#client_cmd" do
     it "creates a valid command if using all default properties" do
       expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb") | eql("C:/opscode/chef/bin/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb")

data/spec/unit/resource/file/verification/json_spec.rb

@@ -0,0 +1,72 @@
+#
+# Author:: Antony Thomas (<antonydeepak@gmail.com>)
+# Copyright:: Copyright (c) Facebook, Inc. and its affiliates.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+
+describe Chef::Resource::File::Verification::Json do
+  let(:parent_resource) { Chef::Resource.new("llama") }
+
+  before(:all) do
+    @valid_json = "valid-#{Time.now.to_i}.json"
+    f = File.new(@valid_json, "w")
+    f.write('{
+      "foo": "bar"
+    }')
+    f.close
+
+    @invalid_json = "invalid-#{Time.now.to_i}.json"
+    f = File.new(@invalid_json, "w")
+    f.write("{
+      'foo': 'bar'
+    }")
+    f.close
+
+    @empty_json = "empty-#{Time.now.to_i}.json"
+    File.new(@empty_json, "w").close
+  end
+
+  context "verify" do
+    it "returns true for valid json" do
+      v = Chef::Resource::File::Verification::Json.new(parent_resource, :json, {})
+      expect(v.verify(@valid_json)).to eq(true)
+    end
+
+    it "returns false for invalid json" do
+      v = Chef::Resource::File::Verification::Json.new(parent_resource, :json, {})
+      expect(v.verify(@invalid_json)).to eq(false)
+    end
+
+    it "returns true for empty file" do
+      # Expectation here is different from that of default JSON parser included in ruby 2.4+.
+      # The default parser considers empty string as invalid JSON
+      # https://stackoverflow.com/questions/30621802/why-does-json-parse-fail-with-the-empty-string,
+      # however JSONCompat parses an empty string to `nil`.
+      # We are retaining the behavior of JSONCompat for two reasons
+      # - It is universal inside Chef codebase
+      # - It can be helpful to not throw an error when a `file` or `template` is empty
+      v = Chef::Resource::File::Verification::Json.new(parent_resource, :json, {})
+      expect(v.verify(@empty_json)).to eq(true)
+    end
+  end
+
+  after(:all) do
+    File.delete(@valid_json)
+    File.delete(@invalid_json)
+    File.delete(@empty_json)
+  end
+end

data/spec/unit/resource/file/verification/yaml_spec.rb

@@ -0,0 +1,67 @@
+#
+# Author:: Antony Thomas (<antonydeepak@gmail.com>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+
+describe Chef::Resource::File::Verification::Yaml do
+  let(:parent_resource) { Chef::Resource.new("llama") }
+
+  before(:all) do
+    @valid_yaml = "valid-#{Time.now.to_i}.yaml"
+    f = File.new(@valid_yaml, "w")
+    f.write("# comment
+        svc:
+          mysqlPassword: sepppasswd
+        ")
+    f.close
+
+    @invalid_yaml = "invalid-#{Time.now.to_i}.yaml"
+    f = File.new(@invalid_yaml, "w")
+    f.write("# comment
+        svc:
+          mysqlPassword: 'sepppasswd
+        ")
+    f.close
+
+    @empty_yaml = "empty-#{Time.now.to_i}.yaml"
+    File.new(@empty_yaml, "w").close
+  end
+
+  context "verify" do
+    it "returns true for valid yaml" do
+      v = Chef::Resource::File::Verification::Yaml.new(parent_resource, :yaml, {})
+      expect(v.verify(@valid_yaml)).to eq(true)
+    end
+
+    it "returns false for invalid yaml" do
+      v = Chef::Resource::File::Verification::Yaml.new(parent_resource, :yaml, {})
+      expect(v.verify(@invalid_yaml)).to eq(false)
+    end
+
+    it "returns true for empty file" do
+      v = Chef::Resource::File::Verification::Yaml.new(parent_resource, :yaml, {})
+      expect(v.verify(@empty_yaml)).to eq(true)
+    end
+  end
+
+  after(:all) do
+    File.delete(@valid_yaml)
+    File.delete(@invalid_yaml)
+    File.delete(@empty_yaml)
+  end
+end