chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/unit/provider/powershell_spec.rb

@@ -32,7 +32,7 @@ describe Chef::Provider::PowershellScript, "action_run" do
   end
 
   it "should set the -File flag as the last flag" do
-    @provider.flags.split(' ').pop.should == "-File"
+    expect(@provider.flags.split(' ').pop).to eq("-File")
   end
 
 end

data/spec/unit/provider/registry_key_spec.rb

@@ -31,9 +31,9 @@ shared_examples_for "a registry key" do
 
     @provider = Chef::Provider::RegistryKey.new(@new_resource, @run_context)
 
-    @provider.stub(:running_on_windows!).and_return(true)
+    allow(@provider).to receive(:running_on_windows!).and_return(true)
     @double_registry = double(Chef::Win32::Registry)
-    @provider.stub(:registry).and_return(@double_registry)
+    allow(@provider).to receive(:registry).and_return(@double_registry)
   end
 
   describe "when first created" do
@@ -42,36 +42,36 @@ shared_examples_for "a registry key" do
   describe "executing load_current_resource" do
     describe "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).with(keyname).and_return(true)
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
+        expect(@double_registry).to receive(:key_exists?).with(keyname).and_return(true)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval2 )
         @provider.load_current_resource
       end
 
       it "should set the key of the current resource to the key of the new resource" do
-        @provider.current_resource.key.should == @new_resource.key
+        expect(@provider.current_resource.key).to eq(@new_resource.key)
       end
 
       it "should set the architecture of the current resource to the architecture of the new resource" do
-        @provider.current_resource.architecture.should == @new_resource.architecture
+        expect(@provider.current_resource.architecture).to eq(@new_resource.architecture)
       end
 
       it "should set the recursive flag of the current resource to the recursive flag of the new resource" do
-        @provider.current_resource.recursive.should == @new_resource.recursive
+        expect(@provider.current_resource.recursive).to eq(@new_resource.recursive)
       end
 
       it "should set the unscrubbed values of the current resource to the values it got from the registry" do
-        @provider.current_resource.unscrubbed_values.should == [ testval2 ]
+        expect(@provider.current_resource.unscrubbed_values).to eq([ testval2 ])
       end
     end
 
     describe "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).with(keyname).and_return(false)
+        expect(@double_registry).to receive(:key_exists?).with(keyname).and_return(false)
         @provider.load_current_resource
       end
 
       it "should set the values in the current resource to empty array" do
-        @provider.current_resource.values.should == []
+        expect(@provider.current_resource.values).to eq([])
       end
     end
   end
@@ -79,29 +79,29 @@ shared_examples_for "a registry key" do
   describe "action_create" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "should do nothing if the key and the value both exist" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
-        @double_registry.should_not_receive(:set_value)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1 )
+        expect(@double_registry).not_to receive(:set_value)
         @provider.load_current_resource
         @provider.action_create
       end
       it "should create the value if the key exists but the value does not" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
-        @double_registry.should_receive(:set_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval2 )
+        expect(@double_registry).to receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
       it "should set the value if the key exists but the data does not match" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_data )
-        @double_registry.should_receive(:set_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1_wrong_data )
+        expect(@double_registry).to receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
       it "should set the value if the key exists but the type does not match" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_type )
-        @double_registry.should_receive(:set_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1_wrong_type )
+        expect(@double_registry).to receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
@@ -109,30 +109,30 @@ shared_examples_for "a registry key" do
     context "when the key exists and the values in the new resource are empty" do
       it "when a value is in the key, it should do nothing" do
         @provider.new_resource.values([])
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
-        @double_registry.should_not_receive(:create_key)
-        @double_registry.should_not_receive(:set_value)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1 )
+        expect(@double_registry).not_to receive(:create_key)
+        expect(@double_registry).not_to receive(:set_value)
         @provider.load_current_resource
         @provider.action_create
       end
       it "when no value is in the key, it should do nothing" do
         @provider.new_resource.values([])
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
-        @double_registry.should_receive(:get_values).with(keyname).and_return( nil )
-        @double_registry.should_not_receive(:create_key)
-        @double_registry.should_not_receive(:set_value)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( nil )
+        expect(@double_registry).not_to receive(:create_key)
+        expect(@double_registry).not_to receive(:set_value)
         @provider.load_current_resource
         @provider.action_create
       end
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "should create the key and the value" do
-        @double_registry.should_receive(:create_key).with(keyname, false)
-        @double_registry.should_receive(:set_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:create_key).with(keyname, false)
+        expect(@double_registry).to receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
@@ -140,9 +140,9 @@ shared_examples_for "a registry key" do
     context "when the key does not exist and the values in the new resource are empty" do
       it "should create the key" do
         @new_resource.values([])
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
-        @double_registry.should_receive(:create_key).with(keyname, false)
-        @double_registry.should_not_receive(:set_value)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(false)
+        expect(@double_registry).to receive(:create_key).with(keyname, false)
+        expect(@double_registry).not_to receive(:set_value)
         @provider.load_current_resource
         @provider.action_create
       end
