chef 18.8.11 → 18.8.54

data/spec/functional/dsl/reboot_pending_spec.rb

@@ -1,88 +0,0 @@
-#
-# Author:: Bryan McLellan <btm@loftninjas.org>
-# 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 "chef/dsl/reboot_pending"
-require "chef/dsl/registry_helper"
-require "chef/win32/registry"
-require "spec_helper"
-
-describe Chef::DSL::RebootPending, :windows_only do
-  include Chef::DSL::RegistryHelper
-
-  def run_ohai
-    node.consume_external_attrs(OHAI_SYSTEM.data, {})
-  end
-
-  let(:node) { Chef::Node.new }
-  let!(:ohai) { run_ohai } # Ensure we have necessary node data
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:recipe) { Chef::Recipe.new("a windows cookbook", "the windows recipe", run_context) }
-  let(:registry) { Chef::Win32::Registry.new(run_context) }
-
-  describe "reboot_pending?" do
-    let(:reg_key) { nil }
-    let(:original_set) { false }
-
-    describe "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\PendingFileRenameOperations" do
-      let(:reg_key) { "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager" }
-      let(:original_set) { registry.value_exists?(reg_key, { name: "PendingFileRenameOperations" }) }
-
-      it "returns true if the registry value exists" do
-        skip "found existing registry key" if original_set
-        registry.set_value(reg_key,
-          { name: "PendingFileRenameOperations", type: :multi_string, data: ['\??\C:\foo.txt|\??\C:\bar.txt'] })
-
-        expect(recipe.reboot_pending?).to be_truthy
-      end
-
-      after do
-        unless original_set
-          registry.delete_value(reg_key, { name: "PendingFileRenameOperations" })
-        end
-      end
-    end
-
-    describe 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired' do
-      let(:reg_key) { 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired' }
-      let(:original_set) { registry.key_exists?(reg_key) }
-
-      it "returns true if the registry key exists" do
-        skip "found existing registry key" if original_set
-        registry.create_key(reg_key, false)
-
-        expect(recipe.reboot_pending?).to be_truthy
-      end
-
-      after do
-        unless original_set
-          registry.delete_key(reg_key, false)
-        end
-      end
-    end
-
-    describe "when there is nothing to indicate a reboot is pending" do
-      it "should return false" do
-        skip "reboot pending" if registry_value_exists?("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager", { name: "PendingFileRenameOperations" }) ||
-          registry_key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired') ||
-          registry_key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending')
-        expect(recipe.reboot_pending?).to be_falsey
-      end
-    end
-  end
-end

data/spec/functional/dsl/registry_helper_spec.rb

@@ -1,61 +0,0 @@
-#
-# Author:: Prajakta Purohit (<prajakta@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 "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
-    node.consume_external_attrs(OHAI_SYSTEM.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
-      expect(@resource.registry_key_exists?("HKCU\\Software\\Root")).to eq(true)
-    end
-    it "returns true if registry has specified value" do
-      values = @resource.registry_get_values("HKCU\\Software\\Root")
-      expect(values.include?({ name: "RootType1", type: :string, data: "fibrous" })).to eq(true)
-    end
-    it "returns true if specified registry_has_subkey" do
-      expect(@resource.registry_has_subkeys?("HKCU\\Software\\Root")).to eq(true)
-    end
-    it "returns true if specified key has specified subkey" do
-      subkeys = @resource.registry_get_subkeys("HKCU\\Software\\Root")
-      expect(subkeys.include?("Branch")).to eq(true)
-    end
-    it "returns true if registry_value_exists" do
-      expect(@resource.registry_value_exists?("HKCU\\Software\\Root", { name: "RootType1", type: :string, data: "fibrous" })).to eq(true)
-    end
-    it "returns true if data_value_exists" do
-      expect(@resource.registry_data_exists?("HKCU\\Software\\Root", { name: "RootType1", type: :string, data: "fibrous" })).to eq(true)
-    end
-  end
-end

data/spec/functional/event_loggers/windows_eventlog_spec.rb

@@ -1,107 +0,0 @@
-#
-# Author:: Jay Mundrawala (<jdm@chef.io>)
-#
-# Copyright:: Copyright (c) Chef Software Inc.
-#
-# 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 "securerandom"
-require "chef/event_loggers/windows_eventlog"
-require "chef-utils"
-if ChefUtils.windows?
-  require "win32/eventlog"
-  include Win32
-end
-
-describe Chef::EventLoggers::WindowsEventLogger, :windows_only do
-  def rand
-    random.rand(1 << 32).to_s
-  end
-
-  let(:random)       { Random.new }
-  let(:run_id)       { rand }
-  let(:version)      { rand }
-  let(:elapsed_time) { rand }
-  let(:logger)       { Chef::EventLoggers::WindowsEventLogger.new }
-  let(:flags)        { nil }
-  let(:node)         { nil }
-  let(:run_status)   { double("Run Status", { run_id: run_id, elapsed_time: elapsed_time }) }
-  let(:event_log)    { EventLog.new("Application") }
-  let!(:offset)      { event_log.read_last_event.record_number }
-  let(:mock_exception) { double("Exception", { message: rand, backtrace: [rand, rand] }) }
-
-  it "is available" do
-    expect(Chef::EventLoggers::WindowsEventLogger.available?).to be_truthy
-  end
-
-  it "writes run_start event with event_id 10000 and contains version" do
-    logger.run_start(version, run_status)
-
-    expect(event_log.read(flags, offset).any? do |e|
-      e.source == ChefUtils::Dist::Infra::SHORT && e.event_id == 10000 &&
-                                        e.string_inserts[0].include?(version)
-    end ).to be_truthy
-  end
-
-  it "writes run_started event with event_id 10001 and contains the run_id" do
-    logger.run_started(run_status)
-
-    expect(event_log.read(flags, offset).any? do |e|
-      e.source == ChefUtils::Dist::Infra::SHORT && e.event_id == 10001 &&
-                                        e.string_inserts[0].include?(run_id)
-    end ).to be_truthy
-  end
-
-  it "writes run_completed event with event_id 10002 and contains the run_id and elapsed time" do
-    logger.run_started(run_status)
-    logger.run_completed(node)
-
-    expect(event_log.read(flags, offset).any? do |e|
-      e.source == ChefUtils::Dist::Infra::SHORT && e.event_id == 10002 &&
-                                         e.string_inserts[0].include?(run_id) &&
-                                         e.string_inserts[1].include?(elapsed_time.to_s)
-    end).to be_truthy
-  end
-
-  it "writes run_failed event with event_id 10003 and contains the run_id, elapsed time, and exception info" do
-    logger.run_started(run_status)
-    logger.run_failed(mock_exception)
-
-    expect(event_log.read(flags, offset).any? do |e|
-      e.source == ChefUtils::Dist::Infra::SHORT && e.event_id == 10003 &&
-        e.string_inserts[0].include?(run_id) &&
-        e.string_inserts[1].include?(elapsed_time.to_s) &&
-        e.string_inserts[2].include?(mock_exception.class.name) &&
-        e.string_inserts[3].include?(mock_exception.message) &&
-        e.string_inserts[4].include?(mock_exception.backtrace[0]) &&
-        e.string_inserts[4].include?(mock_exception.backtrace[1])
-    end).to be_truthy
-  end
-
-  it "writes run_failed event with event_id 10003 even when run_status is not set" do
-    logger.run_failed(mock_exception)
-
-    expect(event_log.read(flags, offset).any? do |e|
-      e.source == ChefUtils::Dist::Infra::SHORT && e.event_id == 10003 &&
-        e.string_inserts[0].include?("UNKNOWN") &&
-        e.string_inserts[1].include?("UNKNOWN") &&
-        e.string_inserts[2].include?(mock_exception.class.name) &&
-        e.string_inserts[3].include?(mock_exception.message) &&
-        e.string_inserts[4].include?(mock_exception.backtrace[0]) &&
-        e.string_inserts[4].include?(mock_exception.backtrace[1])
-    end).to be_truthy
-  end
-
-end

data/spec/functional/file_content_management/deploy_strategies_spec.rb

@@ -1,229 +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"
-
-shared_examples_for "a content deploy strategy" do
-
-  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(0666 & ~File.umask) }
-
-    it "touches the file to create it (UNIX)", :unix_only do
-      content_deployer.create(target_file_path)
-      expect(File).to exist(target_file_path)
-      file_info = File.stat(target_file_path)
-      expect(file_info).to be_owned
-      expect(file_info).to be_file
-      expect(normalize_mode(file_info.mode)).to eq(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
-
-    it "touches the file to create it (Windows)", :windows_only do
-      content_deployer.create(target_file_path)
-      expect(File).to exist(target_file_path)
-      file_info = File.stat(target_file_path)
-      expect(file_info).to be_owned
-      expect(file_info).to 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)
-      # On certain windows systems like 2003 and Azure VMs there are some default
-      # ACEs that are not inherited from parents. So filter out the parents before
-      # comparing the aces
-      self_aces = security_descriptor.dacl.select do |ace|
-        ace_inherits?(ace)
-      end
-
-      self_aces.each_with_index do |ace, index|
-        expect(ace.mask).to eq(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_properties(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)
-
-      expect(unix_invariant_properties(original_info)).to eq(unix_invariant_properties(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)
-
-      expect(win_invariant_properties(original_info)).to eq(win_invariant_properties(updated_info))
-    end
-
-    it "updates the target with content from staged" do
-      content_deployer.deploy(staging_file_path, target_file_path)
-      expect(IO.binread(target_file_path)).to eq(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)
-
-        expect(unix_invariant_properties(original_info)).to eq(unix_invariant_properties(updated_info))
-      end
-
-    end
-
-  end
-end
-
-describe Chef::FileContentManagement::Deploy::Cp do
-
-  let(:unix_invariants) do
-    %i{
-      uid
-      gid
-      mode
-      ino
-    }
-  end
-
-  let(:security_descriptor_invariants) do
-    %i{
-      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
-    %i{
-      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
-      %i{
-       owner
-       group
-       dacl
-      }
-    end
-
-    it_should_behave_like "a content deploy strategy"
-  end
-
-end

data/spec/functional/http/simple_spec.rb

@@ -1,146 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@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 "tiny_server"
-require "support/shared/functional/http"
-
-describe Chef::HTTP::Simple do
-  include ChefHTTPShared
-
-  let(:http_client) { described_class.new(source) }
-  let(:http_client_disable_gzip) { described_class.new(source, { disable_gzip: true } ) }
-
-  before(:all) do
-    start_tiny_server(RequestTimeout: 1)
-  end
-
-  before(:each) do
-    Chef::Config[:rest_timeout] = 2
-    Chef::Config[:http_retry_delay] = 1
-    Chef::Config[:http_retry_count] = 2
-  end
-
-  after(:all) do
-    stop_tiny_server
-  end
-
-  shared_examples_for "downloads requests correctly" do
-    it "successfully downloads a streaming request" do
-      tempfile = http_client.streaming_request(source, {})
-      tempfile.close
-      expect(Digest::MD5.hexdigest(binread(tempfile.path))).to eq(Digest::MD5.hexdigest(expected_content))
-    end
-    it "successfully does a non-streaming GET request" do
-      expect(Digest::MD5.hexdigest(http_client.get(source))).to eq(Digest::MD5.hexdigest(expected_content))
-    end
-  end
-
-  shared_examples_for "validates content length and throws an exception" do
-    it "a streaming request throws a content length exception" do
-      expect { http_client.streaming_request(source) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
-    end
-    it "a non-streaming GET request throws a content length exception" do
-      expect { http_client.get(source) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
-    end
-  end
-
-  shared_examples_for "an endpoint that 403s" do
-    it "fails with a Net::HTTPClientException for a streaming request" do
-      expect { http_client.streaming_request(source) }.to raise_error(Net::HTTPClientException)
-    end
-
-    it "fails with a Net::HTTPClientException for a GET request" do
-      expect { http_client.get(source) }.to raise_error(Net::HTTPClientException)
-    end
-  end
-
-  # see CHEF-5100
-  shared_examples_for "a 403 after a successful request when reusing the request object" do
-    it "fails with a Net::HTTPClientException for a streaming request" do
-      tempfile = http_client.streaming_request(source)
-      tempfile.close
-      expect(Digest::MD5.hexdigest(binread(tempfile.path))).to eq(Digest::MD5.hexdigest(expected_content))
-      expect { http_client.streaming_request(source2) }.to raise_error(Net::HTTPClientException)
-    end
-
-    it "fails with a Net::HTTPClientException for a GET request" do
-      expect(Digest::MD5.hexdigest(http_client.get(source))).to eq(Digest::MD5.hexdigest(expected_content))
-      expect { http_client.get(source2) }.to raise_error(Net::HTTPClientException)
-    end
-  end
-
-  it_behaves_like "downloading all the things"
-
-  context "when Chef::Log.level = :trace" do
-    before do
-      Chef::Log.level = :trace
-      @debug_log = ""
-      allow(Chef::Log).to receive(:trace) { |str| @debug_log << str }
-    end
-
-    let(:source) { "http://localhost:9000" }
-
-    it "Logs the request and response for 200's but not the body" do
-      http_client.get("http://localhost:9000/nyan_cat.png")
-      expect(@debug_log).to match(/200/)
-      expect(@debug_log).to match(/HTTP Request Header Data/)
-      expect(@debug_log).to match(/HTTP Status and Header Data/)
-      expect(@debug_log).not_to match(/HTTP Request Body/)
-      expect(@debug_log).not_to match(/HTTP Response Body/)
-      expect(@debug_log).not_to match(/Your request is just terrible./)
-    end
-
-    it "Logs the request and response for 200 POST, but not the body" do
-      http_client.post("http://localhost:9000/posty", "hithere")
-      expect(@debug_log).to match(/200/)
-      expect(@debug_log).to match(/HTTP Request Header Data/)
-      expect(@debug_log).to match(/HTTP Status and Header Data/)
-      expect(@debug_log).not_to match(/HTTP Request Body/)
-      expect(@debug_log).not_to match(/hithere/)
-      expect(@debug_log).not_to match(/HTTP Response Body/)
-      expect(@debug_log).not_to match(/Your request is just terrible./)
-    end
-
-    it "Logs the request and response and bodies for 400 response" do
-      expect do
-        http_client.get("http://localhost:9000/bad_request")
-      end.to raise_error(Net::HTTPClientException)
-      expect(@debug_log).to match(/400/)
-      expect(@debug_log).to match(/HTTP Request Header Data/)
-      expect(@debug_log).to match(/HTTP Status and Header Data/)
-      expect(@debug_log).not_to match(/HTTP Request Body/)
-      expect(@debug_log).not_to match(/hithere/)
-      expect(@debug_log).to match(/HTTP Response Body/)
-      expect(@debug_log).to match(/Your request is just terrible./)
-    end
-
-    it "Logs the request and response and bodies for 400 POST response" do
-      expect do
-        http_client.post("http://localhost:9000/bad_request", "hithere")
-      end.to raise_error(Net::HTTPClientException)
-      expect(@debug_log).to match(/400/)
-      expect(@debug_log).to match(/HTTP Request Header Data/)
-      expect(@debug_log).to match(/HTTP Status and Header Data/)
-      expect(@debug_log).to match(/HTTP Request Body/)
-      expect(@debug_log).to match(/hithere/)
-      expect(@debug_log).to match(/HTTP Response Body/)
-      expect(@debug_log).to match(/Your request is just terrible./)
-    end
-  end
-end