chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

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

@@ -2,7 +2,8 @@
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Tim Hinderliter (<tim@opscode.com>)
 # Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2011 Opscode, Inc.
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2011, 2012 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,134 +28,198 @@ describe Chef::Knife::UI do
     @ui = Chef::Knife::UI.new(@out, @err, @in, @config)
   end
 
-  describe "edit" do
-    ruby_for_json = { 'foo' => 'bar' }
-    json_from_ruby = "{\n  \"foo\": \"bar\"\n}"
-    json_from_editor = "{\n  \"bar\": \"foo\"\n}"
-    ruby_from_editor = { 'bar' => 'foo' }
-    my_editor = "veeeye"
-    temp_path = "/tmp/bar/baz"
-
-    let(:subject) { @ui.edit_data(ruby_for_json, parse_output) }
-    let(:parse_output) { false }
-
-    context "when editing is disabled" do
-      before do
-        @ui.config[:disable_editing] = true
-        stub_const("Tempfile", double)  # Tempfiles should never be invoked
-      end
-      context "when parse_output is false" do
-        it "returns pretty json string" do
-          expect(subject).to eql(json_from_ruby)
-        end
-      end
-      context "when parse_output is true" do
-        let(:parse_output) { true }
-        it "returns a ruby object" do
-          expect(subject).to eql(ruby_for_json)
-        end
-      end
+  describe "format_list_for_display" do
+    it "should print the full hash if --with-uri is true" do
+      @ui.config[:with_uri] = true
+      @ui.format_list_for_display({ :marcy => :playground }).should == { :marcy => :playground }
+    end
 
+    it "should print only the keys if --with-uri is false" do
+      @ui.config[:with_uri] = false
+      @ui.format_list_for_display({ :marcy => :playground }).should == [ :marcy ]
     end
+  end
 
-    context "when editing is enabled" do
-      before do
-        @ui.config[:disable_editing] = false
-        @ui.config[:editor] = my_editor
-        @mock = mock('Tempfile')
-        @mock.should_receive(:sync=).with(true)
-        @mock.should_receive(:puts).with(json_from_ruby)
-        @mock.should_receive(:close)
-        @mock.should_receive(:path).at_least(:once).and_return(temp_path)
-        Tempfile.should_receive(:open).with([ 'knife-edit-', '.json' ]).and_yield(@mock)
-      end
-      context "and the editor works" do
-        before do
-          @ui.should_receive(:system).with("#{my_editor} #{temp_path}").and_return(true)
-          IO.should_receive(:read).with(temp_path).and_return(json_from_editor)
-        end
-
-        context "when parse_output is false" do
-          it "returns an edited pretty json string" do
-            expect(subject).to eql(json_from_editor)
-          end
-        end
-        context "when parse_output is true" do
-          let(:parse_output) { true }
-          it "returns an edited ruby object" do
-            expect(subject).to eql(ruby_from_editor)
-          end
-        end
-      end
-      context "when running the editor fails with nil" do
-        before do
-          @ui.should_receive(:system).with("#{my_editor} #{temp_path}").and_return(nil)
-          IO.should_not_receive(:read)
-        end
-        it "throws an exception" do
-          expect{ subject }.to raise_error(RuntimeError)
-        end
-      end
-      context "when running the editor fails with false" do
-        before do
-          @ui.should_receive(:system).with("#{my_editor} #{temp_path}").and_return(false)
-          IO.should_not_receive(:read)
-        end
-        it "throws an exception" do
-          expect{ subject }.to raise_error(RuntimeError)
-        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
-    context "when editing and not stubbing Tempfile (semi-functional test)" do
-      before do
-        @ui.config[:disable_editing] = false
-        @ui.config[:editor] = my_editor
-        @tempfile = Tempfile.new([ 'knife-edit-', '.json' ])
-        Tempfile.should_receive(:open).with([ 'knife-edit-', '.json' ]).and_yield(@tempfile)
-      end
 
-      context "and the editor works" do
-        before do
-          @ui.should_receive(:system).with("#{my_editor} #{@tempfile.path}").and_return(true)
-          IO.should_receive(:read).with(@tempfile.path).and_return(json_from_editor)
-        end
-
-        context "when parse_output is false" do
-          it "returns an edited pretty json string" do
-            expect(subject).to eql(json_from_editor)
-          end
-          it "the tempfile should have mode 0600", :unix_only do
-            # XXX: this looks odd because we're really testing Tempfile.new here
-            expect(File.stat(@tempfile.path).mode & 0777).to eql(0600)
-            expect(subject).to eql(json_from_editor)
-          end
-        end
-
-        context "when parse_output is true" do
-          let(:parse_output) { true }
-          it "returns an edited ruby object" do
-            expect(subject).to eql(ruby_from_editor)
-          end
-          it "the tempfile should have mode 0600", :unix_only do
-            # XXX: this looks odd because we're really testing Tempfile.new here
-            expect(File.stat(@tempfile.path).mode & 0777).to eql(0600)
-            expect(subject).to eql(ruby_from_editor)
-          end
-        end
-      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 "format_list_for_display" do
-    it "should print the full hash if --with-uri is true" do
-      @ui.config[:with_uri] = true
-      @ui.format_list_for_display({ :marcy => :playground }).should == { :marcy => :playground }
+  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"
     end
 
