chef 11.4.4 → 11.6.0.hotfix.1

data/spec/functional/resource/package_spec.rb

@@ -0,0 +1,297 @@
+# encoding: UTF-8
+#
+# Author:: Daniel DeLeo (<dan@opscode.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 'spec_helper'
+require 'webrick'
+
+module AptServer
+  def enable_testing_apt_source
+    File.open("/etc/apt/sources.list.d/chef-integration-test.list", "w+") do |f|
+      f.puts "deb http://localhost:9000/ sid main"
+    end
+    # Magic to update apt cache for only our repo
+    shell_out!("apt-get update " +
+               '-o Dir::Etc::sourcelist="sources.list.d/chef-integration-test.list" ' +
+               '-o Dir::Etc::sourceparts="-" -o APT::Get::List-Cleanup="0"')
+  end
+
+  def disable_testing_apt_source
+    FileUtils.rm("/etc/apt/sources.list.d/chef-integration-test.list")
+  rescue Errno::ENOENT
+    puts("Attempted to remove integration test from /etc/apt/sources.list.d but it didn't exist")
+  end
+
+  def tcp_test_port(hostname, port)
+    tcp_socket = TCPSocket.new(hostname, port)
+    true
+  rescue Errno::ETIMEDOUT
+    false
+  rescue Errno::ECONNREFUSED
+    false
+  ensure
+    tcp_socket && tcp_socket.close
+  end
+
+  def apt_server
+    @apt_server ||= WEBrick::HTTPServer.new(
+      :Port         => 9000,
+      :DocumentRoot => apt_data_dir + "/var/www/apt",
+      # Make WEBrick quiet, comment out for debug.
+      :Logger       => Logger.new(StringIO.new),
+      :AccessLog    => [ StringIO.new, WEBrick::AccessLog::COMMON_LOG_FORMAT ]
+    )
+  end
+
+  def run_apt_server
+    apt_server.start
+  end
+
+  def start_apt_server
+    @apt_server_thread = Thread.new do
+      run_apt_server
+    end
+    until tcp_test_port("localhost", 9000) do
+      if @apt_server_thread.alive?
+        sleep 1
+      else
+        @apt_server_thread.join
+        raise "apt server failed to start"
+      end
+    end
+  end
+
+  def stop_apt_server
+    apt_server.shutdown
+    @apt_server_thread.join
+  end
+
+  def apt_data_dir
+    File.join(CHEF_SPEC_DATA, "apt")
+  end
+end
+
+metadata = { :unix_only => true,
+  :requires_root => true,
+  :provider => {:package => Chef::Provider::Package::Apt},
+  :arch => "x86_64" # test packages are 64bit
+}
+
+describe Chef::Resource::Package, metadata do
+  include Chef::Mixin::ShellOut
+
+  def chef_test_dpkg_installed?
+    shell_out("dpkg -l chef-integration-test").status.success?
+  end
+
+  def dpkg_should_be_installed(pkg_name)
+    shell_out!("dpkg -l #{pkg_name}")
+  end
+
+
+  context "with a remote package source" do
+
+    include AptServer
+
+    before(:all) do
+      # Disable mixlib-shellout live streams
+      Chef::Log.level = :warn
+      start_apt_server
+      enable_testing_apt_source
+    end
+
+    after(:all) do
+      stop_apt_server
+      disable_testing_apt_source
+      shell_out!("apt-get clean")
+    end
+
+
+    after do
+      shell_out!("dpkg -r chef-integration-test")
+      shell_out("dpkg --clear-avail")
+      shell_out!("apt-get clean")
+    end
+
+    let(:node) do
+      n = Chef::Node.new
+      n.consume_external_attrs(OHAI_SYSTEM.data.dup, {})
+      n
+    end
+
+    let(:events) do
+      Chef::EventDispatch::Dispatcher.new
+    end
+
+    # TODO: lots of duplication from client.rb;
+    # All of this must be setup for preseed files to get found
+    let(:cookbook_collection) do
+      cookbook_path = File.join(CHEF_SPEC_DATA, "cookbooks")
+      cl = Chef::CookbookLoader.new(cookbook_path)
+      cl.load_cookbooks
+      Chef::Cookbook::FileVendor.on_create do |manifest|
+        Chef::Cookbook::FileSystemFileVendor.new(manifest, cookbook_path)
+      end
+      Chef::CookbookCollection.new(cl)
+    end
+
+    let(:run_context) do
+      Chef::RunContext.new(node, cookbook_collection, events)
+    end
+
+    def base_resource
+      r = Chef::Resource::Package.new("chef-integration-test", run_context)
+      # The apt repository in the spec data is not gpg signed, so we need to
+      # force apt to accept the package:
+      r.options("--force-yes")
+      r
+    end
+
+    let(:package_resource) do
+      base_resource
+    end
+
+    # it "results in a usable apt server" do
+    #   shell_out!("apt-get install -q -y --force-yes chef-integration-test ", :env => { "DEBIAN_FRONTEND" => "noninteractive" })
+    #   shell_out!("dpkg -l chef-integration-test")
+    # end
+
+    context "when the package is not yet installed" do
+      it "installs the package with action :install" do
+        package_resource.run_action(:install)
+        shell_out!("dpkg -l chef-integration-test")
+        package_resource.should be_updated_by_last_action
+      end
+
+      it "installs the package for action :upgrade" do
+        package_resource.run_action(:upgrade)
+        shell_out!("dpkg -l chef-integration-test")
+        package_resource.should be_updated_by_last_action
+      end
+
+      it "does nothing for action :remove" do
+        package_resource.run_action(:remove)
+        shell_out!("dpkg -l chef-integration-test", :returns => [1])
+        package_resource.should_not be_updated_by_last_action
+      end
+
+      it "does nothing for action :purge" do
+        package_resource.run_action(:purge)
+        shell_out!("dpkg -l chef-integration-test", :returns => [1])
+        package_resource.should_not be_updated_by_last_action
+      end
+
+      context "and a not-available package version is specified" do
+        let(:package_resource) do
+          r = base_resource
+          r.version("2.0")
+          r
+        end
+
+        it "raises a reasonable error for action :install" do
+          expect do
+            package_resource.run_action(:install)
+          end.to raise_error(Chef::Exceptions::Exec)
+        end
+
+      end
+
+      describe "when preseeding the install" do
+
+        let(:file_cache_path) { Dir.mktmpdir }
+
+        before do
+          @old_config = Chef::Config.configuration.dup
+          Chef::Config[:file_cache_path] = file_cache_path
+          debconf_reset = 'chef-integration-test chef-integration-test/sample-var string "INVALID"'
+          shell_out!("echo #{debconf_reset} |debconf-set-selections")
+        end
+
+        after do
+          FileUtils.rm_rf(file_cache_path)
+          Chef::Config.configuration = @old_config
+        end
+
+        context "with a preseed file" do
+
+          let(:package_resource) do
+            r = base_resource
+            r.cookbook_name = "preseed"
+            r.response_file("preseed-file.seed")
+            r
+          end
+
+          it "preseeds the package, then installs it" do
+            package_resource.run_action(:install)
+            cmd = shell_out!("debconf-show chef-integration-test")
+            cmd.stdout.should include('chef-integration-test/sample-var: "hello world"')
+            package_resource.should be_updated_by_last_action
+          end
+
+          context "and the preseed file exists and is up-to-date" do
+
+            before do
+              # Code here is duplicated from the implementation. Not great, but
+              # it should at least fail if the code gets out of sync.
+              source = File.join(CHEF_SPEC_DATA, "cookbooks/preseed/files/default/preseed-file.seed")
+              file_cache_dir = Chef::FileCache.create_cache_path("preseed/preseed")
+              dest = "#{file_cache_dir}/chef-integration-test-1.1-1.seed"
+              FileUtils.cp(source, dest)
+            end
+
+            it "does not update the package configuration" do
+              package_resource.run_action(:install)
+              cmd = shell_out!("debconf-show chef-integration-test")
+              cmd.stdout.should include('chef-integration-test/sample-var: INVALID')
+              package_resource.should be_updated_by_last_action
+            end
+
+          end
+
+        end
+
+        context "with a preseed template" do
+
+          let(:package_resource) do
+            r = base_resource
+            r.cookbook_name = "preseed"
+            r.response_file("preseed-template.seed")
+            r
+          end
+
+          before do
+            node.set[:preseed_value] = "FROM TEMPLATE"
+          end
+
+          it "preseeds the package, then installs it" do
+            package_resource.run_action(:install)
+            cmd = shell_out!("debconf-show chef-integration-test")
+            cmd.stdout.should include('chef-integration-test/sample-var: "FROM TEMPLATE"')
+            package_resource.should be_updated_by_last_action
+          end
+
+        end
+
+      end
+    end
+
+  end
+
+end
+
+

