chef 12.0.0.alpha.1-x86-mingw32 → 12.0.0.alpha.2-x86-mingw32

data/spec/unit/knife/core/bootstrap_context_spec.rb

@@ -33,10 +33,6 @@ describe Chef::Knife::Core::BootstrapContext do
 
   subject(:bootstrap_context) { described_class.new(config, run_list, chef_config) }
 
-  it "installs the same version of chef on the remote host" do
-    bootstrap_context.bootstrap_version_string.should eq "--version #{Chef::VERSION}"
-  end
-
   it "runs chef with the first-boot.json in the _default environment" do
     bootstrap_context.start_chef.should eq "chef-client -j /etc/chef/first-boot.json -E _default"
   end
@@ -95,24 +91,6 @@ EXPECTED
     end
   end
 
-  describe "when installing a prerelease version of chef" do
-    let(:config){ {:prerelease => true }}
-    it "supplies --prerelease as the version string" do
-      bootstrap_context.bootstrap_version_string.should eq '--prerelease'
-    end
-  end
-
-  describe "when installing an explicit version of chef" do
-    let(:chef_config) do
-      {
-        :knife => { :bootstrap_version => '123.45.678' }
-      }
-    end
-    it "gives --version $VERSION as the version string" do
-      bootstrap_context.bootstrap_version_string.should eq '--version 123.45.678'
-    end
-  end
-
   describe "when JSON attributes are given" do
     let(:config) { {:first_boot_attributes => {:baz => :quux}} }
     it "adds the attributes to first_boot" do
@@ -141,7 +119,20 @@ EXPECTED
     context "via config[:secret_file]" do
       let(:chef_config) do
         {
-          :knife => {:secret_file =>  secret_file}
+          :knife => {:secret_file => secret_file}
+        }
+      end
+      it "reads the encrypted_data_bag_secret" do
+        bootstrap_context.encrypted_data_bag_secret.should eq IO.read(secret_file)
+      end
+    end
+
+    context "via config[:secret_file] with short home path" do
+      let(:chef_config) do
+        home_path = File.expand_path("~")
+        shorted_secret_file_path = secret_file.gsub(home_path, "~")
+        {
+          :knife => {:secret_file => shorted_secret_file_path}
         }
       end
       it "reads the encrypted_data_bag_secret" do
@@ -158,13 +149,6 @@ EXPECTED
     it "sets the @run_list instance variable" do
       bootstrap_context.instance_variable_get(:@run_list).should eq run_list
     end
-
-    describe "accepts encrypted_data_bag_secret via Chef::Config" do
-      let(:chef_config) { {:encrypted_data_bag_secret => secret_file }}
-      it "reads the encrypted_data_bag_secret" do
-        bootstrap_context.encrypted_data_bag_secret.should eq IO.read(secret_file)
-      end
-    end
   end
 
   describe "when a bootstrap_version is specified" do
@@ -197,4 +181,57 @@ EXPECTED
       bootstrap_context.latest_current_chef_version_string.should eq("-v #{Chef::VERSION.to_i}")
     end
   end
+
+  describe "ssl_verify_mode" do
+    it "isn't set in the config_content by default" do
+      bootstrap_context.config_content.should_not include("ssl_verify_mode")
+    end
+
+    describe "when configured in config" do
+      let(:chef_config) do
+        {
+          :knife => {:ssl_verify_mode => :verify_peer}
+        }
+      end
+
+      it "uses the config value" do
+        bootstrap_context.config_content.should include("ssl_verify_mode :verify_peer")
+      end
+
+      describe "when configured via CLI" do
+        let(:config) {{:node_ssl_verify_mode => "none"}}
+
+        it "uses CLI value" do
+          bootstrap_context.config_content.should include("ssl_verify_mode :verify_none")
+        end
+      end
+    end
+  end
+
+  describe "verify_api_cert" do
+    it "isn't set in the config_content by default" do
+      bootstrap_context.config_content.should_not include("verify_api_cert")
+    end
+
+    describe "when configured in config" do
+      let(:chef_config) do
+        {
+          :knife => {:verify_api_cert => :false}
+        }
+      end
+
+      it "uses the config value" do
+        bootstrap_context.config_content.should include("verify_api_cert false")
+      end
+
+      describe "when configured via CLI" do
+        let(:config) {{:node_verify_api_cert => true}}
+
+        it "uses CLI value" do
+          bootstrap_context.config_content.should include("verify_api_cert true")
+        end
+      end
+    end
+  end
+
 end

