chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/knife/configure_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe Chef::Knife::Configure do
   before do
-    @original_config = Chef::Config.configuration.dup
-
     Chef::Log.logger = Logger.new(StringIO.new)
 
+    @original_config = Chef::Config.configuration.dup
+
     Chef::Config[:node_name]  = "webmonkey.example.com"
     @knife = Chef::Knife::Configure.new
     @rest_client = mock("null rest client", :post_rest => { :result => :true })
@@ -21,27 +21,43 @@ describe Chef::Knife::Configure do
     @err = StringIO.new
     @knife.ui.stub!(:stderr).and_return(@err)
 
-    @ohai = Ohai::System.new
-    @ohai.stub(:require_plugin)
-    @ohai[:fqdn] = "foo.example.org"
-    Ohai::System.stub!(:new).and_return(@ohai)
+    Ohai::System.stub!(:new).and_return(ohai)
   end
 
   after do
     Chef::Config.configuration.replace(@original_config)
   end
 
+
+  let(:fqdn) { "foo.example.org" }
+
+  let(:ohai) do
+    o = {}
+    o.stub(:require_plugin)
+    o[:fqdn] = fqdn
+    o
+  end
+
+  let(:default_admin_key) { "/etc/chef-server/admin.pem" }
+  let(:default_admin_key_win32) { File.expand_path(default_admin_key) }
+
+  let(:default_validator_key) { "/etc/chef-server/chef-validator.pem" }
+  let(:default_validator_key_win32) { File.expand_path(default_validator_key) }
+
+  let(:default_server_url) { "https://#{fqdn}:443" }
+
+
   it "asks the user for the URL of the chef server" do
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape('Please enter the chef server URL: [http://foo.example.org:4000]'))
-    @knife.chef_server.should == 'http://foo.example.org:4000'
+    @out.string.should match(Regexp.escape("Please enter the chef server URL: [#{default_server_url}]"))
+    @knife.chef_server.should == default_server_url
   end
 
   it "asks the user for the clientname they want for the new client if -i is specified" do
     @knife.config[:initial] = true
     Etc.stub!(:getlogin).and_return("a-new-user")
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape("Please enter a clientname for the new client: [a-new-user]"))
+    @out.string.should match(Regexp.escape("Please enter a name for the new user: [a-new-user]"))
     @knife.new_client_name.should == Etc.getlogin
   end
 
@@ -50,7 +66,7 @@ describe Chef::Knife::Configure do
     @knife.config[:node_name] = 'testnode'
     Etc.stub!(:getlogin).and_return("a-new-user")
     @knife.ask_user_for_config
-    @out.string.should_not match(Regexp.escape("Please enter a clientname for the new client"))
+    @out.string.should_not match(Regexp.escape("Please enter a name for the new user"))
     @knife.new_client_name.should == 'testnode'
   end
 
@@ -64,32 +80,32 @@ describe Chef::Knife::Configure do
   it "asks the user for the existing admin client's name if -i is specified" do
     @knife.config[:initial] = true
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape("Please enter the existing admin clientname: [chef-webui]"))
-    @knife.admin_client_name.should == 'chef-webui'
+    @out.string.should match(Regexp.escape("Please enter the existing admin name: [admin]"))
+    @knife.admin_client_name.should == 'admin'
   end
 
   it "should not ask the user for the existing admin client's name if -i and --admin-client_name are specified" do
     @knife.config[:initial] = true
     @knife.config[:admin_client_name] = 'my-webui'
     @knife.ask_user_for_config
-    @out.string.should_not match(Regexp.escape("Please enter the existing admin clientname:"))
+    @out.string.should_not match(Regexp.escape("Please enter the existing admin:"))
     @knife.admin_client_name.should == 'my-webui'
   end
 
   it "should not ask the user for the existing admin client's name if -i is not specified" do
     @knife.ask_user_for_config
