puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/puppet_pal_spec.rb

@@ -1,3 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require_relative 'puppet_pal_2pec'

data/spec/unit/puppet_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-require 'puppet'
-require 'puppet_spec/files'
-
-describe Puppet do
-  include PuppetSpec::Files
-
-  context "#version" do
-    it "should be valid semver" do
-      expect(SemanticPuppet::Version).to be_valid Puppet.version
-    end
-  end
-
-  Puppet::Util::Log.eachlevel do |level|
-    it "should have a method for sending '#{level}' logs" do
-      expect(Puppet).to respond_to(level)
-    end
-  end
-
-  it "should be able to change the path" do
-    newpath = ENV["PATH"] + File::PATH_SEPARATOR + "/something/else"
-    Puppet[:path] = newpath
-    expect(ENV["PATH"]).to eq(newpath)
-  end
-
-  it 'should propagate --modulepath to base environment' do
-    expect(Puppet::Node::Environment).to receive(:create).with(
-      be_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
-
-    Puppet.base_context({
-      :environmentpath => '/envs',
-      :basemodulepath => '/base/modules',
-      :modulepath => '/my/modules'
-    })
-  end
-
-  it 'empty modulepath does not override basemodulepath' do
-    expect(Puppet::Node::Environment).to receive(:create).with(
-      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
-
-    Puppet.base_context({
-      :environmentpath => '/envs',
-      :basemodulepath => '/base/modules',
-      :modulepath => ''
-    })
-  end
-
-  it 'nil modulepath does not override basemodulepath' do
-    expect(Puppet::Node::Environment).to receive(:create).with(
-      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
-
-    Puppet.base_context({
-      :environmentpath => '/envs',
-      :basemodulepath => '/base/modules',
-      :modulepath => nil
-    })
-  end
-
-  context "Puppet::OLDEST_RECOMMENDED_RUBY_VERSION" do
-    it "should have an oldest recommended ruby version constant" do
-      expect(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION).not_to be_nil
-    end
-
-    it "should be a string" do
-      expect(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION).to be_a_kind_of(String)
-    end
-
-    it "should match a semver version" do
-      expect(SemanticPuppet::Version).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
-    end
-  end
-
-  context "Settings" do
-    before(:each) do
-      @old_settings = Puppet.settings
-    end
-    after(:each) do
-      Puppet.replace_settings_object(@old_settings)
-    end
-    it "should allow for settings to be redefined with a custom object" do
-      new_settings = double()
-      Puppet.replace_settings_object(new_settings)
-      expect(Puppet.settings).to eq(new_settings)
-    end
-  end
-
-  context 'when registering implementations' do
-    it 'does not register an implementation by default' do
-      Puppet.initialize_settings
-
-      expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::Client)
-    end
-
-    it 'allows a http implementation to be registered' do
-      http_impl = double('http')
-      Puppet.initialize_settings([], true, true, http: http_impl)
-
-
-      expect(Puppet.runtime[:http]).to eq(http_impl)
-    end
-
-    it 'allows a facter implementation to be registered' do
-      facter_impl = double('facter')
-      Puppet.initialize_settings([], true, true, facter: facter_impl)
-
-
-      expect(Puppet.runtime[:facter]).to eq(facter_impl)
-    end
-  end
-
-  context "initializing $LOAD_PATH" do
-    it "should add libdir and module paths to the load path" do
-      libdir = tmpdir('libdir_test')
-      vendor_dir = tmpdir('vendor_modules')
-      module_libdir = File.join(vendor_dir, 'amodule_core', 'lib')
-      FileUtils.mkdir_p(module_libdir)
-
-      Puppet[:libdir] = libdir
-      Puppet[:vendormoduledir] = vendor_dir
-      Puppet.initialize_settings
-
-      expect($LOAD_PATH).to include(libdir)
-      expect($LOAD_PATH).to include(module_libdir)
-    end
-
-  end
-end

data/spec/unit/relationship_spec.rb

@@ -1,202 +0,0 @@
-require 'spec_helper'
-require 'puppet/relationship'
-
-describe Puppet::Relationship do
-  before do
-    @edge = Puppet::Relationship.new(:a, :b)
-  end
-
-  it "should have a :source attribute" do
-    expect(@edge).to respond_to(:source)
-  end
-
-  it "should have a :target attribute" do
-    expect(@edge).to respond_to(:target)
-  end
-
-  it "should have a :callback attribute" do
-    @edge.callback = :foo
-    expect(@edge.callback).to eq(:foo)
-  end
-
-  it "should have an :event attribute" do
-    @edge.event = :NONE
-    expect(@edge.event).to eq(:NONE)
-  end
-
-  it "should require a callback if a non-NONE event is specified" do
-    expect { @edge.event = :something }.to raise_error(ArgumentError)
-  end
-
-  it "should have a :label attribute" do
-    expect(@edge).to respond_to(:label)
-  end
-
-  it "should provide a :ref method that describes the edge" do
-    @edge = Puppet::Relationship.new("a", "b")
-    expect(@edge.ref).to eq("a => b")
-  end
-
-  it "should be able to produce a label as a hash with its event and callback" do
-    @edge.callback = :foo
-    @edge.event = :bar
-
-    expect(@edge.label).to eq({:callback => :foo, :event => :bar})
-  end
-
-  it "should work if nil options are provided" do
-    expect { Puppet::Relationship.new("a", "b", nil) }.not_to raise_error
-  end
-end
-
-describe Puppet::Relationship, " when initializing" do
-  before do
-    @edge = Puppet::Relationship.new(:a, :b)
-  end
-
-  it "should use the first argument as the source" do
-    expect(@edge.source).to eq(:a)
-  end
-
-  it "should use the second argument as the target" do
-    expect(@edge.target).to eq(:b)
-  end
-
-  it "should set the rest of the arguments as the event and callback" do
-    @edge = Puppet::Relationship.new(:a, :b, :callback => :foo, :event => :bar)
-    expect(@edge.callback).to eq(:foo)
-    expect(@edge.event).to eq(:bar)
-  end
-
-  it "should accept events specified as strings" do
-    @edge = Puppet::Relationship.new(:a, :b, "event" => :NONE)
-    expect(@edge.event).to eq(:NONE)
-  end
-
-  it "should accept callbacks specified as strings" do
-    @edge = Puppet::Relationship.new(:a, :b, "callback" => :foo)
-    expect(@edge.callback).to eq(:foo)
-  end
-end
-
-describe Puppet::Relationship, " when matching edges with no specified event" do
-  before do
-    @edge = Puppet::Relationship.new(:a, :b)
-  end
-
-  it "should not match :NONE" do
-    expect(@edge).not_to be_match(:NONE)
-  end
-
-  it "should not match :ALL_EVENTS" do
-    expect(@edge).not_to be_match(:ALL_EVENTS)
-  end
-
-  it "should not match any other events" do
-    expect(@edge).not_to be_match(:whatever)
-  end
-end
-
-describe Puppet::Relationship, " when matching edges with :NONE as the event" do
-  before do
-    @edge = Puppet::Relationship.new(:a, :b, :event => :NONE)
-  end
-  it "should not match :NONE" do
-    expect(@edge).not_to be_match(:NONE)
-  end
-
-  it "should not match :ALL_EVENTS" do
-    expect(@edge).not_to be_match(:ALL_EVENTS)
-  end
-
-  it "should not match other events" do
-    expect(@edge).not_to be_match(:yayness)
-  end
-end
-
-describe Puppet::Relationship, " when matching edges with :ALL as the event" do
-  before do
-    @edge = Puppet::Relationship.new(:a, :b, :event => :ALL_EVENTS, :callback => :whatever)
-  end
-
-  it "should not match :NONE" do
-    expect(@edge).not_to be_match(:NONE)
-  end
-
-  it "should match :ALL_EVENTS" do
-    expect(@edge).to be_match(:ALL_EVENTS)
-  end
-
-  it "should match all other events" do
-    expect(@edge).to be_match(:foo)
-  end
-end
-
-describe Puppet::Relationship, " when matching edges with a non-standard event" do
-  before do
-    @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
-  end
-
-  it "should not match :NONE" do
-    expect(@edge).not_to be_match(:NONE)
-  end
-
-  it "should not match :ALL_EVENTS" do
-    expect(@edge).not_to be_match(:ALL_EVENTS)
-  end
-
-  it "should match events with the same name" do
-    expect(@edge).to be_match(:random)
-  end
-end
-
-describe Puppet::Relationship, "when converting to json" do
-  before do
-    @edge = Puppet::Relationship.new('a', 'b', :event => :random, :callback => :whatever)
-  end
-
-  it "should store the stringified source as the source in the data" do
-    expect(JSON.parse(@edge.to_json)["source"]).to eq("a")
-  end
-
-  it "should store the stringified target as the target in the data" do
-    expect(JSON.parse(@edge.to_json)['target']).to eq("b")
-  end
-
-  it "should store the jsonified event as the event in the data" do
-    expect(JSON.parse(@edge.to_json)["event"]).to eq("random")
-  end
-
-  it "should not store an event when none is set" do
-    @edge.event = nil
-    expect(JSON.parse(@edge.to_json)).not_to include('event')
-  end
-
-  it "should store the jsonified callback as the callback in the data" do
-    @edge.callback = "whatever"
-    expect(JSON.parse(@edge.to_json)["callback"]).to eq("whatever")
-  end
-
-  it "should not store a callback when none is set in the edge" do
-    @edge.callback = nil
-    expect(JSON.parse(@edge.to_json)).not_to include('callback')
-  end
-end
-
-describe Puppet::Relationship, "when converting from json" do
-  it "should pass the source in as the first argument" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").source).to eq('mysource')
-  end
-
-  it "should pass the target in as the second argument" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").target).to eq('mytarget')
-  end
-
-  it "should pass the event as an argument if it's provided" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event).to eq(:myevent)
-  end
-
-  it "should pass the callback as an argument if it's provided" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback).to eq(:mycallback)
-  end
-end

