chef 11.4.4 → 11.6.0.hotfix.1

data/spec/unit/provider/cookbook_file/content_spec.rb

@@ -0,0 +1,40 @@
+#
+# Author:: Lamont Granquist (<lamont@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'
+
+describe Chef::Provider::CookbookFile::Content do
+
+  let(:new_resource) { mock('Chef::Resource::CookbookFile (new)', :cookbook_name => 'apache2', :cookbook => 'apache2') }
+  let(:content) do
+    @run_context = mock('Chef::RunContext')
+    @current_resource = mock('Chef::Resource::CookbookFile (current)')
+    Chef::Provider::CookbookFile::Content.new(new_resource, @current_resource, @run_context)
+  end
+
+  it "prefers the explicit cookbook name on the resource to the implicit one" do
+    new_resource.stub!(:cookbook).and_return('nginx')
+    content.send(:resource_cookbook).should == 'nginx'
+  end
+
+  it "falls back to the implicit cookbook name on the resource" do
+    content.send(:resource_cookbook).should == 'apache2'
+  end
+
+end
+

data/spec/unit/provider/cookbook_file_spec.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2009-2013 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,196 +20,38 @@
 require 'spec_helper'
 require 'ostruct'
 
-describe Chef::Provider::CookbookFile do
-  before do
-    Chef::FileAccessControl.any_instance.stub(:set_all)
-    Chef::FileAccessControl.any_instance.stub(:modified?).and_return(true)
-    @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
-    Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, @cookbook_repo) }
-
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    cl = Chef::CookbookLoader.new(@cookbook_repo)
-    cl.load_cookbooks
-    @cookbook_collection = Chef::CookbookCollection.new(cl)
-    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
-
-    @new_resource = Chef::Resource::CookbookFile.new('apache2_module_conf_generate.pl', @run_context)
-    @new_resource.cookbook_name = 'apache2'
-    @provider = Chef::Provider::CookbookFile.new(@new_resource, @run_context)
-
-    @file_content=<<-EXPECTED
-# apache2_module_conf_generate.pl
-# this is just here for show.
-EXPECTED
-
-  end
-
-  it "prefers the explicit cookbook name on the resource to the implicit one" do
-    @new_resource.cookbook('nginx')
-    @provider.resource_cookbook.should == 'nginx'
-  end
+require 'support/shared/unit/provider/file'
 
-  it "falls back to the implicit cookbook name on the resource" do
-    @provider.resource_cookbook.should == 'apache2'
-  end
-
-  describe "when loading the current file state" do
-
-    it "converts windows-y filenames to unix-y ones" do
-      @new_resource.path('windows\stuff')
-      @provider.load_current_resource
-      @new_resource.path.should == 'windows/stuff'
-    end
-
-    it "sets the current resources path to the same as the new resource" do
-      @new_resource.path('/tmp/file')
-      @provider.load_current_resource
-      @provider.current_resource.path.should == '/tmp/file'
-    end
-  end
+describe Chef::Provider::CookbookFile do
+  let(:node) { double('Chef::Node') }
+  let(:events) { double('Chef::Events').as_null_object }  # mock all the methods
+  let(:run_context) { double('Chef::RunContext', :node => node, :events => events) }
+  let(:enclosing_directory) {
+    canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
+  }
+  let(:resource_path) {
+    canonicalize_path(File.expand_path(File.join(enclosing_directory, "seattle.txt")))
+  }
 
-  describe "when the enclosing directory of the target file location doesn't exist" do
-    before do
-      @new_resource.path("/tmp/no/such/intermediate/path/file.txt")
-    end
+  # Subject
 
