chef 12.12.15-universal-mingw32 → 12.13.30-universal-mingw32

data/spec/functional/resource/link_spec.rb

@@ -580,12 +580,7 @@ describe Chef::Resource::Link do
             it "links to the target file" do
               skip("OS X/FreeBSD/AIX fails to create hardlinks to broken symlinks") if os_x? || freebsd? || aix?
               resource.run_action(:create)
-              # Windows and Unix have different definitions of exists? here, and that's OK.
-              if windows?
-                expect(File.exists?(target_file)).to be_truthy
-              else
-                expect(File.exists?(target_file)).to be_falsey
-              end
+              expect(File.exists?(target_file) || File.symlink?(target_file)).to be_truthy
               expect(symlink?(target_file)).to be_truthy
               expect(readlink(target_file)).to eq(canonicalize(@other_target))
             end

data/spec/functional/run_lock_spec.rb

@@ -258,11 +258,12 @@ describe Chef::RunLock do
 
     it "test returns true and acquires the lock" do
       run_lock = Chef::RunLock.new(lockfile)
+      from_tests, to_fork = IO.pipe
       p1 = fork do
         expect(run_lock.test).to eq(true)
-        run_lock.save_pid
-        sleep 2
-        exit! 1
+        # Wait for the test to tell us we can exit before exiting
+        from_tests.readline
+        exit! 0
       end
 
       wait_on_lock
@@ -272,23 +273,29 @@ describe Chef::RunLock do
         exit! 0
       end
 
-      Process.waitpid2(p2)
-      Process.waitpid2(p1)
+      pid, exit_status = Process.waitpid2(p2)
+      expect(exit_status).to eq(0)
+      to_fork.puts "you can exit now"
+      pid, exit_status = Process.waitpid2(p1)
+      expect(exit_status).to eq(0)
     end
 
     it "test returns without waiting when the lock is acquired" do
       run_lock = Chef::RunLock.new(lockfile)
+      from_tests, to_fork = IO.pipe
       p1 = fork do
         run_lock.acquire
-        run_lock.save_pid
-        sleep 2
-        exit! 1
+        # Wait for the test to tell us we can exit before exiting
+        from_tests.readline
+        exit! 0
       end
 
       wait_on_lock
-
       expect(run_lock.test).to eq(false)
-      Process.waitpid2(p1)
+
+      to_fork.puts "you can exit now"
+      pid, exit_status = Process.waitpid2(p1)
+      expect(exit_status).to eq(0)
     end
 
   end

data/spec/integration/knife/diff_spec.rb

@@ -72,7 +72,7 @@ EOM
           file "data_bags/x/y.json", {}
           file "environments/_default.json", { "description" => "The default Chef environment" }
           file "environments/x.json", {}
-          file "nodes/x.json", {}
+          file "nodes/x.json", { "normal" => { "tags" => [] } }
           file "roles/x.json", {}
           file "users/admin.json", { "admin" => true, "public_key" => ChefZero::PUBLIC_KEY }
           file "users/x.json", { "public_key" => ChefZero::PUBLIC_KEY }
@@ -366,7 +366,7 @@ EOM
           file "data_bags/x/y.json", {}
           file "environments/_default.json", { "description" => "The default Chef environment" }
           file "environments/x.json", {}
-          file "nodes/x.json", {}
+          file "nodes/x.json", { "normal" => { "tags" => [] } }
           file "roles/x.json", {}
           file "users/admin.json", { "admin" => true, "public_key" => ChefZero::PUBLIC_KEY }
           file "users/x.json", { "public_key" => ChefZero::PUBLIC_KEY }

data/spec/integration/knife/download_spec.rb

@@ -76,7 +76,7 @@ EOM
           file "data_bags/x/y.json", {}
           file "environments/_default.json", { "description" => "The default Chef environment" }
           file "environments/x.json", {}
-          file "nodes/x.json", {}
+          file "nodes/x.json", { "normal" => { "tags" => [] } }
           file "roles/x.json", {}
           file "users/admin.json", { "admin" => true, "public_key" => ChefZero::PUBLIC_KEY }
           file "users/x.json", { "public_key" => ChefZero::PUBLIC_KEY }
