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

data/spec/unit/shell/shell_ext_spec.rb

@@ -23,7 +23,7 @@ describe Shell::Extensions do
 
     before do
       @shell_client = TestableShellSession.instance
-      Shell.stub(:session).and_return(@shell_client)
+      allow(Shell).to receive(:session).and_return(@shell_client)
       @job_manager = TestJobManager.new
       @root_context = Object.new
       @root_context.instance_eval(&ObjectTestHarness)
@@ -37,98 +37,98 @@ describe Shell::Extensions do
       irb_context = double("context", :main => target_context_obj)
       irb_session = double("irb session", :context => irb_context)
       @job_manager.jobs = [[:thread, irb_session]]
-      @root_context.stub(:jobs).and_return(@job_manager)
+      allow(@root_context).to receive(:jobs).and_return(@job_manager)
       @root_context.ensure_session_select_defined
-      @root_context.jobs.select_shell_session(target_context_obj).should == irb_session
-      @root_context.jobs.select_shell_session(:idontexist).should be_nil
+      expect(@root_context.jobs.select_shell_session(target_context_obj)).to eq(irb_session)
+      expect(@root_context.jobs.select_shell_session(:idontexist)).to be_nil
     end
 
     it "finds, then switches to a session" do
       @job_manager.jobs = []
-      @root_context.stub(:ensure_session_select_defined)
-      @root_context.stub(:jobs).and_return(@job_manager)
-      @job_manager.should_receive(:select_shell_session).and_return(:the_shell_session)
-      @job_manager.should_receive(:switch).with(:the_shell_session)
+      allow(@root_context).to receive(:ensure_session_select_defined)
+      allow(@root_context).to receive(:jobs).and_return(@job_manager)
+      expect(@job_manager).to receive(:select_shell_session).and_return(:the_shell_session)
+      expect(@job_manager).to receive(:switch).with(:the_shell_session)
       @root_context.find_or_create_session_for(:foo)
     end
 
     it "creates a new session if an existing one isn't found" do
       @job_manager.jobs = []
-      @root_context.stub(:jobs).and_return(@job_manager)
-      @job_manager.stub(:select_shell_session).and_return(nil)
-      @root_context.should_receive(:irb).with(:foo)
+      allow(@root_context).to receive(:jobs).and_return(@job_manager)
+      allow(@job_manager).to receive(:select_shell_session).and_return(nil)
+      expect(@root_context).to receive(:irb).with(:foo)
       @root_context.find_or_create_session_for(:foo)
     end
 
     it "switches to recipe context" do
-      @root_context.should respond_to(:recipe_mode)
+      expect(@root_context).to respond_to(:recipe_mode)
       @shell_client.recipe = :monkeyTime
-      @root_context.should_receive(:find_or_create_session_for).with(:monkeyTime)
+      expect(@root_context).to receive(:find_or_create_session_for).with(:monkeyTime)
       @root_context.recipe_mode
     end
 
     it "switches to attribute context" do
-      @root_context.should respond_to(:attributes_mode)
+      expect(@root_context).to respond_to(:attributes_mode)
       @shell_client.node = "monkeyNodeTime"
-      @root_context.should_receive(:find_or_create_session_for).with("monkeyNodeTime")
+      expect(@root_context).to receive(:find_or_create_session_for).with("monkeyNodeTime")
       @root_context.attributes_mode
     end
 
     it "has a help command" do
-      @root_context.should respond_to(:help)
+      expect(@root_context).to respond_to(:help)
     end
 
     it "turns irb tracing on and off" do
-      @root_context.should respond_to(:trace)
-      @root_context.conf.should_receive(:use_tracer=).with(true)
-      @root_context.stub(:tracing?)
+      expect(@root_context).to respond_to(:trace)
+      expect(@root_context.conf).to receive(:use_tracer=).with(true)
+      allow(@root_context).to receive(:tracing?)
       @root_context.tracing :on
     end
 
     it "says if tracing is on or off" do
-      @root_context.conf.stub(:use_tracer).and_return(true)
-      @root_context.should_receive(:puts).with("tracing is on")
+      allow(@root_context.conf).to receive(:use_tracer).and_return(true)
+      expect(@root_context).to receive(:puts).with("tracing is on")
       @root_context.tracing?
     end
 
     it "prints node attributes" do
       node = double("node", :attribute => {:foo => :bar})
       @shell_client.node = node