@@ -152,40 +152,40 @@ shared_examples_for "a registry key" do
   describe "action_create_if_missing" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "should do nothing if the key and the value both exist" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
-        @double_registry.should_not_receive(:set_value)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1 )
+        expect(@double_registry).not_to receive(:set_value)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
       it "should create the value if the key exists but the value does not" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
-        @double_registry.should_receive(:set_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval2 )
+        expect(@double_registry).to receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
       it "should not set the value if the key exists but the data does not match" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_data )
-        @double_registry.should_not_receive(:set_value)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1_wrong_data )
+        expect(@double_registry).not_to receive(:set_value)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
       it "should not set the value if the key exists but the type does not match" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_type )
-        @double_registry.should_not_receive(:set_value)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1_wrong_type )
+        expect(@double_registry).not_to receive(:set_value)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "should create the key and the value" do
-        @double_registry.should_receive(:create_key).with(keyname, false)
-        @double_registry.should_receive(:set_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:create_key).with(keyname, false)
+        expect(@double_registry).to receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
@@ -195,39 +195,39 @@ shared_examples_for "a registry key" do
   describe "action_delete" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "deletes the value when the value exists" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
-        @double_registry.should_receive(:delete_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1 )
+        expect(@double_registry).to receive(:delete_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_delete
       end
       it "deletes the value when the value exists, but the type is wrong" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_type )
-        @double_registry.should_receive(:delete_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1_wrong_type )
+        expect(@double_registry).to receive(:delete_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_delete
       end
       it "deletes the value when the value exists, but the data is wrong" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_data )
-        @double_registry.should_receive(:delete_value).with(keyname, testval1)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1_wrong_data )
+        expect(@double_registry).to receive(:delete_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_delete
       end
       it "does not delete the value when the value does not exist" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
-        @double_registry.should_not_receive(:delete_value)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval2 )
+        expect(@double_registry).not_to receive(:delete_value)
         @provider.load_current_resource
         @provider.action_delete
       end
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "does nothing" do
-        @double_registry.should_not_receive(:delete_value)
+        expect(@double_registry).not_to receive(:delete_value)
         @provider.load_current_resource
         @provider.action_delete
       end
@@ -237,21 +237,21 @@ shared_examples_for "a registry key" do
   describe "action_delete_key" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "deletes the key" do
-        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
-        @double_registry.should_receive(:delete_key).with(keyname, false)
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( testval1 )
+        expect(@double_registry).to receive(:delete_key).with(keyname, false)
         @provider.load_current_resource
         @provider.action_delete_key
       end
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "does nothing" do
-        @double_registry.should_not_receive(:delete_key)
+        expect(@double_registry).not_to receive(:delete_key)
         @provider.load_current_resource
         @provider.action_delete_key
       end

data/spec/unit/provider/remote_directory_spec.rb

@@ -27,7 +27,7 @@ end
 
 describe Chef::Provider::RemoteDirectory do
   before do
-    Chef::FileAccessControl.any_instance.stub(:set_all)
+    allow_any_instance_of(Chef::FileAccessControl).to receive(:set_all)
 
     @resource = Chef::Resource::RemoteDirectory.new(File.join(Dir.tmpdir, "tafty"))
     # in CHEF_SPEC_DATA/cookbooks/openldap/files/default/remotedir
@@ -80,11 +80,11 @@ describe Chef::Provider::RemoteDirectory do
 
     it "configures access control on intermediate directorys" do
       directory_resource = @provider.send(:resource_for_directory, File.join(Dir.tmpdir, "intermediate_dir"))
