chef 18.8.11 → 18.8.54

data/spec/unit/resource/directory_spec.rb

@@ -1,69 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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::Directory do
-  let(:resource) { Chef::Resource::Directory.new("fakey_fakerton") }
-
-  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, :delete actions" do
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-  end
-
-  it "accepts a string as the path" do
-    expect { resource.path "/tmp" }.not_to raise_error
-    expect(resource.path).to eql("/tmp")
-    expect { resource.path({}) }.to raise_error(ArgumentError)
-  end
-
-  it "allows you to have specify whether the action is recursive with true/false" do
-    expect { resource.recursive true }.not_to raise_error
-    expect { resource.recursive false }.not_to raise_error
-    expect { resource.recursive "monkey" }.to raise_error(ArgumentError)
-  end
-
-  describe "when it has group, mode, and owner" do
-    before do
-      resource.path("/tmp/foo/bar/")
-      resource.group("wheel")
-      resource.mode("0664")
-      resource.owner("root")
-    end
-
-    it "describes its state" do
-      state = resource.state_for_resource_reporter
-      expect(state[:group]).to eq("wheel")
-      expect(state[:mode]).to eq("0664")
-      expect(state[:owner]).to eq("root")
-    end
-
-    it "returns the directory path as its identity" do
-      expect(resource.identity).to eq("/tmp/foo/bar/")
-    end
-  end
-end

data/spec/unit/resource/dmg_package_spec.rb

@@ -1,39 +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::DmgPackage do
-
-  let(:resource) { Chef::Resource::DmgPackage.new("fakey_fakerton") }
-
-  it "has a resource name of :dmg_package" do
-    expect(resource.resource_name).to eql(:dmg_package)
-  end
-
-  it "the app property is the name_property" do
-    expect(resource.app).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
-  it "supports :install action" do
-    expect { resource.action :install }.not_to raise_error
-  end
-end

data/spec/unit/resource/dnf_package_spec.rb

@@ -1,114 +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"
-require "support/shared/unit/resource/static_provider_resolution"
-
-describe Chef::Resource::DnfPackage, "initialize" do
-
-  static_provider_resolution(
-    resource: Chef::Resource::DnfPackage,
-    provider: Chef::Provider::Package::Dnf,
-    name: :dnf_package,
-    action: :install,
-    os: "linux",
-    platform_family: "rhel"
-  )
-
-end
-
-describe Chef::Resource::DnfPackage, "defaults" do
-  let(:resource) { Chef::Resource::DnfPackage.new("foo") }
-
-  it "sets the arch variable to whatever is passed in" do
-    resource.arch("i386")
-    expect(resource.arch).to eql(["i386"])
-  end
-
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
-  it "supports :flush_cache, :install, :lock, :purge, :reconfig, :remove, :unlock, :upgrade actions" do
-    expect { resource.action :flush_cache }.not_to raise_error
-    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 "accepts a hash for environment variables" do
-    resource.environment({ variables: true })
-    expect(resource.environment).to eql({ variables: true })
-  end
-
-end
-
-describe Chef::Resource::DnfPackage, "flush_cache" do
-  let(:resource) { Chef::Resource::DnfPackage.new("foo") }
-
-  it "defaults the flush timing to false" do
-    flush_hash = { before: false, after: false }
-    expect(resource.flush_cache).to eq(flush_hash)
-  end
-
-  it "allows you to set the flush timing with an array" do
-    flush_array = %i{before after}
-    flush_hash = { before: true, after: true }
-    resource.flush_cache(flush_array)
-    expect(resource.flush_cache).to eq(flush_hash)
-  end
-
-  it "allows you to set the flush timing with a hash" do
-    flush_hash = { before: true, after: true }
-    resource.flush_cache(flush_hash)
-    expect(resource.flush_cache).to eq(flush_hash)
-  end
-
-  it "allows 'true' for flush_cache" do
-    resource.flush_cache(true)
-    expect(resource.flush_cache).to eq({ before: true, after: true })
-  end
-
-  it "allows 'false' for flush_cache" do
-    resource.flush_cache(false)
-    expect(resource.flush_cache).to eq({ before: false, after: false })
-  end
-
-  it "allows ':before' for flush_cache" do
-    resource.flush_cache(:before)
-    expect(resource.flush_cache).to eq({ before: true, after: false })
-  end
-
-  it "allows ':after' for flush_cache" do
-    resource.flush_cache(:after)
-    expect(resource.flush_cache).to eq({ before: false, after: true })
-  end
-end
-
-describe Chef::Resource::DnfPackage, "allow_downgrade" do
-  let(:resource) { Chef::Resource::DnfPackage.new("foo") }
-
-  it "allows you to specify whether allow_downgrade is true or false" do
-    Chef::Config[:treat_deprecation_warnings_as_errors] = false
-    expect { resource.allow_downgrade true }.not_to raise_error
-    expect { resource.allow_downgrade false }.not_to raise_error
-  end
-end

