chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/provider/dsc_script_spec.rb

@@ -39,21 +39,21 @@ describe Chef::Provider::DscScript 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_true
+        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_true
+        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_false
+        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
@@ -62,7 +62,7 @@ describe Chef::Provider::DscScript do
 
         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_false
+        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
@@ -71,7 +71,7 @@ describe Chef::Provider::DscScript do
 
         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_true
+        expect(provider.instance_variable_get('@resource_converged')).to be_truthy
       end
     end
 
@@ -99,7 +99,7 @@ describe Chef::Provider::DscScript do
       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())
+        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

data/spec/unit/provider/env_spec.rb

@@ -30,7 +30,7 @@ describe Chef::Provider::Env do
   end
 
   it "assumes the key_name exists by default" do
-    expect(@provider.key_exists).to be_true
+    expect(@provider.key_exists).to be_truthy
   end
 
   describe "when loading the current status" do
@@ -55,13 +55,13 @@ describe Chef::Provider::Env do
     it "should check if the key_name exists" do
       expect(@provider).to receive(:env_key_exists).with("FOO").and_return(true)
       @provider.load_current_resource
-      expect(@provider.key_exists).to be_true
+      expect(@provider.key_exists).to be_truthy
     end
 
     it "should flip the value of exists if the key does not exist" do
       expect(@provider).to receive(:env_key_exists).with("FOO").and_return(false)
       @provider.load_current_resource
-      expect(@provider.key_exists).to be_false
+      expect(@provider.key_exists).to be_falsey
     end
 
     it "should return the current resource" do
@@ -230,40 +230,47 @@ describe Chef::Provider::Env do
     end
 
     it "should return false if the values are equal" do
-      expect(@provider.requires_modify_or_create?).to be_false
+      expect(@provider.requires_modify_or_create?).to be_falsey
     end
 
     it "should return true if the values not are equal" do
       @new_resource.value("C:/elsewhere")
-      expect(@provider.requires_modify_or_create?).to be_true
+      expect(@provider.requires_modify_or_create?).to be_truthy
     end
 
     it "should return false if the current value contains the element" do
       @new_resource.delim(";")
       @current_resource.value("C:/bar;C:/foo;C:/baz")
 
-      expect(@provider.requires_modify_or_create?).to be_false
+      expect(@provider.requires_modify_or_create?).to be_falsey
     end
 
     it "should return true if the current value does not contain the element" do
       @new_resource.delim(";")
       @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
-      expect(@provider.requires_modify_or_create?).to be_true
+      expect(@provider.requires_modify_or_create?).to be_truthy
     end
 
     context "when new_resource's value contains the delimiter"  do
-      it "should return false if all the current values are contained" do
+      it "should return false if all the current values are contained in specified order" do
         @new_resource.value("C:/biz;C:/baz")
         @new_resource.delim(";")
         @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
-        expect(@provider.requires_modify_or_create?).to be_false
+        expect(@provider.requires_modify_or_create?).to be_falsey
       end
 
       it "should return true if any of the new values are not contained" do
         @new_resource.value("C:/biz;C:/baz;C:/bin")
         @new_resource.delim(";")
         @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
-        expect(@provider.requires_modify_or_create?).to be_true
+        expect(@provider.requires_modify_or_create?).to be_truthy
+      end
+
+      it "should return true if values are contained in different order" do
+        @new_resource.value("C:/biz;C:/baz")
+        @new_resource.delim(";")
+        @current_resource.value("C:/baz;C:/foo/bin;C:/biz")
+        expect(@provider.requires_modify_or_create?).to be_truthy
       end
     end
   end
@@ -286,12 +293,18 @@ describe Chef::Provider::Env do
       expect(passed_value).to eq(new_value)
     end
 
-    it "should only add values not already contained when a delimiter is provided" do
+    it "should only add values not already contained" do
       @new_resource.value("C:/foo;C:/bar;C:/baz")
-      @new_resource.delim(";")
-      @current_resource.value("C:/foo/bar;C:/bar;C:/baz")
+      @current_resource.value("C:/bar;C:/baz;C:/foo/bar")
+      @provider.modify_env
+      expect(@new_resource.value).to eq("C:/foo;C:/bar;C:/baz;C:/foo/bar")
+    end
+
+    it "should reorder values to keep order which asked" do
+      @new_resource.value("C:/foo;C:/bar;C:/baz")
+      @current_resource.value("C:/foo/bar;C:/baz;C:/bar")
       @provider.modify_env
