chef 18.8.11 → 18.8.54

data/spec/unit/resource/mount_spec.rb

@@ -1,201 +0,0 @@
-#
-# Author:: Joshua Timberman (<joshua@chef.io>)
-# Author:: Tyler Cloke (<tyler@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::Mount do
-  let(:resource) { Chef::Resource::Mount.new("fakey_fakerton") }
-
-  it "the mount_point property is the name_property" do
-    expect(resource.mount_point).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :mount" do
-    expect(resource.action).to eql([:mount])
-  end
-
-  it "supports :disable, :enable, :mount, :remount, :umount, :unmount actions" do
-    expect { resource.action :disable }.not_to raise_error
-    expect { resource.action :enable }.not_to raise_error
-    expect { resource.action :mount }.not_to raise_error
-    expect { resource.action :remount }.not_to raise_error
-    expect { resource.action :umount }.not_to raise_error
-    expect { resource.action :unmount }.not_to raise_error
-  end
-
-  it "allows you to set the device property" do
-    resource.device "/dev/sdb3"
-    expect(resource.device).to eql("/dev/sdb3")
-  end
-
-  it "allows you to set mount_point property" do
-    resource.mount_point "U:"
-    expect(resource.mount_point).to eql("U:")
-  end
-
-  it "splits strings passed to the mount_point property" do
-    resource.mount_point "U:"
-    expect(resource.mount_point).to eql("U:")
-  end
-
-  it "strips trailing slashes from mount_point values" do
-    resource.mount_point "//192.168.11.102/Share/backup/"
-    expect(resource.mount_point).to eql("//192.168.11.102/Share/backup")
-  end
-
-  it "does not strip slash when mount_point is root directory" do
-    resource.mount_point "/"
-    expect(resource.mount_point).to eql("/")
-  end
-
-  it "does not strip slash when mount_point is root of network mount" do
-    resource.mount_point "127.0.0.1:/"
-    expect(resource.mount_point).to eql("127.0.0.1:/")
-  end
-
-  it "raises error when mount_point property is not set" do
-    expect { resource.mount_point nil }.to raise_error(Chef::Exceptions::ValidationFailed, "Property mount_point must be one of: String!  You passed nil.")
-  end
-
-  it "sets fsck_device to '-' by default" do
-    expect(resource.fsck_device).to eql("-")
-  end
-
-  it "allows you to set the fsck_device property" do
-    resource.fsck_device "/dev/rdsk/sdb3"
-    expect(resource.fsck_device).to eql("/dev/rdsk/sdb3")
-  end
-
-  it "allows you to set the fstype property" do
-    resource.fstype "nfs"
-    expect(resource.fstype).to eql("nfs")
-  end
-
-  it "sets fstype to 'auto' by default" do
-    expect(resource.fstype).to eql("auto")
-  end
-
-  it "allows you to set the dump property" do
-    resource.dump 1
-    expect(resource.dump).to eql(1)
-  end
-
-  it "allows you to set the pass property" do
-    resource.pass 1
-    expect(resource.pass).to eql(1)
-  end
-
-  it "sets the options property to defaults" do
-    expect(resource.options).to eql(["defaults"])
-  end
-
-  it "allows options to be sent as a string, and convert to array" do
-    resource.options "rw,noexec"
-    expect(resource.options).to eql(%w{rw noexec})
-  end
-
-  it "strips whitespace around options in a comma deliminated string" do
-    resource.options "rw, noexec"
-    expect(resource.options).to eql(%w{rw noexec})
-  end
-
-  it "allows options property as an array" do
-    resource.options %w{ro nosuid}
-    expect(resource.options).to eql(%w{ro nosuid})
-  end
-
-  it "allows options to be sent as a delayed evaluator" do
-    resource.options Chef::DelayedEvaluator.new { %w{rw noexec} }
-    expect(resource.options).to eql(%w{rw noexec})
-  end
-
-  it "allows options to be sent as a delayed evaluator, and convert to array" do
-    resource.options Chef::DelayedEvaluator.new { "rw,noexec" }
-    expect(resource.options).to eql(%w{rw noexec})
-  end
-
-  it "accepts true for mounted" do
-    resource.mounted(true)
-    expect(resource.mounted).to eql(true)
-  end
-
-  it "accepts false for mounted" do
-    resource.mounted(false)
-    expect(resource.mounted).to eql(false)
-  end
-
-  it "sets mounted to false by default" do
-    expect(resource.mounted).to eql(false)
-  end
-
-  it "does not accept a string for mounted" do
-    expect { resource.mounted("poop") }.to raise_error(ArgumentError)
-  end
-
-  it "accepts true for enabled" do
-    resource.enabled(true)
-    expect(resource.enabled).to eql(true)
-  end
-
-  it "accepts false for enabled" do
-    resource.enabled(false)
-    expect(resource.enabled).to eql(false)
-  end
-
-  it "sets enabled to false by default" do
-    expect(resource.enabled).to eql(false)
-  end
-
-  it "does not accept a string for enabled" do
-    expect { resource.enabled("poop") }.to raise_error(ArgumentError)
-  end
-
-  it "defaults all feature support to false" do
-    support_hash = { remount: false }
-    expect(resource.supports).to eq(support_hash)
-  end
-
-  it "allows you to set feature support as an array" do
-    support_array = [ :remount ]
-    support_hash = { remount: true }
-    resource.supports(support_array)
-    expect(resource.supports).to eq(support_hash)
-  end
-
-  it "allows you to set feature support as a hash" do
-    support_hash = { remount: true }
-    resource.supports(support_hash)
-    expect(resource.supports).to eq(support_hash)
-  end
-
-  it "allows you to set username" do
-    resource.username("Administrator")
-    expect(resource.username).to eq("Administrator")
-  end
-
-  it "allows you to set password" do
-    resource.password("Jetstream123!")
-    expect(resource.password).to eq("Jetstream123!")
-  end
-
-  it "allows you to set domain" do
-    resource.domain("TEST_DOMAIN")
-    expect(resource.domain).to eq("TEST_DOMAIN")
-  end
-end

