chef 12.13.37 → 12.14.60

data/spec/unit/recipe_spec.rb

@@ -75,15 +75,15 @@ describe Chef::Recipe do
       end
 
       it "should require a name argument" do
-        expect {
+        expect do
           recipe.cat
-        }.to raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
       end
 
       it "should allow regular errors (not NameErrors) to pass unchanged" do
-        expect {
+        expect do
           recipe.cat("felix") { raise ArgumentError, "You Suck" }
-        }.to raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
       end
 
       it "should add our zen_master to the collection" do
@@ -288,9 +288,10 @@ describe Chef::Recipe do
       end
 
       it "validating resources via build_resource" do
-        expect {recipe.build_resource(:remote_file, "klopp") do
-          source Chef::DelayedEvaluator.new { "http://chef.io" }
-        end}.to_not raise_error
+        expect do
+          recipe.build_resource(:remote_file, "klopp") do
+            source Chef::DelayedEvaluator.new { "http://chef.io" }
+          end end.to_not raise_error
       end
 
     end

data/spec/unit/resource/apt_repository_spec.rb

@@ -38,13 +38,13 @@ describe Chef::Resource::AptRepository do
     expect(resource.distribution).to eql(nil)
   end
 
-  it "should resolve to a Noop class when uses_apt? is false" do
-    expect(Chef::Provider::AptRepository).to receive(:uses_apt?).and_return(false)
+  it "should resolve to a Noop class when apt-get is not found" do
+    expect(Chef::Provider::AptRepository).to receive(:which).with("apt-get").and_return(false)
     expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
   end
 
-  it "should resolve to a AptRepository class when uses_apt? is true" do
-    expect(Chef::Provider::AptRepository).to receive(:uses_apt?).and_return(true)
+  it "should resolve to a AptRepository class when apt-get is found" do
+    expect(Chef::Provider::AptRepository).to receive(:which).with("apt-get").and_return(true)
     expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::AptRepository)
   end
 end

data/spec/unit/resource/apt_update_spec.rb

@@ -38,13 +38,13 @@ describe Chef::Resource::AptUpdate do
     expect(resource.frequency).to eql(400)
   end
 
-  it "should resolve to a Noop class when uses_apt? is false" do
-    expect(Chef::Provider::AptUpdate).to receive(:uses_apt?).and_return(false)
+  it "should resolve to a Noop class when apt-get is not found" do
+    expect(Chef::Provider::AptUpdate).to receive(:which).with("apt-get").and_return(false)
     expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
   end
 
-  it "should resolve to a AptUpdate class when uses_apt? is true" do
-    expect(Chef::Provider::AptUpdate).to receive(:uses_apt?).and_return(true)
+  it "should resolve to a AptUpdate class when apt-get is found" do
+    expect(Chef::Provider::AptUpdate).to receive(:which).with("apt-get").and_return(true)
     expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::AptUpdate)
   end
 end

data/spec/unit/resource/conditional_spec.rb

@@ -124,6 +124,29 @@ describe Chef::Resource::Conditional do
         expect(@conditional.continue?).to be_falsey
       end
     end
+
+    describe "after running a block that returns a string value" do
+      before do
+        @conditional = Chef::Resource::Conditional.only_if(@parent_resource) { "some command" }
+      end
+
+      it "logs a warning" do
+        expect(Chef::Log).to receive(:warn).with("only_if block for [] returned \"some command\", did you mean to run a command? If so use 'only_if \"some command\"' in your code.")
+        @conditional.evaluate
+      end
+    end
+
+    describe "after running a block that returns a string value on a sensitive resource" do
+      before do
+        @parent_resource.sensitive(true)
+        @conditional = Chef::Resource::Conditional.only_if(@parent_resource) { "some command" }
+      end
+
+      it "logs a warning" do
+        expect(Chef::Log).to receive(:warn).with("only_if block for [] returned a string, did you mean to run a command?")
+        @conditional.evaluate
+      end
+    end
   end
 
   describe "when created as a `not_if`" do
@@ -204,5 +227,28 @@ describe Chef::Resource::Conditional do
         expect(@conditional.continue?).to be_truthy
       end
     end
+
+    describe "after running a block that returns a string value" do
+      before do
+        @conditional = Chef::Resource::Conditional.not_if(@parent_resource) { "some command" }
+      end
+
+      it "logs a warning" do
+        expect(Chef::Log).to receive(:warn).with("not_if block for [] returned \"some command\", did you mean to run a command? If so use 'not_if \"some command\"' in your code.")
+        @conditional.evaluate
+      end
+    end
+
+    describe "after running a block that returns a string value on a sensitive resource" do
+      before do
+        @parent_resource.sensitive(true)
+        @conditional = Chef::Resource::Conditional.not_if(@parent_resource) { "some command" }
+      end
+
+      it "logs a warning" do
+        expect(Chef::Log).to receive(:warn).with("not_if block for [] returned a string, did you mean to run a command?")
+        @conditional.evaluate
+      end
+    end
   end
 end

data/spec/unit/resource/dsc_resource_spec.rb