-    it "should print only the keys if --with-uri is false" do
-      @ui.config[:with_uri] = false
-      @ui.format_list_for_display({ :marcy => :playground }).should == [ :marcy ]
+    it "formats hashes appropriately" do
+      @ui.output({'hi' => 'a', 'lo' => 'b' })
+      @out.string.should == <<EOM
+hi: a
+lo: b
+EOM
+    end
+
+    it "formats empty hashes appropriately" do
+      @ui.output({})
+      @out.string.should == "\n"
+    end
+
+    it "formats arrays appropriately" do
+      @ui.output([ 'a', 'b' ])
+      @out.string.should == <<EOM
+a
+b
+EOM
+    end
+
+    it "formats empty arrays appropriately" do
+      @ui.output([ ])
+      @out.string.should == "\n"
+    end
+
+    it "formats single-member arrays appropriately" do
+      @ui.output([ 'a' ])
+      @out.string.should == "a\n"
     end
+
+    it "formats nested single-member arrays appropriately" do
+      @ui.output([ [ 'a' ] ])
+      @out.string.should == "a\n"
+    end
+
+    it "formats nested arrays appropriately" do
+      @ui.output([ [ 'a', 'b' ], [ 'c', 'd' ]])
+      @out.string.should == <<EOM
+a
+b
+
+c
+d
+EOM
+    end
+
+    it "formats nested arrays with single- and empty subarrays appropriately" do
+      @ui.output([ [ 'a', 'b' ], [ 'c' ], [], [ 'd', 'e' ]])
+      @out.string.should == <<EOM
+a
+b
+
+c
+
+
+d
+e
+EOM
+    end
+
+    it "formats arrays of hashes with extra lines in between for readability" do
+      @ui.output([ { 'a' => 'b', 'c' => 'd' }, { 'x' => 'y' }, { 'm' => 'n', 'o' => 'p' }])
+      @out.string.should == <<EOM
+a: b
+c: d
+
+x: y
+
+m: n
+o: p
+EOM
+    end
+
+    it "formats hashes with empty array members appropriately" do
+      @ui.output({ 'a' => [], 'b' => 'c' })
+      @out.string.should == <<EOM
+a:
+b: c
+EOM
+    end
+
+    it "formats hashes with single-member array values appropriately" do
+      @ui.output({ 'a' => [ 'foo' ], 'b' => 'c' })
+      @out.string.should == <<EOM
+a: foo
+b: c
+EOM
+    end
+
+    it "formats hashes with array members appropriately" do
+      @ui.output({ 'a' => [ 'foo', 'bar' ], 'b' => 'c' })
+      @out.string.should == <<EOM
+a:
+  foo
+  bar
+b: c
+EOM
+    end
+
+    it "formats hashes with single-member nested array values appropriately" do
+      @ui.output({ 'a' => [ [ 'foo' ] ], 'b' => 'c' })
+      @out.string.should == <<EOM
+a:
+  foo
+b: c
+EOM
+    end
+
+    it "formats hashes with nested array values appropriately" do
+      @ui.output({ 'a' => [ [ 'foo', 'bar' ], [ 'baz', 'bjork' ] ], 'b' => 'c' })
+      @out.string.should == <<EOM
+a:
+  foo
+  bar
+  
+  baz
+  bjork
+b: c
+EOM
+    end
+
+    it "formats hashes with hash values appropriately" do
+      @ui.output({ 'a' => { 'aa' => 'bb', 'cc' => 'dd' }, 'b' => 'c' })
+      @out.string.should == <<EOM
+a:
+  aa: bb
+  cc: dd
+b: c
+EOM
+    end
+
+    it "formats hashes with empty hash values appropriately" do
+      @ui.output({ 'a' => { }, 'b' => 'c' })
+      @out.string.should == <<EOM
+a:
+b: c
+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
@@ -165,20 +230,27 @@ describe Chef::Knife::UI do
 
     describe "with --attribute passed" do
       it "should return the deeply nested attribute" do
-        input = { "gi" => { "go" => "ge" } }
+        input = { "gi" => { "go" => "ge" }, "id" => "sample-data-bag-item" }
         @ui.config[:attribute] = "gi.go"
-        @ui.format_for_display(input).should == { "gi.go" => "ge" }
+        @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
       it "should return the run list" do
         input = Chef::Node.new
