chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/http/simple_spec.rb

@@ -25,8 +25,8 @@ describe Chef::HTTP::Simple do
     content_length = middlewares.find_index { |e| e.is_a? Chef::HTTP::ValidateContentLength }
     decompressor = middlewares.find_index { |e| e.is_a? Chef::HTTP::Decompressor }
 
-    content_length.should_not be_nil
-    decompressor.should_not be_nil
-    (decompressor < content_length).should be_true
+    expect(content_length).not_to be_nil
+    expect(decompressor).not_to be_nil
+    expect(decompressor < content_length).to be_truthy
   end
 end

data/spec/unit/http/ssl_policies_spec.rb

@@ -45,31 +45,31 @@ describe "HTTP SSL Policy" do
       end
 
       it "configures the HTTP client to use SSL when given a URL with the https protocol" do
-        http_client.use_ssl?.should be_true
+        expect(http_client.use_ssl?).to be_truthy
       end
 
       it "sets the OpenSSL verify mode to verify_peer" do
-        http_client.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+        expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
       end
 
       it "raises a ConfigurationError if :ssl_ca_path is set to a path that doesn't exist" do
         Chef::Config[:ssl_ca_path] = "/dev/null/nothing_here"
-        lambda {http_client}.should raise_error(Chef::Exceptions::ConfigurationError)
+        expect {http_client}.to raise_error(Chef::Exceptions::ConfigurationError)
       end
 
       it "should set the CA path if that is set in the configuration" do
         Chef::Config[:ssl_ca_path] = File.join(CHEF_SPEC_DATA, "ssl")
-        http_client.ca_path.should == File.join(CHEF_SPEC_DATA, "ssl")
+        expect(http_client.ca_path).to eq(File.join(CHEF_SPEC_DATA, "ssl"))
       end
 
       it "raises a ConfigurationError if :ssl_ca_file is set to a file that does not exist" do
         Chef::Config[:ssl_ca_file] = "/dev/null/nothing_here"
-        lambda {http_client}.should raise_error(Chef::Exceptions::ConfigurationError)
+        expect {http_client}.to raise_error(Chef::Exceptions::ConfigurationError)
       end
 
       it "should set the CA file if that is set in the configuration" do
         Chef::Config[:ssl_ca_file] = CHEF_SPEC_DATA + '/ssl/5e707473.0'
-        http_client.ca_file.should == CHEF_SPEC_DATA + '/ssl/5e707473.0'
+        expect(http_client.ca_file).to eq(CHEF_SPEC_DATA + '/ssl/5e707473.0')
       end
     end
 
@@ -80,7 +80,7 @@ describe "HTTP SSL Policy" do
       end
 
       it "sets the OpenSSL verify mode to :verify_none" do
-        http_client.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+        expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
       end
     end
 
@@ -90,26 +90,26 @@ describe "HTTP SSL Policy" do
       it "raises ConfigurationError if the certificate file doesn't exist" do
         Chef::Config[:ssl_client_cert] = "/dev/null/nothing_here"
         Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + '/ssl/chef-rspec.key'
-        lambda {http_client}.should raise_error(Chef::Exceptions::ConfigurationError)
+        expect {http_client}.to raise_error(Chef::Exceptions::ConfigurationError)
       end
 
       it "raises ConfigurationError if the certificate file doesn't exist" do
         Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + '/ssl/chef-rspec.cert'
         Chef::Config[:ssl_client_key]  = "/dev/null/nothing_here"
-        lambda {http_client}.should raise_error(Chef::Exceptions::ConfigurationError)
+        expect {http_client}.to raise_error(Chef::Exceptions::ConfigurationError)
       end
 
       it "raises a ConfigurationError if one of :ssl_client_cert and :ssl_client_key is set but not both" do
         Chef::Config[:ssl_client_cert] = "/dev/null/nothing_here"
         Chef::Config[:ssl_client_key]  = nil
-        lambda {http_client}.should raise_error(Chef::Exceptions::ConfigurationError)
+        expect {http_client}.to raise_error(Chef::Exceptions::ConfigurationError)
       end
 
       it "configures the HTTP client's cert and private key" do
         Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + '/ssl/chef-rspec.cert'
         Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + '/ssl/chef-rspec.key'
