chef 11.6.2-x86-mingw32 → 11.8.0.rc.1-x86-mingw32

data/spec/functional/resource/ifconfig_spec.rb

@@ -0,0 +1,163 @@
+#
+# Author:: Kaustubh Deorukhkar (<kaustubh@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.
+include_flag = !(['ubuntu', 'centos', 'aix'].include?(ohai[:platform]))
+
+describe Chef::Resource::Ifconfig, :requires_root, :external => include_flag do
+  include Chef::Mixin::ShellOut
+
+  let(:new_resource) do
+    new_resource = Chef::Resource::Ifconfig.new('10.10.0.1', run_context)
+    new_resource
+  end
+
+  let(:provider) do
+    provider = new_resource.provider_for_action(new_resource.action)
+    provider
+  end
+
+  let(:current_resource) do
+    provider.load_current_resource
+  end
+
+  def lo_interface_for_test
+    # use loopback interface for tests
+    case ohai[:platform]
+    when "aix"
+      'lo0'
+    else
+      'lo'
+    end
+  end
+
+  # **Caution: any updates to core interfaces can be risky.
+  def en0_interface_for_test
+    case ohai[:platform]
+    when "aix"
+      'en0'
+    else
+      'eth0'
+    end
+  end
+
+  def network_interface_alias(interface)
+    case ohai[:platform]
+    when "aix"
+      interface
+    else
+      interface + ":10"
+    end
+  end
+
+  # platform specific test setup and validation routines
+
+  def setup_add_interface(resource)
+    resource.device network_interface_alias(en0_interface_for_test)
+  end
+
+  def setup_enable_interface(resource)
+    resource.device network_interface_alias(en0_interface_for_test)
+  end
+
+  def interface_should_exists(interface)
+    expect(shell_out("ifconfig #{@interface} | grep 10.10.0.1").exitstatus).to eq(0)
+  end
+
+  def interface_should_not_exists(interface)
+    expect(shell_out("ifconfig #{@interface} | grep 10.10.0.1").exitstatus).to eq(1)
+  end
+
+  def interface_persistence_should_exists(interface)
+    case ohai[:platform]
+    when "aix"
+      expect(shell_out("lsattr -E -l #{@interface} | grep 10.10.0.1").exitstatus).to eq(0)
+    else
+    end
+  end
+
+  def interface_persistence_should_not_exists(interface)
+    case ohai[:platform]
+    when "aix"
+      expect(shell_out("lsattr -E -l #{@interface} | grep 10.10.0.1").exitstatus).to eq(1)
+    else
+    end
+  end
+
+  # Actual tests
+
+  describe "#load_current_resource" do
+    it 'should load given interface' do
+      new_resource.device lo_interface_for_test
+      expect(current_resource.device).to eql(lo_interface_for_test)
+      expect(current_resource.inet_addr).to match(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/)
+    end
+  end
+
+  exclude_test = ohai[:platform] != 'ubuntu'
+  describe "#action_add", :external => exclude_test do
+    after do
+      new_resource.run_action(:delete)
+    end
+    it "should add interface (vip)" do
+      setup_add_interface(new_resource)
+      new_resource.run_action(:add)
+      interface_should_exists(network_interface_alias(en0_interface_for_test))
+      interface_persistence_should_exists(network_interface_alias(en0_interface_for_test))
+    end
+  end
+
+  describe "#action_enable", :external => exclude_test do
+    after do
+      new_resource.run_action(:disable)
+    end
+    it "should enable interface (vip)" do
+      setup_enable_interface(new_resource)
+      new_resource.run_action(:enable)
+      interface_should_exists(network_interface_alias(en0_interface_for_test))
+    end
+  end
+
+  describe "#action_disable", :external => exclude_test do
+    before do
+      setup_enable_interface(new_resource)
+      new_resource.run_action(:enable)
+    end
+    it "should disable interface (vip)" do
+      new_resource.run_action(:disable)
+      new_resource.should be_updated_by_last_action
+      interface_should_not_exists(network_interface_alias(en0_interface_for_test))
+    end
+  end
+
+  describe "#action_delete", :external => exclude_test do
+    before do
+      setup_add_interface(new_resource)
+      new_resource.run_action(:add)
+    end
+    it "should delete interface (vip)" do
+      new_resource.run_action(:delete)
+      new_resource.should be_updated_by_last_action
+      interface_should_not_exists(network_interface_alias(en0_interface_for_test))
+      interface_persistence_should_not_exists(network_interface_alias(en0_interface_for_test))
+    end
+  end
+end

