chef 18.8.11 → 18.8.54

data/spec/functional/mixin/from_file_spec.rb

@@ -1,93 +0,0 @@
-#
-# 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"
-
-describe Chef::Mixin::FromFile do
-  REAL_DATA = File.join(CHEF_SPEC_DATA, "mixin", "real_data.rb")
-  INVALID_DATA = File.join(CHEF_SPEC_DATA, "mixin", "invalid_data.rb")
-  NO_DATA = File.join(CHEF_SPEC_DATA, "mixin", "non_existant_data.rb")
-  DIRECTORY = File.expand_path("")
-
-  class TestData
-    include Chef::Mixin::FromFile
-
-    def a(a = nil)
-      @a = a if a
-      @a
-    end
-  end
-
-  class ClassTestData
-    class << self
-      include Chef::Mixin::FromFile
-
-      def a(a = nil)
-        @a = a if a
-        @a
-      end
-    end
-  end
-
-  describe "from_file" do
-    it "should load data" do
-      datum = TestData.new
-      datum.from_file(REAL_DATA)
-      expect(datum.a).to eq(:foo)
-    end
-
-    it "should load class data" do
-      datum = ClassTestData
-      datum.class_from_file(REAL_DATA)
-      expect(datum.a).to eq(:foo)
-    end
-
-    it "should set source_file" do
-      datum = TestData.new
-      datum.from_file(REAL_DATA)
-      expect(datum.source_file).to eq(REAL_DATA)
-    end
-
-    it "should set class source_file" do
-      datum = ClassTestData
-      datum.class_from_file(REAL_DATA)
-      expect(datum.source_file).to eq(REAL_DATA)
-    end
-
-    it "should fail on invalid data" do
-      datum = TestData.new
-      expect do
-        datum.from_file(INVALID_DATA)
-      end.to raise_error(NoMethodError)
-    end
-
-    it "should fail on nonexistant data" do
-      datum = TestData.new
-      expect { datum.from_file(NO_DATA) }.to raise_error(IOError)
-    end
-
-    it "should fail if it's a directory not a file" do
-      datum = TestData.new
-      expect { datum.from_file(DIRECTORY) }.to raise_error(IOError)
-    end
-
-    it "should fail class if it's a directory not a file" do
-      datum = ClassTestData
-      expect { datum.from_file(DIRECTORY) }.to raise_error(IOError)
-    end
-  end
-end

data/spec/functional/mixin/powershell_out_spec.rb

@@ -1,51 +0,0 @@
-#
-# 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 "chef/mixin/powershell_out"
-
-describe Chef::Mixin::PowershellOut, :windows_only do
-  include Chef::Mixin::PowershellOut
-
-  describe "#powershell_out" do
-    it "runs a powershell command and collects stdout" do
-      expect(powershell_out("get-process").run_command.stdout).to match(/Handles/)
-    end
-
-    it "uses :powershell by default" do
-      expect(powershell_out("$PSVersionTable").run_command.stdout).to match(/CLRVersion/)
-    end
-
-    it ":pwsh interpreter uses core edition", :pwsh_installed do
-      expect(powershell_out("$PSVersionTable", :pwsh).run_command.stdout).to match(/Core/)
-    end
-
-    it "does not raise exceptions when the command is invalid" do
-      powershell_out("this-is-not-a-valid-command").run_command
-    end
-  end
-
-  describe "#powershell_out!" do
-    it "runs a powershell command and collects stdout" do
-      expect(powershell_out!("get-process").run_command.stdout).to match(/Handles/)
-    end
-
-    it "raises exceptions when the command is invalid" do
-      expect { powershell_out!("this-is-not-a-valid-command").run_command }.to raise_exception(Mixlib::ShellOut::ShellCommandFailed)
-    end
-  end
-end

data/spec/functional/mixin/shell_out_spec.rb

