chef 13.12.14-universal-mingw32 → 14.0.190-universal-mingw32

data/spec/unit/recipe_spec.rb

@@ -3,7 +3,7 @@
 # Author:: Christopher Walters (<cw@chef.io>)
 # Author:: Tim Hinderliter (<tim@chef.io>)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -141,16 +141,16 @@ describe Chef::Recipe do
             Object.send(:remove_const, :TottenhamHotspur)
           end
 
-          it "selects the first one alphabetically" do
+          it "selects the last-writer wins" do
             Sounders.provides :football, platform: "nbc_sports"
             TottenhamHotspur.provides :football, platform: "nbc_sports"
 
             res1 = recipe.football "club world cup"
             expect(res1.name).to eql("club world cup")
-            expect(res1).to be_a_kind_of(Sounders)
+            expect(res1).to be_a_kind_of(TottenhamHotspur)
           end
 
-          it "selects the first one alphabetically even if the declaration order is reversed" do
+          it "selects the last-writer wins even if the declaration order is reversed" do
             TottenhamHotspur.provides :football2, platform: "nbc_sports"
             Sounders.provides :football2, platform: "nbc_sports"
 

data/spec/unit/resource/apt_package_spec.rb

@@ -35,4 +35,8 @@ describe Chef::Resource::AptPackage, "initialize" do
     resource.default_release("lenny-backports")
     expect(resource.default_release).to eql("lenny-backports")
   end
+
+  it "should preserve configuration files by default" do
+    expect(resource.overwrite_config_files).to eql(false)
+  end
 end

data/spec/unit/resource/apt_preference_spec.rb

@@ -24,11 +24,6 @@ describe Chef::Resource::AptPreference do
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:resource) { Chef::Resource::AptPreference.new("libmysqlclient16", run_context) }
 
-  it "creates a new Chef::Resource::AptPreference" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::AptPreference)
-  end
-
   it "resolves to a Noop class when on non-linux OS" do
     node.automatic[:os] = "windows"
     node.automatic[:platform_family] = "windows"

data/spec/unit/resource/apt_repository_spec.rb

@@ -20,22 +20,47 @@ require "spec_helper"
 
 describe Chef::Resource::AptRepository do
   let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:run_context) do
+    node.automatic[:lsb][:codename] = "superduper"
+    empty_events = Chef::EventDispatch::Dispatcher.new
+    Chef::RunContext.new(node, {}, empty_events)
+  end
   let(:resource) { Chef::Resource::AptRepository.new("multiverse", run_context) }
 
-  it "creates a new Chef::Resource::AptRepository" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::AptRepository)
+  it "keyserver defaults to keyserver.ubuntu.com" do
+    expect(resource.keyserver).to eql("keyserver.ubuntu.com")
   end
 
-  it "uses keyserver.ubuntu.com as the keyserver" do
-    expect(resource.keyserver).to eql("keyserver.ubuntu.com")
+  it "repo_name is the name property" do
+    expect(resource.repo_name).to eql("multiverse")
+  end
+
+  it "distribution defaults to the distro codename" do
+    expect(resource.distribution).to eql("superduper")
+  end
+
+  it "allows setting key to an Array of keys and does not coerce it" do
+    resource.key = %w{key1 key2}
+    expect(resource.key).to eql(%w{key1 key2})
+  end
+
+  it "allows setting key to nil and does not coerce it" do
+    resource.key = nil
+    expect(resource.key).to be_nil
+  end
+
+  it "allows setting key to false and does not coerce it" do
+    resource.key = false
+    expect(resource.key).to be false
+  end
+
+  it "allows setting key to a String and coerces it to an Array" do
+    resource.key = "key1"
+    expect(resource.key).to eql(["key1"])
   end
 
-  it "default distribution is nillable" do
-    expect(resource.distribution(nil)).to eql(nil)
-    expect(resource.distribution).to eql(nil)
+  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 "resolves to a Noop class when on non-linux OS" do

data/spec/unit/resource/apt_update_spec.rb

