chef 11.10.0.alpha.1-x86-mingw32 → 11.10.0.rc.0-x86-mingw32

data/spec/unit/client_spec.rb

@@ -169,6 +169,7 @@ shared_examples_for Chef::Client do
 
     it "should identify the node and run ohai, then register the client" do
       mock_chef_rest_for_node = mock("Chef::REST (node)")
+      mock_chef_rest_for_cookbook_sync = mock("Chef::REST (cookbook sync)")
       mock_chef_rest_for_node_save = mock("Chef::REST (node save)")
       mock_chef_runner = mock("Chef::Runner")
 
@@ -201,7 +202,8 @@ shared_examples_for Chef::Client do
       # ---Client#sync_cookbooks -- downloads the list of cookbooks to sync
       #
       Chef::CookbookSynchronizer.any_instance.should_receive(:sync_cookbooks)
-      mock_chef_rest_for_node.should_receive(:post_rest).with("environments/_default/cookbook_versions", {:run_list => []}).and_return({})
+      Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url]).and_return(mock_chef_rest_for_cookbook_sync)
+      mock_chef_rest_for_cookbook_sync.should_receive(:post).with("environments/_default/cookbook_versions", {:run_list => []}).and_return({})
 
       # --Client#converge
       Chef::Runner.should_receive(:new).and_return(mock_chef_runner)
@@ -274,6 +276,7 @@ shared_examples_for Chef::Client do
         Chef::Client.clear_notifications
         Chef::Node.stub!(:find_or_create).and_return(@node)
         @node.stub!(:save)
+        @client.load_node
         @client.build_node
       end
 
@@ -329,7 +332,10 @@ shared_examples_for Chef::Client do
       @node[:roles].should be_nil
       @node[:recipes].should be_nil
 
-      @client.build_node
+      @client.policy_builder.stub!(:node).and_return(@node)
+
+      # chefspec and possibly others use the return value of this method
+      @client.build_node.should == @node
 
       # check post-conditions.
       @node[:roles].should_not be_nil
@@ -434,7 +440,8 @@ shared_examples_for Chef::Client do
 
       @node.should_receive(:save).and_return(nil)
 
-      @client.build_node
+      @client.policy_builder.stub(:node).and_return(@node)
+      @client.policy_builder.build_node
 
       @node[:roles].should_not be_nil
       @node[:roles].should eql(['test_role'])

data/spec/unit/config_spec.rb

@@ -121,29 +121,6 @@ describe Chef::Config do
 
   end
 
-  describe "config attribute writer: log_method=" do
-    describe "when given an object that responds to sync= e.g. IO" do
-      it "should configure itself to use the IO as log_location" do
-        Chef::Config.log_location = STDOUT
-        Chef::Config.log_location.should == STDOUT
-      end
-    end
-
-    describe "when given an object that is stringable (to_str)" do
-      before do
-        @mockfile = mock("File", :path => "/var/log/chef/client.log", :sync= => true)
-        File.should_receive(:new).
-          with("/var/log/chef/client.log", "a").
-          and_return(@mockfile)
-      end
-
-      it "should configure itself to use a File object based upon the String" do
-        Chef::Config.log_location = "/var/log/chef/client.log"
-        Chef::Config.log_location.path.should == "/var/log/chef/client.log"
-      end
-    end
-  end
-
   describe "class method: plaform_specific_path" do
     it "should return given path on non-windows systems" do
       platform_mock :unix do
@@ -354,13 +331,6 @@ describe Chef::Config do
     end
   end
 
-  describe "Chef::Config[:log_location]" do
-    it "raises ConfigurationError when log_location directory is missing" do
-      missing_path = "/tmp/non-existing-dir/file"
-      expect{Chef::Config.log_location = missing_path}.to raise_error Chef::Exceptions::ConfigurationError
-    end
-  end
-
   describe "Chef::Config[:event_handlers]" do
     it "sets a event_handlers to an empty array by default" do
       Chef::Config[:event_handlers].should eq([])

data/spec/unit/cookbook_spec.rb

@@ -70,6 +70,7 @@ describe Chef::CookbookVersion do
 
   it "should allow you to include a fully-qualified recipe using the DSL" do
     # DSL method include_recipe allows multiple arguments, so extract the first
+    @node.should_receive(:loaded_recipe).with(:openldap, "gigantor")
     recipe = @run_context.include_recipe("openldap::gigantor").first
 
     recipe.recipe_name.should == "gigantor"

