1 files changed, 35 insertions, 35 deletions
diff --git a/spec/unit/data_bag_spec.rb b/spec/unit/data_bag_spec.rb
index ff323902eb..f6db1e222a 100644
--- a/spec/unit/data_bag_spec.rb
+++ b/spec/unit/data_bag_spec.rb
@@ -22,36 +22,36 @@ require 'chef/data_bag'
 describe Chef::DataBag do
   before(:each) do
     @data_bag = Chef::DataBag.new
-    Chef::Platform::stub(:windows?) { false }
+    allow(Chef::Platform)::to receive(:windows?) { false }
   end
 
   describe "initialize" do
     it "should be a Chef::DataBag" do
-      @data_bag.should be_a_kind_of(Chef::DataBag)
+      expect(@data_bag).to be_a_kind_of(Chef::DataBag)
     end
   end
 
   describe "name" do
     it "should let you set the name to a string" do
-      @data_bag.name("clowns").should == "clowns"
+      expect(@data_bag.name("clowns")).to eq("clowns")
     end
 
     it "should return the current name" do
       @data_bag.name "clowns"
-      @data_bag.name.should == "clowns"
+      expect(@data_bag.name).to eq("clowns")
     end
 
     it "should not accept spaces" do
-      lambda { @data_bag.name "clown masters" }.should raise_error(ArgumentError)
+      expect { @data_bag.name "clown masters" }.to raise_error(ArgumentError)
     end
 
     it "should throw an ArgumentError if you feed it anything but a string" do
-      lambda { @data_bag.name Hash.new }.should raise_error(ArgumentError)
+      expect { @data_bag.name Hash.new }.to raise_error(ArgumentError)
     end
 
     [ ".", "-", "_", "1"].each do |char|
       it "should allow a '#{char}' character in the data bag name" do
-        @data_bag.name("clown#{char}clown").should == "clown#{char}clown"
+        expect(@data_bag.name("clown#{char}clown")).to eq("clown#{char}clown")
       end
     end
   end
@@ -63,14 +63,14 @@ describe Chef::DataBag do
     end
 
     it "should deserialize to a Chef::DataBag object" do
-      @deserial.should be_a_kind_of(Chef::DataBag)
+      expect(@deserial).to be_a_kind_of(Chef::DataBag)
     end
 
     %w{
       name
     }.each do |t|
       it "should match '#{t}'" do
-        @deserial.send(t.to_sym).should == @data_bag.send(t.to_sym)
+        expect(@deserial.send(t.to_sym)).to eq(@data_bag.send(t.to_sym))
       end
 
       include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
@@ -84,17 +84,17 @@ describe Chef::DataBag do
     before do
       @data_bag.name('piggly_wiggly')
       @rest = double("Chef::REST")
-      Chef::REST.stub(:new).and_return(@rest)
+      allow(Chef::REST).to receive(:new).and_return(@rest)
     end
 
     it "should silently proceed when the data bag already exists" do
       exception = double("409 error", :code => "409")
-      @rest.should_receive(:post_rest).and_raise(Net::HTTPServerException.new("foo", exception))
+      expect(@rest).to receive(:post_rest).and_raise(Net::HTTPServerException.new("foo", exception))
       @data_bag.save
     end
 
     it "should create the data bag" do
-      @rest.should_receive(:post_rest).with("data", @data_bag)
+      expect(@rest).to receive(:post_rest).with("data", @data_bag)
       @data_bag.save
     end
 
@@ -106,7 +106,7 @@ describe Chef::DataBag do
         Chef::Config[:why_run] = false
       end
       it "should not save" do
-        @rest.should_not_receive(:post_rest)
+        expect(@rest).not_to receive(:post_rest)
         @data_bag.save
       end
     end
@@ -120,25 +120,25 @@ describe Chef::DataBag do
       end
 
       it "should get the data bag from the server" do
-        Chef::REST.should_receive(:new).with('https://myserver.example.com').and_return(@http_client)
-        @http_client.should_receive(:get_rest).with('data/foo')
+        expect(Chef::REST).to receive(:new).with('https://myserver.example.com').and_return(@http_client)
+        expect(@http_client).to receive(:get_rest).with('data/foo')
         Chef::DataBag.load('foo')
       end
 
       it "should return the data bag" do
-        Chef::REST.stub(:new).and_return(@http_client)
-        @http_client.should_receive(:get_rest).with('data/foo').and_return({'bar' => 'https://myserver.example.com/data/foo/bar'})
+        allow(Chef::REST).to receive(:new).and_return(@http_client)
+        expect(@http_client).to receive(:get_rest).with('data/foo').and_return({'bar' => 'https://myserver.example.com/data/foo/bar'})
         data_bag = Chef::DataBag.load('foo')
