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

data/spec/functional/dsl/registry_helper_spec.rb

@@ -0,0 +1,63 @@
+#
+# Author:: Prajakta Purohit (<prajakta@opscode.com>)
+# Copyright:: Copyright (c) 2011 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 "chef/dsl/registry_helper"
+require "spec_helper"
+
+describe Chef::Resource::RegistryKey, :windows_only do
+
+  before (:all) do
+    ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root"
+    ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\Branch"
+    ::Win32::Registry::HKEY_CURRENT_USER.open('Software\\Root', Win32::Registry::KEY_ALL_ACCESS) do |reg|
+      reg['RootType1', Win32::Registry::REG_SZ] = 'fibrous'
+      reg.write('Roots', Win32::Registry::REG_MULTI_SZ, ["strong roots", "healthy tree"])
+    end
+
+    events = Chef::EventDispatch::Dispatcher.new
+    node = Chef::Node.new
+    ohai = Ohai::System.new
+    ohai.all_plugins
+    node.consume_external_attrs(ohai.data,{})
+    run_context = Chef::RunContext.new(node, {}, events)
+    @resource = Chef::Resource.new("foo", run_context)
+  end
+
+  context "tests registry dsl" do
+    it "returns true if registry_key_exists" do
+      @resource.registry_key_exists?("HKCU\\Software\\Root").should == true
+    end
+    it "returns true if registry has specified value" do
+      values = @resource.registry_get_values("HKCU\\Software\\Root")
+      values.include?({:name=>"RootType1",:type=>:string,:data=>"fibrous"}).should == true
+    end
+    it "returns true if specified registry_has_subkey" do
+      @resource.registry_has_subkeys?("HKCU\\Software\\Root").should == true
+    end
+    it "returns true if specified key has specified subkey" do
+      subkeys = @resource.registry_get_subkeys("HKCU\\Software\\Root")
+      subkeys.include?("Branch").should == true
+    end
+    it "returns true if registry_value_exists" do
+      @resource.registry_value_exists?("HKCU\\Software\\Root", {:name=>"RootType1", :type=>:string, :data=>"fibrous"}).should == true
+    end
+    it "returns true if data_value_exists" do
+      @resource.registry_data_exists?("HKCU\\Software\\Root", {:name=>"RootType1", :type=>:string, :data=>"fibrous"}).should == true
+    end
+  end
+end

data/spec/functional/file_content_management/deploy_strategies_spec.rb

