chef 16.3.45-universal-mingw32 → 16.5.77-universal-mingw32

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

@@ -44,15 +44,30 @@ module IntegrationSupport
 
     def when_the_repository(desc, *tags, &block)
       context("when the chef repo #{desc}", *tags) do
-        include_context "with a chef repo"
+        before :each do
+          raise "Can only create one directory per test" if @repository_dir
 
-        module_eval(&block)
-      end
-    end
+          @repository_dir = Dir.mktmpdir("chef_repo")
+          Chef::Config.chef_repo_path = @repository_dir
+          %w{client cookbook data_bag environment node role user}.each do |object_name|
+            Chef::Config.delete("#{object_name}_path".to_sym)
+          end
+        end
+
+        after :each do
+          if @repository_dir
+            begin
+              # TODO: "force" actually means "silence all exceptions". this
+              # silences a weird permissions error on Windows that we should track
+              # down, but for now there's no reason for it to blow up our CI.
+              FileUtils.remove_entry_secure(@repository_dir, force = ChefUtils.windows?)
+            ensure
+              @repository_dir = nil
+            end
+          end
+          Dir.chdir(@old_cwd) if @old_cwd
+        end
 
-    def with_versioned_cookbooks(&block)
-      context("with versioned cookbooks") do
-        include_context "with versioned cookbooks"
         module_eval(&block)
       end
     end
@@ -105,49 +120,4 @@ module IntegrationSupport
     @old_cwd = Dir.pwd
     Dir.chdir(path_to(relative_path))
   end
-
-  RSpec.shared_context "with a chef repo" do
-    before :each do
-      raise "Can only create one directory per test" if @repository_dir
-
-      @repository_dir = Dir.mktmpdir("chef_repo")
-      Chef::Config.chef_repo_path = @repository_dir
-      %w{client cookbook data_bag environment node role user}.each do |object_name|
-        Chef::Config.delete("#{object_name}_path".to_sym)
-      end
-    end
-
-    after :each do
-      if @repository_dir
-        begin
-          %w{client cookbook data_bag environment node role user}.each do |object_name|
-            Chef::Config.delete("#{object_name}_path".to_sym)
-          end
-          Chef::Config.delete(:chef_repo_path)
-          # TODO: "force" actually means "silence all exceptions". this
-          # silences a weird permissions error on Windows that we should track
-          # down, but for now there's no reason for it to blow up our CI.
-          FileUtils.remove_entry_secure(@repository_dir, force = ChefUtils.windows?)
-        ensure
-          @repository_dir = nil
-        end
-      end
-      Dir.chdir(@old_cwd) if @old_cwd
-    end
-
-  end
-
-  # Versioned cookbooks
-
-  RSpec.shared_context "with versioned cookbooks", versioned_cookbooks: true do
-    before(:each) { Chef::Config[:versioned_cookbooks] = true }
-    after(:each)  { Chef::Config.delete(:versioned_cookbooks) }
-  end
-
-  RSpec.shared_context "without versioned cookbooks", versioned_cookbooks: false do
-    # Just make sure this goes back to default
-    before(:each) { Chef::Config[:versioned_cookbooks] = false }
-    after(:each)  { Chef::Config.delete(:versioned_cookbooks) }
-  end
-
 end

data/spec/support/shared/unit/application_dot_d.rb

@@ -33,14 +33,16 @@ shared_examples_for "an application that loads a dot d" do
     # make sure that we are correctly globbing.
     let(:client_d_dir) do
       Chef::Util::PathHelper.cleanpath(
-        File.join(File.dirname(__FILE__), "../../../data/client.d_00")
+        File.join(__dir__, "../../../data/client.d_00")
       )
     end
 
     it "loads the configuration in order" do
+      etc_chef_client_rb = Chef::Config.platform_specific_path("#{ChefConfig::Config.etc_chef_dir}/client.rb")
       expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/00-foo.rb").cleanpath.to_s).and_return("foo 0")
       expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/01-bar.rb").cleanpath.to_s).and_return("bar 0")
       expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/02-strings.rb").cleanpath.to_s).and_return("strings 0")
