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

data/spec/unit/indirector/node/rest_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/node/rest'
-
-describe Puppet::Node::Rest do
-  let(:certname) { 'ziggy' }
-  let(:uri) { %r{/puppet/v3/node/ziggy} }
-  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
-  let(:node) { Puppet::Node.new(certname) }
-
-  before :each do
-    Puppet[:server] = 'compiler.example.com'
-    Puppet[:serverport] = 8140
-
-    described_class.indirection.terminus_class = :rest
-  end
-
-  def node_response(node)
-    { body: formatter.render(node), headers: {'Content-Type' => formatter.mime } }
-  end
-
-  it 'finds a node' do
-    stub_request(:get, uri).to_return(**node_response(node))
-
-    expect(described_class.indirection.find(certname)).to be_a(Puppet::Node)
-  end
-
-  it "serializes the environment" do
-    stub_request(:get, uri)
-      .with(query: hash_including('environment' => 'outerspace'))
-      .to_return(**node_response(node))
-
-    described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
-  end
-
-  it 'preserves the node environment_name as a symbol' do
-    env = Puppet::Node::Environment.remote('outerspace')
-    node = Puppet::Node.new(certname, environment: env)
-
-    stub_request(:get, uri).to_return(**node_response(node))
-
-    expect(described_class.indirection.find(certname).environment_name).to eq(:outerspace)
-  end
-
-  it 'returns nil if the node does not exist' do
-    stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
-
-    expect(described_class.indirection.find(certname)).to be_nil
-  end
-
-  it 'raises if fail_on_404 is specified' do
-    stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
-
-    expect{
-      described_class.indirection.find(certname, fail_on_404: true)
-    }.to raise_error(Puppet::Error, %r{Find /puppet/v3/node/ziggy resulted in 404 with the message: {}})
-  end
-
-  it 'raises Net::HTTPError on 500' do
-    stub_request(:get, uri).to_return(status: 500)
-
-    expect{
-      described_class.indirection.find(certname)
-    }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
-  end
-end

data/spec/unit/indirector/node/store_configs_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'puppet/node'
-require 'puppet/indirector/memory'
-require 'puppet/indirector/node/store_configs'
-
-class Puppet::Node::StoreConfigsTesting < Puppet::Indirector::Memory
-end
-
-describe Puppet::Node::StoreConfigs do
-  after :each do
-    Puppet::Node.indirection.reset_terminus_class
-    Puppet::Node.indirection.cache_class = nil
-  end
-
-  it_should_behave_like "a StoreConfigs terminus"
-end

data/spec/unit/indirector/node/yaml_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/node'
-require 'puppet/indirector/node/yaml'
-
-describe Puppet::Node::Yaml do
-  it "should be a subclass of the Yaml terminus" do
-    expect(Puppet::Node::Yaml.superclass).to equal(Puppet::Indirector::Yaml)
-  end
-
-  it "should have documentation" do
-    expect(Puppet::Node::Yaml.doc).not_to be_nil
-  end
-
-  it "should be registered with the configuration store indirection" do
-    indirection = Puppet::Indirector::Indirection.instance(:node)
-    expect(Puppet::Node::Yaml.indirection).to equal(indirection)
-  end
-
-  it "should have its name set to :node" do
-    expect(Puppet::Node::Yaml.name).to eq(:yaml)
-  end
-end

data/spec/unit/indirector/none_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/none'
-
-describe Puppet::Indirector::None do
-  before do
-    allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
-    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(indirection)
-
-    module Testing; end
-    @none_class = class Testing::None < Puppet::Indirector::None
-      self
-    end
-
-    @data_binder = @none_class.new
-  end
-
-  let(:model)   { double('model') }
-  let(:request) { double('request', :key => "port") }
-  let(:indirection) do
-    double('indirection', :name => :none, :register_terminus_type => nil,
-      :model => model)
-  end
-
-  it "should not be the default data_binding_terminus" do
-    expect(Puppet.settings[:data_binding_terminus]).not_to eq('none')
-  end
-
-  describe "the behavior of the find method" do
-    it "should just return nil" do
-      expect(@data_binder.find(request)).to be_nil
-    end
-  end
-end