@@ -645,7 +645,7 @@ EOM
           file "data_bags/x/y.json", {}
           file "environments/_default.json", { "description" => "The default Chef environment" }
           file "environments/x.json", {}
-          file "nodes/x.json", {}
+          file "nodes/x.json", { "normal" => { "tags" => [] } }
           file "roles/x.json", {}
           file "users/admin.json", { "admin" => true, "public_key" => ChefZero::PUBLIC_KEY }
           file "users/x.json", { "public_key" => ChefZero::PUBLIC_KEY }
@@ -1271,7 +1271,7 @@ EOM
             file "groups/x.json", {}
             file "invitations.json", [ "foo" ]
             file "members.json", [ "bar" ]
-            file "nodes/x.json", {}
+            file "nodes/x.json", { "normal" => { "tags" => [] } }
             file "org.json", { "full_name" => "Something" }
             file "policies/x-1.0.0.json", {}
             file "policies/blah-1.0.0.json", {}
@@ -1295,7 +1295,7 @@ EOM
             file "environments/x.json", { "description" => "foo" }
             file "groups/x.json", { "description" => "foo" }
             file "groups/x.json", { "groups" => [ "admin" ] }
-            file "nodes/x.json", { "run_list" => [ "blah" ] }
+            file "nodes/x.json", { "normal" => { "tags" => [] }, "run_list" => [ "blah" ] }
             file "org.json", { "full_name" => "Something Else " }
             file "policies/x-1.0.0.json", { "run_list" => [ "blah" ] }
             file "policy_groups/x.json", {

data/spec/integration/knife/raw_spec.rb

@@ -49,7 +49,9 @@ describe "knife raw", :workstation do
 
   },
   "normal": {
+    "tags": [
 
+    ]
   },
   "default": {
 

data/spec/integration/knife/upload_spec.rb

@@ -96,7 +96,7 @@ EOM
           file "data_bags/x/y.json", {}
           file "environments/_default.json", { "description" => "The default Chef environment" }
           file "environments/x.json", {}
-          file "nodes/x.json", {}
+          file "nodes/x.json", { "normal" => { "tags" => [] } }
           file "roles/x.json", {}
           file "users/admin.json", { "admin" => true, "public_key" => ChefZero::PUBLIC_KEY }
           file "users/x.json", { "public_key" => ChefZero::PUBLIC_KEY }
@@ -802,7 +802,7 @@ EOM
           file "data_bags/x/y.json", {}
           file "environments/_default.json", { "description" => "The default Chef environment" }
           file "environments/x.json", {}
-          file "nodes/x.json", {}
+          file "nodes/x.json", { "normal" => { "tags" => [] } }
           file "roles/x.json", {}
           file "users/admin.json", { "admin" => true, "public_key" => ChefZero::PUBLIC_KEY }
           file "users/x.json", { "public_key" => ChefZero::PUBLIC_KEY }
@@ -1313,7 +1313,7 @@ EOM
           file "invitations.json", [ "foo" ]
           file "members.json", [ "bar" ]
           file "org.json", { "full_name" => "wootles" }
-          file "nodes/x.json", {}
+          file "nodes/x.json", { "normal" => { "tags" => [] } }
           file "policies/x-1.0.0.json", {}
           file "policies/blah-1.0.0.json", {}
           file "policy_groups/x.json", { "policies" => { "x" => { "revision_id" => "1.0.0" }, "blah" => { "revision_id" => "1.0.0" } } }

data/spec/rcov.opts

@@ -1,2 +1,2 @@
---exclude
-spec,bin,/Library/Ruby
+--exclude
+spec,bin,/Library/Ruby

data/spec/spec_helper.rb

@@ -66,6 +66,8 @@ require "chef/util/file_edit"
 
 require "chef/config"
 
+require "chef/chef_fs/file_system_cache"
+
 if ENV["CHEF_FIPS"] == "1"
   Chef::Config.init_openssl
 end
@@ -200,6 +202,8 @@ RSpec.configure do |config|
   config.before(:each) do
     Chef.reset!
 
+    Chef::ChefFS::FileSystemCache.instance.reset!
+
     Chef::Config.reset
 
     # By default, treat deprecation warnings as errors in tests.
@@ -220,6 +224,7 @@ RSpec.configure do |config|
 end
 
 require "webrick/utils"
+require "thread"
 
 #    Webrick uses a centralized/synchronized timeout manager. It works by
 #    starting a thread to check for timeouts on an interval. The timeout
@@ -238,7 +243,12 @@ module WEBrick
   module Utils
     class TimeoutHandler
       def initialize
-        @timeout_info = Hash.new
+      end
+
+      def register(*args)
+      end
+
+      def cancel(*args)
       end
     end
   end

data/spec/support/shared/integration/knife_support.rb

@@ -20,6 +20,7 @@ require "chef/knife"
 require "chef/application/knife"
 require "logger"
 require "chef/log"
+require "chef/chef_fs/file_system_cache"
 
 module KnifeSupport
   DEBUG = ENV["DEBUG"]
@@ -70,6 +71,9 @@ module KnifeSupport
         Chef::Config[:verbosity] = ( DEBUG ? 2 : 0 )
         instance.config[:config_file] = File.join(CHEF_SPEC_DATA, "null_config.rb")
 
+        # Ensure the ChefFS cache is empty
+        Chef::ChefFS::FileSystemCache.instance.reset!
+
         # Configure chef with a (mostly) blank knife.rb
         # We set a global and then mutate it in our stub knife.rb so we can be
         # extra sure that we're not loading someone's real knife.rb and then

data/spec/unit/application/client_spec.rb

@@ -74,6 +74,8 @@ describe Chef::Application::Client, "reconfigure" do
   end
 
   before do
+    Chef::Config.reset
+
     allow(Kernel).to receive(:trap).and_return(:ok)
     allow(::File).to receive(:read).and_call_original
     allow(::File).to receive(:read).with(Chef::Config.platform_specific_path("/etc/chef/client.rb")).and_return("")
@@ -141,6 +143,39 @@ describe Chef::Application::Client, "reconfigure" do
                         :daemonize => true
       end
     end
+
+    describe "--config-option" do
+      context "with a single value" do
+        it_behaves_like "sets the configuration", "--config-option chef_server_url=http://example",
+                        :chef_server_url => "http://example"
+      end
+
+      context "with two values" do
+        it_behaves_like "sets the configuration", "--config-option chef_server_url=http://example --config-option policy_name=web",
+                        :chef_server_url => "http://example", :policy_name => "web"
+      end
+
+      context "with a boolean value" do
+        it_behaves_like "sets the configuration", "--config-option minimal_ohai=true",
+                        :minimal_ohai => true
+      end
+
+      context "with an empty value" do
+        it "should terminate with message" do
+          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option ""').and_raise("so ded")
+          ARGV.replace(["--config-option", ""])
+          expect { app.reconfigure }.to raise_error "so ded"
+        end
+      end
+
+      context "with an invalid value" do
+        it "should terminate with message" do
+          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option "asdf"').and_raise("so ded")
+          ARGV.replace(["--config-option", "asdf"])
+          expect { app.reconfigure }.to raise_error "so ded"
+        end
+      end
+    end
   end
 
   describe "when configured to not fork the client process" do

data/spec/unit/application/solo_spec.rb

@@ -120,9 +120,10 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
         expect(app).to receive(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(tarfile)
         expect(File).to receive(:open).with("#{Dir.tmpdir}/chef-solo/recipes.tgz", "wb").and_yield(target_file)
 
-        shellout = instance_double("Mixlib::ShellOut", run_command: nil, error!: nil, stdout: "")
+        archive = double(Mixlib::Archive)
 
-        expect(app).to receive(:shell_out!).with("tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo").and_return(shellout)
+        expect(Mixlib::Archive).to receive(:new).with("#{Dir.tmpdir}/chef-solo/recipes.tgz").and_return(archive)
+        expect(archive).to receive(:extract).with("#{Dir.tmpdir}/chef-solo", { perms: false, ignore: /^\.$/ })
         app.reconfigure
         expect(target_file.string).to eq("remote_tarball_content")
       end
@@ -136,11 +137,10 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
         Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
         expect(FileUtils).to receive(:mkdir_p).with("#{Dir.tmpdir}/chef-solo").and_return(true)
 
-        allow(Chef::Mixin::Command).to receive(:run_command).and_return(true)
+        archive = double(Mixlib::Archive)
 
-        shellout = instance_double("Mixlib::ShellOut", run_command: nil, error!: nil, stdout: "")
-
-        expect(app).to receive(:shell_out!).with("tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo").and_return(shellout)
+        expect(Mixlib::Archive).to receive(:new).with("#{Dir.tmpdir}/chef-solo/recipes.tgz").and_return(archive)
+        expect(archive).to receive(:extract).with("#{Dir.tmpdir}/chef-solo", { perms: false, ignore: /^\.$/ })
         expect(app).to receive(:fetch_recipe_tarball).ordered
         expect(Chef::ConfigFetcher).to receive(:new).ordered.and_return(config_fetcher)
         app.reconfigure

data/spec/unit/chef_fs/file_system/repository/directory_spec.rb

@@ -76,6 +76,7 @@ describe Chef::ChefFS::FileSystem::Repository::Directory do
   context "#create_child" do
     it "creates a new TestFile" do
       expect(TestFile).to receive(:new).with("test_child", test_directory).and_return(file_double)
+      allow(file_double).to receive(:file_path).and_return("#{test_directory}/test_child")
       expect(file_double).to receive(:write).with("test")
       test_directory.create_child("test_child", "test")
     end

data/spec/unit/data_collector_spec.rb

@@ -156,6 +156,10 @@ describe Chef::DataCollector::Reporter do
   let(:reporter) { described_class.new }
   let(:run_status) { Chef::RunStatus.new(Chef::Node.new, Chef::EventDispatch::Dispatcher.new) }
 
+  before do
+    Chef::Config[:data_collector][:server_url] = "http://my-data-collector-server.mycompany.com"
+  end
+
   describe '#run_started' do
     before do
       allow(reporter).to receive(:update_run_status)
@@ -490,7 +494,8 @@ describe Chef::DataCollector::Reporter do
 
     [ Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
       Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
-      Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError ].each do |exception_class|
+      Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError,
+      Errno::EHOSTDOWN ].each do |exception_class|
       context "when the block raises a #{exception_class} exception" do
         it "disables the reporter" do
           expect(reporter).to receive(:disable_data_collector_reporter)
@@ -515,4 +520,39 @@ describe Chef::DataCollector::Reporter do
       end
     end
   end
+
+  describe '#validate_data_collector_server_url!' do
+    context "when server_url is empty" do
+      it "raises an exception" do
+        Chef::Config[:data_collector][:server_url] = ""
+        expect { reporter.send(:validate_data_collector_server_url!) }.to raise_error(Chef::Exceptions::ConfigurationError)
+      end
+    end
+
+    context "when server_url is not empty" do
+      context "when server_url is an invalid URI" do
+        it "raises an exception" do
+          Chef::Config[:data_collector][:server_url] = "this is not a URI"
+          expect { reporter.send(:validate_data_collector_server_url!) }.to raise_error(Chef::Exceptions::ConfigurationError)
+        end
+      end
+
+      context "when server_url is a valid URI" do
+        context "when server_url is a URI with no host" do
+          it "raises an exception" do
+            Chef::Config[:data_collector][:server_url] = "/file/uri.txt"
+            expect { reporter.send(:validate_data_collector_server_url!) }.to raise_error(Chef::Exceptions::ConfigurationError)
+          end
+
+        end
+
+        context "when server_url is a URI with a valid host" do
+          it "does not an exception" do
+            Chef::Config[:data_collector][:server_url] = "http://www.google.com/data-collector"
+            expect { reporter.send(:validate_data_collector_server_url!) }.not_to raise_error
+          end
+        end
+      end
+    end
+  end
 end

data/spec/unit/dsl/declare_resource_spec.rb

@@ -235,6 +235,36 @@ describe Chef::ResourceCollection do
       ).to eql(resource)
       expect(run_context.resource_collection.all_resources.size).to eql(0)
     end