data/spec/functional/resource/link_spec.rb

@@ -340,7 +340,7 @@ describe Chef::Resource::Link do
           it 'create errors out' do
             if windows?
               lambda { resource.run_action(:create) }.should raise_error(Errno::EACCES)
-            elsif os_x? or solaris? or freebsd?
+            elsif os_x? or solaris? or freebsd? or aix?
               lambda { resource.run_action(:create) }.should raise_error(Errno::EPERM)
             else
               lambda { resource.run_action(:create) }.should raise_error(Errno::EISDIR)
@@ -502,7 +502,7 @@ describe Chef::Resource::Link do
           it 'errors out' do
             if windows?
               lambda { resource.run_action(:create) }.should raise_error(Errno::EACCES)
-            elsif os_x? or solaris? or freebsd?
+            elsif os_x? or solaris? or freebsd? or aix?
               lambda { resource.run_action(:create) }.should raise_error(Errno::EPERM)
             else
               lambda { resource.run_action(:create) }.should raise_error(Errno::EISDIR)
@@ -554,7 +554,7 @@ describe Chef::Resource::Link do
               resource.run_action(:create)
               File.exists?(target_file).should be_true
               # OS X gets angry about this sort of link.  Bug in OS X, IMO.
-              pending('OS X/FreeBSD symlink? and readlink working on hard links to symlinks', :if => (os_x? or freebsd?)) do
+              pending('OS X/FreeBSD/AIX symlink? and readlink working on hard links to symlinks', :if => (os_x? or freebsd? or aix?)) do
                 symlink?(target_file).should be_true
                 readlink(target_file).should == canonicalize(@other_target)
               end
@@ -571,7 +571,7 @@ describe Chef::Resource::Link do
           end
           context 'and the link does not yet exist' do
             it 'links to the target file' do
-              pending('OS X/FreeBSD fails to create hardlinks to broken symlinks', :if => (os_x? or freebsd?)) do
+              pending('OS X/FreeBSD/AIX fails to create hardlinks to broken symlinks', :if => (os_x? or freebsd? or aix?)) do
                 resource.run_action(:create)
                 # Windows and Unix have different definitions of exists? here, and that's OK.
                 if windows?

data/spec/functional/resource/mount_spec.rb