-      expect(@new_resource.value).to eq("C:/foo;C:/foo/bar;C:/bar;C:/baz")
+      expect(@new_resource.value).to eq("C:/foo;C:/bar;C:/baz;C:/foo/bar")
     end
   end
 end

data/spec/unit/provider/execute_spec.rb

@@ -15,91 +15,162 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
-#require 'spec_helper'
+
+require 'spec_helper'
 
 describe Chef::Provider::Execute do
-  before do
-    @node = Chef::Node.new
-    @cookbook_collection = Chef::CookbookCollection.new([])
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
-    @new_resource = Chef::Resource::Execute.new("foo_resource", @run_context)
-    @new_resource.timeout 3600
-    @new_resource.returns 0
-    @new_resource.creates "/foo_resource"
-    @provider = Chef::Provider::Execute.new(@new_resource, @run_context)
-    @current_resource = Chef::Resource::Ifconfig.new("foo_resource", @run_context)
-    @provider.current_resource = @current_resource
-    Chef::Log.level = :info
-    # FIXME: There should be a test for how STDOUT.tty? changes the live_stream option being passed
-    allow(STDOUT).to receive(:tty?).and_return(true)
-  end
+
+  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) }
 
   let(:opts) do
     {
-      timeout:	@new_resource.timeout,
-      returns:	@new_resource.returns,
-      log_level: :info,
-      log_tag: @new_resource.to_s,
-      live_stream: STDOUT
+      timeout:      3600,
+      returns:      0,
+      log_level:    :info,
+      log_tag:      new_resource.to_s,
+      live_stream:  STDOUT,
     }
   end
 