+      allow(app).to receive(:apply_config).with("", etc_chef_client_rb) # for chef-client managed nodes running this spec
       expect(app).to receive(:apply_config).with("foo 0", Pathname.new("#{client_d_dir}/00-foo.rb").cleanpath.to_s).and_call_original.ordered
       expect(app).to receive(:apply_config).with("bar 0", Pathname.new("#{client_d_dir}/01-bar.rb").cleanpath.to_s).and_call_original.ordered
       expect(app).to receive(:apply_config).with("strings 0", Pathname.new("#{client_d_dir}/02-strings.rb").cleanpath.to_s).and_call_original.ordered
@@ -51,7 +53,7 @@ shared_examples_for "an application that loads a dot d" do
   context "when client_d_dir is set to a directory without configuration" do
     let(:client_d_dir) do
       Chef::Util::PathHelper.cleanpath(
-        File.join(File.dirname(__FILE__), "../../data/client.d_01")
+        File.join(__dir__, "../../data/client.d_01")
       )
     end
 
@@ -69,7 +71,7 @@ shared_examples_for "an application that loads a dot d" do
     # foo.rb as a directory should be ignored
     let(:client_d_dir) do
       Chef::Util::PathHelper.cleanpath(
-        File.join(File.dirname(__FILE__), "../../data/client.d_02")
+        File.join(__dir__, "../../data/client.d_02")
       )
     end
 

data/spec/support/shared/unit/script_resource.rb

@@ -47,21 +47,6 @@ shared_examples_for "a script resource" do
   end
 
   describe "when executing guards" do
-    let(:resource) do
-      resource = script_resource
-      resource.run_context = run_context
-      resource.code "echo hi"
-      resource
-    end
-    let(:node) do
-      node = Chef::Node.new
-      node.automatic[:platform] = "debian"
-      node.automatic[:platform_version] = "6.0"
-      node
-    end
-    let(:events) { Chef::EventDispatch::Dispatcher.new }
-    let(:run_context) { Chef::RunContext.new(node, {}, events) }
-
     it "inherits exactly the :cwd, :environment, :group, :path, :user, and :umask attributes from a parent resource class" do
       inherited_difference = Chef::Resource::Script.guard_inherited_attributes -
         %i{cwd environment group path user umask}
@@ -73,16 +58,17 @@ shared_examples_for "a script resource" do
       expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate_block)
       expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).not_to receive(:evaluate_action)
       expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:evaluate).and_return(true)
-      resource.only_if "echo hi"
-      expect(resource.should_skip?(:run)).to eq(nil)
+      script_resource.only_if "echo hi"
+      expect(script_resource.should_skip?(:run)).to eq(nil)
     end
 
     it "when a valid guard_interpreter resource is specified, a block should be used to evaluate the guard" do
+      expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate_block)
       expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:evaluate)
       expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
-      resource.guard_interpreter :script
-      resource.only_if "echo hi"
-      expect(resource.should_skip?(:run)).to eq(nil)
+      script_resource.guard_interpreter :script
+      script_resource.only_if "echo hi"
+      expect(script_resource.should_skip?(:run)).to eq(nil)
     end
   end
 end

data/spec/support/shared/unit/windows_script_resource.rb

@@ -20,59 +20,46 @@ require "support/shared/unit/execute_resource"
 require "support/shared/unit/script_resource"
 
 shared_examples_for "a Windows script resource" do
-  before(:each) do
-    node = Chef::Node.new
-
-    node.default["kernel"] = {}
-    node.default["kernel"][:machine] = :x86_64.to_s
-
-    run_context = Chef::RunContext.new(node, nil, nil)
-
-    @resource = resource_instance
-
-  end
-
   it "should be a kind of Chef::Resource::WindowsScript" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::WindowsScript)
