chef 11.4.4 → 11.6.0.hotfix.1

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -42,7 +42,8 @@ describe Chef::Knife::CookbookUpload do
 
   describe 'run' do
     before(:each) do
-      @knife.stub!(:upload).and_return(true)
+      @cookbook_uploader = stub(:upload_cookbooks => nil)
+      Chef::CookbookUploader.stub(:new => @cookbook_uploader)
       Chef::CookbookVersion.stub(:list_all_versions).and_return({})
     end
 
@@ -164,8 +165,11 @@ describe Chef::Knife::CookbookUpload do
 
     describe 'when a frozen cookbook exists on the server' do
       it 'should fail to replace it' do
-        @knife.stub!(:upload).and_raise(Chef::Exceptions::CookbookFrozen)
-        @knife.ui.should_receive(:error).with(/Failed to upload 1 cookbook/)
+        exception = Chef::Exceptions::CookbookFrozen.new
+        @cookbook_uploader.should_receive(:upload_cookbooks).
+          and_raise(exception)
+        @knife.ui.stub(:error)
+        @knife.ui.should_receive(:error).with(exception)
         lambda { @knife.run }.should raise_error(SystemExit)
       end
 
@@ -180,4 +184,4 @@ describe Chef::Knife::CookbookUpload do
       end
     end
   end # run
-end # Chef::Knife::CookbookUpload
+end

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

@@ -20,47 +20,29 @@ require 'spec_helper'
 require 'chef/knife/core/bootstrap_context'
 
 describe Chef::Knife::Core::BootstrapContext do
