chef 11.12.0.alpha.1 → 11.12.0.rc.1

data/spec/unit/knife/bootstrap_spec.rb

@@ -124,12 +124,21 @@ describe Chef::Knife::Bootstrap do
   end
 
   describe "specifying no_proxy with various entries" do
-    subject(:knife) { described_class.new }
-    let(:options){ ["--bootstrap-no-proxy", setting] }
+    subject(:knife) do
+      k = described_class.new
+      k.instance_variable_set("@template_file", template_file)
+      k.parse_options(options)
+      k.merge_configs
+      k
+    end
+
+    # Include a data bag secret in the options to prevent Bootstrap from
+    # attempting to access /etc/chef/encrypted_data_bag_secret, which
+    # can fail when the file exists but can't be accessed by the user
+    # running the tests.
+    let(:options){ ["--bootstrap-no-proxy", setting, "-s", "foo"] }
     let(:template_file) { File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "no_proxy.erb")) }
     let(:rendered_template) do
-      knife.instance_variable_set("@template_file", template_file)
-      knife.parse_options(options)
       template_string = knife.read_template
       knife.render_template(template_string)
     end

data/spec/unit/knife/client_bulk_delete_spec.rb

@@ -19,60 +19,145 @@
 require 'spec_helper'
 
 describe Chef::Knife::ClientBulkDelete do
-  before(:each) do
-    Chef::Log.logger = Logger.new(StringIO.new)
-
-    Chef::Config[:node_name]  = "webmonkey.example.com"
-    @knife = Chef::Knife::ClientBulkDelete.new
-    @knife.name_args = ["."]
-    @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
-    @knife.ui.stub(:confirm).and_return(true)
-    @clients = Hash.new
-    %w{tim dan stephen}.each do |client_name|
+  let(:stdout_io) { StringIO.new }
+  let(:stdout) {stdout_io.string}
+
+  let(:knife) {
+    k = Chef::Knife::ClientBulkDelete.new
+    k.name_args = name_args
+    k.config = option_args
+    k.ui.stub(:stdout).and_return(stdout_io)
+    k.ui.stub(:confirm).and_return(knife_confirm)
+    k.ui.stub(:confirm_without_exit).and_return(knife_confirm)
+    k
+  }
+
+  let(:name_args) { [ "." ] }
+  let(:option_args) { {} }
+
+  let(:knife_confirm) { true }
+
+  let(:nonvalidator_client_names) { %w{tim dan stephen} }
+  let(:nonvalidator_clients) {
+    clients = Hash.new
+
+    nonvalidator_client_names.each do |client_name|
       client = Chef::ApiClient.new()
       client.name(client_name)
       client.stub(:destroy).and_return(true)
-      @clients[client_name] = client
+      clients[client_name] = client
+    end
+
+    clients
+  }
+
+  let(:validator_client_names) { %w{myorg-validator} }
+  let(:validator_clients) {
+    clients = Hash.new
+
+    validator_client_names.each do |validator_client_name|
+      validator_client = Chef::ApiClient.new()
+      validator_client.name(validator_client_name)
+      validator_client.stub(:validator).and_return(true)
+      validator_client.stub(:destroy).and_return(true)
+      clients[validator_client_name] = validator_client
     end
-    Chef::ApiClient.stub(:list).and_return(@clients)
+
+    clients
+  }
+
+  let(:client_names) { nonvalidator_client_names + validator_client_names}
+  let(:clients) {
+    nonvalidator_clients.merge(validator_clients)
+  }
+
+  before(:each) do
+    Chef::ApiClient.stub(:list).and_return(clients)
   end
 
   describe "run" do
+    describe "without a regex" do
+      let(:name_args) { [ ] }
 
-    it "should get the list of the clients" do
-      Chef::ApiClient.should_receive(:list).and_return(@clients)
-      @knife.run
+      it "should exit if the regex is not provided" do
+        lambda { knife.run }.should raise_error(SystemExit)
+      end
     end
 