-      @root_context.should_receive(:pp).with({:foo => :bar})
+      expect(@root_context).to receive(:pp).with({:foo => :bar})
       @root_context.ohai
-      @root_context.should_receive(:pp).with(:bar)
+      expect(@root_context).to receive(:pp).with(:bar)
       @root_context.ohai(:foo)
     end
 
     it "resets the recipe and reloads ohai data" do
-      @shell_client.should_receive(:reset!)
+      expect(@shell_client).to receive(:reset!)
       @root_context.reset
     end
 
     it "turns irb echo on and off" do
-      @root_context.conf.should_receive(:echo=).with(true)
+      expect(@root_context.conf).to receive(:echo=).with(true)
       @root_context.echo :on
     end
 
     it "says if echo is on or off" do
-      @root_context.conf.stub(:echo).and_return(true)
-      @root_context.should_receive(:puts).with("echo is on")
+      allow(@root_context.conf).to receive(:echo).and_return(true)
+      expect(@root_context).to receive(:puts).with("echo is on")
       @root_context.echo?
     end
 
     it "gives access to the stepable iterator" do
-      Shell::StandAloneSession.instance.stub(:reset!)
-      Shell.session.stub(:rebuild_context)
+      allow(Shell::StandAloneSession.instance).to receive(:reset!)
+      allow(Shell.session).to receive(:rebuild_context)
       events = Chef::EventDispatch::Dispatcher.new
       run_context = Chef::RunContext.new(Chef::Node.new, {}, events)
       run_context.resource_collection.instance_variable_get(:@resource_list).instance_variable_set(:@iterator, :the_iterator)
       Shell.session.run_context = run_context
-      @root_context.chef_run.should == :the_iterator
+      expect(@root_context.chef_run).to eq(:the_iterator)
     end
 
     it "lists directory contents" do
       entries = %w{. .. someFile}
-      Dir.should_receive(:entries).with("/tmp").and_return(entries)
+      expect(Dir).to receive(:entries).with("/tmp").and_return(entries)
       @root_context.ls "/tmp"
     end
 
@@ -145,7 +145,7 @@ describe Shell::Extensions do
 
     it "gives a list of the resources" do
       resource = @recipe_object.file("foo")
-      @recipe_object.should_receive(:pp).with(["file[foo]"])
+      expect(@recipe_object).to receive(:pp).with(["file[foo]"])
       @recipe_object.resources
     end
 

data/spec/unit/shell/shell_session_spec.rb

@@ -42,7 +42,7 @@ end
 describe Shell::ShellSession do
 
   it "is a singleton object" do
-    Shell::ShellSession.should include(Singleton)
+    expect(Shell::ShellSession).to include(Singleton)
   end
 
 end
@@ -66,13 +66,13 @@ describe Shell::ClientSession do
     @session.instance_variable_set(:@client, @client)
     @expansion = Chef::RunList::RunListExpansion.new(@node.chef_environment, [])
 
-    @node.run_list.should_receive(:expand).with(@node.chef_environment).and_return(@expansion)
-    Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url]).and_return(@chef_rest)
+    expect(@node.run_list).to receive(:expand).with(@node.chef_environment).and_return(@expansion)
+    expect(Chef::REST).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(@chef_rest)
     @session.rebuild_context
   end
 
   it "passes the shell CLI args to the client" do
-    Chef::Client.should_receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
+    expect(Chef::Client).to receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
     @session.send(:rebuild_node)
   end
 
@@ -90,30 +90,30 @@ describe Shell::StandAloneSession do
   end
 
   it "has a run_context" do
-    @session.run_context.should equal(@run_context)
+    expect(@session.run_context).to equal(@run_context)
   end
 
   it "returns a collection based on it's standalone recipe file" do
-    @session.resource_collection.should == @recipe.run_context.resource_collection
+    expect(@session.resource_collection).to eq(@recipe.run_context.resource_collection)
   end
 
   it "gives nil for the definitions (for now)" do
-    @session.definitions.should be_nil
+    expect(@session.definitions).to be_nil
   end
 
   it "gives nil for the cookbook_loader" do
-    @session.cookbook_loader.should be_nil
+    expect(@session.cookbook_loader).to be_nil
   end
 
   it "runs chef with the standalone recipe" do
