chef 12.4.0-universal-mingw32 → 12.4.1-universal-mingw32

data/spec/spec_helper.rb

@@ -87,12 +87,14 @@ Dir["spec/support/**/*.rb"].
 OHAI_SYSTEM = Ohai::System.new
 OHAI_SYSTEM.all_plugins("platform")
 
-TEST_PLATFORM =
-  (OHAI_SYSTEM['platform'] ||
-  'unknown_test_platform').dup.freeze
-TEST_PLATFORM_VERSION =
-  (OHAI_SYSTEM['platform_version'] ||
-  'unknown_platform_version').dup.freeze
+test_node = Chef::Node.new
+test_node.automatic['os'] = (OHAI_SYSTEM['os'] || 'unknown_os').dup.freeze
+test_node.automatic['platform_family'] = (OHAI_SYSTEM['platform_family'] || 'unknown_platform_family').dup.freeze
+test_node.automatic['platform'] = (OHAI_SYSTEM['platform'] || 'unknown_platform').dup.freeze
+test_node.automatic['platform_version'] = (OHAI_SYSTEM['platform_version'] || 'unknown_platform_version').dup.freeze
+TEST_NODE = test_node.freeze
+TEST_PLATFORM = TEST_NODE['platform']
+TEST_PLATFORM_VERSION = TEST_NODE['platform_version']
 
 RSpec.configure do |config|
   config.include(Matchers)
@@ -162,13 +164,17 @@ RSpec.configure do |config|
   config.filter_run_excluding :provider => lambda {|criteria|
     type, target_provider = criteria.first
 
-    platform = TEST_PLATFORM.dup
-    platform_version = TEST_PLATFORM_VERSION.dup
-
-    begin
-      provider_for_running_platform = Chef::Platform.find_provider(platform, platform_version, type)
-      provider_for_running_platform != target_provider
-    rescue ArgumentError # no provider for platform
+    node = TEST_NODE.dup
+    resource_class = Chef::ResourceResolver.resolve(type, node: node)
+    if resource_class
+      resource = resource_class.new('test', Chef::RunContext.new(node, nil, nil))
+      begin
+        provider = resource.provider_for_action(Array(resource_class.default_action).first)
+        provider.class != target_provider
+      rescue Chef::Exceptions::ProviderNotFound # no provider for platform
+        true
+      end
+    else
       true
     end
   }

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

@@ -26,7 +26,7 @@ shared_examples_for "version handling" do
     allow(rest_v1).to receive(http_verb).and_raise(exception_406)
   end
 
-  context "when the server does not support the min or max server API version that Chef::User supports" do
+  context "when the server does not support the min or max server API version that Chef::UserV1 supports" do
     before do
       allow(object).to receive(:server_client_api_version_intersection).and_return([])
     end
@@ -34,7 +34,7 @@ shared_examples_for "version handling" do
     it "raises the original exception" do
       expect{ object.send(method) }.to raise_error(exception_406)
     end
-  end # when the server does not support the min or max server API version that Chef::User supports
+  end # when the server does not support the min or max server API version that Chef::UserV1 supports
 end # version handling
 
 shared_examples_for "user and client reregister" do

data/spec/unit/api_client_spec.rb

@@ -21,6 +21,11 @@ require 'spec_helper'
 require 'chef/api_client'
 require 'tempfile'
 
+# DEPRECATION NOTE
+#
+# This code will be removed in Chef 13 in favor of the code in Chef::ApiClientV1,
+# which will be moved to this namespace. New development should occur in
+# Chef::ApiClientV1 until the time before Chef 13.
 describe Chef::ApiClient do
   before(:each) do
     @client = Chef::ApiClient.new
@@ -53,20 +58,6 @@ describe Chef::ApiClient do
     expect { @client.admin(Hash.new) }.to raise_error(ArgumentError)
   end
 
