chef 12.0.3 → 12.1.0.rc.0

data/spec/functional/resource/windows_service_spec.rb

@@ -0,0 +1,98 @@
+#
+# Author:: Chris Doherty (<cdoherty@chef.io>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Resource::WindowsService, :windows_only, :system_windows_service_gem_only do
+
+  include_context "using Win32::Service"
+
+  let(:username) { "service_spec_user"}
+  let(:qualified_username) { ".\\#{username}"}
+  let(:password) { "1a2b3c4X!&narf"}
+
+  let(:user_resource) {
+    r = Chef::Resource::User.new(username, run_context)
+    r.username(username)
+    r.password(password)
+    r.comment("temp spec user")
+    r
+  }
+
+  let(:global_service_file_path) {
+    "#{ENV['WINDIR']}\\temp\\#{File.basename(test_service[:service_file_path])}"
+  }
+
+  let(:service_params) {
+
+    id = "#{$$}_#{rand(1000)}"
+
+    test_service.merge( {
+      run_as_user: qualified_username,
+      run_as_password: password,
+      service_name: "spec_service_#{id}",
+      service_display_name: "windows_service spec #{id}}",
+      service_description: "Test service for running the windows_service functional spec.",
+      service_file_path: global_service_file_path,
+      } )
+  }
+
+  let(:manager) {
+    Chef::Application::WindowsServiceManager.new(service_params)
+  }
+
+  let(:service_resource) {
+    r = Chef::Resource::WindowsService.new(service_params[:service_name], run_context)
+    [:run_as_user, :run_as_password].each { |prop| r.send(prop, service_params[prop]) }
+    r
+  }
+
+  before {
+    user_resource.run_action(:create)
+
+    # the service executable has to be outside the current user's home
+    # directory in order for the logon user to execute it.
+    FileUtils::copy_file(test_service[:service_file_path], global_service_file_path)
+
+    # if you don't make the file executable by the service user, you'll get
+    # the not-very-helpful "service did not respond fast enough" error.
+
+    # #mode may break in a post-Windows 8.1 release, and have to be replaced
+    # with the rights stuff in the file resource.
+    file = Chef::Resource::File.new(global_service_file_path, run_context)
+    file.mode("0777")
+
+    file.run_action(:create)
+
+    manager.run(%w{--action install})
+  }
+
+  after {
+    user_resource.run_action(:remove)
+    manager.run(%w{--action uninstall})
+    File.delete(global_service_file_path)
+  }
+
+  describe "logon as a service" do
+    it "successfully runs a service as another user" do
+      service_resource.run_action(:start)
+    end
+
+    it "raises an exception when it can't grant the logon privilege"
+  end
+end

data/spec/functional/run_lock_spec.rb

@@ -163,13 +163,13 @@ describe Chef::RunLock do
     let!(:run_lock) { Chef::RunLock.new(lockfile) }
 
     it "creates the full path to the lockfile" do
-      lambda { run_lock.acquire }.should_not raise_error
-      File.should exist(lockfile)
+      expect { run_lock.acquire }.not_to raise_error
+      expect(File).to exist(lockfile)
     end
 
     it "sets FD_CLOEXEC on the lockfile", :supports_cloexec => true do
       run_lock.acquire
-      (run_lock.runlock.fcntl(Fcntl::F_GETFD, 0) & Fcntl::FD_CLOEXEC).should == Fcntl::FD_CLOEXEC
+      expect(run_lock.runlock.fcntl(Fcntl::F_GETFD, 0) & Fcntl::FD_CLOEXEC).to eq(Fcntl::FD_CLOEXEC)
     end
 
     it "allows only one chef client run per lockfile" do
@@ -208,7 +208,7 @@ p1 has lock
 p1 releasing lock
 p2 has lock
 E
-      results.should == expected
+      expect(results).to eq(expected)
     end
 
     it "clears the lock if the process dies unexpectedly" do
@@ -233,12 +233,12 @@ E
 
       Process.waitpid2(p2)
 
-      results.should =~ /p2 has lock\Z/
+      expect(results).to match(/p2 has lock\Z/)
     end
 
     it "test returns true and acquires the lock" do
       p1 = fork do
-        run_lock.test.should == true
+        expect(run_lock.test).to eq(true)
         sleep 2
         exit! 1
       end
@@ -246,7 +246,7 @@ E
       wait_on_lock
 
       p2 = fork do
-        run_lock.test.should == false
+        expect(run_lock.test).to eq(false)
         exit! 0
       end
 
@@ -263,7 +263,7 @@ E
 
       wait_on_lock
 
