chef 15.1.36 → 15.2.20

data/spec/unit/data_collector_spec.rb

@@ -879,4 +879,86 @@ describe Chef::DataCollector do
       data_collector.send(:send_to_file_location, tempfile, { invalid: shift_jis })
     end
   end
+
+  describe "#send_to_datacollector" do
+    def stub_http_client(exception = nil)
+      if exception.nil?
+        expect(http_client).to receive(:post).with(nil, message, data_collector.send(:headers))
+      else
+        expect(http_client).to receive(:post).with(nil, message, data_collector.send(:headers)).and_raise(exception)
+      end
+    end
+
+    let(:message) { "message" }
+    let(:http_client) { instance_double(Chef::ServerAPI) }
+
+    before do
+      expect(data_collector).to receive(:setup_http_client).and_return(http_client)
+    end
+
+    it "does not disable the data_collector when no exception is raised" do
+      stub_http_client
+      expect(data_collector.events).not_to receive(:unregister)
+      data_collector.send(:send_to_data_collector, message)
+    end
+
+    errors = [ Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
+               Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
+               Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError,
+               Errno::EHOSTDOWN ]
+
+    errors.each do |exception_class|
+      context "when the client raises a #{exception_class} exception" do
+        before do
+          stub_http_client(exception_class)
+        end
+
+        it "disables the reporter" do
+          expect(data_collector.events).to receive(:unregister).with(data_collector)
+          data_collector.send(:send_to_data_collector, message)
+        end
+
+        it "logs an error and raises when raise_on_failure is enabled" do
+          Chef::Config[:data_collector][:raise_on_failure] = true
+          expect(Chef::Log).to receive(:error)
+          expect { data_collector.send(:send_to_data_collector, message) }.to raise_error(exception_class)
+        end
+
+        it "logs a warn message and does not raise an exception when raise_on_failure is disabled" do
+          Chef::Config[:data_collector][:raise_on_failure] = false
+          expect(Chef::Log).to receive(:warn)
+          data_collector.send(:send_to_data_collector, message)
+        end
+      end
+    end
+
+    context "when the client raises a 404 exception" do
+      let(:err) do
+        response = double("Net::HTTP response", code: "404")
+        Net::HTTPClientException.new("Not Found", response)
+      end
+
+      before do
+        stub_http_client(err)
+      end
+
+      it "disables the reporter" do
+        expect(data_collector.events).to receive(:unregister).with(data_collector)
+        data_collector.send(:send_to_data_collector, message)
+      end
+
+      it "logs an error and raises when raise_on_failure is enabled" do
+        Chef::Config[:data_collector][:raise_on_failure] = true
+        expect(Chef::Log).to receive(:error)
+        expect { data_collector.send(:send_to_data_collector, message) }.to raise_error(err)
+      end
+
+      # this is different specifically for 404s
+      it "logs an info message and does not raise an exception when raise_on_failure is disabled" do
+        Chef::Config[:data_collector][:raise_on_failure] = false
+        expect(Chef::Log).to receive(:debug).with(/This is normal if you do not have Chef Automate/)
+        data_collector.send(:send_to_data_collector, message)
+      end
+    end
+  end
 end

data/spec/unit/decorator_spec.rb

@@ -28,11 +28,11 @@ def impersonates_a(klass)
   end
 
   it "#kind_of?(#{klass}) is true" do
-    expect(decorator.kind_of?(klass)).to be true
+    expect(decorator.is_a?(klass)).to be true
   end
 
   it "#kind_of?(Chef::Decorator) is true" do
-    expect(decorator.kind_of?(Chef::Decorator)).to be true
+    expect(decorator.is_a?(Chef::Decorator)).to be true
   end
 
   it "#instance_of?(#{klass}) is false" do

data/spec/unit/deprecated_spec.rb

@@ -44,7 +44,7 @@ describe Chef::Deprecated do
     let(:location) { "the location" }
 
     it "displays the full URL" do
-      expect(TestDeprecation.new().url).to eql("https://docs.chef.io/deprecations_test.html")
+      expect(TestDeprecation.new.url).to eql("https://docs.chef.io/deprecations_test.html")
     end
 
     it "formats a complete deprecation message" do
@@ -59,7 +59,7 @@ describe Chef::Deprecated do
     end
     collisions = id_map.select { |k, v| v.size != 1 }
     unless collisions.empty?
