Updated changes to remove userV1 and use root_rest object

Signed-off-by: snehaldwivedi <sdwivedi@msystechnologies.com>

23 files changed, 203 insertions, 265 deletions

diff --git a/lib/chef/knife.rb b/lib/chef/knife.rb
index ac7a68d0fc..9e2578ef3a 100644
--- a/lib/chef/knife.rb
+++ b/lib/chef/knife.rb
@@ -661,5 +661,12 @@ class Chef
       end
       Chef::Config.init_openssl
     end
+
+    def root_rest
+      @root_rest ||= begin
+        require_relative "server_api"
+        Chef::ServerAPI.new(Chef::Config[:chef_server_root], { api_version: "2" })
+      end
+    end
   end
 end
diff --git a/lib/chef/knife/org_create.rb b/lib/chef/knife/org_create.rb
index d9f30e565d..3c1354ae22 100644
--- a/lib/chef/knife/org_create.rb
+++ b/lib/chef/knife/org_create.rb
@@ -62,6 +62,8 @@ class Chef
           org.add_user_to_group("admins", config[:association_user])
           org.add_user_to_group("billing-admins", config[:association_user])
         end
+
+        ui.info("Created #{org_name}")
       end
     end
   end
diff --git a/lib/chef/knife/org_delete.rb b/lib/chef/knife/org_delete.rb
index 6fc3f7aaae..340f6c529a 100644
--- a/lib/chef/knife/org_delete.rb
+++ b/lib/chef/knife/org_delete.rb
@@ -22,15 +22,10 @@ class Chef
       category "CHEF ORGANIZATION MANAGEMENT"
       banner "knife org delete ORG_NAME"
 
-      deps do
-        require_relative "../org"
-      end
-
       def run
         org_name = @name_args[0]
-        org = Chef::Org.new(org_name)
         ui.confirm "Do you want to delete the organization #{org_name}"
-        ui.output org.chef_rest.delete("organizations/#{org_name}")
+        ui.output root_rest.delete("organizations/#{org_name}")
       end
     end
   end
diff --git a/lib/chef/knife/org_edit.rb b/lib/chef/knife/org_edit.rb
index 9857e27600..1d684ca0b4 100644
--- a/lib/chef/knife/org_edit.rb
+++ b/lib/chef/knife/org_edit.rb
@@ -22,10 +22,6 @@ class Chef
       category "CHEF ORGANIZATION MANAGEMENT"
       banner "knife org edit ORG"
 
-      deps do
-        require_relative "../org"
-      end
-
       def run
         org_name = @name_args[0]
 
@@ -35,8 +31,7 @@ class Chef
           exit 1
         end
 
-        chef_rest = Chef::Org.from_hash({ "name" => org_name }).chef_rest
-        original_org = chef_rest.get("organizations/#{org_name}")
+        original_org = root_rest.get("organizations/#{org_name}")
         edited_org = edit_hash(original_org)
 
         if original_org == edited_org
@@ -45,7 +40,7 @@ class Chef
         end
 
         ui.msg edited_org
-        chef_rest.put("organizations/#{org_name}", edited_org)
+        root_rest.put("organizations/#{org_name}", edited_org)
         ui.msg("Saved #{org_name}.")
       end
     end
diff --git a/lib/chef/knife/org_list.rb b/lib/chef/knife/org_list.rb
index 33c7b4c893..85a49ee4c5 100644
--- a/lib/chef/knife/org_list.rb
+++ b/lib/chef/knife/org_list.rb
@@ -32,13 +32,8 @@ class Chef
         short: "-a",
         description: "Show auto-generated hidden orgs in output"
 
-      deps do
-        require_relative "../org"
-      end
-
       def run
-        org = Chef::Org.from_hash({})
-        results = org.chef_rest.get("organizations")
+        results = root_rest.get("organizations")
         unless config[:all_orgs]
           results = results.select { |k, v| !(k.length == 20 && k =~ /^[a-z]+$/) }
         end
diff --git a/lib/chef/knife/org_show.rb b/lib/chef/knife/org_show.rb
index d96dfb7727..a8bb207c1d 100644
--- a/lib/chef/knife/org_show.rb
+++ b/lib/chef/knife/org_show.rb
@@ -22,14 +22,9 @@ class Chef
       category "CHEF ORGANIZATION MANAGEMENT"
       banner "knife org show ORGNAME"
 
-      deps do
-        require_relative "../org"
-      end
-
       def run
         org_name = @name_args[0]
