chef 12.6.0-universal-mingw32 → 12.7.2-universal-mingw32

data/spec/unit/cookbook_version_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,16 +15,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::CookbookVersion do
   describe "when first created" do
     before do
-      @cookbook_version = Chef::CookbookVersion.new("tatft", '/tmp/blah')
+      @cookbook_version = Chef::CookbookVersion.new("tatft", "/tmp/blah")
     end
 
     it "has a name" do
-      expect(@cookbook_version.name).to eq('tatft')
+      expect(@cookbook_version.name).to eq("tatft")
     end
 
     it "has no attribute files" do
@@ -80,26 +80,26 @@ describe Chef::CookbookVersion do
     before do
       @cookbook = Hash.new { |hash, key| hash[key] = [] }
 
-      @cookbook_root = File.join(CHEF_SPEC_DATA, 'cb_version_cookbooks', 'tatft')
+      @cookbook_root = File.join(CHEF_SPEC_DATA, "cb_version_cookbooks", "tatft")
 
       # Dunno if the paths here are representitive of what is set by CookbookLoader...
-      @cookbook[:attribute_filenames]   = Dir[File.join(@cookbook_root, 'attributes', '**', '*.rb')]
-      @cookbook[:definition_filenames]  = Dir[File.join(@cookbook_root, 'definitions', '**', '*.rb')]
-      @cookbook[:file_filenames]        = Dir[File.join(@cookbook_root, 'files', '**', '*.tgz')]
-      @cookbook[:recipe_filenames]      = Dir[File.join(@cookbook_root, 'recipes', '**', '*.rb')]
-      @cookbook[:template_filenames]    = Dir[File.join(@cookbook_root, 'templates', '**', '*.erb')]
-      @cookbook[:library_filenames]     = Dir[File.join(@cookbook_root, 'libraries', '**', '*.rb')]
-      @cookbook[:resource_filenames]    = Dir[File.join(@cookbook_root, 'resources', '**', '*.rb')]
-      @cookbook[:provider_filenames]    = Dir[File.join(@cookbook_root, 'providers', '**', '*.rb')]
-      @cookbook[:root_filenames]        = Array(File.join(@cookbook_root, 'README.rdoc'))
-      @cookbook[:metadata_filenames]    = Array(File.join(@cookbook_root, 'metadata.json'))
+      @cookbook[:attribute_filenames]   = Dir[File.join(@cookbook_root, "attributes", "**", "*.rb")]
+      @cookbook[:definition_filenames]  = Dir[File.join(@cookbook_root, "definitions", "**", "*.rb")]
+      @cookbook[:file_filenames]        = Dir[File.join(@cookbook_root, "files", "**", "*.tgz")]
+      @cookbook[:recipe_filenames]      = Dir[File.join(@cookbook_root, "recipes", "**", "*.rb")]
+      @cookbook[:template_filenames]    = Dir[File.join(@cookbook_root, "templates", "**", "*.erb")]
+      @cookbook[:library_filenames]     = Dir[File.join(@cookbook_root, "libraries", "**", "*.rb")]
+      @cookbook[:resource_filenames]    = Dir[File.join(@cookbook_root, "resources", "**", "*.rb")]
+      @cookbook[:provider_filenames]    = Dir[File.join(@cookbook_root, "providers", "**", "*.rb")]
+      @cookbook[:root_filenames]        = Array(File.join(@cookbook_root, "README.rdoc"))
+      @cookbook[:metadata_filenames]    = Array(File.join(@cookbook_root, "metadata.json"))
     end
 
     describe "and a cookbook with the same name" do
       before do
         # Currently the cookbook loader finds all the files then tells CookbookVersion
         # where they are.
-        @cookbook_version = Chef::CookbookVersion.new('tatft', @cookbook_root)
+        @cookbook_version = Chef::CookbookVersion.new("tatft", @cookbook_root)
 
         @cookbook_version.attribute_filenames  = @cookbook[:attribute_filenames]
         @cookbook_version.definition_filenames = @cookbook[:definition_filenames]
@@ -154,25 +154,25 @@ describe Chef::CookbookVersion do
 
   end
 
