chef 11.18.12 → 12.0.0.alpha.0

data/spec/support/shared/integration/integration_helper.rb

@@ -21,6 +21,7 @@ require 'tmpdir'
 require 'fileutils'
 require 'chef/config'
 require 'chef_zero/rspec'
+require 'json'
 require 'support/shared/integration/knife_support'
 require 'support/shared/integration/app_server_support'
 require 'spec_helper'
@@ -68,7 +69,7 @@ module IntegrationSupport
         File.open(filename, 'w') do |file|
           raw = case contents
                 when Hash
-                  Chef::JSONCompat.to_json_pretty(contents)
+                  JSON.pretty_generate(contents)
                 when Array
                   contents.join("\n")
                 else

data/spec/support/shared/matchers.rb

@@ -0,0 +1,17 @@
+
+require 'rspec/expectations'
+require 'spec/support/platform_helpers'
+
+RSpec::Matchers.define :match_environment_variable do |varname|
+  match do |actual|
+    expected = if windows? && ENV[varname].nil?
+      # On Windows, if an environment variable is not set, the command
+      # `echo %VARNAME%` outputs %VARNAME%
+      "%#{varname}%"
+    else
+      ENV[varname].to_s
+    end
+
+    actual == expected
+  end
+end

data/spec/tiny_server.rb

@@ -25,7 +25,6 @@ require 'singleton'
 require 'chef/json_compat'
 require 'open-uri'
 require 'chef/config'
-require 'chef/json_compat'
 
 module TinyServer
 
@@ -153,7 +152,7 @@ module TinyServer
                       :available_routes => @routes, :request => env}
         # Uncomment me for glorious debugging
         # pp :not_found => debug_info
-        [404, {'Content-Type' => 'application/json'}, [ Chef::JSONCompat.to_json(debug_info) ]]
+        [404, {'Content-Type' => 'application/json'}, [ debug_info.to_json ]]
       end
     end
 

data/spec/unit/api_client_spec.rb

@@ -92,7 +92,7 @@ describe Chef::ApiClient do
     before(:each) do
       @client.name("black")
       @client.public_key("crowes")
-      @json = Chef::JSONCompat.to_json(@client)
+      @json = @client.to_json
     end
 
     it "serializes as a JSON object" do
@@ -117,7 +117,7 @@ describe Chef::ApiClient do
 
     it "includes the private key when present" do
       @client.private_key("monkeypants")
-      Chef::JSONCompat.to_json(@client).should include(%q{"private_key":"monkeypants"})
+      @client.to_json.should include(%q{"private_key":"monkeypants"})
     end
 
     it "does not include the private key if not present" do
@@ -135,7 +135,7 @@ describe Chef::ApiClient do
       "validator" => true,
       "json_class" => "Chef::ApiClient"
       }
-      @client = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(client))
+      @client = Chef::JSONCompat.from_json(client.to_json)
     end
 
     it "should deserialize to a Chef::ApiClient object" do

data/spec/unit/application_spec.rb

@@ -255,12 +255,7 @@ describe Chef::Application do
 
       it "should set ENV['http_proxy']" do
         @app.configure_proxy_environment_variables
-        @env['http_proxy'].should == "#{scheme}://#{address}:#{port}"
-      end
-
-      it "should set ENV['HTTP_PROXY']" do
-        @app.configure_proxy_environment_variables
-        @env['HTTP_PROXY'].should == "#{scheme}://#{address}:#{port}"
+        @env['http_proxy'].should == "http://#{address}:#{port}"
       end
 
       describe "when Chef::Config[:http_proxy_user] is set" do
@@ -270,8 +265,7 @@ describe Chef::Application do
 
         it "should set ENV['http_proxy'] with the username" do
           @app.configure_proxy_environment_variables
-          @env['http_proxy'].should == "#{scheme}://username@#{address}:#{port}"
-          @env['HTTP_PROXY'].should == "#{scheme}://username@#{address}:#{port}"
+          @env['http_proxy'].should == "http://username@#{address}:#{port}"
         end
 
         context "when :http_proxy_user contains '@' and/or ':'" do
@@ -281,8 +275,7 @@ describe Chef::Application do
 
           it "should set ENV['http_proxy'] with the escaped username" do
             @app.configure_proxy_environment_variables
-            @env['http_proxy'].should == "#{scheme}://my%3Ausern%40me@#{address}:#{port}"
-            @env['HTTP_PROXY'].should == "#{scheme}://my%3Ausern%40me@#{address}:#{port}"
+            @env['http_proxy'].should == "http://my%3Ausern%40me@#{address}:#{port}"
           end
         end
 
@@ -293,8 +286,7 @@ describe Chef::Application do
 
           it "should set ENV['http_proxy'] with the password" do
             @app.configure_proxy_environment_variables