-      raise "Found deprecation ID collisions:\n#{collisions.map { |k, v| "* #{k} #{v.map(&:name).join(', ')}" }.join("\n")}"
+      raise "Found deprecation ID collisions:\n#{collisions.map { |k, v| "* #{k} #{v.map(&:name).join(", ")}" }.join("\n")}"
     end
   end
 end

data/spec/unit/dsl/data_query_spec.rb

@@ -24,7 +24,7 @@ class DataQueryDSLTester
 end
 
 describe Chef::DSL::DataQuery do
-  let(:node) { Hash.new }
+  let(:node) { {} }
 
   let(:language) do
     language = DataQueryDSLTester.new
@@ -68,7 +68,8 @@ describe Chef::DSL::DataQuery do
         "a1" => [1, 2, 3],
         "a2" => { "b1" => true },
       },
-    } end
+    }
+    end
 
     let(:item) do
       item = Chef::DataBagItem.new

data/spec/unit/dsl/declare_resource_spec.rb

@@ -34,7 +34,7 @@ describe Chef::ResourceCollection do
 
   describe "mixed in correctly" do
     it "the resources() method winds up in the right classes" do
-      methods = [ :resources, :find_resource, :find_resource!, :edit_resource, :edit_resource!, :delete_resource, :delete_resource!, :declare_resource, :build_resource ]
+      methods = %i{resources find_resource find_resource! edit_resource edit_resource! delete_resource delete_resource! declare_resource build_resource}
       expect(Chef::Resource.instance_methods).to include(*methods)
       expect(Chef::Recipe.instance_methods).to include(*methods)
       expect(Chef::Provider.instance_methods).to include(*methods)

data/spec/unit/dsl/platform_introspection_spec.rb

@@ -40,7 +40,7 @@ describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
   before do
     platform_hash = {
       :openbsd => { default: "free, functional, secure" },
-      [:redhat, :centos, :fedora, :scientific] => { default: '"stable"' },
+      %i{redhat centos fedora scientific} => { default: '"stable"' },
       :ubuntu => { "10.04" => "using upstart more", :default => "using init more" },
       :default => "bork da bork",
     }
@@ -84,7 +84,7 @@ describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
 end
 describe Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue do
   before do
-    @array_values = [:stop, :start, :reload]
+    @array_values = %i{stop start reload}
 
     @platform_family_hash = {
       "debian" => "debian value",

data/spec/unit/encrypted_data_bag_item/check_encrypted_spec.rb

@@ -47,7 +47,8 @@ describe Chef::EncryptedDataBagItem::CheckEncrypted do
             "a1" => [1, 2, 3],
             "a2" => { "b1" => true },
         },
-    } end
+    }
+    end
 
     let(:version) { 1 }
     let(:encoded_data) do

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -325,7 +325,8 @@ describe Chef::EncryptedDataBagItem do
       "id" => "item_name",
       "greeting" => "hello",
       "nested" => { "a1" => [1, 2, 3], "a2" => { "b1" => true } },
-  } end
+  }
+  end
   let(:secret) { "abc123SECRET" }
   let(:encoded_data) { subject.encrypt_data_bag_item(plaintext_data, secret) }
 

data/spec/unit/environment_spec.rb

@@ -48,8 +48,8 @@ describe Chef::Environment do
     end
 
     it "should not accept anything but strings" do
-      expect { @environment.name(Array.new) }.to raise_error(ArgumentError)
-      expect { @environment.name(Hash.new) }.to raise_error(ArgumentError)
+      expect { @environment.name([]) }.to raise_error(ArgumentError)
+      expect { @environment.name({}) }.to raise_error(ArgumentError)
       expect { @environment.name(2) }.to raise_error(ArgumentError)
     end
   end
@@ -65,8 +65,8 @@ describe Chef::Environment do
     end
 
     it "should not accept anything but strings" do
-      expect { @environment.description(Array.new) }.to raise_error(ArgumentError)
-      expect { @environment.description(Hash.new) }.to raise_error(ArgumentError)
+      expect { @environment.description([]) }.to raise_error(ArgumentError)
+      expect { @environment.description({}) }.to raise_error(ArgumentError)
       expect { @environment.description(42) }.to raise_error(ArgumentError)
     end
   end
