chef 14.15.6-universal-mingw32 → 15.0.293-universal-mingw32

data/spec/functional/event_loggers/windows_eventlog_spec.rb

@@ -1,106 +1,104 @@
-#
-# Author:: Jay Mundrawala (<jdm@chef.io>)
-#
-# Copyright:: Copyright 2014-2016, 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"
-if Chef::Platform.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)
-
-    expect(event_log.read(flags, offset).any? do |e|
-      e.source == "Chef" && 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 == "Chef" && 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 == "Chef" && 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 == "Chef" && 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 == "Chef" && 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
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+#
+# Copyright:: Copyright 2014-2019, 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"
+if Chef::Platform.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 == "Chef" && 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 == "Chef" && 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 == "Chef" && 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 == "Chef" && 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 == "Chef" && 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 +1,229 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2013-2016, 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_properies(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_properies(original_info)).to eq(unix_invariant_properies(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_properies(original_info)).to eq(unix_invariant_properies(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
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2013-2016, 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_properies(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_properies(original_info)).to eq(unix_invariant_properies(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_properies(original_info)).to eq(unix_invariant_properies(updated_info))
+      end
+
+    end
+
+  end
+end
+
+describe Chef::FileContentManagement::Deploy::Cp do
+
+  let(:unix_invariants) do
+    [
+      :uid,
+      :gid,
+      :mode,
+      :ino,
+    ]
+  end
+
+  let(:security_descriptor_invariants) do
+    [
+      :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
+    [
+      :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
+      [
+       :owner,
+       :group,
+       :dacl,
+      ]
+    end
+
+    it_should_behave_like "a content deploy strategy"
+  end
+
+end