@@ -24,11 +24,6 @@ describe Chef::Resource::AptUpdate do
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:resource) { Chef::Resource::AptUpdate.new("update", run_context) }
 
-  it "creates a new Chef::Resource::AptUpdate" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::AptUpdate)
-  end
-
   it "default frequency is set to be 1 day" do
     expect(resource.frequency).to eql(86_400)
   end

data/spec/unit/resource/bash_spec.rb

@@ -22,9 +22,8 @@ describe Chef::Resource::Bash do
 
   let(:resource) { Chef::Resource::Bash.new("fakey_fakerton") }
 
-  it "creates a new Chef::Resource::Bash" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::Bash)
+  it "is a subclass of Chef::Resource::Script" do
+    expect(resource).to be_a_kind_of(Chef::Resource::Script)
   end
 
   it "has a resource name of :bash" do

data/spec/unit/resource/batch_spec.rb

@@ -19,18 +19,15 @@
 require "spec_helper"
 
 describe Chef::Resource::Batch do
+  let(:node) { Chef::Node.new }
 
   before(:each) do
-    node = Chef::Node.new
-
     node.default["kernel"] = Hash.new
     node.default["kernel"][:machine] = :x86_64.to_s
     node.automatic[:os] = "windows"
 
     run_context = Chef::RunContext.new(node, nil, nil)
-
     @resource = Chef::Resource::Batch.new("batch_unit_test", run_context)
-
   end
 
   it "creates a new Chef::Resource::Batch" do

data/spec/unit/resource/{timestamped_deploy_spec.rb → build_essential_spec.rb}

@@ -1,6 +1,5 @@
 #
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
+# Copyright:: Copyright 2018, Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,15 +17,15 @@
 
 require "spec_helper"
 
-describe Chef::Resource::TimestampedDeploy, "initialize" do
+describe Chef::Resource::BuildEssential do
 
-  static_provider_resolution(
-    resource: Chef::Resource::TimestampedDeploy,
-    provider: Chef::Provider::Deploy::Timestamped,
-    name: :timestamped_deploy,
-    action: :deploy,
-    os: "linux",
-    platform_family: "rhel"
-  )
+  let(:resource) { Chef::Resource::BuildEssential.new("foo") }
 
+  it "has a resource name of :build_essential" do
+    expect(resource.resource_name).to eql(:build_essential)
+  end
+
+  it "has a default action of install" do
+    expect(resource.action).to eql([:install])
+  end
 end

data/spec/unit/resource/cab_package_spec.rb

@@ -22,10 +22,8 @@ describe Chef::Resource::CabPackage do
 
   let(:resource) { Chef::Resource::CabPackage.new("test_pkg") }
 
-  it "creates a new Chef::Resource::CabPackage" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
+  it "is a subclass of Chef::Resource::Package" do
     expect(resource).to be_a_kind_of(Chef::Resource::Package)
-    expect(resource).to be_a_instance_of(Chef::Resource::CabPackage)
   end
 
   it "sets resource name as :cab_package" do

data/{lib/chef/mixin/language_include_attribute.rb → spec/unit/resource/chef_handler_spec.rb}

@@ -1,6 +1,5 @@
 #
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2018, Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,19 +15,21 @@
 # limitations under the License.
 #
 
-require "chef/dsl/include_attribute"
-require "chef/mixin/deprecation"
+require "spec_helper"
 
-class Chef
-  module Mixin
+describe Chef::Resource::ChefHandler do
 
-    # DEPRECATED: This is just here for compatibility, use
-    # Chef::DSL::IncludeAttribute instead.
+  let(:resource) { Chef::Resource::ChefHandler.new("foo") }
 
-    deprecate_constant(:LanguageIncludeAttribute, Chef::DSL::IncludeAttribute, <<-EOM)
-Chef::Mixin::LanguageIncludeAttribute is deprecated. Use
-Chef::DSL::IncludeAttribute instead.
-EOM
+  it "has a resource name of :chef_handler" do
+    expect(resource.resource_name).to eql(:chef_handler)
+  end
+
+  it "has a default action of enable" do
+    expect(resource.action).to eql([:enable])
+  end
 