-    it "should print the clients you are about to delete" do
-      @knife.run
-      @stdout.string.should match(/#{@knife.ui.list(@clients.keys.sort, :columns_down)}/)
-    end
+    describe "with any clients" do
+      it "should get the list of the clients" do
+        Chef::ApiClient.should_receive(:list)
+        knife.run
+      end
 
-    it "should confirm you really want to delete them" do
-      @knife.ui.should_receive(:confirm)
-      @knife.run
-    end
+      it "should print the name of the clients" do
+        knife.run
+        client_names.each do |client_name|
+          stdout.should include(client_name)
+        end
+      end
 
-    it "should delete each client" do
-      @clients.each_value do |c|
-        c.should_receive(:destroy)
+      it "should confirm you really want to delete them" do
+        knife.ui.should_receive(:confirm)
+        knife.run
       end
-      @knife.run
-    end
 
-    it "should only delete clients that match the regex" do
-      @knife.name_args = ["tim"]
-      @clients["tim"].should_receive(:destroy)
-      @clients["stephen"].should_not_receive(:destroy)
-      @clients["dan"].should_not_receive(:destroy)
-      @knife.run
+      describe "without --delete-validators" do
+        it "should mention that validator clients wont be deleted" do
+          knife.run
+          stdout.should include("Following clients are validators and will not be deleted.")
+          info = stdout.index "Following clients are validators and will not be deleted."
+          val = stdout.index "myorg-validator"
+          (val > info).should be_true
+        end
+
+        it "should only delete nonvalidator clients" do
+          nonvalidator_clients.each_value do |c|
+            c.should_receive(:destroy)
+          end
+
+          validator_clients.each_value do |c|
+            c.should_not_receive(:destroy)
+          end
+
+          knife.run
+        end
+      end
+
+      describe "with --delete-validators" do
+        let(:option_args) { {:delete_validators => true} }
+
+        it "should mention that validator clients will be deleted" do
+          knife.run
+          stdout.should include("The following validators will be deleted")
+        end
+
+        it "should confirm twice" do
+          knife.ui.should_receive(:confirm).once
+          knife.ui.should_receive(:confirm_without_exit).once
+          knife.run
+        end
+
+        it "should delete all clients" do
+          clients.each_value do |c|
+            c.should_receive(:destroy)
+          end
+
+          knife.run
+        end
+      end
     end
 
-    it "should exit if the regex is not provided" do
-      @knife.name_args = []
-      lambda { @knife.run }.should raise_error(SystemExit)
+    describe "with some clients" do
+      let(:name_args) { [ "^ti" ] }
+
+      it "should only delete clients that match the regex" do
+        clients["tim"].should_receive(:destroy)
+        clients["stephen"].should_not_receive(:destroy)
+        clients["dan"].should_not_receive(:destroy)
+        clients["myorg-validator"].should_not_receive(:destroy)
+        knife.run
+      end
     end
   end
 end

data/spec/unit/knife/client_delete_spec.rb

@@ -23,7 +23,7 @@ describe Chef::Knife::ClientDelete do
     @knife = Chef::Knife::ClientDelete.new
     # defaults
     @knife.config = {
-      :force => false
+      :delete_validators => false
     }
     @knife.name_args = [ 'adam' ]
   end
@@ -51,7 +51,7 @@ describe Chef::Knife::ClientDelete do
     end
 
     it 'should delete non-validator client if --force is not set' do
-      @knife.config[:force] = false
+      @knife.config[:delete_validators] = false
       @client.should_receive(:destroy).and_return(@client)
       @knife.should_receive(:msg)
 
@@ -59,7 +59,7 @@ describe Chef::Knife::ClientDelete do
     end
 
     it 'should delete non-validator client if --force is set' do
-      @knife.config[:force] = true
+      @knife.config[:delete_validators] = true
       @client.should_receive(:destroy).and_return(@client)
       @knife.should_receive(:msg)
 
@@ -73,7 +73,7 @@ describe Chef::Knife::ClientDelete do
     end
 
     it 'should delete validator client if --force is set' do
-      @knife.config[:force] = true
+      @knife.config[:delete_validators] = true
       @client.should_receive(:destroy).and_return(@client)
       @knife.should_receive(:msg)
 

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -23,178 +23,271 @@ require 'chef/cookbook_uploader'
 require 'timeout'
 
 describe Chef::Knife::CookbookUpload do
-  before(:each) do
-    @knife = Chef::Knife::CookbookUpload.new
-    @knife.name_args = ['test_cookbook']
+  let(:cookbook) { Chef::CookbookVersion.new('test_cookbook') }
+
+  let(:cookbooks_by_name) do
+    {cookbook.name => cookbook}
+  end
 
-    @cookbook = Chef::CookbookVersion.new('test_cookbook')
+  let(:cookbook_loader) do
+    cookbook_loader = cookbooks_by_name.dup
+    cookbook_loader.stub(:merged_cookbooks).and_return([])
+    cookbook_loader.stub(:load_cookbooks).and_return(cookbook_loader)
+    cookbook_loader
+  end
+
+  let(:cookbook_uploader) { double(:upload_cookbooks => nil) }
 
-    @cookbook_loader = {}
-    @cookbook_loader.stub(:[]).and_return(@cookbook)
-    @cookbook_loader.stub(:merged_cookbooks).and_return([])
-    @cookbook_loader.stub(:load_cookbooks).and_return(@cookbook_loader)
-    Chef::CookbookLoader.stub(:new).and_return(@cookbook_loader)
+  let(:output) { StringIO.new }
+  
+  let(:name_args) { ['test_cookbook'] }
 
-    @output = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@output)
-    @knife.ui.stub(:stderr).and_return(@output)
+  let(:knife) do
+    k = Chef::Knife::CookbookUpload.new
+    k.name_args = name_args
+    k.ui.stub(:stdout).and_return(output)
+    k.ui.stub(:stderr).and_return(output)
+    k
+  end
+
+  before(:each) do
+    Chef::CookbookLoader.stub(:new).and_return(cookbook_loader)
   end
 
   describe 'with --concurrency' do
     it 'should upload cookbooks with predefined concurrency' do