-  it "has an create_key flag attribute" do
-    @client.create_key(true)
-    expect(@client.create_key).to be_truthy
-  end
-
-  it "create_key defaults to false" do
-    expect(@client.create_key).to be_falsey
-  end
-
-  it "allows only boolean values for the create_key flag" do
-    expect { @client.create_key(false) }.not_to raise_error
-    expect { @client.create_key(Hash.new) }.to raise_error(ArgumentError)
-  end
-
   it "has a 'validator' flag attribute" do
     @client.validator(true)
     expect(@client.validator).to be_truthy
@@ -129,12 +120,6 @@ describe Chef::ApiClient do
       expect(@json).to include(%q{"validator":false})
     end
 
-    it "includes the 'create_key' flag when present" do
-      @client.create_key(true)
-      @json = @client.to_json
-      expect(@json).to include(%q{"create_key":true})
-    end
-
     it "includes the private key when present" do
       @client.private_key("monkeypants")
       expect(@client.to_json).to include(%q{"private_key":"monkeypants"})
@@ -143,15 +128,11 @@ describe Chef::ApiClient do
     it "does not include the private key if not present" do
       expect(@json).not_to include("private_key")
     end
-
-    include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
-      let(:jsonable) { @client }
-    end
   end
 
   describe "when deserializing from JSON (string) using ApiClient#from_json" do
     let(:client_string) do
-      "{\"name\":\"black\",\"public_key\":\"crowes\",\"private_key\":\"monkeypants\",\"admin\":true,\"validator\":true,\"create_key\":true}"
+      "{\"name\":\"black\",\"public_key\":\"crowes\",\"private_key\":\"monkeypants\",\"admin\":true,\"validator\":true}"
     end
 
     let(:client) do
@@ -178,10 +159,6 @@ describe Chef::ApiClient do
       expect(client.admin).to be_truthy
     end
 
-    it "preserves the create_key status" do
-      expect(client.create_key).to be_truthy
-    end
-
     it "preserves the 'validator' status" do
       expect(client.validator).to be_truthy
     end
@@ -199,7 +176,6 @@ describe Chef::ApiClient do
         "private_key" => "monkeypants",
         "admin" => true,
         "validator" => true,
-        "create_key" => true,
         "json_class" => "Chef::ApiClient"
       }
     end
@@ -224,10 +200,6 @@ describe Chef::ApiClient do
       expect(client.admin).to be_truthy
     end
 
-    it "preserves the create_key status" do
-      expect(client.create_key).to be_truthy
-    end
-
     it "preserves the 'validator' status" do
       expect(client.validator).to be_truthy
     end
@@ -243,18 +215,16 @@ describe Chef::ApiClient do
 
     before(:each) do
       client = {
-        "name" => "black",
-        "clientname" => "black",
-        "public_key" => "crowes",
-        "private_key" => "monkeypants",
-        "admin" => true,
-        "create_key" => true,
-        "validator" => true,
-        "json_class" => "Chef::ApiClient"
+      "name" => "black",
+      "clientname" => "black",
+      "public_key" => "crowes",
+      "private_key" => "monkeypants",
+      "admin" => true,
+      "validator" => true,
+      "json_class" => "Chef::ApiClient"
       }
-
-      @http_client = double("Chef::REST mock")
-      allow(Chef::REST).to receive(:new).and_return(@http_client)
+      @http_client = double("Chef::ServerAPI mock")
+      allow(Chef::ServerAPI).to receive(:new).and_return(@http_client)
       expect(@http_client).to receive(:get).with("clients/black").and_return(client)
       @client = Chef::ApiClient.load(client['name'])
     end
@@ -275,10 +245,6 @@ describe Chef::ApiClient do
       expect(@client.admin).to be_a_kind_of(TrueClass)
     end
 
-    it "preserves the create_key status" do
-      expect(@client.create_key).to be_a_kind_of(TrueClass)
-    end
-
     it "preserves the 'validator' status" do
       expect(@client.validator).to be_a_kind_of(TrueClass)
     end