-  describe 'with a cookbook directory named cookbook2 that has unscoped files' do
+  describe "with a cookbook directory named cookbook2 that has unscoped files" do
     before do
       @cookbook = Hash.new { |hash, key| hash[key] = [] }
 
-      @cookbook_root = File.join(CHEF_SPEC_DATA, 'cb_version_cookbooks', 'cookbook2')
+      @cookbook_root = File.join(CHEF_SPEC_DATA, "cb_version_cookbooks", "cookbook2")
 
       # Dunno if the paths here are representitive of what is set by CookbookLoader...
-      @cookbook[:attribute_filenames]   = Dir[File.join(@cookbook_root, 'attributes', '**', '*.rb')]
-      @cookbook[:definition_filenames]  = Dir[File.join(@cookbook_root, 'definitions', '**', '*.rb')]
-      @cookbook[:file_filenames]        = Dir[File.join(@cookbook_root, 'files', '**', '*.*')]
-      @cookbook[:recipe_filenames]      = Dir[File.join(@cookbook_root, 'recipes', '**', '*.rb')]
-      @cookbook[:template_filenames]    = Dir[File.join(@cookbook_root, 'templates', '**', '*.*')]
-      @cookbook[:library_filenames]     = Dir[File.join(@cookbook_root, 'libraries', '**', '*.rb')]
-      @cookbook[:resource_filenames]    = Dir[File.join(@cookbook_root, 'resources', '**', '*.rb')]
-      @cookbook[:provider_filenames]    = Dir[File.join(@cookbook_root, 'providers', '**', '*.rb')]
-      @cookbook[:root_filenames]        = Array(File.join(@cookbook_root, 'README.rdoc'))
-      @cookbook[:metadata_filenames]    = Array(File.join(@cookbook_root, 'metadata.json'))
-
-      @cookbook_version = Chef::CookbookVersion.new('cookbook2', @cookbook_root)
+      @cookbook[:attribute_filenames]   = Dir[File.join(@cookbook_root, "attributes", "**", "*.rb")]
+      @cookbook[:definition_filenames]  = Dir[File.join(@cookbook_root, "definitions", "**", "*.rb")]
+      @cookbook[:file_filenames]        = Dir[File.join(@cookbook_root, "files", "**", "*.*")]
+      @cookbook[:recipe_filenames]      = Dir[File.join(@cookbook_root, "recipes", "**", "*.rb")]
+      @cookbook[:template_filenames]    = Dir[File.join(@cookbook_root, "templates", "**", "*.*")]
+      @cookbook[:library_filenames]     = Dir[File.join(@cookbook_root, "libraries", "**", "*.rb")]
+      @cookbook[:resource_filenames]    = Dir[File.join(@cookbook_root, "resources", "**", "*.rb")]
+      @cookbook[:provider_filenames]    = Dir[File.join(@cookbook_root, "providers", "**", "*.rb")]
+      @cookbook[:root_filenames]        = Array(File.join(@cookbook_root, "README.rdoc"))
+      @cookbook[:metadata_filenames]    = Array(File.join(@cookbook_root, "metadata.json"))
+
+      @cookbook_version = Chef::CookbookVersion.new("cookbook2", @cookbook_root)
       @cookbook_version.attribute_filenames  = @cookbook[:attribute_filenames]
       @cookbook_version.definition_filenames = @cookbook[:definition_filenames]
       @cookbook_version.recipe_filenames     = @cookbook[:recipe_filenames]
@@ -233,7 +233,6 @@ describe Chef::CookbookVersion do
 
   end
 
-
   describe "<=>" do
 
     it "should sort based on the version number" do
@@ -249,11 +248,11 @@ describe Chef::CookbookVersion do
                   ["1.2", "1.3.0"],
                   ["1.2", "1.3"],
                   ["1.2", "2.1.1"],
-                  ["1.2", "2.1"]
+                  ["1.2", "2.1"],
                  ]
       examples.each do |smaller, larger|
-        sm = Chef::CookbookVersion.new("foo", '/tmp/blah')
-        lg = Chef::CookbookVersion.new("foo", '/tmp/blah')
+        sm = Chef::CookbookVersion.new("foo", "/tmp/blah")
+        lg = Chef::CookbookVersion.new("foo", "/tmp/blah")
         sm.version = smaller
         lg.version = larger
         expect(sm).to be < lg
