chef 11.14.0.alpha.2-x86-mingw32 → 11.14.0.alpha.3-x86-mingw32

data/spec/unit/client_spec.rb

@@ -253,9 +253,11 @@ describe Chef::Client do
       end
 
       def stub_for_node_save
+        node.stub(:data_for_save).and_return(node.for_json)
+
         # --Client#save_updated_node
         Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url]).and_return(http_node_save)
-        http_node_save.should_receive(:put_rest).with("nodes/#{fqdn}", node).and_return(true)
+        http_node_save.should_receive(:put_rest).with("nodes/#{fqdn}", node.for_json).and_return(true)
       end
 
       def stub_for_run
@@ -270,6 +272,7 @@ describe Chef::Client do
 
       before do
         Chef::Config[:client_fork] = enable_fork
+        Chef::Config[:cache_path] = windows? ? 'C:\chef' : '/var/chef'
 
         stub_const("Chef::Client::STDOUT_FD", stdout)
         stub_const("Chef::Client::STDERR_FD", stderr)
@@ -614,4 +617,3 @@ describe Chef::Client do
 
   end
 end
-

data/spec/unit/config_spec.rb

@@ -138,13 +138,71 @@ describe Chef::Config do
   end
 
   describe "default values" do
+    def primary_cache_path
+      if windows?
+        "#{Chef::Config.env['SYSTEMDRIVE']}\\chef"
+      else
+        "/var/chef"
+      end
+    end
 
-    it "Chef::Config[:file_backup_path] defaults to /var/chef/backup" do
-      backup_path = if windows?
-        "#{ENV['SYSTEMDRIVE']}\\chef\\backup"
+    def secondary_cache_path
+      if windows?
+        "#{Chef::Config[:user_home]}\\.chef"
+      else
+        "#{Chef::Config[:user_home]}/.chef"
+      end
+    end
+
+    before do
+      if windows?
+        Chef::Config.stub(:env).and_return({ 'SYSTEMDRIVE' => 'C:' })
+        Chef::Config[:user_home] = 'C:\Users\charlie'
       else