-        org = Chef::Org.from_hash({ "name" => org_name })
-        ui.output org.chef_rest.get("organizations/#{org_name}")
+        ui.output root_rest.get("organizations/#{org_name}")
       end
     end
   end
diff --git a/lib/chef/knife/user_create.rb b/lib/chef/knife/user_create.rb
index 6e552e25b6..bd9103d958 100644
--- a/lib/chef/knife/user_create.rb
+++ b/lib/chef/knife/user_create.rb
@@ -1,5 +1,4 @@
 #
-# Author:: Steven Danna (<steve@chef.io>)
 # Author:: Tyler Cloke (<tyler@chef.io>)
 # Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
@@ -27,7 +26,7 @@ class Chef
       attr_accessor :user_field
 
       deps do
-        require_relative "../user_v1"
+        require_relative "../user"
       end
 
       option :file,
@@ -58,15 +57,7 @@ class Chef
       banner "knife user create USERNAME DISPLAY_NAME FIRST_NAME LAST_NAME EMAIL PASSWORD (options)"
 
       def user
-        @user_field ||= Chef::UserV1.new
-      end
-
-      def create_user_from_hash(hash)
-        Chef::UserV1.from_hash(hash).create
-      end
-
-      def chef_rest
-        user.chef_root_rest_v0
+        @user_field ||= Chef::User.new
       end
 
       def run
@@ -123,16 +114,16 @@ class Chef
           end
         end
 
-        final_user = chef_rest.post("users/", user_hash)
+        final_user = root_rest.post("users/", user_hash)
 
         if config[:orgname]
           request_body = { user: user.username }
-          response = chef_rest.post("organizations/#{config[:orgname]}/association_requests", request_body)
+          response = root_rest.post("organizations/#{config[:orgname]}/association_requests", request_body)
           association_id = response["uri"].split("/").last
-          chef_rest.put("users/#{user.username}/association_requests/#{association_id}", { response: "accept" })
+          root_rest.put("users/#{user.username}/association_requests/#{association_id}", { response: "accept" })
         end
 
-        ui.info("Created #{user}")
+        ui.info("Created #{user.username}")
         if final_user["private_key"]
           if config[:file]
             File.open(config[:file], "w") do |f|
diff --git a/lib/chef/knife/user_delete.rb b/lib/chef/knife/user_delete.rb
index 217b83e2fa..64d729c951 100644
--- a/lib/chef/knife/user_delete.rb
+++ b/lib/chef/knife/user_delete.rb
@@ -24,7 +24,6 @@ class Chef
 
       deps do
         require_relative "../org"
-        require_relative "../user_v1"
       end
 
       banner "knife user delete USER (options)"
@@ -41,10 +40,6 @@ class Chef
 
       attr_reader :username
 
-      def user
-        @user_field ||= Chef::UserV1.new
-      end
-
       def run
         @username = @name_args[0]
         admin_memberships = []
@@ -87,7 +82,7 @@ class Chef
       end
 
       def org_memberships(username)
-        org_data = user.chef_root_rest_v0.get("users/#{username}/organizations")
+        org_data = root_rest.get("users/#{username}/organizations")
         org_data.map { |org| Chef::Org.new(org["organization"]["name"]) }
       end
 
@@ -114,7 +109,7 @@ class Chef
 
       def delete_user(username)
         ui.stderr.puts "Deleting user #{username}."
-        user.chef_root_rest_v0.delete("users/#{username}")
+        root_rest.delete("users/#{username}")
       end
 
       # Error message that says how to removed from org
diff --git a/lib/chef/knife/user_edit.rb b/lib/chef/knife/user_edit.rb
index 6175276335..fff8c6b70f 100644
--- a/lib/chef/knife/user_edit.rb
+++ b/lib/chef/knife/user_edit.rb
@@ -22,10 +22,6 @@ class Chef
   class Knife
     class UserEdit < Knife
 
-      deps do
-        require_relative "../user_v1"
-      end
-
       banner "knife user edit USER (options)"
 
       option :input,
@@ -46,11 +42,10 @@ class Chef
           ui.fatal("You must specify a user name")
           exit 1
         end
-
-        original_user = Chef::UserV1.load(@user_name).to_hash
-        edited_user = edit_hash(original_user)
+        original_user = root_rest.get("users/#{@user_name}")
+        edited_user = get_updated_user(original_user)
         if original_user != edited_user
-          result = Chef::UserV1.new.chef_root_rest_v0.put("users/#{@user_name}", edited_user)
+          result = root_rest.put("users/#{@user_name}", edited_user)
           ui.msg("Saved #{@user_name}.")
           unless result["private_key"].nil?
             if config[:filename]