-    @session.stub(:node_built?).and_return(true)
-    Chef::Log.stub(:level)
+    allow(@session).to receive(:node_built?).and_return(true)
+    allow(Chef::Log).to receive(:level)
     chef_runner = double("Chef::Runner.new", :converge => :converged)
     # pre-heat resource collection cache
     @session.resource_collection
 
-    Chef::Runner.should_receive(:new).with(@session.recipe.run_context).and_return(chef_runner)
-    @recipe.run_chef.should == :converged
+    expect(Chef::Runner).to receive(:new).with(@session.recipe.run_context).and_return(chef_runner)
+    expect(@recipe.run_chef).to eq(:converged)
   end
 
   it "passes the shell CLI args to the client" do
@@ -123,7 +123,7 @@ describe Shell::StandAloneSession do
                      :build_node => true,
                      :register => true,
                      :sync_cookbooks => {})
-    Chef::Client.should_receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
+    expect(Chef::Client).to receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
     @session.send(:rebuild_node)
   end
 
@@ -147,39 +147,39 @@ describe Shell::SoloSession do
   end
 
   it "returns a collection based on it's compilation object and the extra recipe provided by chef-shell" do
-    @session.stub(:node_built?).and_return(true)
+    allow(@session).to receive(:node_built?).and_return(true)
     kitteh = Chef::Resource::Cat.new("keyboard")
     @recipe.run_context.resource_collection << kitteh
-    @session.resource_collection.should include(kitteh)
+    expect(@session.resource_collection).to include(kitteh)
   end
 
   it "returns definitions from its compilation object" do
-    @session.definitions.should == @run_context.definitions
+    expect(@session.definitions).to eq(@run_context.definitions)
   end
 
   it "keeps json attribs and passes them to the node for consumption" do
     @session.node_attributes = {"besnard_lakes" => "are_the_dark_horse"}
-    @session.node.besnard_lakes.should == "are_the_dark_horse"
+    expect(@session.node.besnard_lakes).to eq("are_the_dark_horse")
     #pending "1) keep attribs in an ivar 2) pass them to the node 3) feed them to the node on reset"
   end
 
   it "generates its resource collection from the compiled cookbooks and the ad hoc recipe" do
-    @session.stub(:node_built?).and_return(true)
+    allow(@session).to receive(:node_built?).and_return(true)
     kitteh_cat = Chef::Resource::Cat.new("kitteh")
     @run_context.resource_collection << kitteh_cat
     keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @recipe.run_context.resource_collection << keyboard_cat
     #@session.rebuild_collection
-    @session.resource_collection.should include(kitteh_cat, keyboard_cat)
+    expect(@session.resource_collection).to include(kitteh_cat, keyboard_cat)
   end
 
   it "runs chef with a resource collection from the compiled cookbooks" do
-    @session.stub(:node_built?).and_return(true)
-    Chef::Log.stub(:level)
+    allow(@session).to receive(:node_built?).and_return(true)
+    allow(Chef::Log).to receive(:level)
     chef_runner = double("Chef::Runner.new", :converge => :converged)
-    Chef::Runner.should_receive(:new).with(an_instance_of(Chef::RunContext)).and_return(chef_runner)
+    expect(Chef::Runner).to receive(:new).with(an_instance_of(Chef::RunContext)).and_return(chef_runner)
 
-    @recipe.run_chef.should == :converged
+    expect(@recipe.run_chef).to eq(:converged)
   end
 
   it "passes the shell CLI args to the client" do
@@ -189,7 +189,7 @@ describe Shell::SoloSession do
                      :build_node => true,
                      :register => true,
                      :sync_cookbooks => {})
-    Chef::Client.should_receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
+    expect(Chef::Client).to receive(:new).with(nil, Chef::Config[:shell_config]).and_return(@client)
     @session.send(:rebuild_node)
   end
 

data/spec/unit/shell_out_spec.rb

@@ -2,8 +2,8 @@ require File.expand_path('../../spec_helper', __FILE__)
 
 describe "Chef::ShellOut deprecation notices" do
   it "logs a warning when initializing a new Chef::ShellOut object" do
-    Chef::Log.should_receive(:warn).with("Chef::ShellOut is deprecated, please use Mixlib::ShellOut")
-    Chef::Log.should_receive(:warn).with(/Called from\:/)
+    expect(Chef::Log).to receive(:warn).with("Chef::ShellOut is deprecated, please use Mixlib::ShellOut")
+    expect(Chef::Log).to receive(:warn).with(/Called from\:/)
     Chef::ShellOut.new("pwd")
   end
 end