+        input.name("sample-node")
         input.run_list("role[monkey]", "role[churchmouse]")
         @ui.config[:run_list] = true
         response = @ui.format_for_display(input)
-        response["run_list"][0].should == "role[monkey]"
-        response["run_list"][1].should == "role[churchmouse]"
+        response["sample-node"]["run_list"][0].should == "role[monkey]"
+        response["sample-node"]["run_list"][1].should == "role[churchmouse]"
       end
     end
   end
@@ -207,8 +279,8 @@ describe Chef::Knife::UI do
       it "should return the URIs" do
         response = {
           "cookbook_name"=>{
-            "1.0.0" => "http://url/cookbooks/1.0.0", 
-            "2.0.0" => "http://url/cookbooks/2.0.0", 
+            "1.0.0" => "http://url/cookbooks/1.0.0",
+            "2.0.0" => "http://url/cookbooks/2.0.0",
             "3.0.0" => "http://url/cookbooks/3.0.0"}
         }
         @ui.config[:with_uri] = true

data/spec/unit/knife/data_bag_create_spec.rb

@@ -82,6 +82,15 @@ describe Chef::Knife::DataBagCreate do
 
       @rest.should_receive(:post_rest).with("data", {'name' => 'sudoing_admins'}).ordered
       @rest.should_receive(:post_rest).with("data/sudoing_admins", data_bag_item).ordered
+
+      @secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
+      @secret_file.puts(@secret)
+      @secret_file.flush
+    end
+
+    after do
+      @secret_file.close
+      @secret_file.unlink
     end
 
     it "creates an encrypted data bag item via --secret" do

data/spec/unit/knife/data_bag_edit_spec.rb

@@ -83,10 +83,7 @@ describe Chef::Knife::DataBagEdit do
     end
 
     it "decrypts and encrypts via --secret_file" do
-      secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
-      secret_file.puts(@secret)
-      secret_file.flush
-      @knife.stub!(:config).and_return({:secret_file => secret_file.path})
+      @knife.stub!(:config).and_return({:secret_file => @secret_file.path})
       @knife.should_receive(:edit_data).with(@plain_data).and_return(@edited_data)
       @rest.should_receive(:put_rest).with("data/bag_name/item_name", @enc_edited_data).ordered
 

data/spec/unit/knife/data_bag_from_file_spec.rb

@@ -170,10 +170,7 @@ describe Chef::Knife::DataBagFromFile do
     end
 
     it "encrypts values when given --secret_file" do
-      secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
-      secret_file.puts(@secret)
-      secret_file.flush
-      @knife.stub!(:config).and_return({:secret_file => secret_file.path})
+      @knife.stub!(:config).and_return({:secret_file => @secret_file.path})
 
       @knife.loader.stub!(:load_from).with("data_bags", 'bag_name', @db_file.path).and_return(@plain_data)
       dbag = Chef::DataBagItem.new
@@ -190,8 +187,9 @@ describe Chef::Knife::DataBagFromFile do
     it "prints help if given no arguments" do
       @knife.instance_variable_set(:@name_args, [])
       lambda { @knife.run }.should raise_error(SystemExit)
-      expected = 'knife data bag from file BAG FILE|FOLDER [FILE|FOLDER..] (options)'
-      @stdout.string.should include(expected)
+      help_text = "knife data bag from file BAG FILE|FOLDER [FILE|FOLDER..] (options)"
+      help_text_regex = Regexp.new("^#{Regexp.escape(help_text)}")
+      @stdout.string.should match(help_text_regex)
     end
   end
 

data/spec/unit/knife/data_bag_show_spec.rb

@@ -57,6 +57,7 @@ describe Chef::Knife::DataBagShow do
 
     @knife.run
     Chef::JSONCompat.from_json(@stdout.string).should == data_item.raw_data
+
   end
 
   describe "encrypted data bag items" do
@@ -70,6 +71,15 @@ describe Chef::Knife::DataBagShow do
       @enc_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@plain_data,
                                                                    @secret)
       @knife.instance_variable_set(:@name_args, ['bag_name', 'item_name'])
+
+      @secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
+      @secret_file.puts(@secret)
+      @secret_file.flush
+    end
+
+    after do
+      @secret_file.close
+      @secret_file.unlink
     end
 
     it "prints the decrypted contents of an item when given --secret" do
@@ -82,10 +92,7 @@ describe Chef::Knife::DataBagShow do
     end
 
     it "prints the decrypted contents of an item when given --secret_file" do
-      secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
-      secret_file.puts(@secret)
-      secret_file.flush
-      @knife.stub!(:config).and_return({:secret_file => secret_file.path})
+      @knife.stub!(:config).and_return({:secret_file => @secret_file.path})
       Chef::EncryptedDataBagItem.should_receive(:load).
         with('bag_name', 'item_name', @secret).
         and_return(Chef::EncryptedDataBagItem.new(@enc_data, @secret))