chef 18.8.11 → 18.8.54

data/spec/functional/resource/locale_spec.rb

@@ -1,108 +0,0 @@
-#
-# Author:: Nimesh Patni (<nimesh.patni@msystechnologies.com>)
-# Copyright:: Copyright (c) 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::Locale, :requires_root do
-  let(:node) do
-    n = Chef::Node.new
-    n.consume_external_attrs(OHAI_SYSTEM.data, {})
-    n
-  end
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::Locale.new("fakey_fakerton", run_context) }
-
-  context "on debian/ubuntu", :debian_family_only do
-    def sets_system_locale(*locales)
-      system_locales = File.readlines("/etc/locale.conf")
-      expect(system_locales.map(&:strip)).to eq(locales)
-    end
-
-    def unsets_system_locale(*locales)
-      system_locales = File.readlines("/etc/locale.conf")
-      expect(system_locales.map(&:strip)).not_to eq(locales)
-    end
-
-    describe "action: update" do
-      context "Sets system variable" do
-        it "when LC var is given" do
-          resource.lc_env({ "LC_MESSAGES" => "en_US" })
-          resource.run_action(:update)
-          sets_system_locale("LC_MESSAGES=en_US")
-        end
-        it "when lang is given" do
-          resource.lang("en_US")
-          resource.run_action(:update)
-          sets_system_locale("LANG=en_US")
-        end
-        it "when both lang & LC vars are given" do
-          resource.lang("en_US")
-          resource.lc_env({ "LC_TIME" => "en_IN" })
-          resource.run_action(:update)
-          sets_system_locale("LANG=en_US", "LC_TIME=en_IN")
-        end
-      end
-
-      context "Unsets system variable" do
-        it "when LC var is not given" do
-          resource.lc_env
-          resource.run_action(:update)
-          unsets_system_locale("LC_MESSAGES=en_US")
-        end
-        it "when lang is not given" do
-          resource.lang
-          resource.run_action(:update)
-          unsets_system_locale("LANG=en_US")
-        end
-        it "when both lang & LC vars are not given" do
-          resource.lang
-          resource.lc_env
-          resource.run_action(:update)
-          expect(resource).not_to be_updated_by_last_action
-        end
-      end
-    end
-  end
-
-  context "on rhel", :rhel do
-    it "raises an exception due lacking the locale-gen tool" do
-      resource.lang("en_US")
-      expect { resource.run_action(:update) }.to raise_error(Chef::Exceptions::ProviderNotFound)
-    end
-  end
-
-  context "on macos", :macos_only do
-    it "raises an exception due to being an unsupported platform" do
-      resource.lang("en_US")
-      expect { resource.run_action(:update) }.to raise_error(Chef::Exceptions::ProviderNotFound)
-    end
-  end
-
-  # @TODO we need to enable these again
-  # context "on windows", :windows_only, requires_root: false do
-  #   describe "action: update" do
-  #     context "Sets system locale" do
-  #       it "when lang is given" do
-  #         resource.lang("en-US")
-  #         resource.run_action(:update)
-  #       end
-  #     end
-  #   end
-  # end
-end

data/spec/functional/resource/macos_userdefaults_spec.rb