data/spec/unit/resource/msu_package_spec.rb

@@ -1,67 +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"
-
-describe Chef::Resource::MsuPackage do
-  let(:resource) { Chef::Resource::MsuPackage.new("test_pkg") }
-
-  it "is a subclass of Chef::Resource::Package" do
-    expect(resource).to be_a_kind_of(Chef::Resource::Package)
-  end
-
-  it "sets resource name as :msu_package" do
-    expect(resource.resource_name).to eql(:msu_package)
-  end
-
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
-  it "supports :install, :lock, :purge, :reconfig, :remove, :unlock, :upgrade actions" do
-    expect { resource.action :install }.not_to raise_error
-    expect { resource.action :lock }.not_to raise_error
-    expect { resource.action :purge }.not_to raise_error
-    expect { resource.action :reconfig }.not_to raise_error
-    expect { resource.action :remove }.not_to raise_error
-    expect { resource.action :unlock }.not_to raise_error
-    expect { resource.action :upgrade }.not_to raise_error
-  end
-
-  it "coerces name property to package_name property" do
-    expect(resource.package_name).to eql("test_pkg")
-  end
-
-  it "coerces name property to a source property if source not provided" do
-    expect(resource.source).to end_with("test_pkg")
-  end
-
-  it "coerces name property to a source property if source not provided and package_name is" do
-    resource.package_name("package.msu")
-    expect(resource.source).to end_with("package.msu")
-  end
-
-  it "coerces source property if it does not looks like a path" do
-    resource.source("package.msu")
-    expect(resource.source).not_to eq("package.msu")
-  end
-
-  it "sets timeout property to 3600 by default" do
-    expect(resource.timeout).to eql(3600)
-  end
-end

data/spec/unit/resource/notify_group_spec.rb

@@ -1,34 +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::NotifyGroup do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::NotifyGroup.new("whatever", run_context) }
-
-  it "sets the default action as :run" do
-    expect(resource.action).to eql([:nothing])
-  end
-
-  it "is always updated" do
-    resource.run_action(:run)
-    expect(resource.updated_by_last_action?).to be true
-  end
-end

data/spec/unit/resource/ohai_hint_spec.rb

@@ -1,44 +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::OhaiHint do
-
-  let(:resource) { Chef::Resource::OhaiHint.new("fakey_fakerton") }
-
-  it "has a resource name of :ohai_hint" do
-    expect(resource.resource_name).to eql(:ohai_hint)
-  end
-
-  it "the hint_name property is the name_property" do
-    expect(resource.hint_name).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "supports :create, :delete actions" do
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-  end
-
-  it "runs at compile_time by default" do
-    expect(resource.compile_time).to eql(true)
-  end
-end

data/spec/unit/resource/ohai_spec.rb

