chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/registry_helper_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Provider::RegistryKey do
   let(:missing_key_path) {'HKCU\Software'}
 
   before(:each) do
-    Chef::Win32::Registry.any_instance.stub(:machine_architecture).and_return(:x86_64)
+    allow_any_instance_of(Chef::Win32::Registry).to receive(:machine_architecture).and_return(:x86_64)
     @registry = Chef::Win32::Registry.new()
 
     #Making the values for registry constants available on unix
@@ -49,328 +49,328 @@ describe Chef::Provider::RegistryKey do
 
   describe "get_values" do
     it "gets all values for a key if the key exists" do
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:map)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:map)
       @registry.get_values(key_path)
     end
 
     it "throws an exception if key does not exist" do
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
-      lambda{@registry.get_values(key_path)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect{@registry.get_values(key_path)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
   end
 
   describe "set_value" do
     it "does nothing if key and hive and value exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
-      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:data_exists?).with(key_path, value1).and_return(true)
       @registry.set_value(key_path, value1)
     end
 
     it "updates value if key and hive and value exist, but data is different" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
-      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(false)
-      @hive_mock.should_receive(:open).with(key, Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
-      @reg_mock.should_receive(:write).with("one", 1, "1")
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:data_exists?).with(key_path, value1).and_return(false)
+      expect(@hive_mock).to receive(:open).with(key, Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(@reg_mock).to receive(:write).with("one", 1, "1")
       @registry.set_value(key_path, value1)
     end
 
     it "creates value if the key exists and the value does not exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
-      @reg_mock.should_receive(:write).with("one", 1, "1")
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(@reg_mock).to receive(:write).with("one", 1, "1")
       @registry.set_value(key_path, value1)
     end
 
     it "should raise an exception if the key does not exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
-      lambda {@registry.set_value(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect(@registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.set_value(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
   end
 
   describe "delete_value" do
     it "deletes value if value exists" do
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:delete_value).with("one").and_return(true)
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:delete_value).with("one").and_return(true)
       @registry.delete_value(key_path, value1)
     end
 
     it "raises an exception if the key does not exist" do
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
       @registry.delete_value(key_path, value1)
     end
 
     it "does nothing if the value does not exist" do
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
       @registry.delete_value(key_path, value1)
     end
   end
 
   describe "create_key" do
     it "creates key if intermediate keys are missing and recursive is set to true" do
-      @registry.should_receive(:keys_missing?).with(key_path).and_return(true)
-      @registry.should_receive(:create_missing).with(key_path)
-      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
+      expect(@registry).to receive(:keys_missing?).with(key_path).and_return(true)
+      expect(@registry).to receive(:create_missing).with(key_path)
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
       @registry.create_key(key_path, true)
     end
 
     it "raises an exception if intermediate keys are missing and recursive is set to false" do
-      @registry.should_receive(:keys_missing?).with(key_path).and_return(true)
-      lambda{@registry.create_key(key_path, false)}.should raise_error(Chef::Exceptions::Win32RegNoRecursive)
+      expect(@registry).to receive(:keys_missing?).with(key_path).and_return(true)
+      expect{@registry.create_key(key_path, false)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
     end
 
     it "does nothing if the key exists" do
-      @registry.should_receive(:keys_missing?).with(key_path).and_return(true)
-      @registry.should_receive(:create_missing).with(key_path)
-      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
+      expect(@registry).to receive(:keys_missing?).with(key_path).and_return(true)
+      expect(@registry).to receive(:create_missing).with(key_path)
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(true)
       @registry.create_key(key_path, true)
     end
 
     it "create key if intermediate keys not missing and recursive is set to false" do
-      @registry.should_receive(:keys_missing?).with(key_path).and_return(false)
-      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
+      expect(@registry).to receive(:keys_missing?).with(key_path).and_return(false)
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
       @registry.create_key(key_path, false)
     end
 
     it "create key if intermediate keys not missing and recursive is set to true" do
-      @registry.should_receive(:keys_missing?).with(key_path).and_return(false)
-      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
+      expect(@registry).to receive(:keys_missing?).with(key_path).and_return(false)
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
       @registry.create_key(key_path, true)
     end
   end
 
   describe "delete_key", :windows_only do
     it "deletes key if it has subkeys and recursive is set to true" do
-      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:has_subkeys?).with(key_path).and_return(true)
-      @registry.should_receive(:get_subkeys).with(key_path).and_return([sub_key])
-      @registry.should_receive(:key_exists?).with(key_path+"\\"+sub_key).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path+"\\"+sub_key).and_return([@hive_mock, key+"\\"+sub_key])
-      @registry.should_receive(:has_subkeys?).with(key_path+"\\"+sub_key).and_return(false)
-      @registry.should_receive(:delete_key_ex).twice
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:has_subkeys?).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_subkeys).with(key_path).and_return([sub_key])
+      expect(@registry).to receive(:key_exists?).with(key_path+"\\"+sub_key).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path+"\\"+sub_key).and_return([@hive_mock, key+"\\"+sub_key])
+      expect(@registry).to receive(:has_subkeys?).with(key_path+"\\"+sub_key).and_return(false)
+      expect(@registry).to receive(:delete_key_ex).twice
       @registry.delete_key(key_path, true)
     end
 
     it "raises an exception if it has subkeys but recursive is set to false" do
