chef 10.34.6 → 11.0.0.beta.0

data/spec/support/shared/unit/file_system_support.rb

@@ -0,0 +1,110 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2012 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 'chef/chef_fs/file_system'
+require 'chef/chef_fs/file_system/base_fs_dir'
+require 'chef/chef_fs/file_system/base_fs_object'
+
+module FileSystemSupport
+  class MemoryFile < Chef::ChefFS::FileSystem::BaseFSObject
+    def initialize(name, parent, value)
+      super(name, parent)
+      @value = value
+    end
+    def read
+      return @value
+    end
+  end
+
+  class MemoryDir < Chef::ChefFS::FileSystem::BaseFSDir
+    def initialize(name, parent)
+      super(name, parent)
+      @children = []
+    end
+    attr_reader :children
+    def child(name)
+      @children.select { |child| child.name == name }.first || Chef::ChefFS::FileSystem::NonexistentFSObject.new(name, self)
+    end
+    def add_child(child)
+      @children.push(child)
+    end
+    def can_have_child?(name, is_dir)
+      root.cannot_be_in_regex ? (name !~ root.cannot_be_in_regex) : true
+    end
+  end
+
+  class MemoryRoot < MemoryDir
+    def initialize(pretty_name, cannot_be_in_regex = nil)
+      super('', nil)
+      @pretty_name = pretty_name
+      @cannot_be_in_regex = cannot_be_in_regex
+    end
+
+    attr_reader :cannot_be_in_regex
+
+    def path_for_printing
+      @pretty_name
+    end
+  end
+
+  def memory_fs(pretty_name, value, cannot_be_in_regex = nil)
+    if !value.is_a?(Hash)
+      raise "memory_fs() must take a Hash"
+    end
+    dir = MemoryRoot.new(pretty_name, cannot_be_in_regex)
+    value.each do |key, child|
+      dir.add_child(memory_fs_value(child, key.to_s, dir))
+    end
+    dir
+  end
+
+  def memory_fs_value(value, name = '', parent = nil)
+    if value.is_a?(Hash)
+      dir = MemoryDir.new(name, parent)
+      value.each do |key, child|
+        dir.add_child(memory_fs_value(child, key.to_s, dir))
+      end
+      dir
+    else
+      MemoryFile.new(name, parent, value || "#{name}\n")
+    end
+  end
+
+  def pattern(p)
+    Chef::ChefFS::FilePattern.new(p)
+  end
+
+  def return_paths(*expected)
+    ReturnPaths.new(expected)
+  end
+
+  def no_blocking_calls_allowed
+    [ MemoryFile, MemoryDir ].each do |c|
+      [ :children, :exists?, :read ].each do |m|
+        c.any_instance.stub(m).and_raise("#{m.to_s} should not be called")
+      end
+    end
+  end
+
+  def list_should_yield_paths(fs, pattern_str, *expected_paths)
+    result_paths = []
+    Chef::ChefFS::FileSystem.list(fs, pattern(pattern_str)) { |result| result_paths << result.path }
+    result_paths.should =~ expected_paths
+  end
+end
+

data/spec/support/shared/unit/platform_introspector.rb