+    expect(windows_script_resource).to be_a_kind_of(Chef::Resource)
+    expect(windows_script_resource).to be_a_kind_of(Chef::Resource::WindowsScript)
   end
 
   context "when evaluating guards" do
     it "should have a default_guard_interpreter attribute that is the same as the resource" do
-      expect(@resource.default_guard_interpreter).to eq(@resource.resource_name)
+      expect(windows_script_resource.default_guard_interpreter).to eq(windows_script_resource.resource_name)
     end
 
     it "should default to using guard_interpreter attribute that is the same as the resource" do
-      expect(@resource.guard_interpreter).to eq(@resource.resource_name)
+      expect(windows_script_resource.guard_interpreter).to eq(windows_script_resource.resource_name)
     end
 
     it "should use a resource to evaluate the guard when guard_interpreter is not specified" do
       expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
       expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:evaluate)
-      @resource.only_if "echo hi"
-      expect(@resource.should_skip?(:run)).to eq(nil)
+      windows_script_resource.only_if "echo hi"
+      expect(windows_script_resource.should_skip?(:run)).to eq(nil)
     end
 
     describe "when the guard is given a ruby block" do
       it "should evaluate the guard if the guard_interpreter is set to its default value" do
-        @resource.only_if { true }
-        expect(@resource.should_skip?(:run)).to eq(nil)
+        windows_script_resource.only_if { true }
+        expect(windows_script_resource.should_skip?(:run)).to eq(nil)
       end
 
       it "should raise an exception if the guard_interpreter is overridden from its default value" do
-        @resource.guard_interpreter :bash
-        @resource.only_if { true }
-        expect { @resource.should_skip?(:run) }.to raise_error(ArgumentError)
+        windows_script_resource.guard_interpreter :bash
+        windows_script_resource.only_if { true }
+        expect { windows_script_resource.should_skip?(:run) }.to raise_error(ArgumentError)
       end
     end
   end
 
   context "script with a default guard interpreter" do
-    let(:script_resource) do
-      resource_instance.guard_interpreter :default
-      resource_instance
-    end
+    let(:script_resource) { windows_script_resource }
+
+    before { windows_script_resource.guard_interpreter :default }
+
     it_should_behave_like "a script resource"
   end
-
 end

data/spec/tiny_server.rb

@@ -19,7 +19,6 @@
 require "webrick"
 require "webrick/https"
 require "rack"
-require "thread"
 require "singleton"
 require "open-uri"
 require "chef/config"

data/spec/unit/application/client_spec.rb

@@ -192,7 +192,7 @@ describe Chef::Application::Client, "reconfigure" do
 
       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")
+          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option ""', ChefConfig::ConfigurationError.new).and_raise("so ded")
           ARGV.replace(["--config-option", ""])
           expect { app.reconfigure }.to raise_error "so ded"
         end
@@ -200,7 +200,7 @@ describe Chef::Application::Client, "reconfigure" do
 
       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")
+          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option "asdf"', ChefConfig::ConfigurationError.new).and_raise("so ded")
           ARGV.replace(["--config-option", "asdf"])
           expect { app.reconfigure }.to raise_error "so ded"
         end

data/spec/unit/application/exit_code_spec.rb

@@ -61,6 +61,10 @@ describe Chef::Application::ExitCode do
       expect(valid_rfc_exit_codes.include?(41)).to eq(true)
     end
 
+    it "validates a CONFIG_FAILURE return code of 43" do
+      expect(valid_rfc_exit_codes.include?(43)).to eq(true)
+    end
+
     it "validates a CLIENT_UPGRADED return code of 213" do
       expect(valid_rfc_exit_codes.include?(213)).to eq(true)
     end
@@ -113,6 +117,12 @@ describe Chef::Application::ExitCode do
       expect(exit_codes.normalize_exit_code(runtime_error)).to eq(37)
     end
 