diff --git a/lib/chef/knife/user_list.rb b/lib/chef/knife/user_list.rb
index b0b709b642..3284964a47 100644
--- a/lib/chef/knife/user_list.rb
+++ b/lib/chef/knife/user_list.rb
@@ -29,19 +29,10 @@ class Chef
         long: "--with-uri",
         description: "Show corresponding URIs."
 
-      deps do
-        require_relative "../user_v1"
-      end
-
-      def user
-        @user_field ||= Chef::UserV1.new
-      end
-
       def run
-        results = user.chef_root_rest_v0.get("users")
+        results = root_rest.get("users")
         output(format_list_for_display(results))
       end
-
     end
   end
 end
diff --git a/lib/chef/knife/user_password.rb b/lib/chef/knife/user_password.rb
index 06e83e4f52..2da3c3e285 100644
--- a/lib/chef/knife/user_password.rb
+++ b/lib/chef/knife/user_password.rb
@@ -26,14 +26,6 @@ class Chef
         short: "-e",
         description: "Enable external authentication for this user (such as LDAP)"
 
-      deps do
-        require_relative "../user_v1"
-      end
-
-      def user
-        @user_field ||= Chef::UserV1.new
-      end
-
       def run
         # check that correct number of args was passed, should be either
         # USERNAME PASSWORD or USERNAME --enable-external-auth
@@ -55,7 +47,7 @@ class Chef
         # true or false, there is no way of knowing if the user is using ldap or not,
         # so we will update the user every time, instead of checking if we are actually
         # changing anything before we PUT.
-        result = user.chef_root_rest_v0.get("users/#{user_name}")
+        result = root_rest.get("users/#{user_name}")
 
         result["password"] = password unless password.nil?
 
@@ -66,7 +58,7 @@ class Chef
         result["recovery_authentication_enabled"] = !config[:enable_external_auth]
 
         begin
-          user.chef_root_rest_v0.put("users/#{user_name}", result)
+          root_rest.put("users/#{user_name}", result)
         rescue => e
           raise e
         end
diff --git a/lib/chef/knife/user_show.rb b/lib/chef/knife/user_show.rb
index f3caf1bec7..ea2b06b753 100644
--- a/lib/chef/knife/user_show.rb
+++ b/lib/chef/knife/user_show.rb
@@ -30,14 +30,6 @@ class Chef
         long: "--with-orgs",
         short: "-l"
 
-      deps do
-        require_relative "../user_v1"
-      end
-
-      def user
-        @user_field ||= Chef::UserV1.new
-      end
-
       def run
         @user_name = @name_args[0]
 
@@ -47,9 +39,9 @@ class Chef
           exit 1
         end
 
-        results = user.chef_root_rest_v0.get("users/#{@user_name}")
+        results = root_rest.get("users/#{@user_name}")
         if config[:with_orgs]
-          orgs = user.chef_root_rest_v0.get("users/#{@user_name}/organizations")
+          orgs = root_rest.get("users/#{@user_name}/organizations")
           results["organizations"] = orgs.map { |o| o["organization"]["name"] }
         end
         output(format_for_display(results))
diff --git a/lib/chef/user.rb b/lib/chef/user.rb
index e578cc2131..1350db5f10 100644
--- a/lib/chef/user.rb
+++ b/lib/chef/user.rb
@@ -22,6 +22,7 @@ require_relative "mash"
 require_relative "json_compat"
 require_relative "search/query"
 require_relative "server_api"
+require_relative "userable"
 
 # TODO
 # DEPRECATION NOTE
@@ -35,48 +36,10 @@ require_relative "server_api"
 # This file and corresponding osc_user knife files
 # should be removed once client support for Open Source Chef Server 11 expires.
 class Chef
-  class User
-
+  class User < Chef::Userable
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
 