@@ -304,18 +270,13 @@ describe Chef::ApiClient do
       File.open(Chef::Config[:client_key], "r") {|f| f.read.chomp }
     end
 
-    it "has an HTTP client configured with default credentials" do
-      expect(@client.http_api).to be_a_kind_of(Chef::REST)
-      expect(@client.http_api.client_name).to eq("silent-bob")
-      expect(@client.http_api.signing_key.to_s).to eq(private_key_data)
-    end
   end
 
 
   describe "when requesting a new key" do
     before do
       @http_client = double("Chef::REST mock")
-      allow(Chef::REST).to receive(:new).and_return(@http_client)
+      allow(Chef::ServerAPI).to receive(:new).and_return(@http_client)
     end
 
     context "and the client does not exist on the server" do
@@ -332,34 +293,24 @@ describe Chef::ApiClient do
     end
 
     context "and the client exists" do
-      let(:chef_rest_v0_mock) { double('chef rest root v0 object') }
-      let(:payload) {
-        {:name => "lost-my-key", :admin => false, :validator => false, :private_key => true}
-      }
-
       before do
         @api_client_without_key = Chef::ApiClient.new
         @api_client_without_key.name("lost-my-key")
-        allow(@api_client_without_key).to receive(:chef_rest_v0).and_return(chef_rest_v0_mock)
-        #allow(@api_client_with_key).to receive(:http_api).and_return(_api_mock)
-
-        allow(chef_rest_v0_mock).to receive(:put).with("clients/lost-my-key", payload).and_return(@api_client_with_key)
-        allow(chef_rest_v0_mock).to receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
-        allow(@http_client).to receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
+        expect(@http_client).to receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
       end
 
+
       context "and the client exists on a Chef 11-like server" do
         before 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")
-          allow(@api_client_with_key).to receive(:chef_rest_v0).and_return(chef_rest_v0_mock)
+          expect(@http_client).to receive(:put).
+            with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :validator => false, :private_key => true).
+            and_return(@api_client_with_key)
         end
 
         it "returns an ApiClient with a private key" do
-          expect(chef_rest_v0_mock).to receive(:put).with("clients/lost-my-key", payload).
-                                        and_return(@api_client_with_key)
-
           response = Chef::ApiClient.reregister("lost-my-key")
           # no sane == method for ApiClient :'(
           expect(response).to eq(@api_client_without_key)
@@ -372,7 +323,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"}
-          expect(chef_rest_v0_mock).to receive(:put).
+          expect(@http_client).to receive(:put).
             with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :validator => false, :private_key => true).
             and_return(@api_client_with_key)
         end
@@ -390,134 +341,4 @@ describe Chef::ApiClient do
 
     end
   end