-            @env['http_proxy'].should == "#{scheme}://username:password@#{address}:#{port}"
-            @env['HTTP_PROXY'].should == "#{scheme}://username:password@#{address}:#{port}"
+            @env['http_proxy'].should == "http://username:password@#{address}:#{port}"
           end
 
           context "when :http_proxy_pass contains '@' and/or ':'" do
@@ -304,8 +296,7 @@ describe Chef::Application do
 
             it "should set ENV['http_proxy'] with the escaped password" do
               @app.configure_proxy_environment_variables
-              @env['http_proxy'].should == "#{scheme}://username:%3AP%40ssword101@#{address}:#{port}"
-              @env['HTTP_PROXY'].should == "#{scheme}://username:%3AP%40ssword101@#{address}:#{port}"
+              @env['http_proxy'].should == "http://username:%3AP%40ssword101@#{address}:#{port}"
             end
           end
         end
@@ -319,8 +310,7 @@ describe Chef::Application do
 
         it "should set ENV['http_proxy']" do
           @app.configure_proxy_environment_variables
-          @env['http_proxy'].should == "#{scheme}://#{address}:#{port}"
-          @env['HTTP_PROXY'].should == "#{scheme}://#{address}:#{port}"
+          @env['http_proxy'].should == "http://#{address}:#{port}"
         end
       end
     end
@@ -348,43 +338,30 @@ describe Chef::Application do
 
       describe "when Chef::Config[:http_proxy] is set" do
         context "when given an FQDN" do
-          let(:scheme) { "http" }
-          let(:address) { "proxy.example.org" }
-          let(:port) { 8080 }
-          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
-
-          it_should_behave_like "setting ENV['http_proxy']"
-        end
-
-        context "when given an HTTPS URL" do
-          let(:scheme) { "https" }
           let(:address) { "proxy.example.org" }
           let(:port) { 8080 }
-          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
+          let(:http_proxy) { "http://#{address}:#{port}" }
 
           it_should_behave_like "setting ENV['http_proxy']"
         end
 
         context "when given an IP" do
-          let(:scheme) { "http" }
           let(:address) { "127.0.0.1" }
           let(:port) { 22 }
-          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
+          let(:http_proxy) { "http://#{address}:#{port}" }
 
           it_should_behave_like "setting ENV['http_proxy']"
         end
 
         context "when given an IPv6" do
-          let(:scheme) { "http" }
           let(:address) { "[2001:db8::1]" }
           let(:port) { 80 }
-          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
+          let(:http_proxy) { "http://#{address}:#{port}" }
 
           it_should_behave_like "setting ENV['http_proxy']"
         end
 
         context "when given without including http://" do
-          let(:scheme) { "http" }
           let(:address) { "proxy.example.org" }
           let(:port) { 8181 }
           let(:http_proxy) { "#{address}:#{port}" }

data/spec/unit/config_fetcher_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'chef/config_fetcher'
 describe Chef::ConfigFetcher do