@@ -0,0 +1,207 @@
+#
+# Author:: Kaustubh Deorukhkar (<kaustubh@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'
+require 'tmpdir'
+
+# run this test only for following platforms.
+include_flag = !(['ubuntu', 'centos', 'aix'].include?(ohai[:platform]))
+
+describe Chef::Resource::Mount, :requires_root, :external => include_flag do
+
+  include Chef::Mixin::ShellOut
+
+  # Platform specific setup, cleanup and validation helpers.
+
+  def setup_device_for_mount
+    # use ramdisk for creating a test device for mount.
+    # This can cleaner if we have chef resource/provider for ramdisk.
+    case ohai[:platform]
+    when "aix"
+      ramdisk = shell_out!("mkramdisk 16M").stdout
+
+      # identify device, for /dev/rramdisk0 it is /dev/ramdisk0
+      device = ramdisk.tr("\n","").gsub(/\/rramdisk/, '/ramdisk')
+
+      fstype = "jfs2"
+      shell_out!("mkfs  -V #{fstype} #{device}")
+    when "ubuntu", "centos"
+      device = "/dev/ram1"
+      shell_out("ls -1 /dev/ram*").stdout.each_line do |d|
+        if shell_out("mount | grep #{d}").exitstatus == "1"
+          # this device is not mounted, so use it.
+          device = d
+          break
+        end
+      end
+      fstype = "tmpfs"
+      shell_out!("mkfs -q #{device} 512")
+    else
+    end
+    [device, fstype]
+  end
+
+  def cleanup_device(device)
+    case ohai[:platform]
+    when "aix"
+      ramdisk = device.gsub(/\/ramdisk/, '/rramdisk')
+      shell_out("rmramdisk #{ramdisk}")
+    else
+    end
+  end
+
+  def cleanup_mount(mount_point)
+    shell_out("umount #{mount_point}")
+  end
+
+  # platform specific validations.
+  def mount_should_exists(mount_point, device, fstype = nil, options = nil)
+    validation_cmd = "mount | grep #{mount_point} | grep #{device} "
+    validation_cmd << " | grep #{fstype} " unless fstype.nil?
+    validation_cmd << " | grep #{options.join(',')} " unless options.nil? || options.empty?
+    puts "validation_cmd = #{validation_cmd}"
+    expect(shell_out(validation_cmd).exitstatus).to eq(0)
+  end
+
+  def mount_should_not_exists(mount_point)
+    shell_out("mount").stdout.should_not include(mount_point)
+  end
+
+  def unix_mount_config_file
+    case ohai[:platform]
+    when 'aix'
+      mount_config = "/etc/filesystems"
+    else
+      mount_config = "/etc/fstab"
+    end
+  end
+
+  def mount_should_be_enabled(mount_point, device)
+    case ohai[:platform]
+    when 'aix'
+      expect(shell_out("cat #{unix_mount_config_file} | grep \"#{mount_point}:\" ").exitstatus).to eq(0)
+    else
+      expect(shell_out("cat #{unix_mount_config_file} | grep \"#{mount_point}\" | grep \"#{device}\" ").exitstatus).to eq(0)
+    end
+  end
+
+  def mount_should_be_disabled(mount_point)
+    shell_out("cat #{unix_mount_config_file}").stdout.should_not include("#{mount_point}:")
+  end
+
+  let(:new_resource) do
+    new_resource = Chef::Resource::Mount.new(@mount_point, run_context)
+    new_resource.device      @device
+    new_resource.name        @mount_point
+    new_resource.fstype      @fstype
+    new_resource.options     "log=NULL" if ohai[:platform] == 'aix'
+    new_resource
+  end
+
+  let(:provider) do
+    provider = new_resource.provider_for_action(new_resource.action)
+    provider
+  end
+
+  def current_resource
+    provider.load_current_resource
+    provider.current_resource
+  end
+
+  # Actual tests begin here.
+  before(:all) do
+    @device, @fstype = setup_device_for_mount
+
+    @mount_point = Dir.mktmpdir("testmount")
+
+    # Make sure all the potentially leaked mounts are cleared up
+    shell_out("mount").stdout.each_line do |line|
+      if line.include? "testmount"
+        line.split(" ").each do |section|
+          cleanup_mount(section) if section.include? "testmount"
+        end
+      end
+    end
+
+  end
+
+  after(:all) do
+    Dir.rmdir(@mount_point)
+    cleanup_device(@device)
+  end
+
+  after(:each) do
+    cleanup_mount(new_resource.mount_point)
+  end
+
+  describe "when the target state is a mounted filesystem" do
+    it "should mount the filesystem if it isn't mounted" do
+      current_resource.enabled.should be_false
+      current_resource.mounted.should be_false
+      new_resource.run_action(:mount)
+      new_resource.should be_updated
+      mount_should_exists(new_resource.mount_point, new_resource.device)
+    end
+
+  end
+
+  describe "when the filesystem should be remounted and the resource supports remounting" do
+    it "should remount the filesystem if it is mounted" do
+      new_resource.run_action(:mount)
+      mount_should_exists(new_resource.mount_point, new_resource.device)
+
+      new_resource.supports[:remount] = true
+      new_resource.options "rw,log=NULL" if ohai[:platform] == 'aix'
+      new_resource.run_action(:remount)
+
+      mount_should_exists(new_resource.mount_point, new_resource.device, nil, (ohai[:platform] == 'aix') ? new_resource.options : nil)
+    end
+  end
+
+  describe "when the target state is a unmounted filesystem" do
+    it "should umount the filesystem if it is mounted" do
+      new_resource.run_action(:mount)
+      mount_should_exists(new_resource.mount_point, new_resource.device)
+
+      new_resource.run_action(:umount)
+      mount_should_not_exists(new_resource.mount_point)
+    end
+  end
+
+  describe "when enabling the filesystem to be mounted" do
+    after do
+      new_resource.run_action(:disable)
+    end
+
+    it "should enable the mount if it isn't enable" do
+      new_resource.run_action(:mount)
+      new_resource.run_action(:enable)
+      mount_should_be_enabled(new_resource.mount_point, new_resource.device)
+    end
+  end
+
+  describe "when the target state is to disable the mount" do
+    it "should disable the mount if it is enabled" do
+      new_resource.run_action(:mount)
+      new_resource.run_action(:enable)
+      new_resource.run_action(:disable)
+      mount_should_be_disabled(new_resource.mount_point)
+    end
+  end
+end

data/spec/functional/resource/package_spec.rb

@@ -95,15 +95,6 @@ metadata = { :unix_only => true,
 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
@@ -166,11 +157,6 @@ describe Chef::Resource::Package, metadata 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)
@@ -206,7 +192,7 @@ describe Chef::Resource::Package, metadata do
         it "raises a reasonable error for action :install" do
           expect do
             package_resource.run_action(:install)
