chef 14.15.6-universal-mingw32 → 15.0.293-universal-mingw32

data/spec/unit/provider/dsc_script_spec.rb

@@ -1,173 +1,173 @@
-#
-# Author:: Jay Mundrawala (<jdm@chef.io>)
-#
-# Copyright:: Copyright 2014-2016, 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 "chef"
-require "chef/util/dsc/resource_info"
-require "spec_helper"
-
-describe Chef::Provider::DscScript do
-  context "when DSC is available" do
-    let (:node) do
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = "4.0"
-      node
-    end
-    let (:events) { Chef::EventDispatch::Dispatcher.new }
-    let (:run_context) { Chef::RunContext.new(node, {}, events) }
-    let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
-    let (:provider) do
-      Chef::Provider::DscScript.new(resource, run_context)
-    end
-
-    describe "#load_current_resource" do
-      it "describes the resource as converged if there were 0 DSC resources" do
-        allow(provider).to receive(:run_configuration).with(:test).and_return([])
-        provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
-      end
-
-      it "describes the resource as not converged if there is 1 DSC resources that is converged" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-        provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
-      end
-
-      it "describes the resource as not converged if there is 1 DSC resources that is not converged" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", true, ["will change something"])
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-        provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_falsey
-      end
-
-      it "describes the resource as not converged if there are any DSC resources that are not converged" do
-        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new("resource", true, ["will change something"])
-        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
-
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
-        provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_falsey
-      end
-
-      it "describes the resource as converged if all DSC resources that are converged" do
-        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
-        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
-
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
-        provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
-      end
-    end
-
-    describe "#generate_configuration_document" do
-      # I think integration tests should cover these cases
-
-      it "uses configuration_document_from_script_path when a dsc script file is given" do
-        allow(provider).to receive(:load_current_resource)
-        resource.command("path_to_script")
-        generator = double("Chef::Util::DSC::ConfigurationGenerator")
-        expect(generator).to receive(:configuration_document_from_script_path)
-        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-        provider.send(:generate_configuration_document, "tmp", nil)
-      end
-
-      it "uses configuration_document_from_script_code when a the dsc resource is given" do
-        allow(provider).to receive(:load_current_resource)
-        resource.code("ImADSCResource{}")
-        generator = double("Chef::Util::DSC::ConfigurationGenerator")
-        expect(generator).to receive(:configuration_document_from_script_code)
-        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-        provider.send(:generate_configuration_document, "tmp", nil)
-      end
-
-      it "should noop if neither code or command are provided" do
-        allow(provider).to receive(:load_current_resource)
-        generator = double("Chef::Util::DSC::ConfigurationGenerator")
-        expect(generator).to receive(:configuration_document_from_script_code).with("", anything, anything, anything)
-        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-        provider.send(:generate_configuration_document, "tmp", nil)
-      end
-    end
-
-    describe "action_run" do
-      it "should converge the script if it is not converged" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", true, ["will change something"])
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-        allow(provider).to receive(:run_configuration).with(:set)
-
-        provider.run_action(:run)
-        expect(resource).to be_updated
-      end
-
-      it "should not converge if the script is already converged" do
-        allow(provider).to receive(:run_configuration).with(:test).and_return([])
-
-        provider.run_action(:run)
-        expect(resource).not_to be_updated
-      end
-    end
-
-    describe "#generate_description" do
-      it "removes the resource name from the beginning of any log line from the LCM" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", true, ["resourcename doing something", "lastline"])
-        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
-        expect(provider.send(:generate_description)[1]).to match(/converge DSC resource resourcename by doing something/)
-      end
-
-      it "ignores the last line" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", true, ["resourcename doing something", "lastline"])
-        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
-        expect(provider.send(:generate_description)[1]).not_to match(/lastline/)
-      end
-
-      it "reports a dsc resource has not been changed if the LCM reported no change was required" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", false, ["resourcename does nothing", "lastline"])
-        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
-        expect(provider.send(:generate_description)[1]).to match(/converge DSC resource resourcename by doing nothing/)
-      end
-    end
-  end
-
-  context "when Dsc is not available" do
-    let (:node) { Chef::Node.new }
-    let (:events) { Chef::EventDispatch::Dispatcher.new }
-    let (:run_context) { Chef::RunContext.new(node, {}, events) }
-    let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
-    let (:provider) { Chef::Provider::DscScript.new(resource, run_context) }
-
-    describe "action_run" do
-      ["1.0", "2.0", "3.0"].each do |version|
-        it "raises an exception for powershell version '#{version}'" do
-          node.automatic[:languages][:powershell][:version] = version
-
-          expect do
-            provider.run_action(:run)
-          end.to raise_error(Chef::Exceptions::ProviderNotFound)
-        end
-      end
-
-      it "raises an exception if PowerShell is not present" do
-        expect do
-          provider.run_action(:run)
-        end.to raise_error(Chef::Exceptions::ProviderNotFound)
-      end
-
-    end
-  end
-end
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+#
+# Copyright:: Copyright 2014-2016, 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 "chef"
+require "chef/util/dsc/resource_info"
+require "spec_helper"
+
+describe Chef::Provider::DscScript do
+  context "when DSC is available" do
+    let (:node) do
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = "4.0"
+      node
+    end
+    let (:events) { Chef::EventDispatch::Dispatcher.new }
+    let (:run_context) { Chef::RunContext.new(node, {}, events) }
+    let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
+    let (:provider) do
+      Chef::Provider::DscScript.new(resource, run_context)
+    end
+
+    describe "#load_current_resource" do
+      it "describes the resource as converged if there were 0 DSC resources" do
+        allow(provider).to receive(:run_configuration).with(:test).and_return([])
+        provider.load_current_resource
+        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
+      end
+
+      it "describes the resource as not converged if there is 1 DSC resources that is converged" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+        provider.load_current_resource
+        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
+      end
+
+      it "describes the resource as not converged if there is 1 DSC resources that is not converged" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", true, ["will change something"])
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+        provider.load_current_resource
+        expect(provider.instance_variable_get("@resource_converged")).to be_falsey
+      end
+
+      it "describes the resource as not converged if there are any DSC resources that are not converged" do
+        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new("resource", true, ["will change something"])
+        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
+
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
+        provider.load_current_resource
+        expect(provider.instance_variable_get("@resource_converged")).to be_falsey
+      end
+
+      it "describes the resource as converged if all DSC resources that are converged" do
+        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
+        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
+
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
+        provider.load_current_resource
+        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
+      end
+    end
+
+    describe "#generate_configuration_document" do
+      # I think integration tests should cover these cases
+
+      it "uses configuration_document_from_script_path when a dsc script file is given" do
+        allow(provider).to receive(:load_current_resource)
+        resource.command("path_to_script")
+        generator = double("Chef::Util::DSC::ConfigurationGenerator")
+        expect(generator).to receive(:configuration_document_from_script_path)
+        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+        provider.send(:generate_configuration_document, "tmp", nil)
+      end
+
+      it "uses configuration_document_from_script_code when a the dsc resource is given" do
+        allow(provider).to receive(:load_current_resource)
+        resource.code("ImADSCResource{}")
+        generator = double("Chef::Util::DSC::ConfigurationGenerator")
+        expect(generator).to receive(:configuration_document_from_script_code)
+        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+        provider.send(:generate_configuration_document, "tmp", nil)
+      end
+
+      it "should noop if neither code or command are provided" do
+        allow(provider).to receive(:load_current_resource)
+        generator = double("Chef::Util::DSC::ConfigurationGenerator")
+        expect(generator).to receive(:configuration_document_from_script_code).with("", anything(), anything(), anything())
+        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+        provider.send(:generate_configuration_document, "tmp", nil)
+      end
+    end
+
+    describe "action_run" do
+      it "should converge the script if it is not converged" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", true, ["will change something"])
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+        allow(provider).to receive(:run_configuration).with(:set)
+
+        provider.run_action(:run)
+        expect(resource).to be_updated
+      end
+
+      it "should not converge if the script is already converged" do
+        allow(provider).to receive(:run_configuration).with(:test).and_return([])
+
+        provider.run_action(:run)
+        expect(resource).not_to be_updated
+      end
+    end
+
+    describe "#generate_description" do
+      it "removes the resource name from the beginning of any log line from the LCM" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", true, ["resourcename doing something", "lastline"])
+        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
+        expect(provider.send(:generate_description)[1]).to match(/converge DSC resource resourcename by doing something/)
+      end
+
+      it "ignores the last line" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", true, ["resourcename doing something", "lastline"])
+        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
+        expect(provider.send(:generate_description)[1]).not_to match(/lastline/)
+      end
+
+      it "reports a dsc resource has not been changed if the LCM reported no change was required" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", false, ["resourcename does nothing", "lastline"])
+        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
+        expect(provider.send(:generate_description)[1]).to match(/converge DSC resource resourcename by doing nothing/)
+      end
+    end
+  end
+
+  context "when Dsc is not available" do
+    let (:node) { Chef::Node.new }
+    let (:events) { Chef::EventDispatch::Dispatcher.new }
+    let (:run_context) { Chef::RunContext.new(node, {}, events) }
+    let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
+    let (:provider) { Chef::Provider::DscScript.new(resource, run_context) }
+
+    describe "action_run" do
+      ["1.0", "2.0", "3.0"].each do |version|
+        it "raises an exception for powershell version '#{version}'" do
+          node.automatic[:languages][:powershell][:version] = version
+
+          expect do
+            provider.run_action(:run)
+          end.to raise_error(Chef::Exceptions::ProviderNotFound)
+        end
+      end
+
+      it "raises an exception if PowerShell is not present" do
+        expect do
+          provider.run_action(:run)
+        end.to raise_error(Chef::Exceptions::ProviderNotFound)
+      end
+
+    end
+  end
+end