-      run_lock.test.should == false
+      expect(run_lock.test).to eq(false)
       Process.waitpid2(p1)
     end
 
@@ -277,7 +277,7 @@ E
 
       wait_on_lock
       sleep 0.5 # Possible race condition on Solaris which pid is observed as 0
-      File.read(lockfile).should == p1.to_s
+      expect(File.read(lockfile)).to eq(p1.to_s)
 
       Process.waitpid2(p1)
     end

data/spec/functional/shell_spec.rb

@@ -105,7 +105,7 @@ describe Shell do
 
     it "boots correctly with -lauto" do
       output, exitstatus = run_chef_shell_with("-lauto")
-      output.should include("done")
+      expect(output).to include("done")
       expect(exitstatus).to eq(0)
     end
 
@@ -115,7 +115,7 @@ describe Shell do
         keyboard.puts(show_log_level_code)
         read_until(out, show_log_level_code)
       end
-      output.should include("===fatal===")
+      expect(output).to include("===fatal===")
       expect(exitstatus).to eq(0)
     end
 
@@ -125,7 +125,7 @@ describe Shell do
         keyboard.puts(show_recipes_code)
         read_until(out, show_recipes_code)
       end
-      output.should include(%q{["override::foo", "override::bar"]})
+      expect(output).to include(%q{["override::foo", "override::bar"]})
       expect(exitstatus).to eq(0)
     end
   end

data/spec/functional/tiny_server_spec.rb

@@ -26,39 +26,39 @@ describe TinyServer::API do
   end
 
   it "is a Singleton" do
-    lambda {TinyServer::API.new}.should raise_error
+    expect {TinyServer::API.new}.to raise_error
   end
 
   it "clears the router" do
     @api.get('/blargh', 200, "blargh")
     @api.clear
-    @api.routes["GET"].should be_empty
+    expect(@api.routes["GET"]).to be_empty
   end
 
   it "creates a route for a GET request" do
     @api.get('/foo/bar', 200, 'hello foobar')
     # WEBrick gives you the full URI with host, Thin only gave the part after scheme+host+port
     response = @api.call("REQUEST_METHOD" => "GET", "REQUEST_URI" => 'http://localhost:1974/foo/bar')
-    response.should == [200, {'Content-Type' => 'application/json'}, [ 'hello foobar' ]]
+    expect(response).to eq([200, {'Content-Type' => 'application/json'}, [ 'hello foobar' ]])
   end
 
   it "creates a route for a request with a block" do
     block_called = false
     @api.get('/bar/baz', 200) { block_called = true; 'hello barbaz' }
     response = @api.call("REQUEST_METHOD" => "GET", "REQUEST_URI" => 'http://localhost:1974/bar/baz')
-    response.should == [200, {'Content-Type' => 'application/json'}, [ 'hello barbaz' ]]
-    block_called.should be_true
+    expect(response).to eq([200, {'Content-Type' => 'application/json'}, [ 'hello barbaz' ]])
+    expect(block_called).to be_truthy
   end
 
   it "returns debugging info for 404s" do
     response = @api.call("REQUEST_METHOD" => "GET", "REQUEST_URI" => '/no_such_thing')
-    response[0].should == 404
-    response[1].should == {'Content-Type' => 'application/json'}
-    response[2].should be_a_kind_of(Array)
+    expect(response[0]).to eq(404)
+    expect(response[1]).to eq({'Content-Type' => 'application/json'})
+    expect(response[2]).to be_a_kind_of(Array)
     response_obj = Chef::JSONCompat.from_json(response[2].first)
-    response_obj["message"].should == "no data matches the request for /no_such_thing"
-    response_obj["available_routes"].should == {"GET"=>[], "PUT"=>[], "POST"=>[], "DELETE"=>[]}
-    response_obj["request"].should == {"REQUEST_METHOD"=>"GET", "REQUEST_URI"=>"/no_such_thing"}
+    expect(response_obj["message"]).to eq("no data matches the request for /no_such_thing")
+    expect(response_obj["available_routes"]).to eq({"GET"=>[], "PUT"=>[], "POST"=>[], "DELETE"=>[]})
+    expect(response_obj["request"]).to eq({"REQUEST_METHOD"=>"GET", "REQUEST_URI"=>"/no_such_thing"})
   end
 
 end
@@ -71,7 +71,7 @@ describe TinyServer::Manager do
     TinyServer::API.instance.get("/index", 200, "[\"hello\"]")
 
     rest = Chef::REST.new('http://localhost:9000', false, false)