-  it "should execute foo_resource" do
-    allow(@provider).to receive(:load_current_resource)
-    expect(@provider).to receive(:shell_out!).with(@new_resource.command, opts)
-    expect(@provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-    expect(Chef::Log).not_to receive(:warn)
+  let(:new_resource) { Chef::Resource::Execute.new("foo_resource", run_context) }
 
-    @provider.run_action(:run)
-    expect(@new_resource).to be_updated
+  before do
+    allow(Chef::Platform).to receive(:windows?) { false }
+    @original_log_level = Chef::Log.level
+    Chef::Log.level = :info
+    allow(STDOUT).to receive(:tty?).and_return(true)
   end
 
-  it "should honor sensitive attribute" do
-    @new_resource.sensitive true
-    @provider = Chef::Provider::Execute.new(@new_resource, @run_context)
-    allow(@provider).to receive(:load_current_resource)
-    # Since the resource is sensitive, it should not have :live_stream set
-    expect(@provider).to receive(:shell_out!).with(@new_resource.command, opts.reject { |k| k == :live_stream })
-    expect(Chef::Log).not_to receive(:warn)
-    expect(@provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
-    @provider.run_action(:run)
-    expect(@new_resource).to be_updated
+  after do
+    Chef::Log.level = @original_log_level
   end
 
-  it "should do nothing if the sentinel file exists" do
-    allow(@provider).to receive(:load_current_resource)
-    expect(File).to receive(:exists?).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
+  describe "#initialize" do
+    it "should return a Chef::Provider::Execute provider" do
+      expect(provider.class).to eql(Chef::Provider::Execute)
+    end
   end
 
-  it "should respect cwd options for 'creates'" do
-    @new_resource.cwd "/tmp"
-    @new_resource.creates "foo_resource"
-    allow(@provider).to receive(:load_current_resource)
-    expect(File).to receive(:exists?).with(@new_resource.creates).and_return(false)
-    expect(File).to receive(:exists?).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
+  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
 
-  it "should warn if user specified relative path without cwd" do
-    @new_resource.creates "foo_resource"
-    allow(@provider).to receive(:load_current_resource)
-    expect(Chef::Log).to receive(:warn).with(/relative path/)
-    expect(File).to receive(:exists?).with(@new_resource.creates).and_return(true)
-    expect(@provider).not_to receive(:shell_out!)
+  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
 
-    @provider.run_action(:run)
-    expect(@new_resource).not_to be_updated
+    it "if you pass a command attribute, 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 attribute" 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 warn in Chef-12", :chef_lt_13_only do
+        expect(Chef::Log).to receive(:warn).with(/relative path/)
+        expect(FileTest).to receive(:exist?).with(new_resource.creates).and_return(true)
+        expect(provider).not_to receive(:shell_out!)
+        provider.run_action(:run)
+        expect(new_resource).not_to be_updated
+      end
+
+      it "should raise if user specified relative path without cwd for Chef-13", :chef_gte_13_only do
+        expect(Chef::Log).to receive(:warn).with(/relative path/)
+        expect(FileTest).to receive(:exist?).with(new_resource.creates).and_return(true)
+        expect(provider).not_to receive(:shell_out!)
+        expect { provider.run_action(:run) }.to raise_error  # @todo: add a real error for Chef-13
+      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 unset the live_stream if STDOUT is not a tty" do
+      expect(STDOUT).to receive(:tty?).and_return(false)
+      opts.delete(:live_stream)
+      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
+
+    it "should unset the live_stream if chef is running as a daemon" do
+      allow(Chef::Config).to receive(:[]).and_call_original
+      expect(Chef::Config).to receive(:[]).with(:daemon).and_return(true)
+      opts.delete(:live_stream)
+      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
+
+    it "should unset the live_stream if we are not running with a log level of at least :info" do
+      expect(Chef::Log).to receive(:info?).and_return(false)
+      opts.delete(:live_stream)
+      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
-

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

@@ -66,14 +66,14 @@ describe Chef::Provider::File::Content do
 
     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_true
-      expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_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_false
-      expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_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
@@ -83,8 +83,8 @@ describe Chef::Provider::File::Content do
 
       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_true
-        expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_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 "fails when :file_desployment_uses_destdir is set" do
@@ -93,8 +93,8 @@ describe Chef::Provider::File::Content do
       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_true
-        expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be_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
     end
 

data/spec/unit/provider/git_spec.rb

@@ -22,6 +22,7 @@ describe Chef::Provider::Git do
 
   before(:each) do
     allow(STDOUT).to receive(:tty?).and_return(true)
+    @original_log_level = Chef::Log.level
     Chef::Log.level = :info
 
     @current_resource = Chef::Resource::Git.new("web2.0 app")
@@ -38,6 +39,10 @@ describe Chef::Provider::Git do
     @provider.current_resource = @current_resource
   end
 
+  after(:each) do
+    Chef::Log.level = @original_log_level
+  end
+
   context "determining the revision of the currently deployed checkout" do
 
     before do
@@ -621,21 +626,21 @@ SHAS
     describe "when check remote command returns with status 2" do
       it "returns true" do
         allow(@command_response).to receive(:exitstatus) { 2 }
-        expect(@provider.multiple_remotes?(@command_response)).to be_true
+        expect(@provider.multiple_remotes?(@command_response)).to be_truthy
       end
     end
 
     describe "when check remote command returns with status 0" do
       it "returns false" do
         allow(@command_response).to receive(:exitstatus) { 0 }
-        expect(@provider.multiple_remotes?(@command_response)).to be_false
+        expect(@provider.multiple_remotes?(@command_response)).to be_falsey
       end
     end
 
     describe "when check remote command returns with status 0" do
       it "returns false" do
         allow(@command_response).to receive(:exitstatus) { 1 }
-        expect(@provider.multiple_remotes?(@command_response)).to be_false
+        expect(@provider.multiple_remotes?(@command_response)).to be_falsey
       end
     end
   end
@@ -649,7 +654,7 @@ SHAS
       it "returns true" do
         allow(@command_response).to receive(:exitstatus) { 0 }
         allow(@command_response).to receive(:stdout) { @resource.repository }
-        expect(@provider.remote_matches?(@resource.repository, @command_response)).to be_true
+        expect(@provider.remote_matches?(@resource.repository, @command_response)).to be_truthy
       end
     end
 
@@ -657,7 +662,7 @@ SHAS
       it "returns false" do
         allow(@command_response).to receive(:exitstatus) { 0 }
         allow(@command_response).to receive(:stdout) { @resource.repository + "test" }
-        expect(@provider.remote_matches?(@resource.repository, @command_response)).to be_false
+        expect(@provider.remote_matches?(@resource.repository, @command_response)).to be_falsey
       end
     end
   end