+  it "the class_name property is the name property" do
+    expect(resource.class_name).to eql("foo")
   end
 end

data/spec/unit/resource/chocolatey_package_spec.rb

@@ -22,10 +22,8 @@ describe Chef::Resource::ChocolateyPackage do
 
   let(:resource) { Chef::Resource::ChocolateyPackage.new("fakey_fakerton") }
 
-  it "creates a new Chef::Resource::ChocolateyPackage" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
+  it "is a subclass of Chef::Resource::Package" do
     expect(resource).to be_a_kind_of(Chef::Resource::Package)
-    expect(resource).to be_a_instance_of(Chef::Resource::ChocolateyPackage)
   end
 
   it "has a resource name of :python" do

data/spec/unit/resource/cron_spec.rb

@@ -22,11 +22,6 @@ require "spec_helper"
 describe Chef::Resource::Cron do
   let(:resource) { Chef::Resource::Cron.new("cronify") }
 
-  it "creates a new Chef::Resource::Cron" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::Cron)
-  end
-
   it "has a name property" do
     expect(resource.name).to eql("cronify")
   end

data/spec/unit/resource/csh_spec.rb

@@ -22,9 +22,8 @@ describe Chef::Resource::Csh do
 
   let(:resource) { Chef::Resource::Csh.new("fakey_fakerton") }
 
-  it "creates a new Chef::Resource::Csh" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::Csh)
+  it "is a subclass of Chef::Resource::Script" do
+    expect(resource).to be_a_kind_of(Chef::Resource::Script)
   end
 
   it "has a resource name of :csh" do

data/spec/unit/resource/directory_spec.rb

@@ -22,12 +22,7 @@ require "spec_helper"
 describe Chef::Resource::Directory do
   let(:resource) { Chef::Resource::Directory.new("fakey_fakerton") }
 
-  it "creates a new Chef::Resource::Directory" do
-    expect(resource).to be_a_kind_of(Chef::Resource)
-    expect(resource).to be_a_kind_of(Chef::Resource::Directory)
-  end
-
-  it "has a name" do
+  it "has a name property" do
     expect(resource.name).to eql("fakey_fakerton")
   end
 

data/{lib/chef/resource/deploy_revision.rb → spec/unit/resource/dmg_package_spec.rb}

@@ -1,6 +1,5 @@
 #
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
+# Copyright:: Copyright 2018, Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,16 +15,21 @@
 # limitations under the License.
 #
 
-class Chef
-  class Resource
+require "spec_helper"
 
-    # Convenience class for using the deploy resource with the revision
-    # deployment strategy (provider)
-    class DeployRevision < Chef::Resource::Deploy
-    end
+describe Chef::Resource::DmgPackage do
 
-    class DeployBranch < Chef::Resource::DeployRevision
-    end
+  let(:resource) { Chef::Resource::DmgPackage.new("myapp") }
 
+  it "has a resource name of :dmg_package" do
+    expect(resource.resource_name).to eql(:dmg_package)
+  end
+
+  it "has a default action of install" do
+    expect(resource.action).to eql([:install])
+  end
+
+  it "the app property is the name property" do
+    expect(resource.app).to eql("myapp")
   end
 end

data/spec/unit/resource/dnf_package_spec.rb

@@ -32,68 +32,62 @@ describe Chef::Resource::DnfPackage, "initialize" do
 end
 
 describe Chef::Resource::DnfPackage, "arch" do
-  before(:each) do
-    @resource = Chef::Resource::DnfPackage.new("foo")
-  end
+  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"])
+    resource.arch("i386")
+    expect(resource.arch).to eql(["i386"])
   end
 end
 
 describe Chef::Resource::DnfPackage, "flush_cache" do
-  before(:each) do
-    @resource = Chef::Resource::DnfPackage.new("foo")
-  end
+  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)
+    expect(resource.flush_cache).to eq(flush_hash)
   end
 
   it "allows you to set the flush timing with an array" do
     flush_array = [ :before, :after ]
     flush_hash = { :before => true, :after => true }