-  let(:valid_json) { Chef::JSONCompat.to_json({:a=>"b"}) }
+  let(:valid_json) { {:a=>"b"}.to_json }
   let(:invalid_json) { %q[{"syntax-error": "missing quote}] }
   let(:http) { double("Chef::HTTP::Simple") }
 

data/spec/unit/cookbook/metadata_spec.rb

@@ -582,7 +582,7 @@ describe Chef::Cookbook::Metadata do
       @meta.version "1.2.3"
     end
 
-    describe "#to_json" do
+    describe "serialize" do
       before(:each) do
         @serial = Chef::JSONCompat.from_json(@meta.to_json)
       end
@@ -613,15 +613,11 @@ describe Chef::Cookbook::Metadata do
           @serial[t].should == @meta.send(t.to_sym)
         end
       end
-
-      it "should produce the same output from to_json and Chef::JSONCompat" do
-        expect(@meta.to_json).to eq(Chef::JSONCompat.to_json(@meta))
-      end
     end
 
-    describe "::from_json" do
+    describe "deserialize" do
       before(:each) do
-        @deserial = Chef::Cookbook::Metadata.from_json(Chef::JSONCompat.to_json(@meta))
+        @deserial = Chef::Cookbook::Metadata.from_json(@meta.to_json)
       end
 
       it "should deserialize to a Chef::Cookbook::Metadata object" do

data/spec/unit/cookbook/synchronizer_spec.rb

@@ -5,302 +5,517 @@ require 'chef/cookbook_version'
 describe Chef::CookbookCacheCleaner do
   describe "when cleaning up unused cookbook components" do
 
-    before do
-      @cleaner = Chef::CookbookCacheCleaner.instance
-      @cleaner.reset!
+    let(:cleaner) do
+      cleaner = Chef::CookbookCacheCleaner.instance
+      cleaner.reset!
+      cleaner
     end
 
-    it "removes all files that belong to unused cookbooks" do
-    end
+    let(:file_cache) { double("Chef::FileCache with files from unused cookbooks") }
 
-    it "removes all files not validated during the chef run" do
-      file_cache = double("Chef::FileCache with files from unused cookbooks")
-      unused_template_files = %w{cookbooks/unused/templates/default/foo.conf.erb cookbooks/unused/tempaltes/default/bar.conf.erb}
-      valid_cached_cb_files = %w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb}
-      @cleaner.mark_file_as_valid('cookbooks/valid1/recipes/default.rb')
-      @cleaner.mark_file_as_valid('cookbooks/valid2/recipes/default.rb')
-      file_cache.should_receive(:find).with(File.join(%w{cookbooks ** *})).and_return(valid_cached_cb_files + unused_template_files)
-      file_cache.should_receive(:delete).with('cookbooks/unused/templates/default/foo.conf.erb')
-      file_cache.should_receive(:delete).with('cookbooks/unused/tempaltes/default/bar.conf.erb')
-      cookbook_hash = {"valid1"=> {}, "valid2" => {}}
-      @cleaner.stub(:cache).and_return(file_cache)
-      @cleaner.cleanup_file_cache
+    let(:unused_template_files) do
+      %w{
+        cookbooks/unused/templates/default/foo.conf.erb
+        cookbooks/unused/tempaltes/default/bar.conf.erb
+      }
     end
 
-    describe "on chef-solo" do
-      before do
-        Chef::Config[:solo] = true
-      end
+    let(:valid_cached_cb_files) do
+      %w{
+        cookbooks/valid1/recipes/default.rb
+        cookbooks/valid2/recipes/default.rb
+      }
+    end
 
-      after do
-        Chef::Config[:solo] = false
+    before do
+      valid_cached_cb_files.each do |cbf|
+        cleaner.mark_file_as_valid(cbf)
       end
+    end
 
-      it "does not remove anything" do
-        @cleaner.cache.stub(:find).and_return(%w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb})
-        @cleaner.cache.should_not_receive(:delete)
-        @cleaner.cleanup_file_cache
+    it "removes all files not validated during the chef run" do
+      expect(file_cache).to receive(:find).with(File.join(%w{cookbooks ** {*,.*}})).and_return(valid_cached_cb_files + unused_template_files)
+      unused_template_files.each do |cbf|
+        expect(file_cache).to receive(:delete).with(cbf)
       end
+      cookbook_hash = {"valid1"=> {}, "valid2" => {}}
+      allow(cleaner).to receive(:cache).and_return(file_cache)
+      cleaner.cleanup_file_cache
+    end
 
+    it "does not remove anything when skip_removal is true" do
+      cleaner.skip_removal = true
+      allow(cleaner.cache).to receive(:find).and_return(%w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb})
+      expect(cleaner.cache).not_to receive(:delete)
+      cleaner.cleanup_file_cache
     end
 
+    it "does not remove anything on chef-solo" do
+      Chef::Config[:solo] = true
+      allow(cleaner.cache).to receive(:find).and_return(%w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb})
+      expect(cleaner.cache).not_to receive(:delete)
+      cleaner.cleanup_file_cache
+    end
   end
 end
 
 describe Chef::CookbookSynchronizer do
-  before do
+  let(:cookbook_a_default_recipe) do
+    {
+      "path" => "recipes/default.rb",
+      "url"  => "http://chef.example.com/abc123",
+      "checksum" => "abc123",
+    }
+  end
+
+  let(:cookbook_a_default_attrs) do
+    {
+      "path" => "attributes/default.rb",
+      "url"  => "http://chef.example.com/abc456",
+      "checksum" => "abc456",
+    }
+  end
+
+  let(:cookbook_a_template) do
+    {
+      "path" => "templates/default/apache2.conf.erb",
+      "url" => "http://chef.example.com/ffffff",
+      "checksum" => "abc125",
+    }
+  end
+
+  let(:cookbook_a_file) do
+    {
+      "path" => "files/default/megaman.conf",
+      "url" => "http://chef.example.com/megaman.conf",
+      "checksum" => "abc124",
+    }
+  end
+
+  let(:cookbook_a_manifest) do
     segments = [ :resources, :providers, :recipes, :definitions, :libraries, :attributes, :files, :templates, :root_files ]
