RubyGems - puppet - Versions diffs - 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32 - Mend

puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

Files changed (1257) hide show

data/spec/unit/util/skip_tags_spec.rb DELETED Viewed

@@ -1,14 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-require 'puppet/util/skip_tags'
-describe Puppet::Util::SkipTags do
-  let(:tagger) { Puppet::Util::SkipTags.new([]) }
-  it "should add qualified classes as single tags" do
-    tagger.tag("one::two::three")
-    expect(tagger.tags).to include("one::two::three")
-    expect(tagger.tags).not_to include("one", "two", "three")
-  end
-end

data/spec/unit/util/splayer_spec.rb DELETED Viewed

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/splayer'
-describe Puppet::Util::Splayer do
-  include Puppet::Util::Splayer
-  let (:subject) { self }
-  before do
-    Puppet[:splay] = true
-    Puppet[:splaylimit] = "10"
-  end
-  it "should do nothing if splay is disabled" do
-    Puppet[:splay] = false
-    expect(subject).not_to receive(:sleep)
-    subject.splay
-  end
-  it "should do nothing if it has already splayed" do
-    expect(subject).to receive(:splayed?).and_return(true)
-    expect(subject).not_to receive(:sleep)
-    subject.splay
-  end
-  it "should log that it is splaying" do
-    allow(subject).to receive(:sleep)
-    expect(Puppet).to receive(:info)
-    subject.splay
-  end
-  it "should sleep for a random portion of the splaylimit plus 1" do
-    Puppet[:splaylimit] = "50"
-    expect(subject).to receive(:rand).with(51).and_return(10)
-    expect(subject).to receive(:sleep).with(10)
-    subject.splay
-  end
-  it "should mark that it has splayed" do
-    allow(subject).to receive(:sleep)
-    subject.splay
-    expect(subject).to be_splayed
-  end
-end

data/spec/unit/util/storage_spec.rb DELETED Viewed