data/spec/unit/data_bag_item_spec.rb

@@ -70,6 +70,14 @@ describe Chef::DataBagItem do
       lambda { @data_bag_item.raw_data = { "id" => "h1-_" } }.should_not raise_error(ArgumentError)
     end
 
+    it "should accept alphanum.alphanum for the id" do
+      lambda { @data_bag_item.raw_data = { "id" => "foo.bar" } }.should_not raise_error(ArgumentError)
+    end
+
+    it "should accept .alphanum for the id" do
+      lambda { @data_bag_item.raw_data = { "id" => ".bozo" } }.should_not raise_error(ArgumentError)
+    end
+
     it "should raise an exception if the id contains anything but alphanum/-/_" do
       lambda { @data_bag_item.raw_data = { "id" => "!@#" } }.should raise_error(ArgumentError)
     end

data/spec/unit/data_bag_spec.rb

@@ -47,6 +47,12 @@ describe Chef::DataBag do
     it "should throw an ArgumentError if you feed it anything but a string" do
       lambda { @data_bag.name Hash.new }.should raise_error(ArgumentError)
     end
+
+    [ ".", "-", "_", "1"].each do |char|
+      it "should allow a '#{char}' character in the data bag name" do
+        @data_bag.name("clown#{char}clown").should == "clown#{char}clown"
+      end
+    end
   end
 
   describe "deserialize" do

data/spec/unit/http_spec.rb

@@ -0,0 +1,48 @@
+#
+# Author:: Xabier de Zuazo (xabier@onddo.com)
+# Copyright:: Copyright (c) 2014 Onddo Labs, SL.
+# 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/http'
+require 'chef/http/basic_client'
+
+describe Chef::HTTP do
+
+  describe "head" do
+
+    it 'should return nil for a "200 Success" response (CHEF-4762)' do
+      resp = Net::HTTPOK.new("1.1", 200, "OK")
+      resp.should_receive(:read_body).and_return(nil)
+      http = Chef::HTTP.new("")
+      Chef::HTTP::BasicClient.any_instance.should_receive(:request).and_return(["request", resp])
+
+      http.head("http://www.getchef.com/").should eql(nil)
+    end
+
+    it 'should return false for a "304 Not Modified" response (CHEF-4762)' do
+      resp = Net::HTTPNotModified.new("1.1", 304, "Not Modified")
+      resp.should_receive(:read_body).and_return(nil)
+      http = Chef::HTTP.new("")
+      Chef::HTTP::BasicClient.any_instance.should_receive(:request).and_return(["request", resp])
+
+      http.head("http://www.getchef.com/").should eql(false)
+    end
+
+  end # head
+
+end

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

@@ -20,6 +20,7 @@ require 'spec_helper'
 
 describe Chef::Knife::SubcommandLoader do
   before do
+
     @home = File.join(CHEF_SPEC_DATA, 'knife-home')
     @env = {'HOME' => @home}
     @loader = Chef::Knife::SubcommandLoader.new(File.join(CHEF_SPEC_DATA, 'knife-site-subcommands'), @env)
@@ -46,7 +47,7 @@ describe Chef::Knife::SubcommandLoader do
     $LOAD_PATH.should_receive(:map).and_return([])
     if Gem::Specification.respond_to? :latest_specs
       Gem::Specification.should_receive(:latest_specs).with(true).and_return(gems)
-      gems[0].should_receive(:matches_for_glob).with(/chef\/knife\/\*\.rb{(.*),\.rb,(.*)}/).and_return(gem_files)
+      gems[0].should_receive(:matches_for_glob).with(/chef\/knife\/\*\.rb\{(.*),\.rb,(.*)\}/).and_return(gem_files)
     else
       Gem.source_index.should_receive(:latest_specs).with(true).and_return(gems)
       gems[0].should_receive(:require_paths).twice.and_return(['lib'])
@@ -71,4 +72,79 @@ describe Chef::Knife::SubcommandLoader do
     expected_command = File.join(CHEF_SPEC_DATA, 'knife-site-subcommands', 'plugins', 'knife', 'example_subcommand.rb')
     @loader.site_subcommands.should include(expected_command)
   end