@@ -24,16 +24,16 @@ describe Chef::Resource::DscResource do
   let(:dsc_test_timeout) { 101 }
 
   context "when Powershell supports Dsc" do
-    let(:dsc_test_run_context) {
+    let(:dsc_test_run_context) do
       node = Chef::Node.new
       node.automatic[:languages][:powershell][:version] = "5.0.10018.0"
       empty_events = Chef::EventDispatch::Dispatcher.new
       Chef::RunContext.new(node, {}, empty_events)
-    }
+    end
 
-    let(:dsc_test_resource) {
+    let(:dsc_test_resource) do
       Chef::Resource::DscResource.new(dsc_test_resource_name, dsc_test_run_context)
-    }
+    end
 
     it "has a default action of `:run`" do
       expect(dsc_test_resource.action).to eq([:run])
@@ -71,16 +71,16 @@ describe Chef::Resource::DscResource do
       end
 
       it "raises a TypeError if property_name is not a symbol" do
-        expect {
+        expect do
           dsc_test_resource.property("Foo", dsc_test_property_value)
-        }.to raise_error(TypeError)
+        end.to raise_error(TypeError)
       end
 
       context "when using DelayedEvaluators" do
         it "allows setting a dsc property with a property name of type Symbol" do
-          dsc_test_resource.property(dsc_test_property_name, Chef::DelayedEvaluator.new {
+          dsc_test_resource.property(dsc_test_property_name, Chef::DelayedEvaluator.new do
             dsc_test_property_value
-          })
+          end)
           expect(dsc_test_resource.property(dsc_test_property_name)).to eq(dsc_test_property_value)
           expect(dsc_test_resource.properties[dsc_test_property_name]).to eq(dsc_test_property_value)
         end

data/spec/unit/resource/dsc_script_spec.rb

@@ -22,15 +22,15 @@ describe Chef::Resource::DscScript do
   let(:dsc_test_resource_name) { "DSCTest" }
 
   context "when Powershell supports Dsc" do
-    let(:dsc_test_run_context) {
+    let(:dsc_test_run_context) do
       node = Chef::Node.new
       node.automatic[:languages][:powershell][:version] = "4.0"
       empty_events = Chef::EventDispatch::Dispatcher.new
       Chef::RunContext.new(node, {}, empty_events)
-    }
-    let(:dsc_test_resource) {
+    end
+    let(:dsc_test_resource) do
       Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context)
-    }
+    end
     let(:configuration_code) { 'echo "This is supposed to create a configuration document."' }
     let(:configuration_path) { "c:/myconfigs/formatc.ps1" }
     let(:configuration_name) { "formatme" }

data/spec/unit/resource/freebsd_package_spec.rb

@@ -52,10 +52,10 @@ describe Chef::Resource::FreebsdPackage do
       end
     end
 
-    describe "if __Freebsd_version is greater than or equal to 1000017" do
+    describe "if freebsd_version is greater than or equal to 1000017" do
       it "should be Freebsd::Pkgng" do
-        [1000017, 1000018, 1000500, 1001001, 1100000].each do |__freebsd_version|
-          @node.automatic_attrs[:os_version] = __freebsd_version
+        [1000017, 1000018, 1000500, 1001001, 1100000].each do |freebsd_version|
+          @node.automatic_attrs[:os_version] = freebsd_version
           @resource.after_created
           expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng)
         end
@@ -71,13 +71,13 @@ describe Chef::Resource::FreebsdPackage do
       end
     end
 
-    describe "if __Freebsd_version is less than 1000017 and pkgng not enabled" do
+    describe "if freebsd_version is less than 1000017 and pkgng not enabled" do
       it "should be Freebsd::Pkg" do
         pkg_enabled = OpenStruct.new(:stdout => "\n")
         allow(@resource).to receive(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled)
 
-        [1000016, 1000000, 901503, 902506, 802511].each do |__freebsd_version|
-          @node.automatic_attrs[:os_version] = __freebsd_version
+        [1000016, 1000000, 901503, 902506, 802511].each do |freebsd_version|
+          @node.automatic_attrs[:os_version] = freebsd_version
           @resource.after_created
           expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkg)
         end

data/spec/unit/resource/launchd_spec.rb

@@ -4,10 +4,11 @@ require "spec_helper"
 
 describe Chef::Resource::Launchd do
   @launchd = Chef::Resource::Launchd.new("io.chef.chef-client")
-  let(:resource) { Chef::Resource::Launchd.new(
+  let(:resource) do
+    Chef::Resource::Launchd.new(
     "io.chef.chef-client",
     run_context
-  )}
+  ) end
 
   it "should create a new Chef::Resource::Launchd" do
     expect(resource).to be_a_kind_of(Chef::Resource)

data/spec/unit/resource/osx_profile_spec.rb

@@ -19,10 +19,11 @@
 require "spec_helper"
 
 describe Chef::Resource::OsxProfile do