@@ -0,0 +1,162 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010, 2012 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.
+#
+
+
+shared_examples_for "a platform introspector" do
+  before(:each) do
+    @platform_hash = {}
+    %w{openbsd freebsd}.each do |x|
+      @platform_hash[x] = {
+        "default" => x,
+        "1.2.3" => "#{x}-1.2.3"
+      }
+    end
+    @platform_hash["debian"] = {["5", "6"] => "debian-5/6", "default" => "debian"}
+    @platform_hash["default"] = "default"
+
+    @platform_family_hash = {
+      "debian" => "debian value",
+      [:rhel, :fedora] => "redhatty value",
+      "suse" => "suse value",
+      :default => "default value"
+    }
+  end
+
+  it "returns a default value when there is no known platform" do
+    node = Hash.new
+    platform_introspector.value_for_platform(@platform_hash).should == "default"
+  end
+
+  it "returns a default value when there is no known platform family" do
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+  end
+
+  it "returns a default value when the current platform doesn't match" do
+    node.automatic_attrs[:platform] = "not-a-known-platform"
+    platform_introspector.value_for_platform(@platform_hash).should == "default"
+  end
+
+  it "returns a default value when current platform_family doesn't match" do
+    node.automatic_attrs[:platform_family] = "ultra-derived-linux"
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+  end
+
+  it "returns a value based on the current platform" do
+    node.automatic_attrs[:platform] = "openbsd"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+  end
+
+  it "returns a value based on the current platform family" do
+    node.automatic_attrs[:platform_family] = "debian"
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "debian value"
+  end
+
+  it "returns a version-specific value based on the current platform" do
+    node.automatic_attrs[:platform] = "openbsd"
+    node.automatic_attrs[:platform_version] = "1.2.3"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd-1.2.3"
+  end
+
+  it "returns a value based on the current platform if version not found" do
+    node.automatic_attrs[:platform] = "openbsd"
+    node.automatic_attrs[:platform_version] = "0.0.0"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+  end
+
+  describe "when platform versions is an array" do
+    it "returns a version-specific value based on the current platform" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = "6"
+      platform_introspector.value_for_platform(@platform_hash).should == "debian-5/6"
+    end
+
+    it "returns a value based on the current platform if version not found" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = "0.0.0"
+      platform_introspector.value_for_platform(@platform_hash).should == "debian"
+    end
+  end
+
+  describe "when checking platform?" do
+
+    it "returns true if the node is a provided platform and platforms are provided as symbols" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?([:redhat, :ubuntu]).should == true
+    end
+
+    it "returns true if the node is a provided platform and platforms are provided as strings" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?(["redhat", "ubuntu"]).should == true
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?(:splatlinux).should == false
+    end
+  end
+
+  describe "when checking platform_family?" do
+
+    it "returns true if the node is in a provided platform family and families are provided as symbols" do
+      node.automatic_attrs[:platform_family] = 'debian'
+      platform_introspector.platform_family?([:rhel, :debian]).should == true
+    end
+
+    it "returns true if the node is a provided platform and platforms are provided as strings" do
+      node.automatic_attrs[:platform_family] = 'rhel'
+      platform_introspector.platform_family?(["rhel", "debian"]).should == true
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform_family] = 'suse'
+      platform_introspector.platform_family?(:splatlinux).should == false
+    end
+
+    it "returns false if the node is not of the provided platforms and platform_family is not set" do
+      platform_introspector.platform_family?(:splatlinux).should == false
+    end
+
+  end
+  # NOTE: this is a regression test for bug CHEF-1514
+  describe "when the value is an array" do
+    before do
+      @platform_hash = {
+        "debian" => { "4.0" => [ :restart, :reload ], "default" => [ :restart, :reload, :status ] },
+        "ubuntu" => { "default" => [ :restart, :reload, :status ] },
+        "centos" => { "default" => [ :restart, :reload, :status ] },
+        "redhat" => { "default" => [ :restart, :reload, :status ] },
+        "fedora" => { "default" => [ :restart, :reload, :status ] },
+        "default" => { "default" => [:restart, :reload ] }}
+    end
+
+    it "returns the correct default for a given platform" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = '9000'
+      platform_introspector.value_for_platform(@platform_hash).should == [ :restart, :reload, :status ]
+    end
+
+    it "returns the correct platform+version specific value " do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = '4.0'
+      platform_introspector.value_for_platform(@platform_hash).should == [:restart, :reload]
+    end
+  end
+
+end
+

data/spec/unit/api_client/registration_spec.rb

