chef 10.12.0 → 10.14.0.beta.1

data/spec/unit/exceptions_spec.rb

@@ -0,0 +1,74 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2010 Thomas Bishop
+# 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 Chef::Exceptions do
+  exception_to_super_class = {
+    Chef::Exceptions::Application => RuntimeError,
+    Chef::Exceptions::Cron => RuntimeError,
+    Chef::Exceptions::Env => RuntimeError,
+    Chef::Exceptions::Exec => RuntimeError,
+    Chef::Exceptions::FileNotFound => RuntimeError,
+    Chef::Exceptions::Package => RuntimeError,
+    Chef::Exceptions::Service => RuntimeError,
+    Chef::Exceptions::Route => RuntimeError,
+    Chef::Exceptions::SearchIndex => RuntimeError,
+    Chef::Exceptions::Override => RuntimeError,
+    Chef::Exceptions::UnsupportedAction => RuntimeError,
+    Chef::Exceptions::MissingLibrary => RuntimeError,
+    Chef::Exceptions::MissingRole => RuntimeError,
+    Chef::Exceptions::CannotDetermineNodeName => RuntimeError,
+    Chef::Exceptions::User => RuntimeError,
+    Chef::Exceptions::Group => RuntimeError,
+    Chef::Exceptions::Link => RuntimeError,
+    Chef::Exceptions::Mount => RuntimeError,
+    Chef::Exceptions::CouchDBNotFound => RuntimeError,
+    Chef::Exceptions::PrivateKeyMissing => RuntimeError,
+    Chef::Exceptions::CannotWritePrivateKey => RuntimeError,
+    Chef::Exceptions::RoleNotFound => RuntimeError,
+    Chef::Exceptions::ValidationFailed => ArgumentError,
+    Chef::Exceptions::InvalidPrivateKey => ArgumentError,
+    Chef::Exceptions::ConfigurationError => ArgumentError,
+    Chef::Exceptions::RedirectLimitExceeded => RuntimeError,
+    Chef::Exceptions::AmbiguousRunlistSpecification => ArgumentError,
+    Chef::Exceptions::CookbookNotFound => RuntimeError,
+    Chef::Exceptions::AttributeNotFound => RuntimeError,
+    Chef::Exceptions::InvalidCommandOption => RuntimeError,
+    Chef::Exceptions::CommandTimeout => RuntimeError,
+    Mixlib::ShellOut::ShellCommandFailed => RuntimeError,
+    Chef::Exceptions::RequestedUIDUnavailable => RuntimeError,
+    Chef::Exceptions::InvalidHomeDirectory => ArgumentError,
+    Chef::Exceptions::DsclCommandFailed => RuntimeError,
+    Chef::Exceptions::UserIDNotFound => ArgumentError,
+    Chef::Exceptions::GroupIDNotFound => ArgumentError,
+    Chef::Exceptions::InvalidResourceReference => RuntimeError,
+    Chef::Exceptions::ResourceNotFound => RuntimeError,
+    Chef::Exceptions::InvalidResourceSpecification => ArgumentError,
+    Chef::Exceptions::SolrConnectionError => RuntimeError,
+    Chef::Exceptions::InvalidDataBagPath => ArgumentError
+  }
+
+  exception_to_super_class.each do |exception, expected_super_class|
+    it "should have an exception class of #{exception} which inherits from #{expected_super_class}" do
+      lambda{ raise exception }.should raise_error(expected_super_class)
+    end
+  end
+end

data/spec/unit/file_access_control_spec.rb