-  let(:resource) { Chef::Resource::OsxProfile.new(
+  let(:resource) do
+    Chef::Resource::OsxProfile.new(
     "Test Profile Resource",
     run_context)
-  }
+  end
 
   it "should create a new Chef::Resource::OsxProfile" do
     expect(resource).to be_a_kind_of(Chef::Resource)

data/spec/unit/resource/remote_file_spec.rb

@@ -86,15 +86,15 @@ describe Chef::Resource::RemoteFile do
     end
 
     it "should only accept a single argument if a delayed evalutor is used" do
-      expect {
+      expect do
         @resource.source("http://opscode.com/", Chef::DelayedEvaluator.new { "http://opscode.com/" })
-      }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+      end.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
 
     it "should only accept a single array item if a delayed evalutor is used" do
-      expect {
+      expect do
         @resource.source(["http://opscode.com/", Chef::DelayedEvaluator.new { "http://opscode.com/" }])
-      }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+      end.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
 
     it "does not accept a non-URI as the source" do
@@ -102,10 +102,10 @@ describe Chef::Resource::RemoteFile do
     end
 
     it "does not accept a non-URI as the source when read from a delayed evaluator" do
-      expect {
+      expect do
         @resource.source(Chef::DelayedEvaluator.new { "not-a-uri" })
         @resource.source
-      }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
+      end.to raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
 
     it "should raise an exception when source is an empty array" do

data/spec/unit/resource/service_spec.rb

@@ -53,9 +53,9 @@ describe Chef::Resource::Service do
   end
 
   it "should not accept a regexp for the service pattern" do
-    expect {
+    expect do
       @resource.pattern /.*/
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service start command" do
@@ -64,9 +64,9 @@ describe Chef::Resource::Service do
   end
 
   it "should not accept a regexp for the service start command" do
-    expect {
+    expect do
       @resource.start_command /.*/
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service stop command" do
@@ -75,9 +75,9 @@ describe Chef::Resource::Service do
   end
 
   it "should not accept a regexp for the service stop command" do
-    expect {
+    expect do
       @resource.stop_command /.*/
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service status command" do
@@ -86,9 +86,9 @@ describe Chef::Resource::Service do
   end
 
   it "should not accept a regexp for the service status command" do
-    expect {
+    expect do
       @resource.status_command /.*/
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service restart command" do
@@ -97,9 +97,9 @@ describe Chef::Resource::Service do
   end
 
   it "should not accept a regexp for the service restart command" do
-    expect {
+    expect do
       @resource.restart_command /.*/
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service reload command" do
@@ -108,9 +108,9 @@ describe Chef::Resource::Service do
   end
 
   it "should not accept a regexp for the service reload command" do
-    expect {
+    expect do
       @resource.reload_command /.*/
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service init command" do
@@ -119,9 +119,9 @@ describe Chef::Resource::Service do
   end
 
   it "should not accept a regexp for the service init command" do
-    expect {
+    expect do
       @resource.init_command /.*/
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   %w{enabled running}.each do |attrib|

data/spec/unit/resource/user_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Resource::User, "initialize" do
   end
 
   it "should set the resource_name to :user" do
-    expect(@resource.resource_name).to eql(:user)
+    expect(@resource.resource_name).to eql(:user_resource_abstract_base_class)
   end
 
   it "should set the username equal to the argument to initialize" do

data/spec/unit/resource/yum_repository_spec.rb

@@ -0,0 +1,49 @@
+#
+# Author:: Thom May (<thom@chef.io>)
+# Copyright:: Copyright (c) 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 "spec_helper"
+
+describe Chef::Resource::YumRepository do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::YumRepository.new("multiverse", run_context) }
+
+  context "on linux", :linux_only do
+    it "should create a new Chef::Resource::YumRepository" do
+      expect(resource).to be_a_kind_of(Chef::Resource)
+      expect(resource).to be_a_kind_of(Chef::Resource::YumRepository)
+    end
+
+    it "should resolve to a Noop class when yum is not found" do
+      expect(Chef::Provider::YumRepository).to receive(:which).with("yum").and_return(false)
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
+    end
+
+    it "should resolve to a YumRepository class when yum is found" do
+      expect(Chef::Provider::YumRepository).to receive(:which).with("yum").and_return(true)
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::YumRepository)
+    end
+  end
+
+  context "on windows", :windows_only do
+    it "should resolve to a NoOp provider" do
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
+    end
+  end
+end

data/spec/unit/resource_collection_spec.rb

@@ -98,11 +98,11 @@ describe Chef::ResourceCollection do
     it "should allow you to iterate over every resource in the collection" do
       load_up_resources
       results = Array.new
-      expect {
+      expect do
         rc.each do |r|
           results << r.name
         end
-      }.not_to raise_error
+      end.not_to raise_error
       results.each_index do |i|
         case i
         when 0
@@ -120,11 +120,11 @@ describe Chef::ResourceCollection do
     it "should allow you to iterate over every resource by index" do
       load_up_resources
       results = Array.new
-      expect {
+      expect do
         rc.each_index do |i|
           results << rc[i].name
         end
-      }.not_to raise_error
+      end.not_to raise_error
       results.each_index do |i|
         case i
         when 0