data/spec/unit/resource/dpkg_package_spec.rb

@@ -1,72 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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"
-require "support/shared/unit/resource/static_provider_resolution"
-
-describe Chef::Resource::DpkgPackage, "initialize" do
-
-  static_provider_resolution(
-    resource: Chef::Resource::DpkgPackage,
-    provider: Chef::Provider::Package::Dpkg,
-    name: :dpkg_package,
-    action: :install,
-    os: "linux"
-  )
-
-  describe Chef::Resource::DpkgPackage, "defaults" do
-    let(:resource) { Chef::Resource::DpkgPackage.new("fakey_fakerton") }
-
-    it "sets the default action as :install" do
-      expect(resource.action).to eql([:install])
-    end
-
-    it "accepts a string for the response file" do
-      resource.response_file "something"
-      expect(resource.response_file).to eql("something")
-    end
-
-    it "accepts a hash for response file template variables" do
-      resource.response_file_variables({ variables: true })
-      expect(resource.response_file_variables).to eql({ variables: true })
-    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
-  end
-
-  describe Chef::Resource::DpkgPackage, "allow_downgrade" do
-    before(:each) do
-      @resource = Chef::Resource::DpkgPackage.new("fakey_fakerton")
-    end
-
-    it "should allow you to specify whether allow_downgrade is true or false" do
-      expect { @resource.allow_downgrade true }.not_to raise_error
-      expect { @resource.allow_downgrade false }.not_to raise_error
-      expect { @resource.allow_downgrade "something" }.to raise_error(ArgumentError)
-    end
-  end
-
-end

data/spec/unit/resource/dsc_resource_spec.rb

@@ -1,102 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@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::DscResource do
-  let(:dsc_test_resource_name) { "DSCTest" }
-  let(:dsc_test_resource_module_version) { "2.7.2" }
-  let(:dsc_test_property_name) { :DSCTestProperty }
-  let(:dsc_test_property_value) { "DSCTestValue" }
-  let(:dsc_test_reboot_action) { :reboot_now }
-  let(:dsc_test_timeout) { 101 }
-
-  context "when Powershell supports Dsc" do
-    let(:dsc_test_run_context) do
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = "5.0.10018.0"
-      empty_events = Chef::EventDispatch::Dispatcher.new
-      Chef::RunContext.new(node, {}, empty_events)
-    end
-
-    let(:dsc_test_resource) do
-      Chef::Resource::DscResource.new(dsc_test_resource_name, dsc_test_run_context)
-    end
-
-    it "has a default action of `:run`" do
-      expect(dsc_test_resource.action).to eq([:run])
-    end
-
-    it "has an ed_actions property with only the `:run` and `:nothing` properties" do
-      expect(dsc_test_resource.allowed_actions.to_set).to eq(%i{run nothing}.to_set)
-    end
-
-    it "allows the resource property to be set" do
-      dsc_test_resource.resource(dsc_test_resource_name)
-      expect(dsc_test_resource.resource).to eq(dsc_test_resource_name)
-    end
-
-    it "allows the module_name property to be set" do
-      dsc_test_resource.module_name(dsc_test_resource_name)
-      expect(dsc_test_resource.module_name).to eq(dsc_test_resource_name)
-    end
-
-    it "allows the module_version property to be set" do
-      dsc_test_resource.module_version(dsc_test_resource_module_version)
-      expect(dsc_test_resource.module_version).to eq(dsc_test_resource_module_version)
-    end
-
-    it "allows the reboot_action property to be set" do
-      dsc_test_resource.reboot_action(dsc_test_reboot_action)
-      expect(dsc_test_resource.reboot_action).to eq(dsc_test_reboot_action)
-    end
-
-    it "allows the timeout property to be set" do
-      dsc_test_resource.timeout(dsc_test_timeout)
-      expect(dsc_test_resource.timeout).to eq(dsc_test_timeout)
-    end
-
-    context "when setting a dsc property" do
-      it "allows setting a dsc property with a property name of type Symbol" do
-        dsc_test_resource.property(dsc_test_property_name, dsc_test_property_value)
-        expect(dsc_test_resource.property(dsc_test_property_name)).to eq(dsc_test_property_value)
-        expect(dsc_test_resource.properties[dsc_test_property_name]).to eq(dsc_test_property_value)
-      end
-
-      it "raises a TypeError if property_name is not a symbol" do
-        expect do
-          dsc_test_resource.property("Foo", dsc_test_property_value)
-        end.to raise_error(TypeError)
-      end
-
-      context "when using DelayedEvaluators" do
-        it "allows setting a dsc property with a property name of type Symbol" do
-          dsc_test_resource.property(dsc_test_property_name, Chef::DelayedEvaluator.new do
-            dsc_test_property_value
-          end)
-          expect(dsc_test_resource.property(dsc_test_property_name)).to eq(dsc_test_property_value)
-          expect(dsc_test_resource.properties[dsc_test_property_name]).to eq(dsc_test_property_value)
-        end
-      end
-    end
-
-    context "PowerShell DSL methods" do
-      it "responds to :ps_credential" do
-        expect(dsc_test_resource.respond_to?(:ps_credential)).to be true
-      end
-    end
-  end
-end