data/spec/unit/knife_spec.rb

@@ -44,34 +44,6 @@ describe Chef::Knife do
     @stderr = StringIO.new
   end
 
-  describe "selecting a config file" do
-    context "when the current working dir is inside a symlinked directory" do
-      before do
-        Chef::Knife.reset_config_path!
-        # pwd according to your shell is /home/someuser/prod/chef-repo, but
-        # chef-repo is a symlink to /home/someuser/codes/chef-repo
-        if Chef::Platform.windows?
-          ENV.should_receive(:[]).with("CD").and_return("/home/someuser/prod/chef-repo")
-        else
-          ENV.should_receive(:[]).with("PWD").and_return("/home/someuser/prod/chef-repo")
-        end
-
-        Dir.stub(:pwd).and_return("/home/someuser/codes/chef-repo")
-      end
-
-      after do
-        Chef::Knife.reset_config_path!
-      end
-
-      it "loads the config from the non-dereferenced directory path" do
-        File.should_receive(:exist?).with("/home/someuser/prod/chef-repo/.chef").and_return(false)
-        File.should_receive(:exist?).with("/home/someuser/prod/.chef").and_return(true)
-        File.should_receive(:directory?).with("/home/someuser/prod/.chef").and_return(true)
-        Chef::Knife.chef_config_dir.should == "/home/someuser/prod/.chef"
-      end
-    end
-  end
-
   describe "after loading a subcommand" do
     before do
       Chef::Knife.reset_subcommands!
@@ -247,7 +219,7 @@ describe Chef::Knife do
     end
 
     it "loads lazy dependencies" do
-      command = Chef::Knife.run(%w{test yourself})
+      Chef::Knife.run(%w{test yourself})
       KnifeSpecs::TestYourself.test_deps_loaded.should be_true
     end
 
@@ -256,7 +228,8 @@ describe Chef::Knife do
       KnifeSpecs::TestYourself.class_eval do
         deps { other_deps_loaded = true }
       end
-      command = Chef::Knife.run(%w{test yourself})
+
+      Chef::Knife.run(%w{test yourself})
       KnifeSpecs::TestYourself.test_deps_loaded.should be_true
       other_deps_loaded.should be_true
     end

data/spec/unit/mixin/deep_merge_spec.rb

@@ -236,6 +236,20 @@ describe Chef::Mixin::DeepMerge, "deep_merge!" do
     @dm.deep_merge!(hash_src, hash_dst)
     hash_dst.should == {"item" => "orange"}
   end
+
+  it 'should overwrite hashes with nil' do
+    hash_src = {"item" => { "1" => "2"}, "other" => true }
+    hash_dst = {"item" => nil }
+    @dm.deep_merge!(hash_src, hash_dst)
+    hash_dst.should == {"item" => nil, "other" => true }
+  end
+
+  it 'should overwrite strings with nil' do
+    hash_src = {"item" => "to_overwrite", "other" => false }
+    hash_dst = {"item" => nil }
+    @dm.deep_merge!(hash_src, hash_dst)
+    hash_dst.should == {"item" => nil, "other" => false }
+  end
 end # deep_merge!
 
 # Chef specific

data/spec/unit/mixin/shell_out_spec.rb

@@ -32,7 +32,7 @@ describe Chef::Mixin::ShellOut do
 
     let(:output) { StringIO.new }
     let!(:capture_log_output) { Chef::Log.logger = Logger.new(output)  }
-    let(:assume_deprecation_log_level) { Chef::Log.stub(:level).and_return(:warn) }
+    let(:assume_deprecation_log_level) { allow(Chef::Log).to receive(:level).and_return(:warn) }
 
     context 'without options' do
       let(:command_args) { [ cmd ] }