@@ -11,8 +11,8 @@ end
 describe "Chef::Exceptions::ShellCommandFailed deprecation notices" do
 
   it "logs a warning when referencing the constant Chef::Exceptions::ShellCommandFailed" do
-    Chef::Log.should_receive(:warn).with("Chef::Exceptions::ShellCommandFailed is deprecated, use Mixlib::ShellOut::ShellCommandFailed")
-    Chef::Log.should_receive(:warn).with(/Called from\:/)
+    expect(Chef::Log).to receive(:warn).with("Chef::Exceptions::ShellCommandFailed is deprecated, use Mixlib::ShellOut::ShellCommandFailed")
+    expect(Chef::Log).to receive(:warn).with(/Called from\:/)
     Chef::Exceptions::ShellCommandFailed
   end
 end

data/spec/unit/shell_spec.rb

@@ -42,13 +42,13 @@ describe Shell do
 
   before do
     Shell.irb_conf = {}
-    Shell::ShellSession.instance.stub(:reset!)
+    allow(Shell::ShellSession.instance).to receive(:reset!)
   end
 
   describe "reporting its status" do
 
-    it "alway says it is running" do
-      Shell.should be_running
+    it "always says it is running" do
+      expect(Shell).to be_running
     end
 
   end
@@ -56,8 +56,8 @@ describe Shell do
   describe "configuring IRB" do
     it "configures irb history" do
       Shell.configure_irb
-      Shell.irb_conf[:HISTORY_FILE].should == "~/.chef/chef_shell_history"
-      Shell.irb_conf[:SAVE_HISTORY].should == 1000
+      expect(Shell.irb_conf[:HISTORY_FILE]).to eq("~/.chef/chef_shell_history")
+      expect(Shell.irb_conf[:SAVE_HISTORY]).to eq(1000)
     end
 
     it "has a prompt like ``chef > '' in the default context" do
@@ -67,12 +67,12 @@ describe Shell do
       conf.main = Object.new
       conf.main.instance_eval(&ObjectTestHarness)
       Shell.irb_conf[:IRB_RC].call(conf)
-      conf.prompt_c.should      == "chef > "
-      conf.return_format.should == " => %s \n"
-      conf.prompt_i.should      == "chef > "
-      conf.prompt_n.should      == "chef ?> "
-      conf.prompt_s.should      == "chef%l> "
-      conf.use_tracer.should    == false
+      expect(conf.prompt_c).to      eq("chef > ")
+      expect(conf.return_format).to eq(" => %s \n")
+      expect(conf.prompt_i).to      eq("chef > ")
+      expect(conf.prompt_n).to      eq("chef ?> ")
+      expect(conf.prompt_s).to      eq("chef%l> ")
+      expect(conf.use_tracer).to    eq(false)
     end
 
     it "has a prompt like ``chef:recipe > '' in recipe context" do
@@ -82,10 +82,10 @@ describe Shell do
       events = Chef::EventDispatch::Dispatcher.new
       conf.main = Chef::Recipe.new(nil,nil,Chef::RunContext.new(Chef::Node.new, {}, events))
       Shell.irb_conf[:IRB_RC].call(conf)
-      conf.prompt_c.should      == "chef:recipe > "
-      conf.prompt_i.should      == "chef:recipe > "
-      conf.prompt_n.should      == "chef:recipe ?> "
-      conf.prompt_s.should      == "chef:recipe%l> "
+      expect(conf.prompt_c).to      eq("chef:recipe > ")
+      expect(conf.prompt_i).to      eq("chef:recipe > ")
+      expect(conf.prompt_n).to      eq("chef:recipe ?> ")
+      expect(conf.prompt_s).to      eq("chef:recipe%l> ")
     end
 
     it "has a prompt like ``chef:attributes > '' in attributes/node context" do
@@ -94,10 +94,10 @@ describe Shell do
       conf = OpenStruct.new
       conf.main = Chef::Node.new
       Shell.irb_conf[:IRB_RC].call(conf)
