chef 12.19.36 → 14.14.25

data/spec/unit/knife/cookbook_download_spec.rb

@@ -47,44 +47,62 @@ describe Chef::Knife::CookbookDownload do
         @rest_mock = double("rest")
         allow(@knife).to receive(:rest).and_return(@rest_mock)
 
-        @manifest_data = {
-          :recipes => [
-            { "path" => "recipes/foo.rb",
-              "url" => "http://example.org/files/foo.rb" },
-            { "path" => "recipes/bar.rb",
-              "url" => "http://example.org/files/bar.rb" },
-          ],
-          :templates => [
-            { "path" => "templates/default/foo.erb",
-              "url" => "http://example.org/files/foo.erb" },
-            { "path" => "templates/default/bar.erb",
-              "url" => "http://example.org/files/bar.erb" },
-          ],
-          :attributes => [
-            { "path" => "attributes/default.rb",
-              "url" => "http://example.org/files/default.rb" },
+        expect(Chef::CookbookVersion).to receive(:load).with("foobar", "1.0.0")
+          .and_return(cookbook)
+      end
+
+      let(:manifest_data) do
+        {
+          all_files: [
+            {
+              "path" => "recipes/foo.rb",
+              "name" => "recipes/foo.rb",
+              "url" => "http://example.org/files/foo.rb",
+            },
+            {
+              "path" => "recipes/bar.rb",
+              "name" => "recipes/bar.rb",
+              "url" => "http://example.org/files/bar.rb",
+            },
+            {
+              "path" => "templates/default/foo.erb",
+              "name" => "templates/foo.erb",
+              "url" => "http://example.org/files/foo.erb",
+            },
+            {
+              "path" => "templates/default/bar.erb",
+              "name" => "templates/bar.erb",
+              "url" => "http://example.org/files/bar.erb",
+            },
+            {
+              "path" => "attributes/default.rb",
+              "name" => "attributes/default.rb",
+              "url" => "http://example.org/files/default.rb",
+            },
           ],
         }
+      end
 
-        @cookbook_mock = double("cookbook")
-        allow(@cookbook_mock).to receive(:version).and_return("1.0.0")
-        allow(@cookbook_mock).to receive(:manifest).and_return(@manifest_data)
-        expect(Chef::CookbookVersion).to receive(:load).with("foobar", "1.0.0").
-          and_return(@cookbook_mock)
+      let (:cookbook) do
+        cb = Chef::CookbookVersion.new("foobar")
+        cb.version = "1.0.0"
+        cb.manifest = manifest_data
+        cb
       end
 
-      it "should determine which version if one was not explicitly specified" do
-        allow(@cookbook_mock).to receive(:manifest).and_return({})
-        expect(@knife).to receive(:determine_version).and_return("1.0.0")
-        expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
-        allow(Chef::CookbookVersion).to receive(:COOKBOOK_SEGEMENTS).and_return([])
-        @knife.run
+      describe "and no version" do
+        let (:manifest_data) { { all_files: [] } }
+        it "should determine which version to download" do
+          expect(@knife).to receive(:determine_version).and_return("1.0.0")
+          expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
+          @knife.run
+        end
       end
 
       describe "and a version" do
         before(:each) do
           @knife.name_args << "1.0.0"
-          @files = @manifest_data.values.map { |v| v.map { |i| i["path"] } }.flatten.uniq
+          @files = manifest_data.values.map { |v| v.map { |i| i["path"] } }.flatten.uniq
           @files_mocks = {}
           @files.map { |f| File.basename(f) }.flatten.uniq.each do |f|
             @files_mocks[f] = double("#{f}_mock")
@@ -101,18 +119,18 @@ describe Chef::Knife::CookbookDownload do
         describe "when downloading the cookbook" do
           before(:each) do
             @files.map { |f| File.dirname(f) }.flatten.uniq.each do |dir|
-              expect(FileUtils).to receive(:mkdir_p).with("/var/tmp/chef/foobar-1.0.0/#{dir}").
-                at_least(:once)
+              expect(FileUtils).to receive(:mkdir_p).with("/var/tmp/chef/foobar-1.0.0/#{dir}")
+                .at_least(:once)
             end
 
             @files_mocks.each_pair do |file, mock|
-              expect(@rest_mock).to receive(:streaming_request).with("http://example.org/files/#{file}").
-                and_return(mock)
+              expect(@rest_mock).to receive(:streaming_request).with("http://example.org/files/#{file}")
+                .and_return(mock)
             end
 
             @files.each do |f|
-              expect(FileUtils).to receive(:mv).
-                with("/var/tmp/#{File.basename(f)}", "/var/tmp/chef/foobar-1.0.0/#{f}")
+              expect(FileUtils).to receive(:mv)
+                .with("/var/tmp/#{File.basename(f)}", "/var/tmp/chef/foobar-1.0.0/#{f}")
             end
           end
 
@@ -164,8 +182,8 @@ describe Chef::Knife::CookbookDownload do
     describe "with -N or --latest" do
       it "should return and set the version to the latest version" do
         @knife.config[:latest] = true
-        expect(@knife).to receive(:available_versions).at_least(:once).
-          and_return(["1.0.0", "1.1.0", "2.0.0"])
+        expect(@knife).to receive(:available_versions).at_least(:once)
+          .and_return(["1.0.0", "1.1.0", "2.0.0"])
         @knife.determine_version
         expect(@knife.version.to_s).to eq("2.0.0")
       end
@@ -178,26 +196,26 @@ describe Chef::Knife::CookbookDownload do
     end
 
     it "should return nil if there are no versions" do
-      expect(Chef::CookbookVersion).to receive(:available_versions).
-        with("foobar").
-        and_return(nil)
+      expect(Chef::CookbookVersion).to receive(:available_versions)
+        .with("foobar")
+        .and_return(nil)
       expect(@knife.available_versions).to eq(nil)
     end
 
     it "should return the available versions" do
-      expect(Chef::CookbookVersion).to receive(:available_versions).
-        with("foobar").
-        and_return(["1.1.0", "2.0.0", "1.0.0"])
+      expect(Chef::CookbookVersion).to receive(:available_versions)
+        .with("foobar")
+        .and_return(["1.1.0", "2.0.0", "1.0.0"])
       expect(@knife.available_versions).to eq([Chef::Version.new("1.0.0"),
                                            Chef::Version.new("1.1.0"),
                                            Chef::Version.new("2.0.0")])
     end
 
     it "should avoid multiple API calls to the server" do
-      expect(Chef::CookbookVersion).to receive(:available_versions).
-        once.
-        with("foobar").
-        and_return(["1.1.0", "2.0.0", "1.0.0"])
+      expect(Chef::CookbookVersion).to receive(:available_versions)
+        .once
+        .with("foobar")
+        .and_return(["1.1.0", "2.0.0", "1.0.0"])
       @knife.available_versions
       @knife.available_versions
     end

data/spec/unit/knife/cookbook_list_spec.rb

@@ -37,8 +37,8 @@ describe Chef::Knife::CookbookList do
 
   describe "run" do
     it "should display the latest version of the cookbooks" do
-      expect(@rest_mock).to receive(:get).with("/cookbooks?num_versions=1").
-        and_return(@cookbook_data)
+      expect(@rest_mock).to receive(:get).with("/cookbooks?num_versions=1")
+        .and_return(@cookbook_data)
       @knife.run
       @cookbook_names.each do |item|
         expect(@stdout.string).to match /#{item}\s+1\.0\.1/
@@ -47,9 +47,9 @@ describe Chef::Knife::CookbookList do
 
     it "should query cookbooks for the configured environment" do
       @knife.config[:environment] = "production"
-      expect(@rest_mock).to receive(:get).
-        with("/environments/production/cookbooks?num_versions=1").
-        and_return(@cookbook_data)
+      expect(@rest_mock).to receive(:get)
+        .with("/environments/production/cookbooks?num_versions=1")
+        .and_return(@cookbook_data)
       @knife.run
     end
 
@@ -75,8 +75,8 @@ describe Chef::Knife::CookbookList do
 
       it "should display all versions of the cookbooks" do
         @knife.config[:all_versions] = true
-        expect(@rest_mock).to receive(:get).with("/cookbooks?num_versions=all").
-          and_return(@cookbook_data)
+        expect(@rest_mock).to receive(:get).with("/cookbooks?num_versions=all")
+          .and_return(@cookbook_data)
         @knife.run
         @cookbook_names.each do |item|
           expect(@stdout.string).to match /#{item}\s+1\.0\.1\s+1\.0\.0/

data/spec/unit/knife/cookbook_show_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, eersion 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -47,12 +47,12 @@ describe Chef::Knife::CookbookShow do
 
   let (:manifest) do
     {
-      "recipes" => [
+      "all_files" => [
         {
-          :name => "default.rb",
-          :path => "recipes/default.rb",
-          :checksum => "1234",
-          :url => "http://example.org/files/default.rb",
+          name: "recipes/default.rb",
+          path: "recipes/default.rb",
+          checksum: "1234",
+          url: "http://example.org/files/default.rb",
         },
       ],
     }
@@ -101,9 +101,42 @@ describe Chef::Knife::CookbookShow do
         knife.name_args << "0.1.0"
       end
 
+      let(:output) do
+        { "cookbook_name" => "cookbook_name",
+          "name" => "cookbook_name-0.0.0",
+          "frozen?" => false,
+          "version" => "0.0.0",
+          "metadata" => {
+            "name" => nil,
+            "description" => "",
+            "long_description" => "",
+            "maintainer" => "",
+            "maintainer_email" => "",
+            "license" => "All rights reserved",
+            "platforms" => {},
+            "dependencies" => {},
+            "providing" => {},
+            "attributes" => {},
+            "recipes" => {},
+            "version" => "0.0.0",
+            "source_url" => "",
+            "issues_url" => "",
+            "privacy" => false,
+            "chef_versions" => [],
+            "ohai_versions" => [],
+            "gems" => [],
+          },
+          "recipes" =>
+          [{ "name" => "recipes/default.rb",
+             "path" => "recipes/default.rb",
+             "checksum" => "1234",
+             "url" => "http://example.org/files/default.rb" }],
+        }
+      end
+
       it "should show the specific part of a cookbook" do
         expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-        expect(knife).to receive(:output).with(cb)
+        expect(knife).to receive(:output).with(output)
         knife.run
       end
     end
@@ -115,7 +148,7 @@ describe Chef::Knife::CookbookShow do
 
       it "should print the json of the part" do
         expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-        expect(knife).to receive(:output).with(cb.manifest["recipes"])
+        expect(knife).to receive(:output).with(cb.files_for("recipes"))
         knife.run
       end
     end
@@ -137,34 +170,34 @@ describe Chef::Knife::CookbookShow do
       before(:each) do
         knife.name_args = [ "cookbook_name", "0.1.0", "files", "afile.rb" ]
         cb.manifest = {
-          "files" => [
+          "all_files" => [
             {
-              :name => "afile.rb",
-              :path => "files/host-examplehost.example.org/afile.rb",
-              :checksum => "1111",
-              :specificity => "host-examplehost.example.org",
-              :url => "http://example.org/files/1111",
+              name: "files/afile.rb",
+              path: "files/host-examplehost.example.org/afile.rb",
+              checksum: "1111",
+              specificity: "host-examplehost.example.org",
+              url: "http://example.org/files/1111",
             },
             {
-              :name => "afile.rb",
-              :path => "files/ubuntu-9.10/afile.rb",
-              :checksum => "2222",
-              :specificity => "ubuntu-9.10",
-              :url => "http://example.org/files/2222",
+              name: "files/afile.rb",
+              path: "files/ubuntu-9.10/afile.rb",
+              checksum: "2222",
+              specificity: "ubuntu-9.10",
+              url: "http://example.org/files/2222",
             },
             {
-              :name => "afile.rb",
-              :path => "files/ubuntu/afile.rb",
-              :checksum => "3333",
-              :specificity => "ubuntu",
-              :url => "http://example.org/files/3333",
+              name: "files/afile.rb",
+              path: "files/ubuntu/afile.rb",
+              checksum: "3333",
+              specificity: "ubuntu",
+              url: "http://example.org/files/3333",
             },
             {
-              :name => "afile.rb",
-              :path => "files/default/afile.rb",
-              :checksum => "4444",
-              :specificity => "default",
-              :url => "http://example.org/files/4444",
+              name: "files/afile.rb",
+              path: "files/default/afile.rb",
+              checksum: "4444",
+              specificity: "default",
+              url: "http://example.org/files/4444",
             },
           ],
         }

data/spec/unit/knife/cookbook_test_spec.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Stephen Delano (<stephen@chef.io>)$
 # Author:: Matthew Kent (<mkent@magoazul.com>)
-# Copyright:: Copyright 2010-2016, Chef Software Inc.$
+# Copyright:: Copyright 2010-2018, Chef Software Inc.$
 # Copyright:: Copyright 2010-2016, Matthew Kent
 # License:: Apache License, Version 2.0
 #
@@ -73,7 +73,7 @@ describe Chef::Knife::CookbookTest do
           @loader[cookbook.name] = cookbook
         end
         allow(@knife).to receive(:cookbook_loader).and_return(@loader)
-        @loader.each do |key, cookbook|
+        @loader.each_value do |cookbook|
           expect(@knife).to receive(:test_cookbook).with(cookbook.name)
         end
         @knife.run

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -36,7 +36,7 @@ describe Chef::Knife::CookbookUpload do
     cookbook_loader
   end
 
-  let(:cookbook_uploader) { double(:upload_cookbooks => nil) }
+  let(:cookbook_uploader) { double(upload_cookbooks: nil) }
 
   let(:output) { StringIO.new }
 
@@ -61,16 +61,16 @@ describe Chef::Knife::CookbookUpload do
       test_cookbook = Chef::CookbookVersion.new("test_cookbook", "/tmp/blah")
       allow(cookbook_loader).to receive(:each).and_yield("test_cookbook", test_cookbook)
       allow(cookbook_loader).to receive(:cookbook_names).and_return(["test_cookbook"])
-      expect(Chef::CookbookUploader).to receive(:new).
-        with( kind_of(Array), { :force => nil, :concurrency => 3 }).
-        and_return(double("Chef::CookbookUploader", :upload_cookbooks => true))
+      expect(Chef::CookbookUploader).to receive(:new)
+        .with( kind_of(Array), { force: nil, concurrency: 3 })
+        .and_return(double("Chef::CookbookUploader", upload_cookbooks: true))
       knife.run
     end
   end
 
   describe "run" do
     before(:each) do
-      allow(Chef::CookbookUploader).to receive_messages(:new => cookbook_uploader)
+      allow(Chef::CookbookUploader).to receive_messages(new: cookbook_uploader)
       allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
     end
 
@@ -106,22 +106,22 @@ describe Chef::Knife::CookbookUpload do
 
       before do
         allow(cookbook_loader).to receive(:merged_cookbooks).and_return(["test_cookbook"])
-        allow(cookbook_loader).to receive(:merged_cookbook_paths).
-          and_return({ "test_cookbook" => %w{/path/one/test_cookbook /path/two/test_cookbook} })
+        allow(cookbook_loader).to receive(:merged_cookbook_paths)
+          .and_return({ "test_cookbook" => %w{/path/one/test_cookbook /path/two/test_cookbook} })
       end
 
       it "emits a warning" do
         knife.run
-        expected_message = <<-E
-WARNING: The cookbooks: test_cookbook exist in multiple places in your cookbook_path.
-A composite version of these cookbooks has been compiled for uploading.
-
-IMPORTANT: In a future version of Chef, this behavior will be removed and you will no longer
-be able to have the same version of a cookbook in multiple places in your cookbook_path.
-WARNING: The affected cookbooks are located:
-test_cookbook:
-  /path/one/test_cookbook
-  /path/two/test_cookbook
+        expected_message = <<~E
+          WARNING: The cookbooks: test_cookbook exist in multiple places in your cookbook_path.
+          A composite version of these cookbooks has been compiled for uploading.
+
+          IMPORTANT: In a future version of Chef, this behavior will be removed and you will no longer
+          be able to have the same version of a cookbook in multiple places in your cookbook_path.
+          WARNING: The affected cookbooks are located:
+          test_cookbook:
+            /path/one/test_cookbook
+            /path/two/test_cookbook
 E
         expect(output.string).to include(expected_message)
       end
@@ -310,8 +310,8 @@ E
     describe "when a frozen cookbook exists on the server" do
       it "should fail to replace it" do
         exception = Chef::Exceptions::CookbookFrozen.new
-        expect(cookbook_uploader).to receive(:upload_cookbooks).
-          and_raise(exception)
+        expect(cookbook_uploader).to receive(:upload_cookbooks)
+          .and_raise(exception)
         allow(knife.ui).to receive(:error)
         expect(knife.ui).to receive(:error).with(exception)
         expect { knife.run }.to raise_error(SystemExit)

data/spec/unit/knife/core/bootstrap_context_spec.rb

@@ -26,15 +26,15 @@ describe Chef::Knife::Core::BootstrapContext do
     Chef::Config[:fips] = false
   end
 
-  let(:config) { { :foo => :bar, :color => true } }
+  let(:config) { { foo: :bar, color: true } }
   let(:run_list) { Chef::RunList.new("recipe[tmux]", "role[base]") }
   let(:chef_config) do
     {
-      :config_log_level => "info",
-      :config_log_location => "/tmp/log",
-      :validation_key => File.join(CHEF_SPEC_DATA, "ssl", "private_key.pem"),
-      :chef_server_url => "http://chef.example.com:4444",
-      :validation_client_name => "chef-validator-testing",
+      config_log_level: "info",
+      config_log_location: "/tmp/log",
+      validation_key: File.join(CHEF_SPEC_DATA, "ssl", "private_key.pem"),
+      chef_server_url: "http://chef.example.com:4444",
+      validation_client_name: "chef-validator-testing",
     }
   end
 
@@ -51,14 +51,14 @@ describe Chef::Knife::Core::BootstrapContext do
   end
 
   describe "when in verbosity mode" do
-    let(:config) { { :verbosity => 2, :color => true } }
+    let(:config) { { verbosity: 2, color: true } }
     it "adds '-l debug' when verbosity is >= 2" do
       expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json -l debug"
     end
   end
 
   describe "when no color value has been set in config" do
-    let(:config) { { :color => false } }
+    let(:config) { { color: false } }
     it "adds '--no-color' when color is false" do
       expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json --no-color"
     end
@@ -69,25 +69,25 @@ describe Chef::Knife::Core::BootstrapContext do
   end
 
   it "generates the config file data" do
-    expected = <<-EXPECTED
-chef_server_url  "http://chef.example.com:4444"
-validation_client_name "chef-validator-testing"
-log_level   :info
-log_location   "/tmp/log"
-# Using default node name (fqdn)
+    expected = <<~EXPECTED
+      chef_server_url  "http://chef.example.com:4444"
+      validation_client_name "chef-validator-testing"
+      log_level   :info
+      log_location   "/tmp/log"
+      # Using default node name (fqdn)
 EXPECTED
     expect(bootstrap_context.config_content).to eq expected
   end
 
   describe "alternate chef-client path" do
-    let(:chef_config) { { :chef_client_path => "/usr/local/bin/chef-client" } }
+    let(:chef_config) { { chef_client_path: "/usr/local/bin/chef-client" } }
     it "runs chef-client from another path when specified" do
       expect(bootstrap_context.start_chef).to eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json"
     end
   end
 
   describe "validation key path that contains a ~" do
-    let(:chef_config) { { :validation_key => "~/my.key" } }
+    let(:chef_config) { { validation_key: "~/my.key" } }
     it "reads the validation key when it contains a ~" do
       expect(File).to receive(:exist?).with(File.expand_path("my.key", ENV["HOME"])).and_return(true)
       expect(IO).to receive(:read).with(File.expand_path("my.key", ENV["HOME"]))
@@ -96,36 +96,36 @@ EXPECTED
   end
 
   describe "when an explicit node name is given" do
-    let(:config) { { :chef_node_name => "foobar.example.com" } }
+    let(:config) { { chef_node_name: "foobar.example.com" } }
     it "sets the node name in the client.rb" do
       expect(bootstrap_context.config_content).to match(/node_name "foobar\.example\.com"/)
     end
   end
 
   describe "when bootstrapping into a specific environment" do
-    let(:config) { { :environment => "prodtastic", :color => true } }
+    let(:config) { { environment: "prodtastic", color: true } }
     it "starts chef in the configured environment" do
       expect(bootstrap_context.start_chef).to eq("chef-client -j /etc/chef/first-boot.json -E prodtastic")
     end
   end
 
   describe "when tags are given" do
-    let(:config) { { :tags => [ "unicorn" ] } }
+    let(:config) { { tags: [ "unicorn" ] } }
     it "adds the attributes to first_boot" do
-      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ :run_list => run_list, :tags => ["unicorn"] }))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ run_list: run_list, tags: ["unicorn"] }))
     end
   end
 
   describe "when JSON attributes are given" do
