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

data/spec/unit/file_content_management/deploy/mv_windows_spec.rb

@@ -0,0 +1,179 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+unless Chef::Platform.windows?
+  class Chef
+    module ReservedNames
+      module Win32
+        module Security
+          ACL = Object.new
+          SecurableObject = Object.new
+        end
+      end
+    end
+  end
+end
+
+require 'chef/file_content_management/deploy/mv_windows'
+
+describe Chef::FileContentManagement::Deploy::MvWindows do
+
+  let(:content_deployer) { described_class.new }
+  let(:target_file_path) { "/etc/my_app.conf" }
+
+  describe "creating the file" do
+
+    it "touches the file to create it" do
+      FileUtils.should_receive(:touch).with(target_file_path)
+      content_deployer.create(target_file_path)
+    end
+  end
+
+  describe "updating the file" do
+
+    let(:staging_file_path) { "/tmp/random-dir/staging-file.tmp" }
+
+    let(:target_file_security_object) do
+      mock "Securable Object for target file"
+    end
+
+    let(:updated_target_security_object) do
+      mock "Securable Object for target file after staging file deploy"
+    end
+
+    before do
+      Chef::ReservedNames::Win32::Security::SecurableObject.
+        stub(:new).
+        with(target_file_path).
+        and_return(target_file_security_object, updated_target_security_object)
+
+    end
+
+    context "when run without adminstrator privileges" do
+      before do
+        target_file_security_object.should_receive(:security_descriptor).and_raise(Chef::Exceptions::Win32APIError)
+      end
+
+      it "errors out with a WindowsNotAdmin error" do
+        lambda { content_deployer.deploy(staging_file_path, target_file_path)}.should raise_error(Chef::Exceptions::WindowsNotAdmin)
+      end
+
+    end
+
+    context "when run with administrator privileges" do
+
+      let(:original_target_file_owner) { mock("original target file owner") }
+      let(:original_target_file_group) { mock("original target file group") }
+
+      let(:target_file_security_descriptor) do
+        mock "security descriptor for target file",
+             :group => original_target_file_group,
+             :owner => original_target_file_owner
+      end
+
+      let(:updated_target_security_descriptor) do
+        mock "security descriptor for target file"
+      end
+
+
+      before do
+        target_file_security_object.stub(:security_descriptor).and_return(target_file_security_descriptor)
+
+        FileUtils.should_receive(:mv).with(staging_file_path, target_file_path)
+
+        updated_target_security_object.should_receive(:group=).with(original_target_file_group)
+        updated_target_security_object.should_receive(:owner=).with(original_target_file_owner)
+      end
+
+      context "and the target file has no dacl or sacl" do
+
+        before do
+          target_file_security_descriptor.stub(:dacl_present?).and_return(false)
+          target_file_security_descriptor.stub(:sacl_present?).and_return(false)
+        end
+
+        it "fixes up permissions and moves the file into place" do
+          content_deployer.deploy(staging_file_path, target_file_path)
+        end
+
+      end
+
+      context "and the target has a dacl and sacl" do
+        let(:inherited_dacl_ace) { mock("Windows dacl ace (inherited)", :inherited? => true) }
+        let(:not_inherited_dacl_ace) { mock("Windows dacl ace (not inherited)", :inherited? => false) }
+
+        let(:original_target_file_dacl) { [inherited_dacl_ace, not_inherited_dacl_ace] }
+
+        let(:inherited_sacl_ace) { mock("Windows sacl ace (inherited)", :inherited? => true) }
+        let(:not_inherited_sacl_ace) { mock("Windows sacl ace (not inherited)", :inherited? => false) }
+        let(:original_target_file_sacl) { [inherited_sacl_ace, not_inherited_sacl_ace] }
+
+        let(:custom_dacl) { mock("Windows ACL for non-inherited dacl aces") }
+        let(:custom_sacl) { mock("Windows ACL for non-inherited sacl aces") }
+
+        before do
+          target_file_security_descriptor.stub(:dacl_present?).and_return(true)
+          target_file_security_descriptor.stub(:dacl_inherits?).and_return(dacl_inherits?)
+
+          target_file_security_descriptor.stub(:dacl).and_return(original_target_file_dacl)
+          Chef::ReservedNames::Win32::Security::ACL.
+            should_receive(:create).
+            with([not_inherited_dacl_ace]).
+            and_return(custom_dacl)
+
+          target_file_security_descriptor.stub(:sacl_present?).and_return(true)
+          target_file_security_descriptor.stub(:sacl_inherits?).and_return(sacl_inherits?)
+
+          target_file_security_descriptor.stub(:sacl).and_return(original_target_file_sacl)
+          Chef::ReservedNames::Win32::Security::ACL.
+            should_receive(:create).
+            with([not_inherited_sacl_ace]).
+            and_return(custom_sacl)
+
+          updated_target_security_object.should_receive(:set_dacl).with(custom_dacl, dacl_inherits?)
+          updated_target_security_object.should_receive(:set_sacl).with(custom_sacl, sacl_inherits?)
+        end
+
+        context "and the dacl and sacl don't inherit" do
+          let(:dacl_inherits?) { false }
+          let(:sacl_inherits?) { false }
+
+          it "fixes up permissions and moves the file into place" do
+            content_deployer.deploy(staging_file_path, target_file_path)
+          end
+        end
+
+        context "and the dacl and sacl inherit" do
+          let(:dacl_inherits?) { true }
+          let(:sacl_inherits?) { true }
+
+          it "fixes up permissions and moves the file into place" do
+            content_deployer.deploy(staging_file_path, target_file_path)
+          end
+        end
+
+      end
+
+    end
+
+  end
+end
+
+