-        http_client.cert.to_s.should == OpenSSL::X509::Certificate.new(IO.read(CHEF_SPEC_DATA + '/ssl/chef-rspec.cert')).to_s
-        http_client.key.to_s.should  == IO.read(CHEF_SPEC_DATA + '/ssl/chef-rspec.key')
+        expect(http_client.cert.to_s).to eq(OpenSSL::X509::Certificate.new(IO.read(CHEF_SPEC_DATA + '/ssl/chef-rspec.cert')).to_s)
+        expect(http_client.key.to_s).to  eq(IO.read(CHEF_SPEC_DATA + '/ssl/chef-rspec.key'))
       end
     end
 
@@ -125,7 +125,7 @@ describe "HTTP SSL Policy" do
       end
 
       it "enables verification of self-signed certificates" do
-        http_client.cert_store.verify(self_signed_crt).should be_true
+        expect(http_client.cert_store.verify(self_signed_crt)).to be_truthy
       end
 
       it "enables verification of cert chains" do
@@ -137,7 +137,7 @@ describe "HTTP SSL Policy" do
         # If the machine running the test doesn't have ruby SSL configured correctly,
         # then the root cert also has to be loaded for the test to succeed.
         # The system under test **SHOULD** do both of these things.
-        http_client.cert_store.verify(additional_pem).should be_true
+        expect(http_client.cert_store.verify(additional_pem)).to be_truthy
       end
 
       context "and some certs are duplicates" do
@@ -161,7 +161,7 @@ describe "HTTP SSL Policy" do
       end
 
       it "sets the OpenSSL verify mode to verify_peer" do
-        http_client.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+        expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
       end
     end
 

data/spec/unit/http/validate_content_length_spec.rb