-    @cookbook_manifest = {}
-    @cookbook_a = Chef::CookbookVersion.new("cookbook_a")
-    @cookbook_a_manifest = segments.inject({}) {|h, segment| h[segment.to_s] = []; h}
-    @cookbook_a_default_recipe = { "path" => "recipes/default.rb",
-                                   "url"  => "http://chef.example.com/abc123",
-                                   "checksum" => "abc123" }
-    @cookbook_a_manifest["recipes"] = [ @cookbook_a_default_recipe ]
-
-    @cookbook_a_default_attrs  = { "path" => "attributes/default.rb",
-                                   "url"  => "http://chef.example.com/abc456",
-                                   "checksum" => "abc456" }
-    @cookbook_a_manifest["attributes"] = [ @cookbook_a_default_attrs ]
-    @cookbook_a_manifest["templates"] = [{"path" => "templates/default/apache2.conf.erb", "url" => "http://chef.example.com/ffffff"}]
-    @cookbook_a_manifest["files"] = [{"path" => "files/default/megaman.conf", "url" => "http://chef.example.com/megaman.conf"}]
-    @cookbook_a.manifest = @cookbook_a_manifest
-    @cookbook_manifest["cookbook_a"] = @cookbook_a
-
-    @events = Chef::EventDispatch::Dispatcher.new
-    @synchronizer = Chef::CookbookSynchronizer.new(@cookbook_manifest, @events)
+    cookbook_a_manifest = segments.inject({}) {|h, segment| h[segment.to_s] = []; h}
+    cookbook_a_manifest["recipes"] = [ cookbook_a_default_recipe ]
+    cookbook_a_manifest["attributes"] = [ cookbook_a_default_attrs ]
+    cookbook_a_manifest["templates"] = [ cookbook_a_template ]
+    cookbook_a_manifest["files"] = [ cookbook_a_file ]
+    cookbook_a_manifest
+  end
+
+  let(:cookbook_a) do
+    cookbook_a = Chef::CookbookVersion.new("cookbook_a")
+    cookbook_a.manifest = cookbook_a_manifest
+    cookbook_a
+  end
+
+  let(:cookbook_manifest) do
+    {
+      "cookbook_a" => cookbook_a
+    }
+  end
+
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+
+  let(:no_lazy_load) { true }
+
+  let(:synchronizer) do
+    Chef::Config[:no_lazy_load] = no_lazy_load
+    Chef::CookbookSynchronizer.new(cookbook_manifest, events)
   end
 
   it "lists the cookbook names" do
-    @synchronizer.cookbook_names.should == %w[cookbook_a]
+    expect(synchronizer.cookbook_names).to eq(%w[cookbook_a])
   end
 
   it "lists the cookbook manifests" do
-    @synchronizer.cookbooks.should == [@cookbook_a]
+    expect(synchronizer.cookbooks).to eq([cookbook_a])
   end
 
-  context "when the cache contains unneeded cookbooks" do
-    before do
-      @file_cache = double("Chef::FileCache with files from unused cookbooks")
-      @valid_cached_cb_files = %w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb}
-      @obsolete_cb_files = %w{cookbooks/old1/recipes/default.rb cookbooks/old2/recipes/default.rb}
+  context "#clear_obsoleted_cookbooks" do
+    after do
+      # Singletons == Global State == Bad
+      Chef::CookbookCacheCleaner.instance.skip_removal = nil
+    end
 
-      @cookbook_hash = {"valid1"=> {}, "valid2" => {}}
+    it "behaves correctly when remove_obsoleted_files is false" do
+      synchronizer.remove_obsoleted_files = false
+      expect(synchronizer).not_to receive(:remove_old_cookbooks)
+      expect(synchronizer).to receive(:remove_deleted_files)
+      synchronizer.clear_obsoleted_cookbooks
+      expect(Chef::CookbookCacheCleaner.instance.skip_removal).to be true
+    end
+
+    it "behaves correctly when remove_obsoleted_files is true" do
+      synchronizer.remove_obsoleted_files = true
+      expect(synchronizer).to receive(:remove_old_cookbooks)
+      expect(synchronizer).to receive(:remove_deleted_files)
+      synchronizer.clear_obsoleted_cookbooks
+      expect(Chef::CookbookCacheCleaner.instance.skip_removal).to be nil
+    end
+  end
+
+  context "#remove_old_cookbooks" do
+    let(:file_cache) { double("Chef::FileCache with files from unused cookbooks") }
 
-      @synchronizer = Chef::CookbookSynchronizer.new(@cookbook_hash, @events)
+    let(:cookbook_manifest) do
+      {"valid1"=> {}, "valid2" => {}}
     end
 
     it "removes unneeded cookbooks" do
-      @file_cache.should_receive(:find).with(File.join(%w{cookbooks ** *})).and_return(@valid_cached_cb_files + @obsolete_cb_files)
-      @file_cache.should_receive(:delete).with('cookbooks/old1/recipes/default.rb')
-      @file_cache.should_receive(:delete).with('cookbooks/old2/recipes/default.rb')
-      @synchronizer.stub(:cache).and_return(@file_cache)
-      @synchronizer.clear_obsoleted_cookbooks
+      valid_cached_cb_files = %w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb}
+      obsolete_cb_files = %w{cookbooks/old1/recipes/default.rb cookbooks/old2/recipes/default.rb}
+      expect(file_cache).to receive(:find).with(File.join(%w{cookbooks ** {*,.*}})).and_return(valid_cached_cb_files + obsolete_cb_files)
+      expect(file_cache).to receive(:delete).with('cookbooks/old1/recipes/default.rb')
+      expect(file_cache).to receive(:delete).with('cookbooks/old2/recipes/default.rb')
+      allow(synchronizer).to receive(:cache).and_return(file_cache)
+      synchronizer.remove_old_cookbooks
     end
   end
 