data/spec/unit/formatters/error_inspectors/cookbook_resolve_error_inspector_spec.rb

@@ -24,8 +24,9 @@ describe Chef::Formatters::ErrorInspectors::CookbookResolveErrorInspector do
     @expanded_run_list = Chef::RunList.new("recipe[annoyances]", "recipe[apache2]", "recipe[users]", "recipe[chef::client]")
 
     @description = Chef::Formatters::ErrorDescription.new("Error Resolving Cookbooks for Run List:")
-    @outputter = Chef::Formatters::Outputter.new(StringIO.new, STDERR)
-    #@outputter = Chef::Formatters::Outputter.new(STDOUT, STDERR)
+    @outputter_output = StringIO.new
+    @outputter = Chef::Formatters::Outputter.new(@outputter_output, STDERR)
+    # @outputter = Chef::Formatters::Outputter.new(STDOUT, STDERR)
   end
 
   describe "when explaining a 403 error" do
@@ -63,6 +64,36 @@ describe Chef::Formatters::ErrorInspectors::CookbookResolveErrorInspector do
 
     it "prints a pretty message" do
       @description.display(@outputter)
+      @outputter_output.rewind
+      observed_output = @outputter_output.read
+      observed_output.should include("apache2")
+      observed_output.should include("users")
+      observed_output.should_not include("Run list contains invalid items: no such cookbook nope.")
+    end
+
+  end
+
+  describe "when explaining a PreconditionFailed (412) error with current error message style without cookbook details" do
+    # Chef currently returns error messages with some fields as JSON strings,
+    # which must be re-parsed to get the actual data.
+    # In some cases the error message doesn't contain any cookbook
+    # details. But we should still print a pretty error message.
+
+    before do
+
+      @response_body = "{\"error\":[{\"non_existent_cookbooks\":[],\"cookbooks_with_no_versions\":[],\"message\":\"unable to solve dependencies in alotted time.\"}]}"
+      @response = Net::HTTPPreconditionFailed.new("1.1", "412", "(response) unauthorized")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) precondition failed", @response)
+
+      @inspector = Chef::Formatters::ErrorInspectors::CookbookResolveErrorInspector.new(@expanded_run_list, @exception)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a pretty message" do
+      @description.display(@outputter)
+      @outputter_output.rewind
+      @outputter_output.read.should include("unable to solve dependencies in alotted time.")
     end
 
   end
@@ -84,6 +115,11 @@ describe Chef::Formatters::ErrorInspectors::CookbookResolveErrorInspector do
 
     it "prints a pretty message" do
       @description.display(@outputter)
