puppet 7.28.0-universal-darwin → 7.29.1-universal-darwin

data/spec/unit/util/execution_stub_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Util::ExecutionStub do
-  it "should use the provided stub code when 'set' is called" do
-    Puppet::Util::ExecutionStub.set do |command, options|
-      expect(command).to eq(['/bin/foo', 'bar'])
-      "stub output"
-    end
-    expect(Puppet::Util::ExecutionStub.current_value).not_to eq(nil)
-    expect(Puppet::Util::Execution.execute(['/bin/foo', 'bar'])).to eq("stub output")
-  end
-
-  it "should automatically restore normal execution at the conclusion of each spec test" do
-    # Note: this test relies on the previous test creating a stub.
-    expect(Puppet::Util::ExecutionStub.current_value).to eq(nil)
-  end
-
-  it "should restore normal execution after 'reset' is called", unless: Puppet::Util::Platform.jruby? do
-    # Note: "true" exists at different paths in different OSes
-    if Puppet::Util::Platform.windows?
-      true_command = [Puppet::Util.which('cmd.exe').tr('/', '\\'), '/c', 'exit 0']
-    else
-      true_command = [Puppet::Util.which('true')]
-    end
-    stub_call_count = 0
-    Puppet::Util::ExecutionStub.set do |command, options|
-      expect(command).to eq(true_command)
-      stub_call_count += 1
-      'stub called'
-    end
-    expect(Puppet::Util::Execution.execute(true_command)).to eq('stub called')
-    expect(stub_call_count).to eq(1)
-    Puppet::Util::ExecutionStub.reset
-    expect(Puppet::Util::ExecutionStub.current_value).to eq(nil)
-    expect(Puppet::Util::Execution.execute(true_command)).to eq('')
-    expect(stub_call_count).to eq(1)
-  end
-end

data/spec/unit/util/feature_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/feature'
-
-describe Puppet::Util::Feature do
-  before do
-    @features = Puppet::Util::Feature.new("features")
-    allow(@features).to receive(:warn)
-  end
-
-  it "should not call associated code when adding a feature" do
-    $loaded_feature = false
-    @features.add(:myfeature) { $loaded_feature = true}
-    expect($loaded_feature).to eq(false)
-  end
-
-  it "should consider a feature absent when the feature load fails" do
-    @features.add(:failer) { raise "foo" }
-    expect(@features.failer?).to eq(false)
-  end
-
-  it "should consider a feature to be absent when the feature load returns false" do
-    @features.add(:failer) { false }
-    expect(@features.failer?).to eq(false)
-  end
-
-  it "should consider a feature to be absent when the feature load returns nil" do
-    @features.add(:failer) { nil }
-    expect(@features.failer?).to eq(false)
-  end
-
-  it "should consider a feature to be present when the feature load returns true" do
-    @features.add(:available) { true }
-    expect(@features.available?).to eq(true)
-  end
-
-  it "should consider a feature to be present when the feature load returns truthy" do
-    @features.add(:available) { "yes" }
-    expect(@features.available?).to eq(true)
-  end
-
-  it "should cache the results of a feature load via code block when the block returns true" do
-    $loaded_feature = 0
-    @features.add(:myfeature) { $loaded_feature += 1; true }
-    @features.myfeature?
-    @features.myfeature?
-    expect($loaded_feature).to eq(1)
-  end
-
-  it "should cache the results of a feature load via code block when the block returns false" do
-    $loaded_feature = 0
-    @features.add(:myfeature) { $loaded_feature += 1; false }
-    @features.myfeature?
-    @features.myfeature?
-    expect($loaded_feature).to eq(1)
-  end
-
-  it "should not cache the results of a feature load via code block when the block returns nil" do
-    $loaded_feature = 0
-    @features.add(:myfeature) { $loaded_feature += 1; nil }
-    @features.myfeature?
-    @features.myfeature?
-    expect($loaded_feature).to eq(2)
-  end
-
-  it "should invalidate the cache for the feature when loading" do
-    @features.add(:myfeature) { false }
-    expect(@features).not_to be_myfeature
-    @features.add(:myfeature)
-    expect(@features).to be_myfeature
-  end
-
-  it "should support features with libraries" do
-    expect { @features.add(:puppet, :libs => %w{puppet}) }.not_to raise_error
-  end
-
-  it "should consider a feature to be present if all of its libraries are present" do
-    @features.add(:myfeature, :libs => %w{foo bar})
-    expect(@features).to receive(:require).with("foo")
-    expect(@features).to receive(:require).with("bar")
-
-    expect(@features).to be_myfeature
-  end
-
-  it "should log and consider a feature to be absent if any of its libraries are absent" do
-    @features.add(:myfeature, :libs => %w{foo bar})
-    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
-    allow(@features).to receive(:require).with("bar")
-
-    expect(@features).to receive(:debug_once)
-
-    expect(@features).not_to be_myfeature
-  end
-
-  it "should change the feature to be present when its libraries become available" do
-    @features.add(:myfeature, :libs => %w{foo bar})
-    times_feature_require_called = 0
-    expect(@features).to receive(:require).twice().with("foo") do
-      times_feature_require_called += 1
-      if times_feature_require_called == 1
-        raise LoadError
-      else
-        nil
-      end
-    end
-    allow(@features).to receive(:require).with("bar")
-    allow(Puppet::Util::RubyGems::Source).to receive(:source).and_return(Puppet::Util::RubyGems::Gems18Source)
-    times_clear_paths_called = 0
-    allow_any_instance_of(Puppet::Util::RubyGems::Gems18Source).to receive(:clear_paths) { times_clear_paths_called += 1 }
-
-    expect(@features).to receive(:debug_once)
-
-    expect(@features).not_to be_myfeature
-    expect(@features).to be_myfeature
-    expect(times_clear_paths_called).to eq(3)
-  end
-
-  it "should cache load failures when configured to do so" do
-    Puppet[:always_retry_plugins] = false
-
-    @features.add(:myfeature, :libs => %w{foo bar})
-    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
-
-    expect(@features).not_to be_myfeature
-    # second call would cause an expectation exception if 'require' was
-    # called a second time
-    expect(@features).not_to be_myfeature
-  end
-end