+
+  describe "finding 3rd party plugins" do 
+    let(:env_home) { "/home/alice" }
+    let(:manifest_path) { env_home + "/.chef/plugin_manifest.json" }
+
+    before do
+      env_dup = ENV.to_hash
+      ENV.stub(:[]).and_return { |key| env_dup[key] }
+      ENV.stub(:[]).with("HOME").and_return(env_home)
+    end
+
+    context "when there is not a ~/.chef/plugin_manifest.json file" do
+      before do
+        File.stub(:exist?).with(manifest_path).and_return(false)
+      end
+
+      it "searches rubygems for plugins" do
+        if Gem::Specification.respond_to?(:latest_specs)
+          Gem::Specification.should_receive(:latest_specs).and_call_original
+        else
+          Gem.source_index.should_receive(:latest_specs).and_call_original
+        end
+        @loader.subcommand_files.each do |require_path|
+          require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/)
+        end
+      end
+
+      context "and HOME environment variable is not set" do
+        before do
+          ENV.stub(:[]).with("HOME").and_return(nil)
+        end
+
+        it "searches rubygems for plugins" do
+          if Gem::Specification.respond_to?(:latest_specs)
+            Gem::Specification.should_receive(:latest_specs).and_call_original
+          else
+            Gem.source_index.should_receive(:latest_specs).and_call_original
+          end
+          @loader.subcommand_files.each do |require_path|
+            require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/)
+          end
+        end
+      end
+
+    end
+
+    context "when there is a ~/.chef/plugin_manifest.json file" do
+      let(:ec2_server_create_plugin) { "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_server_create.rb" }
+
+      let(:manifest_content) do
+        { "plugins" => {
+            "knife-ec2" => {
+              "paths" => [
+                ec2_server_create_plugin
+              ]
+            }
+          }
+        }
+      end
+
+      let(:manifest_json) { Chef::JSONCompat.to_json(manifest_content) }
+
+      before do
+        File.stub(:exist?).with(manifest_path).and_return(true)
+        File.stub(:read).with(manifest_path).and_return(manifest_json)
+      end
+
+      it "uses paths from the manifest instead of searching gems" do
+        Gem::Specification.should_not_receive(:latest_specs).and_call_original
+        @loader.subcommand_files.should include(ec2_server_create_plugin)
+      end
+
+    end
+  end
+
 end

data/spec/unit/knife/ssh_spec.rb

@@ -280,4 +280,111 @@ describe Chef::Knife::Ssh do
       end
     end
   end