+      @outputter_output.rewind
+      observed_output = @outputter_output.read
+      observed_output.should include("apache2")
+      observed_output.should include("users")
+      observed_output.should_not include("Run list contains invalid items: no such cookbook nope.")
     end
 
   end

data/spec/unit/formatters/error_inspectors/resource_failure_inspector_spec.rb

@@ -19,12 +19,12 @@
 require 'spec_helper'
 
 describe Chef::Formatters::ErrorInspectors::ResourceFailureInspector do
-  include Chef::Mixin::RecipeDefinitionDSLCore
+  include Chef::DSL::Recipe
 
   def run_context
     node = Chef::Node.new
-    node[:platform] = "ubuntu"
-    node[:platform_version] = "10.04"
+    node.automatic_attrs[:platform] = "ubuntu"
+    node.automatic_attrs[:platform_version] = "10.04"
     Chef::RunContext.new(node, {}, nil)
   end
 
@@ -83,14 +83,15 @@ describe Chef::Formatters::ErrorInspectors::ResourceFailureInspector do
         @description = Chef::Formatters::ErrorDescription.new("Error Converging Resource:")
         @template_class = Class.new { include Chef::Mixin::Template }
         @template = @template_class.new
-        @context = {:chef => "cool"}
+        @context = Chef::Mixin::Template::TemplateContext.new({})
+        @context[:chef] = "cool"
 
         @resource = template("/tmp/foo.txt") do
           mode "0644"
         end
 
         @error = begin
-                   @template.render_template("foo\nbar\nbaz\n<%= this_is_not_defined %>\nquin\nqunx\ndunno", @context) {|r| r}
+                   @context.render_template_from_string("foo\nbar\nbaz\n<%= this_is_not_defined %>\nquin\nqunx\ndunno")
                  rescue  Chef::Mixin::Template::TemplateError => e
                    e
                  end

data/spec/unit/json_compat_spec.rb

@@ -28,6 +28,14 @@ describe Chef::JSONCompat do
     end
   end
 
+  describe 'with JSON containing "Chef::Sandbox" as a json_class value' do
+    require 'chef/sandbox' # Only needed for this test
+    let(:json){'{"json_class": "Chef::Sandbox", "arbitrary": "data"}'}
+    it "returns a Hash, because Chef::Sandbox is a dummy class" do
+      Chef::JSONCompat.from_json(json).should eq({"json_class" => "Chef::Sandbox", "arbitrary" => "data"})
+    end
+  end
+
   describe "with a file with 300 or less nested entries" do
     before(:all) do
       @json = IO.read(File.join(CHEF_SPEC_DATA, 'big_json.json'))

data/spec/unit/knife/bootstrap_spec.rb

@@ -35,6 +35,8 @@ describe Chef::Knife::Bootstrap do
   before(:each) do
     Chef::Log.logger = Logger.new(StringIO.new)
     @knife = Chef::Knife::Bootstrap.new
+    # Merge default settings in.
+    @knife.merge_configs
     @knife.config[:template_file] = File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "test.erb"))
     @stdout = StringIO.new
     @knife.ui.stub!(:stdout).and_return(@stdout)
