microwave 1.0.4 → 11.400.2

data/spec/unit/knife/data_bag_create_spec.rb

@@ -75,8 +75,22 @@ describe Chef::Knife::DataBagCreate do
       @knife.should_receive(:create_object).and_yield(@plain_data)
       data_bag_item = Chef::DataBagItem.from_hash(@enc_data)
       data_bag_item.data_bag("sudoing_admins")
+
+      # Random IV is used each time the data bag item is encrypted, so values
+      # will not be equal if we re-encrypt.
+      Chef::EncryptedDataBagItem.should_receive(:encrypt_data_bag_item).and_return(@enc_data)
+
       @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

@@ -59,6 +59,19 @@ describe Chef::Knife::DataBagEdit do
       @enc_edited_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@edited_data,
                                                                           @secret)
       Chef::DataBagItem.stub!(:load).with('bag_name', 'item_name').and_return(@enc_data)
+
+      # Random IV is used each time the data bag item is encrypted, so values
+      # will not be equal if we encrypt same value twice.
+      Chef::EncryptedDataBagItem.should_receive(:encrypt_data_bag_item).and_return(@enc_edited_data)
+
+      @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 "decrypts and encrypts via --secret" do
@@ -70,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

@@ -142,6 +142,19 @@ describe Chef::Knife::DataBagFromFile do
       @secret = "abc123SECRET"
       @enc_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@plain_data,
                                                                    @secret)
+
+      # Random IV is used each time the data bag item is encrypted, so values
+      # will not be equal if we re-encrypt.
+      Chef::EncryptedDataBagItem.should_receive(:encrypt_data_bag_item).and_return(@enc_data)
+
+      @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 "encrypts values when given --secret" do
@@ -157,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
@@ -177,7 +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)
-      @stdout.string.should match(/^knife data bag from file BAG FILE|FOLDER [FILE|FOLDER..] \(options\)/)
+      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
+
+
+

data/spec/unit/knife/knife_help.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -21,7 +21,7 @@ require 'spec_helper'
 describe Chef::Knife::Help do
   before(:each) do
     # Perilously use the build in list even though it is dynamic so we don't get warnings about the constant
-    # HELP_TOPICS = [ "foo", "bar", "knife-kittens", "ceiling-cat", "shef" ]
+    # HELP_TOPICS = [ "foo", "bar", "knife-kittens", "ceiling-cat", "shell" ]
     @knife = Chef::Knife::Help.new
   end
 
@@ -30,8 +30,8 @@ describe Chef::Knife::Help do
   end
 
   it "should run man for you" do
-    @knife.name_args = [ "shef" ]
-    @knife.should_receive(:exec).with(/^man \/.*\/shef.1$/)
+    @knife.name_args = [ "shell" ]
+    @knife.should_receive(:exec).with(/^man \/.*\/shell.1$/)
     @knife.run
   end
 
@@ -47,9 +47,9 @@ describe Chef::Knife::Help do
 
   describe "find_manpage_path" do
     it "should find the man page in the gem" do
-      @knife.find_manpage_path("shef").should =~ /distro\/common\/man\/man1\/shef.1$/
+      @knife.find_manpage_path("shell").should =~ /distro\/common\/man\/man1\/chef-shell.1$/
     end
-  
+
     it "should provide the man page name if not in the gem" do
       @knife.find_manpage_path("foo").should == "foo"
     end

data/spec/unit/knife/node_run_list_remove_spec.rb

@@ -25,6 +25,7 @@ describe Chef::Knife::NodeRunListRemove do
     @knife.config[:print_after] = nil
     @knife.name_args = [ "adam", "role[monkey]" ]
     @node = Chef::Node.new()
+    @node.name("knifetest-node")
     @node.run_list << "role[monkey]"
     @node.stub!(:save).and_return(true)
 
@@ -52,7 +53,7 @@ describe Chef::Knife::NodeRunListRemove do
 
     it "should print the run list" do
       @knife.config[:print_after] = true
-      @knife.ui.should_receive(:output).with({ 'run_list' => [] })
+      @knife.ui.should_receive(:output).with({ "knifetest-node" => { 'run_list' => [] } })
       @knife.run
     end
 

data/spec/unit/knife/ssh_spec.rb

@@ -34,14 +34,14 @@ describe Chef::Knife::Ssh do
 
   before do
     @knife = Chef::Knife::Ssh.new
-    @knife.config = {}
+    @knife.merge_configs
     @knife.config[:attribute] = "fqdn"
-    @node_foo = Chef::Node.new('foo')
-    @node_foo[:fqdn] = "foo.example.org"
-    @node_foo[:ipaddress] = "10.0.0.1"
-    @node_bar = Chef::Node.new('bar')
-    @node_bar[:fqdn] = "bar.example.org"
-    @node_bar[:ipaddress] = "10.0.0.2"
+    @node_foo = Chef::Node.new
+    @node_foo.automatic_attrs[:fqdn] = "foo.example.org"
+    @node_foo.automatic_attrs[:ipaddress] = "10.0.0.1"
+    @node_bar = Chef::Node.new
+    @node_bar.automatic_attrs[:fqdn] = "bar.example.org"
+    @node_bar.automatic_attrs[:ipaddress] = "10.0.0.2"
   end
 
   describe "#configure_session" do
