chef 18.8.11 → 18.8.46

data/spec/unit/shell/shell_ext_spec.rb

@@ -1,196 +0,0 @@
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
-# 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 Shell::Extensions do
-  let(:test_shell_session) do
-    Class.new(Shell::ShellSession) do
-      def rebuild_node
-        nil
-      end
-
-      def rebuild_collection
-        nil
-      end
-
-      def loading
-        nil
-      end
-
-      def loading_complete
-        nil
-      end
-    end
-  end
-
-  let(:test_job_manager) do
-    Class.new do
-      attr_accessor :jobs
-    end
-  end
-
-  let(:object_test_harness) do
-    Proc.new do
-      extend Shell::Extensions::ObjectCoreExtensions
-
-      def conf=(new_conf)
-        @conf = new_conf
-      end
-
-      def conf
-        @conf
-      end
-
-      desc "rspecin'"
-      def rspec_method; end
-    end
-  end
-
-  describe "extending object for top level methods" do
-
-    before do
-      @shell_client = test_shell_session.instance
-      allow(Shell).to receive(:session).and_return(@shell_client)
-      @job_manager = test_job_manager.new
-      @root_context = Object.new
-      @root_context.instance_eval(&object_test_harness)
-      Shell::Extensions.extend_context_object(@root_context)
-      @root_context.conf = double("irbconf")
-    end
-
-    it "finds a subsession in irb for an object" do
-      target_context_obj = Chef::Node.new
-
-      irb_context = double("context", main: target_context_obj)
-      irb_session = double("irb session", context: irb_context)
-      @job_manager.jobs = [[:thread, irb_session]]
-      allow(@root_context).to receive(:jobs).and_return(@job_manager)
-      @root_context.ensure_session_select_defined
-      expect(@root_context.jobs.select_shell_session(target_context_obj)).to eq(irb_session)
-      expect(@root_context.jobs.select_shell_session(:idontexist)).to be_nil
-    end
-
-    it "finds, then switches to a session" do
-      @job_manager.jobs = []
-      allow(@root_context).to receive(:ensure_session_select_defined)
-      allow(@root_context).to receive(:jobs).and_return(@job_manager)
-      expect(@job_manager).to receive(:select_shell_session).and_return(:the_shell_session)
-      expect(@job_manager).to receive(:switch).with(:the_shell_session)
-      @root_context.find_or_create_session_for(:foo)
-    end
-
-    it "creates a new session if an existing one isn't found" do
-      @job_manager.jobs = []
-      allow(@root_context).to receive(:jobs).and_return(@job_manager)
-      allow(@job_manager).to receive(:select_shell_session).and_return(nil)
-      expect(@root_context).to receive(:irb).with(:foo)
-      @root_context.find_or_create_session_for(:foo)
-    end
-
-    it "switches to recipe context" do
-      expect(@root_context).to respond_to(:recipe_mode)
-      @shell_client.recipe = :monkeyTime
-      expect(@root_context).to receive(:find_or_create_session_for).with(:monkeyTime)
-      @root_context.recipe_mode
-    end
-
-    it "switches to attribute context" do
-      expect(@root_context).to respond_to(:attributes_mode)
-      @shell_client.node = "monkeyNodeTime"
-      expect(@root_context).to receive(:find_or_create_session_for).with("monkeyNodeTime")
-      @root_context.attributes_mode
-    end
-
-    it "has a help command" do
-      expect(@root_context).to respond_to(:help)
-    end
-
-    it "turns irb tracing on and off" do
-      expect(@root_context).to respond_to(:trace)
-      expect(@root_context.conf).to receive(:use_tracer=).with(true)
-      allow(@root_context).to receive(:tracing?)
-      @root_context.tracing :on
-    end
-
-    it "says if tracing is on or off" do
-      allow(@root_context.conf).to receive(:use_tracer).and_return(true)
-      expect(@root_context).to receive(:puts).with("tracing is on")
-      @root_context.tracing?
-    end
-
-    it "prints node attributes" do
-      node = double("node", attribute: { foo: :bar })
-      @shell_client.node = node
-      expect(@root_context).to receive(:pp).with({ foo: :bar })
-      @root_context.ohai
-      expect(@root_context).to receive(:pp).with(:bar)
-      @root_context.ohai(:foo)
-    end
-
-    it "resets the recipe and reloads ohai data" do
-      expect(@shell_client).to receive(:reset!)
-      @root_context.reset
-    end
-
-    it "turns irb echo on and off" do
-      expect(@root_context.conf).to receive(:echo=).with(true)
-      @root_context.echo :on
-    end
-
-    it "says if echo is on or off" do
-      allow(@root_context.conf).to receive(:echo).and_return(true)
-      expect(@root_context).to receive(:puts).with("echo is on")
-      @root_context.echo?
-    end
-
-    it "gives access to the stepable iterator" do
-      allow(Shell::StandAloneSession.instance).to receive(:reset!)
-      allow(Shell.session).to receive(:rebuild_context)
-      events = Chef::EventDispatch::Dispatcher.new
-      run_context = Chef::RunContext.new(Chef::Node.new, {}, events)
-      run_context.resource_collection.instance_variable_get(:@resource_list).instance_variable_set(:@iterator, :the_iterator)
-      Shell.session.run_context = run_context
-      expect(@root_context.chef_run).to eq(:the_iterator)
-    end
-
-    it "lists directory contents" do
-      entries = %w{. .. someFile}
-      expect(Dir).to receive(:entries).with("/tmp").and_return(entries)
-      @root_context.ls "/tmp"
-    end
-
-  end
-
-  describe "extending the recipe object" do
-
-    before do
-      @events = Chef::EventDispatch::Dispatcher.new
-      @run_context = Chef::RunContext.new(Chef::Node.new, {}, @events)
-      @recipe_object = Chef::Recipe.new(nil, nil, @run_context)
-      Shell::Extensions.extend_context_recipe(@recipe_object)
-    end
-
-    it "gives a list of the resources" do
-      resource = @recipe_object.file("foo")
-      expect(@recipe_object).to receive(:pp).with(["file[foo]"])
-      @recipe_object.resources
-    end
-
-  end
-end