+    it "returns CONFIG_FAILURE when a configuration exception is specified" do
+      config_error = Chef::Exceptions::ConfigurationError.new("BOOM")
+      runtime_error = Chef::Exceptions::RunFailedWrappingError.new(config_error)
+      expect(exit_codes.normalize_exit_code(runtime_error)).to eq(43)
+    end
+
     it "returns CLIENT_UPGRADED when the client was upgraded during converge" do
       client_upgraded_error = Chef::Exceptions::ClientUpgraded.new("BOOM")
       runtime_error = Chef::Exceptions::RunFailedWrappingError.new(client_upgraded_error)

data/spec/unit/application_spec.rb

@@ -491,16 +491,14 @@ describe Chef::Application do
 
   describe "configuration errors" do
     before do
-      expect(Process).to receive(:exit)
+      allow(Process).to receive(:exit).and_return(true)
     end
 
     def raises_informative_fatals_on_configure_chef
       config_file_regexp = Regexp.new @app.config[:config_file]
-      expect(Chef::Log).to receive(:fatal)
-        .with(/Configuration error/)
-      expect(Chef::Log).to receive(:fatal)
-        .with(config_file_regexp)
-        .at_least(1).times
+      expect(Chef::Log).to receive(:fatal).with(/Configuration error/)
+      expect(Chef::Log).to receive(:fatal).with(config_file_regexp)
+      expect(Process).to receive(:exit).with(43).and_return(true)
       @app.configure_chef
     end
 

data/spec/unit/chef_fs/config_spec.rb

@@ -18,7 +18,7 @@
 
 require "spec_helper"
 require "chef/exceptions"
-require "lib/chef/chef_fs/config.rb"
+require "lib/chef/chef_fs/config"
 
 describe Chef::ChefFS::Config do
   describe "initialize" do

data/spec/unit/chef_fs/data_handler/data_bag_item_data_handler.rb

@@ -17,7 +17,7 @@
 #
 
 require "spec_helper"
-require "lib/chef/chef_fs/data_handler/data_bag_item_data_handler.rb"
+require "lib/chef/chef_fs/data_handler/data_bag_item_data_handler"
 
 class TestDataBag < Mash
   attr_accessor :name

data/spec/unit/chef_fs/parallelizer_spec.rb

@@ -1,7 +1,11 @@
 require "spec_helper"
 require "chef/chef_fs/parallelizer"
 
-describe Chef::ChefFS::Parallelizer do
+# FIXME: these are disabled on MacOS due to timing issues in our anka build cluster
+# these issues should be fixed and the tests should be re-eenabled.  If we are getting
+# omnibus test phases on mac tests which are reasonable and not ~3 hours long, then the
+# condition to avoid this testing on macs can be deleted
+describe Chef::ChefFS::Parallelizer, :not_supported_on_macos do
   before :each do
     @start_time = Time.now
   end

data/spec/unit/chef_fs/path_util_spec.rb

@@ -61,7 +61,7 @@ describe Chef::ChefFS::PathUtils do
   end
 
   context "invoking realest_path" do
-    let(:good_path) { File.dirname(__FILE__) }
+    let(:good_path) { __dir__ }
     let(:parent_path) { File.dirname(good_path) }
 
     it "handles paths with no wildcards or globs" do

data/spec/unit/cookbook/synchronizer_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "chef/cookbook/synchronizer"
 require "chef/cookbook_version"
-require "chef/dist"
+require "chef-utils/dist"
 
 describe Chef::CookbookCacheCleaner do
   describe "when cleaning up unused cookbook components" do
@@ -50,7 +50,7 @@ describe Chef::CookbookCacheCleaner do
       cleaner.cleanup_file_cache
     end
 
-    it "does not remove anything on #{Chef::Dist::SOLOEXEC}" do
+    it "does not remove anything on #{ChefUtils::Dist::Solo::EXEC}" do
       Chef::Config[:solo_legacy_mode] = true
       allow(cleaner.cache).to receive(:find).and_return(%w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb})
       expect(cleaner.cache).not_to receive(:delete)

