chef 18.8.11 → 18.8.46

data/spec/unit/provider/remote_directory_spec.rb

@@ -1,236 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2010-2016, 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"
-require "chef/mixin/file_class"
-
-class Chef::CFCCheck
-  include Chef::Mixin::FileClass
-end
-
-describe Chef::Provider::RemoteDirectory do
-  before do
-    allow_any_instance_of(Chef::FileAccessControl).to receive(:set_all)
-
-    @resource = Chef::Resource::RemoteDirectory.new(File.join(Dir.tmpdir, "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.fetch_from_disk(@cookbook_repo)
-
-    @node = Chef::Node.new
-    cl = Chef::CookbookLoader.new(@cookbook_repo)
-    cl.load_cookbooks
-    @cookbook_collection = Chef::CookbookCollection.new(cl)
-
-    @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 the contents of the directory changed on the first run and not on the second run" do
-    before do
-      @resource_second_run = @resource.clone
-      @provider_second_run = Chef::Provider::RemoteDirectory.new(@resource_second_run, @run_context)
-      @provider.run_action(:create)
-      @provider_second_run.run_action(:create)
-    end
-    it "identifies that the state has changed the after first run" do
-      @provider_second_run.new_resource.updated_by_last_action? == true
-    end
-    it "identifies that the state has not changed after the second run" do
-      @provider_second_run.new_resource.updated_by_last_action? == false
-    end
-  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(:directory_resource, File.join(Dir.tmpdir, "intermediate_dir"))
-      expect(directory_resource.path).to  eq(File.join(Dir.tmpdir, "intermediate_dir"))
-      expect(directory_resource.mode).to  eq("0750")
-      expect(directory_resource.group).to eq("wheel")
-      expect(directory_resource.owner).to eq("root")
-      expect(directory_resource.recursive).to be_truthy
-    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")
-      expect(cookbook_file.cookbook_name).to  eq("berlin_style_tasty_cupcakes")
-      expect(cookbook_file.source).to         eq("remotedir_root/relative/source/path.txt")
-      expect(cookbook_file.mode).to           eq("0640")
-      expect(cookbook_file.group).to          eq("staff")
-      expect(cookbook_file.owner).to          eq("toor")
-      expect(cookbook_file.backup).to         eq(23)
-    end
-
-    it "respects sensitive flag" do
-      @resource.cookbook "gondola_rides"
-      @resource.sensitive true
-      cookbook_file = @provider.send(:cookbook_file_resource,
-        "/target/destination/path.txt",
-        "relative/source/path.txt")
-      expect(cookbook_file.sensitive).to eq(true)
-
-      @resource.sensitive false
-      cookbook_file = @provider.send(:cookbook_file_resource,
-        "/target/destination/path.txt",
-        "relative/source/path.txt")
-      expect(cookbook_file.sensitive).to eq(false)
-    end
-  end
-
-  describe "when creating the remote directory" do
-    before do
-      @node.automatic_attrs[:platform] = :just_testing
-      @node.automatic_attrs[:platform_version] = :just_testing
-
-      @destination_dir = make_canonical_temp_directory << "/remote_directory_test"
-      @resource.path(@destination_dir)
-    end
-
-    after { FileUtils.rm_rf(@destination_dir) }
-
-    # CHEF-3552
-    it "creates the toplevel directory without error " do
-      @resource.recursive(false)
-      @provider.run_action(:create)
-      expect(::File.exist?(@destination_dir)).to be_truthy
-    end
-
-    it "transfers the directory with all contents" do
-      @provider.run_action(:create)
-      expect(::File.exist?(@destination_dir + "/remote_dir_file1.txt")).to be_truthy
-      expect(::File.exist?(@destination_dir + "/remote_dir_file2.txt")).to be_truthy
-      expect(::File.exist?(@destination_dir + "/remotesubdir/remote_subdir_file1.txt")).to be_truthy
-      expect(::File.exist?(@destination_dir + "/remotesubdir/remote_subdir_file2.txt")).to be_truthy
-      expect(::File.exist?(@destination_dir + "/remotesubdir/.a_dotfile")).to be_truthy
-      expect(::File.exist?(@destination_dir + "/.a_dotdir/.a_dotfile_in_a_dotdir")).to be_truthy
-    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)
-
-        expect(file1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + "/remote_dir_file1.txt")))).to be_truthy
-        expect(subdirfile1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + "/remotesubdir/remote_subdir_file1.txt")))).to be_truthy
-      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)
-
-        expect(::File.exist?(@destination_dir + "/remote_dir_file1.txt")).to be_truthy
-        expect(::File.exist?(@destination_dir + "/remote_dir_file2.txt")).to be_truthy
-        expect(::File.exist?(@destination_dir + "/remotesubdir/remote_subdir_file1.txt")).to be_truthy
-        expect(::File.exist?(@destination_dir + "/remotesubdir/remote_subdir_file2.txt")).to be_truthy
-
-        expect(::File.exist?(@destination_dir + "/marked_for_death.txt")).to be_falsey
-        expect(::File.exist?(@destination_dir + "/remotesubdir/marked_for_death_again.txt")).to be_falsey
-      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)
-        expect(::File.exist?(@destination_dir + "/a/foo.txt")).to be_falsey
-        expect(::File.exist?(@destination_dir + "/a/multiply/bar.txt")).to be_falsey
-        expect(::File.exist?(@destination_dir + "/a/multiply/nested/baz.txt")).to be_falsey
-        expect(::File.exist?(@destination_dir + "/a/multiply/nested/directory/qux.txt")).to be_falsey
-      end
-
-      it "removes directory symlinks properly" do
-        symlinked_dir_path = @destination_dir + "/symlinked_dir"
-        @provider.action = :create
-        @provider.run_action
-
-        @fclass = Chef::CFCCheck.new
-
-        Dir.mktmpdir do |tmp_dir|
-
-          @fclass.file_class.symlink(tmp_dir.dup, symlinked_dir_path)
-          expect(::File.exist?(symlinked_dir_path)).to be_truthy
-
-          @provider.run_action
-
-          expect(::File.exist?(symlinked_dir_path)).to be_falsey
-          expect(::File.exist?(tmp_dir)).to be_truthy
-        rescue Chef::Exceptions::Win32APIError
-          skip "This must be run as an Administrator to create symlinks"
-
-        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)
-        expect(file1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + "/remote_dir_file1.txt")))).to be_truthy
-        expect(subdirfile1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + "/remotesubdir/remote_subdir_file1.txt")))).to be_truthy
-      end
-    end
-
-  end
-end

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