-      conf.prompt_c.should      == "chef:attributes > "
-      conf.prompt_i.should      == "chef:attributes > "
-      conf.prompt_n.should      == "chef:attributes ?> "
-      conf.prompt_s.should      == "chef:attributes%l> "
+      expect(conf.prompt_c).to      eq("chef:attributes > ")
+      expect(conf.prompt_i).to      eq("chef:attributes > ")
+      expect(conf.prompt_n).to      eq("chef:attributes ?> ")
+      expect(conf.prompt_s).to      eq("chef:attributes%l> ")
     end
 
   end
@@ -110,7 +110,7 @@ describe Shell do
     end
 
     it "creates help text for methods with descriptions" do
-      @chef_object.help_descriptions.should == [Shell::Extensions::Help.new("rspec_method", "rspecin'", nil)]
+      expect(@chef_object.help_descriptions).to eq([Shell::Extensions::Help.new("rspec_method", "rspecin'", nil)])
     end
 
     it "adds help text when a new method is described then defined" do
@@ -120,8 +120,8 @@ describe Shell do
         end
       EVAL
       @chef_object.instance_eval describe_define
-      @chef_object.help_descriptions.should == [Shell::Extensions::Help.new("rspec_method", "rspecin'"),
-                                                Shell::Extensions::Help.new("baz", "foo2the Bar")]
+      expect(@chef_object.help_descriptions).to eq([Shell::Extensions::Help.new("rspec_method", "rspecin'"),
+                                                Shell::Extensions::Help.new("baz", "foo2the Bar")])
     end
 
     it "adds help text for subcommands" do
@@ -133,7 +133,7 @@ describe Shell do
       @chef_object.instance_eval describe_define
       expected_help_text_fragments = [Shell::Extensions::Help.new("rspec_method", "rspecin'")]
       expected_help_text_fragments << Shell::Extensions::Help.new("baz.baz_obj_command", "something you can do with baz.baz_obj_command")
-      @chef_object.help_descriptions.should == expected_help_text_fragments
+      expect(@chef_object.help_descriptions).to eq(expected_help_text_fragments)
     end
 
     it "doesn't add previous subcommand help to commands defined afterward" do
@@ -147,13 +147,13 @@ describe Shell do
 
       EVAL
       @chef_object.instance_eval describe_define
-      @chef_object.help_descriptions.should have(2).descriptions
-      @chef_object.help_descriptions.select {|h| h.cmd == "super_monkey_time" }.should be_empty
+      expect(@chef_object.help_descriptions.size).to eq(2)
+      expect(@chef_object.help_descriptions.select {|h| h.cmd == "super_monkey_time" }).to be_empty
     end
 
     it "creates a help banner with the command descriptions" do