-    it "raises a specific error alerting the user to the problem" do
-      lambda {@provider.run_action(:create)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
-    end
+  let(:provider) do
+    provider = described_class.new(resource, run_context)
+    provider.stub!(:content).and_return(content)
+    provider
   end
-  describe "when the file doesn't yet exist" do
-    before do
-      @install_to = Dir.tmpdir + '/apache2_modconf.pl'
-
-      @current_resource = @new_resource.dup
-      @provider.current_resource = @current_resource
-    end
-
-    after { ::File.exist?(File.dirname(@install_to)) && FileUtils.rm_rf(@install_to) }
-
-    it "loads the current file state" do
-      @provider.load_current_resource
-      @provider.current_resource.checksum.should be_nil
-    end
-
-    it "looks up a file from the cookbook cache" do
-      expected = CHEF_SPEC_DATA + "/cookbooks/apache2/files/default/apache2_module_conf_generate.pl"
-      @provider.file_cache_location.should == expected
-    end
-
-    it "installs the file from the cookbook cache" do
-      @new_resource.path(@install_to)
-      @provider.should_receive(:backup_new_resource)
-      @provider.stub!(:update_new_file_state)
-      @provider.run_action(:create)
-      actual = IO.read(@install_to)
-      actual.should == @file_content
-    end
-
-    it "installs the file for create_if_missing --> from Provider::File" do
-      @new_resource.path(@install_to)
-      @provider.should_receive(:backup_new_resource)
-      @provider.stub!(:update_new_file_state)
-      @provider.run_action(:create_if_missing)
-      actual = IO.read(@install_to)
-      actual.should == @file_content
-    end
-
-    it "marks the resource as updated by the last action --> being tested in the converge framework" do
-      @new_resource.path(@install_to)
-      @provider.stub!(:backup_new_resource)
-      @provider.stub!(:set_file_access_controls)
-      @provider.stub!(:update_new_file_state)
-      @provider.run_action(:create)
-      @new_resource.should be_updated
-      @new_resource.should be_updated_by_last_action
-    end
 
+  let(:resource) do
+    resource = Chef::Resource::CookbookFile.new("seattle", @run_context)
+    resource.path(resource_path)
+    resource.cookbook_name = 'apache2'
+    resource
   end
 
-  describe "when the file exists but has incorrect content" do
-    before do
-      @tempfile = Tempfile.open('cookbook_file_spec')
-      @new_resource.path(@target_file = @tempfile.path)
-      @tempfile.puts "the wrong content"
-      @tempfile.close
-      @current_resource = @new_resource.dup
-      @provider.current_resource = @current_resource
-    end
-
-    it "stages the cookbook to a temporary file" do
-      # prevents file backups where we might not have write access
-      @provider.should_receive(:backup_new_resource) 
-      @new_resource.path(@install_to)
-      @provider.should_receive(:deploy_tempfile)
-      @provider.run_action(:create)
-    end
-
-    it "overwrites it when the create action is called" do
-      @provider.should_receive(:backup_new_resource)
-      @provider.run_action(:create)
-      actual = IO.read(@target_file)
-      actual.should == @file_content
-    end
-
-    it "marks the resource as updated by the last action" do
-      @provider.should_receive(:backup_new_resource)
-      @provider.run_action(:create)
-      @new_resource.should be_updated
-      @new_resource.should be_updated_by_last_action
-    end
-
-    it "doesn't overwrite when the create if missing action is called" do
-      @provider.should_not_receive(:set_file_access_controls)
-      @provider.run_action(:create_if_missing)
-      actual = IO.read(@target_file)
-      actual.should == "the wrong content\n"
-    end
-
-    it "doesn't mark the resource as updated by the action for create_if_missing" do
-      @provider.run_action(:create_if_missing)
-      @new_resource.should_not be_updated
-      @new_resource.should_not be_updated_by_last_action
-    end
-
-    after { @tempfile && @tempfile.close! }
+  let(:content) do
+    content = mock('Chef::Provider::CookbookFile::Content')
   end
 
-  describe "when the file has the correct content" do
-    before do
-      Chef::FileAccessControl.any_instance.stub(:modified?).and_return(false)
-      @tempfile = Tempfile.open('cookbook_file_spec')
-      # CHEF-2991: We handle CRLF very poorly and we don't know what line endings
-      # our source file is going to have, so we use binary mode to preserve CRLF if needed.
-      source_file = CHEF_SPEC_DATA + "/cookbooks/apache2/files/default/apache2_module_conf_generate.pl"
-      @tempfile.binmode unless File.open(source_file, "rb") { |f| f.read =~ /\r/ }
-      @new_resource.path(@target_file = @tempfile.path)
-      @tempfile.write(@file_content)
-      @tempfile.close
-      @current_resource = @new_resource.dup
-      @provider.current_resource = @current_resource
-    end
-
-    after { @tempfile && @tempfile.unlink}
+  it_behaves_like Chef::Provider::File
 
-    it "checks access control but does not alter content when action is create" do
-      @provider.should_receive(:set_all_access_controls)
-      @provider.should_not_receive(:stage_file_to_tmpdir)
-      @provider.run_action(:create)
-    end
-
-    it "does not mark the resource as updated by the last action" do
-      @provider.run_action(:create)
-      @new_resource.should_not be_updated
-      @new_resource.should_not be_updated_by_last_action
-    end
-
-    it "does not alter content or access control when action is create if missing" do
-      @provider.should_not_receive(:set_all_access_controls)
-      @provider.should_not_receive(:stage_file_to_tmpdir)
-      @provider.run_action(:create_if_missing)
-    end
-
-  end
 end

data/spec/unit/provider/cron/solaris_spec.rb

@@ -87,7 +87,7 @@ CRONTAB
     before :each do
       @status = mock("Status", :exitstatus => 0)
       @provider.stub!(:run_command).and_return(@status)
-      @tempfile = mock("foo", :path => "/tmp/foo", :close => true, :binmode => nil)
+      @tempfile = mock("foo", :path => "/tmp/foo", :close => true)
       Tempfile.stub!(:new).and_return(@tempfile)
       @tempfile.should_receive(:flush)
       @tempfile.should_receive(:chmod).with(420)

data/spec/unit/provider/deploy/revision_spec.rb

@@ -51,13 +51,13 @@ describe Chef::Provider::Deploy::Revision do
     @provider.release_path.should == @expected_release_dir
   end
 
-  it "stores the release dir in the file cache when copying the cached repo" do
+  it "stores the release dir in the file cache in the cleanup step" do
     FileUtils.stub!(:mkdir_p)
     FileUtils.stub!(:cp_r)
-    @provider.copy_cached_repo
+    @provider.cleanup!
     @provider.stub!(:release_slug).and_return("73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2")
     @provider.load_current_resource
-    @provider.copy_cached_repo
+    @provider.cleanup!
     second_release = "/my/deploy/dir/releases/73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2"
 
     @provider.all_releases.should == [@expected_release_dir,second_release]
@@ -66,29 +66,37 @@ describe Chef::Provider::Deploy::Revision do
   it "removes a release from the file cache when it's used again in another release and append it to the end" do
     FileUtils.stub!(:mkdir_p)
     FileUtils.stub!(:cp_r)
-    @provider.copy_cached_repo
+    @provider.cleanup!
     @provider.stub!(:release_slug).and_return("73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2")
     @provider.load_current_resource
-    @provider.copy_cached_repo
+    @provider.cleanup!
     second_release = "/my/deploy/dir/releases/73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2"
     @provider.all_releases.should == [@expected_release_dir,second_release]
-    @provider.copy_cached_repo
+    @provider.cleanup!
 
     @provider.stub!(:release_slug).and_return("8a3195bf3efa246f743c5dfa83683201880f935c")
     @provider.load_current_resource
-    @provider.copy_cached_repo
+    @provider.cleanup!
     @provider.all_releases.should == [second_release, @expected_release_dir]
   end
 
   it "removes a release from the file cache when it's deleted by :cleanup!" do
-    %w{first second third fourth fifth latest}.each do |release_name|
-      @provider.send(:release_created, release_name)
+    release_paths = %w{first second third fourth fifth}.map do |release_name|
+       "/my/deploy/dir/releases/#{release_name}"
+    end
+    release_paths.each do |release_path|
+      @provider.send(:release_created, release_path)
     end
-    @provider.all_releases.should == %w{first second third fourth fifth latest}
+    @provider.all_releases.should == release_paths
 
     FileUtils.stub!(:rm_rf)
     @provider.cleanup!
-    @provider.all_releases.should == %w{second third fourth fifth latest}
+
+    expected_release_paths = (%w{second third fourth fifth} << @resource.revision).map do |release_name|
+       "/my/deploy/dir/releases/#{release_name}"
+    end
+
+    @provider.all_releases.should == expected_release_paths
   end
 
   it "regenerates the file cache if it's not available" do

data/spec/unit/provider/deploy_spec.rb

@@ -324,11 +324,11 @@ describe Chef::Provider::Deploy do
     @provider.copy_cached_repo
   end
 
-  it "calls the internal callback :release_created when copying the cached repo" do
+  it "calls the internal callback :release_created when cleaning up the releases" do
     FileUtils.stub!(:mkdir_p)
     FileUtils.stub!(:cp_r)
     @provider.should_receive(:release_created)
-    @provider.copy_cached_repo
+    @provider.cleanup!
   end
 
   it "chowns the whole release dir to user and group specified in the resource" do

data/spec/unit/provider/directory_spec.rb

@@ -59,7 +59,7 @@ describe Chef::Provider::Directory do
     end
 
     it "describes the access mode as a String of octal integers" do
-      File.stub!(:exist?).and_return(true)
+      File.stub!(:exists?).and_return(true)
       File.should_receive(:stat).and_return(mock_stat)
       @directory.load_current_resource
       @directory.current_resource.mode.should == "0755"
@@ -67,7 +67,7 @@ describe Chef::Provider::Directory do
 
     context "when user and group are specified with UID/GID" do
       it "describes the current owner and group as UID and GID" do
-        File.stub!(:exist?).and_return(true)
+        File.stub!(:exists?).and_return(true)
         File.should_receive(:stat).and_return(mock_stat)
         @directory.load_current_resource
         @directory.current_resource.path.should eql(@new_resource.path)
@@ -81,43 +81,43 @@ describe Chef::Provider::Directory do
   end
 
   # Unix only for now. While file security attribute reporting for windows is
-  # disabled, unix and windows differ in the number of exist? calls that are
+  # disabled, unix and windows differ in the number of exists? calls that are
   # made by the provider.
   it "should create a new directory on create, setting updated to true", :unix_only do
     @new_resource.path "/tmp/foo"
 
-    File.should_receive(:exist?).exactly(2).and_return(false)
+    File.should_receive(:exists?).at_least(:once).and_return(false)
     File.should_receive(:directory?).with("/tmp").and_return(true)
     Dir.should_receive(:mkdir).with(@new_resource.path).once.and_return(true)
 
-    @directory.should_receive(:set_all_access_controls)
-    @directory.stub!(:update_new_file_state)
+    @directory.should_receive(:do_acl_changes)
+    @directory.stub!(:do_selinux)
     @directory.run_action(:create)
     @directory.new_resource.should be_updated
   end
 
-  it "should raise an exception if the parent directory does not exist and recursive is false" do 
+  it "should raise an exception if the parent directory does not exist and recursive is false" do
     @new_resource.path "/tmp/some/dir"
     @new_resource.recursive false
-    lambda { @directory.run_action(:create) }.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist) 
+    lambda { @directory.run_action(:create) }.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
   end
 
   # Unix only for now. While file security attribute reporting for windows is