-    let(:config) { { :first_boot_attributes => { :baz => :quux } } }
+    let(:config) { { first_boot_attributes: { baz: :quux } } }
     it "adds the attributes to first_boot" do
-      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ :baz => :quux, :run_list => run_list }))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ baz: :quux, run_list: run_list }))
     end
   end
 
   describe "when JSON attributes are NOT given" do
     it "sets first_boot equal to run_list" do
-      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ :run_list => run_list }))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ run_list: run_list }))
     end
   end
 
@@ -159,7 +159,7 @@ EXPECTED
   describe "when a bootstrap_version is specified" do
     let(:chef_config) do
       {
-        :knife => { :bootstrap_version => "11.12.4" },
+        knife: { bootstrap_version: "11.12.4" },
       }
     end
 
@@ -171,7 +171,7 @@ EXPECTED
   describe "when a pre-release bootstrap_version is specified" do
     let(:chef_config) do
       {
-        :knife => { :bootstrap_version => "11.12.4.rc.0" },
+        knife: { bootstrap_version: "11.12.4.rc.0" },
       }
     end
 
@@ -195,7 +195,7 @@ EXPECTED
     describe "when configured in config" do
       let(:chef_config) do
         {
-          :knife => { :ssl_verify_mode => :verify_peer },
+          knife: { ssl_verify_mode: :verify_peer },
         }
       end
 
