chef 18.7.10 → 18.8.46

data/spec/unit/resource/yum_package_spec.rb

@@ -1,150 +0,0 @@
-#
-# Author:: AJ Christensen (<aj@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::YumPackage, "initialize" do
-
-  static_provider_resolution(
-    resource: Chef::Resource::YumPackage,
-    provider: Chef::Provider::Package::Yum,
-    name: :yum_package,
-    action: :install,
-    os: "linux",
-    platform_family: "rhel"
-  )
-
-end
-
-describe Chef::Resource::YumPackage do
-  before(:each) do
-    @resource = Chef::Resource::YumPackage.new("foo")
-  end
-
-  # this set of tests is somewhat terrible.  the yum provider promiscuously writes over
-  # the new_resource.package_named/version/arch properties.  until that is fixed properly
-  # we need to coerce and dup those properties into normal arrays.  this does not affect
-  # strings because those are not mutated in place and they are not (currently) frozen
-  # in immutable properties (even though they really, really should be).
-  context "when passed immutable node property arrays" do
-    let(:node) { Chef::Node.new }
-
-    before do
-      node.default["foo"] = %w{one two three}
-    end
-
-    it "allows mutation of the package_name array" do
-      @resource.package_name node["foo"]
-      expect(@resource.package_name).not_to be_a_kind_of(Chef::Node::ImmutableArray)
-      expect { @resource.package_name[0] = "four" }.not_to raise_error
-      expect(@resource.package_name).to eql(%w{four two three})
-    end
-
-    it "allows mutation of the version array" do
-      @resource.version node["foo"]
-      expect(@resource.version).not_to be_a_kind_of(Chef::Node::ImmutableArray)
-      expect { @resource.version[0] = "four" }.not_to raise_error
-      expect(@resource.version).to eql(%w{four two three})
-    end
-
-    it "allows mutation of the arch array" do
-      @resource.arch node["foo"]
-      expect(@resource.arch).not_to be_a_kind_of(Chef::Node::ImmutableArray)
-      expect { @resource.arch[0] = "four" }.not_to raise_error
-      expect(@resource.arch).to eql(%w{four two three})
-    end
-
-  end
-end
-
-describe Chef::Resource::YumPackage, "arch" do
-  before(:each) do
-    @resource = Chef::Resource::YumPackage.new("foo")
-  end
-
-  it "sets the arch variable to whatever is passed in" do
-    @resource.arch("i386")
-    expect(@resource.arch).to eql("i386")
-  end
-end
-
-describe Chef::Resource::YumPackage, "flush_cache" do
-  before(:each) do
-    @resource = Chef::Resource::YumPackage.new("foo")
-  end
-
-  it "should default the flush timing to false" do
-    flush_hash = { before: false, after: false }
-    expect(@resource.flush_cache).to eq(flush_hash)
-  end
-
-  it "should allow 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 "should allow 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 "should allow 'true' for flush_cache" do
-    @resource.flush_cache(true)
-    expect(@resource.flush_cache).to eq({ before: true, after: true })
-  end
-
-  it "should allow 'false' for flush_cache" do
-    @resource.flush_cache(false)
-    expect(@resource.flush_cache).to eq({ before: false, after: false })
-  end
-
-  it "should allow ':before' for flush_cache" do
-    @resource.flush_cache(:before)
-    expect(@resource.flush_cache).to eq({ before: true, after: false })
-  end
-
-  it "should allow ':after' for flush_cache" do
-    @resource.flush_cache(:after)
-    expect(@resource.flush_cache).to eq({ before: false, after: true })
-  end
-end
-
-describe Chef::Resource::YumPackage, "allow_downgrade" do
-  before(:each) do
-    @resource = Chef::Resource::YumPackage.new("foo")
-  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 "monkey" }.to raise_error(ArgumentError)
-  end
-end
-
-describe Chef::Resource::YumPackage, "yum_binary" do
-  let(:resource) { Chef::Resource::YumPackage.new("foo") }
-
-  it "should allow you to specify the yum_binary" do
-    resource.yum_binary "/usr/bin/yum-something"
-    expect(resource.yum_binary).to eql("/usr/bin/yum-something")
-  end
-end