@@ -1,330 +0,0 @@
-require 'spec_helper'
-require 'yaml'
-require 'fileutils'
-require 'puppet/util/storage'
-describe Puppet::Util::Storage do
-  include PuppetSpec::Files
-  before(:each) do
-    @basepath = File.expand_path("/somepath")
-  end
-  describe "when caching a symbol" do
-    it "should return an empty hash" do
-      expect(Puppet::Util::Storage.cache(:yayness)).to eq({})
-      expect(Puppet::Util::Storage.cache(:more_yayness)).to eq({})
-    end
-    it "should add the symbol to its internal state" do
-      Puppet::Util::Storage.cache(:yayness)
-      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-    end
-    it "should not clobber existing state when caching additional objects" do
-      Puppet::Util::Storage.cache(:yayness)
-      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-      Puppet::Util::Storage.cache(:bubblyness)
-      expect(Puppet::Util::Storage.state).to eq({:yayness=>{},:bubblyness=>{}})
-    end
-  end
-  describe "when caching a Puppet::Type" do
-    before(:each) do
-      @file_test = Puppet::Type.type(:file).new(:name => @basepath+"/yayness", :audit => %w{checksum type})
-      @exec_test = Puppet::Type.type(:exec).new(:name => @basepath+"/bin/ls /yayness")
-    end
-    it "should return an empty hash" do
-      expect(Puppet::Util::Storage.cache(@file_test)).to eq({})
-      expect(Puppet::Util::Storage.cache(@exec_test)).to eq({})
-    end
-    it "should add the resource ref to its internal state" do
-      expect(Puppet::Util::Storage.state).to eq({})
-      Puppet::Util::Storage.cache(@file_test)
-      expect(Puppet::Util::Storage.state).to eq({"File[#{@basepath}/yayness]"=>{}})
-      Puppet::Util::Storage.cache(@exec_test)
-      expect(Puppet::Util::Storage.state).to eq({"File[#{@basepath}/yayness]"=>{}, "Exec[#{@basepath}/bin/ls /yayness]"=>{}})
-    end
-  end
-  describe "when caching something other than a resource or symbol" do
-    it "should cache by converting to a string" do
-      data = Puppet::Util::Storage.cache(42)
-      data[:yay] = true
-      expect(Puppet::Util::Storage.cache("42")[:yay]).to be_truthy
-    end
-  end
-  it "should clear its internal state when clear() is called" do
-    Puppet::Util::Storage.cache(:yayness)
-    expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-    Puppet::Util::Storage.clear
-    expect(Puppet::Util::Storage.state).to eq({})
-  end
-  describe "when loading from the state file" do
-    before do
-      allow(Puppet.settings).to receive(:use).and_return(true)
-    end
-    describe "when the state file/directory does not exist" do
-      before(:each) do
-        @path = tmpfile('storage_test')
-      end
-      it "should not fail to load" do
-        expect(Puppet::FileSystem.exist?(@path)).to be_falsey
-        Puppet[:statedir] = @path
-        Puppet::Util::Storage.load
-        Puppet[:statefile] = @path
-        Puppet::Util::Storage.load
-      end
-      it "should not lose its internal state when load() is called" do
-        expect(Puppet::FileSystem.exist?(@path)).to be_falsey
-        Puppet::Util::Storage.cache(:yayness)
-        expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-        Puppet[:statefile] = @path
-        Puppet::Util::Storage.load
-        expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-      end
-    end
-    describe "when the state file/directory exists" do
-      before(:each) do
-        @state_file = tmpfile('storage_test')
-        FileUtils.touch(@state_file)
-        Puppet[:statefile] = @state_file
-      end
-      def write_state_file(contents)
-        File.open(@state_file, 'w') { |f| f.write(contents) }
-      end
-      it "should overwrite its internal state if load() is called" do
-        # Should the state be overwritten even if Puppet[:statefile] is not valid YAML?
-        Puppet::Util::Storage.cache(:yayness)
-        expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-        Puppet::Util::Storage.load
-        expect(Puppet::Util::Storage.state).to eq({})
-      end
-      it "should restore its internal state if the state file contains valid YAML" do
-        test_yaml = {'File["/yayness"]'=>{"name"=>{:a=>:b,:c=>:d}}}
-        write_state_file(test_yaml.to_yaml)
-        Puppet::Util::Storage.load
-        expect(Puppet::Util::Storage.state).to eq(test_yaml)
-      end
-      it "should initialize with a clear internal state if the state file does not contain valid YAML" do
-        write_state_file('{ invalid')
-        Puppet::Util::Storage.load
-        expect(Puppet::Util::Storage.state).to eq({})
-      end
-      it "should initialize with a clear internal state if the state file does not contain a hash of data" do
-        write_state_file("not_a_hash")
-        Puppet::Util::Storage.load
-        expect(Puppet::Util::Storage.state).to eq({})
-      end
-      it "should raise an error if the state file does not contain valid YAML and cannot be renamed" do
-        allow(File).to receive(:rename).and_call_original
-        write_state_file('{ invalid')
-        expect(File).to receive(:rename).with(@state_file, "#{@state_file}.bad").and_raise(SystemCallError)
-        expect { Puppet::Util::Storage.load }.to raise_error(Puppet::Error, /Could not rename/)
-      end
-      it "should attempt to rename the state file if the file is corrupted" do
-        write_state_file('{ invalid')
-        expect(File).to receive(:rename).at_least(:once)
-        Puppet::Util::Storage.load
-      end
-      it "should fail gracefully on load() if the state file is not a regular file" do
-        FileUtils.rm_f(@state_file)
-        Dir.mkdir(@state_file)
-        Puppet::Util::Storage.load
-      end
-      it 'should load Time and Symbols' do
-        state = {
-          'File[/etc/puppetlabs/puppet]' =>
-          { :checked => Time.new(2018, 8, 8, 15, 28, 25, "-07:00") }
-        }
-        write_state_file(YAML.dump(state))
-        Puppet::Util::Storage.load
-        expect(Puppet::Util::Storage.state).to eq(state.dup)
-      end
-    end
-  end
-  describe "when storing to the state file" do
-    A_SMALL_AMOUNT_OF_TIME = 0.001 #Seconds
-    before(:each) do
-      @state_file = tmpfile('storage_test')
-      @saved_statefile = Puppet[:statefile]
-      Puppet[:statefile] = @state_file
-    end
-    it "should create the state file if it does not exist" do
-      expect(Puppet::FileSystem.exist?(Puppet[:statefile])).to be_falsey
-      Puppet::Util::Storage.cache(:yayness)
-      Puppet::Util::Storage.store
-      expect(Puppet::FileSystem.exist?(Puppet[:statefile])).to be_truthy
-    end
-    it "should raise an exception if the state file is not a regular file" do
-      Dir.mkdir(Puppet[:statefile])
-      Puppet::Util::Storage.cache(:yayness)
-      expect { Puppet::Util::Storage.store }.to raise_error(Errno::EISDIR, /Is a directory/)
-      Dir.rmdir(Puppet[:statefile])
-    end
-    it "should load() the same information that it store()s" do
-      Puppet::Util::Storage.cache(:yayness)
-      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-      Puppet::Util::Storage.store
-      Puppet::Util::Storage.clear
-      expect(Puppet::Util::Storage.state).to eq({})
-      Puppet::Util::Storage.load
-      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
-    end
-    it "expires entries with a :checked older than statettl seconds ago" do
-      Puppet[:statettl] = '1d'
-      recent_checked = Time.now.round
-      stale_checked = recent_checked - (Puppet[:statettl] + 10)
-      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
-      Puppet::Util::Storage.cache(:stale)[:checked] = stale_checked
-      expect(Puppet::Util::Storage.state).to match(
-        {
-          :yayness => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
-          },
-          :stale => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(stale_checked)
-          }
-        }
-      )
-      Puppet::Util::Storage.store
-      Puppet::Util::Storage.clear
-      expect(Puppet::Util::Storage.state).to eq({})
-      Puppet::Util::Storage.load
-      expect(Puppet::Util::Storage.state).to match(
-        {
-          :yayness => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
-          }
-        }
-      )
-    end
-    it "does not expire entries when statettl is 0" do
-      Puppet[:statettl] = '0'
-      recent_checked = Time.now.round
-      older_checked = recent_checked - 10_000_000
-      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
-      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
-      expect(Puppet::Util::Storage.state).to match(
-        {
-          :yayness => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
-          },
-          :older => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
-          }
-        }
-      )
-      Puppet::Util::Storage.store
-      Puppet::Util::Storage.clear
-      expect(Puppet::Util::Storage.state).to eq({})
-      Puppet::Util::Storage.load
-      expect(Puppet::Util::Storage.state).to match(
-        {
-          :yayness => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
-          },
-          :older => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
-          }
-        }
-      )
-    end
-    it "does not expire entries when statettl is 'unlimited'" do
-      Puppet[:statettl] = 'unlimited'
-      recent_checked = Time.now
-      older_checked = Time.now - 10_000_000
-      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
-      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
-      expect(Puppet::Util::Storage.state).to match(
-        {
-          :yayness => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
-          },
-          :older => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
-          }
-        }
-      )
-      Puppet::Util::Storage.store
-      Puppet::Util::Storage.clear
-      expect(Puppet::Util::Storage.state).to eq({})
-      Puppet::Util::Storage.load
-      expect(Puppet::Util::Storage.state).to match(
-        {
-          :yayness => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
-          },
-          :older => {
-            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
-          }
-        }
-      )
-    end
-  end
-end

