chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/unit/encrypted_data_bag_item/check_encrypted_spec.rb

@@ -0,0 +1,95 @@
+#
+# Author:: Tyler Ball (<tball@getchef.com>)
+# Copyright:: Copyright (c) 2010-2014 Opscode, Inc.
+# 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'
+require 'chef/encrypted_data_bag_item/check_encrypted'
+
+class CheckEncryptedTester
+  include Chef::EncryptedDataBagItem::CheckEncrypted
+end
+
+describe Chef::EncryptedDataBagItem::CheckEncrypted do
+
+  let(:tester) { CheckEncryptedTester.new }
+
+  it "detects the item is not encrypted when the data is empty" do
+    expect(tester.encrypted?({})).to eq(false)
+  end
+
+  it "detects the item is not encrypted when the data only contains an id" do
+    expect(tester.encrypted?({id: "foo"})).to eq(false)
+  end
+
+  context "when the item is encrypted" do
+
+    let(:default_secret) { "abc123SECRET" }
+    let(:item_name) { "item_name" }
+    let(:raw_data) {{
+        "id" => item_name,
+        "greeting" => "hello",
+        "nested" => {
+            "a1" => [1, 2, 3],
+            "a2" => { "b1" => true }
+        }
+    }}
+
+    let(:version) { 1 }
+    let(:encoded_data) do
+      Chef::Config[:data_bag_encrypt_version] = version
+      Chef::EncryptedDataBagItem.encrypt_data_bag_item(raw_data, default_secret)
+    end
+
+    it "does not detect encryption when the item version is unknown" do
+      # It shouldn't be possible for someone to normally encrypt an item with an unknown version - they would have to
+      # do something funky like encrypting it and then manually changing the version
+      modified_encoded_data = encoded_data
+      modified_encoded_data["greeting"]["version"] = 4
+      expect(tester.encrypted?(modified_encoded_data)).to eq(false)
+    end
+
+    shared_examples_for "encryption detected" do
+      it "detects encrypted data bag" do
+        expect( encryptor ).to receive(:encryptor_keys).at_least(:once).and_call_original
+        expect(tester.encrypted?(encoded_data)).to eq(true)
+      end
+    end
+
+    context "when encryption version is 1" do
+      include_examples "encryption detected" do
+        let(:version) { 1 }
+        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor }
+      end
+    end
+
+    context "when encryption version is 2" do
+      include_examples "encryption detected" do
+        let(:version) { 2 }
+        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor }
+      end
+    end
+
+    context "when encryption version is 3", :aes_256_gcm_only, :ruby_20_only do
+      include_examples "encryption detected" do
+        let(:version) { 3 }
+        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor }
+      end
+    end
+
+  end
+
+end

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -97,7 +97,7 @@ describe Chef::EncryptedDataBagItem::Encryptor  do
       Chef::Config[:data_bag_encrypt_version] = 3
     end
 
-    context "on supported platforms", :ruby_gte_20_and_openssl_gte_101 do
+    context "on supported platforms", :aes_256_gcm_only, :ruby_20_only do
 
       it "creates a version 3 encryptor" do
         encryptor.should be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor)
@@ -168,10 +168,21 @@ describe Chef::EncryptedDataBagItem::Decryptor do
   let(:plaintext_data) { {"foo" => "bar"} }
   let(:encryption_key) { "passwd" }
   let(:decryption_key) { encryption_key }
+  let(:json_wrapped_data) {  Chef::JSONCompat.to_json({"json_wrapper" => plaintext_data}) }
+
+  shared_examples "decryption examples" do
+    it "decrypts the encrypted value" do
+      decryptor.decrypted_data.should eq(json_wrapped_data)
+    end
+
+    it "unwraps the encrypted data and returns it" do
+      decryptor.for_decrypted_item.should eq plaintext_data
+    end
+  end
 
   context "when decrypting a version 3 (JSON+aes-256-gcm+random iv+auth tag) encrypted value" do
 
-    context "on supported platforms", :ruby_gte_20_and_openssl_gte_101 do
+    context "on supported platforms", :aes_256_gcm_only, :ruby_20_only do
 
       let(:encrypted_value) do
         Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
@@ -179,13 +190,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
 
       let(:bogus_auth_tag) { "bogus_auth_tag" }
 
