puppet 8.4.0-universal-darwin → 8.5.1-universal-darwin

data/spec/unit/util/watcher/periodic_watcher_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/watcher'
-
-describe Puppet::Util::Watcher::PeriodicWatcher do
-  let(:enabled_timeout) { 1 }
-  let(:disabled_timeout) { -1 }
-  let(:a_value) { 15 }
-  let(:a_different_value) { 16 }
-
-  let(:unused_watcher) { double('unused watcher') }
-  let(:unchanged_watcher) { a_watcher_reporting(a_value) }
-  let(:changed_watcher) { a_watcher_reporting(a_value, a_different_value) }
-
-  it 'reads only the initial change state when the timeout has not yet expired' do
-    watcher = Puppet::Util::Watcher::PeriodicWatcher.new(unchanged_watcher, an_unexpired_timer(enabled_timeout))
-
-    expect(watcher).to_not be_changed
-  end
-
-  it 'reads enough values to determine change when the timeout has expired' do
-    watcher = Puppet::Util::Watcher::PeriodicWatcher.new(changed_watcher, an_expired_timer(enabled_timeout))
-
-    expect(watcher).to be_changed
-  end
-
-  it 'is always marked as changed when the timeout is disabled' do
-    watcher = Puppet::Util::Watcher::PeriodicWatcher.new(unused_watcher, an_expired_timer(disabled_timeout))
-
-    expect(watcher).to be_changed
-  end
-
-  def a_watcher_reporting(*observed_values)
-    Puppet::Util::Watcher::ChangeWatcher.watch(proc do
-      observed_values.shift or raise "No more observed values to report!"
-    end)
-  end
-
-  def an_expired_timer(timeout)
-    a_time_that_reports_expired_as(true, timeout)
-  end
-
-  def an_unexpired_timer(timeout)
-    a_time_that_reports_expired_as(false, timeout)
-  end
-
-  def a_time_that_reports_expired_as(expired, timeout)
-    timer = Puppet::Util::Watcher::Timer.new(timeout)
-    allow(timer).to receive(:expired?).and_return(expired)
-    timer
-  end
-end