@@ -204,7 +204,7 @@ EXPECTED
       end
 
       describe "when configured via CLI" do
-        let(:config) { { :node_ssl_verify_mode => "none" } }
+        let(:config) { { node_ssl_verify_mode: "none" } }
 
         it "uses CLI value" do
           expect(bootstrap_context.config_content).to include("ssl_verify_mode :verify_none")
@@ -213,6 +213,23 @@ EXPECTED
     end
   end
 
+  describe "fips mode" do
+    before do
+      Chef::Config[:fips] = true
+    end
+
+    it "adds the chef version check" do
+      expect(bootstrap_context.config_content).to include <<-CONFIG.gsub(/^ {8}/, "")
+        fips true
+        require "chef/version"
+        chef_version = ::Chef::VERSION.split(".")
+        unless chef_version[0].to_i > 12 || (chef_version[0].to_i == 12 && chef_version[1].to_i >= 8)
+          raise "FIPS Mode requested but not supported by this client"
+        end
+      CONFIG
+    end
+  end
+
   describe "verify_api_cert" do
     it "isn't set in the config_content by default" do
       expect(bootstrap_context.config_content).not_to include("verify_api_cert")
@@ -221,7 +238,7 @@ EXPECTED
     describe "when configured in config" do
       let(:chef_config) do
         {
-          :knife => { :verify_api_cert => :false },
+          knife: { verify_api_cert: :false },
         }
       end
 