-      it "decrypts the encrypted value" do
-        decryptor.decrypted_data.should eq({"json_wrapper" => plaintext_data}.to_json)
-      end
-
-      it "unwraps the encrypted data and returns it" do
-        decryptor.for_decrypted_item.should eq plaintext_data
-      end
+      include_examples "decryption examples"
 
       it "rejects the data if the authentication tag is wrong" do
         encrypted_value["auth_tag"] = bogus_auth_tag
@@ -240,13 +245,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       Base64.encode64(raw_hmac)
     end
 
-    it "decrypts the encrypted value" do
-      decryptor.decrypted_data.should eq({"json_wrapper" => plaintext_data}.to_json)
-    end
-
-    it "unwraps the encrypted data and returns it" do
-      decryptor.for_decrypted_item.should eq plaintext_data
-    end
+    include_examples "decryption examples"
 
     it "rejects the data if the hmac is wrong" do
       encrypted_value["hmac"] = bogus_hmac
@@ -270,13 +269,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       decryptor.should be_a_instance_of Chef::EncryptedDataBagItem::Decryptor::Version1Decryptor
     end
 
-    it "decrypts the encrypted value" do
-      decryptor.decrypted_data.should eq({"json_wrapper" => plaintext_data}.to_json)
-    end
-
-    it "unwraps the encrypted data and returns it" do
-      decryptor.for_decrypted_item.should eq plaintext_data
-    end
+    include_examples "decryption examples"
 
     describe "and the decryption step returns invalid data" do
       it "raises a decryption failure error" do

data/spec/unit/environment_spec.rb

@@ -196,7 +196,7 @@ describe Chef::Environment do
 
     %w{name description cookbook_versions}.each do |t|
       it "should include '#{t}'" do
-        @json.should =~ /"#{t}":#{Regexp.escape(@environment.send(t.to_sym).to_json)}/
+        @json.should =~ /"#{t}":#{Regexp.escape(Chef::JSONCompat.to_json(@environment.send(t.to_sym)))}/
       end
     end
 
@@ -207,6 +207,10 @@ describe Chef::Environment do
     it "should include 'chef_type'" do
       @json.should =~ /"chef_type":"environment"/
     end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:jsonable) { @environment }
+    end
   end
 
   describe "from_json" do
@@ -222,7 +226,7 @@ describe Chef::Environment do
         "json_class" => "Chef::Environment",
         "chef_type" => "environment"
       }
-      @environment = Chef::JSONCompat.from_json(@data.to_json)
+      @environment = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data))
     end
 
     it "should return a Chef::Environment" do

data/spec/unit/exceptions_spec.rb

@@ -74,5 +74,11 @@ describe Chef::Exceptions do
     it "should have an exception class of #{exception} which inherits from #{expected_super_class}" do
       lambda{ raise exception }.should raise_error(expected_super_class)
     end
+
+    if exception.methods.include?(:to_json)
+      include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+        let(:jsonable) { exception }
+      end
+    end
   end
 end

data/spec/unit/guard_interpreter/resource_guard_interpreter_spec.rb

@@ -19,37 +19,38 @@
 require 'spec_helper'
 
 describe Chef::GuardInterpreter::ResourceGuardInterpreter do
-  before(:each) do
+  let(:node) do
     node = Chef::Node.new
 
     node.default["kernel"] = Hash.new
     node.default["kernel"][:machine] = :x86_64.to_s
+    node
+  end
 
-    run_context = Chef::RunContext.new(node, nil, nil)
+  let(:run_context) { Chef::RunContext.new(node, nil, nil) }
 
-    @resource = Chef::Resource.new("powershell_unit_test", run_context)
-    @resource.stub(:run_action)
-    @resource.stub(:updated).and_return(true)
+  let(:resource) do
+    resource = Chef::Resource.new("powershell_unit_test", run_context)
+    resource.stub(:run_action)
+    resource.stub(:updated).and_return(true)
+    resource
   end
 
-  describe "when evaluating a guard resource" do
-    let(:resource) { @resource }
 