-        "/var/chef/backup"
+        Chef::Config[:user_home] = '/Users/charlie'
+      end
+
+      Chef::Config.stub(:path_accessible?).and_return(false)
+    end
+
+    describe "Chef::Config[:cache_path]" do
+      context "when /var/chef exists and is accessible" do
+        it "defaults to /var/chef" do
+          Chef::Config.stub(:path_accessible?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(true)
+          Chef::Config[:cache_path].should == primary_cache_path
+        end
       end
+
+      context "when /var/chef does not exist and /var is accessible" do
+        it "defaults to /var/chef" do
+          File.stub(:exists?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(false)
+          Chef::Config.stub(:path_accessible?).with(Chef::Config.platform_specific_path("/var")).and_return(true)
+          Chef::Config[:cache_path].should == primary_cache_path
+        end
+      end
+
+      context "when /var/chef does not exist and /var is not accessible" do
+        it "defaults to $HOME/.chef" do
+          File.stub(:exists?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(false)
+          Chef::Config.stub(:path_accessible?).with(Chef::Config.platform_specific_path("/var")).and_return(false)
+          Chef::Config[:cache_path].should == secondary_cache_path
+        end
+      end
+
+      context "when /var/chef exists and is not accessible" do
+        it "defaults to $HOME/.chef" do
+          File.stub(:exists?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(true)
+          File.stub(:readable?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(true)
+          File.stub(:writable?).with(Chef::Config.platform_specific_path("/var/chef")).and_return(false)
+
+          Chef::Config[:cache_path].should == secondary_cache_path
+        end
+      end
+    end
+
+    it "Chef::Config[:file_backup_path] defaults to /var/chef/backup" do
+      Chef::Config.stub(:cache_path).and_return(primary_cache_path)
+      backup_path = windows? ? "#{primary_cache_path}\\backup" : "#{primary_cache_path}/backup"
       Chef::Config[:file_backup_path].should == backup_path
     end
 
@@ -167,18 +225,14 @@ describe Chef::Config do
     end
 
     it "Chef::Config[:data_bag_path] defaults to /var/chef/data_bags" do
-      data_bag_path =
-        Chef::Config.platform_specific_path("/var/chef/data_bags")
+      Chef::Config.stub(:cache_path).and_return(primary_cache_path)
+      data_bag_path = windows? ? "#{primary_cache_path}\\data_bags" : "#{primary_cache_path}/data_bags"
       Chef::Config[:data_bag_path].should == data_bag_path
     end
 
     it "Chef::Config[:environment_path] defaults to /var/chef/environments" do
-      environment_path = if windows?
-        "C:\\chef\\environments"
-      else
-        "/var/chef/environments"
-      end
-
+      Chef::Config.stub(:cache_path).and_return(primary_cache_path)
+      environment_path = windows? ? "#{primary_cache_path}\\environments" : "#{primary_cache_path}/environments"
       Chef::Config[:environment_path].should == environment_path
     end
 

data/spec/unit/knife/bootstrap_spec.rb

@@ -376,6 +376,12 @@ describe Chef::Knife::Bootstrap do
       @knife.run
     end
 
+    it "raises the exception if config[:ssh_password] is set and an authentication exception is raised" do
+      @knife.config[:ssh_password] = "password"
+      @knife_ssh.should_receive(:run).and_raise(Net::SSH::AuthenticationFailed)
+      lambda { @knife.run }.should raise_error(Net::SSH::AuthenticationFailed)
+    end
+
     context "Chef::Config[:encrypted_data_bag_secret] is set" do
       let(:secret_file) { File.join(CHEF_SPEC_DATA, 'bootstrap', 'encrypted_data_bag_secret') }
       before { Chef::Config[:encrypted_data_bag_secret] = secret_file }

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

@@ -166,5 +166,35 @@ EXPECTED
       end
     end
   end
-end
 
+  describe "when a bootstrap_version is specified" do
+    let(:chef_config) do
+      {
+        :knife => {:bootstrap_version => "11.12.4" }
+      }
+    end
+
+    it "should send the full version to the installer" do
+      bootstrap_context.latest_current_chef_version_string.should eq("-v 11.12.4")
+    end
+  end
+
+  describe "when a pre-release bootstrap_version is specified" do
+    let(:chef_config) do
+      {
+        :knife => {:bootstrap_version => "11.12.4.rc.0" }
+      }
+    end
+
+    it "should send the full version to the installer and set the pre-release flag" do
+      bootstrap_context.latest_current_chef_version_string.should eq("-v 11.12.4.rc.0 -p")
+    end
+  end
+
+  describe "when a bootstrap_version is not specified" do
+    it "should send the latest current to the installer" do
+      # Intentionally hard coded in order not to replicate the logic.
+      bootstrap_context.latest_current_chef_version_string.should eq("-v 11")
+    end
+  end
+end

data/spec/unit/node_spec.rb

@@ -814,22 +814,25 @@ describe Chef::Node do
     describe "save" do
       it "should update a node if it already exists" do
         node.name("monkey")
-        @rest.should_receive(:put_rest).with("nodes/monkey", node).and_return("foo")
+        node.stub(:data_for_save).and_return({})
+        @rest.should_receive(:put_rest).with("nodes/monkey", {}).and_return("foo")
         node.save
       end
 
       it "should not try and create if it can update" do
         node.name("monkey")
-        @rest.should_receive(:put_rest).with("nodes/monkey", node).and_return("foo")
+        node.stub(:data_for_save).and_return({})
+        @rest.should_receive(:put_rest).with("nodes/monkey", {}).and_return("foo")
         @rest.should_not_receive(:post_rest)
         node.save
       end
 
       it "should create if it cannot update" do
         node.name("monkey")
+        node.stub(:data_for_save).and_return({})
         exception = double("404 error", :code => "404")
         @rest.should_receive(:put_rest).and_raise(Net::HTTPServerException.new("foo", exception))
-        @rest.should_receive(:post_rest).with("nodes", node)
+        @rest.should_receive(:post_rest).with("nodes", {})
         node.save
       end
 
@@ -847,6 +850,73 @@ describe Chef::Node do
           node.save
         end
       end
+
+      context "with whitelisted attributes configured" do
+        it "should only save whitelisted attributes (and subattributes)" do
+          Chef::Config[:automatic_attribute_whitelist] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0"
+          ]
+
+          data = {
+            "automatic" => {
+              "filesystem" => {
+                "/dev/disk0s2"   => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" }
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {}
+                }
+              }
+            },
+            "default" => {}, "normal" => {}, "override" => {}
+          }
+
+          selected_data = {
+            "automatic" => {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" }
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {}
+                }
+              }
+            },
+            "default" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          node.stub(:for_json).and_return(data)
+          @rest.should_receive(:put_rest).with("nodes/picky-monkey", selected_data).and_return("foo")
+          node.save
+        end
+
+        it "should not save any attributes if the whitelist is empty" do
+          Chef::Config[:automatic_attribute_whitelist] = []
+
+          data = {
+            "automatic" => {
+              "filesystem" => {
+                "/dev/disk0s2"   => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" }
+              }
+            },
+            "default" => {}, "normal" => {}, "override" => {}
+          }
+
+          selected_data = {
+            "automatic" => {}, "default" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          node.stub(:for_json).and_return(data)
+          @rest.should_receive(:put_rest).with("nodes/picky-monkey", selected_data).and_return("foo")
+          node.save
+        end
+      end
     end
   end
 

data/spec/unit/provider/mount_spec.rb

@@ -1,6 +1,7 @@
 #
-# Author:: Joshua Timberman (<joshua@opscode.com>)
-# Copyright:: Copyright (c) 2008 OpsCode, Inc.
+# Author:: Joshua Timberman (<joshua@getchef.com>)
+# Author:: Lamont Granquist (<lamont@getchef.com>)
+# Copyright:: Copyright (c) 2008-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,152 +20,174 @@
 require 'spec_helper'
 
 describe Chef::Provider::Mount do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-
-    @new_resource = Chef::Resource::Mount.new('/tmp/foo')
-    @new_resource.device      "/dev/sdz1"
-    @new_resource.name        "/tmp/foo"
-    @new_resource.mount_point "/tmp/foo"
-    @new_resource.fstype      "ext3"
-
-    @current_resource = Chef::Resource::Mount.new('/tmp/foo')
-    @current_resource.device      "/dev/sdz1"
-    @current_resource.name        "/tmp/foo"
-    @current_resource.mount_point "/tmp/foo"
-    @current_resource.fstype      "ext3"
-
-    @provider = Chef::Provider::Mount.new(@new_resource, @run_context)
-    @provider.current_resource = @current_resource
+
+  let(:node) { Chef::Node.new }
+
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+
+  let(:new_resource) do
+    new_resource = Chef::Resource::Mount.new('/tmp/foo')
+    new_resource.device      "/dev/sdz1"
+    new_resource.name        "/tmp/foo"
+    new_resource.mount_point "/tmp/foo"
+    new_resource.fstype      "ext3"
+    new_resource
+  end
+
+  let(:current_resource) do
+    # this abstract superclass has no load_current_resource to call
+    current_resource = Chef::Resource::Mount.new('/tmp/foo')
+    current_resource.device      "/dev/sdz1"
+    current_resource.name        "/tmp/foo"
+    current_resource.mount_point "/tmp/foo"
+    current_resource.fstype      "ext3"
+    current_resource
+  end
+
+  let(:provider) do
+    provider = Chef::Provider::Mount.new(new_resource, run_context)
+    provider.current_resource = current_resource
+    provider
   end
 
   describe "when the target state is a mounted filesystem" do
 
     it "should mount the filesystem if it isn't mounted" do
-      @current_resource.stub(:mounted).and_return(false)
-      @provider.should_receive(:mount_fs).with.and_return(true)
-      @provider.run_action(:mount)
-      @new_resource.should be_updated_by_last_action
+      allow(current_resource).to receive(:mounted).and_return(false)
+      expect(provider).to receive(:mount_fs).and_return(true)
+      provider.run_action(:mount)
+      expect(new_resource).to be_updated_by_last_action
     end
 
     it "should not mount the filesystem if it is mounted" do
-      @current_resource.stub(:mounted).and_return(true)
-      @provider.should_not_receive(:mount_fs)
-      @provider.run_action(:mount)
-      @new_resource.should_not be_updated_by_last_action
+      allow(current_resource).to receive(:mounted).and_return(true)
+      expect(provider).not_to receive(:mount_fs)
+      provider.run_action(:mount)
+      expect(new_resource).not_to be_updated_by_last_action
     end
 
   end
 
   describe "when the target state is an unmounted filesystem" do
     it "should umount the filesystem if it is mounted" do
-      @current_resource.stub(:mounted).and_return(true)
-      @provider.should_receive(:umount_fs).with.and_return(true)
-      @provider.run_action(:umount)
-      @new_resource.should be_updated_by_last_action
+      allow(current_resource).to receive(:mounted).and_return(true)
+      expect(provider).to receive(:umount_fs).and_return(true)
+      provider.run_action(:umount)
+      expect(new_resource).to be_updated_by_last_action
     end
 
     it "should not umount the filesystem if it is not mounted" do
-      @current_resource.stub(:mounted).and_return(false)
-      @provider.should_not_receive(:umount_fs)
-      @provider.run_action(:umount)
-      @new_resource.should_not be_updated_by_last_action
+      allow(current_resource).to receive(:mounted).and_return(false)
+      expect(provider).not_to receive(:umount_fs)
+      provider.run_action(:umount)
+      expect(new_resource).not_to be_updated_by_last_action
     end
   end
 
   describe "when the filesystem should be remounted and the resource supports remounting" do
     before do
-      @new_resource.supports[:remount] = true
+      new_resource.supports[:remount] = true
     end
 
     it "should remount the filesystem if it is mounted" do
-      @current_resource.stub(:mounted).and_return(true)
-      @provider.should_receive(:remount_fs).and_return(true)
-      @provider.run_action(:remount)
-      @new_resource.should be_updated_by_last_action
+      allow(current_resource).to receive(:mounted).and_return(true)
+      expect(provider).to receive(:remount_fs).and_return(true)
+      provider.run_action(:remount)
+      expect(new_resource).to be_updated_by_last_action
     end
 
     it "should not remount the filesystem if it is not mounted" do
-      @current_resource.stub(:mounted).and_return(false)
-      @provider.should_not_receive(:remount_fs)
-      @provider.run_action(:remount)
-      @new_resource.should_not be_updated_by_last_action
+      allow(current_resource).to receive(:mounted).and_return(false)
+      expect(provider).not_to receive(:remount_fs)
+      provider.run_action(:remount)
+      expect(new_resource).not_to be_updated_by_last_action
     end
   end
+
   describe "when the filesystem should be remounted and the resource does not support remounting" do
     before do
-      @new_resource.supports[:remount] = false
+      new_resource.supports[:remount] = false
+      allow(current_resource).to receive(:mounted).and_return(true)
     end
 
-    it "should fail to remount the filesystem" do
-      @provider.should_not_receive(:remount_fs)
-      lambda {@provider.run_action(:remount)}.should raise_error(Chef::Exceptions::UnsupportedAction)
-      @new_resource.should_not be_updated_by_last_action
+    it "should try a umount/remount of the filesystem" do
+      expect(provider).to receive(:umount_fs)
+      expect(provider).to receive(:mounted?).and_return(true, false)
+      expect(provider).to receive(:mount_fs)
+      provider.run_action(:remount)
+      expect(new_resource).to be_updated_by_last_action
     end
 
+    it "should fail when it runs out of remounts" do
+      provider.unmount_retries = 1
+      expect(provider).to receive(:umount_fs)
+      expect(provider).to receive(:mounted?).and_return(true, true)
+      expect{ provider.run_action(:remount) }.to raise_error(Chef::Exceptions::Mount)
+    end
   end
+
   describe "when enabling the filesystem to be mounted" do
     it "should enable the mount if it isn't enable" do
-      @current_resource.stub(:enabled).and_return(false)
-      @provider.should_not_receive(:mount_options_unchanged?)
-      @provider.should_receive(:enable_fs).and_return(true)
-      @provider.run_action(:enable)
-      @new_resource.should be_updated_by_last_action
+      allow(current_resource).to receive(:enabled).and_return(false)
+      expect(provider).not_to receive(:mount_options_unchanged?)
+      expect(provider).to receive(:enable_fs).and_return(true)
+      provider.run_action(:enable)
+      expect(new_resource).to be_updated_by_last_action
     end
 
     it "should enable the mount if it is enabled and mount options have changed" do
-      @current_resource.stub(:enabled).and_return(true)
-      @provider.should_receive(:mount_options_unchanged?).and_return(false)
-      @provider.should_receive(:enable_fs).and_return(true)
-      @provider.run_action(:enable)
-      @new_resource.should be_updated_by_last_action
+      allow(current_resource).to receive(:enabled).and_return(true)
+      expect(provider).to receive(:mount_options_unchanged?).and_return(false)
+      expect(provider).to receive(:enable_fs).and_return(true)
+      provider.run_action(:enable)
+      expect(new_resource).to be_updated_by_last_action
     end
 
     it "should not enable the mount if it is enabled and mount options have not changed" do
-      @current_resource.stub(:enabled).and_return(true)
-      @provider.should_receive(:mount_options_unchanged?).and_return(true)
-      @provider.should_not_receive(:enable_fs)
-      @provider.run_action(:enable)
-      @new_resource.should_not be_updated_by_last_action
+      allow(current_resource).to receive(:enabled).and_return(true)
+      expect(provider).to receive(:mount_options_unchanged?).and_return(true)
+      expect(provider).not_to receive(:enable_fs)
+      provider.run_action(:enable)
+      expect(new_resource).not_to be_updated_by_last_action
     end
   end
 
   describe "when the target state is to disable the mount" do
     it "should disable the mount if it is enabled" do
-      @current_resource.stub(:enabled).and_return(true)
-      @provider.should_receive(:disable_fs).with.and_return(true)
-      @provider.run_action(:disable)
-      @new_resource.should be_updated_by_last_action
+      allow(current_resource).to receive(:enabled).and_return(true)
+      expect(provider).to receive(:disable_fs).and_return(true)
+      provider.run_action(:disable)
+      expect(new_resource).to be_updated_by_last_action
     end
 
     it "should not disable the mount if it isn't enabled" do
-      @current_resource.stub(:enabled).and_return(false)
-      @provider.should_not_receive(:disable_fs)
-      @provider.run_action(:disable)
-      @new_resource.should_not be_updated_by_last_action
+      allow(current_resource).to receive(:enabled).and_return(false)
+      expect(provider).not_to receive(:disable_fs)
+      provider.run_action(:disable)
+      expect(new_resource).not_to be_updated_by_last_action
     end
   end
 
 
   it "should delegates the mount implementation to subclasses" do
-    lambda { @provider.mount_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    expect { provider.mount_fs }.to raise_error(Chef::Exceptions::UnsupportedAction)
   end
 
   it "should delegates the umount implementation to subclasses" do
-    lambda { @provider.umount_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    expect { provider.umount_fs }.to raise_error(Chef::Exceptions::UnsupportedAction)
   end
 
   it "should delegates the remount implementation to subclasses" do
-    lambda { @provider.remount_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    expect { provider.remount_fs }.to raise_error(Chef::Exceptions::UnsupportedAction)
   end
 
   it "should delegates the enable implementation to subclasses" do
-    lambda { @provider.enable_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    expect { provider.enable_fs }.to raise_error(Chef::Exceptions::UnsupportedAction)
   end
 
   it "should delegates the disable implementation to subclasses" do
-    lambda { @provider.disable_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    expect { provider.disable_fs }.to raise_error(Chef::Exceptions::UnsupportedAction)
   end
 end