-  # disabled, unix and windows differ in the number of exist? calls that are
+  # disabled, unix and windows differ in the number of exists? calls that are
   # made by the provider.
   it "should create a new directory when parent directory does not exist if recursive is true and permissions are correct", :unix_only do
     @new_resource.path "/path/to/dir"
     @new_resource.recursive true
-    File.should_receive(:exist?).with(@new_resource.path).ordered.and_return(false)
+    File.should_receive(:exists?).with(@new_resource.path).ordered.and_return(false)
 
-    File.should_receive(:exist?).with('/path/to').ordered.and_return(false)
-    File.should_receive(:exist?).with('/path').ordered.and_return(true)
+    File.should_receive(:exists?).with('/path/to').ordered.and_return(false)
+    File.should_receive(:exists?).with('/path').ordered.and_return(true)
     File.should_receive(:writable?).with('/path').ordered.and_return(true)
-    File.should_receive(:exist?).with(@new_resource.path).ordered.and_return(false)
+    File.should_receive(:exists?).with(@new_resource.path).ordered.and_return(false)
 
-    FileUtils.should_receive(:mkdir_p).with(@new_resource.path).and_return(true) 
-    @directory.should_receive(:set_all_access_controls)
-    @directory.stub!(:update_new_file_state)
+    FileUtils.should_receive(:mkdir_p).with(@new_resource.path).and_return(true)
+    @directory.should_receive(:do_acl_changes)
+    @directory.stub!(:do_selinux)
     @directory.run_action(:create)
     @new_resource.should be_updated
   end