-    @out.string.should_not match(Regexp.escape("Please enter the existing admin clientname: [chef-webui]"))
-    @knife.admin_client_name.should_not == 'chef-webui'
+    @out.string.should_not match(Regexp.escape("Please enter the existing admin: [admin]"))
+    @knife.admin_client_name.should_not == 'admin'
   end
 
   it "asks the user for the location of the existing admin key if -i is specified" do
     @knife.config[:initial] = true
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape("Please enter the location of the existing admin client's private key: [/etc/chef/webui.pem]"))
+    @out.string.should match(Regexp.escape("Please enter the location of the existing admin's private key: [#{default_admin_key}]"))
     if windows?
-      @knife.admin_client_key.capitalize.should == 'C:/etc/chef/webui.pem'
+      @knife.admin_client_key.capitalize.should == default_admin_key_win32.capitalize
     else
-      @knife.admin_client_key.should == '/etc/chef/webui.pem'
+      @knife.admin_client_key.should == default_admin_key
     end
   end
 
@@ -99,7 +115,7 @@ describe Chef::Knife::Configure do
     @knife.ask_user_for_config
     @out.string.should_not match(Regexp.escape("Please enter the location of the existing admin client's private key:"))
     if windows?
-      @knife.admin_client_key.capitalize.should == 'C:/home/you/.chef/my-webui.pem'
+      @knife.admin_client_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-webui\.pem$}
     else
       @knife.admin_client_key.should == '/home/you/.chef/my-webui.pem'
     end
@@ -107,11 +123,11 @@ describe Chef::Knife::Configure do
 
   it "should not ask the user for the location of the existing admin key if -i is not specified" do
     @knife.ask_user_for_config
-    @out.string.should_not match(Regexp.escape("Please enter the location of the existing admin client's private key: [/etc/chef/webui.pem]"))
+    @out.string.should_not match(Regexp.escape("Please enter the location of the existing admin client's private key: [#{default_admin_key}]"))
     if windows?
-      @knife.admin_client_key.should_not == 'C:/etc//chef/webui.pem'
+      @knife.admin_client_key.should_not == default_admin_key_win32
     else
-      @knife.admin_client_key.should_not == '/etc/chef/webui.pem' 
+      @knife.admin_client_key.should_not == default_admin_key
     end
   end
 
@@ -136,11 +152,11 @@ describe Chef::Knife::Configure do
 
   it "asks the users for the location of the validation key" do
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape("Please enter the location of the validation key: [/etc/chef/validation.pem]"))
+    @out.string.should match(Regexp.escape("Please enter the location of the validation key: [#{default_validator_key}]"))
     if windows?
-      @knife.validation_key.capitalize.should == 'C:/etc/chef/validation.pem'
+      @knife.validation_key.capitalize.should == default_validator_key_win32.capitalize
     else
-      @knife.validation_key.should == '/etc/chef/validation.pem' 
+      @knife.validation_key.should == default_validator_key
     end
   end
 
@@ -149,7 +165,7 @@ describe Chef::Knife::Configure do
     @knife.ask_user_for_config
     @out.string.should_not match(Regexp.escape("Please enter the location of the validation key:"))
     if windows?
-      @knife.validation_key.capitalize.should == 'C:/home/you/.chef/my-validation.pem'
+      @knife.validation_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-validation\.pem$}
     else
       @knife.validation_key.should == '/home/you/.chef/my-validation.pem'
     end
@@ -174,9 +190,9 @@ describe Chef::Knife::Configure do
     @knife.chef_server.should == 'http://localhost:5000'
     @knife.admin_client_name.should == 'my-webui'
     if windows?