-      @cookbook_uploader = double(:upload_cookbooks => nil)
       Chef::CookbookVersion.stub(:list_all_versions).and_return({})
-      @knife.config[:concurrency] = 3
-      @test_cookbook = Chef::CookbookVersion.new('test_cookbook')
-      @cookbook_loader.stub(:each).and_yield("test_cookbook", @test_cookbook)
-      @cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook"])
+      knife.config[:concurrency] = 3
+      test_cookbook = Chef::CookbookVersion.new('test_cookbook')
+      cookbook_loader.stub(:each).and_yield("test_cookbook", test_cookbook)
+      cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook"])
       Chef::CookbookUploader.should_receive(:new).with( kind_of(Array),  kind_of(Array),
         {:force=>nil, :concurrency => 3}).and_return(double("Chef::CookbookUploader", :upload_cookbooks=> true))
-      @knife.run
+      knife.run
     end
   end
 
   describe 'run' do
     before(:each) do
-      @cookbook_uploader = double(:upload_cookbooks => nil)
-      Chef::CookbookUploader.stub(:new => @cookbook_uploader)
+      Chef::CookbookUploader.stub(:new => cookbook_uploader)
       Chef::CookbookVersion.stub(:list_all_versions).and_return({})
     end
 
     it 'should print usage and exit when a cookbook name is not provided' do
-      @knife.name_args = []
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      knife.name_args = []
+      knife.should_receive(:show_usage)
+      knife.ui.should_receive(:fatal)
+      lambda { knife.run }.should raise_error(SystemExit)
     end
 
     describe 'when specifying a cookbook name' do
       it 'should upload the cookbook' do
-        @knife.should_receive(:upload).once
-        @knife.run
+        knife.should_receive(:upload).once
+        knife.run
       end
 
       it 'should report on success' do
-        @knife.should_receive(:upload).once
-        @knife.ui.should_receive(:info).with(/Uploaded 1 cookbook/)
-        @knife.run
+        knife.should_receive(:upload).once
+        knife.ui.should_receive(:info).with(/Uploaded 1 cookbook/)
+        knife.run
       end
     end
 
     describe 'when specifying the same cookbook name twice' do
       it 'should upload the cookbook only once' do
-        @knife.name_args = ['test_cookbook', 'test_cookbook']
-        @knife.should_receive(:upload).once
-        @knife.run
+        knife.name_args = ['test_cookbook', 'test_cookbook']
+        knife.should_receive(:upload).once
+        knife.run
+      end
+    end
+
+    context "when uploading a cookbook that uses deprecated overlays" do
+
+      before do
+        cookbook_loader.stub(:merged_cookbooks).and_return(['test_cookbook'])
+        cookbook_loader.stub(:merged_cookbook_paths).
+          and_return({'test_cookbook' => %w{/path/one/test_cookbook /path/two/test_cookbook}})
+      end
+
+      it "emits a warning" do
+        knife.run
+        expected_message=<<-E
+WARNING: The cookbooks: test_cookbook exist in multiple places in your cookbook_path.
+A composite version of these cookbooks has been compiled for uploading.
+
+IMPORTANT: In a future version of Chef, this behavior will be removed and you will no longer
+be able to have the same version of a cookbook in multiple places in your cookbook_path.
+WARNING: The affected cookbooks are located:
+test_cookbook:
+  /path/one/test_cookbook
+  /path/two/test_cookbook
+E
+        output.string.should include(expected_message)
       end
     end
 
     describe 'when specifying a cookbook name among many' do