@@ -230,7 +247,7 @@ EXPECTED
       end
 
       describe "when configured via CLI" do
-        let(:config) { { :node_verify_api_cert => true } }
+        let(:config) { { node_verify_api_cert: true } }
 
         it "uses CLI value" do
           expect(bootstrap_context.config_content).to include("verify_api_cert true")
@@ -245,7 +262,7 @@ EXPECTED
     end
 
     describe "when configured via cli" do
-      let(:config) { { :prerelease => true } }
+      let(:config) { { prerelease: true } }
 
       it "uses CLI value" do
         expect(bootstrap_context.latest_current_chef_version_string).to eq("-p")
@@ -255,49 +272,49 @@ EXPECTED
 
   describe "#config_log_location" do
     context "when config_log_location is nil" do
-      let(:chef_config) { { :config_log_location => nil } }
+      let(:chef_config) { { config_log_location: nil } }
       it "sets the default config_log_location  in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDOUT"
       end
     end
 
     context "when config_log_location is empty" do
-      let(:chef_config) { { :config_log_location => "" } }
+      let(:chef_config) { { config_log_location: "" } }
       it "sets the default config_log_location  in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDOUT"
       end
     end
 
     context "when config_log_location is :win_evt" do
-      let(:chef_config) { { :config_log_location => :win_evt } }
+      let(:chef_config) { { config_log_location: :win_evt } }
       it "raise error when config_log_location is :win_evt " do
         expect { bootstrap_context.get_log_location }.to raise_error("The value :win_evt is not supported for config_log_location on Linux Platforms \n")
       end
     end
 
     context "when config_log_location is :syslog" do
-      let(:chef_config) { { :config_log_location => :syslog } }
+      let(:chef_config) { { config_log_location: :syslog } }
       it "sets the config_log_location value as :syslog in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq ":syslog"
       end
     end
 
     context "When config_log_location is STDOUT" do
-      let(:chef_config) { { :config_log_location => STDOUT } }
+      let(:chef_config) { { config_log_location: STDOUT } }
       it "Sets the config_log_location value as STDOUT in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDOUT"
       end
     end
 
     context "when config_log_location is STDERR" do
-      let(:chef_config) { { :config_log_location => STDERR } }
+      let(:chef_config) { { config_log_location: STDERR } }
       it "sets the config_log_location value as STDERR  in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDERR"
       end
     end
 
     context "when config_log_location is a path" do
-      let(:chef_config) { { :config_log_location => "/tmp/ChefLogFile" } }
+      let(:chef_config) { { config_log_location: "/tmp/ChefLogFile" } }
       it "sets the config_log_location path in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "\"/tmp/ChefLogFile\""
       end