-    def initialize
-      @name = ""
-      @public_key = nil
-      @private_key = nil
-      @password = nil
-      @admin = false
-    end
-
-    def chef_rest_v0
-      @chef_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "0" })
-    end
-
-    def name(arg = nil)
-      set_or_return(:name, arg,
-        regex: /^[a-z0-9\-_]+$/)
-    end
-
-    def admin(arg = nil)
-      set_or_return(:admin,
-        arg, kind_of: [TrueClass, FalseClass])
-    end
-
-    def public_key(arg = nil)
-      set_or_return(:public_key,
-        arg, kind_of: String)
-    end
-
-    def private_key(arg = nil)
-      set_or_return(:private_key,
-        arg, kind_of: String)
-    end
-
-    def password(arg = nil)
-      set_or_return(:password,
-        arg, kind_of: String)
-    end
-
     def to_h
       result = {
         "name" => @name,
@@ -95,13 +58,13 @@ class Chef
     end
 
     def destroy
-      chef_rest_v0.delete("users/#{@name}")
+      chef_root_rest_v0.delete("users/#{@name}")
     end
 
     def create
       payload = { name: name, admin: admin, password: password }
       payload[:public_key] = public_key if public_key
-      new_user = chef_rest_v0.post("users", payload)
+      new_user = chef_root_rest_v0.post("users", payload)
       Chef::User.from_hash(to_h.merge(new_user))
     end
 
@@ -109,7 +72,7 @@ class Chef
       payload = { name: name, admin: admin }
       payload[:private_key] = new_key if new_key
       payload[:password] = password if password
-      updated_user = chef_rest_v0.put("users/#{name}", payload)
+      updated_user = chef_root_rest_v0.put("users/#{name}", payload)
       Chef::User.from_hash(to_h.merge(updated_user))
     end
 
@@ -124,7 +87,7 @@ class Chef
     end
 
     def reregister
-      reregistered_self = chef_rest_v0.put("users/#{name}", { name: name, admin: admin, private_key: true })
+      reregistered_self = chef_root_rest_v0.put("users/#{name}", { name: name, admin: admin, private_key: true })
       private_key(reregistered_self["private_key"])
       self
     end
diff --git a/lib/chef/user_v1.rb b/lib/chef/user_v1.rb
index 945f0197df..a8dc9215c5 100644
--- a/lib/chef/user_v1.rb
+++ b/lib/chef/user_v1.rb
@@ -24,6 +24,7 @@ require_relative "search/query"
 require_relative "mixin/api_version_request_handling"
 require_relative "exceptions"
 require_relative "server_api"
+require_relative "userable"
 
 # OSC 11 BACKWARDS COMPATIBILITY NOTE (remove after OSC 11 support ends)
 #
@@ -33,7 +34,7 @@ require_relative "server_api"
 #
 # Exception: self.list is backwards compatible with OSC 11
 class Chef
-  class UserV1
+  class UserV1 < Chef::Userable
 
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
@@ -41,77 +42,6 @@ class Chef
 
     SUPPORTED_API_VERSIONS = [0, 1].freeze
 
-    def initialize
-      @username = nil
-      @display_name = nil
-      @first_name = nil
-      @middle_name = nil
-      @last_name = nil
-      @email = nil
-      @password = nil
-      @public_key = nil
-      @private_key = nil
-      @create_key = nil
-    end
-
-    def chef_root_rest_v0
-      @chef_root_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], { api_version: "0" })
-    end
-
-    def chef_root_rest_v1
-      @chef_root_rest_v1 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], { api_version: "1" })
-    end
-
-    def username(arg = nil)
-      set_or_return(:username, arg,
-        regex: /^[a-z0-9\-_]+$/)
-    end
-
-    def display_name(arg = nil)
-      set_or_return(:display_name,
-        arg, kind_of: String)
-    end
-
-    def first_name(arg = nil)
-      set_or_return(:first_name,
-        arg, kind_of: String)
-    end
-
-    def middle_name(arg = nil)
-      set_or_return(:middle_name,
-        arg, kind_of: String)
-    end
-
-    def last_name(arg = nil)
-      set_or_return(:last_name,
-        arg, kind_of: String)
-    end
-
-    def email(arg = nil)
-      set_or_return(:email,
-        arg, kind_of: String)
-    end
-
-    def create_key(arg = nil)
-      set_or_return(:create_key, arg,
-        kind_of: [TrueClass, FalseClass])
-    end
-
-    def public_key(arg = nil)
-      set_or_return(:public_key,
-        arg, kind_of: String)
-    end
-
-    def private_key(arg = nil)
-      set_or_return(:private_key,
-        arg, kind_of: String)
-    end
-
-    def password(arg = nil)
-      set_or_return(:password,
-        arg, kind_of: String)
-    end
-
     def to_h
       result = {
         "username" => @username,
diff --git a/lib/chef/userable.rb b/lib/chef/userable.rb
new file mode 100644
index 0000000000..2c25f5237d
--- /dev/null
+++ b/lib/chef/userable.rb
@@ -0,0 +1,106 @@
+#
+# Author:: Snehal Dwivedi (sdwivedi@chef.io)
+# Copyright:: Copyright (c) 2008-2016 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.
+#
+
+# common methods of User and UserV1
+class Chef
+  class Userable
+
+    def initialize
+      @name = ""
+      @password = nil
+      @admin = false
+      @username = nil
+      @display_name = nil
+      @first_name = nil
+      @middle_name = nil
+      @last_name = nil
+      @email = nil
+      @public_key = nil
+      @private_key = nil
+      @create_key = nil
+    end
+
+    def chef_root_rest_v0
+      @chef_root_rest_v22 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], { api_version: "0" })
+    end
+
+    def chef_root_rest_v1
+      @chef_root_rest_v22 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], { api_version: "1" })
+    end
+
+    def name(arg = nil)
+      set_or_return(:name, arg,
+        regex: /^[a-z0-9\-_]+$/)
+    end
+
+    def admin(arg = nil)
+      set_or_return(:admin,
+        arg, kind_of: [TrueClass, FalseClass])
+    end
+
+    def username(arg = nil)
+      set_or_return(:username, arg,
+        regex: /^[a-z0-9\-_]+$/)
+    end
+
+    def display_name(arg = nil)
+      set_or_return(:display_name,
+        arg, kind_of: String)
+    end
+
+    def first_name(arg = nil)
+      set_or_return(:first_name,
+        arg, kind_of: String)
+    end
+
+    def middle_name(arg = nil)
+      set_or_return(:middle_name,
+        arg, kind_of: String)
+    end
+
+    def last_name(arg = nil)
+      set_or_return(:last_name,
+        arg, kind_of: String)
+    end
+
+    def email(arg = nil)
+      set_or_return(:email,
+        arg, kind_of: String)
+    end
+
+    def create_key(arg = nil)
+      set_or_return(:create_key, arg,
+        kind_of: [TrueClass, FalseClass])
+    end
+
+    def public_key(arg = nil)
+      set_or_return(:public_key,
+        arg, kind_of: String)
+    end
+
+    def private_key(arg = nil)
+      set_or_return(:private_key,
+        arg, kind_of: String)
+    end
+
+    def password(arg = nil)
+      set_or_return(:password,
+        arg, kind_of: String)
+    end
+  end
+end
diff --git a/spec/unit/knife/org_delete_spec.rb b/spec/unit/knife/org_delete_spec.rb
index aa457cd414..38a9032bf4 100644
--- a/spec/unit/knife/org_delete_spec.rb
+++ b/spec/unit/knife/org_delete_spec.rb
@@ -21,7 +21,7 @@ require "chef/org"
 
 describe Chef::Knife::OrgDelete do
 