-    rest.get_rest("index").should == ["hello"]
+    expect(rest.get_rest("index")).to eq(["hello"])
 
     @server.stop
   end

data/spec/functional/util/path_helper_spec.rb

@@ -31,7 +31,7 @@ describe Chef::Util::PathHelper, "escape_glob" do
       end
 
       pattern = File.join(PathHelper.escape_glob(dir), "*")
-      Dir.glob(pattern).map { |x| File.basename(x) }.should match_array(files)
+      expect(Dir.glob(pattern).map { |x| File.basename(x) }).to match_array(files)
     end
   end
 end

data/spec/functional/version_spec.rb

@@ -28,7 +28,7 @@ describe "Chef Versions" do
 
   binaries.each do |binary|
     it "#{binary} version should be sane" do
-      shell_out!("ruby #{File.join("bin", binary)} -v", :cwd => chef_dir).stdout.chomp.should == "Chef: #{Chef::VERSION}"
+      expect(shell_out!("ruby #{File.join("bin", binary)} -v", :cwd => chef_dir).stdout.chomp).to include("Chef: #{Chef::VERSION}")
     end
   end
 

data/spec/functional/win32/registry_helper_spec.rb

@@ -34,7 +34,7 @@ describe Chef::Resource::RegistryKey, :unix_only do
     it "throws an exception because you don't have a windows registry (derp)" do
       @resource.key("HKCU\\Software\\Opscode")
       @resource.values([{:name=>"Color", :type=>:string, :data=>"Orange"}])
-      lambda{@resource.run_action(:create)}.should raise_error(Chef::Exceptions::Win32NotWindows)
+      expect{@resource.run_action(:create)}.to raise_error(Chef::Exceptions::Win32NotWindows)
     end
   end
 end
@@ -84,197 +84,197 @@ describe 'Chef::Win32::Registry', :windows_only do
 
   describe "hive_exists?" do
     it "returns true if the hive exists" do
-      @registry.hive_exists?("HKCU\\Software\\Root").should == true
+      expect(@registry.hive_exists?("HKCU\\Software\\Root")).to eq(true)
     end
 
     it "returns false if the hive does not exist" do
-      hive = @registry.hive_exists?("LYRU\\Software\\Root").should == false
+      hive = expect(@registry.hive_exists?("LYRU\\Software\\Root")).to eq(false)
     end
   end
 
   describe "key_exists?" do
     it "returns true if the key path exists" do
-      @registry.key_exists?("HKCU\\Software\\Root\\Branch\\Flower").should == true
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Branch\\Flower")).to eq(true)
     end
 
     it "returns false if the key path does not exist" do
-      @registry.key_exists?("HKCU\\Software\\Branch\\Flower").should == false
+      expect(@registry.key_exists?("HKCU\\Software\\Branch\\Flower")).to eq(false)
     end
 
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.key_exists?("JKLM\\Software\\Branch\\Flower")}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.key_exists?("JKLM\\Software\\Branch\\Flower")}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
   end
 
   describe "key_exists!" do
     it "returns true if the key path exists" do
-      @registry.key_exists!("HKCU\\Software\\Root\\Branch\\Flower").should == true
+      expect(@registry.key_exists!("HKCU\\Software\\Root\\Branch\\Flower")).to eq(true)
     end
 
     it "throws an exception if the key path does not exist" do
-      lambda {@registry.key_exists!("HKCU\\Software\\Branch\\Flower")}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.key_exists!("HKCU\\Software\\Branch\\Flower")}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
 
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.key_exists!("JKLM\\Software\\Branch\\Flower")}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.key_exists!("JKLM\\Software\\Branch\\Flower")}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
   end
 
   describe "value_exists?" do
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.value_exists?("JKLM\\Software\\Branch\\Flower", {:name=>"Petals"})}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.value_exists?("JKLM\\Software\\Branch\\Flower", {:name=>"Petals"})}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
     it "throws an exception if the key does not exist" do
-      lambda {@registry.value_exists?("HKCU\\Software\\Branch\\Flower", {:name=>"Petals"})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.value_exists?("HKCU\\Software\\Branch\\Flower", {:name=>"Petals"})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
     it "returns true if the value exists" do
-      @registry.value_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals"}).should == true
+      expect(@registry.value_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals"})).to eq(true)
     end
     it "returns false if the value does not exist" do
-      @registry.value_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"FOOBAR"}).should == false
+      expect(@registry.value_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"FOOBAR"})).to eq(false)
     end
   end
 
   describe "value_exists!" do
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.value_exists!("JKLM\\Software\\Branch\\Flower", {:name=>"Petals"})}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.value_exists!("JKLM\\Software\\Branch\\Flower", {:name=>"Petals"})}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
     it "throws an exception if the key does not exist" do