-    it "should allow guard interpreter to be set to Chef::Resource::Script" do
+  describe "get_interpreter_resource" do
+    it "allows the guard interpreter to be set to Chef::Resource::Script" do
       resource.guard_interpreter(:script)
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
-      resource.only_if("echo hi")
+      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(resource, "echo hi", nil) }.not_to raise_error
     end
     
-    it "should allow guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
+    it "allows the guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
       resource.guard_interpreter(:powershell_script)
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
-      resource.only_if("echo hi")
+      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(resource, "echo hi", nil) }.not_to raise_error
     end
     
-    it "should raise an exception if guard_interpreter is set to a resource not derived from Chef::Resource::Script" do
+    it "raises an exception if guard_interpreter is set to a resource not derived from Chef::Resource::Script" do
       resource.guard_interpreter(:file)
-      expect { resource.only_if("echo hi") }.to raise_error ArgumentError
+      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(resource, "echo hi", nil) }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/unit/json_compat_spec.rb

@@ -58,13 +58,17 @@ describe Chef::JSONCompat do
   describe "when pretty printing an object that defines #to_json" do
     class Foo
       def to_json(*a)
-        {'foo' => 1234}.to_json(*a)
+        Chef::JSONCompat.to_json({'foo' => 1234, 'bar' => {'baz' => 5678}}, *a)
       end
     end
 
     it "should work" do
       f = Foo.new
-      expect(Chef::JSONCompat.to_json_pretty(f)).to eql("{\n  \"foo\": 1234\n}\n")
+      expect(Chef::JSONCompat.to_json_pretty(f)).to eql("{\n  \"foo\": 1234,\n  \"bar\": {\n    \"baz\": 5678\n  }\n}\n")
+    end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:jsonable) { Foo.new }
     end
   end
 
@@ -97,4 +101,10 @@ describe Chef::JSONCompat do
       end
     end
   end
+
+  it "should define .to_json on all classes" do
+    class SomeClass; end
+
+    expect(SomeClass.new.respond_to?(:to_json)).to eq(true)
+  end
 end

data/spec/unit/knife/bootstrap_spec.rb

@@ -22,6 +22,9 @@ Chef::Knife::Bootstrap.load_deps
 require 'net/ssh'
 
 describe Chef::Knife::Bootstrap do
+  before do
+    Chef::Platform.stub(:windows?) { false }
+  end
   let(:knife) do
     Chef::Log.logger = Logger.new(StringIO.new)
     Chef::Config[:knife][:bootstrap_template] = bootstrap_template unless bootstrap_template.nil?
@@ -30,6 +33,7 @@ describe Chef::Knife::Bootstrap do
     k.merge_configs
 
     k.ui.stub(:stderr).and_return(stderr)
+    allow(k).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(false)
     k
   end
 
@@ -221,10 +225,6 @@ describe Chef::Knife::Bootstrap do
       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
@@ -290,7 +290,6 @@ describe Chef::Knife::Bootstrap do
 
   describe "specifying the encrypted data bag secret key" do
     let(:secret) { "supersekret" }
-    let(:secret_file) { File.join(CHEF_SPEC_DATA, 'bootstrap', 'encrypted_data_bag_secret') }
     let(:options) { [] }
     let(:bootstrap_template) { File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "secret.erb")) }
     let(:rendered_template) do
@@ -299,64 +298,22 @@ describe Chef::Knife::Bootstrap do
       knife.render_template
     end
 
