chef 11.6.2 → 11.8.0.rc.1

data/spec/functional/resource/powershell_spec.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -17,11 +17,10 @@
 #
 
 require 'spec_helper'
-require 'functional/resource/batch_spec.rb'
 
 describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
 
-  include_context Chef::Resource::WindowsScript      
+  include_context Chef::Resource::WindowsScript
 
   let(:successful_executable_script_content) { "#{ENV['SystemRoot']}\\system32\\attrib.exe $env:systemroot" }
   let(:failed_executable_script_content) { "#{ENV['SystemRoot']}\\system32\\attrib.exe /badargument" }
@@ -36,7 +35,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
   let(:arbitrary_nonzero_process_exit_code) { 4193 }
   let(:arbitrary_nonzero_process_exit_code_content) { "exit #{arbitrary_nonzero_process_exit_code}" }
   let(:invalid_powershell_interpreter_flag) { "/thisflagisinvalid" }
-  let(:valid_powershell_interpreter_flag) { "-Sta" }  
+  let(:valid_powershell_interpreter_flag) { "-Sta" }
   let!(:resource) do
     r = Chef::Resource::WindowsScript::PowershellScript.new("Powershell resource functional test", @run_context)
     r.code(successful_executable_script_content)
@@ -53,31 +52,31 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns the process exit code" do
       resource.code(arbitrary_nonzero_process_exit_code_content)
       resource.returns(arbitrary_nonzero_process_exit_code)
-      resource.run_action(:run)      
+      resource.run_action(:run)
     end
 
     it "returns 0 if the last command was a cmdlet that succeeded" do
       resource.code(cmdlet_exit_code_success_content)
       resource.returns(0)
-      resource.run_action(:run)            
+      resource.run_action(:run)
     end
 
     it "returns 0 if the last command was a cmdlet that succeeded and was preceded by a non-cmdlet Windows binary that failed" do
       resource.code([windows_process_exit_code_not_found_content, cmdlet_exit_code_success_content].join(';'))
       resource.returns(0)
-      resource.run_action(:run)            
+      resource.run_action(:run)
     end
-    
+
     it "returns 1 if the last command was a cmdlet that failed" do
       resource.code(cmdlet_exit_code_not_found_content)
       resource.returns(1)
-      resource.run_action(:run)                  
+      resource.run_action(:run)
     end
 
     it "returns 1 if the last command was a cmdlet that failed and was preceded by a successfully executed non-cmdlet Windows binary" do
       resource.code([windows_process_exit_code_success_content, cmdlet_exit_code_not_found_content].join(';'))
       resource.returns(1)
-      resource.run_action(:run)                        
+      resource.run_action(:run)
     end
 
     # This somewhat ambiguous case, two failures of different types,
@@ -91,34 +90,34 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns 1 if the last command was a cmdlet that failed and was preceded by an unsuccessfully executed non-cmdlet Windows binary" do
       resource.code([arbitrary_nonzero_process_exit_code_content,cmdlet_exit_code_not_found_content].join(';'))
       resource.returns(arbitrary_nonzero_process_exit_code)
-      resource.run_action(:run)                              
+      resource.run_action(:run)
     end
 
     it "returns 0 if the last command was a non-cmdlet Windows binary that succeeded and was preceded by a failed cmdlet" do
       resource.code([cmdlet_exit_code_success_content, arbitrary_nonzero_process_exit_code_content].join(';'))
       resource.returns(arbitrary_nonzero_process_exit_code)
-      resource.run_action(:run)                                    
+      resource.run_action(:run)
     end
-    
+
     it "returns a specific error code if the last command was a non-cmdlet Windows binary that failed and was preceded by cmdlet that succeeded" do
       resource.code([cmdlet_exit_code_success_content, arbitrary_nonzero_process_exit_code_content].join(';'))
       resource.returns(arbitrary_nonzero_process_exit_code)
-      resource.run_action(:run)                                    
+      resource.run_action(:run)
     end
 
     it "returns a specific error code if the last command was a non-cmdlet Windows binary that failed and was preceded by cmdlet that failed" do
       resource.code([cmdlet_exit_code_not_found_content, arbitrary_nonzero_process_exit_code_content].join(';'))
       resource.returns(arbitrary_nonzero_process_exit_code)
-      resource.run_action(:run)                                          
+      resource.run_action(:run)
     end
-    
+
     it "executes a script with a 64-bit process on a 64-bit OS, otherwise a 32-bit process" do
       resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
       resource.returns(0)
       resource.run_action(:run)
 
       is_64_bit = (ENV['PROCESSOR_ARCHITECTURE'] == 'AMD64') || (ENV['PROCESSOR_ARCHITEW6432'] == 'AMD64')