+
+  describe "#configure_password" do
+    before do
+      @knife.config.delete(:ssh_password_ng)
+      @knife.config.delete(:ssh_password)
+    end
+
+    context "when setting ssh_password_ng from knife ssh" do
+      # in this case ssh_password_ng exists, but ssh_password does not
+      it "should prompt for a password when ssh_passsword_ng is nil"  do
+        @knife.config[:ssh_password_ng] = nil
+        @knife.should_receive(:get_password).and_return("mysekretpassw0rd")
+        @knife.configure_password
+        @knife.config[:ssh_password].should == "mysekretpassw0rd"
+      end
+
+      it "should set ssh_password to false if ssh_password_ng is false"  do
+        @knife.config[:ssh_password_ng] = false
+        @knife.should_not_receive(:get_password)
+        @knife.configure_password
+        @knife.config[:ssh_password].should be_false
+      end
+
+      it "should set ssh_password to ssh_password_ng if we set a password" do
+        @knife.config[:ssh_password_ng] = "mysekretpassw0rd"
+        @knife.should_not_receive(:get_password)
+        @knife.configure_password
+        @knife.config[:ssh_password].should == "mysekretpassw0rd"
+      end
+    end
+
+    context "when setting ssh_password from knife bootstrap / knife * server create" do
+      # in this case ssh_password exists, but ssh_password_ng does not
+      it "should set ssh_password to nil when ssh_password is nil" do
+        @knife.config[:ssh_password] = nil
+        @knife.should_not_receive(:get_password)
+        @knife.configure_password
+        @knife.config[:ssh_password].should be_nil
+      end
+
+      it "should set ssh_password to false when ssh_password is false" do
+        @knife.config[:ssh_password] = false
+        @knife.should_not_receive(:get_password)
+        @knife.configure_password
+        @knife.config[:ssh_password].should be_false
+      end
+
+      it "should set ssh_password to ssh_password if we set a password" do
+        @knife.config[:ssh_password] = "mysekretpassw0rd"
+        @knife.should_not_receive(:get_password)
+        @knife.configure_password
+        @knife.config[:ssh_password].should == "mysekretpassw0rd"
+      end
+    end
+    context "when setting ssh_password in the config variable" do
+      before(:each) do
+        Chef::Config[:knife][:ssh_password] = "my_knife_passw0rd"
+      end
+      context "when setting ssh_password_ng from knife ssh" do
+        # in this case ssh_password_ng exists, but ssh_password does not
+        it "should prompt for a password when ssh_passsword_ng is nil"  do
+          @knife.config[:ssh_password_ng] = nil
+          @knife.should_receive(:get_password).and_return("mysekretpassw0rd")
+          @knife.configure_password
+          @knife.config[:ssh_password].should == "mysekretpassw0rd"
+        end
+
+        it "should set ssh_password to the configured knife.rb value if ssh_password_ng is false"  do
+          @knife.config[:ssh_password_ng] = false
+          @knife.should_not_receive(:get_password)
+          @knife.configure_password
+          @knife.config[:ssh_password].should == "my_knife_passw0rd"
+        end
+
+        it "should set ssh_password to ssh_password_ng if we set a password" do
+          @knife.config[:ssh_password_ng] = "mysekretpassw0rd"
+          @knife.should_not_receive(:get_password)
+          @knife.configure_password
+          @knife.config[:ssh_password].should == "mysekretpassw0rd"
+        end
+      end
+
+      context "when setting ssh_password from knife bootstrap / knife * server create" do
+        # in this case ssh_password exists, but ssh_password_ng does not
+        it "should set ssh_password to the configured knife.rb value when ssh_password is nil" do
+          @knife.config[:ssh_password] = nil
+          @knife.should_not_receive(:get_password)
+          @knife.configure_password
+          @knife.config[:ssh_password].should == "my_knife_passw0rd"
+        end
+
+        it "should set ssh_password to the configured knife.rb value when ssh_password is false" do
+          @knife.config[:ssh_password] = false
+          @knife.should_not_receive(:get_password)
+          @knife.configure_password
+          @knife.config[:ssh_password].should == "my_knife_passw0rd"
+        end
+
+        it "should set ssh_password to ssh_password if we set a password" do
+          @knife.config[:ssh_password] = "mysekretpassw0rd"
+          @knife.should_not_receive(:get_password)
+          @knife.configure_password
+          @knife.config[:ssh_password].should == "mysekretpassw0rd"
+        end
+      end
+    end
+  end
 end

data/spec/unit/mixin/path_sanity_spec.rb

@@ -38,6 +38,12 @@ describe Chef::Mixin::PathSanity do
       Chef::Platform.stub!(:windows?).and_return(false)
     end
 
+    it "adds all useful PATHs even if environment is an empty hash" do
+      env={}
+      @sanity.enforce_path_sanity(env)
+      env["PATH"].should == "#{@ruby_bindir}:#{@gem_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+    end
+
     it "adds all useful PATHs that are not yet in PATH to PATH" do
       env = {"PATH" => ""}
       @sanity.enforce_path_sanity(env)

data/spec/unit/mixin/securable_spec.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 #
 # Author:: Mark Mzyk (<mmzyk@opscode.com>)
 # Copyright:: Copyright (c) 2011 Opscode, Inc.
@@ -29,13 +30,13 @@ describe Chef::Mixin::Securable do
   it "should accept a group name or id for group" do
     lambda { @securable.group "root" }.should_not raise_error(ArgumentError)
     lambda { @securable.group 123 }.should_not raise_error(ArgumentError)
-    lambda { @securable.group "root*goo" }.should raise_error(ArgumentError)
+    lambda { @securable.group "+bad:group" }.should raise_error(ArgumentError)
   end
 
   it "should accept a user name or id for owner" do
     lambda { @securable.owner "root" }.should_not raise_error(ArgumentError)
     lambda { @securable.owner 123 }.should_not raise_error(ArgumentError)
-    lambda { @securable.owner "root*goo" }.should raise_error(ArgumentError)
+    lambda { @securable.owner "+bad:owner" }.should raise_error(ArgumentError)
   end
 
   it "allows the owner to be specified as #user" do
@@ -53,8 +54,81 @@ describe Chef::Mixin::Securable do
       end
     end
 
-    it "should accept a group name or id for group with spaces and backslashes" do
+    it "should accept group/owner names with spaces and backslashes" do
       lambda { @securable.group 'test\ group' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner 'test\ group' }.should_not raise_error(ArgumentError)