data/spec/unit/util/suidmanager_spec.rb DELETED Viewed

@@ -1,278 +0,0 @@
-require 'spec_helper'
-describe Puppet::Util::SUIDManager do
-  let :user do
-    Puppet::Type.type(:user).new(:name => 'name', :uid => 42, :gid => 42)
-  end
-  let :xids do
-    Hash.new {|h,k| 0}
-  end
-  before :each do
-    allow(Puppet::Util::SUIDManager).to receive(:convert_xid).and_return(42)
-    pwent = double('pwent', :name => 'fred', :uid => 42, :gid => 42)
-    allow(Etc).to receive(:getpwuid).with(42).and_return(pwent)
-    unless Puppet::Util::Platform.windows?
-      [:euid, :egid, :uid, :gid, :groups].each do |id|
-        allow(Process).to receive("#{id}=") {|value| xids[id] = value}
-      end
-    end
-  end
-  describe "#initgroups", unless: Puppet::Util::Platform.windows? do
-    it "should use the primary group of the user as the 'basegid'" do
-      expect(Process).to receive(:initgroups).with('fred', 42)
-      described_class.initgroups(42)
-    end
-  end
-  describe "#uid" do
-    it "should allow setting euid/egid", unless: Puppet::Util::Platform.windows? do
-      Puppet::Util::SUIDManager.egid = user[:gid]
-      Puppet::Util::SUIDManager.euid = user[:uid]
-      expect(xids[:egid]).to eq(user[:gid])
-      expect(xids[:euid]).to eq(user[:uid])
-    end
-  end
-  describe "#asuser" do
-    it "should not get or set euid/egid when not root", unless: Puppet::Util::Platform.windows? do
-      allow(Process).to receive(:uid).and_return(1)
-      allow(Process).to receive(:egid).and_return(51)
-      allow(Process).to receive(:euid).and_return(50)
-      Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
-      expect(xids).to be_empty
-    end
-    context "when root and not Windows" do
-      before :each do
-        allow(Process).to receive(:uid).and_return(0)
-      end
-      it "should set euid/egid", unless: Puppet::Util::Platform.windows? do
-        allow(Process).to receive(:egid).and_return(51, 51, user[:gid])
-        allow(Process).to receive(:euid).and_return(50, 50, user[:uid])
-        allow(Puppet::Util::SUIDManager).to receive(:convert_xid).with(:gid, 51).and_return(51)
-        allow(Puppet::Util::SUIDManager).to receive(:convert_xid).with(:uid, 50).and_return(50)
-        allow(Puppet::Util::SUIDManager).to receive(:initgroups).and_return([])
-        yielded = false
-        Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) do
-          expect(xids[:egid]).to eq(user[:gid])
-          expect(xids[:euid]).to eq(user[:uid])
-          yielded = true
-        end
-        expect(xids[:egid]).to eq(51)
-        expect(xids[:euid]).to eq(50)
-        # It's possible asuser could simply not yield, so the assertions in the
-        # block wouldn't fail. So verify those actually got checked.
-        expect(yielded).to be_truthy
-      end
-      it "should just yield if user and group are nil" do
-        expect { |b| Puppet::Util::SUIDManager.asuser(nil, nil, &b) }.to yield_control
-        expect(xids).to eq({})
-      end
-      it "should just change group if only group is given", unless: Puppet::Util::Platform.windows? do
-        expect { |b| Puppet::Util::SUIDManager.asuser(nil, 42, &b) }.to yield_control
-        expect(xids).to eq({ :egid => 42 })
-      end
-      it "should change gid to the primary group of uid by default", unless: Puppet::Util::Platform.windows? do
-        allow(Process).to receive(:initgroups)
-        expect { |b| Puppet::Util::SUIDManager.asuser(42, nil, &b) }.to yield_control
-        expect(xids).to eq({ :euid => 42, :egid => 42 })
-      end
-      it "should change both uid and gid if given", unless: Puppet::Util::Platform.windows? do
-        # I don't like the sequence, but it is the only way to assert on the
-        # internal behaviour in a reliable fashion, given we need multiple
-        # sequenced calls to the same methods. --daniel 2012-02-05
-        expect(Puppet::Util::SUIDManager).to receive(:change_group).with(43, false).ordered()
-        expect(Puppet::Util::SUIDManager).to receive(:change_user).with(42, false).ordered()
-        expect(Puppet::Util::SUIDManager).to receive(:change_group).with(Puppet::Util::SUIDManager.egid, false).ordered()
-        expect(Puppet::Util::SUIDManager).to receive(:change_user).with(Puppet::Util::SUIDManager.euid, false).ordered()
-        expect { |b| Puppet::Util::SUIDManager.asuser(42, 43, &b) }.to yield_control
-      end
-    end
-    it "should just yield on Windows", if: Puppet::Util::Platform.windows? do
-      expect { |b| Puppet::Util::SUIDManager.asuser(1, 2, &b) }.to yield_control
-    end
-  end
-  describe "#change_group" do
-    it "raises on Windows", if: Puppet::Util::Platform.windows? do
-      expect {
-        Puppet::Util::SUIDManager.change_group(42, true)
-      }.to raise_error(NotImplementedError, /change_privilege\(\) function is unimplemented/)
-    end
-    describe "when changing permanently", unless: Puppet::Util::Platform.windows? do
-      it "should change_privilege" do
-        expect(Process::GID).to receive(:change_privilege) do |gid|
-          Process.gid = gid
-          Process.egid = gid
-        end
-        Puppet::Util::SUIDManager.change_group(42, true)
-        expect(xids[:egid]).to eq(42)
-        expect(xids[:gid]).to eq(42)
-      end
-      it "should not change_privilege when gid already matches" do
-        expect(Process::GID).to receive(:change_privilege) do |gid|
-          Process.gid = 42
-          Process.egid = 42
-        end
-        Puppet::Util::SUIDManager.change_group(42, true)
-        expect(xids[:egid]).to eq(42)
-        expect(xids[:gid]).to eq(42)
-      end
-    end
-    describe "when changing temporarily", unless: Puppet::Util::Platform.windows? do
-      it "should change only egid" do
-        Puppet::Util::SUIDManager.change_group(42, false)
-        expect(xids[:egid]).to eq(42)
-        expect(xids[:gid]).to eq(0)
-      end
-    end
-  end
-  describe "#change_user" do
-    it "raises on Windows", if: Puppet::Util::Platform.windows? do
-      expect {
-        Puppet::Util::SUIDManager.change_user(42, true)
-      }.to raise_error(NotImplementedError, /initgroups\(\) function is unimplemented/)
-    end
-    describe "when changing permanently", unless: Puppet::Util::Platform.windows? do
-      it "should change_privilege" do
-        expect(Process::UID).to receive(:change_privilege) do |uid|
-          Process.uid = uid
-          Process.euid = uid
-        end
-        expect(Puppet::Util::SUIDManager).to receive(:initgroups).with(42)
-        Puppet::Util::SUIDManager.change_user(42, true)
-        expect(xids[:euid]).to eq(42)
-        expect(xids[:uid]).to eq(42)
-      end
-      it "should not change_privilege when uid already matches" do
-        expect(Process::UID).to receive(:change_privilege) do |uid|
-          Process.uid = 42
-          Process.euid = 42
-        end
-        expect(Puppet::Util::SUIDManager).to receive(:initgroups).with(42)
-        Puppet::Util::SUIDManager.change_user(42, true)
-        expect(xids[:euid]).to eq(42)
-        expect(xids[:uid]).to eq(42)
-      end
-    end
-    describe "when changing temporarily", unless: Puppet::Util::Platform.windows? do
-      it "should change only euid and groups" do
-        allow(Puppet::Util::SUIDManager).to receive(:initgroups).and_return([])
-        Puppet::Util::SUIDManager.change_user(42, false)
-        expect(xids[:euid]).to eq(42)
-        expect(xids[:uid]).to eq(0)
-      end
-      it "should set euid before groups if changing to root" do
-        allow(Process).to receive(:euid).and_return(50)
-        expect(Process).to receive(:euid=).ordered()
-        expect(Puppet::Util::SUIDManager).to receive(:initgroups).ordered()
-        Puppet::Util::SUIDManager.change_user(0, false)
-      end
-      it "should set groups before euid if changing from root" do
-        allow(Process).to receive(:euid).and_return(0)
-        expect(Puppet::Util::SUIDManager).to receive(:initgroups).ordered()
-        expect(Process).to receive(:euid=).ordered()
-        Puppet::Util::SUIDManager.change_user(50, false)
-      end
-    end
-  end
-  describe "#root?" do
-    describe "on POSIX systems", unless: Puppet::Util::Platform.windows? do
-      it "should be root if uid is 0" do
-        allow(Process).to receive(:uid).and_return(0)
-        expect(Puppet::Util::SUIDManager).to be_root
-      end
-      it "should not be root if uid is not 0" do
-        allow(Process).to receive(:uid).and_return(1)
-        expect(Puppet::Util::SUIDManager).not_to be_root
-      end
-    end
-    describe "on Windows", :if => Puppet::Util::Platform.windows? do
-      it "should be root if user is privileged" do
-        allow(Puppet::Util::Windows::User).to receive(:admin?).and_return(true)
-        expect(Puppet::Util::SUIDManager).to be_root
-      end
-      it "should not be root if user is not privileged" do
-        allow(Puppet::Util::Windows::User).to receive(:admin?).and_return(false)
-        expect(Puppet::Util::SUIDManager).not_to be_root
-      end
-    end
-  end
-end
-describe 'Puppet::Util::SUIDManager#groups=' do
-  subject do
-    Puppet::Util::SUIDManager
-  end
-  it "raises on Windows", if: Puppet::Util::Platform.windows? do
-    expect {
-      subject.groups = []
-    }.to raise_error(NotImplementedError, /groups=\(\) function is unimplemented/)
-  end
-  it "(#3419) should rescue Errno::EINVAL on OS X", unless: Puppet::Util::Platform.windows? do
-    expect(Process).to receive(:groups=).and_raise(Errno::EINVAL, 'blew up')
-    expect(subject).to receive(:osx_maj_ver).and_return('10.7').twice
-    subject.groups = ['list', 'of', 'groups']
-  end
-  it "(#3419) should fail if an Errno::EINVAL is raised NOT on OS X", unless: Puppet::Util::Platform.windows? do
-    expect(Process).to receive(:groups=).and_raise(Errno::EINVAL, 'blew up')
-    expect(subject).to receive(:osx_maj_ver).and_return(false)
-    expect { subject.groups = ['list', 'of', 'groups'] }.to raise_error(Errno::EINVAL)
-  end
-end