-  let(:chef_rest) { double("Chef::ServerAPI") }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   before :each do
     @knife = Chef::Knife::OrgDelete.new
@@ -32,10 +32,9 @@ describe Chef::Knife::OrgDelete do
   end
 
   it "should confirm that you want to delete and then delete organizations" do
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
-    allow(@org).to receive(:chef_rest).and_return(chef_rest)
+    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
     expect(@knife.ui).to receive(:confirm).with("Do you want to delete the organization #{@org_name}")
-    expect(@org.chef_rest).to receive(:delete).with("organizations/#{@org_name}")
+    expect(root_rest).to receive(:delete).with("organizations/#{@org_name}")
     expect(@knife.ui).to receive(:output)
     @knife.run
   end
diff --git a/spec/unit/knife/org_edit_spec.rb b/spec/unit/knife/org_edit_spec.rb
index 5cc5d9e54b..25be4bf03c 100644
--- a/spec/unit/knife/org_edit_spec.rb
+++ b/spec/unit/knife/org_edit_spec.rb
@@ -20,24 +20,23 @@ require "spec_helper"
 
 describe Chef::Knife::OrgEdit do
   let(:knife) { Chef::Knife::OrgEdit.new }
-  let(:chef_rest) { double("Chef::ServerAPI") }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   before :each do
     Chef::Knife::OrgEdit.load_deps
     @org_name = "foobar"
     knife.name_args << @org_name
     @org = double("Chef::Org")
-    allow(@org).to receive(:chef_rest).and_return(chef_rest)
     knife.config[:disable_editing] = true
   end
 
   it "loads and edits the organisation" do
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
+    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
     original_data = { "org_name" => "my_org" }
     data = { "org_name" => "my_org1" }
-    expect(@org.chef_rest).to receive(:get).with("organizations/foobar").and_return(original_data)
+    expect(root_rest).to receive(:get).with("organizations/foobar").and_return(original_data)
     expect(knife).to receive(:edit_hash).with(original_data).and_return(data)
-    expect(@org.chef_rest).to receive(:put).with("organizations/foobar", data)
+    expect(root_rest).to receive(:put).with("organizations/foobar", data)
     knife.run
   end
 