-
-  describe "Versioned API Interactions" do
-    let(:response_406) { OpenStruct.new(:code => '406') }
-    let(:exception_406) { Net::HTTPServerException.new("406 Not Acceptable", response_406) }
-    let(:payload)  {
-      {
-        :name => "some_name",
-        :validator => true,
-        :admin => true
-      }
-    }
-
-    before do
-      @client = Chef::ApiClient.new
-      allow(@client).to receive(:chef_rest_v0).and_return(double('chef rest root v0 object'))
-      allow(@client).to receive(:chef_rest_v1).and_return(double('chef rest root v1 object'))
-      @client.name "some_name"
-      @client.validator true
-      @client.admin true
-    end
-
-    describe "create" do
-
-      # from spec/support/shared/unit/user_and_client_shared.rb
-      it_should_behave_like "user or client create" do
-        let(:object)  { @client }
-        let(:error)   { Chef::Exceptions::InvalidClientAttribute }
-        let(:rest_v0) { @client.chef_rest_v0 }
-        let(:rest_v1) { @client.chef_rest_v1 }
-        let(:url)     { "clients" }
-      end
-
-      context "when API V1 is not supported by the server" do
-        # from spec/support/shared/unit/api_versioning.rb
-        it_should_behave_like "version handling" do
-          let(:object)    { @client }
-          let(:method)    { :create }
-          let(:http_verb) { :post }
-          let(:rest_v1)   { @client.chef_rest_v1 }
-        end
-      end
-
-    end # create
-
-    describe "update" do
-      context "when a valid client is defined" do
-
-        shared_examples_for "client updating" do
-          it "updates the client" do
-            expect(rest). to receive(:put).with("clients/some_name", payload)
-            @client.update
-          end
-
-          context "when only the name field exists" do
-
-            before do
-              # needed since there is no way to set to nil via code
-              @client.instance_variable_set(:@validator, nil)
-              @client.instance_variable_set(:@admin, nil)
-            end
-
-            after do
-              @client.validator true
-              @client.admin true
-            end
-
-            it "updates the client with only the name" do
-              expect(rest). to receive(:put).with("clients/some_name", {:name => "some_name"})
-              @client.update
-            end
-          end
-
-        end
-
-        context "when API V1 is supported by the server" do
-
-          it_should_behave_like "client updating" do
-            let(:rest) { @client.chef_rest_v1 }
-          end
-
-        end # when API V1 is supported by the server
-
-        context "when API V1 is not supported by the server" do
-          context "when no version is supported" do
-            # from spec/support/shared/unit/api_versioning.rb
-            it_should_behave_like "version handling" do
-              let(:object)    { @client }
-              let(:method)    { :create }
-              let(:http_verb) { :post }
-              let(:rest_v1)   { @client.chef_rest_v1 }
-            end
-          end # when no version is supported
-
-          context "when API V0 is supported" do
-
-            before do
-              allow(@client.chef_rest_v1).to receive(:put).and_raise(exception_406)
-              allow(@client).to receive(:server_client_api_version_intersection).and_return([0])
-            end
-
-            it_should_behave_like "client updating" do
-              let(:rest) { @client.chef_rest_v0 }
-            end
-
-          end
-
-        end # when API V1 is not supported by the server
-      end # when a valid client is defined
-    end # update
-
-    # DEPRECATION
-    # This can be removed after API V0 support is gone
-    describe "reregister" do
-      context "when server API V0 is valid on the Chef Server receiving the request" do
-        it "creates a new object via the API" do
-          expect(@client.chef_rest_v0).to receive(:put).with("clients/#{@client.name}", payload.merge({:private_key => true})).and_return({})
-          @client.reregister
-        end
-      end # when server API V0 is valid on the Chef Server receiving the request
-
-      context "when server API V0 is not supported by the Chef Server" do
-        # from spec/support/shared/unit/api_versioning.rb
-        it_should_behave_like "user and client reregister" do
-          let(:object)    { @client }
-          let(:rest_v0)   { @client.chef_rest_v0 }
-        end
-      end # when server API V0 is not supported by the Chef Server
-    end # reregister
-
-  end
 end

data/spec/unit/api_client_v1_spec.rb