@@ -263,29 +262,28 @@ describe Chef::CookbookVersion do
     end
 
     it "should equate versions 1.2 and 1.2.0" do
-      a = Chef::CookbookVersion.new("foo", '/tmp/blah')
-      b = Chef::CookbookVersion.new("foo", '/tmp/blah')
+      a = Chef::CookbookVersion.new("foo", "/tmp/blah")
+      b = Chef::CookbookVersion.new("foo", "/tmp/blah")
       a.version = "1.2"
       b.version = "1.2.0"
       expect(a).to eq(b)
     end
 
-
     it "should not allow you to sort cookbooks with different names" do
-      apt = Chef::CookbookVersion.new "apt", '/tmp/blah'
+      apt = Chef::CookbookVersion.new "apt", "/tmp/blah"
       apt.version = "1.0"
-      god = Chef::CookbookVersion.new "god", '/tmp/blah'
+      god = Chef::CookbookVersion.new "god", "/tmp/blah"
       god.version = "2.0"
-      expect {apt <=> god}.to raise_error(Chef::Exceptions::CookbookVersionNameMismatch)
+      expect { apt <=> god }.to raise_error(Chef::Exceptions::CookbookVersionNameMismatch)
     end
   end
 
   describe "when you set a version" do
     before do
-      @cbv = Chef::CookbookVersion.new("version validation", '/tmp/blah')
+      @cbv = Chef::CookbookVersion.new("version validation", "/tmp/blah")
     end
     it "should accept valid cookbook versions" do
-      good_versions = %w(1.2 1.2.3 1000.80.50000 0.300.25)
+      good_versions = %w{1.2 1.2.3 1000.80.50000 0.300.25}
       good_versions.each do |v|
         @cbv.version = v
       end
@@ -296,7 +294,7 @@ describe Chef::CookbookVersion do
                       "1 2 3", "1-2-3", "1_2_3", "1.2_3", "1.2-3"]
       the_error = Chef::Exceptions::InvalidCookbookVersion
       bad_versions.each do |v|
-        expect {@cbv.version = v}.to raise_error(the_error)
+        expect { @cbv.version = v }.to raise_error(the_error)
       end
     end
 
@@ -304,7 +302,7 @@ describe Chef::CookbookVersion do
 
   describe "when deprecation warnings are errors" do
 
-    subject(:cbv) { Chef::CookbookVersion.new("version validation", '/tmp/blah') }
+    subject(:cbv) { Chef::CookbookVersion.new("version validation", "/tmp/blah") }
 
     it "errors on #status and #status=" do
       expect { cbv.status = :wat }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
@@ -315,7 +313,7 @@ describe Chef::CookbookVersion do
 
   describe "deprecated features" do
 
-    subject(:cbv) { Chef::CookbookVersion.new("tatft", '/tmp/blah').tap { |c| c.version = "1.2.3" } }
+    subject(:cbv) { Chef::CookbookVersion.new("tatft", "/tmp/blah").tap { |c| c.version = "1.2.3" } }
 
     before do
       Chef::Config[:treat_deprecation_warnings_as_errors] = false
@@ -335,9 +333,8 @@ describe Chef::CookbookVersion do
       expect(cbv.status).to eq(:ready)
     end
 
-
     include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
-      let(:jsonable) { Chef::CookbookVersion.new("tatft", '/tmp/blah') }
+      let(:jsonable) { Chef::CookbookVersion.new("tatft", "/tmp/blah") }
     end
 
   end

data/spec/unit/daemon_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
-require 'ostruct'
+require "spec_helper"
+require "ostruct"
 
 describe Chef::Daemon do
   before do
@@ -74,7 +74,7 @@ describe Chef::Daemon do
 
     before do
       allow(Chef::Application).to receive(:fatal!).and_return(true)
-      Chef::Config[:user] = 'aj'
+      Chef::Config[:user] = "aj"
       allow(Dir).to receive(:chdir)
     end
 
@@ -86,7 +86,7 @@ describe Chef::Daemon do
     describe "when the user and group options are supplied" do
 
       before do
-        Chef::Config[:group] = 'staff'
+        Chef::Config[:group] = "staff"
       end
 
       it "should log an appropriate info message" do