@@ -0,0 +1,175 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 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 'tempfile'
+
+require 'chef/api_client/registration'
+
+describe Chef::ApiClient::Registration do
+  let(:key_location) do
+    path = nil
+    Tempfile.open("client-registration-key") {|f| path = f.path }
+    File.unlink(path)
+    path
+  end
+
+  let(:registration) { Chef::ApiClient::Registration.new("silent-bob", key_location) }
+
+  let :private_key_data do
+    File.open(Chef::Config[:validation_key], "r") {|f| f.read.chomp }
+  end
+
+  before do
+    Chef::Config[:validation_client_name] = "test-validator"
+    Chef::Config[:validation_key] = File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)
+  end
+
+  after do
+    File.unlink(key_location) if File.exist?(key_location)
+    Chef::Config[:validation_client_name] = nil
+    Chef::Config[:validation_key] = nil
+  end
+
+  it "has an HTTP client configured with validator credentials" do
+    registration.http_api.should be_a_kind_of(Chef::REST)
+    registration.http_api.client_name.should == "test-validator"
+    registration.http_api.signing_key.should == private_key_data
+  end
+
+  describe "when creating/updating the client on the server" do
+    let(:http_mock) { mock("Chef::REST mock") }
+
+    before do
+      registration.stub!(:http_api).and_return(http_mock)
+    end
+
+    it "creates a new ApiClient on the server using the validator identity" do
+      response = {"uri" => "https://chef.local/clients/silent-bob", 
+                  "private_key" => "--begin rsa key etc--"}
+      http_mock.should_receive(:post).
+        with("clients", :name => 'silent-bob', :admin => false).
+        and_return(response)
+      registration.create_or_update.should == response
+      registration.private_key.should == "--begin rsa key etc--"
+    end
+
+    context "and the client already exists on a Chef 10 server" do
+      it "requests a new key from the server and saves it" do
+        response = {"name" => "silent-bob", "private_key" => "--begin rsa key etc--" }
+
+        response_409 = Net::HTTPConflict.new("1.1", "409", "Conflict")
+        exception_409 = Net::HTTPServerException.new("409 conflict", response_409)
+
+        http_mock.should_receive(:post).and_raise(exception_409)
+        http_mock.should_receive(:put).
+          with("clients/silent-bob", :name => 'silent-bob', :admin => false, :private_key => true).
+          and_return(response)
+        registration.create_or_update.should == response
+        registration.private_key.should == "--begin rsa key etc--"
+      end
+    end
+
+    context "and the client already exists on a Chef 11 server" do
+      it "requests a new key from the server and saves it" do
+        response = Chef::ApiClient.new
+        response.name("silent-bob")
+        response.private_key("--begin rsa key etc--")
+
+        response_409 = Net::HTTPConflict.new("1.1", "409", "Conflict")
+        exception_409 = Net::HTTPServerException.new("409 conflict", response_409)
+
+        http_mock.should_receive(:post).and_raise(exception_409)
+        http_mock.should_receive(:put).
+          with("clients/silent-bob", :name => 'silent-bob', :admin => false, :private_key => true).
+          and_return(response)
+        registration.create_or_update.should == response
+        registration.private_key.should == "--begin rsa key etc--"
+      end
+    end
+  end
+
+  describe "when writing the private key to disk" do
+    before do
+      registration.stub!(:private_key).and_return('--begin rsa key etc--')
+    end
+
+    # Permission read via File.stat is busted on windows, though creating the
+    # file with 0600 has the desired effect of giving access rights to the
+    # owner only. A platform-specific functional test would be helpful.
+    it "creates the file with 0600 permissions", :unix_only do
+      File.should_not exist(key_location)
+      registration.write_key
+      File.should exist(key_location)
+      stat = File.stat(key_location)
+      (stat.mode & 07777).should == 0600
+    end
+
+    it "writes the private key content to the file" do
+      registration.write_key
+      IO.read(key_location).should == "--begin rsa key etc--"
+    end
+  end
+
+  describe "when registering a client" do
+
+    let(:http_mock) { mock("Chef::REST mock") }
+
+    before do
+      registration.stub!(:http_api).and_return(http_mock)
+    end
+
+    it "creates the client on the server and writes the key" do
+      response = {"uri" => "http://chef.local/clients/silent-bob",
+                  "private_key" => "--begin rsa key etc--" }
+      http_mock.should_receive(:post).ordered.and_return(response)
+      registration.run
+      IO.read(key_location).should == "--begin rsa key etc--"
+    end
+
+    it "retries up to 5 times" do
+      response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
+      exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
+
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 1
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 2
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 3
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 4
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 5
+
+      response = {"uri" => "http://chef.local/clients/silent-bob",
+                  "private_key" => "--begin rsa key etc--" }
+      http_mock.should_receive(:post).ordered.and_return(response)
+      registration.run
+      IO.read(key_location).should == "--begin rsa key etc--"
+    end
+
+    it "gives up retrying after the max attempts" do
+      response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
+      exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
+
+      http_mock.should_receive(:post).exactly(6).times.and_raise(exception_500)
+
+      lambda {registration.run}.should raise_error(Net::HTTPFatalError)
+    end
+
+  end
+
+end
+
+

data/spec/unit/api_client_spec.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.
@@ -26,128 +26,85 @@ describe Chef::ApiClient do
     @client = Chef::ApiClient.new
   end
 
-  describe "initialize" do
-    it "should be a Chef::ApiClient" do
-      @client.should be_a_kind_of(Chef::ApiClient)
-    end
+  it "has a name attribute" do
+    @client.name("ops_master")
+    @client.name.should == "ops_master"
   end
 
-  describe "name" do
-    it "should let you set the name to a string" do
-      @client.name("ops_master").should == "ops_master"
-    end
-
-    it "should return the current name" do
-      @client.name "ops_master"
-      @client.name.should == "ops_master"
-    end
-
-    it "should not accept spaces" do
-      lambda { @client.name "ops master" }.should raise_error(ArgumentError)
-    end
-
-    it "should throw an ArgumentError if you feed it anything but a string" do
-      lambda { @client.name Hash.new }.should raise_error(ArgumentError)
-    end
+  it "does not allow spaces in the name" do
+    lambda { @client.name "ops master" }.should raise_error(ArgumentError)
   end
 