-      
+
       detected_64_bit = source_contains_case_insensitive_content?( get_script_output, 'AMD64' )
 
       is_64_bit.should == detected_64_bit
@@ -128,15 +127,15 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       resource.code(cmdlet_exit_code_success_content)
       resource.flags(invalid_powershell_interpreter_flag)
       resource.returns(1)
-      resource.run_action(:run)                  
+      resource.run_action(:run)
     end
 
     it "returns 0 if a valid flag is passed to the interpreter" do
       resource.code(cmdlet_exit_code_success_content)
       resource.flags(valid_powershell_interpreter_flag)
       resource.returns(0)
-      resource.run_action(:run)                  
-    end        
+      resource.run_action(:run)
+    end
   end
 
   context "when running on a 32-bit version of Windows", :windows32_only do
@@ -167,7 +166,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
 
       source_contains_case_insensitive_content?( get_script_output, 'AMD64' ).should == true
     end
-    
+
     it "executes a script with a 32-bit process if :i386 arch is specified" do
       resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
       resource.architecture(:i386)

data/spec/functional/resource/registry_spec.rb

@@ -104,8 +104,6 @@ describe Chef::Resource::RegistryKey, :windows_only do
     @new_resource = Chef::Resource::RegistryKey.new(resource_name, @run_context)
     @registry = Chef::Win32::Registry.new(@run_context)
 
-    @current_whyrun = Chef::Config[:why_run]
-
     reset_registry
   end
 
@@ -259,12 +257,9 @@ describe Chef::Resource::RegistryKey, :windows_only do
     end
 
     context "while running in whyrun mode" do
-      before (:all) do
+      before (:each) do
         Chef::Config[:why_run] = true
       end
-      after (:all) do
-        Chef::Config[:why_run] = @current_whyrun
-      end
 
       it "does not throw an exception if the keys do not exist but recursive is set to false" do
         @new_resource.key(reg_child + '\Slitheen\Raxicoricofallapatorius')
@@ -373,12 +368,9 @@ describe Chef::Resource::RegistryKey, :windows_only do
     end
 
     context "while running in whyrun mode" do
-      before (:all) do
+      before (:each) do
         Chef::Config[:why_run] = true
       end
-      after (:all) do
-        Chef::Config[:why_run] = @current_whyrun
-      end
 
       it "does not throw an exception if the keys do not exist but recursive is set to false" do
         @new_resource.key(reg_child + '\Zygons\Zygor')
@@ -469,12 +461,9 @@ describe Chef::Resource::RegistryKey, :windows_only do
     end
 
     context "while running in whyrun mode" do
-      before (:all) do
+      before (:each) do
         Chef::Config[:why_run] = true
       end
-      after (:all) do
-        Chef::Config[:why_run] = @current_whyrun
-      end
       it "does nothing if the action is delete" do
         @new_resource.key(reg_parent + '\OpscodeWhyRun')
         @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
@@ -510,7 +499,7 @@ describe Chef::Resource::RegistryKey, :windows_only do
       @registry.key_exists?(reg_parent + '\OpscodeTest').should == false
     end
 
-    it "raises an exception if the the key has subkeys and recursive == false" do
+    it "raises an exception if the key has subkeys and recursive == false" do
       @new_resource.key(reg_parent)
       @new_resource.recursive(false)
       lambda{@new_resource.run_action(:delete_key)}.should raise_error(Chef::Exceptions::Win32RegNoRecursive)
@@ -549,12 +538,9 @@ describe Chef::Resource::RegistryKey, :windows_only do
       @report["total_res_count"].should == "1"
     end
     context "while running in whyrun mode" do
-      before (:all) do
+      before (:each) do
         Chef::Config[:why_run] = true
       end
-      after (:all) do
-        Chef::Config[:why_run] = @current_whyrun
-      end
 
       it "does not throw an exception if the key has subkeys but recursive is set to false" do
         @new_resource.key(reg_parent + '\OpscodeWhyRun')

data/spec/functional/resource/remote_file_spec.rb

@@ -83,6 +83,19 @@ describe Chef::Resource::RemoteFile do
       stop_tiny_server
     end
 
+    describe "when redownload isn't necessary" do
+      let(:source) { 'http://localhost:9000/seattle_capo.png' }
+
+      before do
+        @api.get("/seattle_capo.png", 304, "", { 'Etag' => 'abcdef' } )
+      end
+
+      it "does not fetch the file" do
+        resource.run_action(:create)
+      end
+
+    end
+
     context "when using normal encoding" do
       let(:source) { 'http://localhost:9000/nyan_cat.png' }
       let(:expected_content) do
@@ -112,6 +125,7 @@ describe Chef::Resource::RemoteFile do
 
       it_behaves_like "a securable resource with reporting"
     end