-      lambda {@registry.value_exists!("HKCU\\Software\\Branch\\Flower", {:name=>"Petals"})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.value_exists!("HKCU\\Software\\Branch\\Flower", {:name=>"Petals"})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
     it "returns true if the value exists" do
-      @registry.value_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals"}).should == true
+      expect(@registry.value_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals"})).to eq(true)
     end
     it "throws an exception if the value does not exist" do
-      lambda {@registry.value_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"FOOBAR"})}.should raise_error(Chef::Exceptions::Win32RegValueMissing)
+      expect {@registry.value_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"FOOBAR"})}.to raise_error(Chef::Exceptions::Win32RegValueMissing)
     end
   end
 
   describe "data_exists?" do
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.data_exists?("JKLM\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.data_exists?("JKLM\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
     it "throws an exception if the key does not exist" do
-      lambda {@registry.data_exists?("HKCU\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.data_exists?("HKCU\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
     it "returns true if all the data matches" do
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]}).should == true
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})).to eq(true)
     end
     it "returns false if the name does not exist" do
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"slateP", :type=>:multi_string, :data=>["Pink", "Delicate"]}).should == false
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"slateP", :type=>:multi_string, :data=>["Pink", "Delicate"]})).to eq(false)
     end
     it "returns false if the types do not match" do
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Pink"}).should == false
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Pink"})).to eq(false)
     end
     it "returns false if the data does not match" do
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Mauve", "Delicate"]}).should == false
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Mauve", "Delicate"]})).to eq(false)
     end
   end
 
   describe "data_exists!" do
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.data_exists!("JKLM\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.data_exists!("JKLM\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
     it "throws an exception if the key does not exist" do
-      lambda {@registry.data_exists!("HKCU\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.data_exists!("HKCU\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
     it "returns true if all the data matches" do
-      @registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]}).should == true
+      expect(@registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Pink", "Delicate"]})).to eq(true)
     end
     it "throws an exception if the name does not exist" do
-      lambda {@registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"slateP", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.should raise_error(Chef::Exceptions::Win32RegDataMissing)
+      expect {@registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"slateP", :type=>:multi_string, :data=>["Pink", "Delicate"]})}.to raise_error(Chef::Exceptions::Win32RegDataMissing)
     end
     it "throws an exception if the types do not match" do
-      lambda {@registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Pink"})}.should raise_error(Chef::Exceptions::Win32RegDataMissing)
+      expect {@registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Pink"})}.to raise_error(Chef::Exceptions::Win32RegDataMissing)
     end
     it "throws an exception if the data does not match" do
-      lambda {@registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Mauve", "Delicate"]})}.should raise_error(Chef::Exceptions::Win32RegDataMissing)
+      expect {@registry.data_exists!("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Mauve", "Delicate"]})}.to raise_error(Chef::Exceptions::Win32RegDataMissing)
     end
   end
 
   describe "get_values" do
     it "returns all values for a key if it exists" do
       values = @registry.get_values("HKCU\\Software\\Root")
-      values.should be_an_instance_of Array
-      values.should == [{:name=>"RootType1", :type=>:string, :data=>"fibrous"},
-                        {:name=>"Roots", :type=>:multi_string, :data=>["strong roots", "healthy tree"]}]
+      expect(values).to be_an_instance_of Array
+      expect(values).to eq([{:name=>"RootType1", :type=>:string, :data=>"fibrous"},
+                        {:name=>"Roots", :type=>:multi_string, :data=>["strong roots", "healthy tree"]}])
     end
 
     it "throws an exception if the key does not exist" do
-      lambda {@registry.get_values("HKCU\\Software\\Branch\\Flower")}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.get_values("HKCU\\Software\\Branch\\Flower")}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
 
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.get_values("JKLM\\Software\\Branch\\Flower")}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.get_values("JKLM\\Software\\Branch\\Flower")}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
   end
 
   describe "set_value" do
     it "updates a value if the key, value exist and type matches and value different" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]}).should == true
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})).to eq(true)
     end
 
     it "updates a value if the type does match and the values are different" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Yellow"}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Yellow"}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]}).should == false
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Yellow"})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:string, :data=>"Yellow"})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})).to eq(false)
     end
 
     it "creates a value if key exists and value does not" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]}).should == true
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})).to eq(true)
     end
 
     it "does nothing if data,type and name parameters for the value are same" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]}).should == false
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]}).should == true
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})).to eq(false)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"Stamen", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})).to eq(true)
     end
 
     it "throws an exception if the key does not exist" do
