chef 10.34.6 → 11.0.0.beta.0

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,124 +28,6 @@ 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
-
-    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
-    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
-    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
@@ -157,6 +40,153 @@ describe Chef::Knife::UI do
     end
   end
 
+  describe "output" do
+    it "formats strings appropriately" do
+      @ui.output("hi")
+      @out.string.should == "hi\n"
+    end
+
+    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 "format_for_display" do
     it "should return the raw data" do
       input = { :gi => :go }
@@ -165,20 +195,21 @@ 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
     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 +238,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))

data/spec/unit/knife/index_rebuild_spec.rb

@@ -19,47 +19,110 @@
 require 'spec_helper'
 
 describe Chef::Knife::IndexRebuild do
-  before do
-    Chef::Config[:node_name]  = "webmonkey.example.com"
-    @knife = Chef::Knife::IndexRebuild.new
-    @rest_client = mock("Chef::REST (mock)", :post_rest => { :result => :true })
-    @knife.ui.stub!(:output)
-    @knife.stub!(:rest).and_return(@rest_client)
-
-    @out = StringIO.new
-    @knife.ui.stub!(:stdout).and_return(@out)
-  end
 
-  it "asks a yes/no confirmation and aborts on 'no'" do
-    @knife.ui.stub!(:stdin).and_return(StringIO.new("NO\n"))
-    @knife.should_receive(:puts)
-    @knife.should_receive(:exit).with(7)
-    @knife.run
-    @out.string.should match(/yes\/no/)
+  let(:knife){Chef::Knife::IndexRebuild.new}
+  let(:rest_client){mock(Chef::REST)}
+
+  let(:stub_rest!) do
+    knife.should_receive(:rest).and_return(rest_client)
   end
 
-  it "asks a confirmation and continues on 'yes'" do
-    @knife.ui.stub!(:stdin).and_return(StringIO.new("yes\n"))
-    @knife.should_not_receive(:exit)
-    @knife.run
-    @out.string.should match(/yes\/no/)
+  before :each do
+    # This keeps the test output clean
+    knife.ui.stub!(:stdout).and_return(StringIO.new)
   end
 
-  describe "after confirming the operation" do
-    before do
-      @knife.ui.stub!(:print)
-      @knife.ui.stub!(:puts)
-      @knife.stub!(:nag)
-      @knife.ui.stub!(:output)
+  context "#grab_api_info" do
+    let(:http_not_found_response) do
+      e = Net::HTTPNotFound.new("1.1", 404, "blah")
+      e.stub(:[]).with("x-ops-api-info").and_return(api_header_value)
+      e
+    end
+
+    let(:http_server_exception) do
+      Net::HTTPServerException.new("404: Not Found", http_not_found_response)
+    end
+
+    before(:each) do
+      stub_rest!
+      rest_client.stub(:get_rest).and_raise(http_server_exception)
+    end
+
+    context "against a Chef 11 server" do
+      let(:api_header_value){"flavor=osc;version=11.0.0;erchef=1.2.3"}
+      it "retrieves API information" do
+        knife.grab_api_info.should == {"flavor" => "osc", "version" => "11.0.0", "erchef" => "1.2.3"}
+      end
+    end # Chef 11
+
+    context "against a Chef 10 server" do
+      let(:api_header_value){nil}
+      it "finds no API information" do
+        knife.grab_api_info.should == {}
+      end
+    end # Chef 10
+  end # grab_api_info
+
+  context "#unsupported_version?" do
+    context "with Chef 11 API metadata" do
+      it "is unsupported" do
+        knife.unsupported_version?({"version" => "11.0.0", "flavor" => "osc", "erchef" => "1.2.3"}).should be_true
+      end
+
+      it "only truly relies on the version being non-nil" do
+        knife.unsupported_version?({"version" => "1", "flavor" => "osc", "erchef" => "1.2.3"}).should be_true
+      end
     end
 
-    it "POSTs to /search/reindex and displays the result" do
-      @rest_client = mock("Chef::REST")
-      @knife.stub!(:rest).and_return(@rest_client)
-      @rest_client.should_receive(:post_rest).with("/search/reindex", {}).and_return("monkey")
-      @knife.should_receive(:output).with("monkey")
-      @knife.run
+    context "with Chef 10 API metadata" do
+      it "is supported" do
+        # Chef 10 will have no metadata
+        knife.unsupported_version?({}).should be_false
+      end
+    end
+  end # unsupported_version?
+
+  context "Simulating a 'knife index rebuild' run" do
+
+    before :each do
+      knife.should_receive(:grab_api_info).and_return(api_info)
+      server_specific_stubs!
+    end
+
+    context "against a Chef 11 server" do
+      let(:api_info) do
+        {"flavor" => "osc", 
+          "version" => "11.0.0",
+          "erchef" => "1.2.3"
+        }
+      end
+      let(:server_specific_stubs!) do
+        knife.should_receive(:unsupported_server_message).with(api_info)
+        knife.should_receive(:exit).with(1)
+      end
+
+      it "should not be allowed" do
+        knife.run
+      end
+    end
+
+    context "against a Chef 10 server" do
+      let(:api_info){ {} }
+      let(:server_specific_stubs!) do
+        stub_rest!
+        rest_client.should_receive(:post_rest).with("/search/reindex", {}).and_return("representative output")
+        knife.should_not_receive(:unsupported_server_message)
+        knife.should_receive(:deprecated_server_message)
+        knife.should_receive(:nag)
+        knife.should_receive(:output).with("representative output")
+      end
+      it "should be allowed" do
+        knife.run
+      end
     end
   end
 
 end
+
+
+