-    context "via --secret" do
-      let(:options){ ["--secret", secret] }
-
-      it "creates a secret file" do
-        rendered_template.should match(%r{#{secret}})
-      end
-
-      it "renders the client.rb with an encrypted_data_bag_secret entry" do
-        rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
-      end
+    it "creates a secret file" do
+      expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
+      expect(knife).to receive(:read_secret).and_return(secret)
+      rendered_template.should match(%r{#{secret}})
     end
 
-    context "via --secret-file" do
-      let(:options) { ["--secret-file", secret_file] }
-      let(:secret) { IO.read(secret_file) }
-
-      it "creates a secret file" do
-        rendered_template.should match(%r{#{secret}})
-      end
-
-      it "renders the client.rb with an encrypted_data_bag_secret entry" do
-        rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
-      end
-    end
-
-    context "secret via config" do
-      before do
-        Chef::Config[:knife][:secret] = secret
-      end
-
-      it "creates a secret file" do
-        rendered_template.should match(%r{#{secret}})
-      end
-
-      it "renders the client.rb with an encrypted_data_bag_secret entry" do
-        rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
-      end
+    it "renders the client.rb with an encrypted_data_bag_secret entry" do
+      expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
+      expect(knife).to receive(:read_secret).and_return(secret)
+      rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
     end
 
-    context "secret-file via config" do
-      let(:secret) { IO.read(secret_file) }
-
-      before do
-        Chef::Config[:knife][:secret_file] = secret_file
-      end
-
-      it "creates a secret file" do
-        rendered_template.should match(%r{#{secret}})
-      end
-
-      it "renders the client.rb with an encrypted_data_bag_secret entry" do
-        rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
-      end
-    end
   end
 
   describe "when transferring trusted certificates" do
-    let(:trusted_certs_dir) { File.join(CHEF_SPEC_DATA, 'trusted_certs') }
+    let(:trusted_certs_dir) { Chef::Util::PathHelper.cleanpath(File.join(File.dirname(__FILE__), '../../data/trusted_certs')) }
 
     let(:rendered_template) do
       knife.merge_configs
@@ -366,7 +323,7 @@ describe Chef::Knife::Bootstrap do
     before do
       Chef::Config[:trusted_certs_dir] = trusted_certs_dir
       IO.stub(:read).and_call_original
-      IO.stub(:read).with("/etc/chef/validation.pem").and_return("")
+      IO.stub(:read).with(File.expand_path(Chef::Config[:validation_key])).and_return("")
     end
 
     def certificates
@@ -461,12 +418,6 @@ describe Chef::Knife::Bootstrap do
     context "from the knife config file" do
       let(:knife_ssh) do
         knife.name_args = ["config.example.com"]
-        knife.config[:ssh_user] = nil
-        knife.config[:ssh_port] = nil
-        knife.config[:ssh_gateway] = nil
-        knife.config[:forward_agent] = nil
-        knife.config[:identity_file] = nil
-        knife.config[:host_key_verify] = nil
         Chef::Config[:knife][:ssh_user] = "curiosity"
         Chef::Config[:knife][:ssh_port] = "2430"
         Chef::Config[:knife][:forward_agent] = true
@@ -474,6 +425,8 @@ describe Chef::Knife::Bootstrap do
         Chef::Config[:knife][:ssh_gateway] = "towel.blinkenlights.nl"
         Chef::Config[:knife][:host_key_verify] = true
         knife.stub(:render_template).and_return("")
+        knife.config = {}
+        knife.merge_configs
         knife.knife_ssh
       end
 

data/spec/unit/knife/cookbook_site_share_spec.rb

@@ -25,6 +25,8 @@ describe Chef::Knife::CookbookSiteShare do
 
   before(:each) do
     @knife = Chef::Knife::CookbookSiteShare.new
+    # Merge default settings in.
+    @knife.merge_configs
     @knife.name_args = ['cookbook_name', 'AwesomeSausage']
 
     @cookbook = Chef::CookbookVersion.new('cookbook_name')
@@ -34,6 +36,9 @@ describe Chef::Knife::CookbookSiteShare do
     @cookbook_loader.stub(:[]).and_return(@cookbook)
     Chef::CookbookLoader.stub(:new).and_return(@cookbook_loader)
 
+    @noauth_rest = double(Chef::REST)
+    @knife.stub(:noauth_rest).and_return(@noauth_rest)
+
     @cookbook_uploader = Chef::CookbookUploader.new('herpderp', :rest => "norest")
     Chef::CookbookUploader.stub(:new).and_return(@cookbook_uploader)
     @cookbook_uploader.stub(:validate_cookbooks).and_return(true)
@@ -48,6 +53,20 @@ describe Chef::Knife::CookbookSiteShare do
 
     before(:each) do
       @knife.stub(:do_upload).and_return(true)
+      @category_response = {
+        "name" => "cookbook_name",
+        "category" => "Testing Category"
+      }
+      @bad_category_response = {
+        "error_code" => "NOT_FOUND",
+        "error_messages" => [
+            "Resource does not exist."
+        ]
+      }
+    end
+
+    it 'should set true to config[:dry_run] as default' do
+      @knife.config[:dry_run].should be_false
     end
 
     it 'should should print usage and exit when given no arguments' do
@@ -57,9 +76,23 @@ describe Chef::Knife::CookbookSiteShare do
       lambda { @knife.run }.should raise_error(SystemExit)
     end
 
-    it 'should print usage and exit when given only 1 argument' do
+    it 'should not fail when given only 1 argument and can determine category' do
       @knife.name_args = ['cookbook_name']
-      @knife.should_receive(:show_usage)
+      @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@category_response)
+      @knife.should_receive(:do_upload)
+      @knife.run
+    end
+
+    it 'should print error and exit when given only 1 argument and cannot determine category' do
+      @knife.name_args = ['cookbook_name']
+      @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@bad_category_response)
+      @knife.ui.should_receive(:fatal)
+      lambda { @knife.run }.should raise_error(SystemExit)
+    end
+
+    it 'should print error and exit when given only 1 argument and Chef::REST throws an exception' do
+      @knife.name_args = ['cookbook_name']
+      @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name") { raise Errno::ECONNREFUSED, "Connection refused" }
       @knife.ui.should_receive(:fatal)
       lambda { @knife.run }.should raise_error(SystemExit)
     end
@@ -93,6 +126,26 @@ describe Chef::Knife::CookbookSiteShare do
       FileUtils.should_receive(:rm_rf)
       @knife.run
     end
+
+    context "when the --dry-run flag is specified" do
+      before do
+        Chef::CookbookSiteStreamingUploader.stub(:create_build_dir).and_return("/var/tmp/dummy")
+        @knife.config = { :dry_run => true }
+        @knife.stub_chain(:shell_out!, :stdout).and_return('file')
+      end
+
+      it "should list files in the tarball" do
+        expect(@knife).to receive(:shell_out!).with("tar -czf #{@cookbook.name}.tgz #{@cookbook.name}", {:cwd => "/var/tmp/dummy"})
+        expect(@knife).to receive(:shell_out!).with("tar -tzf #{@cookbook.name}.tgz", {:cwd => "/var/tmp/dummy"})
+        @knife.run
+      end
+
+      it "does not upload the cookbook" do
+        allow(@knife).to receive(:shell_out!).and_return(true)
+        expect(@knife).not_to receive(:do_upload)
+        @knife.run
+      end
+    end
   end
 
   describe 'do_upload' do
@@ -109,7 +162,7 @@ describe Chef::Knife::CookbookSiteShare do
     end
 
     it 'should post the cookbook to "https://supermarket.getchef.com"' do
-      response_text = {:uri => 'https://supermarket.getchef.com/cookbooks/cookbook_name'}.to_json
+      response_text = Chef::JSONCompat.to_json({:uri => 'https://supermarket.getchef.com/cookbooks/cookbook_name'})
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(201)
       Chef::CookbookSiteStreamingUploader.should_receive(:post).with(/supermarket\.getchef\.com/, anything(), anything(), anything())
@@ -117,7 +170,7 @@ describe Chef::Knife::CookbookSiteShare do
     end
 
     it 'should alert the user when a version already exists' do
-      response_text = {:error_messages => ['Version already exists']}.to_json
+      response_text = Chef::JSONCompat.to_json({:error_messages => ['Version already exists']})
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(409)
       lambda { @knife.run }.should raise_error(SystemExit)
@@ -125,7 +178,7 @@ describe Chef::Knife::CookbookSiteShare do
     end
 
     it 'should pass any errors on to the user' do
-      response_text = {:error_messages => ["You're holding it wrong"]}.to_json
+      response_text = Chef::JSONCompat.to_json({:error_messages => ["You're holding it wrong"]})
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(403)
       lambda { @knife.run }.should raise_error(SystemExit)
@@ -133,7 +186,7 @@ describe Chef::Knife::CookbookSiteShare do
     end
 
     it 'should print the body if no errors are exposed on failure' do
-      response_text = {:system_error => "Your call was dropped", :reason => "There's a map for that"}.to_json
+      response_text = Chef::JSONCompat.to_json({:system_error => "Your call was dropped", :reason => "There's a map for that"})
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(500)
       @knife.ui.should_receive(:error).with(/#{Regexp.escape(response_text)}/)#.ordered