@@ -82,7 +82,7 @@ describe Chef::Environment do
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
-      expect { @environment.default_attributes(Array.new) }.to raise_error(ArgumentError)
+      expect { @environment.default_attributes([]) }.to raise_error(ArgumentError)
     end
   end
 
@@ -97,7 +97,7 @@ describe Chef::Environment do
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
-      expect { @environment.override_attributes(Array.new) }.to raise_error(ArgumentError)
+      expect { @environment.override_attributes([]) }.to raise_error(ArgumentError)
     end
   end
 
@@ -121,7 +121,7 @@ describe Chef::Environment do
 
     it "should not accept anything but a hash" do
       expect { @environment.cookbook_versions("I am a string!") }.to raise_error(ArgumentError)
-      expect { @environment.cookbook_versions(Array.new) }.to raise_error(ArgumentError)
+      expect { @environment.cookbook_versions([]) }.to raise_error(ArgumentError)
       expect { @environment.cookbook_versions(42) }.to raise_error(ArgumentError)
     end
 
@@ -257,7 +257,7 @@ describe Chef::Environment do
     end
 
     it "should return false if anything other than a hash is passed as the argument" do
-      expect(Chef::Environment.validate_cookbook_versions(Array.new)).to eq(false)
+      expect(Chef::Environment.validate_cookbook_versions([])).to eq(false)
       expect(Chef::Environment.validate_cookbook_versions(42)).to eq(false)
       expect(Chef::Environment.validate_cookbook_versions(Chef::CookbookVersion.new("meta"))).to eq(false)
       expect(Chef::Environment.validate_cookbook_versions("cookbook => 1.2.3")).to eq(false)
@@ -299,7 +299,7 @@ describe Chef::Environment do
         expect do
           Chef::Environment.validate_cookbook_version("= 1.2.3.4")
         end.to raise_error Chef::Exceptions::IllegalVersionConstraint,
-                             /Environment cookbook version constraints not allowed in .*/
+          /Environment cookbook version constraints not allowed in .*/
       end
     end
 

data/spec/unit/event_dispatch/dsl_spec.rb

@@ -63,7 +63,7 @@ describe Chef::EventDispatch::DSL do
     resource = Chef::Resource::RubyBlock.new("foo", run_context)
     resource.block {}
     resource.run_action(:run)
-    expect(calls).to eq([:started, :updated])
+    expect(calls).to eq(%i{started updated})
   end
 
   it "preserve instance variables across handler callbacks" do

data/spec/unit/file_content_management/deploy/mv_unix_spec.rb

@@ -38,9 +38,9 @@ describe Chef::FileContentManagement::Deploy::MvUnix do
     let(:target_file_mode) { 0644 }
     let(:target_file_stat) do
       double "File::Stat struct for target file",
-           mode: target_file_mode,
-           uid: target_file_uid,
-           gid: target_file_gid
+        mode: target_file_mode,
+        uid: target_file_uid,
+        gid: target_file_gid
     end
 
     before do

data/spec/unit/file_content_management/deploy/mv_windows_spec.rb

@@ -84,8 +84,8 @@ describe Chef::FileContentManagement::Deploy::MvWindows do
 
       let(:target_file_security_descriptor) do
         double "security descriptor for target file",
-             group: original_target_file_group,
-             owner: original_target_file_owner
+          group: original_target_file_group,
+          owner: original_target_file_owner
       end
 
       let(:updated_target_security_descriptor) do

data/spec/unit/formatters/error_inspectors/resource_failure_inspector_spec.rb

@@ -60,7 +60,7 @@ describe Chef::Formatters::ErrorInspectors::ResourceFailureInspector do
       @trace = [
         "/var/chef/cache/cookbooks/syntax-err/recipes/default.rb:14:in `from_file'",
         "/var/chef/cache/cookbooks/syntax-err/recipes/default.rb:11:in `from_file'",
-        "/usr/local/lib/ruby/gems/chef/lib/chef/client.rb:123:in `run'" # should not display
+        "/usr/local/lib/ruby/gems/chef/lib/chef/client.rb:123:in `run'", # should not display
       ]
       @exception = Chef::Exceptions::Package.new("No such package 'non-existing-package'")
       @exception.set_backtrace(@trace)