@@ -126,13 +128,65 @@ describe Chef::Knife::Bootstrap do
     @knife.render_template(template_string).should match /\{\"foo\":\"bar\"\}/
   end
 
-
   it "should take the node name from ARGV" do
     @knife.name_args = ['barf']
     @knife.name_args.first.should == "barf"
   end
 
-  describe "when configuring the underlying knife ssh command"
+  describe "specifying the encrypted data bag secret key" do
+    subject(:knife) { described_class.new }
+    let(:secret) { "supersekret" }
+    let(:secret_file) { File.join(CHEF_SPEC_DATA, 'bootstrap', 'encrypted_data_bag_secret') }
+    let(:options) { [] }
+    let(:template_file) { File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "secret.erb")) }
+    let(:rendered_template) do
+      knife.instance_variable_set("@template_file", template_file)
+      knife.parse_options(options)
+      template_string = knife.read_template
+      knife.render_template(template_string)
+    end
+
+    context "via --secret" do
+      let(:options){ ["--secret", secret] }
+
+      it "creates a secret file" do
+        rendered_template.should match(%r{#{secret}})
+      end
+
+      it "renders the client.rb with an encrypted_data_bag_secret entry" do
+        rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
+      end
+    end
+
+    context "via --secret-file" do
+      let(:options) { ["--secret-file", secret_file] }
+      let(:secret) { IO.read(secret_file) }
+
+      it "creates a secret file" do
+        rendered_template.should match(%r{#{secret}})
+      end
+
+      it "renders the client.rb with an encrypted_data_bag_secret entry" do
+        rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
+      end
+    end
+
+    context "via Chef::Config[:encrypted_data_bag_secret]" do
+      before(:each) { Chef::Config[:encrypted_data_bag_secret] = secret_file }
+      let(:secret) { IO.read(secret_file) }
+
+      it "creates a secret file" do
+        rendered_template.should match(%r{#{secret}})
+      end
+
+      it "renders the client.rb with an encrypted_data_bag_secret entry" do
+        rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"})
+      end
+      after(:each) { Chef::Config.configuration = @original_config }
+    end
+  end
+
+  describe "when configuring the underlying knife ssh command" do
     context "from the command line" do
       before do
         @knife.name_args = ["foo.example.com"]
@@ -141,61 +195,96 @@ describe Chef::Knife::Bootstrap do
         @knife.config[:ssh_password]  = "open_sesame"
         Chef::Config[:knife][:ssh_user] = nil
         Chef::Config[:knife][:ssh_port] = nil
+        @knife.config[:forward_agent] = true
         @knife.config[:identity_file] = "~/.ssh/me.rsa"
         @knife.stub!(:read_template).and_return("")
         @knife_ssh = @knife.knife_ssh
       end
-  
+
       it "configures the hostname" do
         @knife_ssh.name_args.first.should == "foo.example.com"
       end
-  
+
       it "configures the ssh user" do
         @knife_ssh.config[:ssh_user].should == 'rooty'
       end
-  
+
       it "configures the ssh password" do
         @knife_ssh.config[:ssh_password].should == 'open_sesame'
       end
-  
+
       it "configures the ssh port" do
         @knife_ssh.config[:ssh_port].should == '4001'
       end
   
+      it "configures the ssh agent forwarding" do
+        @knife_ssh.config[:forward_agent].should == true
+      end
+
       it "configures the ssh identity file" do
         @knife_ssh.config[:identity_file].should == '~/.ssh/me.rsa'
       end
     end
+    context "validating use_sudo_password" do
+      before do
+        @knife.config[:distro] = "ubuntu"
+        @knife.config[:ssh_password] = "password"
+        @knife.stub(:read_template).and_return(IO.read(@knife.find_template).chomp)
+      end
+
+      it "use_sudo_password contains description and long params for help" do
+        @knife.options.should have_key(:use_sudo_password) \
+          and @knife.options[:use_sudo_password][:description].to_s.should_not == ''\
+          and @knife.options[:use_sudo_password][:long].to_s.should_not == ''
+      end
 
+      it "uses the password from --ssh-password for sudo when --use-sudo-password is set" do
+        @knife.config[:use_sudo] = true
+        @knife.config[:use_sudo_password] = true
+        @knife.ssh_command.should include("echo #{@knife.config[:ssh_password]} | sudo -S")
+      end
+
+      it "should not honor --use-sudo-password when --use-sudo is not set" do
+        @knife.config[:use_sudo] = false
+        @knife.config[:use_sudo_password] = true
+        @knife.ssh_command.should_not include("echo #{@knife.config[:ssh_password]} | sudo -S")
+      end
+    end
     context "from the knife config file" do
       before do
         @knife.name_args = ["config.example.com"]
         @knife.config[:ssh_user] = nil
         @knife.config[:ssh_port] = nil
         @knife.config[:ssh_gateway] = nil
+        @knife.config[:forward_agent] = nil
         @knife.config[:identity_file] = nil
         @knife.config[:host_key_verify] = nil
         Chef::Config[:knife][:ssh_user] = "curiosity"
         Chef::Config[:knife][:ssh_port] = "2430"
+        Chef::Config[:knife][:forward_agent] = true
         Chef::Config[:knife][:identity_file] = "~/.ssh/you.rsa"
         Chef::Config[:knife][:ssh_gateway] = "towel.blinkenlights.nl"
         Chef::Config[:knife][:host_key_verify] = true
         @knife.stub!(:read_template).and_return("")
         @knife_ssh = @knife.knife_ssh
       end
-  
+
       it "configures the ssh user" do
         @knife_ssh.config[:ssh_user].should == 'curiosity'
       end
-  
+
       it "configures the ssh port" do
         @knife_ssh.config[:ssh_port].should == '2430'
       end
   
+      it "configures the ssh agent forwarding" do
+        @knife_ssh.config[:forward_agent].should == true
+      end
+
       it "configures the ssh identity file" do
         @knife_ssh.config[:identity_file].should == '~/.ssh/you.rsa'
       end
-  
+
       it "configures the ssh gateway" do
         @knife_ssh.config[:ssh_gateway].should == 'towel.blinkenlights.nl'
       end
@@ -203,29 +292,30 @@ describe Chef::Knife::Bootstrap do
       it "configures the host key verify mode" do
         @knife_ssh.config[:host_key_verify].should == true
       end
-  end
-
-  describe "when falling back to password auth when host key auth fails" do
-    before do
-      @knife.name_args = ["foo.example.com"]
-      @knife.config[:ssh_user]      = "rooty"
-      @knife.config[:identity_file] = "~/.ssh/me.rsa"
-      @knife.stub!(:read_template).and_return("")
-      @knife_ssh = @knife.knife_ssh
     end
 
-    it "prompts the user for a password " do
-      @knife.stub!(:knife_ssh).and_return(@knife_ssh)
-      @knife_ssh.stub!(:get_password).and_return('typed_in_password')
-      alternate_knife_ssh = @knife.knife_ssh_with_password_auth
-      alternate_knife_ssh.config[:ssh_password].should == 'typed_in_password'
-    end
+    describe "when falling back to password auth when host key auth fails" do
+      before do
+        @knife.name_args = ["foo.example.com"]
+        @knife.config[:ssh_user]      = "rooty"
+        @knife.config[:identity_file] = "~/.ssh/me.rsa"
+        @knife.stub!(:read_template).and_return("")
+        @knife_ssh = @knife.knife_ssh
+      end
 
-    it "configures knife not to use the identity file that didn't work previously" do
-      @knife.stub!(:knife_ssh).and_return(@knife_ssh)
-      @knife_ssh.stub!(:get_password).and_return('typed_in_password')
-      alternate_knife_ssh = @knife.knife_ssh_with_password_auth
-      alternate_knife_ssh.config[:identity_file].should be_nil
+      it "prompts the user for a password " do
+        @knife.stub!(:knife_ssh).and_return(@knife_ssh)
+        @knife_ssh.stub!(:get_password).and_return('typed_in_password')
+        alternate_knife_ssh = @knife.knife_ssh_with_password_auth
+        alternate_knife_ssh.config[:ssh_password].should == 'typed_in_password'
+      end
+
+      it "configures knife not to use the identity file that didn't work previously" do
+        @knife.stub!(:knife_ssh).and_return(@knife_ssh)
+        @knife_ssh.stub!(:get_password).and_return('typed_in_password')
+        alternate_knife_ssh = @knife.knife_ssh_with_password_auth
+        alternate_knife_ssh.config[:identity_file].should be_nil
+      end
     end
   end
 
@@ -260,6 +350,17 @@ describe Chef::Knife::Bootstrap do
       @knife.run
     end
 
+    context "Chef::Config[:encrypted_data_bag_secret] is set" do
+      let(:secret_file) { File.join(CHEF_SPEC_DATA, 'bootstrap', 'encrypted_data_bag_secret') }
+      before { Chef::Config[:encrypted_data_bag_secret] = secret_file }
+
+      it "warns the configuration option is deprecated" do
+        @knife_ssh.should_receive(:run)
+        @knife.ui.should_receive(:warn).at_least(3).times
+        @knife.run
+      end
+    end
+
   end
 
 end