data/spec/unit/resource/yum_repository_spec.rb

@@ -1,156 +0,0 @@
-#
-# Author:: Thom May (<thom@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::YumRepository do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::YumRepository.new("fakey_fakerton", run_context) }
-
-  it "has a resource_name of :yum_repository" do
-    expect(resource.resource_name).to eq(:yum_repository)
-  end
-
-  it "the repositoryid property is the name_property" do
-    expect(resource.repositoryid).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "supports :add, :create, :delete, :makecache, :remove actions" do
-    expect { resource.action :add }.not_to raise_error
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-    expect { resource.action :makecache }.not_to raise_error
-    expect { resource.action :remove }.not_to raise_error
-  end
-
-  it "fails if the user provides a repositoryid with a forward slash" do
-    expect { resource.repositoryid "foo/bar" }.to raise_error(ArgumentError)
-  end
-
-  it "clean_headers property defaults to false" do
-    expect(resource.clean_headers).to eql(false)
-  end
-
-  it "clean_metadata property defaults to true" do
-    expect(resource.clean_metadata).to eql(true)
-  end
-
-  it "description property defaults to 'Yum Repository'" do
-    expect(resource.description).to eql("Yum Repository")
-  end
-
-  it "enabled property defaults to true" do
-    expect(resource.enabled).to eql(true)
-  end
-
-  it "make_cache property defaults to true" do
-    expect(resource.make_cache).to eql(true)
-  end
-
-  it "makecache_fast property defaults to false" do
-    expect(resource.makecache_fast).to eql(false)
-  end
-
-  it "mode property defaults to '0644'" do
-    expect(resource.mode).to eql("0644")
-  end
-
-  it "the timeout property expects numeric Strings" do
-    expect { resource.timeout "123" }.not_to raise_error
-    expect { resource.timeout "123foo" }.to raise_error(ArgumentError)
-  end
-
-  it "the priority property expects numeric Strings from '1' to '99'" do
-    expect { resource.priority "99" }.not_to raise_error
-    expect { resource.priority "1" }.not_to raise_error
-    expect { resource.priority "100" }.to raise_error(ArgumentError)
-    expect { resource.priority "0" }.to raise_error(ArgumentError)
-  end
-
-  it "the failovermethod property accepts 'priority' or 'roundrobin'" do
-    expect { resource.failovermethod "priority" }.not_to raise_error
-    expect { resource.failovermethod "roundrobin" }.not_to raise_error
-    expect { resource.failovermethod "bob" }.to raise_error(ArgumentError)
-  end
-
-  it "the http_caching property accepts 'packages', 'all', or 'none'" do
-    expect { resource.http_caching "packages" }.not_to raise_error
-    expect { resource.http_caching "all" }.not_to raise_error
-    expect { resource.http_caching "none" }.not_to raise_error
-    expect { resource.http_caching "bob" }.to raise_error(ArgumentError)
-  end
-
-  it "the metadata_expire property accepts a time value or 'never'" do
-    expect { resource.metadata_expire "100" }.not_to raise_error
-    expect { resource.metadata_expire "100d" }.not_to raise_error
-    expect { resource.metadata_expire "100h" }.not_to raise_error
-    expect { resource.metadata_expire "100m" }.not_to raise_error
-    expect { resource.metadata_expire "never" }.not_to raise_error
-    expect { resource.metadata_expire "100s" }.to raise_error(ArgumentError)
-  end
-
-  it "the mirror_expire property accepts a time value" do
-    expect { resource.mirror_expire "100" }.not_to raise_error
-    expect { resource.mirror_expire "100d" }.not_to raise_error
-    expect { resource.mirror_expire "100h" }.not_to raise_error
-    expect { resource.mirror_expire "100m" }.not_to raise_error
-    expect { resource.mirror_expire "never" }.to raise_error(ArgumentError)
-  end
-
-  it "the mirrorlist_expire property accepts a time value" do
-    expect { resource.mirrorlist_expire "100" }.not_to raise_error
-    expect { resource.mirrorlist_expire "100d" }.not_to raise_error
-    expect { resource.mirrorlist_expire "100h" }.not_to raise_error
-    expect { resource.mirrorlist_expire "100m" }.not_to raise_error
-    expect { resource.mirrorlist_expire "never" }.to raise_error(ArgumentError)
-  end
-
-  it "accepts the legacy 'url' property" do
-    resource.url "foo"
-    expect(resource.baseurl).to eql("foo")
-  end
-
-  it "accepts the legacy 'keyurl' property" do
-    resource.keyurl "foo"
-    expect(resource.gpgkey).to eql("foo")
-  end
-
-  context "on linux", :linux_only do
-    it "resolves to a Noop class when yum is not found" do
-      expect(Chef::Provider::YumRepository).to receive(:which).with("yum").and_return(false)
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
-    end
-
-    it "resolves to a YumRepository class when yum is found" do
-      expect(Chef::Provider::YumRepository).to receive(:which).with("yum").and_return(true)
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::YumRepository)
-    end
-  end
-
-  context "on windows", :windows_only do
-    it "resolves to a NoOp provider" do
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
-    end
-  end
-end