@@ -45,7 +45,7 @@ describe Chef::HTTP::ValidateContentLength do
 
   let(:response) {
     m = double('HttpResponse', :body => response_body)
-    m.stub(:[]) do |key|
+    allow(m).to receive(:[]) do |key|
       response_headers[key]
     end
 
@@ -83,19 +83,24 @@ describe Chef::HTTP::ValidateContentLength do
   let(:debug_stream) { StringIO.new }
   let(:debug_output) { debug_stream.string }
 
-  before(:each) {
+  before(:each) do
+    @original_log_level = Chef::Log.level
     Chef::Log.level = :debug
-    Chef::Log.stub(:debug) do |message|
+    allow(Chef::Log).to receive(:debug) do |message|
       debug_stream.puts message
     end
-  }
+  end
+
+  after(:each) do
+    Chef::Log.level = @original_log_level
+  end
 
   describe "without response body" do
     let(:request_type) { :direct }
     let(:response_body) { "Thanks for checking in." }
 
     it "shouldn't raise error" do
-      lambda { run_content_length_validation }.should_not raise_error
+      expect { run_content_length_validation }.not_to raise_error
     end
   end
 
@@ -108,7 +113,7 @@ describe Chef::HTTP::ValidateContentLength do
 
         it "should skip validation and log for debug" do
           run_content_length_validation
-          debug_output.should include("HTTP server did not include a Content-Length header in response")
+          expect(debug_output).to include("HTTP server did not include a Content-Length header in response")
         end
       end
     end
@@ -121,7 +126,7 @@ describe Chef::HTTP::ValidateContentLength do
 
         it "should validate correctly" do
           run_content_length_validation
-          debug_output.should include("Content-Length validated correctly.")
+          expect(debug_output).to include("Content-Length validated correctly.")
         end
       end
     end
@@ -134,7 +139,7 @@ describe Chef::HTTP::ValidateContentLength do
         let(:request_type) { req_type.to_sym }
 
         it "should raise ContentLengthMismatch error" do
-          lambda { run_content_length_validation }.should raise_error(Chef::Exceptions::ContentLengthMismatch)
+          expect { run_content_length_validation }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
         end
       end
     end
@@ -144,7 +149,7 @@ describe Chef::HTTP::ValidateContentLength do
     let(:streaming_length) { 12 }
 
     it "should raise ContentLengthMismatch error" do
-      lambda { run_content_length_validation }.should raise_error(Chef::Exceptions::ContentLengthMismatch)
+      expect { run_content_length_validation }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
     end
   end
 
@@ -162,7 +167,7 @@ describe Chef::HTTP::ValidateContentLength do
 
         it "should skip validation and log for debug" do
           run_content_length_validation
-          debug_output.should include("Transfer-Encoding header is set, skipping Content-Length check.")
+          expect(debug_output).to include("Transfer-Encoding header is set, skipping Content-Length check.")
         end
       end
     end
@@ -171,16 +176,16 @@ describe Chef::HTTP::ValidateContentLength do
   describe "when client is being reused" do
     before do
       run_content_length_validation
-      debug_output.should include("Content-Length validated correctly.")
+      expect(debug_output).to include("Content-Length validated correctly.")
     end
 
     it "should reset internal counter" do
-        middleware.instance_variable_get(:@content_length_counter).should be_nil
+        expect(middleware.instance_variable_get(:@content_length_counter)).to be_nil
     end
 
     it "should validate correctly second time" do
       run_content_length_validation
-      debug_output.should include("Content-Length validated correctly.")
+      expect(debug_output).to include("Content-Length validated correctly.")
     end
   end
 

data/spec/unit/http_spec.rb

@@ -31,17 +31,24 @@ describe Chef::HTTP do
 
     it 'should return a correctly formatted url 1/3 CHEF-5261' do
       http = Chef::HTTP.new('http://www.getchef.com')
-      http.create_url('api/endpoint').should eql(URI.parse('http://www.getchef.com/api/endpoint'))
+      expect(http.create_url('api/endpoint')).to eql(URI.parse('http://www.getchef.com/api/endpoint'))
     end
 
     it 'should return a correctly formatted url 2/3 CHEF-5261' do
       http = Chef::HTTP.new('http://www.getchef.com/')
-      http.create_url('/organization/org/api/endpoint/').should eql(URI.parse('http://www.getchef.com/organization/org/api/endpoint/'))
+      expect(http.create_url('/organization/org/api/endpoint/')).to eql(URI.parse('http://www.getchef.com/organization/org/api/endpoint/'))
     end
 
     it 'should return a correctly formatted url 3/3 CHEF-5261' do
       http = Chef::HTTP.new('http://www.getchef.com/organization/org///')
-      http.create_url('///api/endpoint?url=http://foo.bar').should eql(URI.parse('http://www.getchef.com/organization/org/api/endpoint?url=http://foo.bar'))
+      expect(http.create_url('///api/endpoint?url=http://foo.bar')).to eql(URI.parse('http://www.getchef.com/organization/org/api/endpoint?url=http://foo.bar'))
+    end
+
+    # As per: https://github.com/opscode/chef/issues/2500
+    it 'should treat scheme part of the URI in a case-insensitive manner' do
+      http = Chef::HTTP.allocate # Calling Chef::HTTP::new sets @url, don't want that.
+      expect { http.create_url('HTTP://www1.chef.io/') }.not_to raise_error
+      expect(http.create_url('HTTP://www2.chef.io/')).to eql(URI.parse('http://www2.chef.io/'))
     end
 
   end # create_url
@@ -50,20 +57,20 @@ describe Chef::HTTP do
 
     it 'should return nil for a "200 Success" response (CHEF-4762)' do
       resp = Net::HTTPOK.new("1.1", 200, "OK")
-      resp.should_receive(:read_body).and_return(nil)
+      expect(resp).to receive(:read_body).and_return(nil)
       http = Chef::HTTP.new("")
-      Chef::HTTP::BasicClient.any_instance.should_receive(:request).and_return(["request", resp])
+      expect_any_instance_of(Chef::HTTP::BasicClient).to receive(:request).and_return(["request", resp])
 
-      http.head("http://www.getchef.com/").should eql(nil)
+      expect(http.head("http://www.getchef.com/")).to eql(nil)
     end
 
     it 'should return false for a "304 Not Modified" response (CHEF-4762)' do
       resp = Net::HTTPNotModified.new("1.1", 304, "Not Modified")
-      resp.should_receive(:read_body).and_return(nil)
+      expect(resp).to receive(:read_body).and_return(nil)
       http = Chef::HTTP.new("")
-      Chef::HTTP::BasicClient.any_instance.should_receive(:request).and_return(["request", resp])
+      expect_any_instance_of(Chef::HTTP::BasicClient).to receive(:request).and_return(["request", resp])
 
-      http.head("http://www.getchef.com/").should eql(false)
+      expect(http.head("http://www.getchef.com/")).to eql(false)
     end
 
   end # head

data/spec/unit/knife/bootstrap/chef_vault_handler_spec.rb

@@ -0,0 +1,153 @@
+#
+# Author:: Lamont Granquist <lamont@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, 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'
+
+describe Chef::Knife::Bootstrap::ChefVaultHandler do
+
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:stdin) { StringIO.new }
+  let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
+
+  let(:knife_config) { {} }
+
+  let(:node_name) { "bevell.wat" }
+
+  let(:chef_vault_handler) {
+    chef_vault_handler = Chef::Knife::Bootstrap::ChefVaultHandler.new(knife_config: knife_config, ui: ui)
+    chef_vault_handler
+  }
+
+  context "when there's no vault option" do
+    it "should report its not doing anything" do
+      expect(chef_vault_handler.doing_chef_vault?).to be false
+    end
+
+    it "shouldn't do anything" do
+      expect(chef_vault_handler).to_not receive(:sanity_check)
+      expect(chef_vault_handler).to_not receive(:update_bootstrap_vault_json!)
+      chef_vault_handler
+    end
+  end
+
+  context "when setting chef vault items" do
+    let(:bootstrap_vault_item) { double("ChefVault::Item") }
+
+    before do
+      expect(chef_vault_handler).to receive(:wait_for_client).and_return(false)
+      expect(chef_vault_handler).to receive(:require_chef_vault!).at_least(:once)
+      expect(bootstrap_vault_item).to receive(:clients).with("name:#{node_name}").at_least(:once)
+      expect(bootstrap_vault_item).to receive(:save).at_least(:once)
+    end
+
+    context "from knife_config[:bootstrap_vault_item]" do
+      it "sets a single item as a scalar" do
+        knife_config[:bootstrap_vault_item] = { 'vault' => 'item1' }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets a single item as an array" do
+        knife_config[:bootstrap_vault_item] = { 'vault' => [ 'item1' ] }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets two items as an array" do
+        knife_config[:bootstrap_vault_item] = { 'vault' => [ 'item1', 'item2' ] }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item2').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets two vaults from different hash keys" do
+        knife_config[:bootstrap_vault_item] = { 'vault' => [ 'item1', 'item2' ], 'vault2' => [ 'item3' ] }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item2').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault2', 'item3').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+    end
+
+    context "from knife_config[:bootstrap_vault_json]" do
+      it "sets a single item as a scalar" do
+        knife_config[:bootstrap_vault_json] = '{ "vault": "item1" }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets a single item as an array" do
+        knife_config[:bootstrap_vault_json] = '{ "vault": [ "item1" ] }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets two items as an array" do
+        knife_config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ] }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item2').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets two vaults from different hash keys" do
+        knife_config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item2').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault2', 'item3').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+    end
+
+    context "from knife_config[:bootstrap_vault_file]" do
+
+      def setup_file_contents(json)
+        stringio = StringIO.new(json)
+        knife_config[:bootstrap_vault_file] = "/foo/bar/baz"
+        expect(File).to receive(:read).with(knife_config[:bootstrap_vault_file]).and_return(stringio)
+      end
+
+      it "sets a single item as a scalar" do
+        setup_file_contents('{ "vault": "item1" }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets a single item as an array" do
+        setup_file_contents('{ "vault": [ "item1" ] }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets two items as an array" do
+        setup_file_contents('{ "vault": [ "item1", "item2" ] }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item2').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+
+      it "sets two vaults from different hash keys" do
+        setup_file_contents('{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item1').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault', 'item2').and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with('vault2', 'item3').and_return(bootstrap_vault_item)
+        chef_vault_handler.run(node_name: node_name)
+      end
+    end
+  end
+end

data/spec/unit/knife/bootstrap/client_builder_spec.rb

@@ -0,0 +1,178 @@
+#
+# Author:: Lamont Granquist <lamont@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, 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'
+
+
+describe Chef::Knife::Bootstrap::ClientBuilder do
+
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:stdin) { StringIO.new }
+  let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
+
+  let(:knife_config) { {} }
+
+  let(:chef_config) { {} }
+
+  let(:node_name) { "bevell.wat" }
+
+  let(:rest) { double("Chef::REST") }
+
+  let(:client_builder) {
+    client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(knife_config: knife_config, chef_config: chef_config, ui: ui)
+    allow(client_builder).to receive(:rest).and_return(rest)
+    allow(client_builder).to receive(:node_name).and_return(node_name)
+    client_builder
+  }
+
+  context "#sanity_check!" do
+    let(:response_404) { OpenStruct.new(:code => '404') }
+    let(:exception_404) { Net::HTTPServerException.new("404 not found", response_404) }
+
+    context "in cases where the prompting fails" do
+      before do
+        # should fail early in #run
+        expect(client_builder).to_not receive(:create_client!)
+        expect(client_builder).to_not receive(:create_node!)
+      end
+
+      it "exits when the node exists and the user does not want to delete" do
+        expect(rest).to receive(:get_rest).with("nodes/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return('n')
+        expect { client_builder.run }.to raise_error(SystemExit)
+      end
+
+      it "exits when the client exists and the user does not want to delete" do
+        expect(rest).to receive(:get_rest).with("nodes/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:get_rest).with("clients/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return('n')
+        expect { client_builder.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "in cases where the prompting succeeds" do
+      before do
+        # mock out the rest of #run
+        expect(client_builder).to receive(:create_client!)
+        expect(client_builder).to receive(:create_node!)
+      end
+
+      it "when both the client and node do not exist it succeeds" do
+        expect(rest).to receive(:get_rest).with("nodes/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:get_rest).with("clients/#{node_name}").and_raise(exception_404)
+        expect { client_builder.run }.not_to raise_error
+      end
+
+      it "when we are allowed to delete an old node" do
+        expect(rest).to receive(:get_rest).with("nodes/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return('y')
+        expect(rest).to receive(:get_rest).with("clients/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:delete).with("nodes/#{node_name}")
+        expect { client_builder.run }.not_to raise_error
+      end
+
+      it "when we are allowed to delete an old client" do
+        expect(rest).to receive(:get_rest).with("nodes/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:get_rest).with("clients/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return('y')
+        expect(rest).to receive(:delete).with("clients/#{node_name}")
+        expect { client_builder.run }.not_to raise_error
+      end
+
+      it "when we are are allowed to delete both an old client and node" do
+        expect(rest).to receive(:get_rest).with("nodes/#{node_name}")
+        expect(rest).to receive(:get_rest).with("clients/#{node_name}")
+        expect(ui.stdin).to receive(:readline).twice.and_return('y')
+        expect(rest).to receive(:delete).with("nodes/#{node_name}")
+        expect(rest).to receive(:delete).with("clients/#{node_name}")
+        expect { client_builder.run }.not_to raise_error
+      end
+    end
+  end
+
+  context "#create_client!" do
+    before do
+      # mock out the rest of #run
+      expect(client_builder).to receive(:sanity_check)
+      expect(client_builder).to receive(:create_node!)
+    end
+
+    it "delegates everything to Chef::ApiClient::Registration" do
+      reg_double = double("Chef::ApiClient::Registration")
+      expect(Chef::ApiClient::Registration).to receive(:new).with(node_name, client_builder.client_path, http_api: rest).and_return(reg_double)
+      expect(reg_double).to receive(:run)
+      client_builder.run
+    end
+
+  end
+
+  context "#client_path" do
+    it "has a public API for the temporary client.pem file" do
+      expect(client_builder.client_path).to match(/#{node_name}.pem/)
+    end
+  end
+
+  context "#create_node!" do
+    before do
+      # mock out the rest of #run
+      expect(client_builder).to receive(:sanity_check)
+      expect(client_builder).to receive(:create_client!)
+      # mock out default node building steps
+      expect(client_builder).to receive(:client_rest).and_return(client_rest)
+      expect(Chef::Node).to receive(:new).with(chef_server_rest: client_rest).and_return(node)
+      expect(node).to receive(:name).with(node_name)
+      expect(node).to receive(:save)
+    end
+
+    let(:client_rest) { double("Chef::REST (client)") }
+
+    let(:node) { double("Chef::Node") }
+
+    it "builds a node with a default run_list of []" do
+      expect(node).to receive(:run_list).with([])
+      client_builder.run
+    end
+
+    it "builds a node when the run_list is a string" do
+      knife_config[:run_list] = "role[base],role[app]"
+      expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
+      client_builder.run
+    end
+
+    it "builds a node when the run_list is an Array" do
+      knife_config[:run_list] = ["role[base]", "role[app]"]
+      expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
+      client_builder.run
+    end
+
+    it "builds a node with first_boot_attributes if they're given" do
+      knife_config[:first_boot_attributes] = {:baz => :quux}
+      expect(node).to receive(:normal_attrs=).with({:baz=>:quux})
+      expect(node).to receive(:run_list).with([])
+      client_builder.run
+    end
+
+    it "builds a node with an environment if its given" do
+      knife_config[:environment] = "production"
+      expect(node).to receive(:environment).with("production")
+      expect(node).to receive(:run_list).with([])
+      client_builder.run
+    end
+  end
+end