@@ -55,9 +55,9 @@ describe Chef::Mixin::ShellOut do
       it 'should emit a deprecation warning' do
         assume_deprecation_log_level and capture_log_output
         subject
-        output.string.should match /DEPRECATION:/
-        output.string.should match Regexp.escape(old_option.to_s)
-        output.string.should match Regexp.escape(new_option.to_s)
+        expect(output.string).to match /DEPRECATION:/
+        expect(output.string).to match Regexp.escape(old_option.to_s)
+        expect(output.string).to match Regexp.escape(new_option.to_s)
       end
     end
 
@@ -106,7 +106,7 @@ describe Chef::Mixin::ShellOut do
     end
   end
 
-  describe "#shell_out_with_systems_locale" do
+  context "when testing individual methods" do
     before(:each) do
       @original_env = ENV.to_hash
       ENV.clear
@@ -120,82 +120,152 @@ describe Chef::Mixin::ShellOut do
     let(:shell_out) { Chef::Mixin::ShellOut }
     let(:cmd) { "echo '#{rand(1000)}'" }
 
-    describe "when the last argument is a Hash" do
-      describe "and environment is an option" do
-        it "should not change environment['LC_ALL'] when set to nil" do
-          options = { :environment => { 'LC_ALL' => nil } }
-          shell_out.should_receive(:shell_out).with(cmd, options).and_return(true)
-          shell_out.shell_out_with_systems_locale(cmd, options)
+    describe "#shell_out" do
+
+      describe "when the last argument is a Hash" do
+        describe "and environment is an option" do
+          it "should not change environment['LC_ALL'] when set to nil" do
+            options = { :environment => { 'LC_ALL' => nil } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out(cmd, options)
+          end
+
+          it "should not change environment['LC_ALL'] when set to non-nil" do
+            options = { :environment => { 'LC_ALL' => 'en_US.UTF-8' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out(cmd, options)
+          end
+
+          it "should set environment['LC_ALL'] to 'en_US.UTF-8' when 'LC_ALL' not present" do
+            options = { :environment => { 'HOME' => '/Users/morty' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, {
+              :environment => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+            }).and_return(true)
+            shell_out.shell_out(cmd, options)
+          end
+
+          it "should not mutate the options hash when it adds LC_ALL" do
+            options = { :environment => { 'HOME' => '/Users/morty' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, {
+              :environment => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+            }).and_return(true)
+            shell_out.shell_out(cmd, options)
+            expect(options[:environment].has_key?('LC_ALL')).to be false
+          end
         end
 
-        it "should not change environment['LC_ALL'] when set to non-nil" do
-          options = { :environment => { 'LC_ALL' => 'en_US.UTF-8' } }
-          shell_out.should_receive(:shell_out).with(cmd, options).and_return(true)
-          shell_out.shell_out_with_systems_locale(cmd, options)
+        describe "and env is an option" do
+          it "should not change env when set to nil" do
+            options = { :env => { 'LC_ALL' => nil } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out(cmd, options)
+          end
+
+          it "should not change env when set to non-nil" do
+            options = { :env => { 'LC_ALL' => 'de_DE.UTF-8'}}
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out(cmd, options)
+          end
+
+          it "should set env['LC_ALL'] to 'en_US.UTF-8' when 'LC_ALL' not present" do
+            options = { :env => { 'HOME' => '/Users/morty' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, {
+              :env => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+            }).and_return(true)
+            shell_out.shell_out(cmd, options)
+          end
+
+          it "should not mutate the options hash when it adds LC_ALL" do
+            options = { :env => { 'HOME' => '/Users/morty' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, {
+              :env => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+            }).and_return(true)
+            shell_out.shell_out(cmd, options)
+            expect(options[:env].has_key?('LC_ALL')).to be false
+          end
         end
 
-        it "should set environment['LC_ALL'] to nil when 'LC_ALL' not present" do
-          options = { :environment => { 'HOME' => '/Users/morty' } }
-          shell_out.should_receive(:shell_out).with(
-            cmd,
-            { :environment => {
-                'HOME' => '/Users/morty',
-                'LC_ALL' => nil }
-            }
-          ).and_return(true)
-          shell_out.shell_out_with_systems_locale(cmd, options)
+        describe "and no env/environment option is present" do
+          it "should add environment option and set environment['LC_ALL'] to 'en_US.UTF_8'" do
+            options = { :user => 'morty' }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, {
+              :user => 'morty', :environment => { 'LC_ALL' => Chef::Config[:internal_locale] },
+            }).and_return(true)
+            shell_out.shell_out(cmd, options)
+          end
         end
       end
 
-      describe "and env is an option" do
-        it "should not change env when set to nil" do
-          options = { :env => { 'LC_ALL' => nil } }
-          shell_out.should_receive(:shell_out).with(cmd, options).and_return(true)
-          shell_out.shell_out_with_systems_locale(cmd, options)
+      describe "when the last argument is not a Hash" do
+        it "should add environment options and set environment['LC_ALL'] to 'en_US.UTF-8'" do
+          expect(shell_out).to receive(:shell_out_command).with(cmd, {
+            :environment => { 'LC_ALL' => Chef::Config[:internal_locale] },
+          }).and_return(true)
+          shell_out.shell_out(cmd)
         end
+      end
+
+    end
 
-        it "should not change env when set to non-nil" do
-          options = { :env => { 'LC_ALL' => 'en_US.UTF-8'}}
-          shell_out.should_receive(:shell_out).with(cmd, options).and_return(true)
-          shell_out.shell_out_with_systems_locale(cmd, options)
+    describe "#shell_out_with_systems_locale" do
+
+      describe "when the last argument is a Hash" do
+        describe "and environment is an option" do
+          it "should not change environment['LC_ALL'] when set to nil" do
+            options = { :environment => { 'LC_ALL' => nil } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out_with_systems_locale(cmd, options)
+          end
+
+          it "should not change environment['LC_ALL'] when set to non-nil" do
+            options = { :environment => { 'LC_ALL' => 'en_US.UTF-8' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out_with_systems_locale(cmd, options)
+          end
+
+          it "should no longer set environment['LC_ALL'] to nil when 'LC_ALL' not present" do
+            options = { :environment => { 'HOME' => '/Users/morty' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out_with_systems_locale(cmd, options)
+          end
         end
 
-        it "should set env['LC_ALL'] to nil when 'LC_ALL' not present" do
-          options = { :env => { 'HOME' => '/Users/morty' } }
-          shell_out.should_receive(:shell_out).with(
-            cmd,
-            { :env => {
-                'HOME' => '/Users/morty',
-                'LC_ALL' => nil }
-            }
-          ).and_return(true)
-          shell_out.shell_out_with_systems_locale(cmd, options)
+        describe "and env is an option" do
+          it "should not change env when set to nil" do
+            options = { :env => { 'LC_ALL' => nil } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out_with_systems_locale(cmd, options)
+          end
+
+          it "should not change env when set to non-nil" do
+            options = { :env => { 'LC_ALL' => 'en_US.UTF-8'}}
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out_with_systems_locale(cmd, options)
+          end
+
+          it "should no longer set env['LC_ALL'] to nil when 'LC_ALL' not present" do
+            options = { :env => { 'HOME' => '/Users/morty' } }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out_with_systems_locale(cmd, options)
+          end
         end
-      end
 
-      describe "and no env/environment option is present" do
-        it "should add environment option and set environment['LC_ALL'] to nil" do
-          options = { :user => 'morty' }
-          shell_out.should_receive(:shell_out).with(
-            cmd,
-            { :environment => { 'LC_ALL' => nil },
-              :user => 'morty'
-            }
-          ).and_return(true)
-          shell_out.shell_out_with_systems_locale(cmd, options)
+        describe "and no env/environment option is present" do
+          it "should no longer add environment option and set environment['LC_ALL'] to nil" do
+            options = { :user => 'morty' }
+            expect(shell_out).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out.shell_out_with_systems_locale(cmd, options)
+          end
         end
       end
-    end
 
-    describe "when the last argument is not a Hash" do
-      it "should add environment options and set environment['LC_ALL'] to nil" do
-        shell_out.should_receive(:shell_out).with(
-          cmd,
-          { :environment => { 'LC_ALL' => nil } }
-        ).and_return(true)
-        shell_out.shell_out_with_systems_locale(cmd)
+      describe "when the last argument is not a Hash" do
+        it "should no longer add environment options and set environment['LC_ALL'] to nil" do
+          expect(shell_out).to receive(:shell_out_command).with(cmd).and_return(true)
+          shell_out.shell_out_with_systems_locale(cmd)
+        end
       end
     end
-  end
 
+  end
 end

data/spec/unit/provider/ifconfig/debian_spec.rb

@@ -56,8 +56,6 @@ describe Chef::Provider::Ifconfig::Debian do
   describe "generate_config" do
 
     context "when writing a file" do
-      let(:config_file_ifcfg) { StringIO.new }
-
       let(:tempfile) { Tempfile.new("rspec-chef-ifconfig-debian") }
 
       let(:tempdir_path) { Dir.mktmpdir("rspec-chef-ifconfig-debian-dir") }
@@ -67,14 +65,13 @@ describe Chef::Provider::Ifconfig::Debian do
       before do
         stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_FILE", tempfile.path)
         stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_DOT_D_DIR", tempdir_path)
-        expect(File).to receive(:new).with(config_filename_ifcfg, "w").and_return(config_file_ifcfg)
       end
 
       it "should write a network-script" do
         provider.run_action(:add)
-        expect(config_file_ifcfg.string).to match(/^iface eth0 inet static\s*$/)
-        expect(config_file_ifcfg.string).to match(/^\s+address 10\.0\.0\.1\s*$/)
-        expect(config_file_ifcfg.string).to match(/^\s+netmask 255\.255\.254\.0\s*$/)
+        expect(File.read(config_filename_ifcfg)).to match(/^iface eth0 inet static\s*$/)
+        expect(File.read(config_filename_ifcfg)).to match(/^\s+address 10\.0\.0\.1\s*$/)
+        expect(File.read(config_filename_ifcfg)).to match(/^\s+netmask 255\.255\.254\.0\s*$/)
       end
 
       context "when the interface_dot_d directory does not exist" do
@@ -123,7 +120,6 @@ iface eth0 inet static
   netmask 255.255.254.0
 EOF
         )
-        expect(File).to receive(:new).with(config_filename_ifcfg, "w").and_return(config_file_ifcfg)
         expect(File.exists?(tempdir_path)).to be_true  # since the file exists, the enclosing dir must also exist
       end
 
@@ -139,6 +135,8 @@ EOF
         before do
           tempfile.write(expected_string)
           tempfile.close
+
+          expect(provider).not_to receive(:converge_by).with(/modifying #{tempfile.path} to source #{tempdir_path}/)
         end
 
         it "should preserve all the contents" do
@@ -165,6 +163,9 @@ EOF
         before do
           tempfile.write("a line\nanother line\n")
           tempfile.close
+
+          allow(provider).to receive(:converge_by).and_call_original
+          expect(provider).to receive(:converge_by).with(/modifying #{tempfile.path} to source #{tempdir_path}/).and_call_original
         end
 
         it "should preserve the original contents and add the source line" do
@@ -318,8 +319,17 @@ source #{tempdir_path}/*
 
     it "should delete network-script if it exists" do
       current_resource.device new_resource.device
-      expect(File).to receive(:exist?).with(config_filename_ifcfg).and_return(true)
-      expect(FileUtils).to receive(:rm_f).with(config_filename_ifcfg, :verbose => false)
+
+      [:exist?, :exists?, :writable?].each do |cmd|
+        # need to stub :writable? to make why_run? happy
+        allow(File).to receive(cmd).and_call_original
+        allow(File).to receive(cmd).with(config_filename_ifcfg).and_return(true)
+      end
+
+      # stub for Chef::Util::Backup#do_backup
+      expect(FileUtils).to receive(:cp)
+        .with(config_filename_ifcfg, /#{Chef::Config[:file_backup_path]}/, :preserve => true)
+      expect(File).to receive(:delete).with(config_filename_ifcfg)
 
       provider.run_action(:delete)
     end