-      lambda {@registry.set_value("HKCU\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.set_value("HKCU\\Software\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
 
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.set_value("JKLM\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.set_value("JKLM\\Software\\Root\\Branch\\Flower", {:name=>"Petals", :type=>:multi_string, :data=>["Yellow", "Changed Color"]})}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
 
     # we are validating that the data gets .to_i called on it when type is a :dword
 
     it "casts an integer string given as a dword into an integer" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe32767", :type=>:dword, :data=>"32767"}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe32767", :type=>:dword, :data=>32767}).should == true
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe32767", :type=>:dword, :data=>"32767"})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe32767", :type=>:dword, :data=>32767})).to eq(true)
     end
 
     it "casts a nonsense string given as a dword into zero" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBeZero", :type=>:dword, :data=>"whatdoesthisdo"}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBeZero", :type=>:dword, :data=>0}).should == true
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBeZero", :type=>:dword, :data=>"whatdoesthisdo"})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBeZero", :type=>:dword, :data=>0})).to eq(true)
     end
 
     it "throws an exception when trying to cast an array to an int for a dword" do
-      lambda {@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldThrow", :type=>:dword, :data=>["one","two"]})}.should raise_error
+      expect {@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldThrow", :type=>:dword, :data=>["one","two"]})}.to raise_error
     end
 
     # we are validating that the data gets .to_s called on it when type is a :string
 
     it "stores the string representation of an array into a string if you pass it an array" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBePainful", :type=>:string, :data=>["one","two"]}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBePainful", :type=>:string, :data=>'["one", "two"]'}).should == true
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBePainful", :type=>:string, :data=>["one","two"]})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBePainful", :type=>:string, :data=>'["one", "two"]'})).to eq(true)
     end
 
     it "stores the string representation of a number into a string if you pass it an number" do
-      @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe65535", :type=>:string, :data=>65535}).should == true
-      @registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe65535", :type=>:string, :data=>"65535"}).should == true
+      expect(@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe65535", :type=>:string, :data=>65535})).to eq(true)
+      expect(@registry.data_exists?("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBe65535", :type=>:string, :data=>"65535"})).to eq(true)
     end
 
     # we are validating that the data gets .to_a called on it when type is a :multi_string
 
     it "throws an exception when a multi-string is passed a number" do