-      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:has_subkeys?).with(key_path).and_return(true)
-      lambda{@registry.delete_key(key_path, false)}.should raise_error(Chef::Exceptions::Win32RegNoRecursive)
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:has_subkeys?).with(key_path).and_return(true)
+      expect{@registry.delete_key(key_path, false)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
     end
 
     it "deletes key if the key exists and has no subkeys" do
-      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:has_subkeys?).with(key_path).and_return(false)
-      @registry.should_receive(:delete_key_ex)
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:has_subkeys?).with(key_path).and_return(false)
+      expect(@registry).to receive(:delete_key_ex)
       @registry.delete_key(key_path, true)
     end
   end
 
   describe "key_exists?" do
     it "returns true if key_exists" do
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @registry.key_exists?(key_path).should == true
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@registry.key_exists?(key_path)).to eq(true)
     end
 
     it "returns false if key does not exist" do
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_raise(::Win32::Registry::Error)
-      @registry.key_exists?(key_path).should == false
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_raise(::Win32::Registry::Error)
+      expect(@registry.key_exists?(key_path)).to eq(false)
     end
   end
 
   describe "key_exists!" do
     it "throws an exception if the key_parent does not exist" do
-      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
-      lambda{@registry.key_exists!(key_path)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect(@registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect{@registry.key_exists!(key_path)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
   end
 
   describe "hive_exists?" do
     it "returns true if the hive exists" do
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
       @registry.hive_exists?(key_path) == true
     end
 
     it "returns false if the hive does not exist" do
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegHiveMissing)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegHiveMissing)
       @registry.hive_exists?(key_path) == false
     end
   end
 
   describe "has_subkeys?" do
     it "returns true if the key has subkeys" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:each_key).and_yield(key)
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:each_key).and_yield(key)
       @registry.has_subkeys?(key_path) == true
     end
 
     it "returns false if the key does not have subkeys" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:each_key).and_return(no_args())
-      @registry.has_subkeys?(key_path).should == false
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:each_key).and_return(no_args())
+      expect(@registry.has_subkeys?(key_path)).to eq(false)
     end
 
     it "throws an exception if the key does not exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