@@ -122,7 +122,7 @@ describe Chef::Formatters::ErrorInspectors::ResourceFailureInspector do
         source_line = "C:/Users/btm/chef/chef/spec/unit/fake_file.rb:2: undefined local variable or method `non_existent' for main:Object (NameError)"
         @resource.source_line = source_line
         @inspector = Chef::Formatters::ErrorInspectors::ResourceFailureInspector.new(@resource, :create, @exception)
-        expect(@inspector.recipe_snippet).to match(/^# In C:\/Users\/btm/)
+        expect(@inspector.recipe_snippet).to match(%r{^# In C:/Users/btm})
       end
 
       it "parses a Windows path" do
@@ -136,7 +136,7 @@ describe Chef::Formatters::ErrorInspectors::ResourceFailureInspector do
         source_line = "/home/btm/src/chef/chef/spec/unit/fake_file.rb:2: undefined local variable or method `non_existent' for main:Object (NameError)"
         @resource.source_line = source_line
         @inspector = Chef::Formatters::ErrorInspectors::ResourceFailureInspector.new(@resource, :create, @exception)
-        expect(@inspector.recipe_snippet).to match(/^# In \/home\/btm/)
+        expect(@inspector.recipe_snippet).to match(%r{^# In /home/btm})
       end
 
       context "when the recipe file does not exist" do

data/spec/unit/guard_interpreter/resource_guard_interpreter_spec.rb

@@ -22,7 +22,7 @@ describe Chef::GuardInterpreter::ResourceGuardInterpreter do
   let(:node) do
     node = Chef::Node.new
 
-    node.default["kernel"] = Hash.new
+    node.default["kernel"] = {}
     node.default["kernel"][:machine] = :x86_64.to_s
     node.automatic[:os] = "windows"
     node

data/spec/unit/http/authenticator_spec.rb

@@ -23,7 +23,7 @@ describe Chef::HTTP::Authenticator do
   let(:class_instance) { Chef::HTTP::Authenticator.new(client_name: "test") }
   let(:method) { "GET" }
   let(:url) { URI("https://chef.example.com/organizations/test") }
-  let(:headers) { Hash.new }
+  let(:headers) { {} }
   let(:data) { "" }
 
   context "when handle_request is called" do
@@ -92,7 +92,8 @@ describe Chef::HTTP::Authenticator do
       it "calls authentication_headers with the proper input" do
         expect(class_instance).to receive(:authentication_headers).with(
           method, url, data,
-          { "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION }).and_return({})
+          { "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION }
+        ).and_return({})
         class_instance.handle_request(method, url, headers, data)
       end
     end

data/spec/unit/http/json_input_spec.rb

@@ -21,7 +21,7 @@ require "chef/http/json_input"
 
 describe Chef::HTTP::JSONInput do
 
-  let(:json_encoder) { described_class.new() }
+  let(:json_encoder) { described_class.new }
 
   let(:url) { URI.parse("http://example.com") }
   let(:headers) { {} }

data/spec/unit/key_spec.rb

@@ -66,7 +66,7 @@ describe Chef::Key do
 
     context "when you feed it anything but a string" do
       it "should raise an ArgumentError" do
-        expect { key.send(field, Hash.new) }.to raise_error(ArgumentError)
+        expect { key.send(field, {}) }.to raise_error(ArgumentError)
       end
     end
   end
@@ -406,9 +406,9 @@ describe Chef::Key do
 
           it "creates a new key via the API with the fingerprint as the name" do
             expect(rest).to receive(:post).with(url,
-                                                     { "name" => "12:3e:33:73:0b:f4:ec:72:dc:f0:4c:51:62:27:08:76:96:24:f4:4a",
-                                                       "public_key" => key.public_key,
-                                                       "expiration_date" => key.expiration_date }).and_return({})
+              { "name" => "12:3e:33:73:0b:f4:ec:72:dc:f0:4c:51:62:27:08:76:96:24:f4:4a",
+                "public_key" => key.public_key,
+                "expiration_date" => key.expiration_date }).and_return({})
             key.create
           end
         end
@@ -424,9 +424,9 @@ describe Chef::Key do
           context "when create_key is false" do
             it "creates a new key via the API" do
               expect(rest).to receive(:post).with(url,
-                                                       { "name" => key.name,
-                                                         "public_key" => key.public_key,
-                                                         "expiration_date" => key.expiration_date }).and_return({})
+                { "name" => key.name,
+                  "public_key" => key.public_key,
+                  "expiration_date" => key.expiration_date }).and_return({})
               key.create
             end
           end

data/spec/unit/knife/bootstrap/train_connector_spec.rb

@@ -155,21 +155,26 @@ describe Chef::Knife::Bootstrap::TrainConnector do
     context "under linux and unix-like" do
       let(:family) { "debian" }
       let(:name) { "ubuntu" }
+      let(:random) { "wScHX6" }
+      let(:dir) { "/tmp/chef_#{random}" }
+
+      before do
+        allow(SecureRandom).to receive(:alphanumeric).with(6).and_return(random)
+      end
+
       it "uses the *nix command to create the temp dir and sets ownership to logged-in user" do
-        expected_command = Chef::Knife::Bootstrap::TrainConnector::MKTEMP_NIX_COMMAND
+        expected_command = "mkdir -p #{dir} && sudo chown user1 '#{dir}'"
         expect(subject).to receive(:run_command!).with(expected_command)
-          .and_return double("result", stdout: "/a/path")
-        expect(subject).to receive(:run_command!).with("chown user1 '/a/path'")
-        expect(subject.temp_dir).to eq "/a/path"
+          .and_return double("result", stdout: "\r\n")
+        expect(subject.temp_dir).to eq(dir)
       end
 
       context "with noise in stderr" do
         it "uses the *nix command to create the temp dir and sets ownership to logged-in user" do
-          expected_command = Chef::Knife::Bootstrap::TrainConnector::MKTEMP_NIX_COMMAND
+          expected_command = "mkdir -p #{dir} && sudo chown user1 '#{dir}'"
           expect(subject).to receive(:run_command!).with(expected_command)
-            .and_return double("result", stdout: "sudo: unable to resolve host hostname.localhost\r\n" + "/a/path\r\n")
-          expect(subject).to receive(:run_command!).with("chown user1 '/a/path'")
-          expect(subject.temp_dir).to eq "/a/path"
+            .and_return double("result", stdout: "sudo: unable to resolve host hostname.localhost\r\n" + "#{dir}\r\n")
+          expect(subject.temp_dir).to eq(dir)
         end
       end
     end

data/spec/unit/knife/bootstrap_spec.rb

@@ -33,9 +33,10 @@ describe Chef::Knife::Bootstrap do
 
   let(:connection) do
     double("TrainConnector",
-                            windows?: windows_test,
-                            linux?: linux_test,
-                            unix?: unix_test) end
+      windows?: windows_test,
+      linux?: linux_test,
+      unix?: unix_test)
+  end
 
   let(:knife) do
     Chef::Log.logger = Logger.new(StringIO.new)
@@ -107,7 +108,7 @@ describe Chef::Knife::Bootstrap do
         expect(knife).to receive(:read_secret).and_return("secrets")
         expect(rendered_template).to match("cat > /etc/chef/encrypted_data_bag_secret <<'EOP'")
         expect(rendered_template).to match('{"run_list":\[\]}')
-        expect(rendered_template).to match(%r{secrets})
+        expect(rendered_template).to match(/secrets/)
       end
     end
   end
@@ -127,7 +128,7 @@ describe Chef::Knife::Bootstrap do
       knife.render_template
     end
     it "configures the preinstall command in the bootstrap template correctly" do
-      expect(rendered_template).to match(%r{command})
+      expect(rendered_template).to match(/command/)
     end
   end
 
@@ -138,7 +139,7 @@ describe Chef::Knife::Bootstrap do
       knife.render_template
     end
     it "configures the https_proxy environment variable in the bootstrap template correctly" do
-      expect(rendered_template).to match(%r{https_proxy="1.1.1.1" export https_proxy})
+      expect(rendered_template).to match(/https_proxy="1.1.1.1" export https_proxy/)
     end
   end
 
@@ -149,7 +150,7 @@ describe Chef::Knife::Bootstrap do
       knife.render_template
     end
     it "configures the https_proxy environment variable in the bootstrap template correctly" do
-      expect(rendered_template).to match(%r{no_proxy="localserver" export no_proxy})
+      expect(rendered_template).to match(/no_proxy="localserver" export no_proxy/)
     end
   end
 
@@ -360,7 +361,7 @@ describe Chef::Knife::Bootstrap do
     it "should create a hint file when told to" do
       knife.parse_options(["--hint", "openstack"])
       knife.merge_configs
-      expect(knife.render_template).to match(/\/etc\/chef\/ohai\/hints\/openstack.json/)
+      expect(knife.render_template).to match(%r{/etc/chef/ohai/hints/openstack.json})
     end
 
     it "should populate a hint file with JSON when given a file to read" do
@@ -393,7 +394,7 @@ describe Chef::Knife::Bootstrap do
       let(:setting) { "api.opscode.com" }
 
       it "renders the client.rb with a single FQDN no_proxy entry" do
-        expect(rendered_template).to match(%r{.*no_proxy\s*"api.opscode.com".*})
+        expect(rendered_template).to match(/.*no_proxy\s*"api.opscode.com".*/)
       end
     end
 
@@ -401,7 +402,7 @@ describe Chef::Knife::Bootstrap do
       let(:setting) { "api.opscode.com,172.16.10.*" }
 
       it "renders the client.rb with comma-separated FQDN and wildcard IP address no_proxy entries" do
-        expect(rendered_template).to match(%r{.*no_proxy\s*"api.opscode.com,172.16.10.\*".*})
+        expect(rendered_template).to match(/.*no_proxy\s*"api.opscode.com,172.16.10.\*".*/)
       end
     end
 
@@ -459,7 +460,7 @@ describe Chef::Knife::Bootstrap do
     it "creates a secret file" do
       expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
       expect(knife).to receive(:read_secret).and_return(secret)
-      expect(rendered_template).to match(%r{#{secret}})
+      expect(rendered_template).to match(/#{secret}/)
     end
 
     it "renders the client.rb with an encrypted_data_bag_secret entry" do
@@ -569,7 +570,9 @@ describe Chef::Knife::Bootstrap do
     context "when client_d_dir is set" do
       let(:client_d_dir) do
         Chef::Util::PathHelper.cleanpath(
-          File.join(File.dirname(__FILE__), "../../data/client.d_00")) end
+          File.join(File.dirname(__FILE__), "../../data/client.d_00")
+        )
+      end
 
       it "creates /etc/chef/client.d" do
         expect(rendered_template).to match("mkdir -p /etc/chef/client\.d")
@@ -594,7 +597,9 @@ describe Chef::Knife::Bootstrap do
       context "a nested directory structure" do
         let(:client_d_dir) do
           Chef::Util::PathHelper.cleanpath(
-            File.join(File.dirname(__FILE__), "../../data/client.d_01")) end
+            File.join(File.dirname(__FILE__), "../../data/client.d_01")
+          )
+        end
         it "creates a file foo/bar.rb" do
           expect(rendered_template).to match("cat > /etc/chef/client.d/foo/bar.rb <<'EOP'")
           expect(rendered_template).to match("1 / 0")
@@ -1554,7 +1559,8 @@ describe Chef::Knife::Bootstrap do
         ssl: false,
         ssl_peer_fingerprint: nil,
         operation_timeout: 60,
-      } end
+      }
+      end
 
       it "generates a correct configuration hash with expected defaults" do
         expect(knife.winrm_opts).to eq expected
@@ -1730,7 +1736,7 @@ describe Chef::Knife::Bootstrap do
       before do
         Chef::Config[:validation_key] = "/blah"
         allow(vault_handler_mock).to receive(:doing_chef_vault?).and_return false
-        allow(File).to receive(:exist?).with(/\/blah/).and_return false
+        allow(File).to receive(:exist?).with(%r{/blah}).and_return false
       end
       it_behaves_like "creating the client locally"
     end
@@ -1738,7 +1744,7 @@ describe Chef::Knife::Bootstrap do
     context "when a valid validation key is given and we're doing old-style client creation" do
       before do
         Chef::Config[:validation_key] = "/blah"
-        allow(File).to receive(:exist?).with(/\/blah/).and_return true
+        allow(File).to receive(:exist?).with(%r{/blah}).and_return true
         allow(vault_handler_mock).to receive(:doing_chef_vault?).and_return false
       end