+
   end
 
   context "when fetching files over HTTPS" do

data/spec/functional/resource/rpm_spec.rb

@@ -0,0 +1,122 @@
+#
+# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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 'functional/resource/base'
+require 'chef/mixin/shell_out'
+
+# run this test only for following platforms.
+exclude_test = !['aix', 'centos', 'redhat', 'suse'].include?(ohai[:platform])
+describe Chef::Resource::RpmPackage, :requires_root, :external => exclude_test do
+  include Chef::Mixin::ShellOut
+
+  let(:new_resource) do
+    new_resource = Chef::Resource::RpmPackage.new(@pkg_name, run_context)
+    new_resource.source @pkg_path
+    new_resource
+  end
+
+  def rpm_pkg_should_be_installed(resource)
+    case ohai[:platform]
+    # Due to dependency issues , different rpm pkgs are used in different platforms.
+    # dummy rpm package works in aix, without any dependency issues.
+    when "aix"
+      expect(shell_out("rpm -qa | grep dummy").exitstatus).to eq(0)
+    # mytest rpm package works in centos, redhat and in suse without any dependency issues.
+    when "centos", "redhat", "suse"
+      expect(shell_out("rpm -qa | grep mytest").exitstatus).to eq(0)
+      ::File.exists?("/opt/mytest/mytest.sh") # The mytest rpm package contains the mytest.sh file
+    end
+  end
+
+  def rpm_pkg_should_not_be_installed(resource)
+    case ohai[:platform]
+    when "aix"
+      expect(shell_out("rpm -qa | grep dummy").exitstatus).to eq(1)
+    when "centos", "redhat", "suse"
+      expect(shell_out("rpm -qa | grep mytest").exitstatus).to eq(1)
+      !::File.exists?("/opt/mytest/mytest.sh")
+    end
+  end
+
+  before(:all) do
+    case ohai[:platform]
+    # Due to dependency issues , different rpm pkgs are used in different platforms.
+    when "aix"
+      @pkg_name = "dummy"
+      @pkg_version = "1-0"
+      @pkg_path = "/tmp/dummy-1-0.aix6.1.noarch.rpm"
+      FileUtils.cp 'spec/functional/assets/dummy-1-0.aix6.1.noarch.rpm' , @pkg_path
+    when "centos", "redhat", "suse"
+      @pkg_name = "mytest"
+      @pkg_version = "1.0-1"
+      @pkg_path = "/tmp/mytest-1.0-1.noarch.rpm"
+      FileUtils.cp 'spec/functional/assets/mytest-1.0-1.noarch.rpm' , @pkg_path
+    end
+  end
+
+  after(:all) do
+    FileUtils.rm @pkg_path
+  end
+
+  context "package install action" do
+    it "should create a package" do
+      new_resource.run_action(:install)
+      rpm_pkg_should_be_installed(new_resource)
+    end
+
+    after(:each) do
+      shell_out("rpm -qa | grep #{@pkg_name}-#{@pkg_version} | xargs rpm -e")
+    end
+  end
+
+  context "package remove action" do
+    before(:each) do
+      shell_out("rpm -i #{@pkg_path}")
+    end
+
+    it "should remove an existing package" do
+      new_resource.run_action(:remove)
+      rpm_pkg_should_not_be_installed(new_resource)
+    end
+  end
+
+  context "package upgrade action" do
+    before(:each) do
+      shell_out("rpm -i #{@pkg_path}")
+      if ohai[:platform] == 'aix'
+        @pkg_version = "2-0"
+        @pkg_path = "/tmp/dummy-2-0.aix6.1.noarch.rpm"
+        FileUtils.cp 'spec/functional/assets/dummy-2-0.aix6.1.noarch.rpm' , @pkg_path
+      else
+        @pkg_version = "2.0-1"
+        @pkg_path = "/tmp/mytest-2.0-1.noarch.rpm"
+        FileUtils.cp 'spec/functional/assets/mytest-2.0-1.noarch.rpm' , @pkg_path
+      end
+    end
+
+    it "should upgrade a package" do
+      new_resource.run_action(:install)
+      rpm_pkg_should_be_installed(new_resource)
+    end
+
+    after(:each) do
+      shell_out("rpm -qa | grep #{@pkg_name}-#{@pkg_version} | xargs rpm -e")
+      FileUtils.rm @pkg_path
+    end
+  end
+end

data/spec/functional/resource/template_spec.rb

@@ -189,54 +189,21 @@ describe Chef::Resource::Template do
   end
 
   describe "when template source contains windows style line endings" do
-
     include_context "diff disabled"
 