@@ -1,139 +0,0 @@
-#
-# Copyright:: Copyright (c) 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::MacosUserDefaults, :macos_only do
-  def create_resource
-    node = Chef::Node.new
-    events = Chef::EventDispatch::Dispatcher.new
-    run_context = Chef::RunContext.new(node, {}, events)
-    resource = Chef::Resource::MacosUserDefaults.new("test", run_context)
-    resource
-  end
-
-  let(:resource) do
-    create_resource
-  end
-
-  context "has a default value" do
-    it ":macos_userdefaults for resource name" do
-      expect(resource.name).to eq("test")
-    end
-
-    it "NSGlobalDomain for the domain property" do
-      expect(resource.domain).to eq("NSGlobalDomain")
-    end
-
-    it ":all for the host property" do
-      expect(resource.host).to eq(:all)
-    end
-
-    it ":current for the user property" do
-      expect(resource.user).to eq(:current)
-    end
-
-    it ":write for resource action" do
-      expect(resource.action).to eq([:write])
-    end
-  end
-
-  it "supports :write, :delete actions" do
-    expect { resource.action :write }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-  end
-
-  context "can process expected data" do
-    it "set array values" do
-      resource.domain "/Library/Preferences/ManagedInstalls"
-      resource.key "TestArrayValues"
-      resource.value [ "/Library/Managed Installs/fake.log", "/Library/Managed Installs/also_fake.log"]
-      resource.run_action(:write)
-      expect(resource.get_preference resource).to eq([ "/Library/Managed Installs/fake.log", "/Library/Managed Installs/also_fake.log"])
-    end
-
-    it "set dictionary value" do
-      resource.domain "/Library/Preferences/ManagedInstalls"
-      resource.key "TestDictionaryValues"
-      resource.value "User": "/Library/Managed Installs/way_fake.log"
-      resource.run_action(:write)
-      expect(resource.get_preference resource).to eq("User" => "/Library/Managed Installs/way_fake.log")
-    end
-
-    it "set array of dictionaries" do
-      resource.domain "/Library/Preferences/ManagedInstalls"
-      resource.key "TestArrayWithDictionary"
-      resource.value [ { "User": "/Library/Managed Installs/way_fake.log" } ]
-      resource.run_action(:write)
-      expect(resource.get_preference resource).to eq([ { "User" => "/Library/Managed Installs/way_fake.log" } ])
-    end
-
-    it "set boolean for preference value" do
-      resource.domain "/Library/Preferences/ManagedInstalls"
-      resource.key "TestBooleanValue"
-      resource.value true
-      resource.run_action(:write)
-      expect(resource.get_preference resource).to eq(true)
-    end
-
-    it "sets value to global domain when domain is not passed" do
-      resource.key "TestKey"
-      resource.value 1
-      resource.run_action(:write)
-      expect(resource.get_preference resource).to eq(1)
-    end
-
-    it "short domain names" do
-      resource.domain "com.apple.dock"
-      resource.key "titlesize"
-      resource.value "20"
-      resource.run_action(:write)
-      expect(resource.get_preference resource).to eq("20")
-    end
-  end
-
-  it "we can delete a preference with full path" do
-    resource.domain "/Library/Preferences/ManagedInstalls"
-    resource.key "TestKey"
-    expect { resource.run_action(:delete) }. to_not raise_error
-  end
-
-  it "we can delete a preference with short name" do
-    resource.domain "com.apple.dock"
-    resource.key "titlesize"
-    expect { resource.run_action(:delete) }. to_not raise_error
-  end
-
-  context "resource can process FFI::Pointer type" do
-    it "for host property" do
-      resource.domain "/Library/Preferences/ManagedInstalls"
-      resource.key "TestDictionaryValues"
-      resource.value "User": "/Library/Managed Installs/way_fake.log"
-      resource.host :current
-      resource.run_action(:write)
-      expect { resource.run_action(:write) }. to_not raise_error
-    end
-
-    it "for user property" do
-      resource.domain "/Library/Preferences/ManagedInstalls"
-      resource.key "TestDictionaryValues"
-      resource.value "User": "/Library/Managed Installs/way_fake.log"
-      resource.user :current
-      resource.run_action(:write)
-      expect { resource.run_action(:write) }. to_not raise_error
-    end
-  end
-end

data/spec/functional/resource/mount_spec.rb