data/spec/unit/data_bag_item_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/data_bag_item'
+require "spec_helper"
+require "chef/data_bag_item"
 
 describe Chef::DataBagItem do
   let(:data_bag_item) { Chef::DataBagItem.new }
@@ -169,13 +169,12 @@ describe Chef::DataBagItem do
   describe "when deserializing from JSON" do
     let(:data_bag_item) {
       data_bag_item = Chef::DataBagItem.new
-      data_bag_item.data_bag('mars_volta')
+      data_bag_item.data_bag("mars_volta")
       data_bag_item.raw_data = { "id" => "octahedron", "snooze" => { "finally" => :world_will } }
       data_bag_item
     }
 
-    let(:deserial) { Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(data_bag_item)) }
-
+    let(:deserial) { Chef::DataBagItem.from_hash(Chef::JSONCompat.parse(Chef::JSONCompat.to_json(data_bag_item))) }
 
     it "should deserialize to a Chef::DataBagItem object" do
       expect(deserial).to be_a_kind_of(Chef::DataBagItem)
@@ -200,12 +199,12 @@ describe Chef::DataBagItem do
 
   describe "when converting to a string" do
     it "converts to a string in the form data_bag_item[ID]" do
-      data_bag_item['id'] = "heart of darkness"
-      expect(data_bag_item.to_s).to eq('data_bag_item[heart of darkness]')
+      data_bag_item["id"] = "heart of darkness"
+      expect(data_bag_item.to_s).to eq("data_bag_item[heart of darkness]")
     end
 
     it "inspects as data_bag_item[BAG, ID, RAW_DATA]" do
-      raw_data = {"id" => "heart_of_darkness", "author" => "Conrad"}
+      raw_data = { "id" => "heart_of_darkness", "author" => "Conrad" }
       data_bag_item.raw_data = raw_data
       data_bag_item.data_bag("books")
 
@@ -214,29 +213,29 @@ describe Chef::DataBagItem do
   end
 
   describe "save" do
-    let(:server) { instance_double(Chef::REST) }
+    let(:server) { instance_double(Chef::ServerAPI) }
 
     let(:data_bag_item) {
       data_bag_item = Chef::DataBagItem.new
-      data_bag_item['id'] = "heart of darkness"
-      data_bag_item.raw_data = {"id" => "heart_of_darkness", "author" => "Conrad"}
+      data_bag_item["id"] = "heart of darkness"
+      data_bag_item.raw_data = { "id" => "heart_of_darkness", "author" => "Conrad" }
       data_bag_item.data_bag("books")
       data_bag_item
     }
 
     before do
-      expect(Chef::REST).to receive(:new).and_return(server)
+      expect(Chef::ServerAPI).to receive(:new).and_return(server)
     end
 
     it "should update the item when it already exists" do
-      expect(server).to receive(:put_rest).with("data/books/heart_of_darkness", data_bag_item)
+      expect(server).to receive(:put).with("data/books/heart_of_darkness", data_bag_item)
       data_bag_item.save
     end
 
     it "should create if the item is not found" do
       exception = double("404 error", :code => "404")
-      expect(server).to receive(:put_rest).and_raise(Net::HTTPServerException.new("foo", exception))
-      expect(server).to receive(:post_rest).with("data/books", data_bag_item)
+      expect(server).to receive(:put).and_raise(Net::HTTPServerException.new("foo", exception))
+      expect(server).to receive(:post).with("data/books", data_bag_item)
       data_bag_item.save
     end
 
@@ -249,8 +248,8 @@ describe Chef::DataBagItem do
       end
 
       it "should not save" do
-        expect(server).not_to receive(:put_rest)
-        expect(server).not_to receive(:post_rest)
+        expect(server).not_to receive(:put)
+        expect(server).not_to receive(:post)
         data_bag_item.data_bag("books")
         data_bag_item.save
       end
@@ -259,18 +258,18 @@ describe Chef::DataBagItem do
   end
 
   describe "destroy" do