diff --git a/spec/unit/knife/org_list_spec.rb b/spec/unit/knife/org_list_spec.rb
index d4152b66e3..b332bdbe8d 100644
--- a/spec/unit/knife/org_list_spec.rb
+++ b/spec/unit/knife/org_list_spec.rb
@@ -20,7 +20,7 @@ require "chef/org"
 
 describe Chef::Knife::OrgList do
 
-  let(:chef_rest) { double("Chef::ServerAPI") }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   let(:orgs) do
     {
@@ -33,9 +33,8 @@ describe Chef::Knife::OrgList do
   before :each do
     @org = double("Chef::Org")
     @knife = Chef::Knife::OrgList.new
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
-    allow(@org).to receive(:chef_rest).and_return(chef_rest)
-    allow(@org.chef_rest).to receive(:get).with("organizations").and_return(orgs)
+    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+    allow(root_rest).to receive(:get).with("organizations").and_return(orgs)
   end
 
   describe "with no arguments" do
diff --git a/spec/unit/knife/org_show_spec.rb b/spec/unit/knife/org_show_spec.rb
index 90765f4273..e3d5fc1fdb 100644
--- a/spec/unit/knife/org_show_spec.rb
+++ b/spec/unit/knife/org_show_spec.rb
@@ -21,24 +21,24 @@ require "chef/org"
 
 describe Chef::Knife::OrgShow do
 
-  let(:chef_rest) { double("Chef::ServerAPI") }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   before :each do
     @knife = Chef::Knife::OrgShow.new
     @org_name = "foobar"
     @knife.name_args << @org_name
     @org = double("Chef::Org")
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(chef_rest)
-    allow(@org).to receive(:chef_rest).and_return(chef_rest)
+    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+    allow(@org).to receive(:root_rest).and_return(root_rest)
   end
 
   it "should load the organisation" do
-    expect(@org.chef_rest).to receive(:get).with("organizations/#{@org_name}")
+    expect(root_rest).to receive(:get).with("organizations/#{@org_name}")
     @knife.run
   end
 
   it "should pretty print the output organisation" do
-    expect(@org.chef_rest).to receive(:get).with("organizations/#{@org_name}")
+    expect(root_rest).to receive(:get).with("organizations/#{@org_name}")
     expect(@knife.ui).to receive(:output)
     @knife.run
   end
diff --git a/spec/unit/knife/user_create_spec.rb b/spec/unit/knife/user_create_spec.rb
index 3d03b40d03..9149eebb3d 100644
--- a/spec/unit/knife/user_create_spec.rb
+++ b/spec/unit/knife/user_create_spec.rb
@@ -22,7 +22,9 @@ require "spec_helper"
 Chef::Knife::UserCreate.load_deps
 
 describe Chef::Knife::UserCreate do
+
   let(:knife) { Chef::Knife::UserCreate.new }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   let(:stderr) do
     StringIO.new
@@ -77,9 +79,6 @@ describe Chef::Knife::UserCreate do
 
     before :each do
       @user = double("Chef::User")
-      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-      allow(@user).to receive(:chef_root_rest_v0).and_return(chef_root_rest_v0)
-      allow(Chef::User).to receive(:new).and_return(@user)
       @key = "You don't come into cooking to get rich - Ramsay"
       allow(@user).to receive(:[]).with("private_key").and_return(@key)
       knife.config[:passwordprompt] = true
@@ -87,7 +86,8 @@ describe Chef::Knife::UserCreate do
     end
 
     it "creates an user" do
-      expect(@user.chef_root_rest_v0).to receive(:post).and_return(@user)
+      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+      expect(root_rest).to receive(:post).and_return(@user)
       expect(knife.ui).to receive(:ask).with("Please enter the user's password: ", echo: false).and_return("password")
       knife.run
     end
@@ -96,21 +96,14 @@ describe Chef::Knife::UserCreate do
   context "when all mandatory fields are validly specified" do
     before do
       @user = double("Chef::User")
-      allow(Chef::User).to receive(:new).and_return(@user)
-      allow(@user).to receive(:chef_root_rest_v0).and_return(chef_root_rest_v0)
       @key = "You don't come into cooking to get rich - Ramsay"
       allow(@user).to receive(:[]).with("private_key").and_return(@key)
       knife.name_args = %w{some_user some_display_name some_first_name some_last_name some_email some_password}
     end
 
-    before(:each) do
-      # reset the user field every run
-      knife.user_field = nil
-    end
-
     it "sets all the mandatory fields" do
-      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-      expect(@user.chef_root_rest_v0).to receive(:post).and_return(@user)
+      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+      expect(root_rest).to receive(:post).and_return(@user)
       knife.run
       expect(knife.user.username).to eq("some_user")
       expect(knife.user.display_name).to eq("some_display_name")
@@ -142,8 +135,8 @@ describe Chef::Knife::UserCreate do
       end
 
       it "does not set user.create_key" do
-        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-        expect(@user.chef_root_rest_v0).to receive(:post).and_return(@user)
+        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+        expect(root_rest).to receive(:post).and_return(@user)
         knife.run
         expect(knife.user.create_key).to be_falsey
       end
@@ -151,8 +144,8 @@ describe Chef::Knife::UserCreate do
 
     context "when --prevent-keygen is not passed" do
       it "sets user.create_key to true" do
-        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-        expect(@user.chef_root_rest_v0).to receive(:post).and_return(@user)
+        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+        expect(root_rest).to receive(:post).and_return(@user)
         knife.run
         expect(knife.user.create_key).to be_truthy
       end
@@ -166,8 +159,8 @@ describe Chef::Knife::UserCreate do
       end
 
       it "sets user.public_key" do
-        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-        expect(@user.chef_root_rest_v0).to receive(:post).and_return(@user)
+        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+        expect(root_rest).to receive(:post).and_return(@user)
         knife.run
         expect(knife.user.public_key).to eq("some_key")
       end
@@ -175,8 +168,8 @@ describe Chef::Knife::UserCreate do
 
     context "when --user-key is not passed" do
       it "does not set user.public_key" do
-        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-        expect(@user.chef_root_rest_v0).to receive(:post).and_return(@user)
+        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+        expect(root_rest).to receive(:post).and_return(@user)
         knife.run
         expect(knife.user.public_key).to be_nil
       end
@@ -187,10 +180,8 @@ describe Chef::Knife::UserCreate do
 
       before :each do
         @user = double("Chef::User")
-        allow(Chef::User).to receive(:new).and_return(@user)
-        allow(@user).to receive(:chef_root_rest_v0).and_return(chef_root_rest_v0)
-        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-        expect(@user.chef_root_rest_v0).to receive(:post).and_return(@user)
+        expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+        expect(root_rest).to receive(:post).and_return(@user)
         @key = "You don't come into cooking to get rich - Ramsay"
         allow(@user).to receive(:[]).with("private_key").and_return(@key)
         knife.name_args = name_args
@@ -213,8 +204,9 @@ describe Chef::Knife::UserCreate do
         }
 
         it "creates an user, associates a user, and adds it to the admins group" do