-      directory_resource.path.should  == File.join(Dir.tmpdir, "intermediate_dir")
-      directory_resource.mode.should  == "0750"
-      directory_resource.group.should == "wheel"
-      directory_resource.owner.should == "root"
-      directory_resource.recursive.should be_true
+      expect(directory_resource.path).to  eq(File.join(Dir.tmpdir, "intermediate_dir"))
+      expect(directory_resource.mode).to  eq("0750")
+      expect(directory_resource.group).to eq("wheel")
+      expect(directory_resource.owner).to eq("root")
+      expect(directory_resource.recursive).to be_true
     end
 
     it "configures access control on files in the directory" do
@@ -92,12 +92,12 @@ describe Chef::Provider::RemoteDirectory do
       cookbook_file = @provider.send(:cookbook_file_resource,
                                     "/target/destination/path.txt",
                                     "relative/source/path.txt")
-      cookbook_file.cookbook_name.should  == "berlin_style_tasty_cupcakes"
-      cookbook_file.source.should         == "remotedir_root/relative/source/path.txt"
-      cookbook_file.mode.should           == "0640"
-      cookbook_file.group.should          == "staff"
-      cookbook_file.owner.should          == "toor"
-      cookbook_file.backup.should         == 23
+      expect(cookbook_file.cookbook_name).to  eq("berlin_style_tasty_cupcakes")
+      expect(cookbook_file.source).to         eq("remotedir_root/relative/source/path.txt")
+      expect(cookbook_file.mode).to           eq("0640")
+      expect(cookbook_file.group).to          eq("staff")
+      expect(cookbook_file.owner).to          eq("toor")
+      expect(cookbook_file.backup).to         eq(23)
     end
   end
 
@@ -116,17 +116,17 @@ describe Chef::Provider::RemoteDirectory do
     it "creates the toplevel directory without error " do
       @resource.recursive(false)
       @provider.run_action(:create)
-      ::File.exist?(@destination_dir).should be_true
+      expect(::File.exist?(@destination_dir)).to be_true
     end
 
     it "transfers the directory with all contents" do
       @provider.run_action(:create)