@@ -0,0 +1,457 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/api_client_v1'
+require 'tempfile'
+
+describe Chef::ApiClientV1 do
+  before(:each) do
+    @client = Chef::ApiClientV1.new
+  end
+
+  it "has a name attribute" do
+    @client.name("ops_master")
+    expect(@client.name).to eq("ops_master")
+  end
+
+  it "does not allow spaces in the name" do
+    expect { @client.name "ops master" }.to raise_error(ArgumentError)
+  end
+
+  it "only allows string values for the name" do
+    expect { @client.name Hash.new }.to raise_error(ArgumentError)
+  end
+
+  it "has an admin flag attribute" do
+    @client.admin(true)
+    expect(@client.admin).to be_truthy
+  end
+
+  it "defaults to non-admin" do
+    expect(@client.admin).to be_falsey
+  end
+
+  it "allows only boolean values for the admin flag" do
+    expect { @client.admin(false) }.not_to raise_error
+    expect { @client.admin(Hash.new) }.to raise_error(ArgumentError)
+  end
+
+  it "has an create_key flag attribute" do
+    @client.create_key(true)
+    expect(@client.create_key).to be_truthy
+  end
+
+  it "create_key defaults to false" do
+    expect(@client.create_key).to be_falsey
+  end
+
+  it "allows only boolean values for the create_key flag" do
+    expect { @client.create_key(false) }.not_to raise_error
+    expect { @client.create_key(Hash.new) }.to raise_error(ArgumentError)
+  end
+
+  it "has a 'validator' flag attribute" do
+    @client.validator(true)
+    expect(@client.validator).to be_truthy
+  end
+
+  it "defaults to non-validator" do
+    expect(@client.validator).to be_falsey
+  end
+
+  it "allows only boolean values for the 'validator' flag" do
+    expect { @client.validator(false) }.not_to raise_error
+    expect { @client.validator(Hash.new) }.to raise_error(ArgumentError)
+  end
+
+  it "has a public key attribute" do
+    @client.public_key("super public")
+    expect(@client.public_key).to eq("super public")
+  end
+
+  it "accepts only String values for the public key" do
+    expect { @client.public_key "" }.not_to raise_error
+    expect { @client.public_key Hash.new }.to raise_error(ArgumentError)
+  end
+
+
+  it "has a private key attribute" do
+    @client.private_key("super private")
+    expect(@client.private_key).to eq("super private")
+  end
+
+  it "accepts only String values for the private key" do
+    expect { @client.private_key "" }.not_to raise_error
+    expect { @client.private_key Hash.new }.to raise_error(ArgumentError)
+  end
+
+  describe "when serializing to JSON" do
+    before(:each) do
+      @client.name("black")
+      @client.public_key("crowes")
+      @json = @client.to_json
+    end
+
+    it "serializes as a JSON object" do
+      expect(@json).to match(/^\{.+\}$/)
+    end
+
+    it "includes the name value" do
+      expect(@json).to include(%q{"name":"black"})
+    end
+
+    it "includes the public key value" do
+      expect(@json).to include(%{"public_key":"crowes"})
+    end
+
+    it "includes the 'admin' flag" do
+      expect(@json).to include(%q{"admin":false})
+    end
+
+    it "includes the 'validator' flag" do
+      expect(@json).to include(%q{"validator":false})
+    end
+
+    it "includes the 'create_key' flag when present" do
+      @client.create_key(true)
+      @json = @client.to_json
+      expect(@json).to include(%q{"create_key":true})
+    end
+
+    it "includes the private key when present" do
+      @client.private_key("monkeypants")
+      expect(@client.to_json).to include(%q{"private_key":"monkeypants"})
+    end
+
+    it "does not include the private key if not present" do
+      expect(@json).not_to include("private_key")
+    end
+
+    include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
+      let(:jsonable) { @client }
+    end
+  end
+
+  describe "when deserializing from JSON (string) using ApiClient#from_json" do
+    let(:client_string) do
+      "{\"name\":\"black\",\"public_key\":\"crowes\",\"private_key\":\"monkeypants\",\"admin\":true,\"validator\":true,\"create_key\":true}"
+    end
+
+    let(:client) do
+      Chef::ApiClientV1.from_json(client_string)
+    end
+
+    it "does not require a 'json_class' string" do
+      expect(Chef::JSONCompat.parse(client_string)["json_class"]).to eq(nil)
+    end
+
+    it "should deserialize to a Chef::ApiClientV1 object" do
+      expect(client).to be_a_kind_of(Chef::ApiClientV1)
+    end
+
+    it "preserves the name" do
+      expect(client.name).to eq("black")
+    end
+
+    it "preserves the public key" do
+      expect(client.public_key).to eq("crowes")
+    end
+
+    it "preserves the admin status" do
+      expect(client.admin).to be_truthy
+    end
+
+    it "preserves the create_key status" do
+      expect(client.create_key).to be_truthy
+    end
+
+    it "preserves the 'validator' status" do
+      expect(client.validator).to be_truthy
+    end
+
+    it "includes the private key if present" do
+      expect(client.private_key).to eq("monkeypants")
+    end
+  end
+
+  describe "when deserializing from JSON (hash) using ApiClientV1#from_json" do
+    let(:client_hash) do
+      {
+        "name" => "black",
+        "public_key" => "crowes",
+        "private_key" => "monkeypants",
+        "admin" => true,
+        "validator" => true,
+        "create_key" => true
+      }
+    end
+
+    let(:client) do
+      Chef::ApiClientV1.from_json(Chef::JSONCompat.to_json(client_hash))
+    end
+
+    it "should deserialize to a Chef::ApiClientV1 object" do
+      expect(client).to be_a_kind_of(Chef::ApiClientV1)
+    end
+
+    it "preserves the name" do
+      expect(client.name).to eq("black")
+    end
+
+    it "preserves the public key" do
+      expect(client.public_key).to eq("crowes")
+    end
+
+    it "preserves the admin status" do
+      expect(client.admin).to be_truthy
+    end
+
+    it "preserves the create_key status" do
+      expect(client.create_key).to be_truthy
+    end
+
+    it "preserves the 'validator' status" do
+      expect(client.validator).to be_truthy
+    end
+
+    it "includes the private key if present" do
+      expect(client.private_key).to eq("monkeypants")
+    end
+  end
+
+  describe "when loading from JSON" do
+    before do
+    end
+
+    before(:each) do
+      client = {
+        "name" => "black",
+        "clientname" => "black",
+        "public_key" => "crowes",
+        "private_key" => "monkeypants",
+        "admin" => true,
+        "create_key" => true,
+        "validator" => true
+      }
+
+      @http_client = double("Chef::ServerAPI mock")
+      allow(Chef::ServerAPI).to receive(:new).and_return(@http_client)
+      expect(@http_client).to receive(:get).with("clients/black").and_return(client)
+      @client = Chef::ApiClientV1.load(client['name'])
+    end
+
+    it "should deserialize to a Chef::ApiClientV1 object" do
+      expect(@client).to be_a_kind_of(Chef::ApiClientV1)
+    end
+
+    it "preserves the name" do
+      expect(@client.name).to eq("black")
+    end
+
+    it "preserves the public key" do
+      expect(@client.public_key).to eq("crowes")
+    end
+
+    it "preserves the admin status" do
+      expect(@client.admin).to be_a_kind_of(TrueClass)
+    end
+
+    it "preserves the create_key status" do
+      expect(@client.create_key).to be_a_kind_of(TrueClass)
+    end
+
+    it "preserves the 'validator' status" do
+      expect(@client.validator).to be_a_kind_of(TrueClass)
+    end
+
+    it "includes the private key if present" do
+      expect(@client.private_key).to eq("monkeypants")
+    end
+
+  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
+
+  end
+
+
+  describe "when requesting a new key" do
+    before do
+      @http_client = double("Chef::ServerAPI mock")
+      allow(Chef::ServerAPI).to receive(:new).and_return(@http_client)
+    end
+
+    context "and the client does not exist on the server" do
+      before 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)
+
+        expect(@http_client).to receive(:get).with("clients/lost-my-key").and_raise(@a_404_exception)
+      end
+
+      it "raises a 404 error" do
+        expect { Chef::ApiClientV1.reregister("lost-my-key") }.to raise_error(Net::HTTPServerException)
+      end
+    end
+  end
+
+  describe "Versioned API Interactions" do
+    let(:response_406) { OpenStruct.new(:code => '406') }
+    let(:exception_406) { Net::HTTPServerException.new("406 Not Acceptable", response_406) }
+    let(:payload)  {
+      {
+        :name => "some_name",
+        :validator => true,
+        :admin => true
+      }
+    }
+
+    before do
+      @client = Chef::ApiClientV1.new
+      allow(@client).to receive(:chef_rest_v0).and_return(double('chef rest root v0 object'))
+      allow(@client).to receive(:chef_rest_v1).and_return(double('chef rest root v1 object'))
+      @client.name "some_name"
+      @client.validator true
+      @client.admin true
+    end
+
+    describe "create" do
+
+      # from spec/support/shared/unit/user_and_client_shared.rb
+      it_should_behave_like "user or client create" do
+        let(:object)  { @client }
+        let(:error)   { Chef::Exceptions::InvalidClientAttribute }
+        let(:rest_v0) { @client.chef_rest_v0 }
+        let(:rest_v1) { @client.chef_rest_v1 }
+        let(:url)     { "clients" }
+      end
+
+      context "when API V1 is not supported by the server" do
+        # from spec/support/shared/unit/api_versioning.rb
+        it_should_behave_like "version handling" do
+          let(:object)    { @client }
+          let(:method)    { :create }
+          let(:http_verb) { :post }
+          let(:rest_v1)   { @client.chef_rest_v1 }
+        end
+      end
+
+    end # create
+
+    describe "update" do
+      context "when a valid client is defined" do
+
+        shared_examples_for "client updating" do
+          it "updates the client" do
+            expect(rest). to receive(:put).with("clients/some_name", payload).and_return(payload)
+            @client.update
+          end
+
+          context "when only the name field exists" do
+
+            before do
+              # needed since there is no way to set to nil via code
+              @client.instance_variable_set(:@validator, nil)
+              @client.instance_variable_set(:@admin, nil)
+            end
+
+            after do
+              @client.validator true
+              @client.admin true
+            end
+
+            it "updates the client with only the name" do
+              expect(rest). to receive(:put).with("clients/some_name", {:name => "some_name"}).and_return({:name => "some_name"})
+              @client.update
+            end
+          end
+
+        end
+
+        context "when API V1 is supported by the server" do
+
+          it_should_behave_like "client updating" do
+            let(:rest) { @client.chef_rest_v1 }
+          end
+
+        end # when API V1 is supported by the server
+
+        context "when API V1 is not supported by the server" do
+          context "when no version is supported" do
+            # from spec/support/shared/unit/api_versioning.rb
+            it_should_behave_like "version handling" do
+              let(:object)    { @client }
+              let(:method)    { :create }
+              let(:http_verb) { :post }
+              let(:rest_v1)   { @client.chef_rest_v1 }
+            end
+          end # when no version is supported
+
+          context "when API V0 is supported" do
+
+            before do
+              allow(@client.chef_rest_v1).to receive(:put).and_raise(exception_406)
+              allow(@client).to receive(:server_client_api_version_intersection).and_return([0])
+            end
+
+            it_should_behave_like "client updating" do
+              let(:rest) { @client.chef_rest_v0 }
+            end
+
+          end
+
+        end # when API V1 is not supported by the server
+      end # when a valid client is defined
+    end # update
+
+    # DEPRECATION
+    # This can be removed after API V0 support is gone
+    describe "reregister" do
+      context "when server API V0 is valid on the Chef Server receiving the request" do
+        it "creates a new object via the API" do
+          expect(@client.chef_rest_v0).to receive(:put).with("clients/#{@client.name}", payload.merge({:private_key => true})).and_return({})
+          @client.reregister
+        end
+      end # when server API V0 is valid on the Chef Server receiving the request
+
+      context "when server API V0 is not supported by the Chef Server" do
+        # from spec/support/shared/unit/api_versioning.rb
+        it_should_behave_like "user and client reregister" do
+          let(:object)    { @client }
+          let(:rest_v0)   { @client.chef_rest_v0 }
+        end
+      end # when server API V0 is not supported by the Chef Server
+    end # reregister
+
+  end
+end