data/spec/unit/shell/shell_session_spec.rb

@@ -1,218 +0,0 @@
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
-# 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"
-require "ostruct"
-
-describe Shell::ShellSession do
-  it "is a singleton object" do
-    expect(Shell::ShellSession).to include(Singleton)
-  end
-end
-
-describe Shell::ClientSession do
-  let(:json_attribs) { { "a" => "b" } }
-  let(:chef_rest) { double("Chef::ServerAPI") }
-  let(:node) { Chef::Node.build("foo") }
-  let(:session) { Shell::ClientSession.instance }
-  let(:client) do
-    double("Chef::Client.new",
-      run_ohai: true,
-      load_node: true,
-      build_node: true,
-      register: true,
-      sync_cookbooks: {})
-  end
-
-  before do
-    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
-    session.node = node
-    session.json_configuration = json_attribs
-  end
-
-  it "builds the node's run_context with the proper environment" do
-    session.instance_variable_set(:@client, client)
-    expansion = Chef::RunList::RunListExpansion.new(node.chef_environment, [])
-
-    expect(node.run_list).to receive(:expand).with(node.chef_environment).and_return(expansion)
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
-    session.rebuild_context
-  end
-
-  it "passes the shell CLI args to the client" do
-    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
-    session.send(:rebuild_node)
-  end
-
-end
-
-describe Shell::SoloSession do
-  let(:json_attribs) { { "a" => "b" } }
-  let(:chef_rest) { double("Chef::ServerAPI") }
-  let(:node) { Chef::Node.build("foo") }
-  let(:session) { Shell::SoloSession.instance }
-  let(:client) do
-    double("Chef::Client.new",
-      run_ohai: true,
-      load_node: true,
-      build_node: true,
-      register: true,
-      sync_cookbooks: {})
-  end
-
-  before do
-    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
-    session.node = node
-    session.json_configuration = json_attribs
-  end
-
-  it "builds the node's run_context with the proper environment" do
-    session.instance_variable_set(:@client, client)
-    expansion = Chef::RunList::RunListExpansion.new(node.chef_environment, [])
-
-    expect(node.run_list).to receive(:expand).with(node.chef_environment).and_return(expansion)
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
-    session.rebuild_context
-  end
-
-  it "passes the shell CLI args to the client" do
-    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
-    session.send(:rebuild_node)
-  end
-
-end
-
-describe Shell::StandAloneSession do
-  let(:json_attribs) { { "a" => "b" } }
-  let(:node) { Chef::Node.new }
-  let(:session) { Shell::StandAloneSession.instance }
-  let(:recipe) { Chef::Recipe.new(nil, nil, run_context) }
-  let(:run_context) { Chef::RunContext.new(node, {}, Chef::EventDispatch::Dispatcher.new) }
-
-  before do
-    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
-    session.node = node
-    session.json_configuration = json_attribs
-    session.run_context = run_context
-    session.recipe = recipe
-    Shell::Extensions.extend_context_recipe(recipe)
-  end
-
-  it "has a run_context" do
-    expect(session.run_context).to equal(run_context)
-  end
-
-  it "returns a collection based on it's standalone recipe file" do
-    expect(session.resource_collection).to eq(recipe.run_context.resource_collection)
-  end
-
-  it "gives nil for the definitions (for now)" do
-    expect(session.definitions).to be_nil
-  end
-
-  it "gives nil for the cookbook_loader" do
-    expect(session.cookbook_loader).to be_nil
-  end
-
-  it "runs chef with the standalone recipe" do
-    allow(session).to receive(:node_built?).and_return(true)
-    allow(Chef::Log).to receive(:level)
-    chef_runner = double("Chef::Runner.new", converge: :converged)
-    # pre-heat resource collection cache
-    session.resource_collection
-
-    expect(Chef::Runner).to receive(:new).with(session.recipe.run_context).and_return(chef_runner)
-    expect(recipe.run_chef).to eq(:converged)
-  end
-
-  it "passes the shell CLI args to the client" do
-    client = double("Chef::Client.new",
-      run_ohai: true,
-      load_node: true,
-      build_node: true,
-      register: true,
-      sync_cookbooks: {})
-    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
-    session.send(:rebuild_node)
-  end
-
-end
-
-describe Shell::SoloLegacySession do
-  let(:json_attribs) { { "a" => "b" } }
-  let(:node) { Chef::Node.new }
-  let(:session) { Shell::SoloLegacySession.instance }
-  let(:recipe) { Chef::Recipe.new(nil, nil, run_context) }
-  let(:run_context) { Chef::RunContext.new(node, {}, Chef::EventDispatch::Dispatcher.new) }
-
-  before do
-    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
-    Chef::Config[:solo_legacy_shell] = true
-    session.node = node
-    session.json_configuration = json_attribs
-    session.run_context = run_context
-    session.recipe = recipe
-    Shell::Extensions.extend_context_recipe(recipe)
-  end
-
-  it "returns a collection based on it's compilation object and the extra recipe provided by chef-shell" do
-    allow(session).to receive(:node_built?).and_return(true)
-    kitteh = Chef::Resource::Cat.new("keyboard")
-    recipe.run_context.resource_collection << kitteh
-    expect(session.resource_collection.include?(kitteh)).to be true
-  end
-
-  it "returns definitions from its compilation object" do
-    expect(session.definitions).to eq(run_context.definitions)
-  end
-
-  it "keeps json attribs and passes them to the node for consumption" do
-    session.node_attributes = { "besnard_lakes" => "are_the_dark_horse" }
-    expect(session.node["besnard_lakes"]).to eq("are_the_dark_horse")
-    # pending "1) keep attribs in an ivar 2) pass them to the node 3) feed them to the node on reset"
-  end
-
-  it "generates its resource collection from the compiled cookbooks and the ad hoc recipe" do
-    allow(session).to receive(:node_built?).and_return(true)
-    kitteh_cat = Chef::Resource::Cat.new("kitteh")
-    run_context.resource_collection << kitteh_cat
-    keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
-    recipe.run_context.resource_collection << keyboard_cat
-    # session.rebuild_collection
-    expect(session.resource_collection.include?(kitteh_cat)).to be true
-    expect(session.resource_collection.include?(keyboard_cat)).to be true
-  end
-
-  it "runs chef with a resource collection from the compiled cookbooks" do
-    allow(session).to receive(:node_built?).and_return(true)
-    chef_runner = double("Chef::Runner.new", converge: :converged)
-    expect(Chef::Runner).to receive(:new).with(session.recipe.run_context).and_return(chef_runner)
-
-    expect(recipe.run_chef).to eq(:converged)
-  end
-
-  it "passes the shell CLI args to the client" do
-    client = double("Chef::Client.new",
-      run_ohai: true,
-      load_node: true,
-      build_node: true,
-      register: true,
-      sync_cookbooks: {})
-    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
-    session.send(:rebuild_node)
-  end
-end