-  describe "when syncing cookbooks with the server" do
-    before do
-      # Would rather not stub out methods on the test subject, but setting up
-      # the state is a PITA and tests for this behavior are above.
-      @synchronizer.stub(:clear_obsoleted_cookbooks)
+  context "#remove_deleted_files" do
+    let(:file_cache) { double("Chef::FileCache with files from unused cookbooks") }
+
+    let(:cookbook_manifest) do
+      {"valid1"=> {}, "valid2" => {}}
+    end
+
+    it "removes only deleted files" do
+      valid_cached_cb_files = %w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb}
+      obsolete_cb_files = %w{cookbooks/valid1/recipes/deleted.rb cookbooks/valid2/recipes/deleted.rb}
+      expect(file_cache).to receive(:find).with(File.join(%w{cookbooks ** {*,.*}})).and_return(valid_cached_cb_files + obsolete_cb_files)
+      # valid1 is a cookbook in our run_list
+      expect(synchronizer).to receive(:have_cookbook?).with("valid1").at_least(:once).and_return(true)
+      # valid2 is a cookbook not in our run_list (we're simulating an override run_list where valid2 needs to be preserved)
+      expect(synchronizer).to receive(:have_cookbook?).with("valid2").at_least(:once).and_return(false)
+      expect(file_cache).to receive(:delete).with('cookbooks/valid1/recipes/deleted.rb')
+      expect(synchronizer).to receive(:cookbook_segment).with("valid1", "recipes").at_least(:once).and_return([ { "path" => "recipes/default.rb" }])
+      allow(synchronizer).to receive(:cache).and_return(file_cache)
+      synchronizer.remove_deleted_files
+    end
+  end
+
+  let(:cookbook_a_default_recipe_tempfile) do
+    double("Tempfile for cookbook_a default.rb recipe",
+           :path => "/tmp/cookbook_a_recipes_default_rb")
+  end
 
-      @server_api = double("Chef::REST (mock)")
-      @file_cache = double("Chef::FileCache (mock)")
-      @synchronizer.stub(:server_api).and_return(@server_api)
-      @synchronizer.stub(:cache).and_return(@file_cache)
+  let(:cookbook_a_default_attribute_tempfile) do
+    double("Tempfile for cookbook_a default.rb attr file",
+           :path => "/tmp/cookbook_a_attributes_default_rb")
+  end
 
+  let(:cookbook_a_file_default_tempfile) do
+    double("Tempfile for cookbook_a megaman.conf file",
+           :path => "/tmp/cookbook_a_file_default_tempfile")
+  end
 
-      @cookbook_a_default_recipe_tempfile = double("Tempfile for cookbook_a default.rb recipe",
-                                                 :path => "/tmp/cookbook_a_recipes_default_rb")
+  let(:cookbook_a_template_default_tempfile) do
+    double("Tempfile for cookbook_a apache.conf.erb template",
+           :path => "/tmp/cookbook_a_template_default_tempfile")
+  end
 
-      @cookbook_a_default_attribute_tempfile = double("Tempfile for cookbook_a default.rb attr file",
-                                                 :path => "/tmp/cookbook_a_attributes_default_rb")
+  def setup_common_files_missing_expectations
+    # Files are not in the cache:
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/recipes/default.rb").
+      and_return(false)
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/attributes/default.rb").
+      and_return(false)
+
+    # Fetch and copy default.rb recipe
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/abc123', true).
+      and_return(cookbook_a_default_recipe_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_recipes_default_rb", "cookbooks/cookbook_a/recipes/default.rb")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/recipes/default.rb", false).
+      and_return("/file-cache/cookbooks/cookbook_a/recipes/default.rb")
+
+    # Fetch and copy default.rb attribute file
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/abc456', true).
+      and_return(cookbook_a_default_attribute_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_attributes_default_rb", "cookbooks/cookbook_a/attributes/default.rb")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/attributes/default.rb", false).
+      and_return("/file-cache/cookbooks/cookbook_a/attributes/default.rb")
+  end
 