-  describe "admin" do
-    it "should let you set the admin bit" do
-      @client.admin(true).should == true
-    end
+  it "only allows string values for the name" do
+    lambda { @client.name Hash.new }.should raise_error(ArgumentError)
+  end
 
-    it "should return the current admin value" do
-      @client.admin true 
-      @client.admin.should == true 
-    end
+  it "has an admin flag attribute" do
+    @client.admin(true)
+    @client.admin.should be_true
+  end
 
-    it "should default to false" do
-      @client.admin.should == false
-    end
+  it "defaults to non-admin" do
+    @client.admin.should be_false
+  end
 
-    it "should throw an ArgumentError if you feed it anything but true or false" do
-      lambda { @client.name Hash.new }.should raise_error(ArgumentError)
-    end
+  it "allows only boolean values for the admin flag" do
+    lambda { @client.admin(false) }.should_not raise_error
+    lambda { @client.admin(Hash.new) }.should raise_error(ArgumentError)
   end
 
-  describe "public_key" do
-    it "should let you set the public key" do
-      @client.public_key("super public").should == "super public"
-    end
 
-    it "should return the current public key" do
-      @client.public_key("super public")
-      @client.public_key.should == "super public"
-    end
+  it "has a public key attribute" do
+    @client.public_key("super public")
+    @client.public_key.should == "super public"
+  end
 
-    it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
-    end 
+  it "accepts only String values for the public key" do
+    lambda { @client.public_key "" }.should_not raise_error
+    lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
   end
 
-  describe "private_key" do
-    it "should let you set the private key" do
-      @client.private_key("super private").should == "super private"
-    end
 
-    it "should return the private key" do
-      @client.private_key("super private")
-      @client.private_key.should == "super private"
-    end
+  it "has a private key attribute" do
+    @client.private_key("super private")
+    @client.private_key.should == "super private"
+  end
 
-    it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
-    end 
+  it "accepts only String values for the private key" do
+    lambda { @client.private_key "" }.should_not raise_error
+    lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
   end
 
-  describe "create_keys" do
+  describe "when serializing to JSON" do
     before(:each) do
-      Chef::Certificate.stub!(:gen_keypair).and_return(["cert", "key"])
-    end
-
-    it "should create a certificate based on the client name" do
-      Chef::Certificate.should_receive(:gen_keypair).with(@client.name)
-      @client.create_keys
-    end
-
-    it "should set the private key" do
-      @client.create_keys
-      @client.private_key.should == "key"
+      @client.name("black")
+      @client.public_key("crowes")
+      @json = @client.to_json
     end
 
-    it "should set the public key" do
-      @client.create_keys
-      @client.public_key.should == "cert"
+    it "serializes as a JSON object" do
+      @json.should match(/^\{.+\}$/)
     end
-  end
 
-  describe "serialize" do
-    before(:each) do
-      @client.name("black")
-      @client.public_key("crowes")
-      @client.private_key("monkeypants")
-      @serial = @client.to_json
+    it "includes the name value" do
+      @json.should include(%q{"name":"black"})
     end
 
-    it "should serialize to a json hash" do
-      @client.to_json.should match(/^\{.+\}$/)
+    it "includes the public key value" do
+      @json.should include(%{"public_key":"crowes"})
     end
 
-    %w{
-      name
-      public_key
-    }.each do |t| 
-      it "should include '#{t}'" do
-        @serial.should =~ /"#{t}":"#{@client.send(t.to_sym)}"/
-      end
+    it "includes the 'admin' flag" do
+      @json.should include(%q{"admin":false})
     end
 
-    it "should include 'admin'" do
-      @serial.should =~ /"admin":false/
+    it "includes the private key when present" do
+      @client.private_key("monkeypants")
+      @client.to_json.should include(%q{"private_key":"monkeypants"})
     end
 
-    it "should not include the private key" do
-      @serial.should_not =~ /"private_key":/
+    it "does not include the private key if not present" do
+      @json.should_not include("private_key")
     end
   end
 
@@ -185,6 +142,29 @@ describe Chef::ApiClient do
 
   end
 
