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

data/spec/unit/resource/chef_gem_spec.rb

@@ -32,16 +32,130 @@ describe Chef::Resource::ChefGem, "initialize" do
 end
 
 describe Chef::Resource::ChefGem, "gem_binary" do
+  let(:resource) { Chef::Resource::ChefGem.new("foo") }
+
   before(:each) do
     expect(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/opt/chef/embedded/bin")
-    @resource = Chef::Resource::ChefGem.new("foo")
   end
 
   it "should raise an exception when gem_binary is set" do
-    expect { @resource.gem_binary("/lol/cats/gem") }.to raise_error(ArgumentError)
+    expect { resource.gem_binary("/lol/cats/gem") }.to raise_error(ArgumentError)
+  end
+
+  it "should set the gem_binary based on computing it from RbConfig" do
+    expect(resource.gem_binary).to eql("/opt/chef/embedded/bin/gem")
   end
 
   it "should set the gem_binary based on computing it from RbConfig" do
-    expect(@resource.gem_binary).to eql("/opt/chef/embedded/bin/gem")
+    expect(resource.compile_time).to be nil
+  end
+
+  context "when building the resource" do
+    let(:node) do
+      Chef::Node.new.tap {|n| n.normal[:tags] = [] }
+    end
+
+    let(:run_context) do
+      Chef::RunContext.new(node, {}, nil)
+    end
+
+    let(:recipe) do
+      Chef::Recipe.new("hjk", "test", run_context)
+    end
+
+    let(:chef_gem_compile_time) { nil }
+
+    let(:resource) do
+      Chef::Config[:chef_gem_compile_time] = chef_gem_compile_time
+      Chef::Resource::ChefGem.new("foo", run_context)
+    end
+
+    before do
+      expect(Chef::Resource::ChefGem).to receive(:new).and_return(resource)
+    end
+
+    it "runs the install at compile-time by default", :chef_lt_13_only do
+      expect(resource).to receive(:run_action).with(:install)
+      expect(Chef::Log).to receive(:deprecation).at_least(:once)
+      recipe.chef_gem "foo"
+    end
+
+    # the default behavior will change in Chef-13
+    it "does not runs the install at compile-time by default", :chef_gte_13_only do
+      expect(resource).not_to receive(:run_action).with(:install)
+      expect(Chef::Log).not_to receive(:deprecation)
+      recipe.chef_gem "foo"
+    end
+
+    it "compile_time true installs at compile-time" do
+      expect(resource).to receive(:run_action).with(:install)
+      expect(Chef::Log).not_to receive(:deprecation)
+      recipe.chef_gem "foo" do
+        compile_time true
+      end
+    end
+
+    it "compile_time false does not install at compile-time" do
+      expect(resource).not_to receive(:run_action).with(:install)
+      expect(Chef::Log).not_to receive(:deprecation)
+      recipe.chef_gem "foo" do
+        compile_time false
+      end
+    end
+
+    describe "when Chef::Config[:chef_gem_compile_time] is explicitly true" do
+      let(:chef_gem_compile_time) { true }
+
+      before do
+        expect(Chef::Log).not_to receive(:deprecation)
+      end
+
+      it "by default installs at compile-time" do
+        expect(resource).to receive(:run_action).with(:install)
+        recipe.chef_gem "foo"
+      end
+
+      it "compile_time true installs at compile-time" do
+        expect(resource).to receive(:run_action).with(:install)
+        recipe.chef_gem "foo" do
+          compile_time true
+        end
+      end
+
+      it "compile_time false does not install at compile-time" do
+        expect(resource).not_to receive(:run_action).with(:install)
+        recipe.chef_gem "foo" do
+          compile_time false
+        end
+      end
+    end
+
+    describe "when Chef::Config[:chef_gem_compile_time] is explicitly false" do
+
+      let(:chef_gem_compile_time) { false }
+
+      before do
+        expect(Chef::Log).not_to receive(:deprecation)
+      end
+
+      it "by default does not install at compile-time" do
+        expect(resource).not_to receive(:run_action).with(:install)
+        recipe.chef_gem "foo"
+      end
+
+      it "compile_time true installs at compile-time" do
+        expect(resource).to receive(:run_action).with(:install)
+        recipe.chef_gem "foo" do
+          compile_time true
+        end
+      end
+
+      it "compile_time false does not install at compile-time" do
+        expect(resource).not_to receive(:run_action).with(:install)
+        recipe.chef_gem "foo" do
+          compile_time false
+        end
+      end
+    end
   end
 end

data/spec/unit/resource/conditional_action_not_nothing_spec.rb

@@ -27,7 +27,7 @@ describe Chef::Resource::ConditionalActionNotNothing do
     end
 
     it "indicates that resource convergence should not continue" do
-      expect(@conditional.continue?).to be_false
+      expect(@conditional.continue?).to be_falsey
     end
   end
 
@@ -38,7 +38,7 @@ describe Chef::Resource::ConditionalActionNotNothing do
     end
 
     it "indicates that resource convergence should continue" do
-      expect(@conditional.continue?).to be_true
+      expect(@conditional.continue?).to be_truthy
     end
   end
 

data/spec/unit/resource/conditional_spec.rb

@@ -47,24 +47,45 @@ describe Chef::Resource::Conditional do
   end
 
   describe "when created as an `only_if`" do
-    describe "after running a successful command" do
+    describe "after running a successful command given as a string" do
       before do
         @conditional = Chef::Resource::Conditional.only_if(@parent_resource, "true")
       end
 
       it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_true
+        expect(@conditional.continue?).to be_truthy
       end
     end
 
-    describe "after running a negative/false command" do
+    describe "after running a negative/false command given as a string" do
       before do
         @status.send("success?=", false)
         @conditional = Chef::Resource::Conditional.only_if(@parent_resource, "false")
       end
 
       it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_false
+        expect(@conditional.continue?).to be_falsey
+      end
+    end
+
+    describe "after running a successful command given as an array" do
+      before do
+        @conditional = Chef::Resource::Conditional.only_if(@parent_resource, ["true"])
+      end
+
+      it "indicates that resource convergence should continue" do
+        expect(@conditional.continue?).to be true
+      end
+    end
+
+    describe "after running a negative/false command given as an array" do
+      before do
+        @status.send("success?=", false)
+        @conditional = Chef::Resource::Conditional.only_if(@parent_resource, ["false"])
+      end
+
+      it "indicates that resource convergence should not continue" do
+        expect(@conditional.continue?).to be false
       end
     end
 
@@ -75,7 +96,7 @@ describe Chef::Resource::Conditional do
       end
 
       it 'indicates that resource convergence should not continue' do
-        expect(@conditional.continue?).to be_false
+        expect(@conditional.continue?).to be_falsey
       end
 
       it 'should log a warning' do
@@ -90,7 +111,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_true
+        expect(@conditional.continue?).to be_truthy
       end
     end
 
@@ -100,30 +121,51 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_false
+        expect(@conditional.continue?).to be_falsey
       end
     end
   end
 
   describe "when created as a `not_if`" do
-    describe "after running a successful/true command" do
+    describe "after running a successful/true command given as a string" do
       before do
         @conditional = Chef::Resource::Conditional.not_if(@parent_resource, "true")
       end
 
       it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_false
+        expect(@conditional.continue?).to be_falsey
       end
     end
 
-    describe "after running a failed/false command" do
+    describe "after running a failed/false command given as a string" do
       before do
         @status.send("success?=", false)
         @conditional = Chef::Resource::Conditional.not_if(@parent_resource, "false")
       end
 
       it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_true
+        expect(@conditional.continue?).to be_truthy
+      end
+    end
+
+    describe "after running a successful/true command given as an array" do
+      before do
+        @conditional = Chef::Resource::Conditional.not_if(@parent_resource, ["true"])
+      end
+
+      it "indicates that resource convergence should not continue" do
+        expect(@conditional.continue?).to be false
+      end
+    end
+
+    describe "after running a failed/false command given as an array" do
+      before do
+        @status.send("success?=", false)
+        @conditional = Chef::Resource::Conditional.not_if(@parent_resource, ["false"])
+      end
+
+      it "indicates that resource convergence should continue" do
+        expect(@conditional.continue?).to be true
       end
     end
 
@@ -134,7 +176,7 @@ describe Chef::Resource::Conditional do
       end
 
       it 'indicates that resource convergence should continue' do
-        expect(@conditional.continue?).to be_true
+        expect(@conditional.continue?).to be_truthy
       end
 
       it 'should log a warning' do
@@ -149,7 +191,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_false
+        expect(@conditional.continue?).to be_falsey
       end
     end
 
@@ -159,9 +201,8 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_true
+        expect(@conditional.continue?).to be_truthy
       end
     end
   end
-
 end

data/spec/unit/resource/deploy_spec.rb

@@ -115,9 +115,9 @@ describe Chef::Resource::Deploy do
   end
 
   it "has a boolean attribute for svn_force_export defaulting to false" do
-    expect(@resource.svn_force_export).to be_false
+    expect(@resource.svn_force_export).to be_falsey
     @resource.svn_force_export true
-    expect(@resource.svn_force_export).to be_true
+    expect(@resource.svn_force_export).to be_truthy
     expect {@resource.svn_force_export(10053)}.to raise_error(ArgumentError)
   end
 

data/spec/unit/resource/dsc_script_spec.rb

@@ -70,6 +70,38 @@ describe Chef::Resource::DscScript do
       expect(dsc_test_resource.configuration_data_script).to eq(configuration_data_script)
     end
 
+    context "when calling imports" do
+      let(:module_name)   { 'FooModule' }
+      let(:module_name_b)   { 'BarModule' }
+      let(:dsc_resources) { ['ResourceA', 'ResourceB'] }
+
+      it "allows an arbitrary number of resources to be set for a module to be set" do
+        dsc_test_resource.imports module_name, *dsc_resources
+        module_imports = dsc_test_resource.imports[module_name]
+        expect(module_imports).to eq(dsc_resources)
+      end
+
+      it "adds * to the imports when no resources are set for a moudle" do
+        dsc_test_resource.imports module_name
+        module_imports = dsc_test_resource.imports[module_name]
+        expect(module_imports).to eq(['*'])
+      end
+
+      it "allows an arbitrary number of modules" do
+        dsc_test_resource.imports module_name
+        dsc_test_resource.imports module_name_b
+        expect(dsc_test_resource.imports).to have_key(module_name)
+        expect(dsc_test_resource.imports).to have_key(module_name_b)
+      end
+
+      it "allows resources to be added for a module" do
+        dsc_test_resource.imports module_name, dsc_resources[0]
+        dsc_test_resource.imports module_name, dsc_resources[1]
+        module_imports = dsc_test_resource.imports[module_name]
+        expect(module_imports).to eq(dsc_resources)
+      end
+    end
+
     it "raises an ArgumentError exception if an attempt is made to set the code attribute when the command attribute is already set" do
       dsc_test_resource.command(configuration_path)
       expect { dsc_test_resource.code(configuration_code) }.to raise_error(ArgumentError)

data/spec/unit/resource/execute_spec.rb

@@ -28,4 +28,8 @@ describe Chef::Resource::Execute do
     expect(execute_resource.guard_interpreter).to be(:execute)
   end
 
+  it "defaults to not being a guard interpreter" do
+    expect(execute_resource.is_guard_interpreter).to eq(false)
+  end
+
 end

data/spec/unit/resource/file/verification_spec.rb

@@ -0,0 +1,111 @@
+#
+# Author:: Steven Danna (<steve@chef.io>)
+# Copyright:: Copyright (c) 2014 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::File::Verification do
+  let(:t_block) { Proc.new { true } }
+  let(:f_block) { Proc.new { false } }
+  let(:path_block) { Proc.new { |path| path }}
+  let(:temp_path) { "/tmp/foobar" }
+
+  describe "verification registration" do
+    it "registers a verification for later use" do
+      class Chef::Resource::File::Verification::Wombat < Chef::Resource::File::Verification
+        provides :tabmow
+      end
+      expect(Chef::Resource::File::Verification.lookup(:tabmow)).to eq(Chef::Resource::File::Verification::Wombat)
+    end
+
+    it "raises an error if a verification can't be found" do
+      expect{Chef::Resource::File::Verification.lookup(:dne)}.to raise_error(Chef::Exceptions::VerificationNotFound)
+    end
+  end
+
+  describe "#verify" do
+    let(:parent_resource) { Chef::Resource.new("llama") }
+
+    it "expects a string argument" do
+      v = Chef::Resource::File::Verification.new(parent_resource, nil, {}) {}
+      expect{ v.verify("/foo/bar") }.to_not raise_error
+      expect{ v.verify }.to raise_error
+    end
+
+    it "accepts an options hash" do
+      v = Chef::Resource::File::Verification.new(parent_resource, nil, {}) {}
+      expect{ v.verify("/foo/bar", {:future => true}) }.to_not raise_error
+    end
+
+    context "with a verification block" do
+      it "passes a file path to the block" do
+        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}, &path_block)
+        expect(v.verify(temp_path)).to eq(temp_path)
+      end
+
+      it "returns true if the block returned true" do
+        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}, &t_block)
+        expect(v.verify(temp_path)).to eq(true)
+      end
+
+      it "returns false if the block returned false" do
+        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}, &f_block)
+        expect(v.verify(temp_path)).to eq(false)
+      end
+    end
+
+    context "with a verification command(String)" do
+      it "substitutes \%{file} with the path" do
+        test_command = if windows?
+                         "if \"#{temp_path}\" == \"%{file}\" (exit 0) else (exit 1)"
+                       else
+                         "test #{temp_path} = %{file}"
+                       end
+        v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
+        expect(v.verify(temp_path)).to eq(true)
+      end
+
+      it "returns false if the command fails" do
+        v = Chef::Resource::File::Verification.new(parent_resource, "false", {})
+        expect(v.verify(temp_path)).to eq(false)
+      end
+
+      it "returns true if the command succeeds" do
+        v = Chef::Resource::File::Verification.new(parent_resource, "true", {})
+        expect(v.verify(temp_path)).to eq(true)
+      end
+    end
+
+    context "with a named verification(Symbol)" do
+      before(:each) do
+        class Chef::Resource::File::Verification::Turtle < Chef::Resource::File::Verification
+          provides :cats
+          def verify(path, opts)
+          end
+        end
+      end
+
+      it "delegates to the registered verification" do
+        registered_verification = double()
+        allow(Chef::Resource::File::Verification::Turtle).to receive(:new).and_return(registered_verification)
+        v = Chef::Resource::File::Verification.new(parent_resource, :cats, {})
+        expect(registered_verification).to receive(:verify).with(temp_path, {})
+        v.verify(temp_path, {})
+      end
+    end
+  end
+end