-      lambda {@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldThrow", :type=>:multi_string, :data=>65535})}.should raise_error
+      expect {@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldThrow", :type=>:multi_string, :data=>65535})}.to raise_error
     end
 
     it "throws an exception when a multi-string is passed a string" do
-      lambda {@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBeWat", :type=>:multi_string, :data=>"foo"})}.should raise_error
+      expect {@registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", {:name=>"ShouldBeWat", :type=>:multi_string, :data=>"foo"})}.to raise_error
     end
   end
 
@@ -289,22 +289,22 @@ describe 'Chef::Win32::Registry', :windows_only do
     end
 
     it "throws an exception if the path has missing keys but recursive set to false" do
-      lambda {@registry.create_key("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", false)}.should raise_error(Chef::Exceptions::Win32RegNoRecursive)
-      @registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker").should == false
+      expect {@registry.create_key("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", false)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker")).to eq(false)
     end
 
     it "creates the key_path if the keys were missing but recursive was set to true" do
-      @registry.create_key("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", true).should == true
-      @registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker").should == true
+      expect(@registry.create_key("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", true)).to eq(true)
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker")).to eq(true)
     end
 
     it "does nothing if the key already exists" do
-      @registry.create_key("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", false).should == true
-      @registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker").should == true
+      expect(@registry.create_key("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", false)).to eq(true)
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker")).to eq(true)
     end
 
     it "throws an exception of the hive does not exist" do
-      lambda {@registry.create_key("JKLM\\Software\\Root\\Trunk\\Peck\\Woodpecker", false)}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.create_key("JKLM\\Software\\Root\\Trunk\\Peck\\Woodpecker", false)}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
   end
 
@@ -317,21 +317,21 @@ describe 'Chef::Win32::Registry', :windows_only do
     end
 
     it "deletes values if the value exists" do
-      @registry.delete_value("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"}).should == true
-      @registry.value_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"}).should == false
+      expect(@registry.delete_value("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})).to eq(true)
+      expect(@registry.value_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})).to eq(false)
     end
 
     it "does nothing if value does not exist" do
-      @registry.delete_value("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"}).should == true
-      @registry.value_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"}).should == false
+      expect(@registry.delete_value("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})).to eq(true)
+      expect(@registry.value_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})).to eq(false)
     end
 
     it "throws an exception if the key does not exist?" do
-      lambda {@registry.delete_value("HKCU\\Software\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.delete_value("HKCU\\Software\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
 
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.delete_value("JKLM\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.delete_value("JKLM\\Software\\Root\\Trunk\\Peck\\Woodpecker", {:name=>"Peter", :type=>:string, :data=>"Tiny"})}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
   end
 
@@ -348,27 +348,27 @@ describe 'Chef::Win32::Registry', :windows_only do
     end
 
     it "deletes a key if it has no subkeys" do
-      @registry.delete_key("HKCU\\Software\\Root\\Branch\\Fruit", false).should == true
-      @registry.key_exists?("HKCU\\Software\\Root\\Branch\\Fruit").should == false
+      expect(@registry.delete_key("HKCU\\Software\\Root\\Branch\\Fruit", false)).to eq(true)
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Branch\\Fruit")).to eq(false)
     end
 
     it "throws an exception if key to delete has subkeys and recursive is false" do
-      lambda { @registry.delete_key("HKCU\\Software\\Root\\Trunk", false) }.should raise_error(Chef::Exceptions::Win32RegNoRecursive)
-      @registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker").should == true
+      expect { @registry.delete_key("HKCU\\Software\\Root\\Trunk", false) }.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Trunk\\Peck\\Woodpecker")).to eq(true)
     end
 
     it "deletes a key if it has subkeys and recursive true" do
-      @registry.delete_key("HKCU\\Software\\Root\\Trunk", true).should == true
-      @registry.key_exists?("HKCU\\Software\\Root\\Trunk").should == false
+      expect(@registry.delete_key("HKCU\\Software\\Root\\Trunk", true)).to eq(true)
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Trunk")).to eq(false)
     end
 
     it "does nothing if the key does not exist" do
-      @registry.delete_key("HKCU\\Software\\Root\\Trunk", true).should == true
-      @registry.key_exists?("HKCU\\Software\\Root\\Trunk").should == false
+      expect(@registry.delete_key("HKCU\\Software\\Root\\Trunk", true)).to eq(true)
+      expect(@registry.key_exists?("HKCU\\Software\\Root\\Trunk")).to eq(false)
     end
 
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.delete_key("JKLM\\Software\\Root\\Branch\\Flower", false)}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.delete_key("JKLM\\Software\\Root\\Branch\\Flower", false)}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
   end
 
@@ -384,29 +384,29 @@ describe 'Chef::Win32::Registry', :windows_only do
     end
 
     it "throws an exception if the hive was missing" do
-      lambda {@registry.has_subkeys?("LMNO\\Software\\Root")}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.has_subkeys?("LMNO\\Software\\Root")}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
 
     it "throws an exception if the key is missing" do
-      lambda {@registry.has_subkeys?("HKCU\\Software\\Root\\Trunk\\Red")}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.has_subkeys?("HKCU\\Software\\Root\\Trunk\\Red")}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
 
     it "returns true if the key has subkeys" do
-      @registry.has_subkeys?("HKCU\\Software\\Root").should == true
+      expect(@registry.has_subkeys?("HKCU\\Software\\Root")).to eq(true)
     end
 
     it "returns false if the key has no subkeys" do
       ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\Trunk\\Red"
-      @registry.has_subkeys?("HKCU\\Software\\Root\\Trunk\\Red").should == false
+      expect(@registry.has_subkeys?("HKCU\\Software\\Root\\Trunk\\Red")).to eq(false)
     end
   end
 
   describe "get_subkeys" do
     it "throws an exception if the key is missing" do
-      lambda {@registry.get_subkeys("HKCU\\Software\\Trunk\\Red")}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.get_subkeys("HKCU\\Software\\Trunk\\Red")}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
     it "throws an exception if the hive does not exist" do
-      lambda {@registry.get_subkeys("JKLM\\Software\\Root")}.should raise_error(Chef::Exceptions::Win32RegHiveMissing)
+      expect {@registry.get_subkeys("JKLM\\Software\\Root")}.to raise_error(Chef::Exceptions::Win32RegHiveMissing)
     end
     it "returns the array of subkeys for a given key" do
       subkeys = @registry.get_subkeys("HKCU\\Software\\Root")
@@ -414,7 +414,7 @@ describe 'Chef::Win32::Registry', :windows_only do
       ::Win32::Registry::HKEY_CURRENT_USER.open("Software\\Root", Win32::Registry::KEY_ALL_ACCESS) do |reg|
         reg.each_key{|name| reg_subkeys << name}
       end