-          expect(@user.chef_root_rest_v0).to receive(:post).with("organizations/ramsay/association_requests", request_body).and_return(@user)
-          expect(@user.chef_root_rest_v0).to receive(:put).with("users/some_user/association_requests/1", { response: "accept" })
+
+          expect(root_rest).to receive(:post).with("organizations/ramsay/association_requests", request_body).and_return(@user)
+          expect(root_rest).to receive(:put).with("users/some_user/association_requests/1", { response: "accept" })
           knife.run
         end
       end
diff --git a/spec/unit/knife/user_edit_spec.rb b/spec/unit/knife/user_edit_spec.rb
index 54a44890e0..63ff89eee1 100644
--- a/spec/unit/knife/user_edit_spec.rb
+++ b/spec/unit/knife/user_edit_spec.rb
@@ -20,22 +20,27 @@ require "spec_helper"
 
 describe Chef::Knife::UserEdit do
   let(:knife) { Chef::Knife::UserEdit.new }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   before(:each) do
     @stderr = StringIO.new
     @stdout = StringIO.new
-
-    Chef::Knife::UserEdit.load_deps
     allow(knife.ui).to receive(:stderr).and_return(@stderr)
     allow(knife.ui).to receive(:stdout).and_return(@stdout)
-    knife.name_args = [ "my_user" ]
+    knife.name_args = [ "my_user2" ]
     knife.config[:disable_editing] = true
   end
 
   it "loads and edits the user" do
-    data = { "username" => "my_user" }
-    allow(Chef::UserV1).to receive(:load).with("my_user").and_return(data)
-    expect(knife).to receive(:edit_hash).with(data).and_return(data)
+    data = { "username" => "my_user2" }
+    edited_data = { "username" => "edit_user2" }
+    result = {}
+    @key = "You don't come into cooking to get rich - Ramsay"
+    allow(result).to receive(:[]).with("private_key").and_return(@key)
+    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+    expect(root_rest).to receive(:get).with("users/my_user2").and_return(data)
+    expect(knife).to receive(:get_updated_user).with(data).and_return(edited_data)
+    expect(root_rest).to receive(:put).with("users/my_user2", edited_data).and_return(result)
     knife.run
   end
 