data/spec/unit/util/filetype_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/filetype'
-
-# XXX Import all of the tests into this file.
-describe Puppet::Util::FileType do
-  describe "the flat filetype" do
-    let(:path) { '/my/file' }
-    let(:type) { Puppet::Util::FileType.filetype(:flat) }
-    let(:file) { type.new(path) }
-
-    it "should exist" do
-      expect(type).not_to be_nil
-    end
-
-    describe "when the file already exists" do
-      it "should return the file's contents when asked to read it" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(Puppet::FileSystem).to receive(:read).with(path, {:encoding => Encoding.default_external}).and_return("my text")
-
-        expect(file.read).to eq("my text")
-      end
-
-      it "should unlink the file when asked to remove it" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(Puppet::FileSystem).to receive(:unlink).with(path)
-
-        file.remove
-      end
-    end
-
-    describe "when the file does not exist" do
-      it "should return an empty string when asked to read the file" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
-
-        expect(file.read).to eq("")
-      end
-    end
-
-    describe "when writing the file" do
-      let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
-
-      before do
-        allow(FileUtils).to receive(:cp)
-        allow(Tempfile).to receive(:new).and_return(tempfile)
-      end
-
-      it "should first create a temp file and copy its contents over to the file location" do
-        expect(Tempfile).to receive(:new).with("puppet", {:encoding => Encoding.default_external}).and_return(tempfile)
-        expect(tempfile).to receive(:print).with("my text")
-        expect(tempfile).to receive(:flush)
-        expect(tempfile).to receive(:close)
-        expect(FileUtils).to receive(:cp).with(tempfile.path, path)
-
-        file.write "my text"
-      end
-
-      it "should set the selinux default context on the file" do
-        expect(file).to receive(:set_selinux_default_context).with(path)
-        file.write "eh"
-      end
-    end
-
-    describe "when backing up a file" do
-      it "should do nothing if the file does not exist" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
-        expect(file).not_to receive(:bucket)
-        file.backup
-      end
-
-      it "should use its filebucket to backup the file if it exists" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-
-        bucket = double('bucket')
-        expect(bucket).to receive(:backup).with(path)
-
-        expect(file).to receive(:bucket).and_return(bucket)
-        file.backup
-      end
-
-      it "should use the default filebucket" do
-        bucket = double('bucket')
-        expect(bucket).to receive(:bucket).and_return("mybucket")
-
-        expect(Puppet::Type.type(:filebucket)).to receive(:mkdefaultbucket).and_return(bucket)
-
-        expect(file.bucket).to eq("mybucket")
-      end
-    end
-  end
-
-  shared_examples_for "crontab provider" do
-    let(:cron)         { type.new('no_such_user') }
-    let(:crontab)      { File.read(my_fixture(crontab_output)) }
-    let(:options)      { { :failonfail => true, :combine => true } }
-    let(:uid)          { 'no_such_user' }
-    let(:user_options) { options.merge({:uid => uid}) }
-
-    it "should exist" do
-      expect(type).not_to be_nil
-    end
-
-    # make Puppet::Util::SUIDManager return something deterministic, not the
-    # uid of the user running the tests, except where overridden below.
-    before :each do
-      allow(Puppet::Util::SUIDManager).to receive(:uid).and_return(1234)
-    end
-
-    describe "#read" do
-      before(:each) do
-        allow(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
-      end
-
-      it "should run crontab -l as the target user" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(['crontab', '-l'], user_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
-        expect(cron.read).to eq(crontab)
-      end
-
-      it "should not switch user if current user is the target user" do
-        expect(Puppet::Util).to receive(:uid).with(uid).twice.and_return(9000)
-        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(['crontab', '-l'], options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
-        expect(cron.read).to eq(crontab)
-      end
-
-      it "should treat an absent crontab as empty" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, absent_crontab)
-        expect(cron.read).to eq('')
-      end
-
-      it "should treat a nonexistent user's crontab as empty" do
-        expect(Puppet::Util).to receive(:uid).with(uid).and_return(nil)
-
-        expect(cron.read).to eq('')
-      end
-
-      it "should return empty if the user is not authorized to use cron" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, unauthorized_crontab)
-        expect(cron.read).to eq('')
-      end
-    end
-
-    describe "#remove" do
-      it "should run crontab -r as the target user" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-r'], user_options)
-        cron.remove
-      end
-
-      it "should not switch user if current user is the target user" do
-        expect(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
-        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab','-r'], options)
-        cron.remove
-      end
-    end
-
-    describe "#write" do
-      before :each do
-        @tmp_cron = Tempfile.new("puppet_crontab_spec")
-        @tmp_cron_path = @tmp_cron.path
-        allow(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
-        expect(Tempfile).to receive(:new).with("puppet_#{name}", {:encoding => Encoding.default_external}).and_return(@tmp_cron)
-      end
-
-      after :each do
-        expect(Puppet::FileSystem.exist?(@tmp_cron_path)).to be_falsey
-      end
-
-      it "should run crontab as the target user on a temporary file" do
-        expect(File).to receive(:chown).with(9000, nil, @tmp_cron_path)
-        expect(Puppet::Util::Execution).to receive(:execute).with(["crontab", @tmp_cron_path], user_options)
-
-        expect(@tmp_cron).to receive(:print).with("foo\n")
-        cron.write "foo\n"
-      end
-
-      it "should not switch user if current user is the target user" do
-        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
-        expect(File).to receive(:chown).with(9000, nil, @tmp_cron_path)
-        expect(Puppet::Util::Execution).to receive(:execute).with(["crontab", @tmp_cron_path], options)
-
-        expect(@tmp_cron).to receive(:print).with("foo\n")
-        cron.write "foo\n"
-      end
-    end
-  end
-
-  describe "the suntab filetype", :unless => Puppet::Util::Platform.windows? do
-    let(:type)           { Puppet::Util::FileType.filetype(:suntab) }
-    let(:name)           { type.name }
-    let(:crontab_output) { 'suntab_output' }
-
-    # possible crontab output was taken from here:
-    # https://docs.oracle.com/cd/E19082-01/819-2380/sysrescron-60/index.html
-    let(:absent_crontab) do
-      'crontab: can\'t open your crontab file'
-    end
-    let(:unauthorized_crontab) do
-      'crontab: you are not authorized to use cron. Sorry.'
-    end
-
-    it_should_behave_like "crontab provider"
-  end
-
-  describe "the aixtab filetype", :unless => Puppet::Util::Platform.windows? do
-    let(:type)           { Puppet::Util::FileType.filetype(:aixtab) }
-    let(:name)           { type.name }
-    let(:crontab_output) { 'aixtab_output' }
-
-    let(:absent_crontab) do
-      '0481-103 Cannot open a file in the /var/spool/cron/crontabs directory.'
-    end
-    let(:unauthorized_crontab) do
-      '0481-109 You are not authorized to use the cron command.'
-    end
-
-    it_should_behave_like "crontab provider"
-  end
-end