data/spec/unit/resource/dsc_script_spec.rb

@@ -1,134 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@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::DscScript do
-  let(:resource_name) { "DSCTest" }
-
-  context "when Powershell supports Dsc" do
-    let(:dsc_test_run_context) do
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = "4.0"
-      empty_events = Chef::EventDispatch::Dispatcher.new
-      Chef::RunContext.new(node, {}, empty_events)
-    end
-    let(:resource) do
-      Chef::Resource::DscScript.new(resource_name, dsc_test_run_context)
-    end
-    let(:configuration_code) { 'echo "This is supposed to create a configuration document."' }
-    let(:configuration_path) { "c:/myconfigs/formatc.ps1" }
-    let(:configuration_name) { "formatme" }
-    let(:configuration_data) { '@{AllNodes = @( @{ NodeName = "localhost"; PSDscAllowPlainTextPassword = $true })}' }
-    let(:configuration_data_script) { "c:/myconfigs/data/safedata.psd1" }
-
-    it "sets the default action as :run" do
-      expect(resource.action).to eql([:run])
-    end
-
-    it "supports :run action" do
-      expect { resource.action :run }.not_to raise_error
-    end
-
-    it "allows the code property to be set" do
-      resource.code(configuration_code)
-      expect(resource.code).to eq(configuration_code)
-    end
-
-    it "allows the command property to be set" do
-      resource.command(configuration_path)
-      expect(resource.command).to eq(configuration_path)
-    end
-
-    it "allows the configuration_name property to be set" do
-      resource.configuration_name(configuration_name)
-      expect(resource.configuration_name).to eq(configuration_name)
-    end
-
-    it "allows the configuration_data property to be set" do
-      resource.configuration_data(configuration_data)
-      expect(resource.configuration_data).to eq(configuration_data)
-    end
-
-    it "allows the configuration_data_script property to be set" do
-      resource.configuration_data_script(configuration_data_script)
-      expect(resource.configuration_data_script).to eq(configuration_data_script)
-    end
-
-    it "has the ps_credential helper method" do
-      expect(resource).to respond_to(:ps_credential)
-    end
-
-    context "when calling imports" do
-      let(:module_name)   { "FooModule" }
-      let(:module_name_b)   { "BarModule" }
-      let(:dsc_resources) { %w{ResourceA ResourceB} }
-
-      it "allows an arbitrary number of resources to be set for a module to be set" do
-        resource.imports module_name, *dsc_resources
-        module_imports = resource.imports[module_name]
-        expect(module_imports).to eq(dsc_resources)
-      end
-
-      it "adds * to the imports when no resources are set for a moudle" do
-        resource.imports module_name
-        module_imports = resource.imports[module_name]
-        expect(module_imports).to eq(["*"])
-      end
-
-      it "allows an arbitrary number of modules" do
-        resource.imports module_name
-        resource.imports module_name_b
-        expect(resource.imports).to have_key(module_name)
-        expect(resource.imports).to have_key(module_name_b)
-      end
-
-      it "allows resources to be added for a module" do
-        resource.imports module_name, dsc_resources[0]
-        resource.imports module_name, dsc_resources[1]
-        module_imports = resource.imports[module_name]
-        expect(module_imports).to eq(dsc_resources)
-      end
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the code property when the command property is already set" do
-      resource.command(configuration_path)
-      expect { resource.code(configuration_code) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the command property when the code property is already set" do
-      resource.code(configuration_code)
-      expect { resource.command(configuration_path) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the configuration_name property when the code property is already set" do
-      resource.code(configuration_code)
-      expect { resource.configuration_name(configuration_name) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the configuration_data property when the configuration_data_script property is already set" do
-      resource.configuration_data_script(configuration_data_script)
-      expect { resource.configuration_data(configuration_data) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the configuration_data_script property when the configuration_data property is already set" do
-      resource.configuration_data(configuration_data)
-      expect { resource.configuration_data_script(configuration_data_script) }.to raise_error(ArgumentError)
-    end
-  end
-end