-      @knife.admin_client_key.capitalize.should == 'C:/home/you/.chef/my-webui.pem'
-      @knife.validation_key.capitalize.should == 'C:/home/you/.chef/my-validation.pem'
-      @knife.new_client_key.capitalize.should == 'C:/home/you/a-new-user.pem'
+      @knife.admin_client_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-webui\.pem$}
+      @knife.validation_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-validation\.pem$}
+      @knife.new_client_key.should match %r{^[A-Za-z]:/home/you/a-new-user\.pem$}
     else
       @knife.admin_client_key.should == '/home/you/.chef/my-webui.pem'
       @knife.validation_key.should == '/home/you/.chef/my-validation.pem'
@@ -189,8 +205,8 @@ describe Chef::Knife::Configure do
   it "writes the new data to a config file" do
     File.stub!(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb")
     File.stub!(:expand_path).with("/home/you/.chef/#{Etc.getlogin}.pem").and_return("/home/you/.chef/#{Etc.getlogin}.pem")
-    File.stub!(:expand_path).with("/etc/chef/validation.pem").and_return("/etc/chef/validation.pem")
-    File.stub!(:expand_path).with("/etc/chef/webui.pem").and_return("/etc/chef/webui.pem")
+    File.stub!(:expand_path).with(default_validator_key).and_return(default_validator_key)
+    File.stub!(:expand_path).with(default_admin_key).and_return(default_admin_key)
     FileUtils.should_receive(:mkdir_p).with("/home/you/.chef")
     config_file = StringIO.new
     ::File.should_receive(:open).with("/home/you/.chef/knife.rb", "w").and_yield config_file
@@ -199,31 +215,34 @@ describe Chef::Knife::Configure do
     config_file.string.should match(/^node_name[\s]+'#{Etc.getlogin}'$/)
     config_file.string.should match(%r{^client_key[\s]+'/home/you/.chef/#{Etc.getlogin}.pem'$})
     config_file.string.should match(/^validation_client_name\s+'chef-validator'$/)
-    config_file.string.should match(%r{^validation_key\s+'/etc/chef/validation.pem'$})
-    config_file.string.should match(%r{^chef_server_url\s+'http://foo.example.org:4000'$})
+    config_file.string.should match(%r{^validation_key\s+'#{default_validator_key}'$})
+    config_file.string.should match(%r{^chef_server_url\s+'#{default_server_url}'$})
     config_file.string.should match(%r{cookbook_path\s+\[ '/home/you/chef-repo/cookbooks' \]})
   end
 
   it "creates a new client when given the --initial option" do
-    File.stub!(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb")
-    File.stub!(:expand_path).with("/home/you/.chef/a-new-user.pem").and_return("/home/you/.chef/a-new-user.pem")
-    File.stub!(:expand_path).with("/etc/chef/validation.pem").and_return("/etc/chef/validation.pem")
-    File.stub!(:expand_path).with("/etc/chef/webui.pem").and_return("/etc/chef/webui.pem")
+    File.should_receive(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb")
+    File.should_receive(:expand_path).with("/home/you/.chef/a-new-user.pem").and_return("/home/you/.chef/a-new-user.pem")
+    File.should_receive(:expand_path).with(default_validator_key).and_return(default_validator_key)
+    File.should_receive(:expand_path).with(default_admin_key).and_return(default_admin_key)
     Chef::Config[:node_name]  = "webmonkey.example.com"
-    client_command = Chef::Knife::ClientCreate.new
-    client_command.should_receive(:run)
+
+    user_command = Chef::Knife::UserCreate.new
+    user_command.should_receive(:run)
 
     Etc.stub!(:getlogin).and_return("a-new-user")
 
-    Chef::Knife::ClientCreate.stub!(:new).and_return(client_command)
+    Chef::Knife::UserCreate.stub!(:new).and_return(user_command)
     FileUtils.should_receive(:mkdir_p).with("/home/you/.chef")
     ::File.should_receive(:open).with("/home/you/.chef/knife.rb", "w")
     @knife.config[:initial] = true
+    @knife.config[:user_password] = "blah"
     @knife.run
-    client_command.name_args.should == Array("a-new-user")
-    client_command.config[:admin].should be_true
-    client_command.config[:file].should == "/home/you/.chef/a-new-user.pem"
-    client_command.config[:yes].should be_true
-    client_command.config[:disable_editing].should be_true
+    user_command.name_args.should == Array("a-new-user")
+    user_command.config[:user_password].should == "blah"
+    user_command.config[:admin].should be_true
+    user_command.config[:file].should == "/home/you/.chef/a-new-user.pem"
+    user_command.config[:yes].should be_true
+    user_command.config[:disable_editing].should be_true
   end
 end

data/spec/unit/knife/cookbook_download_spec.rb

@@ -33,6 +33,13 @@ describe Chef::Knife::CookbookDownload do
       lambda { @knife.run }.should raise_error(SystemExit)
     end
 
+    it 'should exit with a fatal error when there is no cookbook on the server' do
+      @knife.name_args = ['foobar', nil]
+      @knife.should_receive(:determine_version).and_return(nil)
+      @knife.ui.should_receive(:fatal).with('No such cookbook found')
+      lambda { @knife.run }.should raise_error(SystemExit)
+    end
+
     describe 'with a cookbook name' do
       before(:each) do
         @knife.name_args = ['foobar']
@@ -136,6 +143,13 @@ describe Chef::Knife::CookbookDownload do
   end
 
   describe 'determine_version' do
+
+    it 'should return nil if there are no versions' do
+      @knife.should_receive(:available_versions).and_return(nil)
+      @knife.determine_version.should == nil
+      @knife.version.should == nil
+    end
+
     it 'should return and set the version if there is only one version' do
       @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0'])
       @knife.determine_version.should == '1.0.0'
@@ -143,7 +157,7 @@ describe Chef::Knife::CookbookDownload do
     end
 
     it 'should ask which version to download and return it if there is more than one' do
-      @knife.should_receive(:available_versions).and_return(['1.0.0', '2.0.0'])
+      @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0', '2.0.0'])
       @knife.should_receive(:ask_which_version).and_return('1.0.0')
       @knife.determine_version.should == '1.0.0'
     end
@@ -152,7 +166,7 @@ describe Chef::Knife::CookbookDownload do
       it 'should return and set the version to the latest version' do
         @knife.config[:latest] = true
         @knife.should_receive(:available_versions).at_least(:once).
-                                                   and_return(['1.0.0', '2.0.0', '1.1.0'])
+                                                   and_return(['1.0.0', '1.1.0', '2.0.0'])
         @knife.determine_version
         @knife.version.to_s.should == '2.0.0'
       end
@@ -164,7 +178,14 @@ describe Chef::Knife::CookbookDownload do
       @knife.cookbook_name = 'foobar'
     end
 
-    it 'should return the available vesions' do
+    it 'should return nil if there are no versions' do
+      Chef::CookbookVersion.should_receive(:available_versions).
+                            with('foobar').
+                            and_return(nil)
+      @knife.available_versions.should == nil
+    end
+
+    it 'should return the available versions' do
       Chef::CookbookVersion.should_receive(:available_versions).
                             with('foobar').
                             and_return(['1.1.0', '2.0.0', '1.0.0'])

data/spec/unit/knife/cookbook_metadata_spec.rb

@@ -51,22 +51,29 @@ describe Chef::Knife::CookbookMetadata do
     describe 'with -a or --all' do
       before(:each) do
         @knife.config[:all] = true
+        @foo = Chef::CookbookVersion.new('foo')
+        @foo.version = '1.0.0'
+        @bar = Chef::CookbookVersion.new('bar')
+        @bar.version = '2.0.0'
+        @cookbook_loader = {
+          "foo" => @foo,
+          "bar" => @bar
+        }
+        @cookbook_loader.should_receive(:load_cookbooks).and_return(@cookbook_loader)
         @knife.should_receive(:generate_metadata).with('foo')
         @knife.should_receive(:generate_metadata).with('bar')
       end
 
       it 'should generate the metadata for each cookbook' do
         Chef::Config[:cookbook_path] = @cookbook_dir
-        Chef::CookbookLoader.should_receive(:new).with(@cookbook_dir).
-                                                  and_return({'foo' => '1.0.0', 'bar' => '2.0.0'})
+        Chef::CookbookLoader.should_receive(:new).with(@cookbook_dir).and_return(@cookbook_loader)
         @knife.run
       end
 
       describe 'and with -o or --cookbook-path' do
         it 'should look in the provided path and generate cookbook metadata' do
           @knife.config[:cookbook_path] = '/opt/chef/cookbooks'
-          Chef::CookbookLoader.should_receive(:new).with('/opt/chef/cookbooks').
-                                                    and_return({'foo' => '1.0.0', 'bar' => '2.0.0'})
+          Chef::CookbookLoader.should_receive(:new).with('/opt/chef/cookbooks').and_return(@cookbook_loader)
           @knife.run
         end
       end

data/spec/unit/knife/cookbook_test_spec.rb

@@ -68,6 +68,7 @@ describe Chef::Knife::CookbookTest do
         @knife.stub!(:test_cookbook).and_return(true)
         @knife.config[:all] = true
         @loader = {}
+        @loader.stub!(:load_cookbooks).and_return(@loader)
         @cookbooks.each do |cookbook|
           @loader[cookbook.name] = cookbook
         end

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -32,6 +32,7 @@ describe Chef::Knife::CookbookUpload do
     @cookbook_loader = {}
     @cookbook_loader.stub!(:[]).and_return(@cookbook)
     @cookbook_loader.stub!(:merged_cookbooks).and_return([])
+    @cookbook_loader.stub!(:load_cookbooks).and_return(@cookbook_loader)
     Chef::CookbookLoader.stub!(:new).and_return(@cookbook_loader)
 
     @output = StringIO.new
@@ -66,6 +67,44 @@ describe Chef::Knife::CookbookUpload do
       end
     end
 
+    describe 'when specifying the same cookbook name twice' do
+      it 'should upload the cookbook only once' do
+        @knife.name_args = ['test_cookbook', 'test_cookbook']
+        @knife.should_receive(:upload).once
+        @knife.run
+      end
+    end
+
+    describe 'when specifying a cookbook name among many' do
+      before(:each) do
+        @knife.name_args = ['test_cookbook1']
+        @cookbooks = {
+          'test_cookbook1' => Chef::CookbookVersion.new('test_cookbook1'),
+          'test_cookbook2' => Chef::CookbookVersion.new('test_cookbook2'),
+          'test_cookbook3' => Chef::CookbookVersion.new('test_cookbook3')
+        }
+        @cookbook_loader = {}
+        @cookbook_loader.stub!(:merged_cookbooks).and_return([])
+        @cookbook_loader.stub(:[]) { |ckbk| @cookbooks[ckbk] }
+        Chef::CookbookLoader.stub!(:new).and_return(@cookbook_loader)
+      end
+
+      it "should read only one cookbook" do
+        @cookbook_loader.should_receive(:[]).once.with('test_cookbook1')
+        @knife.run
+      end
+
+      it "should not read all cookbooks" do
+        @cookbook_loader.should_not_receive(:load_cookbooks)
+        @knife.run
+      end
+
+      it "should upload only one cookbook" do
+        @knife.should_receive(:upload).exactly(1).times
+        @knife.run
+      end
+    end
+
     # This is testing too much.  We should break it up.
     describe 'when specifying a cookbook name with dependencies' do
       it "should upload all dependencies once" do

data/spec/unit/knife/core/bootstrap_context_spec.rb

@@ -20,116 +20,133 @@ require 'spec_helper'
 require 'chef/knife/core/bootstrap_context'
 
 describe Chef::Knife::Core::BootstrapContext do
-  before do
-    @config = {:foo => :bar}
-    @run_list = Chef::RunList.new('recipe[tmux]', 'role[base]')
-    @chef_config = {:validation_key => File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem')}
-    @chef_config[:chef_server_url] = 'http://chef.example.com:4444'
-    @chef_config[:validation_client_name] = 'chef-validator-testing'
-    @context = Chef::Knife::Core::BootstrapContext.new(@config, @run_list, @chef_config)
+  let(:config) { {:foo => :bar} }
+  let(:run_list) { Chef::RunList.new('recipe[tmux]', 'role[base]') }
+  let(:chef_config) do
+    {
+      :validation_key => File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'),
+      :chef_server_url => 'http://chef.example.com:4444',
+      :validation_client_name => 'chef-validator-testing'
+    }
   end
+  let(:secret_file) { File.join(CHEF_SPEC_DATA, 'bootstrap', 'encrypted_data_bag_secret') }
 
-  describe "to support compatability with existing templates" do
-    it "sets the @config instance variable" do
-      @context.instance_eval { @config }.should == {:foo => :bar}
-    end
-
-    it "sets the @run_list instance variable" do
-      @context.instance_eval { @run_list }.should equal(@run_list)
-    end
-  end
+  subject(:bootstrap_context) { described_class.new(config, run_list, chef_config) }
 
   it "installs the same version of chef on the remote host" do
-    @context.bootstrap_version_string.should == "--version #{Chef::VERSION}"
+    bootstrap_context.bootstrap_version_string.should eq "--version #{Chef::VERSION}"
   end
 
   it "runs chef with the first-boot.json in the _default environment" do
-    @context.start_chef.should == "chef-client -j /etc/chef/first-boot.json -E _default"
-  end
-
-  it "it runs chef-client from another path when specified" do
-    @chef_config[:chef_client_path] = '/usr/local/bin/chef-client'
-    @context.start_chef.should == "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default"
+    bootstrap_context.start_chef.should eq "chef-client -j /etc/chef/first-boot.json -E _default"
   end
 
   it "reads the validation key" do
-    @context.validation_key.should == IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'))
-  end
-
-  it "reads the validation key when it contains a ~" do
-    IO.should_receive(:read).with(File.expand_path("my.key", ENV['HOME']))
-    @chef_config = {:validation_key => '~/my.key'}
-    @context = Chef::Knife::Core::BootstrapContext.new(@config, @run_list, @chef_config)
-    @context.validation_key
+    bootstrap_context.validation_key.should eq IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'))
   end
 
   it "generates the config file data" do
     expected=<<-EXPECTED
-log_level        :info
+log_level        :auto
 log_location     STDOUT
 chef_server_url  "http://chef.example.com:4444"
 validation_client_name "chef-validator-testing"
 # Using default node name (fqdn)
 EXPECTED
-    @context.config_content.should == expected
+    bootstrap_context.config_content.should eq expected
   end
 
-  describe "when an explicit node name is given" do
-    before do
-      @config[:chef_node_name] = 'foobar.example.com'
+  describe "alternate chef-client path" do
+    let(:chef_config){ {:chef_client_path => '/usr/local/bin/chef-client'} }
+    it "runs chef-client from another path when specified" do
+      bootstrap_context.start_chef.should eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default"
     end
-    it "sets the node name in the client.rb" do
-      @context.config_content.should match(/node_name "foobar\.example\.com"/)
+  end
+
+  describe "validation key path that contains a ~" do
+    let(:chef_config){ {:validation_key => '~/my.key'} }
+    it "reads the validation key when it contains a ~" do
+      IO.should_receive(:read).with(File.expand_path("my.key", ENV['HOME']))
+      bootstrap_context.validation_key
     end
   end
 
-  describe "when bootstrapping into a specific environment" do
-    before do
-      @chef_config[:environment] = "prodtastic"
+  describe "when an explicit node name is given" do
+    let(:config){ {:chef_node_name => 'foobar.example.com' }}
+    it "sets the node name in the client.rb" do
+      bootstrap_context.config_content.should match(/node_name "foobar\.example\.com"/)
     end
+  end
 
+  describe "when bootstrapping into a specific environment" do
+    let(:chef_config){ {:environment => "prodtastic"} }
     it "starts chef in the configured environment" do
-      @context.start_chef.should == 'chef-client -j /etc/chef/first-boot.json -E prodtastic'
+      bootstrap_context.start_chef.should == 'chef-client -j /etc/chef/first-boot.json -E prodtastic'
     end
   end
 
   describe "when installing a prerelease version of chef" do
-    before do
-      @config[:prerelease] = true
-    end
+    let(:config){ {:prerelease => true }}
     it "supplies --prerelease as the version string" do
-      @context.bootstrap_version_string.should == '--prerelease'
+      bootstrap_context.bootstrap_version_string.should eq '--prerelease'
     end
   end
 
   describe "when installing an explicit version of chef" do
-    before do
-      @context = Chef::Knife::Core::BootstrapContext.new(@config, @run_list, :knife => { :bootstrap_version => '123.45.678' })
+    let(:chef_config) do
+      {
+        :knife => { :bootstrap_version => '123.45.678' }
+      }
     end
-
     it "gives --version $VERSION as the version string" do
-      @context.bootstrap_version_string.should == '--version 123.45.678'
+      bootstrap_context.bootstrap_version_string.should eq '--version 123.45.678'
     end
   end
-  
-  describe "when JSON attributes are given" do
-    before do
-      conf = @config.dup
-      conf[:first_boot_attributes] = {:baz => :quux}
-      @context = Chef::Knife::Core::BootstrapContext.new(conf, @run_list, @chef_config)
-    end
 
+  describe "when JSON attributes are given" do
+    let(:config) { {:first_boot_attributes => {:baz => :quux}} }
     it "adds the attributes to first_boot" do
-      @context.first_boot.to_json.should == {:baz => :quux, :run_list => @run_list}.to_json
+      bootstrap_context.first_boot.to_json.should eq({:baz => :quux, :run_list => run_list}.to_json)
     end
   end
-  
+
   describe "when JSON attributes are NOT given" do
     it "sets first_boot equal to run_list" do
-      @context.first_boot.to_json.should == {:run_list => @run_list}.to_json
+      bootstrap_context.first_boot.to_json.should eq({:run_list => run_list}.to_json)
+    end
+  end
+
+  describe "when an encrypted_data_bag_secret is provided" do
+    context "via config[:secret]" do
+      let(:config){ {:secret => "supersekret" }}
+      it "reads the encrypted_data_bag_secret" do
+        bootstrap_context.encrypted_data_bag_secret.should eq "supersekret"
+      end
+    end
+
+    context "via config[:secret_file]" do
+      let(:config){ {:secret_file =>  secret_file}}
+      it "reads the encrypted_data_bag_secret" do
+        bootstrap_context.encrypted_data_bag_secret.should eq IO.read(secret_file)
+      end
+    end
+  end
+
+  describe "to support compatibility with existing templates" do
+    it "sets the @config instance variable" do
+      bootstrap_context.instance_variable_get(:@config).should eq config
+    end
+
+    it "sets the @run_list instance variable" do
+      bootstrap_context.instance_variable_get(:@run_list).should eq run_list
+    end
+
+    describe "accepts encrypted_data_bag_secret via Chef::Config" do
+      let(:chef_config) { {:encrypted_data_bag_secret => secret_file }}
+      it "reads the encrypted_data_bag_secret" do
+        bootstrap_context.encrypted_data_bag_secret.should eq IO.read(secret_file)
+      end
     end
   end
-  
-  
 end