@@ -131,16 +131,16 @@ describe Chef::Provider::Directory do
   end
 
   # Unix only for now. While file security attribute reporting for windows is
-  # disabled, unix and windows differ in the number of exist? calls that are
+  # disabled, unix and windows differ in the number of exists? calls that are
   # made by the provider.
   it "should not create the directory if it already exists", :unix_only do
     stub_file_cstats
     @new_resource.path "/tmp/foo"
-    File.should_receive(:directory?).twice.and_return(true)
+    File.should_receive(:directory?).at_least(:once).and_return(true)
     File.should_receive(:writable?).with("/tmp").and_return(true)
-    File.should_receive(:exist?).exactly(3).and_return(true)
+    File.should_receive(:exists?).at_least(:once).and_return(true)
     Dir.should_not_receive(:mkdir).with(@new_resource.path)
-    @directory.should_receive(:set_all_access_controls)
+    @directory.should_receive(:do_acl_changes)
     @directory.run_action(:create)
   end
 
@@ -152,14 +152,14 @@ describe Chef::Provider::Directory do
   end
 
   it "should raise an exception if it cannot delete the directory due to bad permissions" do
-    File.stub!(:exist?).and_return(true)
+    File.stub!(:exists?).and_return(true)
     File.stub!(:writable?).and_return(false)
     lambda {  @directory.run_action(:delete) }.should raise_error(RuntimeError)
   end
 
   it "should take no action when deleting a target directory that does not exist" do
     @new_resource.path "/an/invalid/path"
-    File.stub!(:exist?).and_return(false)
+    File.stub!(:exists?).and_return(false)
     Dir.should_not_receive(:delete).with(@new_resource.path)
     @directory.run_action(:delete)
     @directory.new_resource.should_not be_updated
@@ -168,7 +168,7 @@ describe Chef::Provider::Directory do
   it "should raise an exception when deleting a directory when target directory is a file" do
     stub_file_cstats
     @new_resource.path "/an/invalid/path"
-    File.stub!(:exist?).and_return(true)
+    File.stub!(:exists?).and_return(true)
     File.should_receive(:directory?).and_return(false)
     Dir.should_not_receive(:delete).with(@new_resource.path)
     lambda { @directory.run_action(:delete) }.should raise_error(RuntimeError)