@@ -1,185 +0,0 @@
-#
-# Author:: Michael Leinartas (<mleinartas@gmail.com>)
-# Copyright:: Copyright 2010-2016, Michael Leinartas
-# 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(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::Ohai.new("fakey_fakerton", run_context) }
-  let(:provider) { resource.provider_for_action(:reload) }
-
-  it "has a resource name of :ohai" do
-    expect(resource.resource_name).to eql(:ohai)
-  end
-
-  it "sets the default action as :reload" do
-    expect(resource.action).to eql([:reload])
-  end
-
-  it "supports :reload action" do
-    expect { resource.action :reload }.not_to raise_error
-  end
-
-  it "allows you to set the plugin property" do
-    resource.plugin "passwd"
-    expect(resource.plugin).to eql("passwd")
-  end
-
-  describe "when it has a plugin value" do
-    before do
-      resource.name("test")
-      resource.plugin("passwd")
-    end
-
-    it "describes its state" do
-      state = resource.state_for_resource_reporter
-      expect(state[:plugin]).to eq("passwd")
-    end
-
-    it "returns the name as its identity" do
-      expect(resource.identity).to eq("test")
-    end
-  end
-
-  describe "reload action" do
-    before(:each) do
-      # Copied from client_spec
-      @fqdn = "hostname.domainname"
-      @hostname = "hostname"
-      @platform = "example-platform"
-      @platform_version = "example-platform"
-      Chef::Config[:node_name] = @fqdn
-      mock_ohai = {
-        fqdn: @fqdn,
-        hostname: @hostname,
-        platform: @platform,
-        platform_version: @platform_version,
-        data: {
-          origdata: "somevalue",
-        },
-        data2: {
-          origdata: "somevalue",
-          newdata: "somevalue",
-        },
-      }
-      allow(mock_ohai).to receive(:all_plugins).and_return(true)
-      allow(mock_ohai).to receive(:data).and_return(mock_ohai[:data],
-        mock_ohai[:data2])
-      allow(Ohai::System).to receive(:new).and_return(mock_ohai)
-      allow(Chef::Platform).to receive(:find_platform_and_version).and_return({ "platform" => @platform,
-                                                                                "platform_version" => @platform_version })
-      # Fake node with a dummy save
-      node.name(@fqdn)
-      allow(node).to receive(:save).and_return(node)
-      ohai = Ohai::System.new
-      ohai.all_plugins
-      node.consume_external_attrs(ohai.data, {})
-      node.automatic_attrs[:origdata] = "somevalue"
-    end
-
-    it "applies updated ohai data to the node" do
-      expect(node[:origdata]).to eq("somevalue")
-      expect(node[:newdata]).to be_nil
-      provider.run_action(:reload)
-      expect(node[:origdata]).to eq("somevalue")
-      expect(node[:newdata]).to eq("somevalue")
-    end
-
-    it "supports reloading a specific plugin and causes node to pick up new values" do
-      resource.plugin "someplugin"
-      provider.run_action(:reload)
-      expect(node[:origdata]).to eq("somevalue")
-      expect(node[:newdata]).to eq("somevalue")
-    end
-
-    it "loads cookbook plugins when the ohai_segment_plugin_path directory exists and has content" do
-      # Setup mock plugin path
-      plugin_path = "/tmp/chef/ohai/cookbook_plugins"
-      Chef::Config[:ohai_segment_plugin_path] = plugin_path
-
-      # Mock that the directory exists and has content
-      allow(Dir).to receive(:exist?).with(plugin_path).and_return(true)
-      allow(Dir).to receive(:empty?).with(plugin_path).and_return(false)
-
-      # Mock the ohai system
-      ohai_mock = double("Ohai::System")
-      config_mock = double("config")
-      plugin_path_array = []
-
-      allow(ohai_mock).to receive(:config).and_return(config_mock)
-      allow(config_mock).to receive(:[]).with(:plugin_path).and_return(plugin_path_array)
-      allow(ohai_mock).to receive(:all_plugins).with(nil)
-      allow(ohai_mock).to receive(:data).and_return({})
-      allow(Ohai::System).to receive(:new).and_return(ohai_mock)
-
-      provider.run_action(:reload)
-
-      # Verify that the plugin path was added to the ohai config
-      expect(plugin_path_array).to include(plugin_path)
-    end
-
-    it "does not attempt to load cookbook plugins when the ohai_segment_plugin_path directory does not exist" do
-      # Setup mock plugin path that doesn't exist
-      plugin_path = "/tmp/chef/ohai/cookbook_plugins"
-      Chef::Config[:ohai_segment_plugin_path] = plugin_path
-
-      # Mock that the directory doesn't exist
-      allow(Dir).to receive(:exist?).with(plugin_path).and_return(false)
-
-      # Mock the ohai system
-      ohai_mock = double("Ohai::System")
-      config_mock = spy("config")
-
-      allow(ohai_mock).to receive(:config).and_return(config_mock)
-      allow(ohai_mock).to receive(:all_plugins).with(nil)
-      allow(ohai_mock).to receive(:data).and_return({})
-      allow(Ohai::System).to receive(:new).and_return(ohai_mock)
-
-      provider.run_action(:reload)
-
-      # Verify that the plugin path configuration was not accessed since directory doesn't exist
-      expect(config_mock).not_to have_received(:[]).with(:additional_plugin_path)
-    end
-
-    it "does not attempt to load cookbook plugins when the ohai_segment_plugin_path directory is empty" do
-      # Setup mock plugin path that exists but is empty
-      plugin_path = "/tmp/chef/ohai/cookbook_plugins"
-      Chef::Config[:ohai_segment_plugin_path] = plugin_path
-
-      # Mock that the directory exists but is empty
-      allow(Dir).to receive(:exist?).with(plugin_path).and_return(true)
-      allow(Dir).to receive(:empty?).with(plugin_path).and_return(true)
-
-      # Mock the ohai system
-      ohai_mock = double("Ohai::System")
-      config_mock = spy("config")
-
-      allow(ohai_mock).to receive(:config).and_return(config_mock)
-      allow(ohai_mock).to receive(:all_plugins).with(nil)
-      allow(ohai_mock).to receive(:data).and_return({})
-      allow(Ohai::System).to receive(:new).and_return(ohai_mock)
-
-      provider.run_action(:reload)
-
-      # Verify that the plugin path configuration was not accessed since directory is empty
-      expect(config_mock).not_to have_received(:[]).with(:additional_plugin_path)
-    end
-  end
-end