data/spec/unit/reports/http_spec.rb

@@ -1,119 +0,0 @@
-require 'spec_helper'
-require 'puppet/reports'
-
-describe Puppet::Reports.report(:http) do
-  subject { Puppet::Transaction::Report.new.extend(described_class) }
-
-  let(:url) { "https://puppet.example.com/report/upload" }
-
-  before :each do
-    Puppet[:reporturl] = url
-  end
-
-  describe "when setting up the connection" do
-    it "raises if the connection fails" do
-      stub_request(:post, url).to_raise(Errno::ECONNREFUSED.new('Connection refused - connect(2)'))
-
-      expect {
-        subject.process
-      }.to raise_error(Puppet::HTTP::HTTPError, /Request to #{url} failed after .* seconds: .*Connection refused/)
-    end
-
-    it "configures the connection for ssl when using https" do
-      stub_request(:post, url)
-
-      expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
-        expect(http).to be_use_ssl
-        expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-      end
-
-      subject.process
-    end
-
-    it "does not configure the connection for ssl when using http" do
-      Puppet[:reporturl] = 'http://puppet.example.com:8080/the/path'
-      stub_request(:post, Puppet[:reporturl])
-
-      expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
-        expect(http).to_not be_use_ssl
-      end
-
-      subject.process
-    end
-  end
-
-  describe "when making a request" do
-    it "uses the path specified by the 'reporturl' setting" do
-      req = stub_request(:post, url)
-
-      subject.process
-
-      expect(req).to have_been_requested
-    end
-
-    it "uses the username and password specified by the 'reporturl' setting" do
-      Puppet[:reporturl] = "https://user:pass@puppet.example.com/report/upload"
-
-      req = stub_request(:post, %r{/report/upload}).with(basic_auth: ['user', 'pass'])
-
-      subject.process
-
-      expect(req).to have_been_requested
-    end
-
-    it "passes metric_id options" do
-      stub_request(:post, url)
-
-      expect(Puppet.runtime[:http]).to receive(:post).with(anything, anything, hash_including(options: hash_including(metric_id: [:puppet, :report, :http]))).and_call_original
-
-      subject.process
-    end
-
-    it "passes the report as YAML" do
-      req = stub_request(:post, url).with(body: subject.to_yaml)
-
-      subject.process
-
-      expect(req).to have_been_requested
-    end
-
-    it "sets content-type to 'application/x-yaml'" do
-      req = stub_request(:post, url).with(headers: {'Content-Type' => 'application/x-yaml'})
-
-      subject.process
-
-      expect(req).to have_been_requested
-    end
-
-    it "doesn't log anything if the request succeeds" do
-      req = stub_request(:post, url).to_return(status: [200, "OK"])
-
-      subject.process
-
-      expect(req).to have_been_requested
-      expect(@logs).to eq([])
-    end
-
-    it "follows redirects" do
-      location = {headers: {'Location' => url}}
-
-      req = stub_request(:post, url)
-              .to_return(**location, status: [301, "Moved Permanently"]).then
-              .to_return(**location, status: [302, "Found"]).then
-              .to_return(**location, status: [307, "Temporary Redirect"]).then
-              .to_return(status: [200, "OK"])
-
-      subject.process
-
-      expect(req).to have_been_requested.times(4)
-    end
-
-    it "logs an error if the request fails" do
-      stub_request(:post, url).to_return(status: [500, "Internal Server Error"])
-
-      subject.process
-
-      expect(@logs).to include(having_attributes(level: :err, message: "Unable to submit report to #{url} [500] Internal Server Error"))
-    end
-  end
-end

data/spec/unit/reports/store_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/reports'
-require 'time'
-require 'pathname'
-require 'tempfile'
-require 'fileutils'
-
-describe Puppet::Reports.report(:store) do
-  describe "#process" do
-    include PuppetSpec::Files
-
-    before :each do
-      Puppet[:reportdir] = File.join(tmpdir('reports'), 'reports')
-    end
-
-    let(:report) do
-      if RUBY_VERSION < "3.0"
-        report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
-      else
-        report = YAML.unsafe_load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
-      end
-      report.extend(described_class)
-      report
-    end
-
-    it "should create a report directory for the client if one doesn't exist" do
-      report.process
-
-      expect(File).to be_directory(File.join(Puppet[:reportdir], report.host))
-    end
-
-    it "should write the report to the file in YAML" do
-      allow(Time).to receive(:now).and_return(Time.utc(2011,01,06,12,00,00))
-      report.process
-
-      expect(File.read(File.join(Puppet[:reportdir], report.host, "201101061200.yaml"))).to eq(report.to_yaml)
-    end
-
-    it "rejects invalid hostnames" do
-      report.host = ".."
-      expect(Puppet::FileSystem).not_to receive(:exist?)
-      expect { report.process }.to raise_error(ArgumentError, /Invalid node/)
-    end
-  end
-
-  describe "::destroy" do
-    it "rejects invalid hostnames" do
-      expect(Puppet::FileSystem).not_to receive(:unlink)
-      expect { described_class.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
-    end
-  end
-
-  describe "::validate_host" do
-    ['..', 'hello/', '/hello', 'he/llo', 'hello/..', '.'].each do |node|
-      it "rejects #{node.inspect}" do
-        expect { described_class.validate_host(node) }.to raise_error(ArgumentError, /Invalid node/)
-      end
-    end
-
-    ['.hello', 'hello.', '..hi', 'hi..'].each do |node|
-      it "accepts #{node.inspect}" do
-        described_class.validate_host(node)
-      end
-    end
-  end
-end

data/spec/unit/reports_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/reports'
-
-describe Puppet::Reports do
-  it "should instance-load report types" do
-    expect(Puppet::Reports.instance_loader(:report)).to be_instance_of(Puppet::Util::Autoload)
-  end
-
-  it "should have a method for registering report types" do
-    expect(Puppet::Reports).to respond_to(:register_report)
-  end
-
-  it "should have a method for retrieving report types by name" do
-    expect(Puppet::Reports).to respond_to(:report)
-  end
-
-  it "should provide a method for returning documentation for all reports" do
-    expect(Puppet::Reports).to receive(:loaded_instances).with(:report).and_return([:one, :two])
-    one = double('one', :doc => "onedoc")
-    two = double('two', :doc => "twodoc")
-    expect(Puppet::Reports).to receive(:report).with(:one).and_return(one)
-    expect(Puppet::Reports).to receive(:report).with(:two).and_return(two)
-
-    doc = Puppet::Reports.reportdocs
-    expect(doc.include?("onedoc")).to be_truthy
-    expect(doc.include?("twodoc")).to be_truthy
-  end
-end
-
-describe Puppet::Reports, " when loading report types" do
-  it "should use the instance loader to retrieve report types" do
-    expect(Puppet::Reports).to receive(:loaded_instance).with(:report, :myreporttype)
-    Puppet::Reports.report(:myreporttype)
-  end
-end
-
-describe Puppet::Reports, " when registering report types" do
-  it "should evaluate the supplied block as code for a module" do
-    expect(Puppet::Reports).to receive(:genmodule).and_return(Module.new)
-    Puppet::Reports.register_report(:testing) { }
-  end
-
-  it "should allow a successful report to be reloaded" do
-    Puppet::Reports.register_report(:testing) { }
-    Puppet::Reports.register_report(:testing) { }
-  end
-
-  it "should allow a failed report to be reloaded and show the correct exception both times" do
-    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
-    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
-  end
-
-  it "should extend the report type with the Puppet::Util::Docs module" do
-    mod = double('module', :define_method => true)
-
-    expect(Puppet::Reports).to receive(:genmodule).with(anything, hash_including(extend: Puppet::Util::Docs)).and_return(mod)
-    Puppet::Reports.register_report(:testing) { }
-  end
-
-  it "should define a :report_name method in the module that returns the name of the report" do
-    mod = double('module')
-    expect(mod).to receive(:define_method).with(:report_name)
-
-    expect(Puppet::Reports).to receive(:genmodule).and_return(mod)
-    Puppet::Reports.register_report(:testing) { }
-  end
-end