+  def setup_no_lazy_files_and_templates_missing_expectations
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/files/default/megaman.conf").
+      and_return(false)
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/templates/default/apache2.conf.erb").
+      and_return(false)
+
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/megaman.conf', true).
+      and_return(cookbook_a_file_default_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_file_default_tempfile", "cookbooks/cookbook_a/files/default/megaman.conf")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/files/default/megaman.conf", false).
+      and_return("/file-cache/cookbooks/cookbook_a/default/megaman.conf")
+
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/ffffff', true).
+      and_return(cookbook_a_template_default_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_template_default_tempfile", "cookbooks/cookbook_a/templates/default/apache2.conf.erb")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/templates/default/apache2.conf.erb", false).
+      and_return("/file-cache/cookbooks/cookbook_a/templates/default/apache2.conf.erb")
+  end
+
+  def setup_common_files_chksum_mismatch_expectations
+    # Files are in the cache:
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/recipes/default.rb").
+      and_return(true)
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/attributes/default.rb").
+      and_return(true)
+
+    # Fetch and copy default.rb recipe
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/abc123', true).
+      and_return(cookbook_a_default_recipe_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_recipes_default_rb", "cookbooks/cookbook_a/recipes/default.rb")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/recipes/default.rb", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/recipes/default.rb")
+
+    # Current file has fff000, want abc123
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/recipes/default.rb").
+      and_return("fff000")
+
+    # Fetch and copy default.rb attribute file
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/abc456', true).
+      and_return(cookbook_a_default_attribute_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_attributes_default_rb", "cookbooks/cookbook_a/attributes/default.rb")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/attributes/default.rb", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/attributes/default.rb")
+
+    # Current file has fff000, want abc456
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/attributes/default.rb").
+      and_return("fff000")
+  end
+
+  def setup_no_lazy_files_and_templates_chksum_mismatch_expectations
+    # Files are in the cache:
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/files/default/megaman.conf").
+      and_return(true)
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/templates/default/apache2.conf.erb").
+      and_return(true)
+
+    # Fetch and copy megaman.conf
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/megaman.conf', true).
+      and_return(cookbook_a_file_default_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_file_default_tempfile", "cookbooks/cookbook_a/files/default/megaman.conf")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/files/default/megaman.conf", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/default/megaman.conf")
+
+    # Fetch and copy apache2.conf template
+    expect(server_api).to receive(:get_rest).
+      with('http://chef.example.com/ffffff', true).
+      and_return(cookbook_a_template_default_tempfile)
+    expect(file_cache).to receive(:move_to).
+      with("/tmp/cookbook_a_template_default_tempfile", "cookbooks/cookbook_a/templates/default/apache2.conf.erb")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/templates/default/apache2.conf.erb", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/templates/default/apache2.conf.erb")
+
+    # Current file has fff000
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/default/megaman.conf").
+      and_return("fff000")
+
+    # Current file has fff000
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/templates/default/apache2.conf.erb").
+      and_return("fff000")
+  end
+
+  def setup_common_files_present_expectations
+    # Files are in the cache:
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/recipes/default.rb").
+      and_return(true)
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/attributes/default.rb").
+      and_return(true)
+
+    # Current file has abc123, want abc123
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/recipes/default.rb").
+      and_return("abc123")
+
+    # Current file has abc456, want abc456
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/attributes/default.rb").
+      and_return("abc456")
+
+    # :load called twice
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/recipes/default.rb", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/recipes/default.rb")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/attributes/default.rb", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/attributes/default.rb")
+  end
+
+  def setup_no_lazy_files_and_templates_present_expectations
+    # Files are in the cache:
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/files/default/megaman.conf").
+      and_return(true)
+    expect(file_cache).to receive(:has_key?).
+      with("cookbooks/cookbook_a/templates/default/apache2.conf.erb").
+      and_return(true)
+
+    # Current file has abc124, want abc124
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/default/megaman.conf").
+      and_return("abc124")
+
+    # Current file has abc125, want abc125
+    expect(Chef::CookbookVersion).to receive(:checksum_cookbook_file).
+      with("/file-cache/cookbooks/cookbook_a/templates/default/apache2.conf.erb").
+      and_return("abc125")
+
+    # :load called twice
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/files/default/megaman.conf", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/default/megaman.conf")
+    expect(file_cache).to receive(:load).
+      with("cookbooks/cookbook_a/templates/default/apache2.conf.erb", false).
+      twice.
+      and_return("/file-cache/cookbooks/cookbook_a/templates/default/apache2.conf.erb")
+  end
+
+  describe "when syncing cookbooks with the server" do
+    let(:server_api) { double("Chef::REST (mock)") }
+
+    let(:file_cache) { double("Chef::FileCache (mock)") }
+
+    before do
+      # Would rather not stub out methods on the test subject, but setting up
+      # the state is a PITA and tests for this behavior are above.
+      allow(synchronizer).to receive(:clear_obsoleted_cookbooks)
+      allow(synchronizer).to receive(:server_api).and_return(server_api)
+      allow(synchronizer).to receive(:cache).and_return(file_cache)
     end
 
     context "when the cache does not contain the desired files" do
       before do