-      @chef_object.help_banner.should match(/^\|\ Command[\s]+\|\ Description[\s]*$/)
-      @chef_object.help_banner.should match(/^\|\ rspec_method[\s]+\|\ rspecin\'[\s]*$/)
+      expect(@chef_object.help_banner).to match(/^\|\ Command[\s]+\|\ Description[\s]*$/)
+      expect(@chef_object.help_banner).to match(/^\|\ rspec_method[\s]+\|\ rspecin\'[\s]*$/)
     end
   end
 

data/spec/unit/user_spec.rb

@@ -28,89 +28,89 @@ describe Chef::User do
 
   describe "initialize" do
     it "should be a Chef::User" do
-      @user.should be_a_kind_of(Chef::User)
+      expect(@user).to be_a_kind_of(Chef::User)
     end
   end
 
   describe "name" do
     it "should let you set the name to a string" do
-      @user.name("ops_master").should == "ops_master"
+      expect(@user.name("ops_master")).to eq("ops_master")
     end
 
     it "should return the current name" do
       @user.name "ops_master"
-      @user.name.should == "ops_master"
+      expect(@user.name).to eq("ops_master")
     end
 
     # It is not feasible to check all invalid characters.  Here are a few
     # that we probably care about.
     it "should not accept invalid characters" do
       # capital letters
-      lambda { @user.name "Bar" }.should raise_error(ArgumentError)
+      expect { @user.name "Bar" }.to raise_error(ArgumentError)
       # slashes
-      lambda { @user.name "foo/bar" }.should raise_error(ArgumentError)
+      expect { @user.name "foo/bar" }.to raise_error(ArgumentError)
       # ?
-      lambda { @user.name "foo?" }.should raise_error(ArgumentError)
+      expect { @user.name "foo?" }.to raise_error(ArgumentError)
       # &
-      lambda { @user.name "foo&" }.should raise_error(ArgumentError)
+      expect { @user.name "foo&" }.to raise_error(ArgumentError)
     end
 
 
     it "should not accept spaces" do
-      lambda { @user.name "ops master" }.should raise_error(ArgumentError)
+      expect { @user.name "ops master" }.to raise_error(ArgumentError)
     end
 
     it "should throw an ArgumentError if you feed it anything but a string" do
-      lambda { @user.name Hash.new }.should raise_error(ArgumentError)
+      expect { @user.name Hash.new }.to raise_error(ArgumentError)
     end
   end
 
   describe "admin" do
     it "should let you set the admin bit" do
-      @user.admin(true).should == true
+      expect(@user.admin(true)).to eq(true)
     end
 
     it "should return the current admin value" do
       @user.admin true
-      @user.admin.should == true
+      expect(@user.admin).to eq(true)
     end
 
     it "should default to false" do
-      @user.admin.should == false
+      expect(@user.admin).to eq(false)
     end
 
     it "should throw an ArgumentError if you feed it anything but true or false" do
-      lambda { @user.name Hash.new }.should raise_error(ArgumentError)
+      expect { @user.name Hash.new }.to raise_error(ArgumentError)
     end
   end
 
   describe "public_key" do
     it "should let you set the public key" do
-      @user.public_key("super public").should == "super public"
+      expect(@user.public_key("super public")).to eq("super public")
     end
 
     it "should return the current public key" do
       @user.public_key("super public")
-      @user.public_key.should == "super public"
+      expect(@user.public_key).to eq("super public")
     end
 
     it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @user.public_key Hash.new }.should raise_error(ArgumentError)
+      expect { @user.public_key Hash.new }.to raise_error(ArgumentError)
     end
   end
 
   describe "private_key" do
     it "should let you set the private key" do
-      @user.private_key("super private").should == "super private"
+      expect(@user.private_key("super private")).to eq("super private")
     end
 
     it "should return the private key" do
       @user.private_key("super private")
-      @user.private_key.should == "super private"
+      expect(@user.private_key).to eq("super private")
     end
 
     it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @user.private_key Hash.new }.should raise_error(ArgumentError)
+      expect { @user.private_key Hash.new }.to raise_error(ArgumentError)
     end
   end
 
@@ -122,37 +122,37 @@ describe Chef::User do
     end
 
     it "serializes as a JSON object" do
-      @json.should match(/^\{.+\}$/)
+      expect(@json).to match(/^\{.+\}$/)
     end
 
     it "includes the name value" do
-      @json.should include(%q{"name":"black"})
+      expect(@json).to include(%q{"name":"black"})
     end
 
     it "includes the public key value" do
-      @json.should include(%{"public_key":"crowes"})
+      expect(@json).to include(%{"public_key":"crowes"})
     end
 
     it "includes the 'admin' flag" do
-      @json.should include(%q{"admin":false})
+      expect(@json).to include(%q{"admin":false})
     end
 
     it "includes the private key when present" do
       @user.private_key("monkeypants")
-      @user.to_json.should include(%q{"private_key":"monkeypants"})
+      expect(@user.to_json).to include(%q{"private_key":"monkeypants"})
     end
 
     it "does not include the private key if not present" do
-      @json.should_not include("private_key")
+      expect(@json).not_to include("private_key")
     end
 
     it "includes the password if present" do
       @user.password "password"
-      @user.to_json.should include(%q{"password":"password"})
+      expect(@user.to_json).to include(%q{"password":"password"})
     end
 
     it "does not include the password if not present" do
-      @json.should_not include("password")
+      expect(@json).not_to include("password")
     end
 
     include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
@@ -171,27 +171,27 @@ describe Chef::User do
     end
 
     it "should deserialize to a Chef::User object" do
-      @user.should be_a_kind_of(Chef::User)
+      expect(@user).to be_a_kind_of(Chef::User)
     end
 
     it "preserves the name" do
-      @user.name.should == "mr_spinks"
+      expect(@user.name).to eq("mr_spinks")
     end
 
     it "preserves the public key" do
-      @user.public_key.should == "turtles"
+      expect(@user.public_key).to eq("turtles")
     end
 
     it "preserves the admin status" do