+  describe "with correctly configured API credentials" do
+    before do
+      Chef::Config[:node_name] = "silent-bob"
+      Chef::Config[:client_key] = File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)
+    end
+
+    after do
+      Chef::Config[:node_name] = nil
+      Chef::Config[:client_key] = nil
+    end
+
+    let :private_key_data do
+      File.open(Chef::Config[:client_key], "r") {|f| f.read.chomp }
+    end
+
+    it "has an HTTP client configured with default credentials" do
+      @client.http_api.should be_a_kind_of(Chef::REST)
+      @client.http_api.client_name.should == "silent-bob"
+      @client.http_api.signing_key.to_s.should == private_key_data
+    end
+  end
+
+
   describe "when requesting a new key" do
     before do
       @http_client = mock("Chef::REST mock")
@@ -196,7 +176,7 @@ describe Chef::ApiClient do
         @a_404_response = Net::HTTPNotFound.new("404 not found and such", nil, nil)
         @a_404_exception = Net::HTTPServerException.new("404 not found exception", @a_404_response)
 
-        @http_client.should_receive(:get_rest).with("clients/lost-my-key").and_raise(@a_404_exception)
+        @http_client.should_receive(:get).with("clients/lost-my-key").and_raise(@a_404_exception)
       end
 
       it "raises a 404 error" do
@@ -208,7 +188,7 @@ describe Chef::ApiClient do
       before do
         @api_client_without_key = Chef::ApiClient.new
         @api_client_without_key.name("lost-my-key")
-        @http_client.should_receive(:get_rest).with("clients/lost-my-key").and_return(@api_client_without_key)
+        @http_client.should_receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
       end
 
 
@@ -217,7 +197,7 @@ describe Chef::ApiClient do
           @api_client_with_key = Chef::ApiClient.new
           @api_client_with_key.name("lost-my-key")
           @api_client_with_key.private_key("the new private key")
-          @http_client.should_receive(:put_rest).
+          @http_client.should_receive(:put).
             with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :private_key => true).
             and_return(@api_client_with_key)
         end
@@ -235,7 +215,7 @@ describe Chef::ApiClient do
       context "and the client exists on a Chef 10-like server" do
         before do
           @api_client_with_key = {"name" => "lost-my-key", "private_key" => "the new private key"}
-          @http_client.should_receive(:put_rest).
+          @http_client.should_receive(:put).
             with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :private_key => true).
             and_return(@api_client_with_key)
         end
@@ -251,64 +231,6 @@ describe Chef::ApiClient do
       end
 
     end
-
-    context "and client side key generation is enabled" do
-
-      let(:response) { {"uri"=> "https://example.com/clients/selfgenkeytest-1395958070", "public_key" => "rsa-key-data"} }
-      let(:pkey_in) { IO.read(File.join(CHEF_SPEC_DATA, "ssl/private_key.pem")) }
-
-      let(:generated_key) { OpenSSL::PKey::RSA.new(pkey_in) }
-      let(:generated_public_key) { generated_key.public_key }
-
-      before do
-        @client.name("deadsexy")
-        OpenSSL::PKey::RSA.stub(:generate).and_return(generated_key)
-        Chef::Config.stub(:local_key_generation).and_return true
-      end
-
-      context "and the client doesn't exist" do
-        let(:response) { {"uri"=> "https://example.com/clients/selfgenkeytest-1395958070", "public_key" => "rsa-key-data"} }
-        let(:pkey_in) { IO.read(File.join(CHEF_SPEC_DATA, "ssl/private_key.pem")) }
-
-        let(:generated_key) { OpenSSL::PKey::RSA.new(pkey_in) }
-        let(:generated_public_key) { generated_key.public_key }
-
-        before do
-          @http_client.should_receive(:post_rest).
-            with("clients", :name => "deadsexy", :admin => false, :public_key => generated_public_key.to_pem).
-            and_return(response)
-        end
-
-        it "creates the client with self generated key" do
-          @client.save(true, true)
-          @client.private_key.should == generated_key.to_pem
-        end
-
-      end
-
-      context "and the client already exists" do
-        before do
-          http_conflict_response = Net::HTTPConflict.new("409 blah blah", "409", "409")
-          http_conflict_error = Net::HTTPServerException.new("409 conflict", http_conflict_response)
-
-          @http_client.should_receive(:post_rest).
-            with("clients", :name => "deadsexy", :admin => false, :public_key => generated_public_key.to_pem).
-            and_raise(http_conflict_error)
-
-          @http_client.should_receive(:put_rest).
-            with("clients/deadsexy", :name => "deadsexy", :admin => false, :public_key => generated_public_key.to_pem).
-            and_return(response)
-        end
-
-        it "creates the client with self generated key" do
-          @client.save(true, true)
-          @client.private_key.should == generated_key.to_pem
-        end
-
-      end
-
-    end
-
   end
 end