@@ -1,219 +0,0 @@
-#
-# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
-# Copyright:: Copyright (c) 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"
-require "chef/mixin/shell_out"
-require "tmpdir"
-
-# run this test only for following platforms.
-include_flag = !(%w{debian rhel amazon aix solaris2}.include?(ohai[:platform_family]))
-
-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_family]
-    when "aix"
-      # On AIX, we can't create a ramdisk inside a WPAR, so we use
-      # a "namefs" mount against / to test
-      # https://www-304.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.performance/namefs_file_sys.htm
-      device = "/"
-      fstype = "namefs"
-    when "debian", "rhel", "amazon"
-      device = "/dev/ram1"
-      unless File.exist?(device)
-        shell_out("mknod -m 660 #{device} b 1 0")
-        shell_out("chown root:disk #{device}")
-      end
-      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")
-    when "solaris2"
-      device = "swap"
-      fstype = "tmpfs"
-    else
-    end
-    [device, fstype]
-  end
-
-  def cleanup_mount(mount_point)
-    shell_out("umount #{mount_point}")
-  end
-
-  # platform specific validations.
-  def mount_should_exist(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?
-    expect(shell_out(validation_cmd).exitstatus).to eq(0)
-  end
-
-  def mount_should_not_exists(mount_point)
-    expect(shell_out("mount").stdout).not_to include(mount_point)
-  end
-
-  def unix_mount_config_file
-    case ohai[:platform]
-    when "aix"
-      mount_config = "/etc/filesystems"
-    when "solaris2"
-      mount_config = "/etc/vfstab"
-    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)
-    expect(shell_out("cat #{unix_mount_config_file}").stdout).not_to include("#{mount_point}:")
-  end
-
-  let(:run_context) do
-    node = Chef::Node.new
-    node.default[:platform] = ohai[:platform]
-    node.default[:platform_version] = ohai[:platform_version]
-    node.default[:os] = ohai[:os]
-    events = Chef::EventDispatch::Dispatcher.new
-    Chef::RunContext.new(node, {}, events)
-  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
-
-  let(:current_resource) do
-    provider.load_current_resource
-    provider.current_resource
-  end
-
-  # Actual tests begin here.
-  before do |test|
-    @device, @fstype = setup_device_for_mount
-    @device = "/" if test.metadata[:skip_before]
-
-    @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) if @mount_point
-  end
-
-  after(:each) do
-    cleanup_mount(new_resource.mount_point)
-  end
-
-  describe "when device is '/'" do
-    it "should mount the filesystem if device is '/'", :skip_before do
-      new_resource.run_action(:mount)
-      mount_should_exist(new_resource.mount_point, new_resource.device)
-    end
-  end
-
-  describe "when the target state is a mounted filesystem" do
-    it "should mount the filesystem if it isn't mounted" do
-      expect(current_resource.enabled).to be_falsey
-      expect(current_resource.mounted).to be_falsey
-      new_resource.run_action(:mount)
-      expect(new_resource).to be_updated
-      mount_should_exist(new_resource.mount_point, new_resource.device)
-    end
-  end
-
-  # don't run the remount tests on solaris2 (tmpfs does not support remount)
-  # Need to make sure the platforms we've already excluded are considered:
-  skip_remount = include_flag || (ohai[:platform] == "solaris2")
-  describe "when the filesystem should be remounted and the resource supports remounting", external: skip_remount do
-    it "should remount the filesystem if it is mounted" do
-      new_resource.run_action(:mount)
-      mount_should_exist(new_resource.mount_point, new_resource.device)
-
-      new_resource.supports[:remount] = true
-      new_resource.options "rw" if ohai[:platform] == "aix"
-      new_resource.run_action(:remount)
-
-      mount_should_exist(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_exist(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/msu_package_spec.rb

@@ -1,107 +0,0 @@
-#
-# Author:: Nimisha Sharad (<nimisha.sharad@msystechnologies.com>)
-# Copyright:: Copyright (c) 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"
-require "chef/provider/package/cab"
-
-describe Chef::Resource::MsuPackage, :win2012r2_only do
-
-  let(:package_name) { "Package_for_KB2959977" }
-  let(:package_source) { "https://download.microsoft.com/download/3/B/3/3B320C07-B7B1-41E5-81F4-79EBC02DF7D3/Windows8.1-KB2959977-x64.msu" }
-  let(:package_identity) { "Package_for_KB2959977~31bf3856ad364e35~amd64~~6.3.1.1" }
-  let(:timeout) { 3600 }
-
-  let(:run_context) do
-    node = Chef::Node.new
-    node.default[:platform] = ohai[:platform]
-    node.default[:platform_version] = ohai[:platform_version]
-    node.default[:os] = ohai[:os]
-    events = Chef::EventDispatch::Dispatcher.new
-    Chef::RunContext.new(node, {}, events)
-  end
-
-  let(:new_resource) { Chef::Resource::CabPackage.new("windows_test_pkg") }
-  let(:cab_provider) do
-    Chef::Provider::Package::Cab.new(new_resource, run_context)
-  end
-
-  subject do
-    new_resource = Chef::Resource::MsuPackage.new("test msu package", run_context)
-    new_resource.package_name package_name
-    new_resource.source package_source
-    new_resource.timeout timeout
-    new_resource
-  end
-
-  context "installing package" do
-    after { remove_package }
-
-    it "installs the package successfully" do
-      subject.run_action(:install)
-      found_packages = cab_provider.installed_packages.select { |p| p["package_identity"] == package_identity }
-      expect(found_packages.length).to be == 1
-    end
-  end
-
-  context "removing a package" do
-    it "removes an installed package" do
-      subject.run_action(:install)
-      remove_package
-      found_packages = cab_provider.installed_packages.select { |p| p["package_identity"] == package_identity }
-      expect(found_packages.length).to be == 0
-    end
-  end
-
-  context "when an invalid msu package is given" do
-    def package_name
-      "Package_for_KB2859903"
-    end
-
-    def package_source
-      "https://download.microsoft.com/download/5/2/B/52BE95BF-22D8-4415-B644-0FDF398F6D96/IE10-Windows6.1-KB2859903-x86.msu"
-    end
-
-    it "raises error while installing" do
-      expect { subject.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
-    end
-
-    it "raises error while removing" do
-      expect { subject.run_action(:remove) }.to raise_error(Chef::Exceptions::Package)
-    end
-  end
-
-  context "when an msu package is not applicable to the image." do
-    def package_name
-      "Package_for_KB4019990"
-    end
-
-    def package_source
-      "http://download.windowsupdate.com/c/msdownload/update/software/updt/2017/05/windows8-rt-kb4019990-x64_a77f4e3e1f2d47205824763e7121bb11979c2716.msu"
-    end
-
-    it "raises error while installing" do
-      expect { subject.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /The specified package is not applicable to this image./)
-    end
-  end
-
-  def remove_package
-    pkg_to_remove = Chef::Resource::MsuPackage.new(package_name, run_context)
-    pkg_to_remove.source = package_source
-    pkg_to_remove.run_action(:remove)
-  end
-end

data/spec/functional/resource/ohai_spec.rb

@@ -1,54 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@chef.io>)
-# Copyright:: Copyright (c) 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::Ohai do
-  let(:node) { Chef::Node.new }
-
-  let(:run_context) do
-    node.default[:platform] = ohai[:platform]
-    node.default[:platform_version] = ohai[:platform_version]
-    events = Chef::EventDispatch::Dispatcher.new
-    Chef::RunContext.new(node, {}, events)
-  end
-
-  shared_examples_for "reloaded :uptime" do
-    it "should reload :uptime" do
-      expect(node[:uptime_seconds]).to be nil
-      ohai_resource.run_action(:reload)
-      expect(Integer(node[:uptime_seconds])).to be_an(Integer)
-    end
-  end
-
-  describe "when reloading all plugins" do
-    let(:ohai_resource) { Chef::Resource::Ohai.new("reload all", run_context) }
-
-    it_behaves_like "reloaded :uptime"
-  end
-
-  describe "when reloading only uptime" do
-    let(:ohai_resource) do
-      r = Chef::Resource::Ohai.new("reload all", run_context)
-      r.plugin("uptime")
-      r
-    end
-
-    it_behaves_like "reloaded :uptime"
-  end
-end

data/spec/functional/resource/plist_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-require "plist"
-
-describe Chef::Resource::PlistResource, :macos_only, requires_root: true do
-  include RecipeDSLHelper
-
-  let(:global_prefs) do
-    File.join(Dir.mktmpdir, ".GlobalPreferences.plist")
-  end
-
-  before(:each) do
-    FileUtils.rm_f global_prefs
-  end
-
-  context "make Monday the first DOW" do
-    it "creates a new plist with a hash value" do
-      plist global_prefs do
-        entry "AppleFirstWeekday"
-        value(gregorian: 4)
-      end
-      expect(File.exist?(global_prefs))
-      expect(shell_out!("/usr/libexec/PlistBuddy -c 'Print :\"AppleFirstWeekday\":gregorian' \"#{global_prefs}\"").stdout.to_i).to eq(4)
-    end
-  end
-end