-      ::File.exist?(@destination_dir + '/remote_dir_file1.txt').should be_true
-      ::File.exist?(@destination_dir + '/remote_dir_file2.txt').should be_true
-      ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt').should be_true
-      ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt').should be_true
-      ::File.exist?(@destination_dir + '/remotesubdir/.a_dotfile').should be_true
-      ::File.exist?(@destination_dir + '/.a_dotdir/.a_dotfile_in_a_dotdir').should be_true
+      expect(::File.exist?(@destination_dir + '/remote_dir_file1.txt')).to be_true
+      expect(::File.exist?(@destination_dir + '/remote_dir_file2.txt')).to be_true
+      expect(::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt')).to be_true
+      expect(::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt')).to be_true
+      expect(::File.exist?(@destination_dir + '/remotesubdir/.a_dotfile')).to be_true
+      expect(::File.exist?(@destination_dir + '/.a_dotdir/.a_dotfile_in_a_dotdir')).to be_true
     end
 
     describe "only if it is missing" do
@@ -141,8 +141,8 @@ describe Chef::Provider::RemoteDirectory do
 
         @provider.run_action(:create_if_missing)
 
-        file1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remote_dir_file1.txt'))).should be_true
-        subdirfile1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))).should be_true
+        expect(file1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remote_dir_file1.txt')))).to be_true
+        expect(subdirfile1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt')))).to be_true
       end
     end
 
@@ -155,13 +155,13 @@ describe Chef::Provider::RemoteDirectory do
         FileUtils.touch(@destination_dir + '/remotesubdir/marked_for_death_again.txt')
         @provider.run_action(:create)
 
-        ::File.exist?(@destination_dir + '/remote_dir_file1.txt').should be_true
-        ::File.exist?(@destination_dir + '/remote_dir_file2.txt').should be_true
-        ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt').should be_true
-        ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt').should be_true
+        expect(::File.exist?(@destination_dir + '/remote_dir_file1.txt')).to be_true
+        expect(::File.exist?(@destination_dir + '/remote_dir_file2.txt')).to be_true
+        expect(::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt')).to be_true
+        expect(::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt')).to be_true
 
-        ::File.exist?(@destination_dir + '/marked_for_death.txt').should be_false
-        ::File.exist?(@destination_dir + '/remotesubdir/marked_for_death_again.txt').should be_false
+        expect(::File.exist?(@destination_dir + '/marked_for_death.txt')).to be_false
+        expect(::File.exist?(@destination_dir + '/remotesubdir/marked_for_death_again.txt')).to be_false
       end
 
       it "removes files in subdirectories before files above" do
@@ -172,10 +172,10 @@ describe Chef::Provider::RemoteDirectory do
         FileUtils.touch(@destination_dir + '/a/multiply/nested/baz.txt')
         FileUtils.touch(@destination_dir + '/a/multiply/nested/directory/qux.txt')
         @provider.run_action(:create)
-        ::File.exist?(@destination_dir + '/a/foo.txt').should be_false
-        ::File.exist?(@destination_dir + '/a/multiply/bar.txt').should be_false
-        ::File.exist?(@destination_dir + '/a/multiply/nested/baz.txt').should be_false
-        ::File.exist?(@destination_dir + '/a/multiply/nested/directory/qux.txt').should be_false
+        expect(::File.exist?(@destination_dir + '/a/foo.txt')).to be_false
+        expect(::File.exist?(@destination_dir + '/a/multiply/bar.txt')).to be_false
+        expect(::File.exist?(@destination_dir + '/a/multiply/nested/baz.txt')).to be_false
+        expect(::File.exist?(@destination_dir + '/a/multiply/nested/directory/qux.txt')).to be_false
       end
 
       it "removes directory symlinks properly", :not_supported_on_win2k3 do
@@ -188,12 +188,12 @@ describe Chef::Provider::RemoteDirectory do
         Dir.mktmpdir do |tmp_dir|
           begin
             @fclass.file_class.symlink(tmp_dir.dup, symlinked_dir_path)
-            ::File.exist?(symlinked_dir_path).should be_true
+            expect(::File.exist?(symlinked_dir_path)).to be_true
 
             @provider.run_action
 
-            ::File.exist?(symlinked_dir_path).should be_false
-            ::File.exist?(tmp_dir).should be_true
+            expect(::File.exist?(symlinked_dir_path)).to be_false
+            expect(::File.exist?(tmp_dir)).to be_true
           rescue Chef::Exceptions::Win32APIError => e
             pending "This must be run as an Administrator to create symlinks"
           end
@@ -212,8 +212,8 @@ describe Chef::Provider::RemoteDirectory do
         file1md5 = Digest::MD5.hexdigest(::File.read(@destination_dir + '/remote_dir_file1.txt'))
         subdirfile1md5 = Digest::MD5.hexdigest(::File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))
         @provider.run_action(:create)
-        file1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remote_dir_file1.txt'))).should be_true
-        subdirfile1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))).should be_true
+        expect(file1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remote_dir_file1.txt')))).to be_true
+        expect(subdirfile1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt')))).to be_true
       end
     end
 

data/spec/unit/provider/remote_file/cache_control_data_spec.rb

@@ -44,21 +44,21 @@ describe Chef::Provider::RemoteFile::CacheControlData do
   context "when loading data for an unknown URI" do
 
     before do
-      Chef::FileCache.should_receive(:load).with(cache_path).and_raise(Chef::Exceptions::FileNotFound, "nope")
+      expect(Chef::FileCache).to receive(:load).with(cache_path).and_raise(Chef::Exceptions::FileNotFound, "nope")
     end
 
     context "and there is no current copy of the file" do
       let(:current_file_checksum) { nil }
 
       it "returns empty cache control data" do
-        cache_control_data.etag.should be_nil
-        cache_control_data.mtime.should be_nil
+        expect(cache_control_data.etag).to be_nil
+        expect(cache_control_data.mtime).to be_nil
       end
     end
 
     it "returns empty cache control data" do
-      cache_control_data.etag.should be_nil
-      cache_control_data.mtime.should be_nil
+      expect(cache_control_data.etag).to be_nil
+      expect(cache_control_data.mtime).to be_nil
     end
 
     context "and the URI contains a password" do
@@ -85,19 +85,19 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       cache["etag"] = etag
       cache["mtime"] = mtime
       cache["checksum"] = last_fetched_checksum
-      cache.to_json
+      Chef::JSONCompat.to_json(cache)
     end
 
     before do
-      Chef::FileCache.should_receive(:load).with(cache_path).and_return(cache_json_data)
+      expect(Chef::FileCache).to receive(:load).with(cache_path).and_return(cache_json_data)
     end
 
     context "and there is no on-disk copy of the file" do
       let(:current_file_checksum) { nil }
 
       it "returns empty cache control data" do
-        cache_control_data.etag.should be_nil
-        cache_control_data.mtime.should be_nil
+        expect(cache_control_data.etag).to be_nil
+        expect(cache_control_data.mtime).to be_nil
       end
     end
 
@@ -105,16 +105,16 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       let(:current_file_checksum) { "e2a8938cc31754f6c067b35aab1d0d4864272e9bf8504536ef3e79ebf8432305" }
 
       it "returns empty cache control data" do
-        cache_control_data.etag.should be_nil
-        cache_control_data.mtime.should be_nil
+        expect(cache_control_data.etag).to be_nil
+        expect(cache_control_data.mtime).to be_nil
       end
     end
 
     context "and the cached checksum matches the on-disk copy" do
 
       it "populates the cache control data" do
-        cache_control_data.etag.should == etag
-        cache_control_data.mtime.should == mtime
+        expect(cache_control_data.etag).to eq(etag)
+        expect(cache_control_data.mtime).to eq(mtime)
       end
     end
 
@@ -122,16 +122,16 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       let(:cache_json_data) { '{"foo",,"bar" []}' }
 
       it "returns empty cache control data" do
-        cache_control_data.etag.should be_nil
-        cache_control_data.mtime.should be_nil
+        expect(cache_control_data.etag).to be_nil
+        expect(cache_control_data.mtime).to be_nil
       end
 
       context "and it still is valid JSON" do
         let(:cache_json_data) { '' }
 
         it "returns empty cache control data" do
-          cache_control_data.etag.should be_nil
-          cache_control_data.mtime.should be_nil
+          expect(cache_control_data.etag).to be_nil
+          expect(cache_control_data.mtime).to be_nil
         end
       end
     end
@@ -162,12 +162,12 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       # so we can't count on the order of the keys in the json format.
 
       json_data = cache_control_data.json_data
-      Chef::JSONCompat.from_json(json_data).should == expected_serialization_data
+      expect(Chef::JSONCompat.from_json(json_data)).to eq(expected_serialization_data)
     end
 
     it "writes data to the cache" do
       json_data = cache_control_data.json_data
-      Chef::FileCache.should_receive(:store).with(cache_path, json_data)
+      expect(Chef::FileCache).to receive(:store).with(cache_path, json_data)
       cache_control_data.save
     end
 
@@ -178,7 +178,7 @@ describe Chef::Provider::RemoteFile::CacheControlData do
 
       it "writes the data to the cache with a sanitized path name" do
         json_data = cache_control_data.json_data
-        Chef::FileCache.should_receive(:store).with(cache_path, json_data)
+        expect(Chef::FileCache).to receive(:store).with(cache_path, json_data)
         cache_control_data.save
       end
     end
@@ -199,18 +199,18 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       it "truncates the file cache path to 102 characters" do
         normalized_cache_path = cache_control_data.send('sanitized_cache_file_basename')
 
-        Chef::FileCache.should_receive(:store).with("remote_file/" + normalized_cache_path, cache_control_data.json_data)
+        expect(Chef::FileCache).to receive(:store).with("remote_file/" + normalized_cache_path, cache_control_data.json_data)
 
         cache_control_data.save
 
-        normalized_cache_path.length.should == CACHE_FILE_PATH_LIMIT
+        expect(normalized_cache_path.length).to eq(CACHE_FILE_PATH_LIMIT)
       end
 
       it "uses a file cache path that starts with the first #{CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH} characters of the URI" do
         normalized_cache_path = cache_control_data.send('sanitized_cache_file_basename')
 
-        truncated_file_cache_path.length.should == CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH
-        normalized_cache_path.start_with?(truncated_file_cache_path).should == true
+        expect(truncated_file_cache_path.length).to eq(CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH)
+        expect(normalized_cache_path.start_with?(truncated_file_cache_path)).to eq(true)
       end
     end