chef 10.12.0 → 10.14.0.beta.1

data/spec/unit/provider/remote_directory_spec.rb

@@ -0,0 +1,186 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2010 Daniel DeLeo
+# 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 'digest/md5'
+require 'tmpdir'
+
+describe Chef::Provider::RemoteDirectory do
+  before do
+    Chef::FileAccessControl.any_instance.stub(:set_all)
+    @resource = Chef::Resource::RemoteDirectory.new("/tmp/tafty")
+    # in CHEF_SPEC_DATA/cookbooks/openldap/files/default/remotedir
+    @resource.source "remotedir"
+    @resource.cookbook('openldap')
+
+    @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
+    @cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(@cookbook_repo))
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+    @provider = Chef::Provider::RemoteDirectory.new(@resource, @run_context)
+    @provider.current_resource = @resource.clone
+  end
+
+  describe "when access control is configured on the resource" do
+    before do
+      @resource.mode  "0750"
+      @resource.group "wheel"
+      @resource.owner "root"
+
+      @resource.files_mode  "0640"
+      @resource.files_group "staff"
+      @resource.files_owner "toor"
+      @resource.files_backup 23
+
+      @resource.source "remotedir_root"
+    end
+
+    it "configures access control on intermediate directorys" do
+      directory_resource = @provider.send(:resource_for_directory, "/tmp/intermediate_dir")
+      directory_resource.path.should  == "/tmp/intermediate_dir"
+      directory_resource.mode.should  == "0750"
+      directory_resource.group.should == "wheel"
+      directory_resource.owner.should == "root"
+      directory_resource.recursive.should be_true
+    end
+
+    it "configures access control on files in the directory" do
+      @resource.cookbook "berlin_style_tasty_cupcakes"
+      cookbook_file = @provider.send(:cookbook_file_resource,
+                                    "/target/destination/path.txt",
+                                    "relative/source/path.txt")
+      cookbook_file.cookbook_name.should  == "berlin_style_tasty_cupcakes"
+      cookbook_file.source.should         == "remotedir_root/relative/source/path.txt"
+      cookbook_file.mode.should           == "0640"
+      cookbook_file.group.should          == "staff"
+      cookbook_file.owner.should          == "toor"
+      cookbook_file.backup.should         == 23
+    end
+  end
+
+  describe "when creating the remote directory" do
+    before do
+      @node[:platform] = :just_testing
+      @node[:platform_version] = :just_testing
+
+      @destination_dir = Dir.tmpdir << "/remote_directory_test"
+      @resource.path(@destination_dir)
+    end
+
+    after {FileUtils.rm_rf(@destination_dir)}
+
+    it "transfers the directory with all contents" do
+      @provider.run_action(:create)
+      ::File.exist?(@destination_dir + '/remote_dir_file1.txt').should be_true
+      ::File.exist?(@destination_dir + '/remote_dir_file2.txt').should be_true
+      ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt').should be_true
+      ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt').should be_true
+      ::File.exist?(@destination_dir + '/remotesubdir/.a_dotfile').should be_true
+      ::File.exist?(@destination_dir + '/.a_dotdir/.a_dotfile_in_a_dotdir').should be_true
+    end
+
+    describe "only if it is missing" do
+      it "should not overwrite existing files" do
+        @resource.overwrite(true)
+        @provider.run_action(:create)
+
+        File.open(@destination_dir + '/remote_dir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        File.open(@destination_dir + '/remotesubdir/remote_subdir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        file1md5 = Digest::MD5.hexdigest(File.read(@destination_dir + '/remote_dir_file1.txt'))
+        subdirfile1md5 = Digest::MD5.hexdigest(File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))
+
+        @provider.run_action(:create_if_missing)
+
+        file1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remote_dir_file1.txt'))).should be_true
+        subdirfile1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))).should be_true
+      end
+    end
+
+    describe "with purging enabled" do
+      before {@resource.purge(true)}
+
+      it "removes existing files if purge is true" do
+        @provider.run_action(:create)
+        FileUtils.touch(@destination_dir + '/marked_for_death.txt')
+        FileUtils.touch(@destination_dir + '/remotesubdir/marked_for_death_again.txt')
+        @provider.run_action(:create)
+
+        ::File.exist?(@destination_dir + '/remote_dir_file1.txt').should be_true
+        ::File.exist?(@destination_dir + '/remote_dir_file2.txt').should be_true
+        ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt').should be_true
+        ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt').should be_true
+
+        ::File.exist?(@destination_dir + '/marked_for_death.txt').should be_false
+        ::File.exist?(@destination_dir + '/remotesubdir/marked_for_death_again.txt').should be_false
+      end
+
+      it "removes files in subdirectories before files above" do
+        @provider.run_action(:create)
+        FileUtils.mkdir_p(@destination_dir + '/a/multiply/nested/directory/')
+        FileUtils.touch(@destination_dir + '/a/foo.txt')
+        FileUtils.touch(@destination_dir + '/a/multiply/bar.txt')
+        FileUtils.touch(@destination_dir + '/a/multiply/nested/baz.txt')
+        FileUtils.touch(@destination_dir + '/a/multiply/nested/directory/qux.txt')
+        @provider.run_action(:create)
+        ::File.exist?(@destination_dir + '/a/foo.txt').should be_false
+        ::File.exist?(@destination_dir + '/a/multiply/bar.txt').should be_false
+        ::File.exist?(@destination_dir + '/a/multiply/nested/baz.txt').should be_false
+        ::File.exist?(@destination_dir + '/a/multiply/nested/directory/qux.txt').should be_false
+      end
+
+      it "removes directory symlinks properly" do
+        symlinked_dir_path = @destination_dir + '/symlinked_dir'
+        @provider.action = :create
+        @provider.run_action
+
+        Dir.mktmpdir do |tmp_dir|
+          FileUtils.ln_s(tmp_dir, symlinked_dir_path)
+          ::File.exist?(symlinked_dir_path).should be_true
+
+          @provider.run_action
+
+          ::File.exist?(symlinked_dir_path).should be_false
+          ::File.exist?(tmp_dir).should be_true
+        end
+      end
+    end
+
+    describe "with overwrite disabled" do
+      before {@resource.purge(false)}
+      before {@resource.overwrite(false)}
+
+      it "leaves modifications alone" do
+        @provider.run_action(:create)
+        ::File.open(@destination_dir + '/remote_dir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        ::File.open(@destination_dir + '/remotesubdir/remote_subdir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        file1md5 = Digest::MD5.hexdigest(::File.read(@destination_dir + '/remote_dir_file1.txt'))
+        subdirfile1md5 = Digest::MD5.hexdigest(::File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))
+        @provider.run_action(:create)
+        file1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remote_dir_file1.txt'))).should be_true
+        subdirfile1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))).should be_true
+      end
+    end
+
+  end
+end
+