+    end
+
+    it "should accept group/owner names that are a single character or digit" do
+      lambda { @securable.group 'v' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group '1' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner 'v' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner '1' }.should_not raise_error(ArgumentError)
+    end
+
+    it "should not accept group/owner names starting with '-', '+', or '~'" do
+      lambda { @securable.group '-test' }.should raise_error(ArgumentError)
+      lambda { @securable.group '+test' }.should raise_error(ArgumentError)
+      lambda { @securable.group '~test' }.should raise_error(ArgumentError)
+      lambda { @securable.group 'te-st' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group 'te+st' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group 'te~st' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner '-test' }.should raise_error(ArgumentError)
+      lambda { @securable.owner '+test' }.should raise_error(ArgumentError)
+      lambda { @securable.owner '~test' }.should raise_error(ArgumentError)
+      lambda { @securable.owner 'te-st' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner 'te+st' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner 'te~st' }.should_not raise_error(ArgumentError)
+    end
+
+    it "should not accept group/owner names containing ':', ',' or non-space whitespace" do
+      lambda { @securable.group ':test' }.should raise_error(ArgumentError)
+      lambda { @securable.group 'te:st' }.should raise_error(ArgumentError)
+      lambda { @securable.group ',test' }.should raise_error(ArgumentError)
+      lambda { @securable.group 'te,st' }.should raise_error(ArgumentError)
+      lambda { @securable.group "\ttest" }.should raise_error(ArgumentError)
+      lambda { @securable.group "te\tst" }.should raise_error(ArgumentError)
+      lambda { @securable.group "\rtest" }.should raise_error(ArgumentError)
+      lambda { @securable.group "te\rst" }.should raise_error(ArgumentError)
+      lambda { @securable.group "\ftest" }.should raise_error(ArgumentError)
+      lambda { @securable.group "te\fst" }.should raise_error(ArgumentError)
+      lambda { @securable.group "\0test" }.should raise_error(ArgumentError)
+      lambda { @securable.group "te\0st" }.should raise_error(ArgumentError)
+      lambda { @securable.owner ':test' }.should raise_error(ArgumentError)
+      lambda { @securable.owner 'te:st' }.should raise_error(ArgumentError)
+      lambda { @securable.owner ',test' }.should raise_error(ArgumentError)
+      lambda { @securable.owner 'te,st' }.should raise_error(ArgumentError)
+      lambda { @securable.owner "\ttest" }.should raise_error(ArgumentError)
+      lambda { @securable.owner "te\tst" }.should raise_error(ArgumentError)
+      lambda { @securable.owner "\rtest" }.should raise_error(ArgumentError)
+      lambda { @securable.owner "te\rst" }.should raise_error(ArgumentError)
+      lambda { @securable.owner "\ftest" }.should raise_error(ArgumentError)
+      lambda { @securable.owner "te\fst" }.should raise_error(ArgumentError)
+      lambda { @securable.owner "\0test" }.should raise_error(ArgumentError)
+      lambda { @securable.owner "te\0st" }.should raise_error(ArgumentError)
+    end
+
+    it "should accept Active Directory-style domain names pulled in via LDAP (on unix hosts)" do
+      lambda { @securable.owner "domain\@user" }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner "domain\\user" }.should_not raise_error(ArgumentError)
+      lambda { @securable.group "domain\@group" }.should_not raise_error(ArgumentError)
+      lambda { @securable.group "domain\\group" }.should_not raise_error(ArgumentError)
+      lambda { @securable.group "domain\\group^name" }.should_not raise_error(ArgumentError)
+    end
+
+    it "should not accept group/owner names containing embedded carriage returns" do
+      pending "XXX: params_validate needs to be extended to support multi-line regex"
+      #lambda { @securable.group "\ntest" }.should raise_error(ArgumentError)
+      #lambda { @securable.group "te\nst" }.should raise_error(ArgumentError)
+      #lambda { @securable.owner "\ntest" }.should raise_error(ArgumentError)
+      #lambda { @securable.owner "te\nst" }.should raise_error(ArgumentError)
+    end
+
+    it "should accept group/owner names in UTF-8" do
+      lambda { @securable.group 'tëst' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group 'ë' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner 'tëst' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner 'ë' }.should_not raise_error(ArgumentError)
     end
 
     it "should accept a unix file mode in string form as an octal number" do