@@ -0,0 +1,282 @@
+#
+# 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'
+require 'ostruct'
+
+describe Chef::FileAccessControl do
+  describe "Unix" do
+    before do
+      platform_mock :unix do
+        # we have to re-load the file so the proper
+        # platform specific module is mixed in
+        @node = Chef::Node.new
+        load File.join(File.dirname(__FILE__), "..", "..", "lib", "chef", "file_access_control.rb")
+        @resource = Chef::Resource::File.new('/tmp/a_file.txt')
+        @resource.owner('toor')
+        @resource.group('wheel')
+        @resource.mode('0400')
+
+        @events = Chef::EventDispatch::Dispatcher.new
+        @run_context = Chef::RunContext.new(@node, {}, @events)
+        @current_resource = Chef::Resource::File.new('/tmp/different_file.txt')
+        @provider_requirements = Chef::Provider::ResourceRequirements.new(@resource, @run_context)
+        @provider = mock("File provider", :requirements => @provider_requirements)
+
+        @fac = Chef::FileAccessControl.new(@current_resource, @resource, @provider)
+      end
+    end
+
+    it "has a resource" do
+      @fac.resource.should equal(@resource)
+    end
+
+    it "has a file to manage" do
+      @fac.file.should == '/tmp/different_file.txt'
+    end
+
+    it "is not modified yet" do
+      @fac.should_not be_modified
+    end
+
+    it "determines the uid of the owner specified by the resource" do
+      Etc.should_receive(:getpwnam).with('toor').and_return(OpenStruct.new(:uid => 2342))
+      @fac.target_uid.should == 2342
+    end
+
+    it "raises a Chef::Exceptions::UserIDNotFound error when Etc can't find the user's name" do
+      Etc.should_receive(:getpwnam).with('toor').and_raise(ArgumentError)
+      lambda { @fac.target_uid ; @provider_requirements.run(:create) }.should raise_error(Chef::Exceptions::UserIDNotFound, "cannot determine user id for 'toor', does the user exist on this system?")
+    end
+
+    it "does not attempt to resolve the uid if the user is not specified" do
+      resource = Chef::Resource::File.new("a file")
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.target_uid.should be_nil
+    end
+
+    it "does not want to update the owner if none is specified" do
+      resource = Chef::Resource::File.new("a file")
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.should_update_owner?.should be_false
+    end
+
+    it "raises an ArgumentError if the resource's owner is set to something wack" do
+      @resource.instance_variable_set(:@owner, :diaf)
+      lambda { @fac.target_uid ; @provider_requirements.run(:create) }.should raise_error(ArgumentError)
+    end
+
+    it "uses the resource's uid for the target uid when the resource's owner is specified by an integer" do
+      @resource.owner(2342)
+      @fac.target_uid.should == 2342
+    end
+
+    it "wraps uids to their negative complements to correctly handle negative uids" do
+      # More: Mac OS X (at least) has negative UIDs for 'nobody' and some other
+      # users. Ruby doesn't believe in negative UIDs so you get the diminished radix
+      # complement (i.e., it wraps around the maximum size of C unsigned int) of these
+      # uids. So we have to get ruby and negative uids to smoke the peace pipe
+      # with each other.
+      @resource.owner('nobody')
+      Etc.should_receive(:getpwnam).with('nobody').and_return(OpenStruct.new(:uid => (4294967294)))
+      @fac.target_uid.should == -2
+    end
+
+    it "does not wrap uids to their negative complements beyond -9" do
+      # More: when OSX userIDs are created by ActiveDirectory sync, it tends to use huge numbers
+      #  which had been incorrectly wrapped.  It does not look like the OSX IDs go below -2
+      @resource.owner('bigdude')
+      Etc.should_receive(:getpwnam).with('bigdude').and_return(OpenStruct.new(:uid => (4294967286)))
+      @fac.target_uid.should == 4294967286
+    end
+
+    it "wants to update the owner when the current owner doesn't match desired" do
+      @resource.owner(2342)
+      @fac.should_update_owner?.should be_true
+    end
+
+    it "includes updating ownership in its list of desired changes" do
+      resource = Chef::Resource::File.new("a file")
+      resource.owner(2342)
+      @current_resource.owner(100)
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.describe_changes.should == ["change owner from '100' to '2342'"]
+    end
+
+    it "sets the file's owner as specified in the resource when the current owner is incorrect" do
+      @resource.owner(2342)
+      File.should_receive(:chown).with(2342, nil, '/tmp/different_file.txt')
+      @fac.set_owner
+      @fac.should be_modified
+    end
+
+    it "doesn't set the file's owner if it already matches" do
+      @resource.owner(2342)
+      @current_resource.owner(2342)
+      File.should_not_receive(:chown)
+      @fac.set_owner
+      @fac.should_not be_modified
+    end
+
+    it "doesn't want to update a file's owner when it's already correct" do
+      @resource.owner(2342)
+      @current_resource.owner(2342)
+      @fac.should_update_owner?.should be_false
+    end
+
+    it "determines the gid of the group specified by the resource" do
+      Etc.should_receive(:getgrnam).with('wheel').and_return(OpenStruct.new(:gid => 2342))
+      @fac.target_gid.should == 2342
+    end
+
+    it "uses a user specified gid as the gid" do
+      @resource.group(2342)
+      @fac.target_gid.should == 2342
+    end
+
+    it "raises a Chef::Exceptions::GroupIDNotFound error when Etc can't find the user's name" do
+      Etc.should_receive(:getgrnam).with('wheel').and_raise(ArgumentError)
+      lambda { @fac.target_gid; @provider_requirements.run(:create) }.should raise_error(Chef::Exceptions::GroupIDNotFound, "cannot determine group id for 'wheel', does the group exist on this system?")
+    end
+
+    it "does not attempt to resolve a gid when none is supplied" do
+      resource = Chef::Resource::File.new('crab')
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.target_gid.should be_nil
+    end
+
+    it "does not want to update the group when no target group is specified" do
+      resource = Chef::Resource::File.new('crab')
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.should_update_group?.should be_false
+    end
+
+    it "raises an error when the supplied group name is an alien" do
+      @resource.instance_variable_set(:@group, :failburger)
+      lambda { @fac.target_gid; @provider_requirements.run(:create) }.should raise_error(ArgumentError)
+    end
+
+    it "wants to update the group when the current group doesn't match the target group" do
+      @resource.group(2342)
+      @current_resource.group(815)
+      @fac.should_update_group?.should be_true
+    end
+
+    it "includes updating the group in the list of changes" do
+      resource = Chef::Resource::File.new('crab')
+      resource.group(2342)
+      @current_resource.group(815)
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.describe_changes.should == ["change group from '815' to '2342'"]
+    end
+
+    it "sets the file's group as specified in the resource when the group is not correct" do
+      @resource.group(2342)
+      @current_resource.group(815)
+
+      File.should_receive(:chown).with(nil, 2342, '/tmp/different_file.txt')
+      @fac.set_group
+      @fac.should be_modified
+    end
+
+    it "doesn't want to modify the file's group when the current group is correct" do
+      @resource.group(2342)
+      @current_resource.group(2342)
+      @fac.should_update_group?.should be_false
+    end
+
+    it "doesnt set the file's group if it is already correct" do
+      @resource.group(2342)
+      @current_resource.group(2342)
+
+      # @fac.stub!(:stat).and_return(OpenStruct.new(:gid => 2342))
+      File.should_not_receive(:chown)
+      @fac.set_group
+      @fac.should_not be_modified
+    end
+
+    it "uses the supplied mode as octal when it's a string" do
+      @resource.mode('444')
+      @fac.target_mode.should == 292 # octal 444 => decimal 292
+    end
+
+    it "uses the supplied mode verbatim when it's an integer" do
+      @resource.mode(00444)
+      @fac.target_mode.should == 292
+    end
+
+    it "does not try to determine the mode when none is given" do
+      resource = Chef::Resource::File.new('blahblah')
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.target_mode.should be_nil
+    end
+
+    it "doesn't want to update the mode when no target mode is given" do
+      resource = Chef::Resource::File.new('blahblah')
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.should_update_mode?.should be_false
+    end
+
+    it "wants to update the mode when the desired mode does not match the current mode" do
+      @current_resource.mode("0644")
+      @fac.should_update_mode?.should be_true
+    end
+
+    it "includes changing the mode in the list of desired changes" do
+      resource = Chef::Resource::File.new('blahblah')
+      resource.mode("0750")
+      @current_resource.mode("0444")
+      fac = Chef::FileAccessControl.new(@current_resource, resource, @provider)
+      fac.describe_changes.should == ["change mode from '0444' to '0750'"]
+    end
+
+    it "sets the file's mode as specified in the resource when the current modes are incorrect" do
+      # stat returns modes like 0100644 (octal) => 33188 (decimal)
+      #@fac.stub!(:stat).and_return(OpenStruct.new(:mode => 33188))
+      @current_resource.mode("0644")
+      File.should_receive(:chmod).with(256, '/tmp/different_file.txt')
+      @fac.set_mode
+      @fac.should be_modified
+    end
+
+    it "does not want to update the mode when the current mode is correct" do
+      @current_resource.mode("0400")
+      @fac.should_update_mode?.should be_false
+    end
+
+    it "does not set the file's mode when the current modes are correct" do
+      #@fac.stub!(:stat).and_return(OpenStruct.new(:mode => 0100400))
+      @current_resource.mode("0400")
+      File.should_not_receive(:chmod)
+      @fac.set_mode
+      @fac.should_not be_modified
+    end
+
+    it "sets all access controls on a file" do
+      @fac.stub!(:stat).and_return(OpenStruct.new(:owner => 99, :group => 99, :mode => 0100444))
+      @resource.mode(0400)
+      @resource.owner(0)
+      @resource.group(0)
+      File.should_receive(:chmod).with(0400, '/tmp/different_file.txt')
+      File.should_receive(:chown).with(0, nil, '/tmp/different_file.txt')
+      File.should_receive(:chown).with(nil, 0, '/tmp/different_file.txt')
+      @fac.set_all
+      @fac.should be_modified
+    end
+  end
+end

