chef 18.8.11 → 18.8.54

data/spec/unit/util/selinux_spec.rb

@@ -1,160 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@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"
-
-describe Chef::Util::Selinux do
-  class TestClass
-    include Chef::Util::Selinux
-
-    def self.reset_state
-      @@selinux_enabled = nil
-      @@restorecon_path = nil
-      @@selinuxenabled_path = nil
-    end
-  end
-
-  before do
-    allow(ChefUtils).to receive(:windows?).and_return(false)
-    allow(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
-    allow(ENV).to receive(:[]).with("PATH").and_call_original
-    TestClass.reset_state
-    @test_instance = TestClass.new
-  end
-
-  after(:each) do
-    TestClass.reset_state
-  end
-
-  it "each part of ENV['PATH'] should be checked" do
-    expected_paths = ENV["PATH"].split(File::PATH_SEPARATOR) + %w{/usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin}
-
-    expected_paths.uniq.each do |bin_path|
-      selinux_path = File.join(bin_path, "selinuxenabled")
-      expect(File).to receive(:executable?).with(selinux_path).and_return(false)
-    end
-
-    expect(@test_instance.selinux_enabled?).to be_falsey
-  end
-
-  describe "when selinuxenabled binary exists" do
-    before do
-      @selinux_enabled_path = File.join("/sbin", "selinuxenabled")
-      allow(File).to receive(:executable?) do |file_path|
-        expect(file_path.end_with?("selinuxenabled")).to be_truthy
-        file_path == @selinux_enabled_path
-      end
-    end
-
-    describe "when selinux is enabled" do
-      before do
-        cmd_result = double("Cmd Result", exitstatus: 0)
-        expect(@test_instance).to receive(:shell_out!).once.with(@selinux_enabled_path, { returns: [0, 1] }).and_return(cmd_result)
-      end
-
-      it "should report selinux is enabled" do
-        expect(@test_instance.selinux_enabled?).to be_truthy
-        # should check the file system only once for multiple calls
-        expect(@test_instance.selinux_enabled?).to be_truthy
-      end
-    end
-
-    describe "when selinux is disabled" do
-      before do
-        cmd_result = double("Cmd Result", exitstatus: 1)
-        expect(@test_instance).to receive(:shell_out!).once.with(@selinux_enabled_path, { returns: [0, 1] }).and_return(cmd_result)
-      end
-
-      it "should report selinux is disabled" do
-        expect(@test_instance.selinux_enabled?).to be_falsey
-        # should check the file system only once for multiple calls
-        expect(@test_instance.selinux_enabled?).to be_falsey
-      end
-    end
-
-    describe "when selinux gives an unexpected status" do
-      before do
-        cmd_result = double("Cmd Result", exitstatus: 101)
-        expect(@test_instance).to receive(:shell_out!).once.with(@selinux_enabled_path, { returns: [0, 1] }).and_return(cmd_result)
-      end
-
-      it "should throw an error" do
-        expect { @test_instance.selinux_enabled? }.to raise_error(RuntimeError)
-      end
-    end
-  end
-
-  describe "when selinuxenabled binary doesn't exist" do
-    before do
-      allow(File).to receive(:executable?) do |file_path|
-        expect(file_path.end_with?("selinuxenabled")).to be_truthy
-        false
-      end
-    end
-
-    it "should report selinux is disabled" do
-      expect(@test_instance.selinux_enabled?).to be_falsey
-      # should check the file system only once for multiple calls
-      expect(File).not_to receive(:executable?)
-      expect(@test_instance.selinux_enabled?).to be_falsey
-    end
-  end
-
-  describe "when restorecon binary exists on the system" do
-    let(:path) { "/path/to/awesome directory" }
-
-    before do
-      @restorecon_enabled_path = File.join("/sbin", "restorecon")
-      allow(File).to receive(:executable?) do |file_path|
-        expect(file_path.end_with?("restorecon")).to be_truthy
-        file_path == @restorecon_enabled_path
-      end
-    end
-
-    it "should call restorecon non-recursive by default" do
-      expect(@test_instance).to receive(:shell_out_compacted!).with(@restorecon_enabled_path, "-R", path).twice
-      @test_instance.restore_security_context(path)
-      expect(File).not_to receive(:executable?)
-      @test_instance.restore_security_context(path)
-    end
-
-    it "should call restorecon recursive when recursive is set" do
-      expect(@test_instance).to receive(:shell_out_compacted!).with(@restorecon_enabled_path, "-R", "-r", path).twice
-      @test_instance.restore_security_context(path, true)
-      expect(File).not_to receive(:executable?)
-      @test_instance.restore_security_context(path, true)
-    end
-
-    it "should call restorecon non-recursive when recursive is not set" do
-      expect(@test_instance).to receive(:shell_out_compacted!).with(@restorecon_enabled_path, "-R", path).twice
-      @test_instance.restore_security_context(path)
-      expect(File).not_to receive(:executable?)
-      @test_instance.restore_security_context(path)
-    end
-
-    describe "when restorecon doesn't exist on the system" do
-      it "should log a warning message" do
-        allow(File).to receive(:executable?).with(/restorecon$/).and_return(false)
-        expect(Chef::Log).to receive(:warn).with(/Can not find 'restorecon' on the system. Skipping selinux security context restore./).at_least(:once)
-        @test_instance.restore_security_context(path)
-        expect(File).not_to receive(:executable?)
-        @test_instance.restore_security_context(path)
-      end
-    end
-  end
-end

data/spec/unit/util/threaded_job_queue_spec.rb

@@ -1,60 +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"
-
-class WorkerThreadError < StandardError
-end
-
-describe Chef::Util::ThreadedJobQueue do
-  let(:queue) { Chef::Util::ThreadedJobQueue.new }
-
-  around(:example) do |example|
-    old_value = Thread.report_on_exception
-    Thread.report_on_exception = false
-
-    example.run
-
-    Thread.report_on_exception = old_value
-  end
-
-  it "should pass mutex to jobs with an arity of 1" do
-    job = double
-    expect(job).to receive(:arity).at_least(:once).and_return(1)
-    expect(job).to receive(:call).exactly(5).times.with(an_instance_of(Mutex))
-
-    5.times { queue << job }
-    queue.process
-  end
-
-  it "should pass nothing to jobs with an arity of 0" do
-    job = double
-    expect(job).to receive(:arity).at_least(:once).and_return(0)
-    expect(job).to receive(:call).exactly(5).times.with(no_args)
-
-    5.times { queue << job }
-    queue.process
-  end
-
-  it "should use specified number of threads" do
-    expect(Thread).to receive(:new).exactly(7).times.and_call_original
-    queue.process(7)
-  end
-
-  it "should propagate exceptions to the main thread" do
-    queue << lambda { raise WorkerThreadError }
-    expect { queue.process }.to raise_error(WorkerThreadError)
-  end
-end

data/spec/unit/util/windows/logon_session_spec.rb

@@ -1,285 +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 "chef/util/windows/logon_session"
-
-describe ::Chef::Util::Windows::LogonSession do
-  before do
-    stub_const("Chef::ReservedNames::Win32::API::Security", Class.new)
-    stub_const("Chef::ReservedNames::Win32::API::Security::LOGON32_LOGON_NEW_CREDENTIALS", 314)
-    stub_const("Chef::ReservedNames::Win32::API::Security::LOGON32_PROVIDER_DEFAULT", 159)
-    stub_const("Chef::ReservedNames::Win32::API::System", Class.new )
-  end
-
-  let(:session) { ::Chef::Util::Windows::LogonSession.new(session_user, password, session_domain, authentication) }
-  let(:authentication) { :remote }
-
-  shared_examples_for "it received syntactically invalid credentials" do
-    it "does not raises an exception when it is initialized" do
-      expect { session }.to raise_error(ArgumentError)
-    end
-  end
-
-  shared_examples_for "it received an incorrect username and password combination" do
-    before do
-      expect(Chef::ReservedNames::Win32::API::Security).to receive(:LogonUserW).and_return(false)
-    end
-
-    it "raises a Chef::Exceptions::Win32APIError exception when the open method is called" do
-      expect { session.open }.to raise_error(Chef::Exceptions::Win32APIError)
-      expect(session).not_to receive(:close)
-      expect(Chef::ReservedNames::Win32::API::System).not_to receive(:CloseHandle)
-    end
-  end
-
-  shared_examples_for "it received valid credentials" do
-    it "does not raise an exception when the open method is called" do
-      expect(Chef::ReservedNames::Win32::API::Security).to receive(:LogonUserW).and_return(true)
-      expect { session.open }.not_to raise_error
-    end
-  end
-
-  shared_examples_for "the session is not open" do
-    it "does not raise an exception when #open is called" do
-      expect(Chef::ReservedNames::Win32::API::Security).to receive(:LogonUserW).and_return(true)
-      expect { session.open }.not_to raise_error
-    end
-
-    it "raises an exception if #close is called" do
-      expect { session.close }.to raise_error(RuntimeError)
-    end
-
-    it "raises an exception if #restore_user_context is called" do
-      expect { session.restore_user_context }.to raise_error(RuntimeError)
-    end
-  end
-
-  shared_examples_for "the session is open" do
-    before do
-      allow(Chef::ReservedNames::Win32::API::System).to receive(:CloseHandle)
-    end
-    it "does not result in an exception when #restore_user_context is called" do
-      expect { session.restore_user_context }.not_to raise_error
-    end
-
-    it "does not result in an exception when #close is called" do
-      expect { session.close }.not_to raise_error
-    end
-
-    it "does close the operating system handle when #close is called" do
-      expect(Chef::ReservedNames::Win32::API::System).not_to receive(:CloseHandle)
-      expect { session.restore_user_context }.not_to raise_error
-    end
-  end
-
-  context "when the session is initialized with a nil user" do
-    context "when the password, and domain are all nil" do
-      let(:session_user) { nil }
-      let(:session_domain) { nil }
-      let(:password) { nil }
-      it_behaves_like "it received syntactically invalid credentials"
-    end
-
-    context "when the password is non-nil password, and the domain is nil" do
-      let(:session_user) { nil }
-      let(:password) { "ponies" }
-      let(:session_domain) { nil }
-      it_behaves_like "it received syntactically invalid credentials"
-    end
-
-    context "when the password is nil and the domain is non-nil" do
-      let(:session_user) { nil }
-      let(:password) { nil }
-      let(:session_domain) { "fairyland" }
-      it_behaves_like "it received syntactically invalid credentials"
-    end
-
-    context "when the password and domain are non-nil" do
-      let(:session_user) { nil }
-      let(:password) { "ponies" }
-      let(:session_domain) { "fairyland" }
-      it_behaves_like "it received syntactically invalid credentials"
-    end
-  end
-
-  context "when the session is initialized with a valid user" do
-    let(:session_user) { "chalena" }
-
-    context "when the password is nil" do
-      let(:password) { nil }
-      context "when the domain is non-nil" do
-        let(:session_domain) { "fairyland" }
-        it_behaves_like "it received syntactically invalid credentials"
-      end
-
-      context "when the domain is nil" do
-        context "when the domain is non-nil" do
-          let(:session_domain) { nil }
-          it_behaves_like "it received syntactically invalid credentials"
-        end
-      end
-    end
-
-    context "when a syntactically valid username and password are supplied" do
-      context "when the password is non-nil and the domain is nil" do
-        let(:password) { "ponies" }
-        let(:session_domain) { nil }
-        it "does not raise an exception if it is initialized with a non-nil username, non-nil password, and a nil domain" do
-          expect { session }.not_to raise_error
-        end
-
-        it_behaves_like "it received valid credentials"
-        it_behaves_like "it received an incorrect username and password combination"
-      end
-
-      context "when the password and domain are non-nil" do
-        let(:password) { "ponies" }
-        let(:session_domain) { "fairyland" }
-        it "does not raise an exception if it is initialized with a non-nil username, non-nil password, and non-nil domain" do
-          expect { session }.not_to raise_error
-        end
-
-        it_behaves_like "it received valid credentials"
-        it_behaves_like "it received an incorrect username and password combination"
-      end
-
-      context "when the #open method has not been called" do
-        let(:password) { "ponies" }
-        let(:session_domain) { "fairyland" }
-        it_behaves_like "the session is not open"
-      end
-
-      context "when the session was opened" do
-        let(:password) { "ponies" }
-        let(:session_domain) { "fairyland" }
-
-        before do
-          expect(Chef::ReservedNames::Win32::API::Security).to receive(:LogonUserW).and_return(true)
-          expect { session.open }.not_to raise_error
-        end
-
-        it "raises an exception if #open is called" do
-          expect { session.open }.to raise_error(RuntimeError)
-        end
-
-        context "when the session was opened and then closed with the #close method" do
-          before do
-            expect(Chef::ReservedNames::Win32::API::System).to receive(:CloseHandle)
-            expect { session.close }.not_to raise_error
-          end
-          it_behaves_like "the session is not open"
-        end
-
-        it "can be closed and close the operating system handle" do
-          expect(Chef::ReservedNames::Win32::API::System).to receive(:CloseHandle)
-          expect { session.close }.not_to raise_error
-        end
-
-        it "can impersonate the user" do
-          expect(Chef::ReservedNames::Win32::API::Security).to receive(:ImpersonateLoggedOnUser).and_return(true)
-          expect { session.set_user_context }.not_to raise_error
-        end
-
-        context "when #set_user_context fails due to low resources causing a failure to impersonate" do
-          before do
-            expect(Chef::ReservedNames::Win32::API::Security).to receive(:ImpersonateLoggedOnUser).and_return(false)
-          end
-
-          it "raises an exception when #set_user_context fails because impersonation failed" do
-            expect { session.set_user_context }.to raise_error(Chef::Exceptions::Win32APIError)
-          end
-
-          context "when calling subsequent methods" do
-            before do
-              expect { session.set_user_context }.to raise_error(Chef::Exceptions::Win32APIError)
-              expect(Chef::ReservedNames::Win32::API::Security).not_to receive(:RevertToSelf)
-            end
-
-            it_behaves_like "the session is open"
-          end
-        end
-
-        context "when #set_user_context successfully impersonates the user" do
-          before do
-            expect(Chef::ReservedNames::Win32::API::Security).to receive(:ImpersonateLoggedOnUser).and_return(true)
-            expect { session.set_user_context }.not_to raise_error
-          end
-
-          context "when attempting to impersonate while already impersonating" do
-            it "raises an error if the #set_user_context is called again" do
-              expect { session.set_user_context }.to raise_error(RuntimeError)
-            end
-          end
-
-          describe "the impersonation will be reverted" do
-            before do
-              expect(Chef::ReservedNames::Win32::API::Security).to receive(:RevertToSelf).and_return(true)
-            end
-            it_behaves_like "the session is open"
-          end
-
-          context "when the attempt to revert impersonation fails" do
-            before do
-              expect(Chef::ReservedNames::Win32::API::Security).to receive(:RevertToSelf).and_return(false)
-            end
-
-            it "raises an exception when #restore_user_context is called" do
-              expect { session.restore_user_context }.to raise_error(Chef::Exceptions::Win32APIError)
-            end
-
-            it "raises an exception when #close is called and impersonation fails" do
-              expect { session.close }.to raise_error(Chef::Exceptions::Win32APIError)
-            end
-
-            context "when calling methods after revert fails in #restore_user_context" do
-              before do
-                expect { session.restore_user_context }.to raise_error(Chef::Exceptions::Win32APIError)
-              end
-
-              context "when revert continues to fail" do
-                before do
-                  expect(Chef::ReservedNames::Win32::API::Security).to receive(:RevertToSelf).and_return(false)
-                end
-                it "raises an exception when #close is called and impersonation fails" do
-                  expect { session.close }.to raise_error(Chef::Exceptions::Win32APIError)
-                end
-              end
-
-              context "when revert stops failing and succeeds" do
-                before do
-                  expect(Chef::ReservedNames::Win32::API::Security).to receive(:RevertToSelf).and_return(true)
-                end
-
-                it "does not raise an exception when #restore_user_context is called" do
-                  expect { session.restore_user_context }.not_to raise_error
-                end
-
-                it "does not raise an exception when #close is called" do
-                  expect(Chef::ReservedNames::Win32::API::System).to receive(:CloseHandle)
-                  expect { session.close }.not_to raise_error
-                end
-              end
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/version/platform_spec.rb

@@ -1,60 +0,0 @@
-# Author:: Xabier de Zuazo (<xabier@onddo.com>)
-# Copyright:: Copyright 2013-2016, Onddo Labs, SL.
-# 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/version/platform"
-
-describe Chef::Version::Platform do
-
-  it "is a subclass of Chef::Version" do
-    v = Chef::Version::Platform.new("1.1")
-    expect(v).to be_an_instance_of(Chef::Version::Platform)
-    expect(v).to be_a_kind_of(Chef::Version)
-  end
-
-  it "should transform 1 to 1.0.0" do
-    expect(Chef::Version::Platform.new("1").to_s).to eq("1.0.0")
-  end
-
-  describe "when creating valid Versions" do
-    good_versions = %w{1 1.2 1.2.3 1000.80.50000 0.300.25 001.02.00003 1.2-STABLE 10.0-BETA3 9.1-RELEASE-p3}
-    good_versions.each do |v|
-      it "should accept '#{v}'" do
-        Chef::Version::Platform.new v
-      end
-    end
-  end
-
-  describe "when given bogus input" do
-    bad_versions = ["1.2.3.4", "1.2.a4", "a", "1.2 3", "1.2 a",
-                    "1 2 3", "1-2-3", "1_2_3", "1.2_3", "1.2-3"]
-    the_error = Chef::Exceptions::InvalidPlatformVersion
-    bad_versions.each do |v|
-      it "should raise #{the_error} when given '#{v}'" do
-        expect { Chef::Version::Platform.new v }.to raise_error(the_error)
-      end
-    end
-  end
-
-  describe "<=>" do
-
-    it "should equate versions 1 and 1.0.0" do
-      expect(Chef::Version::Platform.new("1")).to eq(Chef::Version::Platform.new("1.0.0"))
-    end
-
-  end
-
-end