data/spec/unit/cookbook_spec.rb

@@ -19,10 +19,10 @@
 require "spec_helper"
 
 describe Chef::CookbookVersion do
-  COOKBOOK_PATH = File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "cookbooks", "openldap"))
+  COOKBOOK_PATH = File.expand_path(File.join(__dir__, "..", "data", "cookbooks", "openldap"))
 
   before(:each) do
-    @cookbook_repo = File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "cookbooks"))
+    @cookbook_repo = File.expand_path(File.join(__dir__, "..", "data", "cookbooks"))
     cl = Chef::CookbookLoader.new(@cookbook_repo)
     cl.load_cookbooks
     @cookbook_collection = Chef::CookbookCollection.new(cl)

data/spec/unit/data_collector/config_validation_spec.rb

@@ -0,0 +1,208 @@
+#
+# 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 "chef/data_collector/config_validation"
+
+describe Chef::DataCollector::ConfigValidation do
+  describe "#should_be_enabled?" do
+    shared_examples_for "a solo-like run" do
+      it "is disabled in solo-legacy without a data_collector url and token" do
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+      end
+
+      it "is disabled in solo-legacy with only a url" do
+        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+      end
+
+      it "is disabled in solo-legacy with only a token" do
+        Chef::Config[:data_collector][:token] = "admit_one"
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+      end
+
+      it "is enabled in solo-legacy with both a token and url" do
+        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+        Chef::Config[:data_collector][:token] = "no_cash_value"
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+      end
+
+      it "is enabled in solo-legacy with only an output location to a file" do
+        Chef::Config[:data_collector][:output_locations] = { files: [ "/always/be/counting/down" ] }
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+      end
+
+      it "is disabled in solo-legacy with only an output location to a uri" do
+        Chef::Config[:data_collector][:output_locations] = { urls: [ "https://esa.local/ariane5" ] }
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+      end
+
+      it "is enabled in solo-legacy with only an output location to a uri with a token" do
+        Chef::Config[:data_collector][:output_locations] = { urls: [ "https://esa.local/ariane5" ] }
+        Chef::Config[:data_collector][:token] = "good_for_one_fare"
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+      end
+
+      it "is enabled in solo-legacy when the mode is :solo" do
+        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+        Chef::Config[:data_collector][:token] = "non_redeemable"
+        Chef::Config[:data_collector][:mode] = :solo
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+      end
+
+      it "is enabled in solo-legacy when the mode is :both" do
+        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+        Chef::Config[:data_collector][:token] = "non_negotiable"
+        Chef::Config[:data_collector][:mode] = :both
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+      end
+
+      it "is disabled in solo-legacy when the mode is :client" do
+        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+        Chef::Config[:data_collector][:token] = "NYCTA"
+        Chef::Config[:data_collector][:mode] = :client
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+      end
+
+      it "is disabled in solo-legacy mode when the mode is :nonsense" do
+        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+        Chef::Config[:data_collector][:token] = "MTA"
+        Chef::Config[:data_collector][:mode] = :nonsense
+        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+      end
+    end
+
+    it "by default it is enabled" do
+      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+    end
+
+    it "is disabled in why-run" do
+      Chef::Config[:why_run] = true
+      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+    end
+
+    describe "a solo legacy run" do
+      before(:each) do
+        Chef::Config[:solo_legacy_mode] = true
+      end
+
+      it_behaves_like "a solo-like run"
+    end
+
+    describe "a local mode run" do
+      before(:each) do
+        Chef::Config[:local_mode] = true
+      end
+
+      it_behaves_like "a solo-like run"
+    end
+
+    it "is enabled in client mode when the mode is :both" do
+      Chef::Config[:data_collector][:mode] = :both
+      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+    end
+
+    it "is disabled in client mode when the mode is :solo" do
+      Chef::Config[:data_collector][:mode] = :solo
+      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+    end
+
+    it "is disabled in client mode when the mode is :nonsense" do
+      Chef::Config[:data_collector][:mode] = :nonsense
+      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
+    end
+
+    it "is still enabled if you set a token in client mode" do
+      Chef::Config[:data_collector][:token] =  "good_for_one_ride"
+      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
+    end
+  end
+
+  describe "validate_server_url!" do
+    it "with valid server url" do
+      Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+      expect(Chef::DataCollector::ConfigValidation.validate_server_url!).to be_nil
+    end
+
+    it "with invalid server URL" do
+      Chef::Config[:data_collector][:server_url] = "not valid URL"
+      expect { Chef::DataCollector::ConfigValidation.validate_server_url! }.to raise_error(Chef::Exceptions::ConfigurationError,
+         "Chef::Config[:data_collector][:server_url] (not valid URL) is not a valid URI.")
+    end
+
+    it "with invalid server URL without host" do
+      Chef::Config[:data_collector][:server_url] = "no-host"
+      expect { Chef::DataCollector::ConfigValidation.validate_server_url! }.to raise_error(Chef::Exceptions::ConfigurationError,
+         "Chef::Config[:data_collector][:server_url] (no-host) is a URI with no host. Please supply a valid URL.")
+    end
+
+    it "skip validation if output_locations is set" do
+      Chef::Config[:data_collector][:output_locations] = { files: ["https://www.esa.local/ariane5"] }
+      expect(Chef::DataCollector::ConfigValidation.validate_server_url!).to be_nil
+    end
+
+    it "skip validation if output_locations & server_url both are set" do
+      Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
+      Chef::Config[:data_collector][:output_locations] = { files: ["https://www.esa.local/ariane5"] }
+      expect(Chef::DataCollector::ConfigValidation.validate_server_url!).to be_nil
+    end
+  end
+
+  describe "validate_output_locations!" do
+    it "with nil or not set skip validation" do
+      Chef::Config[:data_collector][:output_locations] = nil
+      expect(Chef::DataCollector::ConfigValidation.validate_output_locations!).to be_nil
+    end
+
+    it "with empty value raise validation error" do
+      Chef::Config[:data_collector][:output_locations] = {}
+      expect { Chef::DataCollector::ConfigValidation.validate_output_locations! }.to raise_error(Chef::Exceptions::ConfigurationError,
+        "Chef::Config[:data_collector][:output_locations] is empty. Please supply an hash of valid URLs and / or local file paths.")
+    end
+
+    it "with valid URLs options" do
+      Chef::Config[:data_collector][:output_locations] = { urls: ["https://www.esa.local/ariane5/data-collector"] }
+      expect { Chef::DataCollector::ConfigValidation.validate_output_locations! }.not_to raise_error
+    end
+
+    context "output_locations contains files" do
+      let(:file_path) { "/tmp/client-runs.txt" }
+
+      before(:each) do
+        allow(File).to receive(:exist?).with(file_path).and_return(true)
+        allow(File).to receive(:readable?).with(file_path).and_return(true)
+        allow(File).to receive(:writable?).with(file_path).and_return(true)
+        allow(File).to receive(:expand_path).with(file_path).and_return(file_path)
+      end
+
+      it "with valid files options" do
+        Chef::Config[:data_collector][:output_locations] = { files: [file_path] }
+        expect { Chef::DataCollector::ConfigValidation.validate_output_locations! }.not_to raise_error
+      end
+
+      it "with valid files & URLs options" do
+        Chef::Config[:data_collector][:output_locations] = { urls: ["https://www.esa.local/ariane5/data-collector"], files: [file_path] }
+        expect { Chef::DataCollector::ConfigValidation.validate_output_locations! }.not_to raise_error
+      end
+
+      it "with valid files options & String location value" do
+        Chef::Config[:data_collector][:output_locations] = { files: file_path }
+        expect { Chef::DataCollector::ConfigValidation.validate_output_locations! }.not_to raise_error
+      end
+    end
+  end
+end