data/spec/unit/indirector/plain_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/plain'
-
-describe Puppet::Indirector::Plain do
-  before do
-    allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
-    @model = double('model')
-    @indirection = double('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
-    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(@indirection)
-
-    module Testing; end
-    @plain_class = class Testing::MyPlain < Puppet::Indirector::Plain
-      self
-    end
-
-    @searcher = @plain_class.new
-
-    @request = double('request', :key => "yay")
-  end
-
-  it "should return return an instance of the indirected model" do
-    object = double('object')
-    expect(@model).to receive(:new).with(@request.key).and_return(object)
-    expect(@searcher.find(@request)).to equal(object)
-  end
-end

data/spec/unit/indirector/report/json_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/transaction/report'
-require 'puppet/indirector/report/json'
-
-describe Puppet::Transaction::Report::Json do
-  include PuppetSpec::Files
-  describe '#save' do
-    subject(:indirection) { described_class.indirection }
-
-    let(:request) { described_class.new }
-    let(:certname) { 'ziggy' }
-    let(:report) do
-      report = Puppet::Transaction::Report.new
-      report.host = certname
-      report
-    end
-    let(:file) { request.path(:me) }
-
-    before do
-      Puppet[:lastrunreport] = File.join(Puppet[:statedir], "last_run_report.json")
-
-      indirection.terminus_class = :json
-    end
-
-    it 'saves the instance of the report as JSON to disk' do
-
-      indirection.save(report)
-      json = Puppet::FileSystem.read(Puppet[:lastrunreport], :encoding => 'bom|utf-8')
-      content = Puppet::Util::Json.load(json)
-      expect(content["host"]).to eq(certname)
-    end
-
-    it 'allows mode overwrite' do
-      Puppet.settings.setting(:lastrunreport).mode = '0644'
-      indirection.save(report)
-
-      if Puppet::Util::Platform.windows?
-        mode = File.stat(file).mode
-      else
-        mode = Puppet::FileSystem.stat(file).mode
-      end
-
-      expect(mode & 07777).to eq(0644)
-    end
-
-    context 'when mode is invalid' do
-      before do
-        Puppet.settings.setting(:lastrunreport).mode = '9999'
-      end
-
-      after do
-        Puppet.settings.setting(:lastrunreport).mode = '0644'
-      end
-
-      it 'raises Puppet::DevError ' do
-        expect{
-          indirection.save(report)
-        }.to raise_error(Puppet::DevError, "replace_file mode: 9999 is invalid")
-      end
-    end
-
-    context 'when report cannot be saved' do
-      it 'raises Error' do
-        FileUtils.mkdir_p(file)
-        expect {
-          indirection.save(report)
-         }.to raise_error(Errno::EISDIR, /last_run_report.json/)
-      end
-    end
-  end
-end

data/spec/unit/indirector/report/msgpack_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/transaction/report'
-require 'puppet/indirector/report/msgpack'
-
-describe Puppet::Transaction::Report::Msgpack, :if => Puppet.features.msgpack? do
-  it "should be a subclass of the Msgpack terminus" do
-    expect(Puppet::Transaction::Report::Msgpack.superclass).to equal(Puppet::Indirector::Msgpack)
-  end
-
-  it "should have documentation" do
-    expect(Puppet::Transaction::Report::Msgpack.doc).not_to be_nil
-  end
-
-  it "should be registered with the report indirection" do
-    indirection = Puppet::Indirector::Indirection.instance(:report)
-    expect(Puppet::Transaction::Report::Msgpack.indirection).to equal(indirection)
-  end
-
-  it "should have its name set to :msgpack" do
-    expect(Puppet::Transaction::Report::Msgpack.name).to eq(:msgpack)
-  end
-
-  it "should unconditionally save/load from the --lastrunreport setting" do
-    expect(subject.path(:me)).to eq(Puppet[:lastrunreport])
-  end
-end

data/spec/unit/indirector/report/processor_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/report/processor'
-
-describe Puppet::Transaction::Report::Processor do
-  before do
-    allow(Puppet.settings).to receive(:use).and_return(true)
-  end
-
-  it "should provide a method for saving reports" do
-    expect(Puppet::Transaction::Report::Processor.new).to respond_to(:save)
-  end
-
-  it "should provide a method for cleaning reports" do
-    expect(Puppet::Transaction::Report::Processor.new).to respond_to(:destroy)
-  end
-
-end
-
-describe Puppet::Transaction::Report::Processor, " when processing a report" do
-  before do
-    allow(Puppet.settings).to receive(:use)
-    @reporter = Puppet::Transaction::Report::Processor.new
-    @request = double('request', :instance => double("report", :host => 'hostname'), :key => 'node')
-  end
-
-  it "should not save the report if reports are set to 'none'" do
-    expect(Puppet::Reports).not_to receive(:report)
-    Puppet[:reports] = 'none'
-
-    request = Puppet::Indirector::Request.new(:indirection_name, :head, "key", nil)
-    report = Puppet::Transaction::Report.new
-    request.instance = report
-
-    @reporter.save(request)
-  end
-
-  it "should save the report with each configured report type" do
-    Puppet[:reports] = "one,two"
-    expect(@reporter.send(:reports)).to eq(%w{one two})
-
-    expect(Puppet::Reports).to receive(:report).with('one')
-    expect(Puppet::Reports).to receive(:report).with('two')
-
-    @reporter.save(@request)
-  end
-
-  it "should destroy reports for each processor that responds to destroy" do
-    Puppet[:reports] = "http,store"
-    http_report = double()
-    store_report = double()
-    expect(store_report).to receive(:destroy).with(@request.key)
-    expect(Puppet::Reports).to receive(:report).with('http').and_return(http_report)
-    expect(Puppet::Reports).to receive(:report).with('store').and_return(store_report)
-    @reporter.destroy(@request)
-  end
-end
-
-describe Puppet::Transaction::Report::Processor, " when processing a report" do
-  before do
-    Puppet[:reports] = "one"
-    allow(Puppet.settings).to receive(:use)
-    @reporter = Puppet::Transaction::Report::Processor.new
-
-    @report_type = double('one')
-    @dup_report = double('dupe report')
-    allow(@dup_report).to receive(:process)
-    @report = Puppet::Transaction::Report.new
-    expect(@report).to receive(:dup).and_return(@dup_report)
-
-    @request = double('request', :instance => @report)
-
-    expect(Puppet::Reports).to receive(:report).with("one").and_return(@report_type)
-
-    expect(@dup_report).to receive(:extend).with(@report_type)
-  end
-
-  # LAK:NOTE This is stupid, because the code is so short it doesn't
-  # make sense to split it out, which means I just do the same test
-  # three times so the spec looks right.
-  it "should process a duplicate of the report, not the original" do
-    @reporter.save(@request)
-  end
-
-  it "should extend the report with the report type's module" do
-    @reporter.save(@request)
-  end
-
-  it "should call the report type's :process method" do
-    expect(@dup_report).to receive(:process)
-    @reporter.save(@request)
-  end
-
-  it "should not raise exceptions" do
-    Puppet[:trace] = false
-    expect(@dup_report).to receive(:process).and_raise(ArgumentError)
-    expect { @reporter.save(@request) }.not_to raise_error
-  end
-end

data/spec/unit/indirector/report/rest_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/report/rest'
-
-describe Puppet::Transaction::Report::Rest do
-  let(:certname) { 'ziggy' }
-  let(:uri) { %r{/puppet/v3/report/ziggy} }
-  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
-  let(:report) do
-    report = Puppet::Transaction::Report.new
-    report.host = certname
-    report
-  end
-
-  before(:each) do
-    described_class.indirection.terminus_class = :rest
-  end
-
-  def report_response
-    { body: formatter.render(["store", "http"]), headers: {'Content-Type' => formatter.mime } }
-  end
-
-  it "saves a report " do
-    stub_request(:put, uri)
-      .to_return(status: 200, **report_response)
-
-    described_class.indirection.save(report)
-  end
-
-  it "serializes the environment" do
-    stub_request(:put, uri)
-      .with(query: hash_including('environment' => 'outerspace'))
-      .to_return(**report_response)
-
-    described_class.indirection.save(report, nil, environment: Puppet::Node::Environment.remote('outerspace'))
-  end
-
-  it "deserializes the response as an array of report processor names" do
-    stub_request(:put, %r{/puppet/v3/report})
-      .to_return(status: 200, **report_response)
-
-    expect(described_class.indirection.save(report)).to eq(["store", "http"])
-  end
-
-  it "returns nil if the node does not exist" do
-    stub_request(:put, uri)
-      .to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
-
-    expect(described_class.indirection.save(report)).to be_nil
-  end
-
-  it "parses charset from response content-type" do
-    stub_request(:put, uri)
-      .to_return(status: 200, body: JSON.dump(["store"]), headers: { 'Content-Type' => 'application/json;charset=utf-8' })
-
-    expect(described_class.indirection.save(report)).to eq(["store"])
-  end
-end

data/spec/unit/indirector/report/yaml_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/transaction/report'
-require 'puppet/indirector/report/yaml'
-
-describe Puppet::Transaction::Report::Yaml do
-  it "should be registered with the report indirection" do
-    indirection = Puppet::Indirector::Indirection.instance(:report)
-    expect(Puppet::Transaction::Report::Yaml.indirection).to equal(indirection)
-  end
-
-  it "should have its name set to :yaml" do
-    expect(Puppet::Transaction::Report::Yaml.name).to eq(:yaml)
-  end
-
-  it "should unconditionally save/load from the --lastrunreport setting" do
-    expect(subject.path(:me)).to eq(Puppet[:lastrunreport])
-  end
-
-  describe '#save' do
-    subject(:indirection) { described_class.indirection }
-
-    let(:request) { described_class.new }
-    let(:certname) { 'ziggy' }
-    let(:report) do
-      report = Puppet::Transaction::Report.new
-      report.host = certname
-      report
-    end
-    let(:file) { request.path(:me) }
-
-    before do
-      indirection.terminus_class = :yaml
-    end
-
-    it 'saves the instance of the report as YAML to disk' do
-      indirection.save(report)
-      content = Puppet::Util::Yaml.safe_load_file(
-        Puppet[:lastrunreport], [Puppet::Transaction::Report]
-      )
-      expect(content.host).to eq(certname)
-    end
-
-    it 'allows mode overwrite' do
-      Puppet.settings.setting(:lastrunreport).mode = '0644'
-      indirection.save(report)
-
-      if Puppet::Util::Platform.windows?
-        mode = File.stat(file).mode
-      else
-        mode = Puppet::FileSystem.stat(file).mode
-      end
-
-      expect(mode & 07777).to eq(0644)
-    end
-
-    context 'when mode is invalid' do
-      before do
-        Puppet.settings.setting(:lastrunreport).mode = '9999'
-      end
-
-      after do
-        Puppet.settings.setting(:lastrunreport).mode = '0644'
-      end
-
-      it 'raises Puppet::DevError ' do
-        expect{
-          indirection.save(report)
-        }.to raise_error(Puppet::DevError, "replace_file mode: 9999 is invalid")
-      end
-    end
-
-    context 'when repport is invalid' do
-      it 'logs error' do
-        expect(Puppet).to receive(:send_log).with(:err, /Could not save yaml ziggy: can't dump anonymous class/)
-
-        report.configuration_version = Class.new
-        indirection.save(report)
-      end
-    end
-
-    context 'when report cannot be saved' do
-      it 'raises Error' do
-        FileUtils.mkdir_p(file)
-        expect {
-          indirection.save(report)
-        }.to raise_error(Errno::EISDIR, /last_run_report.yaml/)
-      end
-    end
-  end
-end