+
+    it "removes pending delayed notifications" do
+      recipe.declare_resource(:zen_master, "one")
+      recipe.declare_resource(:zen_master, "two") do
+        notifies :win, "zen_master[one]"
+      end
+      recipe.delete_resource(:zen_master, "two")
+      resource = recipe.declare_resource(:zen_master, "two")
+      expect(resource.delayed_notifications).to eql([])
+    end
+
+    it "removes pending immediate notifications" do
+      recipe.declare_resource(:zen_master, "one")
+      recipe.declare_resource(:zen_master, "two") do
+        notifies :win, "zen_master[one]", :immediate
+      end
+      recipe.delete_resource(:zen_master, "two")
+      resource = recipe.declare_resource(:zen_master, "two")
+      expect(resource.immediate_notifications).to eql([])
+    end
+
+    it "removes pending before notifications" do
+      recipe.declare_resource(:zen_master, "one")
+      recipe.declare_resource(:zen_master, "two") do
+        notifies :win, "zen_master[one]", :before
+      end
+      recipe.delete_resource(:zen_master, "two")
+      resource = recipe.declare_resource(:zen_master, "two")
+      expect(resource.before_notifications).to eql([])
+    end
   end
 
   describe "run_context helpers" do

data/spec/unit/knife/cookbook_site_install_spec.rb