@@ -64,7 +64,7 @@ describe Chef::Knife::Ssh do
           @knife.should_receive(:session_from_list).with(['10.0.0.1', '10.0.0.2'])
           @knife.configure_session
         end
-        
+
         it "returns an array of the attributes specified on the command line even when a config value is set" do
           @knife.config[:attribute] = "config_file" # this value will be the config file
           @knife.config[:override_attribute] = "ipaddress" # this is the value of the command line via #configure_attribute
@@ -84,10 +84,8 @@ describe Chef::Knife::Ssh do
 
       context "when cloud hostnames are available" do
         before do
-          @node_foo[:cloud] = Mash.new
-          @node_bar[:cloud] = Mash.new
-          @node_foo[:cloud][:public_hostname] = "ec2-10-0-0-1.compute-1.amazonaws.com"
-          @node_bar[:cloud][:public_hostname] = "ec2-10-0-0-2.compute-1.amazonaws.com"
+          @node_foo.automatic_attrs[:cloud][:public_hostname] = "ec2-10-0-0-1.compute-1.amazonaws.com"
+          @node_bar.automatic_attrs[:cloud][:public_hostname] = "ec2-10-0-0-2.compute-1.amazonaws.com"
         end
 
         it "returns an array of cloud public hostnames" do
@@ -109,8 +107,8 @@ describe Chef::Knife::Ssh do
       context "when there are some hosts found but they do not have an attribute to connect with" do
         before do
           @query.stub!(:search).and_return([[@node_foo, @node_bar]])
-          @node_foo[:fqdn] = nil
-          @node_bar[:fqdn] = nil
+          @node_foo.automatic_attrs[:fqdn] = nil
+          @node_bar.automatic_attrs[:fqdn] = nil
           Chef::Search::Query.stub!(:new).and_return(@query)
         end
 
@@ -180,5 +178,113 @@ describe Chef::Knife::Ssh do
     end
   end
 
-end
+  describe "#session_from_list" do
+    before :each do
+      @knife.instance_variable_set(:@longest, 0)
+      ssh_config = {:timeout => 50, :user => "locutus", :port => 23 }
+      Net::SSH.stub!(:configuration_for).with('the.b.org').and_return(ssh_config)
+    end
+
+    it "uses the port from an ssh config file" do
+      @knife.session_from_list(['the.b.org'])
+      @knife.session.servers[0].port.should == 23
+    end
+
+    it "uses the user from an ssh config file" do
+      @knife.session_from_list(['the.b.org'])
+      @knife.session.servers[0].user.should == "locutus"
+    end
+  end
+
+  describe "#ssh_command" do
+    let(:execution_channel) { double(:execution_channel, :on_data => nil) }
+    let(:session_channel) { double(:session_channel, :request_pty => nil)}
+
+    let(:execution_channel2) { double(:execution_channel, :on_data => nil) }
+    let(:session_channel2) { double(:session_channel, :request_pty => nil)}
+
+    let(:session) { double(:session, :loop => nil) }
+
+    let(:command) { "false" }
+
+    before do
+      execution_channel.
+        should_receive(:on_request).
+        and_yield(nil, double(:data_stream, :read_long => exit_status))
+
+      session_channel.
+        should_receive(:exec).
+        with(command).
+        and_yield(execution_channel, true)
+
+      execution_channel2.
+        should_receive(:on_request).
+        and_yield(nil, double(:data_stream, :read_long => exit_status2))
+
+      session_channel2.
+        should_receive(:exec).
+        with(command).
+        and_yield(execution_channel2, true)
+
+      session.
+        should_receive(:open_channel).
+        and_yield(session_channel).
+        and_yield(session_channel2)
+    end
+
+    context "both connections return 0" do
+      let(:exit_status) { 0 }
+      let(:exit_status2) { 0 }
+
+      it "returns a 0 exit code" do
+        @knife.ssh_command(command, session).should == 0
+      end
+    end
+
+    context "the first connection returns 1 and the second returns 0" do
+      let(:exit_status) { 1 }
+      let(:exit_status2) { 0 }
+
+      it "returns a non-zero exit code" do
+        @knife.ssh_command(command, session).should == 1
+      end
+    end
+
+    context "the first connection returns 1 and the second returns 2" do
+      let(:exit_status) { 1 }
+      let(:exit_status2) { 2 }
+
+      it "returns a non-zero exit code" do
+        @knife.ssh_command(command, session).should == 2
+      end
+    end
+  end
+
+  describe "#run" do
+    before do
+      @query = Chef::Search::Query.new
+      @query.should_receive(:search).and_return([[@node_foo]])
+      Chef::Search::Query.stub!(:new).and_return(@query)
+      @knife.stub(:ssh_command).and_return(exit_code)
+      @knife.name_args = ['*:*', 'false']
+    end
+
+    context "with an error" do
+      let(:exit_code) { 1 }
+
+      it "should exit with a non-zero exit code" do
+        @knife.should_receive(:exit).with(exit_code)
+        @knife.run
+      end
+    end
 
+    context "with no error" do
+      let(:exit_code) { 0 }
+
+      it "should not exit" do
+        @knife.should_not_receive(:exit)
+        @knife.run
+      end
+    end
+  end
+end