-      reg_subkeys.should == subkeys
+      expect(reg_subkeys).to eq(subkeys)
     end
   end
 
@@ -431,37 +431,37 @@ describe 'Chef::Win32::Registry', :windows_only do
 
       context "registry constructor" do
         it "throws an exception if requested architecture is 64bit but running on 32bit" do
-          lambda {Chef::Win32::Registry.new(@run_context, :x86_64)}.should raise_error(Chef::Exceptions::Win32RegArchitectureIncorrect)
+          expect {Chef::Win32::Registry.new(@run_context, :x86_64)}.to raise_error(Chef::Exceptions::Win32RegArchitectureIncorrect)
         end
 
         it "can correctly set the requested architecture to 32-bit" do
           @r = Chef::Win32::Registry.new(@run_context, :i386)
-          @r.architecture.should == :i386
-          @r.registry_system_architecture.should == 0x0200
+          expect(@r.architecture).to eq(:i386)
+          expect(@r.registry_system_architecture).to eq(0x0200)
         end
 
         it "can correctly set the requested architecture to :machine" do
           @r = Chef::Win32::Registry.new(@run_context, :machine)
-          @r.architecture.should == :machine
-          @r.registry_system_architecture.should == 0x0200
+          expect(@r.architecture).to eq(:machine)
+          expect(@r.registry_system_architecture).to eq(0x0200)
         end
       end
 
       context "architecture setter" do
         it "throws an exception if requested architecture is 64bit but running on 32bit" do
-          lambda {@registry.architecture = :x86_64}.should raise_error(Chef::Exceptions::Win32RegArchitectureIncorrect)
+          expect {@registry.architecture = :x86_64}.to raise_error(Chef::Exceptions::Win32RegArchitectureIncorrect)
         end
 
         it "sets the requested architecture to :machine if passed :machine" do
           @registry.architecture = :machine
-          @registry.architecture.should == :machine
-          @registry.registry_system_architecture.should == 0x0200
+          expect(@registry.architecture).to eq(:machine)
+          expect(@registry.registry_system_architecture).to eq(0x0200)
         end
 
         it "sets the requested architecture to 32-bit if passed i386 as a string" do
           @registry.architecture = :i386
-          @registry.architecture.should == :i386
-          @registry.registry_system_architecture.should == 0x0200
+          expect(@registry.architecture).to eq(:i386)
+          expect(@registry.registry_system_architecture).to eq(0x0200)
         end
       end
     end
@@ -479,40 +479,40 @@ describe 'Chef::Win32::Registry', :windows_only do
       context "registry constructor" do
         it "can correctly set the requested architecture to 32-bit" do
           @r = Chef::Win32::Registry.new(@run_context, :i386)
-          @r.architecture.should == :i386
-          @r.registry_system_architecture.should == 0x0200
+          expect(@r.architecture).to eq(:i386)
+          expect(@r.registry_system_architecture).to eq(0x0200)
         end
 
         it "can correctly set the requested architecture to 64-bit" do
           @r = Chef::Win32::Registry.new(@run_context, :x86_64)
-          @r.architecture.should == :x86_64
-          @r.registry_system_architecture.should == 0x0100
+          expect(@r.architecture).to eq(:x86_64)
+          expect(@r.registry_system_architecture).to eq(0x0100)
         end
 
         it "can correctly set the requested architecture to :machine" do
           @r = Chef::Win32::Registry.new(@run_context, :machine)
-          @r.architecture.should == :machine
-          @r.registry_system_architecture.should == 0x0100
+          expect(@r.architecture).to eq(:machine)
+          expect(@r.registry_system_architecture).to eq(0x0100)
         end
       end
 
       context "architecture setter" do
         it "sets the requested architecture to 64-bit if passed 64-bit" do
           @registry.architecture = :x86_64
-          @registry.architecture.should == :x86_64
-          @registry.registry_system_architecture.should == 0x0100
+          expect(@registry.architecture).to eq(:x86_64)
+          expect(@registry.registry_system_architecture).to eq(0x0100)
         end
 
         it "sets the requested architecture to :machine if passed :machine" do
           @registry.architecture = :machine
-          @registry.architecture.should == :machine
-          @registry.registry_system_architecture.should == 0x0100
+          expect(@registry.architecture).to eq(:machine)
+          expect(@registry.registry_system_architecture).to eq(0x0100)
         end
 
         it "sets the requested architecture to 32-bit if passed 32-bit" do
           @registry.architecture = :i386