@@ -0,0 +1,238 @@
+#
+# 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'
+
+shared_examples_for "a content deploy strategy" do
+
+  # Ruby 1.8 has no binread
+  def binread(file)
+    if IO.respond_to?(:binread)
+      IO.binread(file)
+    else
+      IO.read(file)
+    end
+  end
+
+  def normalize_mode(mode_int)
+    ( mode_int & 07777).to_s(8)
+  end
+
+  let(:sandbox_dir) do
+    basename = make_tmpname("content-deploy-tests")
+    full_path = File.join(CHEF_SPEC_DATA, basename)
+    FileUtils.mkdir_p(full_path)
+    full_path
+  end
+
+  after do
+    FileUtils.rm_rf(sandbox_dir) if File.exist?(sandbox_dir)
+  end
+
+  let(:content_deployer) { described_class.new }
+  let(:target_file_path) { File.join(sandbox_dir, "cp-deploy-strategy-target-file.txt") }
+
+
+  describe "creating the file" do
+
+    ##
+    # UNIX Context
+    let(:default_mode) { normalize_mode(0100666 - File.umask) }
+
+    it "touches the file to create it (UNIX)", :unix_only do
+      content_deployer.create(target_file_path)
+      File.should exist(target_file_path)
+      file_info = File.stat(target_file_path)
+      file_info.should be_owned
+      file_info.should be_file
+      normalize_mode(file_info.mode).should == default_mode
+    end
+
+    ##
+    # Window Context
+    let(:parent_dir) { File.dirname(target_file_path) }
+
+    let(:parent_security_descriptor) do
+      security_obj = Chef::ReservedNames::Win32::Security::SecurableObject.new(parent_dir)
+      security_obj.security_descriptor(true)
+    end
+
+    let(:masks) do
+      Chef::ReservedNames::Win32::API::Security
+    end
+
+    def ace_inherits?(ace)
+      flags = ace.flags
+      (flags & masks::OBJECT_INHERIT_ACE) !=0
+    end
+
+    let(:parent_inheritable_aces) do
+      inheritable_aces = parent_security_descriptor.dacl.select do |ace|
+        ace_inherits?(ace)
+      end
+    end
+
+    # Win2003 has annoying differences in ACL inheritance behavior that make
+    # the default ACLs substantially different from those created on subsequent
+    # windows versions. The behaviors here are also covered by resource-level
+    # tests so we'll skip win2k3 here to keep the tests simple.
+    it "touches the file to create it (Windows)", :windows_only, :not_supported_on_win2k3 do
+      content_deployer.create(target_file_path)
+      File.should exist(target_file_path)
+      file_info = File.stat(target_file_path)
+      file_info.should be_owned
+      file_info.should be_file
+
+      parent_aces = parent_inheritable_aces
+      security_obj = Chef::ReservedNames::Win32::Security::SecurableObject.new(target_file_path)
+
+      security_descriptor = security_obj.security_descriptor(true)
+      security_descriptor.dacl.each_with_index do |ace, index|
+        ace.inherited?.should be_true
+        ace.mask.should == parent_aces[index].mask
+      end
+
+    end
+  end
+
+  describe "updating the file" do
+
+    let(:staging_dir) { Dir.mktmpdir }
+
+    let(:staging_file_content) { "this is the expected content" }
+
+    let(:staging_file_path) do
+      path = File.join(staging_dir, "cp-deploy-strategy-staging-file.txt")
+      File.open(path, "w+", 0600) { |f| f.print(staging_file_content) }
+      path
+    end
+
+    def unix_invariant_properies(stat_struct)
+      unix_invariants.inject({}) do |property_map, property|
+        property_map[property] = stat_struct.send(property)
+        property_map
+      end
+    end
+
+    def win_invariant_properties(sec_obj)
+      descriptor = sec_obj.security_descriptor(true)
+      security_descriptor_invariants.inject({}) do |prop_map, property|
+        prop_map[property] = descriptor.send(property)
+        prop_map
+       end
+    end
+
+    before do
+      content_deployer.create(target_file_path)
+    end
+
+    it "maintains invariant properties on UNIX", :unix_only do
+      original_info = File.stat(target_file_path)
+      content_deployer.deploy(staging_file_path, target_file_path)
+      updated_info = File.stat(target_file_path)
+
+      unix_invariant_properies(original_info).should == unix_invariant_properies(updated_info)
+    end
+
+    it "maintains invariant properties on Windows", :windows_only do
+      original_info = Chef::ReservedNames::Win32::Security::SecurableObject.new(target_file_path)
+      content_deployer.deploy(staging_file_path, target_file_path)
+      updated_info = Chef::ReservedNames::Win32::Security::SecurableObject.new(target_file_path)
+
+      win_invariant_properties(original_info).should == win_invariant_properties(updated_info)
+    end
+
+    it "updates the target with content from staged" do
+      content_deployer.deploy(staging_file_path, target_file_path)
+      binread(target_file_path).should == staging_file_content
+    end
+
+    context "when the owner of the target file is not the owner of the staging file", :requires_root do
+
+      before do
+        File.chown(1337, 1337, target_file_path)
+      end
+
+      it "copies the staging file's content" do
+        original_info = File.stat(target_file_path)
+        content_deployer.deploy(staging_file_path, target_file_path)
+        updated_info = File.stat(target_file_path)
+
+        unix_invariant_properies(original_info).should == unix_invariant_properies(updated_info)
+      end
+
+    end
+
+  end
+end
+
+describe Chef::FileContentManagement::Deploy::Cp do
+
+  let(:unix_invariants) do
+    [
+      :uid,
+      :gid,
+      :mode,
+      :ino
+    ]
+  end
+
+  let(:security_descriptor_invariants) do
+    [
+      :owner,
+      :group,
+      :dacl
+    ]
+  end
+
+  it_should_behave_like "a content deploy strategy"
+
+end
+
+describe Chef::FileContentManagement::Deploy::MvUnix, :unix_only do
+
+  let(:unix_invariants) do
+    [
+      :uid,
+      :gid,
+      :mode
+    ]
+  end
+
+  it_should_behave_like "a content deploy strategy"
+end
+
+# On Unix we won't have loaded the file, avoid undefined constant errors:
+class Chef::FileContentManagement::Deploy::MvWindows ; end
+
+describe Chef::FileContentManagement::Deploy::MvWindows, :windows_only do
+
+  context "when a file has no sacl" do
+
+    let(:security_descriptor_invariants) do
+      [
+       :owner,
+       :group,
+       :dacl
+      ]
+    end
+
+    it_should_behave_like "a content deploy strategy"
+  end
+
+end

data/spec/functional/knife/cookbook_delete_spec.rb

@@ -42,7 +42,7 @@ describe Chef::Knife::CookbookDelete do
     @server.stop
   end
 
-  context "when the cookbook doesn't exist" do
+  context "when the the cookbook doesn't exist" do
     before do
       @log_output = StringIO.new
 

data/spec/functional/knife/exec_spec.rb

@@ -44,14 +44,14 @@ describe Chef::Knife::Exec do
     @server.stop
   end
 