-
-        # Files are not in the cache:
-        @file_cache.should_receive(:has_key?).
-          with("cookbooks/cookbook_a/recipes/default.rb").
-          and_return(false)
-        @file_cache.should_receive(:has_key?).
-          with("cookbooks/cookbook_a/attributes/default.rb").
-          and_return(false)
-
-        # Fetch and copy default.rb recipe
-        @server_api.should_receive(:get_rest).
-          with('http://chef.example.com/abc123', true).
-          and_return(@cookbook_a_default_recipe_tempfile)
-        @file_cache.should_receive(:move_to).
-          with("/tmp/cookbook_a_recipes_default_rb", "cookbooks/cookbook_a/recipes/default.rb")
-        @file_cache.should_receive(:load).
-          with("cookbooks/cookbook_a/recipes/default.rb", false).
-          and_return("/file-cache/cookbooks/cookbook_a/recipes/default.rb")
-
-        # Fetch and copy default.rb attribute file
-        @server_api.should_receive(:get_rest).
-          with('http://chef.example.com/abc456', true).
-          and_return(@cookbook_a_default_attribute_tempfile)
-        @file_cache.should_receive(:move_to).
-          with("/tmp/cookbook_a_attributes_default_rb", "cookbooks/cookbook_a/attributes/default.rb")
-        @file_cache.should_receive(:load).
-          with("cookbooks/cookbook_a/attributes/default.rb", false).
-          and_return("/file-cache/cookbooks/cookbook_a/attributes/default.rb")
+        setup_common_files_missing_expectations
       end
 
-      it "fetches eagerly loaded files" do
-        @synchronizer.sync_cookbooks
-      end
+      context "Chef::Config[:no_lazy_load] is false" do
+        let(:no_lazy_load) { false }
 
-      it "does not fetch templates or cookbook files" do
-        # Implicitly tested in previous test; this test is just for behavior specification.
-        @server_api.should_not_receive(:get_rest).
-          with('http://chef.example.com/ffffff', true)
+        it "fetches eagerly loaded files" do
+          synchronizer.sync_cookbooks
+        end
+
+        it "does not fetch templates or cookbook files" do
+          # Implicitly tested in previous test; this test is just for behavior specification.
+          expect(server_api).not_to receive(:get_rest).
+            with('http://chef.example.com/ffffff', true)
 
-        @synchronizer.sync_cookbooks
+          synchronizer.sync_cookbooks
+        end
       end
 
       context "Chef::Config[:no_lazy_load] is true" do
-        before do
-          Chef::Config[:no_lazy_load] = true
-          @synchronizer = Chef::CookbookSynchronizer.new(@cookbook_manifest, @events)
-          @synchronizer.stub(:server_api).and_return(@server_api)
-          @synchronizer.stub(:cache).and_return(@file_cache)
-          @synchronizer.stub(:clear_obsoleted_cookbooks)
-
-          @cookbook_a_file_default_tempfile = double("Tempfile for cookbook_a megaman.conf file",
-                                                     :path => "/tmp/cookbook_a_file_default_tempfile")
-          @cookbook_a_template_default_tempfile = double("Tempfile for cookbook_a apache.conf.erb template",
-                                                     :path => "/tmp/cookbook_a_template_default_tempfile")
-        end
+        let(:no_lazy_load) { true }
 
-        after do
-          Chef::Config[:no_lazy_load] = false
+        before do
+          setup_no_lazy_files_and_templates_missing_expectations
         end
 
         it "fetches templates and cookbook files" do
-          @file_cache.should_receive(:has_key?).
-            with("cookbooks/cookbook_a/files/default/megaman.conf").
-            and_return(false)
-          @file_cache.should_receive(:has_key?).
-            with("cookbooks/cookbook_a/templates/default/apache2.conf.erb").
-            and_return(false)
-
-          @server_api.should_receive(:get_rest).
-            with('http://chef.example.com/megaman.conf', true).
-            and_return(@cookbook_a_file_default_tempfile)
-          @file_cache.should_receive(:move_to).
-            with("/tmp/cookbook_a_file_default_tempfile", "cookbooks/cookbook_a/files/default/megaman.conf")
-          @file_cache.should_receive(:load).
-            with("cookbooks/cookbook_a/files/default/megaman.conf", false).
-            and_return("/file-cache/cookbooks/cookbook_a/default/megaman.conf")
-
-          @server_api.should_receive(:get_rest).
-            with('http://chef.example.com/ffffff', true).
-            and_return(@cookbook_a_template_default_tempfile)
-          @file_cache.should_receive(:move_to).
-            with("/tmp/cookbook_a_template_default_tempfile", "cookbooks/cookbook_a/templates/default/apache2.conf.erb")
-          @file_cache.should_receive(:load).
-            with("cookbooks/cookbook_a/templates/default/apache2.conf.erb", false).
-            and_return("/file-cache/cookbooks/cookbook_a/templates/default/apache2.conf.erb")
-
-          @synchronizer.sync_cookbooks
+          synchronizer.sync_cookbooks
         end
       end
     end
 
     context "when the cache contains outdated files" do
       before do