-    let(:expected_content) {
-      "Template rendering libraries\r\nshould support\r\ndifferent line endings\r\n\r\n"
-    }
-
-    context "for all lines" do
-      let(:resource) do
-        r = create_resource
-        r.source "all_windows_line_endings.erb"
-        r
-      end
-
-      it "output should contain windows line endings" do
-        resource.run_action(:create)
-        binread(path).each_line do |line|
-          line.should end_with("\r\n")
-        end
-      end
-    end
-
-    context "for some lines" do
-      let(:resource) do
-        r = create_resource
-        r.source "some_windows_line_endings.erb"
-        r
-      end
-
-      it "output should contain windows line endings" do
-        resource.run_action(:create)
-        binread(path).each_line do |line|
-          line.should end_with("\r\n")
+    ["all", "some", "no"].each do |test_case|
+      context "for #{test_case} lines" do
+        let(:resource) do
+          r = create_resource
+          r.source "#{test_case}_windows_line_endings.erb"
+          r
         end
-      end
-    end
 
-    context "for no lines" do
-      let(:resource) do
-        r = create_resource
-        r.source "no_windows_line_endings.erb"
-        r
-      end
-
-      it "output should not contain windows line endings" do
-        resource.run_action(:create)
-        IO.read(path).each_line do |line|
-          line.should_not end_with("\r\n")
+        it "output should contain platform's line endings" do
+          resource.run_action(:create)
+          binread(path).each_line do |line|
+            line.should end_with(Chef::Platform.windows? ? "\r\n" : "\n")
+          end
         end
       end
     end

data/spec/functional/resource/user_spec.rb

@@ -54,6 +54,7 @@ describe Chef::Resource::User, metadata do
   end
 
   before do
+    pending "porting implementation for user provider in aix" if OHAI_SYSTEM[:platform] == 'aix'
     # Silence shell_out live stream
     Chef::Log.level = :warn
   end
@@ -497,7 +498,7 @@ describe Chef::Resource::User, metadata do
       context "and has no password" do
 
         # TODO: platform_family should be setup in spec_helper w/ tags
-        if OHAI_SYSTEM["platform_family"] == "suse"
+        if %w[suse opensuse].include?(OHAI_SYSTEM["platform_family"])
           # suse gets this right:
           it "errors out trying to unlock the user" do
             @error.should be_a(Mixlib::ShellOut::ShellCommandFailed)

data/spec/functional/run_lock_spec.rb

@@ -20,7 +20,7 @@ require 'chef/client'
 
 describe Chef::RunLock do
 
-  # This behavior is believed to work on windows, but the tests use UNIX APIs.
+  # This behavior works on windows, but the tests use fork :(
   describe "when locking the chef-client run", :unix_only => true do
 
     ##
@@ -31,7 +31,6 @@ describe Chef::RunLock do
       "/tmp/#{Kernel.rand(Time.now.to_i + Process.pid)}"
     end
 
-    let(:file_cache_path){ "/var/chef/cache" }
     let(:lockfile){ "#{random_temp_root}/this/long/path/does/not/exist/chef-client-running.pid" }
 
     # make sure to start with a clean slate.
@@ -161,7 +160,7 @@ describe Chef::RunLock do
 
     ##
     # Run lock is the system under test
-    let!(:run_lock) { Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile) }
+    let!(:run_lock) { Chef::RunLock.new(lockfile) }
 
     it "creates the full path to the lockfile" do
       lambda { run_lock.acquire }.should_not raise_error(Errno::ENOENT)
@@ -225,7 +224,6 @@ E
       Process.kill(:KILL, p1)
       Process.waitpid2(p1)
 
-
       p2 = fork do
         run_lock.acquire
         record "p2 has lock"
@@ -237,7 +235,52 @@ E
 
       results.should =~ /p2 has lock\Z/
     end
-  end
 
+    it "test returns true and acquires the lock" do
+      p1 = fork do
+        run_lock.test.should == true
+        sleep 2
+        exit! 1
+      end
+
+      wait_on_lock
+
+      p2 = fork do
+        run_lock.test.should == false
+        exit! 0
+      end
+
+      Process.waitpid2(p2)
+      Process.waitpid2(p1)
+    end
+
+    it "test returns without waiting when the lock is acquired" do
+      p1 = fork do
+        run_lock.acquire
+        sleep 2
+        exit! 1
+      end
+
+      wait_on_lock
+
+      run_lock.test.should == false
+      Process.waitpid2(p1)
+    end
+
+    it "doesn't truncate the lock file so that contents can be read" do
+      p1 = fork do
+        run_lock.acquire
+        run_lock.save_pid
+        sleep 2
+        exit! 1
+      end
+
+      wait_on_lock
+      File.read(lockfile).should == p1.to_s
+
+      Process.waitpid2(p1)
+    end
+
+  end
 end