data/spec/unit/util/watcher_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/watcher'
-
-describe Puppet::Util::Watcher do
-  describe "the common file ctime watcher" do
-    FakeStat = Struct.new(:ctime)
-
-    def ctime(time)
-      FakeStat.new(time)
-    end
-
-    let(:filename) { "fake" }
-
-    it "is initially unchanged" do
-      expect(Puppet::FileSystem).to receive(:stat).with(filename).and_return(ctime(20)).at_least(:once)
-
-      watcher = Puppet::Util::Watcher::Common.file_ctime_change_watcher(filename)
-
-      expect(watcher).to_not be_changed
-    end
-
-    it "has not changed if a section of the file path continues to not exist" do
-      expect(Puppet::FileSystem).to receive(:stat).with(filename).and_raise(Errno::ENOTDIR).at_least(:once)
-
-      watcher = Puppet::Util::Watcher::Common.file_ctime_change_watcher(filename)
-      watcher = watcher.next_reading
-
-      expect(watcher).to_not be_changed
-    end
-
-    it "has not changed if the file continues to not exist" do
-      expect(Puppet::FileSystem).to receive(:stat).with(filename).and_raise(Errno::ENOENT).at_least(:once)
-
-      watcher = Puppet::Util::Watcher::Common.file_ctime_change_watcher(filename)
-      watcher = watcher.next_reading
-
-      expect(watcher).to_not be_changed
-    end
-
-    it "has changed if the file is created" do
-      times_stat_called = 0
-      expect(Puppet::FileSystem).to receive(:stat).with(filename) do
-        times_stat_called += 1
-        raise Errno::ENOENT if times_stat_called == 1
-        ctime(20)
-      end.at_least(:once)
-
-      watcher = Puppet::Util::Watcher::Common.file_ctime_change_watcher(filename)
-      watcher = watcher.next_reading
-
-      expect(watcher).to be_changed
-    end
-
-    it "is marked as changed if the file is deleted" do
-      times_stat_called = 0
-      expect(Puppet::FileSystem).to receive(:stat).with(filename) do
-        times_stat_called += 1
-        raise Errno::ENOENT if times_stat_called > 1
-        ctime(20)
-      end.at_least(:once)
-
-      watcher = Puppet::Util::Watcher::Common.file_ctime_change_watcher(filename)
-      watcher = watcher.next_reading
-
-      expect(watcher).to be_changed
-    end
-
-    it "is marked as changed if the file modified" do
-      times_stat_called = 0
-      expect(Puppet::FileSystem).to receive(:stat).with(filename) do
-        times_stat_called += 1
-        if times_stat_called == 1
-          ctime(20)
-        else
-          ctime(21)
-        end
-      end.at_least(:once)
-
-      watcher = Puppet::Util::Watcher::Common.file_ctime_change_watcher(filename)
-      watcher = watcher.next_reading
-
-      expect(watcher).to be_changed
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/windows'
-
-describe "Puppet::Util::Windows::AccessControlEntry", :if => Puppet::Util::Platform.windows? do
-  let(:klass) { Puppet::Util::Windows::AccessControlEntry }
-  let(:sid) { 'S-1-5-18' }
-  let(:mask) { Puppet::Util::Windows::File::FILE_ALL_ACCESS }
-
-  it "creates an access allowed ace" do
-    ace = klass.new(sid, mask)
-
-    expect(ace.type).to eq(klass::ACCESS_ALLOWED_ACE_TYPE)
-  end
-
-  it "creates an access denied ace" do
-    ace = klass.new(sid, mask, 0, klass::ACCESS_DENIED_ACE_TYPE)
-
-    expect(ace.type).to eq(klass::ACCESS_DENIED_ACE_TYPE)
-  end
-
-  it "creates a non-inherited ace by default" do
-    ace = klass.new(sid, mask)
-
-    expect(ace).not_to be_inherited
-  end
-
-  it "creates an inherited ace" do
-    ace = klass.new(sid, mask, klass::INHERITED_ACE)
-
-    expect(ace).to be_inherited
-  end
-
-  it "creates a non-inherit-only ace by default" do
-    ace = klass.new(sid, mask)
-
-    expect(ace).not_to be_inherit_only
-  end
-
-  it "creates an inherit-only ace" do
-    ace = klass.new(sid, mask, klass::INHERIT_ONLY_ACE)
-
-    expect(ace).to be_inherit_only
-  end
-
-  context "when comparing aces" do
-    let(:ace1) { klass.new(sid, mask, klass::INHERIT_ONLY_ACE, klass::ACCESS_DENIED_ACE_TYPE) }
-    let(:ace2) { klass.new(sid, mask, klass::INHERIT_ONLY_ACE, klass::ACCESS_DENIED_ACE_TYPE) }
-
-    it "returns true if different objects have the same set of values" do
-    expect(ace1).to eq(ace2)
-    end
-
-    it "returns false if different objects have different sets of values" do
-      ace = klass.new(sid, mask)
-      expect(ace).not_to eq(ace1)
-    end
-
-    it "returns true when testing if two objects are eql?" do
-      ace1.eql?(ace2)
-    end
-
-    it "returns false when comparing object identity" do
-      expect(ace1).not_to be_equal(ace2)
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/windows'
-
-describe "Puppet::Util::Windows::AccessControlList", :if => Puppet::Util::Platform.windows? do
-  let(:klass) { Puppet::Util::Windows::AccessControlList }
-  let(:system_sid) { 'S-1-5-18' }
-  let(:admins_sid) { 'S-1-5-544' }
-  let(:none_sid)   { 'S-1-0-0' }
-
-  let(:system_ace) do
-    Puppet::Util::Windows::AccessControlEntry.new(system_sid, 0x1)
-  end
-  let(:admins_ace) do
-    Puppet::Util::Windows::AccessControlEntry.new(admins_sid, 0x2)
-  end
-  let(:none_ace) do
-    Puppet::Util::Windows::AccessControlEntry.new(none_sid, 0x3)
-  end
-
-  it "constructs an empty list" do
-    acl = klass.new
-
-    expect(acl.to_a).to be_empty
-  end
-
-  it "supports copy constructor" do
-    aces = klass.new([system_ace]).to_a
-
-    expect(aces.to_a).to eq([system_ace])
-  end
-
-  context "appending" do
-    it "appends an allow ace" do
-      acl = klass.new
-      acl.allow(system_sid, 0x1, 0x2)
-
-      expect(acl.first.type).to eq(klass::ACCESS_ALLOWED_ACE_TYPE)
-    end
-
-    it "appends a deny ace" do
-      acl = klass.new
-      acl.deny(system_sid, 0x1, 0x2)
-
-      expect(acl.first.type).to eq(klass::ACCESS_DENIED_ACE_TYPE)
-    end
-
-    it "always appends, never overwrites an ACE" do
-      acl = klass.new([system_ace])
-      acl.allow(admins_sid, admins_ace.mask, admins_ace.flags)
-
-      aces = acl.to_a
-      expect(aces.size).to eq(2)
-      expect(aces[0]).to eq(system_ace)
-      expect(aces[1].sid).to eq(admins_sid)
-      expect(aces[1].mask).to eq(admins_ace.mask)
-      expect(aces[1].flags).to eq(admins_ace.flags)
-    end
-  end
-
-  context "reassigning" do
-    it "preserves the mask from the old sid when reassigning to the new sid" do
-      dacl = klass.new([system_ace])
-
-      dacl.reassign!(system_ace.sid, admins_ace.sid)
-      # we removed system, so ignore prepended ace
-      ace = dacl.to_a[1]
-      expect(ace.sid).to eq(admins_sid)
-      expect(ace.mask).to eq(system_ace.mask)
-    end
-
-    it "matches multiple sids" do
-      dacl = klass.new([system_ace, system_ace])
-
-      dacl.reassign!(system_ace.sid, admins_ace.sid)
-      # we removed system, so ignore prepended ace
-      aces = dacl.to_a
-      expect(aces.size).to eq(3)
-      aces.to_a[1,2].each do |ace|
-        expect(ace.sid).to eq(admins_ace.sid)
-      end
-    end
-
-    it "preserves aces for sids that don't match, in their original order" do
-      dacl = klass.new([system_ace, admins_ace])
-
-      dacl.reassign!(system_sid, none_sid)
-      aces = dacl.to_a
-      aces[1].sid == admins_ace.sid
-    end
-
-    it "preserves inherited aces, even if the sids match" do
-      flags = Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE
-      inherited_ace = Puppet::Util::Windows::AccessControlEntry.new(system_sid, 0x1, flags)
-      dacl = klass.new([inherited_ace, system_ace])
-      dacl.reassign!(system_sid, none_sid)
-      aces = dacl.to_a
-
-      expect(aces[0].sid).to eq(system_sid)
-    end
-
-    it "prepends an explicit ace for the new sid with the same mask and basic inheritance as the inherited ace" do
-      expected_flags =
-        Puppet::Util::Windows::AccessControlEntry::OBJECT_INHERIT_ACE |
-        Puppet::Util::Windows::AccessControlEntry::CONTAINER_INHERIT_ACE |
-        Puppet::Util::Windows::AccessControlEntry::INHERIT_ONLY_ACE
-
-      flags = Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE | expected_flags
-
-      inherited_ace = Puppet::Util::Windows::AccessControlEntry.new(system_sid, 0x1, flags)
-      dacl = klass.new([inherited_ace])
-      dacl.reassign!(system_sid, none_sid)
-      aces = dacl.to_a
-
-      expect(aces.size).to eq(2)
-      expect(aces[0].sid).to eq(none_sid)
-      expect(aces[0]).not_to be_inherited
-      expect(aces[0].flags).to eq(expected_flags)
-
-      expect(aces[1].sid).to eq(system_sid)
-      expect(aces[1]).to be_inherited
-    end
-
-    it "makes a copy of the ace prior to modifying it" do
-      arr = [system_ace]
-
-      acl = klass.new(arr)
-      acl.reassign!(system_sid, none_sid)
-
-      expect(arr[0].sid).to eq(system_sid)
-    end
-  end
-end