-    @resource.flush_cache(flush_array)
-    expect(@resource.flush_cache).to eq(flush_hash)
+    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)
+    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 })
+    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 })
+    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 })
+    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 })
+    resource.flush_cache(:after)
+    expect(resource.flush_cache).to eq({ before: false, after: true })
   end
 end
 
 describe Chef::Resource::DnfPackage, "allow_downgrade" do
-  before(:each) do
-    @resource = Chef::Resource::DnfPackage.new("foo")
-  end
+  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
+    expect { resource.allow_downgrade true }.not_to raise_error
+    expect { resource.allow_downgrade false }.not_to raise_error
   end
 end

data/spec/unit/resource/file_spec.rb

@@ -22,7 +22,7 @@ describe Chef::Resource::File do
 
   let(:resource) { Chef::Resource::File.new("fakey_fakerton") }
 
-  it "has a name" do
+  it "has a name property" do
     expect(resource.name).to eql("fakey_fakerton")
   end
 

data/spec/unit/resource/freebsd_package_spec.rb

@@ -22,42 +22,41 @@ require "spec_helper"
 require "ostruct"
 
 describe Chef::Resource::FreebsdPackage do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @resource = Chef::Resource::FreebsdPackage.new("foo", @run_context)
-  end
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::FreebsdPackage.new("foo", run_context) }
 
   describe "Initialization" do
-    it "returns a Chef::Resource::FreebsdPackage" do
-      expect(@resource).to be_a_kind_of(Chef::Resource::FreebsdPackage)
+
+    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 :freebsd_package" do
-      expect(@resource.resource_name).to eql(:freebsd_package)
+      expect(resource.resource_name).to eql(:freebsd_package)
     end
 
     it "does not set the provider" do
-      expect(@resource.provider).to be_nil
+      expect(resource.provider).to be_nil
     end
   end
 
   describe "Assigning provider after creation" do
     describe "if ports specified as source" do
       it "is Freebsd::Port" do
-        @resource.source("ports")
-        @resource.after_created
-        expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Port)
+        resource.source("ports")
+        resource.after_created
+        expect(resource.provider).to eq(Chef::Provider::Package::Freebsd::Port)
       end
     end
 
     describe "if freebsd_version is greater than or equal to 1000017" do
       it "is Freebsd::Pkgng" do
         [1000017, 1000018, 1000500, 1001001, 1100000].each do |freebsd_version|
-          @node.automatic_attrs[:os_version] = freebsd_version
-          @resource.after_created
-          expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng)
+          node.automatic_attrs[:os_version] = freebsd_version
+          resource.after_created
+          expect(resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng)
         end
       end
     end
@@ -65,21 +64,21 @@ describe Chef::Resource::FreebsdPackage do
     describe "if pkgng enabled" do
       it "is Freebsd::Pkgng" do
         pkg_enabled = OpenStruct.new(:stdout => "yes\n")
-        allow(@resource).to receive(:shell_out!).with("make", "-V", "WITH_PKGNG", :env => nil).and_return(pkg_enabled)
-        @resource.after_created
-        expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng)
+        allow(resource).to receive(:shell_out!).with("make", "-V", "WITH_PKGNG", :env => nil).and_return(pkg_enabled)
+        resource.after_created
+        expect(resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng)
       end
     end
 
     describe "if freebsd_version is less than 1000017 and pkgng not enabled" do
       it "is Freebsd::Pkg" do
         pkg_enabled = OpenStruct.new(:stdout => "\n")
-        allow(@resource).to receive(:shell_out!).with("make", "-V", "WITH_PKGNG", :env => nil).and_return(pkg_enabled)
+        allow(resource).to receive(:shell_out!).with("make", "-V", "WITH_PKGNG", :env => nil).and_return(pkg_enabled)
 
         [1000016, 1000000, 901503, 902506, 802511].each do |freebsd_version|
-          @node.automatic_attrs[:os_version] = freebsd_version
-          @resource.after_created
-          expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkg)
+          node.automatic_attrs[:os_version] = freebsd_version
+          resource.after_created
+          expect(resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkg)
         end
       end
     end