data/spec/unit/file_cache_spec.rb

@@ -0,0 +1,114 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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 Chef::FileCache do
+  before do
+    @file_cache_path = Dir.mktmpdir
+    Chef::Config[:file_cache_path] = @file_cache_path
+    @io = StringIO.new
+  end
+
+  after do
+    FileUtils.rm_rf(Chef::Config[:file_cache_path])
+  end
+
+  describe "when the relative path to the cache file doesn't exist" do
+    it "creates intermediate directories as needed" do
+      Chef::FileCache.store("whiz/bang", "I found a poop")
+      File.should exist(File.join(@file_cache_path, 'whiz'))
+    end
+
+    it "creates the cached file at the correct relative path" do
+      File.should_receive(:open).with(File.join(@file_cache_path, 'whiz', 'bang'), "w",416).and_yield(@io)
+      Chef::FileCache.store("whiz/bang", "borkborkbork")
+    end
+
+  end
+  
+  describe "when storing a file" do
+    before do
+      File.stub!(:open).and_yield(@io)
+    end
+
+    it "should print the contents to the file" do
+      Chef::FileCache.store("whiz/bang", "borkborkbork")
+      @io.string.should == "borkborkbork"
+    end
+
+  end
+
+  describe "when loading cached files" do
+    it "finds and reads the cached file" do
+      FileUtils.mkdir_p(File.join(@file_cache_path, 'whiz'))
+      File.open(File.join(@file_cache_path, 'whiz', 'bang'), 'w') { |f| f.print("borkborkbork") }
+      Chef::FileCache.load('whiz/bang').should == 'borkborkbork'
+    end
+
+    it "should raise a Chef::Exceptions::FileNotFound if the file doesn't exist" do
+      lambda { Chef::FileCache.load('whiz/bang') }.should raise_error(Chef::Exceptions::FileNotFound)
+    end
+  end
+
+  describe "when deleting cached files" do
+    before(:each) do
+      FileUtils.mkdir_p(File.join(@file_cache_path, 'whiz'))
+      File.open(File.join(@file_cache_path, 'whiz', 'bang'), 'w') { |f| f.print("borkborkbork") }
+    end
+
+    it "unlinks the file" do
+      Chef::FileCache.delete("whiz/bang")
+      File.should_not exist(File.join(@file_cache_path, 'whiz', 'bang'))
+    end
+
+  end
+
+  describe "when listing files in the cache" do
+    before(:each) do
+      FileUtils.mkdir_p(File.join(@file_cache_path, 'whiz'))
+      FileUtils.touch(File.join(@file_cache_path, 'whiz', 'bang'))
+      FileUtils.mkdir_p(File.join(@file_cache_path, 'snappy'))
+      FileUtils.touch(File.join(@file_cache_path, 'snappy', 'patter'))
+    end
+
+    it "should return the relative paths" do
+      Chef::FileCache.list.sort.should == %w{snappy/patter whiz/bang}
+    end
+
+    it "searches for cached files by globbing" do
+      Chef::FileCache.find('snappy/**/*').should == %w{snappy/patter}
+    end
+
+  end
+
+  describe "when checking for the existence of a file" do
+    before do
+      FileUtils.mkdir_p(File.join(@file_cache_path, 'whiz'))
+    end
+
+    it "has a key if the corresponding cache file exists" do
+      FileUtils.touch(File.join(@file_cache_path, 'whiz', 'bang'))
+      Chef::FileCache.should have_key("whiz/bang")
+    end
+
+    it "doesn't have a key if the corresponding cache file doesn't exist" do
+      Chef::FileCache.should_not have_key("whiz/bang")
+    end
+  end
+end