@@ -1,48 +0,0 @@
-#
-# 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"
-
-describe Chef::Mixin::ShellOut do
-  include Chef::Mixin::ShellOut
-
-  describe "shell_out default_env: false" do
-    describe "when environment['LC_ALL'] is not set" do
-      it "should use the default shell_out setting" do
-        cmd = if windows?
-                shell_out("echo %LC_ALL%", default_env: false)
-              else
-                shell_out("echo $LC_ALL", default_env: false)
-              end
-
-        expect(cmd.stdout.chomp).to match_environment_variable("LC_ALL")
-      end
-    end
-
-    describe "when environment['LC_ALL'] is set" do
-      it "should use the option's setting" do
-        cmd = if windows?
-                shell_out("echo %LC_ALL%", environment: { "LC_ALL" => "POSIX" }, default_env: false)
-              else
-                shell_out("echo $LC_ALL", environment: { "LC_ALL" => "POSIX" }, default_env: false)
-              end
-
-        expect(cmd.stdout.chomp).to eq "POSIX"
-      end
-    end
-  end
-end

data/spec/functional/mixin/user_context_spec.rb

@@ -1,119 +0,0 @@
-#
-# 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 "chef/win32/api" if ChefUtils.windows?
-require "chef/win32/api/error" if ChefUtils.windows?
-require "chef/mixin/user_context"
-
-describe Chef::Mixin::UserContext, windows_only: true do
-  include Chef::Mixin::UserContext
-
-  let(:get_user_name_a) do
-    FFI.ffi_lib "advapi32.dll"
-    FFI.attach_function :GetUserNameA, %i{pointer pointer}, :bool
-  end
-
-  let(:process_username) do
-    name_size = FFI::Buffer.new(:long).write_long(0)
-    succeeded = get_user_name_a.call(nil, name_size)
-    last_error = FFI::LastError.error
-    if succeeded || last_error != Chef::ReservedNames::Win32::API::Error::ERROR_INSUFFICIENT_BUFFER
-      raise Chef::Exceptions::Win32APIError, "Expected ERROR_INSUFFICIENT_BUFFER from GetUserNameA but it returned the following error: #{last_error}"
-    end
-
-    user_name = FFI::MemoryPointer.new :char, (name_size.read_long)
-    succeeded = get_user_name_a.call(user_name, name_size)
-    last_error = FFI::LastError.error
-    if succeeded == 0 || last_error != 0
-      raise Chef::Exceptions::Win32APIError, "GetUserNameA failed with #{lasterror}"
-    end
-
-    user_name.read_string
-  end
-
-  let(:test_user) { "chefuserctx3" }
-  let(:test_domain) { windows_nonadmin_user_domain }
-  let(:test_password) { "j823jfxK3;2Xe1" }
-
-  let(:username_domain_qualification) { nil }
-  let(:username_with_conditional_domain) { username_domain_qualification.nil? ? username_to_impersonate : "#{username_domain_qualification}\\#{username_to_impersonate}" }
-
-  let(:windows_nonadmin_user) { test_user }
-  let(:windows_nonadmin_user_password) { test_password }
-
-  let(:username_while_impersonating) do
-    username = nil
-    with_user_context(username_with_conditional_domain, username_to_impersonate_password, domain_to_impersonate) do
-      username = process_username
-    end
-    username
-  end
-
-  before do
-    allow_any_instance_of(described_class).to receive(:node).and_return({ "platform_family" => "windows" })
-  end
-
-  shared_examples_for "method that executes the block while impersonating the alternate user" do
-    it "uses different credentials for other network connections" do
-      allow_any_instance_of(Chef::Util::Windows::LogonSession).to receive(:validate_session_open!).and_return(true)
-      expect(username_while_impersonating.downcase).not_to eq(username_to_impersonate.downcase)
-    end
-  end
-
-  describe "#with_user_context" do
-    context "when the user and domain are both nil" do
-      let(:username_to_impersonate) { nil }
-      let(:domain_to_impersonate) { nil }
-      let(:username_to_impersonate_password) { nil }
-
-      it "has the same token and username as the process" do
-        expect(username_while_impersonating.downcase).to eq(ENV["username"].downcase)
-      end
-    end
-
-    context "when a non-nil user is specified" do
-      include_context "a non-admin Windows user"
-      context "when a username different than the process user is specified" do
-        let(:username_to_impersonate) { test_user }
-        let(:username_to_impersonate_password) { test_password }
-        context "when an explicit domain is given with a valid password" do
-          let(:domain_to_impersonate) { test_domain }
-          it "uses different credentials for other network connections" do
-            expect(username_while_impersonating.downcase).not_to eq(username_to_impersonate.downcase)
-          end
-        end
-
-        context "when a valid password and a non-qualified user is given and no domain is specified" do
-          let(:domain_to_impersonate) { "." }
-          it_behaves_like "method that executes the block while impersonating the alternate user"
-        end
-
-        it "raises an error user if specified with the wrong password" do
-          expect { with_user_context(username_to_impersonate, username_to_impersonate_password + "1", nil) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-
-    context "when invalid arguments are passed" do
-      it "raises an ArgumentError exception if the password is not specified but the user is specified" do
-        expect { with_user_context(test_user, nil, nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/functional/notifications_spec.rb

@@ -1,238 +0,0 @@
-require "spec_helper"
-require "chef/recipe"
-
-# The goal of these tests is to make sure that loading resources from a file creates the necessary notifications.
-# Then once converge has started, both immediate and delayed notifications are called as the resources are converged.
-# We want to do this WITHOUT actually converging any resources - we don't want to take time changing the system,
-# we just want to make sure the run_context, the notification DSL and the converge hooks are working together
-# to perform notifications.
-
-# This test is extremely fragile since it mocks MANY different systems at once - any of them changes, this test
-# breaks
-describe "Notifications" do
-
-  # We always pretend we are on OSx because that has a specific provider (HomebrewProvider) so it
-  # tests the translation from Provider => HomebrewProvider
-  let(:node) do
-    n = Chef::Node.new
-    n.override[:os] = "darwin"
-    n
-  end
-  let(:cookbook_collection) { double("Chef::CookbookCollection").as_null_object }
-  let(:events) { double("Chef::EventDispatch::Dispatcher").as_null_object }
-  let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
-  let(:recipe) { Chef::Recipe.new("notif", "test", run_context) }
-  let(:runner) { Chef::Runner.new(run_context) }
-
-  before do
-    # By default, every provider will do nothing
-    p = Chef::Provider.new(Chef::Resource.new("lies"), run_context)
-    allow_any_instance_of(Chef::Resource).to receive(:provider_for_action).and_return(p)
-    allow(p).to receive(:run_action)
-  end
-
-  it "should subscribe from one resource to another" do
-    log_resource = recipe.declare_resource(:log, "subscribed-log") do
-      message "This is a log message"
-      action :nothing
-      subscribes :write, "package[vim]", :immediately
-    end
-
-    package_resource = recipe.declare_resource(:package, "vim") do
-      action :install
-    end
-
-    expect(log_resource).to receive(:run_action).with(:nothing, nil, nil).and_call_original
-
-    expect(package_resource).to receive(:run_action).with(:install, nil, nil).and_call_original
-    update_action(package_resource)
-
-    expect(log_resource).to receive(:run_action).with(:write, :immediate, package_resource).and_call_original
-
-    runner.converge
-  end
-
-  it "should notify from one resource to another immediately" do
-    log_resource = recipe.declare_resource(:log, "log") do
-      message "This is a log message"
-      action :write
-      notifies :install, "package[vim]", :immediately
-    end
-
-    package_resource = recipe.declare_resource(:package, "vim") do
-      action :nothing
-    end
-
-    expect(log_resource).to receive(:run_action).with(:write, nil, nil).and_call_original
-    update_action(log_resource)
-
-    expect(package_resource).to receive(:run_action).with(:install, :immediate, log_resource).ordered.and_call_original
-
-    expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
-
-    runner.converge
-  end
-
-  it "should notify from one resource to another before" do
-    log_resource = recipe.declare_resource(:log, "log") do
-      message "This is a log message"
-      action :write
-      notifies :install, "package[vim]", :before
-    end
-    update_action(log_resource, 2)
-
-    package_resource = recipe.declare_resource(:package, "vim") do
-      action :nothing
-    end
-
-    actions = []
-    [ log_resource, package_resource ].each do |resource|
-      allow(resource).to receive(:run_action).and_wrap_original do |m, action, notification_type, notifying_resource|
-        actions << { resource: resource.to_s, action: action }
-        actions[-1][:why_run] = Chef::Config[:why_run] if Chef::Config[:why_run]
-        actions[-1][:notification_type] = notification_type if notification_type
-        actions[-1][:notifying_resource] = notifying_resource.to_s if notifying_resource
-        m.call(action, notification_type, notifying_resource)
-      end
-    end
-
-    runner.converge
-
-    expect(actions).to eq [
-      # First it runs why-run to check if the resource would update
-      { resource: log_resource.to_s,     action: :write,   why_run: true },
-      # Then it runs the before action
-      { resource: package_resource.to_s, action: :install, notification_type: :before, notifying_resource: log_resource.to_s },
-      # Then it runs the actual action
-      { resource: log_resource.to_s,     action: :write },
-      { resource: package_resource.to_s, action: :nothing },
-    ]
-  end
-
-  it "should not notify from one resource to another before if the resource is not updated" do
-    log_resource = recipe.declare_resource(:log, "log") do
-      message "This is a log message"
-      action :write
-      notifies :install, "package[vim]", :before
-    end
-
-    package_resource = recipe.declare_resource(:package, "vim") do
-      action :nothing
-    end
-
-    actions = []
-    [ log_resource, package_resource ].each do |resource|
-      allow(resource).to receive(:run_action).and_wrap_original do |m, action, notification_type, notifying_resource|
-        actions << { resource: resource.to_s, action: action }
-        actions[-1][:why_run] = Chef::Config[:why_run] if Chef::Config[:why_run]
-        actions[-1][:notification_type] = notification_type if notification_type
-        actions[-1][:notifying_resource] = notifying_resource.to_s if notifying_resource
-        m.call(action, notification_type, notifying_resource)
-      end
-    end
-
-    runner.converge
-
-    expect(actions).to eq [
-      # First it runs why-run to check if the resource would update
-      { resource: log_resource.to_s,     action: :write, why_run: true },
-      # Then it does NOT run the before action
-      # Then it runs the actual action
-      { resource: log_resource.to_s,     action: :write },
-      { resource: package_resource.to_s, action: :nothing },
-    ]
-  end
-
-  it "should notify from one resource to another delayed" do
-    log_resource = recipe.declare_resource(:log, "log") do
-      message "This is a log message"
-      action :write
-      notifies :install, "package[vim]", :delayed
-    end
-
-    package_resource = recipe.declare_resource(:package, "vim") do
-      action :nothing
-    end
-
-    expect(log_resource).to receive(:run_action).with(:write, nil, nil).and_call_original
-    update_action(log_resource)
-
-    expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
-
-    expect(package_resource).to receive(:run_action).with(:install, :delayed, nil).ordered.and_call_original
-
-    runner.converge
-  end
-
-  describe "when one resource is defined lazily" do
-
-    it "subscribes to a resource defined in a ruby block" do
-      r = recipe
-      t = self
-      ruby_block = recipe.declare_resource(:ruby_block, "rblock") do
-        block do
-          log_resource = r.declare_resource(:log, "log") do
-            message "This is a log message"
-            action :write
-          end
-          t.expect(log_resource).to t.receive(:run_action).with(:write, nil, nil).and_call_original
-          t.update_action(log_resource)
-        end
-      end
-
-      package_resource = recipe.declare_resource(:package, "vim") do
-        action :nothing
-        subscribes :install, "log[log]", :delayed
-      end
-
-      # RubyBlock needs to be able to run for our lazy examples to work - and it alone cannot affect the system
-      expect(ruby_block).to receive(:provider_for_action).and_call_original
-
-      expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
-
-      expect(package_resource).to receive(:run_action).with(:install, :delayed, nil).ordered.and_call_original
-
-      runner.converge
-    end
-
-    it "notifies from inside a ruby_block to a resource defined outside" do
-      r = recipe
-      t = self
-      ruby_block = recipe.declare_resource(:ruby_block, "rblock") do
-        block do
-          log_resource = r.declare_resource(:log, "log") do
-            message "This is a log message"
-            action :write
-            notifies :install, "package[vim]", :immediately
-          end
-          t.expect(log_resource).to t.receive(:run_action).with(:write, nil, nil).and_call_original
-          t.update_action(log_resource)
-        end
-      end
-
-      package_resource = recipe.declare_resource(:package, "vim") do
-        action :nothing
-      end
-
-      # RubyBlock needs to be able to run for our lazy examples to work - and it alone cannot affect the system
-      expect(ruby_block).to receive(:provider_for_action).and_call_original
-
-      expect(package_resource).to receive(:run_action).with(:install, :immediate, instance_of(Chef::Resource::Log)).ordered.and_call_original
-
-      expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
-
-      runner.converge
-    end
-
-  end
-
-  # Mocks having the provider run successfully and update the resource
-  def update_action(resource, times = 1)
-    p = Chef::Provider.new(resource, run_context)
-    expect(resource).to receive(:provider_for_action).exactly(times).times.and_return(p)
-    expect(p).to receive(:run_action).exactly(times).times {
-      resource.updated_by_last_action(true)
-    }
-  end
-
-end

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

@@ -1,100 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@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"
-
-describe Chef::Provider::RemoteFile::CacheControlData do
-
-  before do
-    @original_config = Chef::Config.hash_dup
-  end
-
-  after do
-    Chef::Config.configuration = @original_config if @original_config
-  end
-
-  before(:each) do
-    Chef::Config[:file_cache_path] = Dir.mktmpdir
-  end
-
-  after(:each) do
-    FileUtils.rm_rf(Chef::Config[:file_cache_path])
-  end
-
-  let(:uri) { URI.parse("http://www.bing.com/robots.txt") }
-
-  describe "when the cache control data save method is invoked" do
-
-    subject(:cache_control_data) do
-      Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
-    end
-
-    # the checksum of the file last we fetched it.
-    let(:file_checksum) { "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }
-
-    let(:etag) { "\"a-strong-identifier\"" }
-    let(:mtime) { "Thu, 01 Aug 2013 08:16:32 GMT" }
-
-    before do
-      cache_control_data.etag = etag
-      cache_control_data.mtime = mtime
-      cache_control_data.checksum = file_checksum
-    end
-
-    it "writes data to the cache" do
-      cache_control_data.save
-    end
-
-    it "writes the data to the cache and the same data can be read back" do
-      cache_control_data.save
-      saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
-      expect(saved_cache_control_data.etag).to eq(cache_control_data.etag)
-      expect(saved_cache_control_data.mtime).to eq(cache_control_data.mtime)
-      expect(saved_cache_control_data.checksum).to eq(cache_control_data.checksum)
-    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 "when the length of the uri exceeds the path length limits for the local file system" do
-      let(:uri_exceeds_file_system_limit) do
-        URI.parse("http://www.bing.com/" + ("0" * 1024))
-      end
-
-      let(:uri) { uri_exceeds_file_system_limit }
-
-      it "writes data to the cache" do
-        expect do
-          cache_control_data.save
-        end.not_to raise_error
-      end
-
-      it "writes the data to the cache and the same data can be read back" do
-        cache_control_data.save
-        saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
-        expect(saved_cache_control_data.etag).to eq(cache_control_data.etag)
-        expect(saved_cache_control_data.mtime).to eq(cache_control_data.mtime)
-        expect(saved_cache_control_data.checksum).to eq(cache_control_data.checksum)
-      end
-
-    end
-  end
-
-end