diff --git a/spec/unit/knife/user_password_spec.rb b/spec/unit/knife/user_password_spec.rb
index d53abfb34d..d582801780 100644
--- a/spec/unit/knife/user_password_spec.rb
+++ b/spec/unit/knife/user_password_spec.rb
@@ -23,14 +23,14 @@ Chef::Knife::UserDelete.load_deps
 
 describe Chef::Knife::UserPassword do
 
-  let(:chef_root_rest_v0) { double("Chef::ServerAPI") }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   before :each do
     @knife = Chef::Knife::UserPassword.new
     @user_name = "foobar"
     @password = "abc123"
     @user = double("Chef::User")
-    allow(@user).to receive(:chef_root_rest_v0).and_return(chef_root_rest_v0)
+    allow(@user).to receive(:root_rest).and_return(root_rest)
     allow(Chef::User).to receive(:new).and_return(@user)
     @key = "You don't come into cooking to get rich - Ramsay"
   end
@@ -44,9 +44,9 @@ describe Chef::Knife::UserPassword do
       result = { "password" => [], "recovery_authentication_enabled" => true }
       allow(@user).to receive(:[]).with("organization")
 
-      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-      expect(@user.chef_root_rest_v0).to receive(:get).with("users/#{@user_name}").and_return(result)
-      expect(@user.chef_root_rest_v0).to receive(:put).with("users/#{@user_name}", result)
+      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+      expect(@user.root_rest).to receive(:get).with("users/#{@user_name}").and_return(result)
+      expect(@user.root_rest).to receive(:put).with("users/#{@user_name}", result)
       expect(@knife.ui).to receive(:msg).with("Authentication info updated for #{@user_name}.")
 
       @knife.run
diff --git a/spec/unit/knife/user_show_spec.rb b/spec/unit/knife/user_show_spec.rb
index 273cf638ee..31f35b65ef 100644
--- a/spec/unit/knife/user_show_spec.rb
+++ b/spec/unit/knife/user_show_spec.rb
@@ -24,13 +24,13 @@ Chef::Knife::UserShow.load_deps
 describe Chef::Knife::UserShow do
   let(:knife) { Chef::Knife::UserShow.new }
   let(:user_mock) { double("user_mock") }
-  let(:chef_root_rest_v0) { double("Chef::ServerAPI") }
+  let(:root_rest) { double("Chef::ServerAPI") }
 
   before :each do
     @user_name = "foobar"
     @password = "abc123"
     @user = double("Chef::User")
-    allow(@user).to receive(:chef_root_rest_v0).and_return(chef_root_rest_v0)
+    allow(@user).to receive(:root_rest).and_return(root_rest)
     allow(Chef::User).to receive(:new).and_return(@user)
     @key = "You don't come into cooking to get rich - Ramsay"
   end
@@ -42,14 +42,14 @@ describe Chef::Knife::UserShow do
     end
 
     it "should load the user" do
-      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-      expect(@user.chef_root_rest_v0).to receive(:get).with("users/my_user")
+      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+      expect(@user.root_rest).to receive(:get).with("users/my_user")
       knife.run
     end
 
     it "loads and displays the user" do
-      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
-      expect(@user.chef_root_rest_v0).to receive(:get).with("users/my_user")
+      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
+      expect(@user.root_rest).to receive(:get).with("users/my_user")
       expect(knife).to receive(:format_for_display)
       knife.run
     end
@@ -81,10 +81,10 @@ describe Chef::Knife::UserShow do
       result = { "organizations" => [] }
       knife.config[:with_orgs] = true
 
-      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "0" }).and_return(chef_root_rest_v0)
+      expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], { api_version: "2" }).and_return(root_rest)
       allow(@org).to receive(:[]).with("organization").and_return({ "name" => "test" })
-      expect(@user.chef_root_rest_v0).to receive(:get).with("users/#{@user_name}").and_return(result)
-      expect(@user.chef_root_rest_v0).to receive(:get).with("users/#{@user_name}/organizations").and_return(orgs)
+      expect(@user.root_rest).to receive(:get).with("users/#{@user_name}").and_return(result)
+      expect(@user.root_rest).to receive(:get).with("users/#{@user_name}/organizations").and_return(orgs)
       knife.run
     end
   end