-  before do
-    @config = {:foo => :bar}
-    @run_list = Chef::RunList.new('recipe[tmux]', 'role[base]')
-    @chef_config = {:validation_key => File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem')}
-    @chef_config[:chef_server_url] = 'http://chef.example.com:4444'
-    @chef_config[:validation_client_name] = 'chef-validator-testing'
-    @context = Chef::Knife::Core::BootstrapContext.new(@config, @run_list, @chef_config)
+  let(:config) { {:foo => :bar} }
+  let(:run_list) { Chef::RunList.new('recipe[tmux]', 'role[base]') }
+  let(:chef_config) do
+    {
+      :validation_key => File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'),
+      :chef_server_url => 'http://chef.example.com:4444',
+      :validation_client_name => 'chef-validator-testing'
+    }
   end
+  let(:secret_file) { File.join(CHEF_SPEC_DATA, 'bootstrap', 'encrypted_data_bag_secret') }
 
-  describe "to support compatability with existing templates" do
-    it "sets the @config instance variable" do
-      @context.instance_eval { @config }.should == {:foo => :bar}
-    end
-
-    it "sets the @run_list instance variable" do
-      @context.instance_eval { @run_list }.should equal(@run_list)
-    end
-  end
+  subject(:bootstrap_context) { described_class.new(config, run_list, chef_config) }
 
   it "installs the same version of chef on the remote host" do
-    @context.bootstrap_version_string.should == "--version #{Chef::VERSION}"
+    bootstrap_context.bootstrap_version_string.should eq "--version #{Chef::VERSION}"
   end
 
   it "runs chef with the first-boot.json in the _default environment" do
-    @context.start_chef.should == "chef-client -j /etc/chef/first-boot.json -E _default"
-  end
-
-  it "it runs chef-client from another path when specified" do
-    @chef_config[:chef_client_path] = '/usr/local/bin/chef-client'
-    @context.start_chef.should == "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default"
+    bootstrap_context.start_chef.should eq "chef-client -j /etc/chef/first-boot.json -E _default"
   end
 
   it "reads the validation key" do
-    @context.validation_key.should == IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'))
-  end
-
-  it "reads the validation key when it contains a ~" do
-    IO.should_receive(:read).with(File.expand_path("my.key", ENV['HOME']))
-    @chef_config = {:validation_key => '~/my.key'}
-    @context = Chef::Knife::Core::BootstrapContext.new(@config, @run_list, @chef_config)
-    @context.validation_key
+    bootstrap_context.validation_key.should eq IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'))
   end
 
   it "generates the config file data" do
@@ -71,65 +53,100 @@ chef_server_url  "http://chef.example.com:4444"
 validation_client_name "chef-validator-testing"
 # Using default node name (fqdn)
 EXPECTED
-    @context.config_content.should == expected
+    bootstrap_context.config_content.should eq expected
   end
 
-  describe "when an explicit node name is given" do
-    before do
-      @config[:chef_node_name] = 'foobar.example.com'
+  describe "alternate chef-client path" do
+    let(:chef_config){ {:chef_client_path => '/usr/local/bin/chef-client'} }
+    it "runs chef-client from another path when specified" do
+      bootstrap_context.start_chef.should eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default"
     end
-    it "sets the node name in the client.rb" do
-      @context.config_content.should match(/node_name "foobar\.example\.com"/)
+  end
+
+  describe "validation key path that contains a ~" do
+    let(:chef_config){ {:validation_key => '~/my.key'} }
+    it "reads the validation key when it contains a ~" do
+      IO.should_receive(:read).with(File.expand_path("my.key", ENV['HOME']))
+      bootstrap_context.validation_key
     end
   end
 
-  describe "when bootstrapping into a specific environment" do
-    before do
-      @chef_config[:environment] = "prodtastic"
+  describe "when an explicit node name is given" do
+    let(:config){ {:chef_node_name => 'foobar.example.com' }}
+    it "sets the node name in the client.rb" do
+      bootstrap_context.config_content.should match(/node_name "foobar\.example\.com"/)
     end
+  end
 
+  describe "when bootstrapping into a specific environment" do
+    let(:chef_config){ {:environment => "prodtastic"} }
     it "starts chef in the configured environment" do
-      @context.start_chef.should == 'chef-client -j /etc/chef/first-boot.json -E prodtastic'
+      bootstrap_context.start_chef.should == 'chef-client -j /etc/chef/first-boot.json -E prodtastic'
     end
   end
 
   describe "when installing a prerelease version of chef" do
-    before do
-      @config[:prerelease] = true
-    end
+    let(:config){ {:prerelease => true }}
     it "supplies --prerelease as the version string" do
-      @context.bootstrap_version_string.should == '--prerelease'
+      bootstrap_context.bootstrap_version_string.should eq '--prerelease'
     end
   end
 
   describe "when installing an explicit version of chef" do
-    before do
-      @context = Chef::Knife::Core::BootstrapContext.new(@config, @run_list, :knife => { :bootstrap_version => '123.45.678' })
+    let(:chef_config) do
+      {
+        :knife => { :bootstrap_version => '123.45.678' }
+      }
     end
-
     it "gives --version $VERSION as the version string" do
-      @context.bootstrap_version_string.should == '--version 123.45.678'
+      bootstrap_context.bootstrap_version_string.should eq '--version 123.45.678'
     end
   end
-  
-  describe "when JSON attributes are given" do
-    before do
-      conf = @config.dup
-      conf[:first_boot_attributes] = {:baz => :quux}
-      @context = Chef::Knife::Core::BootstrapContext.new(conf, @run_list, @chef_config)
-    end
 
+  describe "when JSON attributes are given" do
+    let(:config) { {:first_boot_attributes => {:baz => :quux}} }
     it "adds the attributes to first_boot" do
-      @context.first_boot.to_json.should == {:baz => :quux, :run_list => @run_list}.to_json
+      bootstrap_context.first_boot.to_json.should eq({:baz => :quux, :run_list => run_list}.to_json)
     end
   end
-  
+
   describe "when JSON attributes are NOT given" do
     it "sets first_boot equal to run_list" do
-      @context.first_boot.to_json.should == {:run_list => @run_list}.to_json
+      bootstrap_context.first_boot.to_json.should eq({:run_list => run_list}.to_json)
+    end
+  end
+
+  describe "when an encrypted_data_bag_secret is provided" do
+    context "via config[:secret]" do
+      let(:config){ {:secret => "supersekret" }}
+      it "reads the encrypted_data_bag_secret" do
+        bootstrap_context.encrypted_data_bag_secret.should eq "supersekret"
+      end
+    end
+
+    context "via config[:secret_file]" do
+      let(:config){ {:secret_file =>  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 "to support compatibility with existing templates" do
+    it "sets the @config instance variable" do
+      bootstrap_context.instance_variable_get(:@config).should eq config
+    end
+
+    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
-  
-  
 end
 

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

@@ -37,6 +37,26 @@ describe Chef::Knife::SubcommandLoader do
     @loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| abs_path.should match(%r[chef/knife/.+])}
   end
 
+  it "finds files from latest version of installed gems" do
+    gems = [ double('knife-ec2-0.5.12') ]
+    gem_files = [
+      '/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_base.rb',
+      '/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_otherstuff.rb'
+    ]
+    $LOAD_PATH.should_receive(:map).and_return([])
+    if Gem::Specification.respond_to? :latest_specs
+      Gem::Specification.should_receive(:latest_specs).and_return(gems)
+      gems[0].should_receive(:matches_for_glob).with(/chef\/knife\/\*\.rb{(.*),\.rb,(.*)}/).and_return(gem_files)
+    else
+      Gem.source_index.should_receive(:latest_specs).and_return(gems)
+      gems[0].should_receive(:require_paths).twice.and_return(['lib'])
+      gems[0].should_receive(:full_gem_path).and_return('/usr/lib/ruby/gems/knife-ec2-0.5.12')
+      Dir.should_receive(:[]).with('/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb').and_return(gem_files)
+    end
+    @loader.should_receive(:find_subcommands_via_dirglob).and_return({})
+    @loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort.should == gem_files
+  end
+
   it "finds files using a dirglob when rubygems is not available" do
     @loader.find_subcommands_via_dirglob.should include('chef/knife/node_create')
     @loader.find_subcommands_via_dirglob.each {|rel_path, abs_path| abs_path.should match(%r[chef/knife/.+])}

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

@@ -40,7 +40,30 @@ describe Chef::Knife::UI do
     end
   end
 
+  shared_examples "an output mehthod handling IO exceptions" do |method|
+    it "should throw Errno::EIO exceptions" do
+      @out.stub(:puts).and_raise(Errno::EIO)
+      @err.stub(:puts).and_raise(Errno::EIO)
+      lambda {@ui.send(method, "hi")}.should raise_error(Errno::EIO)
+    end
+
+    it "should ignore Errno::EPIPE exceptions (CHEF-3516)" do
+      @out.stub(:puts).and_raise(Errno::EPIPE)
+      @err.stub(:puts).and_raise(Errno::EPIPE)
+      lambda {@ui.send(method, "hi")}.should_not raise_error(Errno::EPIPE)
+    end
+
+    it "should throw Errno::EPIPE exceptions with -VV (CHEF-3516)" do
+      @config[:verbosity] = 2
+      @out.stub(:puts).and_raise(Errno::EPIPE)
+      @err.stub(:puts).and_raise(Errno::EPIPE)
+      lambda {@ui.send(method, "hi")}.should raise_error(Errno::EPIPE)
+    end
+  end
+
   describe "output" do
+    it_behaves_like "an output mehthod handling IO exceptions", :output
+
     it "formats strings appropriately" do
       @ui.output("hi")
       @out.string.should == "hi\n"
@@ -187,6 +210,18 @@ EOM
     end
   end
 
+  describe "warn" do
+    it_behaves_like "an output mehthod handling IO exceptions", :warn
+  end
+
+  describe "error" do
+    it_behaves_like "an output mehthod handling IO exceptions", :warn
+  end
+
+  describe "fatal" do
+    it_behaves_like "an output mehthod handling IO exceptions", :warn
+  end
+
   describe "format_for_display" do
     it "should return the raw data" do
       input = { :gi => :go }
@@ -199,6 +234,12 @@ EOM
         @ui.config[:attribute] = "gi.go"
         @ui.format_for_display(input).should == { "sample-data-bag-item" => { "gi.go" => "ge" } }
       end
+
+      it "should return multiple attributes" do
+        input = { "gi" =>  "go", "hi" => "ho", "id" => "sample-data-bag-item" }
+        @ui.config[:attribute] = ["gi", "hi"]
+        @ui.format_for_display(input).should == { "sample-data-bag-item" => { "gi" => "go", "hi"=> "ho" } }
+      end
     end
 
     describe "with --run-list passed" do

data/spec/unit/knife/node_run_list_set_spec.rb

@@ -0,0 +1,140 @@
+#
+# Author:: Mike Fiedler (<miketheman@gmail.com>)
+# Copyright:: Copyright (c) 2013 Mike Fiedler
+# 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'
+
+describe Chef::Knife::NodeRunListSet do
+  before(:each) do
+    Chef::Config[:node_name]  = "webmonkey.example.com"
+    @knife = Chef::Knife::NodeRunListSet.new
+    @knife.config = {}
+    @knife.name_args = [ "adam", "role[monkey]" ]
+    @knife.stub!(:output).and_return(true)
+    @node = Chef::Node.new()
+    @node.stub!(:save).and_return(true)
+    Chef::Node.stub!(:load).and_return(@node)
+  end
+
+  describe "run" do
+    it "should load the node" do
+      Chef::Node.should_receive(:load).with("adam")
+      @knife.run
+    end
+
+    it "should set the run list" do
+      @knife.run
+      @node.run_list[0].should == 'role[monkey]'
+    end
+
+    it "should save the node" do
+      @node.should_receive(:save)
+      @knife.run
+    end
+
+    it "should print the run list" do
+      @knife.should_receive(:output).and_return(true)
+      @knife.run
+    end
+
+    describe "with more than one role or recipe" do
+      it "should set the run list to all the entries" do
+        @knife.name_args = [ "adam", "role[monkey],role[duck]" ]
+        @knife.run
+        @node.run_list[0].should == "role[monkey]"
+        @node.run_list[1].should == "role[duck]"
+      end
+    end
+
+    describe "with more than one role or recipe with space between items" do
+      it "should set the run list to all the entries" do
+        @knife.name_args = [ "adam", "role[monkey], role[duck]" ]
+        @knife.run
+        @node.run_list[0].should == "role[monkey]"
+        @node.run_list[1].should == "role[duck]"
+      end
+    end
+
+    describe "with more than one role or recipe as different arguments" do
+      it "should set the run list to all the entries" do
+        @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ]
+        @knife.run
+        @node.run_list[0].should == "role[monkey]"
+        @node.run_list[1].should == "role[duck]"
+      end
+    end
+
+    describe "with more than one role or recipe as different arguments and list separated by comas" do
+      it "should add to the run list all the entries" do
+        @knife.name_args = [ "adam", "role[monkey]", "role[duck],recipe[bird::fly]" ]
+        @knife.run
+        @node.run_list[0].should == "role[monkey]"
+        @node.run_list[1].should == "role[duck]"
+      end
+    end
+
+    describe "with one role or recipe but with an extraneous comma" do
+      it "should add to the run list one item" do
+        @knife.name_args = [ "adam", "role[monkey]," ]
+        @knife.run
+        @node.run_list[0].should == "role[monkey]"
+      end
+    end
+
+    describe "with an existing run list" do
+      it "should overwrite any existing run list items" do
+        @node.run_list << "role[acorns]"
+        @node.run_list << "role[zebras]"
+        @node.run_list[0].should == "role[acorns]"
+        @node.run_list[1].should == "role[zebras]"
+        @node.run_list.run_list_items.size.should == 2
+
+        @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ]
+        @knife.run
+        @node.run_list[0].should == "role[monkey]"
+        @node.run_list[1].should == "role[duck]"
+        @node.run_list.run_list_items.size.should == 2
+      end
+    end
+
+    describe "with no role or recipe" do
+      # Set up outputs for inspection later
+      before(:each) do
+        @stdout = StringIO.new
+        @stderr = StringIO.new
+
+        @knife.ui.stub!(:stdout).and_return(@stdout)
+        @knife.ui.stub!(:stderr).and_return(@stderr)
+      end
+
+      it "should exit" do
+        @knife.name_args = [ "adam" ]
+        lambda { @knife.run }.should raise_error SystemExit
+      end
+
+      it "should show the user" do
+        @knife.name_args = [ "adam" ]
+
+        begin ; @knife.run ; rescue SystemExit ; end
+
+        @stdout.string.should eq "USAGE: knife node run_list set NODE ENTRIES (options)\n"
+        @stderr.string.should eq "FATAL: You must supply both a node name and a run list.\n"
+      end
+    end
+
+  end
+end