@@ -23,6 +23,7 @@ describe Chef::Knife::CookbookSiteInstall do
   let(:stdout) { StringIO.new }
   let(:stderr) { StringIO.new }
   let(:downloader) { Hash.new }
+  let(:archive) { double(Mixlib::Archive, extract: true) }
   let(:repo) { double(:sanity_check => true, :reset_to_default_state => true,
                       :prepare_to_import => true, :finalize_updates_to => true,
                       :merge_updates_from => true) }
@@ -48,6 +49,7 @@ describe Chef::Knife::CookbookSiteInstall do
     allow(File).to receive(:unlink)
     allow(File).to receive(:rmtree)
     allow(knife).to receive(:shell_out!).and_return(true)
+    allow(Mixlib::Archive).to receive(:new).and_return(archive)
 
     # CookbookSiteDownload Stup
     allow(knife).to receive(:download_cookbook_to).and_return(downloader)

data/spec/unit/knife/cookbook_site_share_spec.rb

@@ -83,11 +83,11 @@ describe Chef::Knife::CookbookSiteShare do
       @knife.run
     end
 
-    it "should print error and exit when given only 1 argument and cannot determine category" do
+    it "should use a default category when given only 1 argument and cannot determine category" do
       @knife.name_args = ["cookbook_name"]
-      expect(@noauth_rest).to receive(:get).with("https://supermarket.chef.io/api/v1/cookbooks/cookbook_name").and_return(@bad_category_response)
-      expect(@knife.ui).to receive(:fatal)
-      expect { @knife.run }.to raise_error(SystemExit)
+      expect(@noauth_rest).to receive(:get).with("https://supermarket.chef.io/api/v1/cookbooks/cookbook_name") { raise Net::HTTPServerException.new("404 Not Found", OpenStruct.new(code: "404")) }
+      expect(@knife).to receive(:do_upload)
+      expect { @knife.run }.to_not raise_error
     end
 
     it "should print error and exit when given only 1 argument and Chef::ServerAPI throws an exception" do

data/spec/unit/node_spec.rb

@@ -255,6 +255,12 @@ describe Chef::Node do
         expect(node[:snoopy][:is_a_puppy]).to eq(true)
       end
 
+      it "should allow you to set an attribute with set_unless with method_missing but emit a deprecation warning" do
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
+        node.normal_unless.snoopy.is_a_puppy = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(false)
+      end
+
       it "should allow you to set an attribute with set_unless" do
         node.normal_unless[:snoopy][:is_a_puppy] = false
         expect(node[:snoopy][:is_a_puppy]).to eq(false)