-      before(:each) do
-        @knife.name_args = ['test_cookbook1']
-        @cookbooks = {
+      let(:name_args) { ['test_cookbook1'] }
+
+      let(:cookbooks_by_name) do
+        {
           'test_cookbook1' => Chef::CookbookVersion.new('test_cookbook1'),
           'test_cookbook2' => Chef::CookbookVersion.new('test_cookbook2'),
           'test_cookbook3' => Chef::CookbookVersion.new('test_cookbook3')
         }
-        @cookbook_loader = {}
-        @cookbook_loader.stub(:merged_cookbooks).and_return([])
-        @cookbook_loader.stub(:[]) { |ckbk| @cookbooks[ckbk] }
-        Chef::CookbookLoader.stub(:new).and_return(@cookbook_loader)
       end
 
       it "should read only one cookbook" do
-        @cookbook_loader.should_receive(:[]).once.with('test_cookbook1')
-        @knife.run
+        cookbook_loader.should_receive(:[]).once.with('test_cookbook1').and_call_original
+        knife.run
       end
 
       it "should not read all cookbooks" do
-        @cookbook_loader.should_not_receive(:load_cookbooks)
-        @knife.run
+        cookbook_loader.should_not_receive(:load_cookbooks)
+        knife.run
       end
 
       it "should upload only one cookbook" do
-        @knife.should_receive(:upload).exactly(1).times
-        @knife.run
+        knife.should_receive(:upload).exactly(1).times
+        knife.run
       end
     end
 
     # This is testing too much.  We should break it up.
     describe 'when specifying a cookbook name with dependencies' do
+      let(:name_args) { ["test_cookbook2"] }
+
+      let(:cookbooks_by_name) do
+        { "test_cookbook1" => test_cookbook1,
+          "test_cookbook2" => test_cookbook2,
+          "test_cookbook3" => test_cookbook3 }
+      end
+
+      let(:test_cookbook1) { Chef::CookbookVersion.new('test_cookbook1') }
+
+      let(:test_cookbook2) do
+        c = Chef::CookbookVersion.new('test_cookbook2')
+        c.metadata.depends("test_cookbook3")
+        c
+      end
+
+      let(:test_cookbook3) do
+        c = Chef::CookbookVersion.new('test_cookbook3')
+        c.metadata.depends("test_cookbook1")
+        c.metadata.depends("test_cookbook2")
+        c
+      end
+
       it "should upload all dependencies once" do
-        @knife.name_args = ["test_cookbook2"]
-        @knife.config[:depends] = true
-        @test_cookbook1 = Chef::CookbookVersion.new('test_cookbook1')
-        @test_cookbook2 = Chef::CookbookVersion.new('test_cookbook2')
-        @test_cookbook3 = Chef::CookbookVersion.new('test_cookbook3')
-        @test_cookbook2.metadata.depends("test_cookbook3")
-        @test_cookbook3.metadata.depends("test_cookbook1")
-        @test_cookbook3.metadata.depends("test_cookbook2")
-        @cookbook_loader.stub(:[])  do |ckbk|
-          { "test_cookbook1" =>  @test_cookbook1,
-            "test_cookbook2" =>  @test_cookbook2,
-            "test_cookbook3" => @test_cookbook3 }[ckbk]
-        end
-        @knife.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2", "test_cookbook3"])
-        @knife.should_receive(:upload).exactly(3).times
-        Timeout::timeout(5) do
-          @knife.run
+        knife.config[:depends] = true
+        knife.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2", "test_cookbook3"])
+        knife.should_receive(:upload).exactly(3).times
+        lambda do
+          Timeout::timeout(5) do
+            knife.run
+          end
         end.should_not raise_error
       end
     end
 
+    describe 'when specifying a cookbook name with missing dependencies' do
+      let(:cookbook_dependency) { Chef::CookbookVersion.new('dependency') }
+
+      before(:each) do
+        cookbook.metadata.depends("dependency")
+        cookbook_loader.stub(:[])  do |ckbk|
+          { "test_cookbook" =>  cookbook,
+            "dependency" => cookbook_dependency}[ckbk]
+        end
+        knife.stub(:cookbook_names).and_return(["cookbook_dependency", "test_cookbook"])
+        @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+        knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
+      end
+
+      it 'should exit and not upload the cookbook' do
+        cookbook_loader.should_receive(:[]).once.with('test_cookbook')
+        cookbook_loader.should_not_receive(:load_cookbooks)
+        cookbook_uploader.should_not_receive(:upload_cookbooks)
+        expect {knife.run}.to raise_error(SystemExit)
+      end
+
+      it 'should output a message for a single missing dependency' do
+        expect {knife.run}.to raise_error(SystemExit)
+        @stderr.string.should include('Cookbook test_cookbook depends on cookbooks which are not currently')
+        @stderr.string.should include('being uploaded and cannot be found on the server.')
+        @stderr.string.should include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+      end
+
+      it 'should output a message for a multiple missing dependencies which are concatenated' do
+        cookbook_dependency2 = Chef::CookbookVersion.new('dependency2')
+        cookbook.metadata.depends("dependency2")
+        cookbook_loader.stub(:[])  do |ckbk|
+          { "test_cookbook" =>  cookbook,
+            "dependency" => cookbook_dependency,
+            "dependency2" => cookbook_dependency2}[ckbk]
+        end
+        knife.stub(:cookbook_names).and_return(["dependency", "dependency2", "test_cookbook"])
+        expect {knife.run}.to raise_error(SystemExit)
+        @stderr.string.should include('Cookbook test_cookbook depends on cookbooks which are not currently')
+        @stderr.string.should include('being uploaded and cannot be found on the server.')
+        @stderr.string.should include("The missing cookbook(s) are:")
+        @stderr.string.should include("'dependency' version '>= 0.0.0'")
+        @stderr.string.should include("'dependency2' version '>= 0.0.0'")
+      end
+    end
+
     it "should freeze the version of the cookbooks if --freeze is specified" do
-      @knife.config[:freeze] = true
-      @cookbook.should_receive(:freeze_version).once
-      @knife.run
+      knife.config[:freeze] = true
+      cookbook.should_receive(:freeze_version).once
+      knife.run
     end
 
     describe 'with -a or --all' do
       before(:each) do
-        @knife.config[:all] = true
+        knife.config[:all] = true
         @test_cookbook1 = Chef::CookbookVersion.new('test_cookbook1')
         @test_cookbook2 = Chef::CookbookVersion.new('test_cookbook2')
-        @cookbook_loader.stub(:each).and_yield("test_cookbook1", @test_cookbook1).and_yield("test_cookbook2", @test_cookbook2)
-        @cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2"])
+        cookbook_loader.stub(:each).and_yield("test_cookbook1", @test_cookbook1).and_yield("test_cookbook2", @test_cookbook2)
+        cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2"])
       end
 
       it 'should upload all cookbooks' do
-        @knife.should_receive(:upload).once
-        @knife.run
+        knife.should_receive(:upload).once
+        knife.run
       end
 
       it 'should report on success' do
-        @knife.should_receive(:upload).once
-        @knife.ui.should_receive(:info).with(/Uploaded all cookbooks/)
-        @knife.run
+        knife.should_receive(:upload).once
+        knife.ui.should_receive(:info).with(/Uploaded all cookbooks/)
+        knife.run
       end
 
       it 'should update the version constraints for an environment' do
-        @knife.stub(:assert_environment_valid!).and_return(true)
-        @knife.config[:environment] = "production"
-        @knife.should_receive(:update_version_constraints).once
-        @knife.run
+        knife.stub(:assert_environment_valid!).and_return(true)
+        knife.config[:environment] = "production"
+        knife.should_receive(:update_version_constraints).once
+        knife.run
       end
     end
 
     describe 'when a frozen cookbook exists on the server' do
       it 'should fail to replace it' do
         exception = Chef::Exceptions::CookbookFrozen.new
-        @cookbook_uploader.should_receive(:upload_cookbooks).
+        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)
+        knife.ui.stub(:error)
+        knife.ui.should_receive(:error).with(exception)
+        lambda { knife.run }.should raise_error(SystemExit)
       end
 
       it 'should not update the version constraints for an environment' do
-        @knife.stub(:assert_environment_valid!).and_return(true)
-        @knife.config[:environment] = "production"
-        @knife.stub(:upload).and_raise(Chef::Exceptions::CookbookFrozen)
-        @knife.ui.should_receive(:error).with(/Failed to upload 1 cookbook/)
-        @knife.ui.should_receive(:warn).with(/Not updating version constraints/)
-        @knife.should_not_receive(:update_version_constraints)
-        lambda { @knife.run }.should raise_error(SystemExit)
+        knife.stub(:assert_environment_valid!).and_return(true)
+        knife.config[:environment] = "production"
+        knife.stub(:upload).and_raise(Chef::Exceptions::CookbookFrozen)
+        knife.ui.should_receive(:error).with(/Failed to upload 1 cookbook/)
+        knife.ui.should_receive(:warn).with(/Not updating version constraints/)
+        knife.should_not_receive(:update_version_constraints)
+        lambda { knife.run }.should raise_error(SystemExit)
       end
     end
   end # run