chef 18.8.11 → 18.8.54

data/spec/unit/provider/dsc_script_spec.rb

@@ -1,173 +0,0 @@
-#
-# Author:: Jay Mundrawala (<jdm@chef.io>)
-#
-# 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 "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)
-        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,244 +0,0 @@
-#
-# Author:: Prajakta Purohit (<prajakta@chef.io>)
-# 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::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(Chef::EventDispatch::Dispatcher.new, 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(ChefUtils).to receive(:windows?) { false }
-    Chef::Log.level = :info
-    allow(STDOUT).to receive(:tty?).and_return(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

data/spec/unit/provider/file/content_spec.rb

@@ -1,114 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@chef.io>)
-# 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::Provider::File::Content do
-
-  #
-  # mock setup
-  #
-
-  let(:current_resource) do
-    double("Chef::Provider::File::Resource (current)")
-  end
-
-  let(:enclosing_directory) do
-    canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
-  end
-  let(:resource_path) do
-    canonicalize_path(File.expand_path(File.join(enclosing_directory, "seattle.txt")))
-  end
-
-  let(:new_resource) do
-    double("Chef::Provider::File::Resource (new)", name: "seattle.txt", path: resource_path)
-  end
-
-  let(:run_context) do
-    double("Chef::RunContext")
-  end
-
-  #
-  # subject
-  #
-  let(:content) do
-    Chef::Provider::File::Content.new(new_resource, current_resource, run_context)
-  end
-
-  describe "when the resource has a content property set" do
-
-    before do
-      allow(new_resource).to receive(:content).and_return("Do do do do, do do do do, do do do do, do do do do")
-    end
-
-    it "returns a tempfile" do
-      expect(content.tempfile).to be_a_kind_of(Tempfile)
-    end
-
-    it "the tempfile contents should match the resource contents" do
-      expect(IO.read(content.tempfile.path)).to eq(new_resource.content)
-    end
-
-    it "returns a tempfile in the tempdir when :file_staging_uses_destdir is not set" do
-      Chef::Config[:file_staging_uses_destdir] = false
-      expect(content.tempfile.path.start_with?(Dir.tmpdir)).to be_truthy
-      expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_falsey
-    end
-
-    it "returns a tempfile in the destdir when :file_deployment_uses_destdir is set" do
-      Chef::Config[:file_staging_uses_destdir] = true
-      expect(content.tempfile.path.start_with?(Dir.tmpdir)).to be_falsey
-      expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_truthy
-    end
-
-    context "when creating a tempfiles in destdir fails" do
-      let(:enclosing_directory) do
-        canonicalize_path("/nonexisting/path")
-      end
-
-      it "returns a tempfile in the tempdir when :file_deployment_uses_destdir is set to :auto" do
-        Chef::Config[:file_staging_uses_destdir] = :auto
-        expect(content.tempfile.path.start_with?(Dir.tmpdir)).to be_truthy
-        expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_falsey
-      end
-
-      it "fails when :file_desployment_uses_destdir is set" do
-        Chef::Config[:file_staging_uses_destdir] = true
-        expect { content.tempfile }.to raise_error(Chef::Exceptions::FileContentStagingError)
-      end
-
-      it "returns a tempfile in the tempdir when :file_desployment_uses_destdir is not set" do
-        expect(content.tempfile.path.start_with?(Dir.tmpdir)).to be_truthy
-        expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_falsey
-      end
-    end
-
-  end
-
-  describe "when the resource does not have a content property set" do
-
-    before do
-      allow(new_resource).to receive(:content).and_return(nil)
-    end
-
-    it "should return nil instead of a tempfile" do
-      expect(content.tempfile).to be_nil
-    end
-
-  end
-end

data/spec/unit/provider/file_spec.rb

@@ -1,58 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Lamont Granquist (<lamont@chef.io>)
-# 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"
-require "support/shared/unit/provider/file"
-
-describe Chef::Provider::File do
-
-  let(:resource) do
-    # need to check for/against mutating state within the new_resource, so don't mock
-    resource = Chef::Resource::File.new("seattle")
-    resource.path(resource_path)
-    resource
-  end
-
-  let(:content) do
-    content = double("Chef::Provider::File::Content")
-  end
-
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-
-  let(:enclosing_directory) do
-    canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
-  end
-  let(:resource_path) do
-    canonicalize_path(File.expand_path(File.join(enclosing_directory, "seattle.txt")))
-  end
-
-  # Subject
-
-  let(:provider) do
-    provider = described_class.new(resource, run_context)
-    allow(provider).to receive(:content).and_return(content)
-    provider
-  end
-
-  it_behaves_like Chef::Provider::File
-
-  it_behaves_like "a file provider with content field"
-end