data/spec/unit/provider/execute_spec.rb

@@ -1,251 +1,251 @@
-#
-# Author:: Prajakta Purohit (<prajakta@chef.io>)
-# Copyright:: Copyright 2008-2018, 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::Provider::Execute do
-
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:provider) { Chef::Provider::Execute.new(new_resource, run_context) }
-  let(:current_resource) { Chef::Resource::Ifconfig.new("foo_resource", run_context) }
-  # You will be the same object, I promise.
-  @live_stream = Chef::EventDispatch::EventsOutputStream.new(run_context.events, name: :execute)
-
-  let(:opts) do
-    {
-      timeout: 3600,
-      returns: 0,
-      log_level: :info,
-      default_env: false,
-      log_tag: new_resource.to_s,
-    }
-  end
-
-  let(:new_resource) { Chef::Resource::Execute.new("foo_resource", run_context) }
-
-  before do
-    allow(Chef::EventDispatch::EventsOutputStream).to receive(:new) { @live_stream }
-    allow(ChefConfig).to receive(:windows?) { false }
-    @original_log_level = Chef::Log.level
-    Chef::Log.level = :info
-    allow(STDOUT).to receive(:tty?).and_return(false)
-  end
-
-  after do
-    Chef::Log.level = @original_log_level
-    Chef::Config[:always_stream_execute] = false
-    Chef::Config[:daemon] = false
-  end
-
-  describe "#initialize" do
-    it "should return a Chef::Provider::Execute provider" do
-      expect(provider.class).to eql(Chef::Provider::Execute)
-    end
-  end
-
-  describe "#load_current_resource" do
-    before do
-      expect(Chef::Resource::Execute).to receive(:new).with(new_resource.name).and_return(current_resource)
-    end
-
-    it "should return the current resource" do
-      expect(provider.load_current_resource).to eql(current_resource)
-    end
-
-    it "our timeout should default to 3600" do
-      provider.load_current_resource
-      expect(provider.timeout).to eql(3600)
-    end
-  end
-
-  describe "#action_run" do
-    it "runs shell_out with the default options" do
-      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-      expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-      expect(Chef::Log).not_to receive(:warn)
-      provider.run_action(:run)
-      expect(new_resource).to be_updated
-    end
-
-    # this next test is tightly coupled to the implementation of the underlying shell_out mixin that we're using
-    # but the point is to ensure that we are not picking up the PATH mangling and locale-variable mangling that the internal
-    # shell_out API uses.  we are asserting that we emulate `ls -la` when the user does `execute "ls -la"`, and to
-    # do that we get dirty and start mocking the implementation of the shell_out mixin itself.  while arguments like
-    # "timeout", "returns", "log_level" and "log_tag" appear here, we MUST NOT have an "environment" or "env" argument
-    # that we are passing to Mixlib::ShellOut by default -- ever.  you might have to add some other argument here from
-    # time to time, but you MUST NOT change the environment.
-    it "does not use shell_out in such a way as to insert extra environment variables" do
-      mock = instance_double(Mixlib::ShellOut)
-      expect(Mixlib::ShellOut).to receive(:new).with("foo_resource", { timeout: 3600, returns: 0, log_level: :info, log_tag: "execute[foo_resource]" }).and_return(mock)
-      expect(mock).to receive(:live_stream=).with(nil)
-      allow(mock).to receive(:live_stream)
-      expect(mock).to receive(:run_command)
-      expect(mock).to receive(:error!)
-      provider.run_action(:run)
-      expect(new_resource).to be_updated
-    end
-
-    it "if you pass a command property, it runs the command" do
-      new_resource.command "/usr/argelbargle/bin/oogachacka 12345"
-      expect(provider).to receive(:shell_out!).with(new_resource.command, opts)
-      expect(provider).to receive(:converge_by).with("execute #{new_resource.command}").and_call_original
-      expect(Chef::Log).not_to receive(:warn)
-      provider.run_action(:run)
-      expect(new_resource).to be_updated
-    end
-
-    it "should honor sensitive property" do
-      new_resource.sensitive true
-      # Since the resource is sensitive, it should not have :live_stream set
-      opts.delete(:live_stream)
-      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-      expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
-      expect(Chef::Log).not_to receive(:warn)
-      provider.run_action(:run)
-      expect(new_resource).to be_updated
-    end
-
-    it "should do nothing if the sentinel file exists" do
-      new_resource.creates "/foo_resource"
-      expect(FileTest).to receive(:exist?).with(new_resource.creates).and_return(true)
-      expect(provider).not_to receive(:shell_out!)
-      expect(Chef::Log).not_to receive(:warn)
-      provider.run_action(:run)
-      expect(new_resource).not_to be_updated
-    end
-
-    describe "when the user specifies a relative path without cwd" do
-      before do
-        expect(new_resource.cwd).to be_falsey
-        new_resource.creates "foo_resource"
-      end
-
-      it "should raise if user specified relative path without cwd for Chef-13" do
-        expect(provider).not_to receive(:shell_out!)
-        expect { provider.run_action(:run) }.to raise_error(Chef::Exceptions::Execute)
-      end
-    end
-
-    it "should respect cwd options for 'creates'" do
-      new_resource.cwd "/tmp"
-      new_resource.creates "foo_resource"
-      expect(FileTest).not_to receive(:exist?).with(new_resource.creates)
-      expect(FileTest).to receive(:exist?).with(File.join("/tmp", new_resource.creates)).and_return(true)
-      expect(Chef::Log).not_to receive(:warn)
-      expect(provider).not_to receive(:shell_out!)
-
-      provider.run_action(:run)
-      expect(new_resource).not_to be_updated
-    end
-
-    it "should not include stdout/stderr in failure exception for sensitive resource" do
-      opts.delete(:live_stream)
-      new_resource.sensitive true
-      expect(provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
-      expect do
-        provider.run_action(:run)
-      end.to raise_error(Mixlib::ShellOut::ShellCommandFailed, /suppressed for sensitive resource/)
-    end
-
-    describe "streaming output" do
-      it "should not set the live_stream if sensitive is on" do
-        new_resource.sensitive true
-        expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-        expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
-        expect(Chef::Log).not_to receive(:warn)
-        provider.run_action(:run)
-        expect(new_resource).to be_updated
-      end
-
-      describe "with an output formatter listening" do
-        let(:events) { d = Chef::EventDispatch::Dispatcher.new; d.register(Chef::Formatters::Doc.new(StringIO.new, StringIO.new)); d }
-
-        before do
-          Chef::Config[:stream_execute_output] = true
-        end
-
-        it "should set the live_stream if the log level is info or above" do
-          nopts = opts
-          nopts[:live_stream] = @live_stream
-          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
-          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-          expect(Chef::Log).not_to receive(:warn)
-          provider.run_action(:run)
-          expect(new_resource).to be_updated
-        end
-
-        it "should set the live_stream if the resource requests live streaming" do
-          Chef::Log.level = :warn
-          new_resource.live_stream true
-          nopts = opts
-          nopts[:live_stream] = @live_stream
-          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
-          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-          expect(Chef::Log).not_to receive(:warn)
-          provider.run_action(:run)
-          expect(new_resource).to be_updated
-        end
-
-        it "should not set the live_stream if the resource is sensitive" do
-          new_resource.sensitive true
-          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-          expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
-          expect(Chef::Log).not_to receive(:warn)
-          provider.run_action(:run)
-          expect(new_resource).to be_updated
-        end
-      end
-
-      describe "with only logging enabled" do
-        it "should set the live_stream to STDOUT if we are a TTY, not daemonized, not sensitive, and info is enabled" do
-          nopts = opts
-          nopts[:live_stream] = STDOUT
-          allow(STDOUT).to receive(:tty?).and_return(true)
-          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
-          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-          expect(Chef::Log).not_to receive(:warn)
-          provider.run_action(:run)
-          expect(new_resource).to be_updated
-        end
-
-        it "should not set the live_stream to STDOUT if we are a TTY, not daemonized, but sensitive" do
-          new_resource.sensitive true
-          allow(STDOUT).to receive(:tty?).and_return(true)
-          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-          expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
-          expect(Chef::Log).not_to receive(:warn)
-          provider.run_action(:run)
-          expect(new_resource).to be_updated
-        end
-
-        it "should not set the live_stream to STDOUT if we are a TTY, but daemonized" do
-          Chef::Config[:daemon] = true
-          allow(STDOUT).to receive(:tty?).and_return(true)
-          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-          expect(Chef::Log).not_to receive(:warn)
-          provider.run_action(:run)
-          expect(new_resource).to be_updated
-        end
-
-      end
-    end
-  end
-end
+#
+# Author:: Prajakta Purohit (<prajakta@chef.io>)
+# Copyright:: Copyright 2008-2018, 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::Provider::Execute do
+
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:provider) { Chef::Provider::Execute.new(new_resource, run_context) }
+  let(:current_resource) { Chef::Resource::Ifconfig.new("foo_resource", run_context) }
+  # You will be the same object, I promise.
+  @live_stream = Chef::EventDispatch::EventsOutputStream.new(run_context.events, name: :execute)
+
+  let(:opts) do
+    {
+      timeout: 3600,
+      returns: 0,
+      log_level: :info,
+      default_env: false,
+      log_tag: new_resource.to_s,
+    }
+  end
+
+  let(:new_resource) { Chef::Resource::Execute.new("foo_resource", run_context) }
+
+  before do
+    allow(Chef::EventDispatch::EventsOutputStream).to receive(:new) { @live_stream }
+    allow(ChefConfig).to receive(:windows?) { false }
+    @original_log_level = Chef::Log.level
+    Chef::Log.level = :info
+    allow(STDOUT).to receive(:tty?).and_return(false)
+  end
+
+  after do
+    Chef::Log.level = @original_log_level
+    Chef::Config[:always_stream_execute] = false
+    Chef::Config[:daemon] = false
+  end
+
+  describe "#initialize" do
+    it "should return a Chef::Provider::Execute provider" do
+      expect(provider.class).to eql(Chef::Provider::Execute)
+    end
+  end
+
+  describe "#load_current_resource" do
+    before do
+      expect(Chef::Resource::Execute).to receive(:new).with(new_resource.name).and_return(current_resource)
+    end
+
+    it "should return the current resource" do
+      expect(provider.load_current_resource).to eql(current_resource)
+    end
+
+    it "our timeout should default to 3600" do
+      provider.load_current_resource
+      expect(provider.timeout).to eql(3600)
+    end
+  end
+
+  describe "#action_run" do
+    it "runs shell_out with the default options" do
+      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+      expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+      expect(Chef::Log).not_to receive(:warn)
+      provider.run_action(:run)
+      expect(new_resource).to be_updated
+    end
+
+    # this next test is tightly coupled to the implementation of the underlying shell_out mixin that we're using
+    # but the point is to ensure that we are not picking up the PATH mangling and locale-variable mangling that the internal
+    # shell_out API uses.  we are asserting that we emulate `ls -la` when the user does `execute "ls -la"`, and to
+    # do that we get dirty and start mocking the implementation of the shell_out mixin itself.  while arguments like
+    # "timeout", "returns", "log_level" and "log_tag" appear here, we MUST NOT have an "environment" or "env" argument
+    # that we are passing to Mixlib::ShellOut by default -- ever.  you might have to add some other argument here from
+    # time to time, but you MUST NOT change the environment.
+    it "does not use shell_out in such a way as to insert extra environment variables" do
+      mock = instance_double(Mixlib::ShellOut)
+      expect(Mixlib::ShellOut).to receive(:new).with("foo_resource", { timeout: 3600, returns: 0, log_level: :info, log_tag: "execute[foo_resource]" }).and_return(mock)
+      expect(mock).to receive(:live_stream=).with(nil)
+      allow(mock).to receive(:live_stream)
+      expect(mock).to receive(:run_command)
+      expect(mock).to receive(:error!)
+      provider.run_action(:run)
+      expect(new_resource).to be_updated
+    end
+
+    it "if you pass a command property, it runs the command" do
+      new_resource.command "/usr/argelbargle/bin/oogachacka 12345"
+      expect(provider).to receive(:shell_out!).with(new_resource.command, opts)
+      expect(provider).to receive(:converge_by).with("execute #{new_resource.command}").and_call_original
+      expect(Chef::Log).not_to receive(:warn)
+      provider.run_action(:run)
+      expect(new_resource).to be_updated
+    end
+
+    it "should honor sensitive property" do
+      new_resource.sensitive true
+      # Since the resource is sensitive, it should not have :live_stream set
+      opts.delete(:live_stream)
+      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+      expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+      expect(Chef::Log).not_to receive(:warn)
+      provider.run_action(:run)
+      expect(new_resource).to be_updated
+    end
+
+    it "should do nothing if the sentinel file exists" do
+      new_resource.creates "/foo_resource"
+      expect(FileTest).to receive(:exist?).with(new_resource.creates).and_return(true)
+      expect(provider).not_to receive(:shell_out!)
+      expect(Chef::Log).not_to receive(:warn)
+      provider.run_action(:run)
+      expect(new_resource).not_to be_updated
+    end
+
+    describe "when the user specifies a relative path without cwd" do
+      before do
+        expect(new_resource.cwd).to be_falsey
+        new_resource.creates "foo_resource"
+      end
+
+      it "should raise if user specified relative path without cwd for Chef-13" do
+        expect(provider).not_to receive(:shell_out!)
+        expect { provider.run_action(:run) }.to raise_error(Chef::Exceptions::Execute)
+      end
+    end
+
+    it "should respect cwd options for 'creates'" do
+      new_resource.cwd "/tmp"
+      new_resource.creates "foo_resource"
+      expect(FileTest).not_to receive(:exist?).with(new_resource.creates)
+      expect(FileTest).to receive(:exist?).with(File.join("/tmp", new_resource.creates)).and_return(true)
+      expect(Chef::Log).not_to receive(:warn)
+      expect(provider).not_to receive(:shell_out!)
+
+      provider.run_action(:run)
+      expect(new_resource).not_to be_updated
+    end
+
+    it "should not include stdout/stderr in failure exception for sensitive resource" do
+      opts.delete(:live_stream)
+      new_resource.sensitive true
+      expect(provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect do
+        provider.run_action(:run)
+      end.to raise_error(Mixlib::ShellOut::ShellCommandFailed, /suppressed for sensitive resource/)
+    end
+
+    describe "streaming output" do
+      it "should not set the live_stream if sensitive is on" do
+        new_resource.sensitive true
+        expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+        expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+        expect(Chef::Log).not_to receive(:warn)
+        provider.run_action(:run)
+        expect(new_resource).to be_updated
+      end
+
+      describe "with an output formatter listening" do
+        let(:events) { d = Chef::EventDispatch::Dispatcher.new; d.register(Chef::Formatters::Doc.new(StringIO.new, StringIO.new)); d }
+
+        before do
+          Chef::Config[:stream_execute_output] = true
+        end
+
+        it "should set the live_stream if the log level is info or above" do
+          nopts = opts
+          nopts[:live_stream] = @live_stream
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should set the live_stream if the resource requests live streaming" do
+          Chef::Log.level = :warn
+          new_resource.live_stream true
+          nopts = opts
+          nopts[:live_stream] = @live_stream
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should not set the live_stream if the resource is sensitive" do
+          new_resource.sensitive true
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+          expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+      end
+
+      describe "with only logging enabled" do
+        it "should set the live_stream to STDOUT if we are a TTY, not daemonized, not sensitive, and info is enabled" do
+          nopts = opts
+          nopts[:live_stream] = STDOUT
+          allow(STDOUT).to receive(:tty?).and_return(true)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should not set the live_stream to STDOUT if we are a TTY, not daemonized, but sensitive" do
+          new_resource.sensitive true
+          allow(STDOUT).to receive(:tty?).and_return(true)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+          expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should not set the live_stream to STDOUT if we are a TTY, but daemonized" do
+          Chef::Config[:daemon] = true
+          allow(STDOUT).to receive(:tty?).and_return(true)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+      end
+    end
+  end
+end