-    let(:server) { instance_double(Chef::REST) }
+    let(:server) { instance_double(Chef::ServerAPI) }
 
     let(:data_bag_item) {
       data_bag_item = Chef::DataBagItem.new
-      data_bag_item.data_bag('a_baggy_bag')
+      data_bag_item.data_bag("a_baggy_bag")
       data_bag_item.raw_data = { "id" => "some_id" }
       data_bag_item
     }
 
     it "should set default parameters" do
-      expect(Chef::REST).to receive(:new).and_return(server)
-      expect(server).to receive(:delete_rest).with("data/a_baggy_bag/data_bag_item_a_baggy_bag_some_id")
+      expect(Chef::ServerAPI).to receive(:new).and_return(server)
+      expect(server).to receive(:delete).with("data/a_baggy_bag/data_bag_item_a_baggy_bag_some_id")
 
       data_bag_item.destroy
     end
@@ -278,26 +277,26 @@ describe Chef::DataBagItem do
 
   describe "when loading" do
     before do
-      data_bag_item.raw_data = {"id" => "charlie", "shell" => "zsh", "ssh_keys" => %w{key1 key2}}
+      data_bag_item.raw_data = { "id" => "charlie", "shell" => "zsh", "ssh_keys" => %w{key1 key2} }
       data_bag_item.data_bag("users")
     end
 
     describe "from an API call" do
-      let(:http_client) { double("Chef::REST") }
+      let(:http_client) { double("Chef::ServerAPI") }
 
       before do
-        allow(Chef::REST).to receive(:new).and_return(http_client)
+        allow(Chef::ServerAPI).to receive(:new).and_return(http_client)
       end
 
       it "converts raw data to a data bag item" do
-        expect(http_client).to receive(:get_rest).with("data/users/charlie").and_return(data_bag_item.to_hash)
+        expect(http_client).to receive(:get).with("data/users/charlie").and_return(data_bag_item.to_hash)
         item = Chef::DataBagItem.load(:users, "charlie")
         expect(item).to be_a_kind_of(Chef::DataBagItem)
         expect(item).to eq(data_bag_item)
       end
 
       it "does not convert when a DataBagItem is returned from the API call" do
-        expect(http_client).to receive(:get_rest).with("data/users/charlie").and_return(data_bag_item)
+        expect(http_client).to receive(:get).with("data/users/charlie").and_return(data_bag_item)
         item = Chef::DataBagItem.load(:users, "charlie")
         expect(item).to be_a_kind_of(Chef::DataBagItem)
         expect(item).to equal(data_bag_item)
@@ -314,8 +313,8 @@ describe Chef::DataBagItem do
       end
 
       it "converts the raw data to a data bag item" do
-        expect(Chef::DataBag).to receive(:load).with('users').and_return({'charlie' => data_bag_item.to_hash})
-        item = Chef::DataBagItem.load('users', 'charlie')
+        expect(Chef::DataBag).to receive(:load).with("users").and_return({ "charlie" => data_bag_item.to_hash })
+        item = Chef::DataBagItem.load("users", "charlie")
         expect(item).to be_a_kind_of(Chef::DataBagItem)
         expect(item).to eq(data_bag_item)
       end

data/spec/unit/data_bag_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/data_bag'
+require "spec_helper"
+require "chef/data_bag"
 
 describe Chef::DataBag do
   before(:each) do
@@ -58,8 +58,8 @@ describe Chef::DataBag do
 
   describe "deserialize" do
     before(:each) do
-      @data_bag.name('mars_volta')
-      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data_bag))
+      @data_bag.name("mars_volta")
+      @deserial = Chef::DataBag.from_hash(Chef::JSONCompat.parse(Chef::JSONCompat.to_json(@data_bag)))
     end
 
     it "should deserialize to a Chef::DataBag object" do
@@ -82,19 +82,19 @@ describe Chef::DataBag do
 
   describe "when saving" do
     before do
-      @data_bag.name('piggly_wiggly')
-      @rest = double("Chef::REST")
-      allow(Chef::REST).to receive(:new).and_return(@rest)
+      @data_bag.name("piggly_wiggly")
+      @rest = double("Chef::ServerAPI")
+      allow(Chef::ServerAPI).to receive(:new).and_return(@rest)
     end
 
     it "should silently proceed when the data bag already exists" do
       exception = double("409 error", :code => "409")