-      @user.admin.should be_true
+      expect(@user.admin).to be_truthy
     end
 
     it "includes the private key if present" do
-      @user.private_key.should == "pandas"
+      expect(@user.private_key).to eq("pandas")
     end
 
     it "includes the password if present" do
-      @user.password.should == "password"
+      expect(@user.password).to eq("password")
     end
 
   end
@@ -201,7 +201,7 @@ describe Chef::User do
       @user = Chef::User.new
       @user.name "foobar"
       @http_client = double("Chef::REST mock")
-      Chef::REST.stub(:new).and_return(@http_client)
+      allow(Chef::REST).to receive(:new).and_return(@http_client)
     end
 
     describe "list" do
@@ -209,61 +209,61 @@ describe Chef::User do
         Chef::Config[:chef_server_url] = "http://www.example.com"
         @osc_response = { "admin" => "http://www.example.com/users/admin"}
         @ohc_response = [ { "user" => { "username" => "admin" }} ]
-        Chef::User.stub(:load).with("admin").and_return(@user)
+        allow(Chef::User).to receive(:load).with("admin").and_return(@user)
         @osc_inflated_response = { "admin" => @user }
       end
 
       it "lists all clients on an OSC server" do
-        @http_client.stub(:get_rest).with("users").and_return(@osc_response)
-        Chef::User.list.should == @osc_response
+        allow(@http_client).to receive(:get_rest).with("users").and_return(@osc_response)
+        expect(Chef::User.list).to eq(@osc_response)
       end
 
       it "inflate all clients on an OSC server" do
-        @http_client.stub(:get_rest).with("users").and_return(@osc_response)
-        Chef::User.list(true).should == @osc_inflated_response
+        allow(@http_client).to receive(:get_rest).with("users").and_return(@osc_response)
+        expect(Chef::User.list(true)).to eq(@osc_inflated_response)
       end
 
       it "lists all clients on an OHC/OPC server" do
-        @http_client.stub(:get_rest).with("users").and_return(@ohc_response)
+        allow(@http_client).to receive(:get_rest).with("users").and_return(@ohc_response)
         # We expect that Chef::User.list will give a consistent response
         # so OHC API responses should be transformed to OSC-style output.
-        Chef::User.list.should == @osc_response
+        expect(Chef::User.list).to eq(@osc_response)
       end
 
       it "inflate all clients on an OHC/OPC server" do
-        @http_client.stub(:get_rest).with("users").and_return(@ohc_response)
-        Chef::User.list(true).should == @osc_inflated_response
+        allow(@http_client).to receive(:get_rest).with("users").and_return(@ohc_response)
+        expect(Chef::User.list(true)).to eq(@osc_inflated_response)
       end
     end
 
     describe "create" do
       it "creates a new user via the API" do
         @user.password "password"
-        @http_client.should_receive(:post_rest).with("users", {:name => "foobar", :admin => false, :password => "password"}).and_return({})
+        expect(@http_client).to receive(:post_rest).with("users", {:name => "foobar", :admin => false, :password => "password"}).and_return({})
         @user.create
       end
     end
 
     describe "read" do
       it "loads a named user from the API" do
-        @http_client.should_receive(:get_rest).with("users/foobar").and_return({"name" => "foobar", "admin" => true, "public_key" => "pubkey"})
+        expect(@http_client).to receive(:get_rest).with("users/foobar").and_return({"name" => "foobar", "admin" => true, "public_key" => "pubkey"})
         user = Chef::User.load("foobar")
-        user.name.should == "foobar"
-        user.admin.should == true
-        user.public_key.should == "pubkey"
+        expect(user.name).to eq("foobar")
+        expect(user.admin).to eq(true)
+        expect(user.public_key).to eq("pubkey")
       end
     end
 
     describe "update" do
       it "updates an existing user on via the API" do
-        @http_client.should_receive(:put_rest).with("users/foobar", {:name => "foobar", :admin => false}).and_return({})
+        expect(@http_client).to receive(:put_rest).with("users/foobar", {:name => "foobar", :admin => false}).and_return({})
         @user.update
       end
     end
 
     describe "destroy" do
       it "deletes the specified user via the API" do
-        @http_client.should_receive(:delete_rest).with("users/foobar")
+        expect(@http_client).to receive(:delete_rest).with("users/foobar")
         @user.destroy
       end
     end