-          @registry.architecture.should == :i386
-          @registry.registry_system_architecture.should == 0x0200
+          expect(@registry.architecture).to eq(:i386)
+          expect(@registry.registry_system_architecture).to eq(0x0200)
         end
       end
     end
@@ -555,75 +555,75 @@ describe 'Chef::Win32::Registry', :windows_only do
       describe "key_exists?" do
         it "does not find 64-bit keys in the 32-bit registry" do
           @registry.architecture=:i386
-          @registry.key_exists?("HKLM\\Software\\Root\\Mauve").should == false
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Mauve")).to eq(false)
         end
         it "finds 32-bit keys in the 32-bit registry" do
           @registry.architecture=:i386
-          @registry.key_exists?("HKLM\\Software\\Root\\Poosh").should == true
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Poosh")).to eq(true)
         end
         it "does not find 32-bit keys in the 64-bit registry" do
           @registry.architecture=:x86_64
-          @registry.key_exists?("HKLM\\Software\\Root\\Mauve").should == true
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Mauve")).to eq(true)
         end
         it "finds 64-bit keys in the 64-bit registry" do
           @registry.architecture=:x86_64
-          @registry.key_exists?("HKLM\\Software\\Root\\Poosh").should == false
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Poosh")).to eq(false)
         end
       end
 
       describe "value_exists?" do
         it "does not find 64-bit values in the 32-bit registry" do
           @registry.architecture=:i386
-          lambda{@registry.value_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert"})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+          expect{@registry.value_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert"})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
         end
         it "finds 32-bit values in the 32-bit registry" do
           @registry.architecture=:i386
-          @registry.value_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status"}).should == true
+          expect(@registry.value_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status"})).to eq(true)
         end
         it "does not find 32-bit values in the 64-bit registry" do
           @registry.architecture=:x86_64
-          @registry.value_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert"}).should == true
+          expect(@registry.value_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert"})).to eq(true)
         end
         it "finds 64-bit values in the 64-bit registry" do
           @registry.architecture=:x86_64
-          lambda{@registry.value_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status"})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+          expect{@registry.value_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status"})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
         end
       end
 
       describe "data_exists?" do
         it "does not find 64-bit keys in the 32-bit registry" do
           @registry.architecture=:i386
-          lambda{@registry.data_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert", :type=>:string, :data=>"Universal"})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+          expect{@registry.data_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert", :type=>:string, :data=>"Universal"})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
         end
         it "finds 32-bit keys in the 32-bit registry" do
           @registry.architecture=:i386
-          @registry.data_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status", :type=>:string, :data=>"Lost"}).should == true
+          expect(@registry.data_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status", :type=>:string, :data=>"Lost"})).to eq(true)
         end
         it "does not find 32-bit keys in the 64-bit registry" do
           @registry.architecture=:x86_64
-          @registry.data_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert", :type=>:string, :data=>"Universal"}).should == true
+          expect(@registry.data_exists?("HKLM\\Software\\Root\\Mauve", {:name=>"Alert", :type=>:string, :data=>"Universal"})).to eq(true)
         end
         it "finds 64-bit keys in the 64-bit registry" do
           @registry.architecture=:x86_64
-          lambda{@registry.data_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status", :type=>:string, :data=>"Lost"})}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+          expect{@registry.data_exists?("HKLM\\Software\\Root\\Poosh", {:name=>"Status", :type=>:string, :data=>"Lost"})}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
         end
       end
 
       describe "create_key" do
         it "can create a 32-bit only registry key" do
           @registry.architecture = :i386
-          @registry.create_key("HKLM\\Software\\Root\\Trunk\\Red", true).should == true
-          @registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Red").should == true
+          expect(@registry.create_key("HKLM\\Software\\Root\\Trunk\\Red", true)).to eq(true)
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Red")).to eq(true)
           @registry.architecture = :x86_64
-          @registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Red").should == false
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Red")).to eq(false)
         end
 
         it "can create a 64-bit only registry key" do
           @registry.architecture = :x86_64
-          @registry.create_key("HKLM\\Software\\Root\\Trunk\\Blue", true).should == true
-          @registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Blue").should == true
+          expect(@registry.create_key("HKLM\\Software\\Root\\Trunk\\Blue", true)).to eq(true)
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Blue")).to eq(true)
           @registry.architecture = :i386
-          @registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Blue").should == false
+          expect(@registry.key_exists?("HKLM\\Software\\Root\\Trunk\\Blue")).to eq(false)
         end
       end