data/spec/functional/resource/powershell_spec.rb

@@ -0,0 +1,188 @@
+#
+# Author:: Adam Edwards (<adamed@opscode.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 'spec_helper'
+require 'functional/resource/batch_spec.rb'
+
+describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
+
+  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" }
+  let(:processor_architecture_script_content) { "echo $env:PROCESSOR_ARCHITECTURE" }
+  let(:native_architecture_script_content) { "echo $env:PROCESSOR_ARCHITECTUREW6432" }
+  let(:cmdlet_exit_code_not_found_content) { "get-item '.\\thisdoesnotexist'" }
+  let(:cmdlet_exit_code_success_content) { "get-item ." }
+  let(:windows_process_exit_code_success_content) { "#{ENV['SystemRoot']}\\system32\\attrib.exe $env:systemroot" }
+  let(:windows_process_exit_code_not_found_content) { "findstr /notavalidswitch" }
+  # Note that process exit codes on 32-bit Win2k3 cannot
+  # exceed maximum value of signed integer
+  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!(:resource) do
+    r = Chef::Resource::WindowsScript::PowershellScript.new("Powershell resource functional test", @run_context)
+    r.code(successful_executable_script_content)
+    r
+  end
+
+  describe "when the run action is invoked on Windows" do
+    it "successfully executes a non-cmdlet Windows binary as the last command of the script" do
+      resource.code(successful_executable_script_content + " | out-file -encoding ASCII #{script_output_path}")
+      resource.returns(0)
+      resource.run_action(:run)
+    end
+
+    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)      
+    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)            
+    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)            
+    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)                  
+    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)                        
+    end
+
+    # This somewhat ambiguous case, two failures of different types,
+    # seems to violate the principle of returning the status of the
+    # last line executed -- in this case, we return the status of the
+    # second to last line. This happens because Powershell gives no
+    # way for us to determine whether the last operation was a cmdlet
+    # or Windows process. Because the latter gives more specified
+    # errors than 0 or 1, we return that instead, which is acceptable
+    # since callers can test for nonzero rather than testing for 1.
+    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)                              
+    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)                                    
+    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)                                    
+    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)                                          
+    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
+    end
+
+    it "returns 1 if an invalid flag is passed to the interpreter" do
+      resource.code(cmdlet_exit_code_success_content)
+      resource.flags(invalid_powershell_interpreter_flag)
+      resource.returns(1)
+      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        
+  end
+
+  context "when running on a 32-bit version of Windows", :windows32_only do
+
+    it "executes a script with a 32-bit process if process architecture :i386 is specified" do
+      resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
+      resource.architecture(:i386)
+      resource.returns(0)
+      resource.run_action(:run)
+
+      source_contains_case_insensitive_content?( get_script_output, 'x86' ).should == true
+    end
+
+    it "raises an exception if :x86_64 process architecture is specified" do
+      begin
+        resource.architecture(:x86_64).should raise_error Chef::Exceptions::Win32ArchitectureIncorrect
+      rescue Chef::Exceptions::Win32ArchitectureIncorrect
+      end
+    end
+  end
+
+  context "when running on a 64-bit version of Windows", :windows64_only do
+    it "executes a script with a 64-bit process if :x86_64 arch is specified" do
+      resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
+      resource.architecture(:x86_64)
+      resource.returns(0)
+      resource.run_action(:run)
+
+      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)
+      resource.returns(0)
+      resource.run_action(:run)
+
+      source_contains_case_insensitive_content?( get_script_output, 'x86' ).should == true
+    end
+  end
+
+  def get_script_output
+    script_output = File.read(script_output_path)
+  end
+
+  def source_contains_case_insensitive_content?( source, content )
+    source.downcase.include?(content.downcase)
+  end
+end