-        data_bag.should == {'bar' => 'https://myserver.example.com/data/foo/bar'}
+        expect(data_bag).to eq({'bar' => 'https://myserver.example.com/data/foo/bar'})
       end
     end
 
     def file_dir_stub(path, returns = true)
-      File.should_receive(:directory?).with(path).and_return(returns)
+      expect(File).to receive(:directory?).with(path).and_return(returns)
     end
 
     def dir_glob_stub(path, returns = [])
-      Dir.should_receive(:glob).with(File.join(path, 'foo/*.json')).and_return(returns)
+      expect(Dir).to receive(:glob).with(File.join(path, 'foo/*.json')).and_return(returns)
     end
 
     shared_examples_for "data bag in solo mode" do |data_bag_path|
@@ -177,21 +177,21 @@ describe Chef::DataBag do
             dir_glob_stub(path)
           end
         end
-        IO.should_receive(:read).with(File.join(@paths.first, 'foo/bar.json')).and_return('{"id": "bar", "name": "Bob Bar" }')
-        IO.should_receive(:read).with(File.join(@paths.first, 'foo/baz.json')).and_return('{"id": "baz", "name": "John Baz" }')
+        expect(IO).to receive(:read).with(File.join(@paths.first, 'foo/bar.json')).and_return('{"id": "bar", "name": "Bob Bar" }')
+        expect(IO).to receive(:read).with(File.join(@paths.first, 'foo/baz.json')).and_return('{"id": "baz", "name": "John Baz" }')
         data_bag = Chef::DataBag.load('foo')
-        data_bag.should == { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar' }, 'baz' => { 'id' => 'baz', 'name' => 'John Baz' }}
+        expect(data_bag).to eq({ 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar' }, 'baz' => { 'id' => 'baz', 'name' => 'John Baz' }})
       end
 
       it "should raise if data bag has items with similar names but different content" do
         @paths.each do |path|
           file_dir_stub(path)
           item_with_different_content = "{\"id\": \"bar\", \"name\": \"Bob Bar\", \"path\": \"#{path}\"}"
-          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_different_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_different_content)
           if data_bag_path.is_a?(String)
             dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
             item_2_with_different_content = '{"id": "bar", "name": "John Baz"}'
-            IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_2_with_different_content)
+            expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_2_with_different_content)
           else
             dir_glob_stub(path, [File.join(path, 'foo/bar.json')])
           end
@@ -204,12 +204,12 @@ describe Chef::DataBag do
           file_dir_stub(path)
           dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
           item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
-          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_same_content)
-          IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_with_same_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_same_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_with_same_content)
         end
         data_bag = Chef::DataBag.load('foo')
         test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
-        data_bag.should == test_data_bag
+        expect(data_bag).to eq(test_data_bag)
       end
 
       it "should merge data bag items if there are no conflicts" do
@@ -217,33 +217,33 @@ describe Chef::DataBag do
           file_dir_stub(path)
           dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
           test_item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
-          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(test_item_with_same_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(test_item_with_same_content)
           test_uniq_item = "{\"id\": \"baz_#{index}\", \"name\": \"John Baz\", \"path\": \"#{path}\"}"
-          IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(test_uniq_item)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(test_uniq_item)
         end
         data_bag = Chef::DataBag.load('foo')
         test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
         @paths.each_with_index do |path, index|
           test_data_bag["baz_#{index}"] = { "id" => "baz_#{index}", "name" => "John Baz", "path" => path }
         end
-        data_bag.should == test_data_bag
+        expect(data_bag).to eq(test_data_bag)
       end
 
       it "should return the data bag list" do
         @paths.each do |path|
           file_dir_stub(path)
-          Dir.should_receive(:glob).and_return([File.join(path, 'foo'), File.join(path, 'bar')])
+          expect(Dir).to receive(:glob).and_return([File.join(path, 'foo'), File.join(path, 'bar')])
         end
         data_bag_list = Chef::DataBag.list
-        data_bag_list.should == { 'bar' => 'bar', 'foo' => 'foo' }
+        expect(data_bag_list).to eq({ 'bar' => 'bar', 'foo' => 'foo' })
       end
 
       it 'should raise an error if the configured data_bag_path is invalid' do
         file_dir_stub(@paths.first, false)
 
-        lambda {
+        expect {
           Chef::DataBag.load('foo')
-        }.should raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' is invalid"
+        }.to raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' is invalid"
       end
 
     end