data/spec/unit/resource/zypper_package_spec.rb

@@ -1,51 +0,0 @@
-#
-# Author:: Tim Smith (<tsmith@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::ZypperPackage, "initialize" do
-
-  static_provider_resolution(
-    resource: Chef::Resource::ZypperPackage,
-    provider: Chef::Provider::Package::Zypper,
-    name: :zypper_package,
-    action: :install,
-    os: "linux",
-    platform_family: "suse"
-  )
-
-end
-
-describe Chef::Resource::ZypperPackage, "defaults" do
-  let(:resource) { Chef::Resource::ZypperPackage.new("fakey_fakerton") }
-
-  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
-end

data/spec/unit/resource/zypper_repository_spec.rb

@@ -1,115 +0,0 @@
-#
-# Author:: Tim Smith (<tsmith@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::ZypperRepository do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::ZypperRepository.new("fakey_fakerton", run_context) }
-
-  it "has a resource_name of :zypper_repository" do
-    expect(resource.resource_name).to eq(:zypper_repository)
-  end
-
-  it "the repo_name property is the name_property" do
-    expect(resource.repo_name).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "supports :add, :create, :refresh, :remove actions" do
-    expect { resource.action :add }.not_to raise_error
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :refresh }.not_to raise_error
-    expect { resource.action :remove }.not_to raise_error
-  end
-
-  it "fails if the user provides a repo_name with a forward slash" do
-    expect { resource.repo_name "foo/bar" }.to raise_error(ArgumentError)
-  end
-
-  it "type property defaults to 'NONE'" do
-    expect(resource.type).to eql("NONE")
-  end
-
-  it "enabled property defaults to true" do
-    expect(resource.enabled).to eql(true)
-  end
-
-  it "autorefresh property defaults to true" do
-    expect(resource.autorefresh).to eql(true)
-  end
-
-  it "gpgcheck property defaults to true" do
-    expect(resource.gpgcheck).to eql(true)
-  end
-
-  it "keeppackages property defaults to false" do
-    expect(resource.keeppackages).to eql(false)
-  end
-
-  it "priority property defaults to 99" do
-    expect(resource.priority).to eql(99)
-  end
-
-  it "mode property defaults to '0644'" do
-    expect(resource.mode).to eql("0644")
-  end
-
-  it "refresh_cache property defaults to true" do
-    expect(resource.refresh_cache).to eql(true)
-  end
-
-  it "gpgautoimportkeys property defaults to true" do
-    expect(resource.gpgautoimportkeys).to eql(true)
-  end
-
-  it "accepts the legacy 'key' property" do
-    resource.key "foo"
-    expect(resource.gpgkey).to eql(["foo"])
-  end
-
-  it "accepts the legacy 'uri' property" do
-    resource.uri "foo"
-    expect(resource.baseurl).to eql("foo")
-  end
-
-  context "on linux", :linux_only do
-    it "resolves to a Noop class when on non-linux OS" do
-      node.automatic[:os] = "windows"
-      node.automatic[:platform_family] = "windows"
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
-    end
-
-    it "resolves to a Noop class when on non-suse linux" do
-      node.automatic[:os] = "linux"
-      node.automatic[:platform_family] = "debian"
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
-    end
-
-    it "resolves to a ZypperRepository class when on a suse platform_family" do
-      node.automatic[:os] = "linux"
-      node.automatic[:platform_family] = "suse"
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::ZypperRepository)
-    end
-  end
-end