-          end.to raise_error(Chef::Exceptions::Exec)
+          end.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
         end
 
       end
@@ -216,7 +202,6 @@ describe Chef::Resource::Package, metadata 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")
@@ -224,7 +209,6 @@ describe Chef::Resource::Package, metadata do
 
         after do
           FileUtils.rm_rf(file_cache_path)
-          Chef::Config.configuration = @old_config
         end
 
         context "with a preseed file" do
@@ -267,6 +251,10 @@ describe Chef::Resource::Package, metadata do
 
         context "with a preseed template" do
 
+          # NOTE: in the fixtures, there is also a cookbook_file named
+          # "preseed-template.seed". This implicitly tests that templates are
+          # preferred over cookbook_files when both are present.
+
           let(:package_resource) do
             r = base_resource
             r.cookbook_name = "preseed"
@@ -286,8 +274,98 @@ describe Chef::Resource::Package, metadata do
           end
 
         end
+      end # installing w/ preseed
+    end # when package not installed
 
+    context "and the desired version of the package is installed" do
+
+      before do
+        v_1_1_package = File.expand_path("apt/chef-integration-test_1.1-1_amd64.deb", CHEF_SPEC_DATA)
+        shell_out!("dpkg -i #{v_1_1_package}")
+      end
+
+      it "does nothing for action :install" do
+        package_resource.run_action(:install)
+        shell_out!("dpkg -l chef-integration-test", :returns => [0])
+        package_resource.should_not be_updated_by_last_action
       end
+
+      it "does nothing for action :upgrade" do
+        package_resource.run_action(:upgrade)
+        shell_out!("dpkg -l chef-integration-test", :returns => [0])
+        package_resource.should_not be_updated_by_last_action
+      end
+
+      # Verify that the package is removed by running `dpkg -l PACKAGE`
+      # On Ubuntu 12.10 and newer, the command exits 1.
+      #
+      # On Ubuntu 12.04 and older, the `dpkg -l` command will exit 0 and
+      # display a package status message like this:
+      #
+      # Desired=Unknown/Install/Remove/Purge/Hold
+      # | Status=Not/Inst/Cfg-files/Unpacked/Failed-cfg/Half-inst/trig-aWait/Trig-pend
+      # |/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
+      # ||/ Name                              Version                                   Description
+      # +++-=================================-=========================================-============================================
+      # un  chef-integration-test             <none>                                    (no description available)
+      def pkg_should_be_removed
+        # will raise if exit code != 0,1
+        pkg_check = shell_out!("dpkg -l chef-integration-test", :returns => [0,1])
+
+        if pkg_check.exitstatus == 0
+          pkg_check.stdout.should =~ /un[\s]+chef-integration-test/
+        end
+      end
+
+
+      it "removes the package for action :remove" do
+        package_resource.run_action(:remove)
+        pkg_should_be_removed
+        package_resource.should be_updated_by_last_action
+      end
+
+      it "removes the package for action :purge" do
+        package_resource.run_action(:purge)
+        pkg_should_be_removed
+        package_resource.should be_updated_by_last_action
+      end
+
+    end
+
+    context "and an older version of the package is installed" do
+      before do
+        v_1_0_package = File.expand_path("apt/chef-integration-test_1.0-1_amd64.deb", CHEF_SPEC_DATA)
+        shell_out!("dpkg -i #{v_1_0_package}")
+      end
+
+      it "does nothing for action :install" do
+        package_resource.run_action(:install)
+        shell_out!("dpkg -l chef-integration-test", :returns => [0])
+        package_resource.should_not be_updated_by_last_action
+      end
+
+      it "upgrades the package for action :upgrade" do
+        package_resource.run_action(:upgrade)
+        dpkg_l = shell_out!("dpkg -l chef-integration-test", :returns => [0])
+        dpkg_l.stdout.should =~ /chef\-integration\-test[\s]+1\.1\-1/
+        package_resource.should be_updated_by_last_action
+      end
+
+      context "and the resource specifies the new version" do
+        let(:package_resource) do
+          r = base_resource
+          r.version("1.1-1")
+          r
+        end
+
+        it "upgrades the package for action :install" do
+          package_resource.run_action(:install)
+          dpkg_l = shell_out!("dpkg -l chef-integration-test", :returns => [0])
+          dpkg_l.stdout.should =~ /chef\-integration\-test[\s]+1\.1\-1/
+          package_resource.should be_updated_by_last_action
+        end
+      end
+
     end
 
   end