data/spec/unit/provider/remote_file_spec.rb

@@ -0,0 +1,274 @@
+#
+# 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::Provider::RemoteFile, "action_create" do
+  before(:each) do
+    @resource = Chef::Resource::RemoteFile.new("seattle")
+    @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "seattle.txt")))
+    @resource.source("http://foo")
+    @node = Chef::Node.new
+    @node.name "latte"
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @provider = Chef::Provider::RemoteFile.new(@resource, @run_context)
+    #To prevent the current_resource.checksum from being overridden.
+    @provider.stub!(:load_current_resource)
+  end
+
+  describe "when checking if the file is at the target version" do
+    it "considers the current file to be at the target version if it exists and matches the user-provided checksum" do
+      @provider.current_resource = @resource.dup
+      @resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.current_resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.current_resource_matches_target_checksum?.should be_true
+    end
+  end
+
+  describe "when fetching the file from the remote" do
+    before(:each) do
+      @tempfile = Tempfile.new("chef-rspec-remote_file_spec-line#{__LINE__}--")
+
+      @rest = mock(Chef::REST, { })
+      Chef::REST.stub!(:new).and_return(@rest)
+      @rest.stub!(:streaming_request).and_return(@tempfile)
+      @rest.stub!(:create_url) { |url| url } 
+      @resource.cookbook_name = "monkey"
+
+      @provider.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.current_resource = @resource.clone
+      @provider.current_resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      File.stub!(:exists?).and_return(true)
+      FileUtils.stub!(:cp).and_return(true)
+      Chef::Platform.stub!(:find_platform_and_version).and_return([ :mac_os_x, "10.5.1" ])
+    end
+
+    after do
+      @tempfile.close!
+    end
+
+    before do
+      @resource.source("http://opscode.com/seattle.txt")
+    end
+
+    describe "and the target location's enclosing directory does not exist" do
+      before do
+        @resource.path("/tmp/this/path/does/not/exist/file.txt")
+      end
+
+      it "raises a specific error describing the problem" do
+        lambda {@provider.run_action(:create)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+      end
+    end
+
+    describe "and the resource specifies a checksum" do
+
+      describe "and the existing file matches the checksum exactly" do
+        before do
+          @resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+        end
+
+        it "does not download the file" do
+          @rest.should_not_receive(:fetch).with("http://opscode.com/seattle.txt").and_return(@tempfile)
+          @provider.run_action(:create)
+        end
+
+        it "does not update the resource" do
+          @provider.run_action(:create)
+          @provider.new_resource.should_not be_updated
+        end
+
+      end
+
+      describe "and the existing file matches the given partial checksum" do
+        before do
+          @resource.checksum("0fd012fd")
+        end
+
+        it "should not download the file if the checksum is a partial match from the beginning" do
+          @rest.should_not_receive(:fetch).with("http://opscode.com/seattle.txt").and_return(@tempfile)
+          @provider.run_action(:create)
+        end
+
+        it "does not update the resource" do
+          @provider.run_action(:create)
+          @provider.new_resource.should_not be_updated
+        end
+
+      end
+
+      describe "and the existing file doesn't match the given checksum" do
+        it "downloads the file" do
+          @resource.checksum("this hash doesn't match")
+          @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
+          @provider.run_action(:create)
+        end
+
+        it "does not consider the checksum a match if the matching string is offset" do
+          # i.e., the existing file is      "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa"
+          @resource.checksum("fd012fd")
+          @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
+          @provider.run_action(:create)
+        end
+      end
+
+    end
+
+    describe "and the resource doesn't specify a checksum" do
+      it "should download the file from the remote URL" do
+        @resource.checksum(nil)
+        @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
+        @provider.run_action(:create)
+      end
+    end
+
+    # CHEF-3140
+    # Some servers return tarballs as content type tar and encoding gzip, which
+    # is totally wrong. When this happens and gzip isn't disabled, Chef::REST
+    # will decompress the file for you, which is not at all what you expected
+    # to happen (you end up with an uncomressed tar archive instead of the
+    # gzipped tar archive you expected). To work around this behavior, we
+    # detect when users are fetching gzipped files and turn off gzip in
+    # Chef::REST.
+
+    context "and the target file is a tarball" do
+      before do
+        @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "seattle.tar.gz")))
+        Chef::REST.should_receive(:new).with("http://opscode.com/seattle.txt", nil, nil, :disable_gzip => true).and_return(@rest)
+      end
+
+      it "disables gzip in the http client" do
+        @provider.action_create
+      end
+
+    end
+
+    context "and the source appears to be a tarball" do
+      before do
+        @resource.source("http://example.com/tarball.tgz")
+        Chef::REST.should_receive(:new).with("http://example.com/tarball.tgz", nil, nil, :disable_gzip => true).and_return(@rest)
+      end
+
+      it "disables gzip in the http client" do
+        @provider.action_create
+      end
+    end
+
+    it "should raise an exception if it's any other kind of retriable response than 304" do
+      r = Net::HTTPMovedPermanently.new("one", "two", "three")
+      e = Net::HTTPRetriableError.new("301", r)
+      @rest.stub!(:streaming_request).and_raise(e)
+      lambda { @provider.run_action(:create) }.should raise_error(Net::HTTPRetriableError)
+    end
+
+    it "should raise an exception if anything else happens" do
+      r = Net::HTTPBadRequest.new("one", "two", "three")
+      e = Net::HTTPServerException.new("fake exception", r)
+      @rest.stub!(:streaming_request).and_raise(e)
+      lambda { @provider.run_action(:create) }.should raise_error(Net::HTTPServerException)
+    end
+
+    it "should checksum the raw file" do
+      @provider.should_receive(:checksum).with(@tempfile.path).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.run_action(:create)
+    end
+
+    describe "when the target file does not exist" do
+      before do
+        ::File.stub!(:exists?).with(@resource.path).and_return(false)
+        @provider.stub!(:get_from_server).and_return(@tempfile)
+      end
+
+      it "should copy the raw file to the new resource" do
+        FileUtils.should_receive(:cp).with(@tempfile.path, @resource.path).and_return(true)
+        @provider.run_action(:create)
+      end
+
+      it "should set the new resource to updated" do
+        @provider.run_action(:create)
+        @resource.should be_updated
+      end
+
+      describe "and create_if_missing is invoked" do
+        it "should invoke action_create" do
+          @provider.should_receive(:action_create)
+          @provider.run_action(:create_if_missing)
+        end
+      end
+    end
+
+    describe "when the target file already exists" do
+      before do
+        ::File.stub!(:exists?).with(@resource.path).and_return(true)
+        @provider.stub!(:get_from_server).and_return(@tempfile)
+      end
+
+      describe "and create_if_missing is invoked" do
+        it "should take no action" do
+          @provider.should_not_receive(:action_create) 
+          @provider.run_action(:create_if_missing)
+        end
+      end
+
+      describe "and the file downloaded from the remote is identical to the current" do
+        it "shouldn't backup the original file" do
+          @provider.should_not_receive(:backup).with(@resource.path)
+          @provider.run_action(:create)
+        end
+
+        it "doesn't mark the resource as updated" do
+          @provider.run_action(:create)
+          @provider.new_resource.should_not be_updated
+        end
+      end
+
+      describe "and the checksum doesn't match" do
+        before do
+          sha2_256 = "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa-NO_MATCHY"
+          @provider.current_resource.checksum(sha2_256)
+        end
+
+        it "should backup the original file" do
+          @provider.should_receive(:backup).with(@resource.path).and_return(true)
+          @provider.run_action(:create)
+        end
+
+        it "should copy the raw file to the new resource" do
+          FileUtils.should_receive(:cp).with(@tempfile.path, @resource.path).and_return(true)
+          @provider.run_action(:create)
+        end
+
+        it "should set the new resource to updated" do
+          @provider.run_action(:create)
+          @resource.should be_updated
+        end
+      end
+
+      it "should set permissions" do
+        @provider.should_receive(:set_all_access_controls).and_return(true)
+        @provider.run_action(:create)
+      end
+
+
+    end
+
+  end
+end