data/spec/unit/shell_spec.rb

@@ -1,178 +0,0 @@
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
-# 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"
-require "ostruct"
-
-describe Shell do
-  let(:object_test_harness) do
-    Proc.new do
-      extend Shell::Extensions::ObjectCoreExtensions
-
-      def conf=(new_conf)
-        @conf = new_conf
-      end
-
-      def conf
-        @conf
-      end
-
-      desc "rspecin'"
-      def rspec_method; end
-    end
-  end
-
-  before do
-    Shell.irb_conf = {}
-    allow(Shell::ShellSession.instance).to receive(:reset!)
-    allow(ChefUtils).to receive(:windows?).and_return(false)
-    allow(Chef::Util::PathHelper).to receive(:home).and_return("/home/foo")
-  end
-
-  describe "reporting its status" do
-
-    it "always says it is running" do
-      expect(Shell).to be_running
-    end
-
-  end
-
-  describe "configuring IRB" do
-    it "configures irb history" do
-      Shell.configure_irb
-      expect(Shell.irb_conf[:HISTORY_FILE]).to eq(Chef::Util::PathHelper.home(".chef", "chef_shell_history"))
-      expect(Shell.irb_conf[:SAVE_HISTORY]).to eq(1000)
-    end
-
-    it "has a prompt like ``chef > '' in the default context" do
-      Shell.configure_irb
-
-      conf = OpenStruct.new
-      conf.main = Object.new
-      conf.main.instance_eval(&object_test_harness)
-      Shell.irb_conf[:IRB_RC].call(conf)
-      if RUBY_VERSION >= "3.3.0"
-        expect(conf.prompt_c).to      eq("chef > ")
-        expect(conf.prompt_n).to      eq("chef ?> ")
-        expect(conf.prompt_s).to      eq("chef%l> ")
-      else
-        expect(conf.prompt_c).to      eq("chef (#{Chef::VERSION})> ")
-        expect(conf.prompt_n).to      eq("chef(#{Chef::VERSION})?> ")
-        expect(conf.prompt_s).to      eq("chef(#{Chef::VERSION})%l> ")
-      end
-      expect(conf.return_format).to eq(" => %s \n")
-      expect(conf.prompt_i).to      eq("chef (#{Chef::VERSION})> ")
-      expect(conf.use_tracer).to    eq(false)
-    end
-
-    it "has a prompt like ``chef:recipe > '' in recipe context" do
-      Shell.configure_irb
-
-      conf = OpenStruct.new
-      events = Chef::EventDispatch::Dispatcher.new
-      conf.main = Chef::Recipe.new(nil, nil, Chef::RunContext.new(Chef::Node.new, {}, events))
-      Shell.irb_conf[:IRB_RC].call(conf)
-      if RUBY_VERSION >= "3.3.0"
-        expect(conf.prompt_c).to eq("chef:recipe > ")
-        expect(conf.prompt_n).to eq("chef:recipe ?> ")
-        expect(conf.prompt_s).to eq("chef:recipe%l> ")
-      else
-        expect(conf.prompt_c).to eq("chef:recipe (#{Chef::VERSION})> ")
-        expect(conf.prompt_n).to eq("chef:recipe(#{Chef::VERSION})?> ")
-        expect(conf.prompt_s).to eq("chef:recipe(#{Chef::VERSION})%l> ")
-      end
-
-      expect(conf.prompt_i).to eq("chef:recipe (#{Chef::VERSION})> ")
-    end
-
-    it "has a prompt like ``chef:attributes > '' in attributes/node context" do
-      Shell.configure_irb
-
-      conf = OpenStruct.new
-      conf.main = Chef::Node.new
-      Shell.irb_conf[:IRB_RC].call(conf)
-
-      if RUBY_VERSION >= "3.3.0"
-        expect(conf.prompt_c).to eq("chef:attributes > ")
-        expect(conf.prompt_n).to eq("chef:attributes ?> ")
-        expect(conf.prompt_s).to eq("chef:attributes%l> ")
-      else
-        expect(conf.prompt_c).to eq("chef:attributes (#{Chef::VERSION})> ")
-        expect(conf.prompt_n).to eq("chef:attributes(#{Chef::VERSION})?> ")
-        expect(conf.prompt_s).to eq("chef:attributes(#{Chef::VERSION})%l> ")
-      end
-      expect(conf.prompt_i).to eq("chef:attributes (#{Chef::VERSION})> ")
-    end
-
-  end
-
-  describe "convenience macros for creating the chef object" do
-
-    before do
-      @chef_object = Object.new
-      @chef_object.instance_eval(&object_test_harness)
-    end
-
-    it "creates help text for methods with descriptions" do
-      expect(@chef_object.help_descriptions).to eq([Shell::Extensions::Help.new("rspec_method", "rspecin'", nil)])
-    end
-
-    it "adds help text when a new method is described then defined" do
-      describe_define = <<-EVAL
-        desc "foo2the Bar"
-        def baz
-        end
-      EVAL
-      @chef_object.instance_eval describe_define
-      expect(@chef_object.help_descriptions).to eq([Shell::Extensions::Help.new("rspec_method", "rspecin'"),
-                                                Shell::Extensions::Help.new("baz", "foo2the Bar")])
-    end
-
-    it "adds help text for subcommands" do
-      describe_define = <<-EVAL
-        subcommands :baz_obj_command => "something you can do with baz.baz_obj_command"
-        def baz
-        end
-      EVAL
-      @chef_object.instance_eval describe_define
-      expected_help_text_fragments = [Shell::Extensions::Help.new("rspec_method", "rspecin'")]
-      expected_help_text_fragments << Shell::Extensions::Help.new("baz.baz_obj_command", "something you can do with baz.baz_obj_command")
-      expect(@chef_object.help_descriptions).to eq(expected_help_text_fragments)
-    end
-
-    it "doesn't add previous subcommand help to commands defined afterward" do
-      describe_define = <<-EVAL
-        desc "swingFromTree"
-        def monkey_time
-        end
-
-        def super_monkey_time
-        end
-
-      EVAL
-      @chef_object.instance_eval describe_define
-      expect(@chef_object.help_descriptions.size).to eq(2)
-      expect(@chef_object.help_descriptions.select { |h| h.cmd == "super_monkey_time" }).to be_empty
-    end
-
-    it "creates a help banner with the command descriptions" do
-      expect(@chef_object.help_banner).to match(/^\|\ Command\s+\|\ Description\s*$/)
-      expect(@chef_object.help_banner).to match(/^\|\ rspec_method\s+\|\ rspecin\'\s*$/)
-    end
-  end
-
-end

data/spec/unit/train_transport_spec.rb

@@ -1,85 +0,0 @@
-#
-# Author:: Bryan McLellan (<btm@loftninjas.org>)
-# 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::TrainTransport do
-  let(:transport) { Chef::TrainTransport.new(Chef::Log) }
-
-  describe "load_credentials" do
-    let(:good_credentials) { { "switch.cisco.com" => { "user" => "cisco", "password" => "cisco", "enable_password" => "secret" } } }
-
-    before do
-      allow(transport).to receive(:parse_credentials_file).and_return(good_credentials)
-    end
-
-    it "matches credentials when they exist" do
-      expect(transport.load_credentials("switch.cisco.com")[:user]).to eq("cisco")
-      expect(transport.load_credentials("switch.cisco.com")[:password]).to eq("cisco")
-      expect(transport.load_credentials("switch.cisco.com")[:enable_password]).to eq("secret")
-    end
-
-    it "returns nil if there is no match" do
-      expect(transport.load_credentials("router.unicorns.com")).to be_nil
-    end
-
-    # [foo.example.org]   => {"foo"=>{"example"=>{"org"=>{}}}}
-    # ['foo.example.org'] => {"foo.example.org"=>{}}
-    it "warns if the host has been split by toml" do
-      allow(transport).to receive(:credentials_file_path).and_return("/Users/scotthourglass/.chef/credentials")
-      allow(transport).to receive(:parse_credentials_file).and_return({ "foo" => { "example" => { "org" => {} } } })
-      expect(Chef::Log).to receive(:warn).with(/as a Hash/)
-      expect(Chef::Log).to receive(:warn).with(/Hostnames must be surrounded by single quotes/)
-      expect(transport.load_credentials("foo.example.org")).to be_nil
-    end
-  end
-
-  describe "credentials_file_path" do
-    let(:config_cred_file_path) { "/somewhere/credentials" }
-    let(:host_cred_file_path) { Chef::Platform.windows? ? "C:\\chef\\foo.example.org\\credentials" : "/etc/chef/foo.example.org/credentials" }
-
-    context "when a file path is specified by a config" do
-      before do
-        tm_config = double("Config Context", host: "foo.example.org", credentials_file: config_cred_file_path)
-        allow(Chef::Config).to receive(:target_mode).and_return(tm_config)
-      end
-
-      it "returns the path if it exists" do
-        allow(File).to receive(:exist?).with(config_cred_file_path).and_return(true)
-        expect(transport.credentials_file_path).to eq(config_cred_file_path)
-      end
-
-      it "raises an error if it does not exist" do
-        allow(File).to receive(:exist?).and_return(false)
-        expect { transport.credentials_file_path }.to raise_error(ArgumentError, /does not exist/)
-      end
-    end
-
-    it "raises an error if the default creds files do not exist" do
-      allow(File).to receive(:exist?).and_return(false)
-      expect { transport.credentials_file_path }.to raise_error(ArgumentError, /does not exist/)
-    end
-
-    it "returns the path to the default config file if it exists" do
-      tm_config = double("Config Context", host: "foo.example.org", credentials_file: nil)
-      allow(Chef::Config).to receive(:target_mode).and_return(tm_config)
-      allow(File).to receive(:exist?).with(host_cred_file_path).and_return(true)
-      expect(transport.credentials_file_path).to eq(host_cred_file_path)
-    end
-  end
-end