data/spec/unit/resource/openbsd_package_spec.rb

@@ -1,58 +0,0 @@
-#
-# Authors:: AJ Christensen (<aj@chef.io>)
-#           Richard Manyanza (<liseki@nyikacraftsmen.com>)
-#           Scott Bonds (<scott@ggr.com>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# Copyright:: Copyright 2014-2016, Richard Manyanza, Scott Bonds
-# 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::OpenbsdPackage do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::OpenbsdPackage.new("foo", run_context) }
-
-  describe "Initialization" do
-    it "is a subclass of Chef::Resource::Package" do
-      expect(resource).to be_a_kind_of(Chef::Resource::Package)
-    end
-
-    it "sets the resource_name to :openbsd_package" do
-      expect(resource.resource_name).to eql(:openbsd_package)
-    end
-
-    it "sets the default action as :install" do
-      expect(resource.action).to eql([:install])
-    end
-
-    it "supports :install, :lock, :purge, :reconfig, :remove, :unlock, :upgrade actions" do
-      expect { resource.action :install }.not_to raise_error
-      expect { resource.action :lock }.not_to raise_error
-      expect { resource.action :purge }.not_to raise_error
-      expect { resource.action :reconfig }.not_to raise_error
-      expect { resource.action :remove }.not_to raise_error
-      expect { resource.action :unlock }.not_to raise_error
-      expect { resource.action :upgrade }.not_to raise_error
-    end
-
-    it "does not set the provider" do
-      expect(resource.provider).to be_nil
-    end
-  end
-
-end

data/spec/unit/resource/openssl_dhparam_spec.rb

@@ -1,61 +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::OpensslDhparam do
-
-  let(:resource) { Chef::Resource::OpensslDhparam.new("fakey_fakerton") }
-
-  it "has a resource name of :openssl_dhparam" do
-    expect(resource.resource_name).to eql(:openssl_dhparam)
-  end
-
-  it "the path property is the name_property" do
-    expect(resource.path).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "supports :create action" do
-    expect { resource.action :create }.not_to raise_error
-  end
-
-  it "has a default mode of '0640'" do
-    expect(resource.mode).to eql("0640")
-  end
-
-  it "has a default generator of 2" do
-    expect(resource.generator).to eql(2)
-  end
-
-  it "has a default key_length of 2048" do
-    expect(resource.key_length).to eql(2048)
-  end
-
-  it "only accepts valid key length" do
-    expect { resource.key_length 1234 }.to raise_error(ArgumentError)
-  end
-
-  it "sets the mode which user provides for existing file" do
-    resource.mode "0600"
-    expect(resource.mode).to eql("0600")
-  end
-
-end