-  pending "executes a script in the context of the shef main context", :ruby_18_only
+  pending "executes a script in the context of the chef-shell main context", :ruby_18_only
 
-  it "executes a script in the context of the shef main context", :ruby_19_only do
+  it "executes a script in the context of the chef-shell main context", :ruby_gte_19_only do
     @node = Chef::Node.new
     @node.name("ohai-world")
     response = {"rows" => [@node],"start" => 0,"total" => 1}
     @api.get(%r{^/search/node}, 200, response.to_json)
-    code = "$output.puts nodes.all.inspect"
+    code = "$output.puts nodes.all"
     @knife.config[:exec] = code
     @knife.run
     $output.string.should match(%r{node\[ohai-world\]})

data/spec/functional/knife/smoke_test.rb

@@ -0,0 +1,34 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 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'
+
+describe "knife smoke tests" do
+
+  # Since our specs load all code, there could be a case where knife does not
+  # run correctly b/c of a missing require, but is not caught by other tests.
+  #
+  # We run `knife -v` to verify that knife at least loads all its code.
+  it "can run and print its version" do
+    knife_path = File.expand_path("../../bin/knife", CHEF_SPEC_DATA)
+    knife_cmd = Mixlib::ShellOut.new("#{knife_path} -v")
+    knife_cmd.run_command
+    knife_cmd.error!
+    knife_cmd.stdout.should include(Chef::VERSION)
+  end
+end

data/spec/functional/knife/ssh_spec.rb

@@ -155,7 +155,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the default" do
         @knife.run
-        @knife.config[:ssh_user].should == nil
+        @knife.config[:ssh_user].should == "root"
       end
     end
   end
@@ -252,6 +252,10 @@ describe Chef::Knife::Ssh do
 
   def setup_knife(params=[])
     @knife = Chef::Knife::Ssh.new(params)
+    # We explicitly avoid running #configure_chef, which would read a knife.rb
+    # if available, but #merge_configs (which is called by #configure_chef) is
+    # necessary to have default options merged in.
+    @knife.merge_configs
     @knife.stub!(:ssh_command).and_return { 0 }
     @api = TinyServer::API.instance
     @api.clear

data/spec/functional/provider/remote_file/cache_control_data_spec.rb

@@ -0,0 +1,101 @@
+#
+# Author:: Adam Edwards (<adamed@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'
+require 'uri'
+
+describe Chef::Provider::RemoteFile::CacheControlData do
+
+  before do
+    @original_config = Chef::Config.hash_dup    
+  end
+
+  after do
+    Chef::Config.configuration = @original_config if @original_config    
+  end
+  
+  before(:each) do
+    Chef::Config[:file_cache_path] = Dir.mktmpdir
+  end
+
+  after(:each) do
+    FileUtils.rm_rf(Chef::Config[:file_cache_path])
+  end
+
+  let(:uri) { URI.parse("http://www.bing.com/robots.txt") }
+  
+  describe "when the cache control data save method is invoked" do
+
+    subject(:cache_control_data) do
+      Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
+    end
+
+    # the checksum of the file last we fetched it.
+    let(:file_checksum) { "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }
+
+    let(:etag) { "\"a-strong-identifier\"" }
+    let(:mtime) { "Thu, 01 Aug 2013 08:16:32 GMT" }
+
+    before do
+      cache_control_data.etag = etag
+      cache_control_data.mtime = mtime
+      cache_control_data.checksum = file_checksum
+    end
+
+    it "writes data to the cache" do
+      cache_control_data.save
+    end
+
+    it "writes the data to the cache and the same data can be read back" do
+      cache_control_data.save
+      saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
+      saved_cache_control_data.etag.should == cache_control_data.etag
+      saved_cache_control_data.mtime.should == cache_control_data.mtime
+      saved_cache_control_data.checksum.should == cache_control_data.checksum  
+    end
+
+    # Cover the very long remote file path case -- see CHEF-4422 where
+    # local cache file names generated from the long uri exceeded
+    # local file system path limits resulting in exceptions from
+    # file system API's on both Windows and Unix systems.
+    context "when the length of the uri exceeds the path length limits for the local file system" do
+      let(:uri_exceeds_file_system_limit) do
+        URI.parse("http://www.bing.com/" + ('0' * 1024))
+      end
+
+      let(:uri) { uri_exceeds_file_system_limit }
+
+      it "writes data to the cache" do
+        lambda do
+          cache_control_data.save
+        end.should_not raise_error
+      end
+
+      it "writes the data to the cache and the same data can be read back" do
+        cache_control_data.save
+        saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
+        saved_cache_control_data.etag.should == cache_control_data.etag
+        saved_cache_control_data.mtime.should == cache_control_data.mtime
+        saved_cache_control_data.checksum.should == cache_control_data.checksum  
+      end
+
+    end
+  end
+
+end
+