@@ -1,245 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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"
-
-CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH = 64
-CACHE_FILE_CHECKSUM_HEX_LENGTH = 32
-CACHE_FILE_JSON_FILE_EXTENSION_LENGTH = 5
-CACHE_FILE_PATH_LIMIT =
-  CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH +
-  1 +
-  CACHE_FILE_CHECKSUM_HEX_LENGTH +
-  CACHE_FILE_JSON_FILE_EXTENSION_LENGTH # {friendly}-{md5hex}.json == 102
-
-describe Chef::Provider::RemoteFile::CacheControlData do
-
-  let(:uri) { URI.parse("http://www.google.com/robots.txt") }
-
-  subject(:cache_control_data) do
-    Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, current_file_checksum)
-  end
-
-  let(:cache_path) { "remote_file/http___www_google_com_robots_txt-6dc1b24315d0cff764d30344199c6f7b.json" }
-  let(:old_cache_path) { "remote_file/http___www_google_com_robots_txt-9839677abeeadf0691026e0cabca2339.json" }
-
-  # the checksum of the file we have on disk already
-  let(:current_file_checksum) { "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }
-
-  context "when loading data for an unknown URI" do
-
-    before do
-      expect(Chef::FileCache).to receive(:key?).with(cache_path).and_return(false)
-      expect(Chef::FileCache).to receive(:key?).with(old_cache_path).and_return(false)
-    end
-
-    context "and there is no current copy of the file" do
-      let(:current_file_checksum) { nil }
-
-      it "returns empty cache control data" do
-        expect(cache_control_data.etag).to be_nil
-        expect(cache_control_data.mtime).to be_nil
-      end
-    end
-
-    it "returns empty cache control data" do
-      expect(cache_control_data.etag).to be_nil
-      expect(cache_control_data.mtime).to be_nil
-    end
-
-    context "and the URI contains a password" do
-
-      let(:uri) { URI.parse("http://bob:password@example.org/") }
-      let(:cache_path) { "remote_file/http___bob_XXXX_example_org_-44be109aa176a165ef599c12d97af792.json" }
-      let(:old_cache_path) { "remote_file/http___bob_XXXX_example_org_-f121caacb74c05a35bcefdf578ed5fc9.json" }
-
-      it "loads the cache data from a path based on a sanitized URI" do
-        Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, current_file_checksum)
-      end
-    end
-  end
-
-  describe "when loading data for a known URI" do
-
-    # the checksum of the file last we fetched it.
-    let(:last_fetched_checksum) { "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }
-
-    let(:etag) { "\"a-strong-identifier\"" }
-    let(:mtime) { "Tue, 21 May 2013 19:19:23 GMT" }
-
-    let(:cache_json_data) do
-      cache = {}
-      cache["etag"] = etag
-      cache["mtime"] = mtime
-      cache["checksum"] = last_fetched_checksum
-      Chef::JSONCompat.to_json(cache)
-    end
-
-    context "when the cache control data uses sha256 for its name" do
-      before do
-        expect(Chef::FileCache).to receive(:key?).with(cache_path).and_return(true)
-        expect(Chef::FileCache).to receive(:load).with(cache_path).and_return(cache_json_data)
-      end
-
-      context "and there is no on-disk copy of the file" do
-        let(:current_file_checksum) { nil }
-
-        it "returns empty cache control data" do
-          expect(cache_control_data.etag).to be_nil
-          expect(cache_control_data.mtime).to be_nil
-        end
-      end
-
-      context "and the cached checksum does not match the on-disk copy" do
-        let(:current_file_checksum) { "e2a8938cc31754f6c067b35aab1d0d4864272e9bf8504536ef3e79ebf8432305" }
-
-        it "returns empty cache control data" do
-          expect(cache_control_data.etag).to be_nil
-          expect(cache_control_data.mtime).to be_nil
-        end
-      end
-
-      context "and the cached checksum matches the on-disk copy" do
-        context "when the filename uses sha256" do
-          before do
-            expect(Chef::FileCache).not_to receive(:key?).with(old_cache_path)
-          end
-          it "populates the cache control data" do
-            expect(cache_control_data.etag).to eq(etag)
-            expect(cache_control_data.mtime).to eq(mtime)
-          end
-        end
-      end
-
-      context "and the cached checksum data is corrupted" do
-        let(:cache_json_data) { '{"foo",,"bar" []}' }
-
-        it "returns empty cache control data" do
-          expect(cache_control_data.etag).to be_nil
-          expect(cache_control_data.mtime).to be_nil
-        end
-
-        context "and it still is valid JSON" do
-          let(:cache_json_data) { "" }
-
-          it "returns empty cache control data" do
-            expect(cache_control_data.etag).to be_nil
-            expect(cache_control_data.mtime).to be_nil
-          end
-        end
-      end
-    end
-
-    context "when the filename uses md5" do
-      before do
-        expect(Chef::FileCache).to receive(:key?).with(cache_path).and_return(false)
-        expect(Chef::FileCache).to receive(:key?).with(old_cache_path).and_return(true)
-        expect(Chef::FileCache).to receive(:load).with(old_cache_path).and_return(cache_json_data)
-      end
-
-      it "populates the cache control data and creates the cache control data file with the correct path" do
-        expect(Chef::FileCache).to receive(:store).with(cache_path, cache_json_data)
-        expect(Chef::FileCache).to receive(:delete).with(old_cache_path)
-        expect(cache_control_data.etag).to eq(etag)
-        expect(cache_control_data.mtime).to eq(mtime)
-      end
-    end
-  end
-
-  describe "when saving to disk" do
-
-    let(:etag) { "\"a-strong-identifier\"" }
-    let(:mtime) { "Tue, 21 May 2013 19:19:23 GMT" }
-    let(:fetched_file_checksum) { "e2a8938cc31754f6c067b35aab1d0d4864272e9bf8504536ef3e79ebf8432305" }
-
-    let(:expected_serialization_data) do
-      data = {}
-      data["etag"] = etag
-      data["mtime"] = mtime
-      data["checksum"] = fetched_file_checksum
-      data
-    end
-
-    before do
-      cache_control_data.etag = etag
-      cache_control_data.mtime = mtime
-      cache_control_data.checksum = fetched_file_checksum
-    end
-
-    it "serializes its properties to JSON" do
-      # we have to test this separately because ruby 1.8 hash order is unstable
-      # so we can't count on the order of the keys in the json format.
-
-      json_data = cache_control_data.json_data
-      expect(Chef::JSONCompat.from_json(json_data)).to eq(expected_serialization_data)
-    end
-
-    it "writes data to the cache" do
-      json_data = cache_control_data.json_data
-      expect(Chef::FileCache).to receive(:store).with(cache_path, json_data)
-      cache_control_data.save
-    end
-
-    context "and the URI contains a password" do
-
-      let(:uri) { URI.parse("http://bob:password@example.org/") }
-      let(:cache_path) { "remote_file/http___bob_XXXX_example_org_-44be109aa176a165ef599c12d97af792.json" }
-      let(:old_cache_path) { "remote_file/http___bob_XXXX_example_org_-f121caacb74c05a35bcefdf578ed5fc9.json" }
-
-      it "writes the data to the cache with a sanitized path name" do
-        json_data = cache_control_data.json_data
-        expect(Chef::FileCache).to receive(:store).with(cache_path, json_data)
-        cache_control_data.save
-      end
-    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 "and the URI results in a file cache path that exceeds #{CACHE_FILE_PATH_LIMIT} characters in length" do
-      let(:long_remote_path) { "http://www.bing.com/" + ("0" * (CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH * 2 )) }
-      let(:uri) { URI.parse(long_remote_path) }
-      let(:truncated_remote_uri) { URI.parse(long_remote_path[0...CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH]) }
-      let(:truncated_file_cache_path) do
-        cache_control_data_truncated = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(truncated_remote_uri, current_file_checksum)
-        cache_control_data_truncated.send(:sanitized_cache_file_basename)[0...CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH]
-      end
-
-      it "truncates the file cache path to 102 characters" do
-        normalized_cache_path = cache_control_data.send(:sanitized_cache_file_basename)
-
-        expect(Chef::FileCache).to receive(:store).with("remote_file/" + normalized_cache_path, cache_control_data.json_data)
-
-        cache_control_data.save
-
-        expect(normalized_cache_path.length).to eq(CACHE_FILE_PATH_LIMIT)
-      end
-
-      it "uses a file cache path that starts with the first #{CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH} characters of the URI" do
-        normalized_cache_path = cache_control_data.send(:sanitized_cache_file_basename)
-
-        expect(truncated_file_cache_path.length).to eq(CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH)
-        expect(normalized_cache_path.start_with?(truncated_file_cache_path)).to eq(true)
-      end
-    end
-
-  end
-
-end