data/spec/unit/resource_builder_spec.rb

@@ -1 +0,0 @@
-# see spec/unit/recipe_spec.rb

data/spec/unit/resource_collection/resource_list_spec.rb

@@ -1,137 +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::ResourceCollection::ResourceList do
-  let(:resource_list) { Chef::ResourceCollection::ResourceList.new }
-  let(:resource) { Chef::Resource::ZenMaster.new("makoto") }
-  let(:second_resource) { Chef::Resource::ZenMaster.new("hattori") }
-
-  def insert_resource(res)
-    expect { resource_list.insert(res) }.not_to raise_error
-  end
-
-  describe "initialize" do
-    it "should return a Chef::ResourceList" do
-      expect(resource_list).to be_instance_of(Chef::ResourceCollection::ResourceList)
-    end
-  end
-
-  describe "insert" do
-    it "should be able to insert a Chef::Resource" do
-      insert_resource(resource)
-      expect(resource_list[0]).to be(resource)
-    end
-
-    it "should insert things in order" do
-      insert_resource(resource)
-      insert_resource(second_resource)
-      expect(resource_list[0]).to be(resource)
-      expect(resource_list[1]).to be(second_resource)
-    end
-
-    it "should raise error when trying to install something other than Chef::Resource" do
-      expect { resource_list.insert("not a resource") }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "accessors" do
-    it "should be able to insert with []=" do
-      expect { resource_list[0] = resource }.not_to raise_error
-      expect { resource_list[1] = second_resource }.not_to raise_error
-      expect(resource_list[0]).to be(resource)
-      expect(resource_list[1]).to be(second_resource)
-    end
-
-    it "should be empty by default" do
-      expect(resource_list.empty?).to be_truthy
-    end
-
-    describe "when resources are inserted" do
-      before do
-        insert_resource(resource)
-        insert_resource(second_resource)
-      end
-
-      it "should get resources with all_resources method" do
-        resources = resource_list.all_resources
-
-        expect(resources[0]).to be(resource)
-        expect(resources[1]).to be(second_resource)
-      end
-
-      it "should be able to get resources with each" do
-        current = 0
-        expected_resources = [resource, second_resource]
-
-        resource_list.each do |r|
-          expect(r).to be(expected_resources[current])
-          current += 1
-        end
-
-        expect(current).to eq(2)
-      end
-
-      it "should be able to get resources with each_index" do
-        current = 0
-
-        resource_list.each_index do |i|
-          expect(i).to eq(current)
-          current += 1
-        end
-
-        expect(current).to eq(2)
-      end
-
-      it "should be able to check if the list is empty" do
-        expect(resource_list.empty?).to be_falsey
-      end
-    end
-  end
-
-  describe "during execute" do
-    before(:each) do
-      insert_resource(resource)
-      insert_resource(second_resource)
-    end
-
-    it "should execute resources in order" do
-      current = 0
-      expected_resources = [resource, second_resource]
-
-      resource_list.execute_each_resource do |r|
-        expect(r).to be(expected_resources[current])
-        current += 1
-      end
-
-      expect(current).to eq(2)
-    end
-
-    it "should be able to insert resources on the fly" do
-      resource_to_inject = Chef::Resource::ZenMaster.new("there is no spoon")
-      expected_resources = [resource, resource_to_inject, second_resource]
-
-      resource_list.execute_each_resource do |r|
-        resource_list.insert(resource_to_inject) if r == resource
-      end
-
-      expect(resource_list.all_resources).to eq(expected_resources)
-    end
-  end
-end