-      expect(@rest).to receive(:post_rest).and_raise(Net::HTTPServerException.new("foo", exception))
+      expect(@rest).to receive(:post).and_raise(Net::HTTPServerException.new("foo", exception))
       @data_bag.save
     end
 
     it "should create the data bag" do
-      expect(@rest).to receive(:post_rest).with("data", @data_bag)
+      expect(@rest).to receive(:post).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
-        expect(@rest).not_to receive(:post_rest)
+        expect(@rest).not_to receive(:post)
         @data_bag.save
       end
     end
@@ -115,21 +115,21 @@ describe Chef::DataBag do
   describe "when loading" do
     describe "from an API call" do
       before do
-        Chef::Config[:chef_server_url] = 'https://myserver.example.com'
-        @http_client = double('Chef::REST')
+        Chef::Config[:chef_server_url] = "https://myserver.example.com"
+        @http_client = double("Chef::ServerAPI")
       end
 
       it "should get the data bag from the server" do
-        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')
+        expect(Chef::ServerAPI).to receive(:new).with("https://myserver.example.com").and_return(@http_client)
+        expect(@http_client).to receive(:get).with("data/foo")
+        Chef::DataBag.load("foo")
       end
 
       it "should return the data bag" do
-        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')
-        expect(data_bag).to eq({'bar' => 'https://myserver.example.com/data/foo/bar'})
+        allow(Chef::ServerAPI).to receive(:new).and_return(@http_client)
+        expect(@http_client).to receive(:get).with("data/foo").and_return({ "bar" => "https://myserver.example.com/data/foo/bar" })
+        data_bag = Chef::DataBag.load("foo")
+        expect(data_bag).to eq({ "bar" => "https://myserver.example.com/data/foo/bar" })
       end
     end
 
@@ -138,7 +138,7 @@ describe Chef::DataBag do
     end
 
     def dir_glob_stub(path, returns = [])
-      expect(Dir).to 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|
@@ -157,7 +157,7 @@ describe Chef::DataBag do
           file_dir_stub(path)
           dir_glob_stub(path)
         end
-        Chef::DataBag.load('foo')
+        Chef::DataBag.load("foo")
       end
 
       it "should get the data bag from the data_bag_path by symbolic name" do
@@ -172,57 +172,57 @@ describe Chef::DataBag do
         @paths.each do |path|
           file_dir_stub(path)
           if path == @paths.first
-            dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
+            dir_glob_stub(path, [File.join(path, "foo/bar.json"), File.join(path, "foo/baz.json")])
           else
             dir_glob_stub(path)
           end
         end
-        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')
-        expect(data_bag).to eq({ 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar' }, 'baz' => { '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")
+        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}\"}"
-          expect(IO).to 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')])
+            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"}'
-            expect(IO).to 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')])
+            dir_glob_stub(path, [File.join(path, "foo/bar.json")])
           end
         end
-        expect { Chef::DataBag.load('foo') }.to raise_error(Chef::Exceptions::DuplicateDataBagItem)
+        expect { Chef::DataBag.load("foo") }.to raise_error(Chef::Exceptions::DuplicateDataBagItem)
       end
 
       it "should return data bag if it has items with similar names and the same content" do
         @paths.each do |path|
           file_dir_stub(path)
-          dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
+          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"}'
-          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)
+          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 = Chef::DataBag.load("foo")
+        test_data_bag = { "bar" => { "id" => "bar", "name" => "Bob Bar" } }
         expect(data_bag).to eq(test_data_bag)
       end
 
       it "should merge data bag items if there are no conflicts" do
         @paths.each_with_index do |path, index|
           file_dir_stub(path)
-          dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
+          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"}'
-          expect(IO).to 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}\"}"
-          expect(IO).to 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'} }
+        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
@@ -232,17 +232,17 @@ describe Chef::DataBag do
       it "should return the data bag list" do
         @paths.each do |path|
           file_dir_stub(path)
-          expect(Dir).to 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
-        expect(data_bag_list).to eq({ '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
+      it "should raise an error if the configured data_bag_path is invalid" do
         file_dir_stub(@paths.first, false)
 
         expect {
-          Chef::DataBag.load('foo')
+          Chef::DataBag.load("foo")
         }.to raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' is invalid"
       end