-        # Files are in the cache:
-        @file_cache.should_receive(:has_key?).
-          with("cookbooks/cookbook_a/recipes/default.rb").
-          and_return(true)
-        @file_cache.should_receive(:has_key?).
-          with("cookbooks/cookbook_a/attributes/default.rb").
-          and_return(true)
-
-
-        # Fetch and copy default.rb recipe
-        @server_api.should_receive(:get_rest).
-          with('http://chef.example.com/abc123', true).
-          and_return(@cookbook_a_default_recipe_tempfile)
-        @file_cache.should_receive(:move_to).
-          with("/tmp/cookbook_a_recipes_default_rb", "cookbooks/cookbook_a/recipes/default.rb")
-        @file_cache.should_receive(:load).
-          with("cookbooks/cookbook_a/recipes/default.rb", false).
-          twice.
-          and_return("/file-cache/cookbooks/cookbook_a/recipes/default.rb")
-
-        # Current file has fff000, want abc123
-        Chef::CookbookVersion.should_receive(:checksum_cookbook_file).
-          with("/file-cache/cookbooks/cookbook_a/recipes/default.rb").
-          and_return("fff000")
-
-        # Fetch and copy default.rb attribute file
-        @server_api.should_receive(:get_rest).
-          with('http://chef.example.com/abc456', true).
-          and_return(@cookbook_a_default_attribute_tempfile)
-        @file_cache.should_receive(:move_to).
-          with("/tmp/cookbook_a_attributes_default_rb", "cookbooks/cookbook_a/attributes/default.rb")
-        @file_cache.should_receive(:load).
-          with("cookbooks/cookbook_a/attributes/default.rb", false).
-          twice.
-          and_return("/file-cache/cookbooks/cookbook_a/attributes/default.rb")
-
-        # Current file has fff000, want abc456
-        Chef::CookbookVersion.should_receive(:checksum_cookbook_file).
-          with("/file-cache/cookbooks/cookbook_a/attributes/default.rb").
-          and_return("fff000")
+        setup_common_files_chksum_mismatch_expectations
       end
 
-      it "updates the outdated files" do
-        @synchronizer.sync_cookbooks
+      context "Chef::Config[:no_lazy_load] is true" do
+        let(:no_lazy_load) { true }
+
+        before do
+          setup_no_lazy_files_and_templates_chksum_mismatch_expectations
+        end
+
+        it "updates the outdated files" do
+          synchronizer.sync_cookbooks
+        end
+      end
+
+      context "Chef::Config[:no_lazy_load] is false" do
+        let(:no_lazy_load) { false }
+
+        it "updates the outdated files" do
+          synchronizer.sync_cookbooks
+        end
       end
     end
 
     context "when the cache is up to date" do
       before do
-        # Files are in the cache:
-        @file_cache.should_receive(:has_key?).
-          with("cookbooks/cookbook_a/recipes/default.rb").
-          and_return(true)
-        @file_cache.should_receive(:has_key?).
-          with("cookbooks/cookbook_a/attributes/default.rb").
-          and_return(true)
-
-        # Current file has abc123, want abc123
-        Chef::CookbookVersion.should_receive(:checksum_cookbook_file).
-          with("/file-cache/cookbooks/cookbook_a/recipes/default.rb").
-          and_return("abc123")
-
-        # Current file has abc456, want abc456
-        Chef::CookbookVersion.should_receive(:checksum_cookbook_file).
-          with("/file-cache/cookbooks/cookbook_a/attributes/default.rb").
-          and_return("abc456")
-
-        @file_cache.should_receive(:load).
-          with("cookbooks/cookbook_a/recipes/default.rb", false).
-          twice.
-          and_return("/file-cache/cookbooks/cookbook_a/recipes/default.rb")
-
-        @file_cache.should_receive(:load).
-          with("cookbooks/cookbook_a/attributes/default.rb", false).
-          twice.
-          and_return("/file-cache/cookbooks/cookbook_a/attributes/default.rb")
+        setup_common_files_present_expectations
       end
 
-      it "does not update files" do
-        @file_cache.should_not_receive(:move_to)
-        @server_api.should_not_receive(:get_rest)
-        @synchronizer.sync_cookbooks
+      context "Chef::Config[:no_lazy_load] is true" do
+        let(:no_lazy_load) { true }
+
+        before do
+          setup_no_lazy_files_and_templates_present_expectations
+        end
+
+        it "does not update files" do
+          expect(file_cache).not_to receive(:move_to)
+          expect(server_api).not_to receive(:get_rest)
+          synchronizer.sync_cookbooks
+        end
       end
 
-    end
+      context "Chef::Config[:no_lazy_load] is false" do
+        let(:no_lazy_load) { false }
 
+        it "does not update files" do
+          expect(file_cache).not_to receive(:move_to)
+          expect(server_api).not_to receive(:get_rest)
+          synchronizer.sync_cookbooks
+        end
+      end
+    end
   end
-
 end
-