-      lambda {@registry.set_value(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect(@registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.set_value(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
   end
 
   describe "get_subkeys" do
     it "returns the subkeys if they exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:each_key).and_yield(sub_key)
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:each_key).and_yield(sub_key)
       @registry.get_subkeys(key_path)
     end
   end
 
   describe "value_exists?" do
     it "throws an exception if the key does not exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
-      lambda {@registry.value_exists?(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect(@registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.value_exists?(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
 
     it "returns true if the value exists" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:any?).and_yield("one")
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:any?).and_yield("one")
       @registry.value_exists?(key_path, value1) == true
     end
 
     it "returns false if the value does not exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:any?).and_yield(no_args())
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:any?).and_yield(no_args())
       @registry.value_exists?(key_path, value1) == false
     end
   end
 
   describe "data_exists?" do
     it "throws an exception if the key does not exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
-      lambda {@registry.data_exists?(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+      expect(@registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {@registry.data_exists?(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
     end
 
     it "returns true if the data exists" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
-      @reg_mock.should_receive(:each).with(no_args()).and_yield("one", 1, "1")
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @registry.data_exists?(key_path, value1).should == true
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(@reg_mock).to receive(:each).with(no_args()).and_yield("one", 1, "1")
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@registry.data_exists?(key_path, value1)).to eq(true)
     end
 
     it "returns false if the data does not exist" do
-      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
-      @reg_mock.should_receive(:each).with(no_args()).and_yield("one", 1, "2")
-      @registry.data_exists?(key_path, value1).should == false
+      expect(@registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(@reg_mock).to receive(:each).with(no_args()).and_yield("one", 1, "2")
+      expect(@registry.data_exists?(key_path, value1)).to eq(false)
     end
   end
 
   describe "value_exists!" do
     it "does nothing if the value exists" do
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
       @registry.value_exists!(key_path, value1)
     end
 
     it "throws an exception if the value does not exist" do
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
-      lambda{@registry.value_exists!(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegValueMissing)
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
+      expect{@registry.value_exists!(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegValueMissing)
     end
   end
 
   describe "data_exists!" do
     it "does nothing if the data exists" do
-      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:data_exists?).with(key_path, value1).and_return(true)
       @registry.data_exists!(key_path, value1)
     end
 
     it "throws an exception if the data does not exist" do
-      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(false)
-      lambda{@registry.data_exists!(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegDataMissing)
+      expect(@registry).to receive(:data_exists?).with(key_path, value1).and_return(false)
+      expect{@registry.data_exists!(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegDataMissing)
     end
   end
 
   describe "type_matches?" do
     it "returns true if type matches" do
-      @registry.should_receive(:value_exists!).with(key_path, value1).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
-      @reg_mock.should_receive(:each).and_yield("one", 1)
-      @registry.type_matches?(key_path, value1).should == true
+      expect(@registry).to receive(:value_exists!).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(@reg_mock).to receive(:each).and_yield("one", 1)
+      expect(@registry.type_matches?(key_path, value1)).to eq(true)
     end
 
     it "returns false if type does not match" do
-      @registry.should_receive(:value_exists!).with(key_path, value1).and_return(true)
-      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
-      @reg_mock.should_receive(:each).and_yield("two", 2)
-      @registry.type_matches?(key_path, value1).should == false
+      expect(@registry).to receive(:value_exists!).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      expect(@hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      expect(@reg_mock).to receive(:each).and_yield("two", 2)
+      expect(@registry.type_matches?(key_path, value1)).to eq(false)
     end
 
     it "throws an exception if value does not exist" do
-      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
-      lambda{@registry.type_matches?(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegValueMissing)
+      expect(@registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
+      expect{@registry.type_matches?(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegValueMissing)
     end
   end
 
   describe "type_matches!" do
     it "does nothing if the type_matches" do
-      @registry.should_receive(:type_matches?).with(key_path, value1).and_return(true)
+      expect(@registry).to receive(:type_matches?).with(key_path, value1).and_return(true)
       @registry.type_matches!(key_path, value1)
     end
 
     it "throws an exception if the type does not match" do
-      @registry.should_receive(:type_matches?).with(key_path, value1).and_return(false)
-      lambda{@registry.type_matches!(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegTypesMismatch)
+      expect(@registry).to receive(:type_matches?).with(key_path, value1).and_return(false)
+      expect{@registry.type_matches!(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegTypesMismatch)
     end
   end
 
   describe "keys_missing?" do
     it "returns true if the keys are missing" do
-      @registry.should_receive(:key_exists?).with(missing_key_path).and_return(false)
-      @registry.keys_missing?(key_path).should == true
+      expect(@registry).to receive(:key_exists?).with(missing_key_path).and_return(false)
+      expect(@registry.keys_missing?(key_path)).to eq(true)
     end
 
     it "returns false if no keys in the path are missing" do
-      @registry.should_receive(:key_exists?).with(missing_key_path).and_return(true)
-      @registry.keys_missing?(key_path).should == false
+      expect(@registry).to receive(:key_exists?).with(missing_key_path).and_return(true)
+      expect(@registry.keys_missing?(key_path)).to eq(false)
     end
   end
 end