puppet 8.4.0-x64-mingw32 → 8.5.0-x64-mingw32

data/spec/unit/resource/status_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper'
-require 'puppet/resource/status'
-
-describe Puppet::Resource::Status do
-  include PuppetSpec::Files
-
-  let(:resource) { Puppet::Type.type(:file).new(:path => make_absolute("/my/file")) }
-  let(:containment_path) { ["foo", "bar", "baz"] }
-  let(:status) { Puppet::Resource::Status.new(resource) }
-
-  before do
-    allow(resource).to receive(:pathbuilder).and_return(containment_path)
-  end
-
-  it "should compute type and title correctly" do
-    expect(status.resource_type).to eq("File")
-    expect(status.title).to eq(make_absolute("/my/file"))
-  end
-
-  [:file, :line, :evaluation_time].each do |attr|
-    it "should support #{attr}" do
-      status.send(attr.to_s + "=", "foo")
-      expect(status.send(attr)).to eq("foo")
-    end
-  end
-
-  [:skipped, :failed, :restarted, :failed_to_restart, :changed, :out_of_sync, :scheduled].each do |attr|
-    it "should support #{attr}" do
-      status.send(attr.to_s + "=", "foo")
-      expect(status.send(attr)).to eq("foo")
-    end
-
-    it "should have a boolean method for determining whether it was #{attr}" do
-      status.send(attr.to_s + "=", "foo")
-      expect(status).to send("be_#{attr}")
-    end
-  end
-
-  it "should accept a resource at initialization" do
-    expect(Puppet::Resource::Status.new(resource).resource).not_to be_nil
-  end
-
-  it "should set its source description to the resource's path" do
-    expect(resource).to receive(:path).and_return("/my/path")
-    expect(Puppet::Resource::Status.new(resource).source_description).to eq("/my/path")
-  end
-
-  it "should set its containment path" do
-  expect(Puppet::Resource::Status.new(resource).containment_path).to eq(containment_path)
-  end
-
-  [:file, :line].each do |attr|
-    it "should copy the resource's #{attr}" do
-      expect(resource).to receive(attr).and_return("foo")
-      expect(Puppet::Resource::Status.new(resource).send(attr)).to eq("foo")
-    end
-  end
-
-  it "should copy the resource's tags" do
-    resource.tag('foo', 'bar')
-    status = Puppet::Resource::Status.new(resource)
-    expect(status).to be_tagged("foo")
-    expect(status).to be_tagged("bar")
-  end
-
-  it "should always convert the resource to a string" do
-    expect(resource).to receive(:to_s).and_return("foo")
-    expect(Puppet::Resource::Status.new(resource).resource).to eq("foo")
-  end
-
-  it 'should set the provider_used correctly' do
-    expected_name = if Puppet::Util::Platform.windows?
-                      'windows'
-                    else
-                      'posix'
-                    end
-    expect(status.provider_used).to eq(expected_name)
-  end
-
-  it "should support tags" do
-    expect(Puppet::Resource::Status.ancestors).to include(Puppet::Util::Tagging)
-  end
-
-  it "should create a timestamp at its creation time" do
-    expect(status.time).to be_instance_of(Time)
-  end
-
-  it "should support adding events" do
-    event = Puppet::Transaction::Event.new(:name => :foobar)
-    status.add_event(event)
-    expect(status.events).to eq([event])
-  end
-
-  it "should use '<<' to add events" do
-    event = Puppet::Transaction::Event.new(:name => :foobar)
-    expect(status << event).to equal(status)
-    expect(status.events).to eq([event])
-  end
-
-  it "fails and records a failure event with a given message" do
-    status.fail_with_event("foo fail")
-    event = status.events[0]
-
-    expect(event.message).to eq("foo fail")
-    expect(event.status).to eq("failure")
-    expect(event.name).to eq(:resource_error)
-    expect(status.failed?).to be_truthy
-  end
-
-  it "fails and records a failure event with a given exception" do
-    error = StandardError.new("the message")
-    expect(resource).to receive(:log_exception).with(error, "Could not evaluate: the message")
-    expect(status).to receive(:fail_with_event).with("the message")
-
-    status.failed_because(error)
-  end
-
-  it "should count the number of successful events and set changed" do
-    3.times{ status << Puppet::Transaction::Event.new(:status => 'success') }
-    expect(status.change_count).to eq(3)
-
-    expect(status.changed).to eq(true)
-    expect(status.out_of_sync).to eq(true)
-  end
-
-  it "should not start with any changes" do
-    expect(status.change_count).to eq(0)
-
-    expect(status.changed).to eq(false)
-    expect(status.out_of_sync).to eq(false)
-  end
-
-  it "should not treat failure, audit, or noop events as changed" do
-    ['failure', 'audit', 'noop'].each do |s| status << Puppet::Transaction::Event.new(:status => s) end
-    expect(status.change_count).to eq(0)
-    expect(status.changed).to eq(false)
-  end
-
-  it "should not treat audit events as out of sync" do
-    status << Puppet::Transaction::Event.new(:status => 'audit')
-    expect(status.out_of_sync_count).to eq(0)
-    expect(status.out_of_sync).to eq(false)
-  end
-
-  ['failure', 'noop', 'success'].each do |event_status|
-    it "should treat #{event_status} events as out of sync" do
-      3.times do status << Puppet::Transaction::Event.new(:status => event_status) end
-      expect(status.out_of_sync_count).to eq(3)
-      expect(status.out_of_sync).to eq(true)
-    end
-  end
-
-  context 'when serializing' do
-    let(:status) do
-      s = Puppet::Resource::Status.new(resource)
-      s.file = '/foo.rb'
-      s.line = 27
-      s.evaluation_time = 2.7
-      s.tags = %w{one two}
-      s << Puppet::Transaction::Event.new(:name => :mode_changed, :status => 'audit')
-      s.failed = false
-      s.changed = true
-      s.out_of_sync = true
-      s.skipped = false
-      s.provider_used = 'provider_used_class_name'
-      s.failed_to_restart = false
-      s
-    end
-
-    it 'should round trip through json' do
-      expect(status.containment_path).to eq(containment_path)
-
-      tripped = Puppet::Resource::Status.from_data_hash(JSON.parse(status.to_json))
-
-      expect(tripped.title).to eq(status.title)
-      expect(tripped.containment_path).to eq(status.containment_path)
-      expect(tripped.file).to eq(status.file)
-      expect(tripped.line).to eq(status.line)
-      expect(tripped.resource).to eq(status.resource)
-      expect(tripped.resource_type).to eq(status.resource_type)
-      expect(tripped.provider_used).to eq(status.provider_used)
-      expect(tripped.evaluation_time).to eq(status.evaluation_time)
-      expect(tripped.tags).to eq(status.tags)
-      expect(tripped.time).to eq(status.time)
-      expect(tripped.failed).to eq(status.failed)
-      expect(tripped.changed).to eq(status.changed)
-      expect(tripped.out_of_sync).to eq(status.out_of_sync)
-      expect(tripped.skipped).to eq(status.skipped)
-      expect(tripped.failed_to_restart).to eq(status.failed_to_restart)
-
-      expect(tripped.change_count).to eq(status.change_count)
-      expect(tripped.out_of_sync_count).to eq(status.out_of_sync_count)
-      expect(events_as_hashes(tripped)).to eq(events_as_hashes(status))
-    end
-
-    it 'to_data_hash returns value that is instance of to Data' do
-      expect(Puppet::Pops::Types::TypeFactory.data.instance?(status.to_data_hash)).to be_truthy
-    end
-
-    def events_as_hashes(report)
-      report.events.collect do |e|
-        {
-          :audited => e.audited,
-          :property => e.property,
-          :previous_value => e.previous_value,
-          :desired_value => e.desired_value,
-          :historical_value => e.historical_value,
-          :message => e.message,
-          :name => e.name,
-          :status => e.status,
-          :time => e.time,
-        }
-      end
-    end
-  end
-end

data/spec/unit/resource/type_collection_spec.rb

@@ -1,332 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/resource/type_collection'
-require 'puppet/resource/type'
-
-describe Puppet::Resource::TypeCollection do
-  include PuppetSpec::Files
-
-  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
-
-  before do
-    @instance = Puppet::Resource::Type.new(:hostclass, "foo")
-    @code = Puppet::Resource::TypeCollection.new(environment)
-  end
-
-  it "should consider '<<' to be an alias to 'add' but should return self" do
-    expect(@code).to receive(:add).with("foo")
-    expect(@code).to receive(:add).with("bar")
-    @code << "foo" << "bar"
-  end
-
-  it "should set itself as the code collection for added resource types" do
-    node = Puppet::Resource::Type.new(:node, "foo")
-
-    @code.add(node)
-    expect(@code.node("foo")).to equal(node)
-
-    expect(node.resource_type_collection).to equal(@code)
-  end
-
-  it "should store node resource types as nodes" do
-    node = Puppet::Resource::Type.new(:node, "foo")
-
-    @code.add(node)
-    expect(@code.node("foo")).to equal(node)
-  end
-
-  it "should fail if a duplicate node is added" do
-    @code.add(Puppet::Resource::Type.new(:node, "foo"))
-
-    expect do
-      @code.add(Puppet::Resource::Type.new(:node, "foo"))
-    end.to raise_error(Puppet::ParseError, /cannot redefine/)
-  end
-
-  it "should fail if a hostclass duplicates a node" do
-    @code.add(Puppet::Resource::Type.new(:node, "foo"))
-
-    expect do
-      @code.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-    end.to raise_error(Puppet::ParseError, /Node 'foo' is already defined; cannot be redefined as a class/)
-  end
-
-  it "should store hostclasses as hostclasses" do
-    klass = Puppet::Resource::Type.new(:hostclass, "foo")
-
-    @code.add(klass)
-    expect(@code.hostclass("foo")).to equal(klass)
-  end
-
-  it "errors if an attempt is made to merge hostclasses of the same name" do
-    klass1 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "first")
-    klass2 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "second")
-
-    expect {
-      @code.add(klass1)
-      @code.add(klass2)
-    }.to raise_error(/.*is already defined; cannot redefine/)
-  end
-
-  it "should fail if a node duplicates a hostclass" do
-    @code.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-
-    expect do
-      @code.add(Puppet::Resource::Type.new(:node, "foo"))
-    end.to raise_error(Puppet::ParseError, /Class 'foo' is already defined; cannot be redefined as a node/)
-  end
-
-  it "should store definitions as definitions" do
-    define = Puppet::Resource::Type.new(:definition, "foo")
-
-    @code.add(define)
-    expect(@code.definition("foo")).to equal(define)
-  end
-
-  it "should fail if a duplicate definition is added" do
-    @code.add(Puppet::Resource::Type.new(:definition, "foo"))
-
-    expect do
-      @code.add(Puppet::Resource::Type.new(:definition, "foo"))
-    end.to raise_error(Puppet::ParseError, /cannot be redefined/)
-  end
-
-  it "should remove all nodes, classes and definitions when cleared" do
-    loader = Puppet::Resource::TypeCollection.new(environment)
-    loader.add Puppet::Resource::Type.new(:hostclass, "class")
-    loader.add Puppet::Resource::Type.new(:definition, "define")
-    loader.add Puppet::Resource::Type.new(:node, "node")
-
-    loader.clear
-    expect(loader.hostclass("class")).to be_nil
-    expect(loader.definition("define")).to be_nil
-    expect(loader.node("node")).to be_nil
-  end
-
-  describe "when looking up names" do
-    before do
-      @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
-    end
-
-    it "should not attempt to import anything when the type is already defined" do
-      @code.add @type
-      expect(@code.loader).not_to receive(:import)
-      expect(@code.find_hostclass("ns::klass")).to equal(@type)
-    end
-
-    describe "that need to be loaded" do
-      it "should use the loader to load the files" do
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "klass")
-        @code.find_hostclass("klass")
-      end
-
-      it "should use the loader to load the files" do
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass")
-        @code.find_hostclass("ns::klass")
-      end
-
-      it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass")
-        @code.find_hostclass("ns::klass")
-      end
-
-      it "should use the class returned by the loader" do
-        expect(@code.loader).to receive(:try_load_fqname).and_return(:klass)
-        expect(@code).to receive(:hostclass).with("ns::klass").and_return(false)
-        expect(@code.find_hostclass("ns::klass")).to eq(:klass)
-      end
-
-      it "should return nil if the name isn't found" do
-        allow(@code.loader).to receive(:try_load_fqname).and_return(nil)
-        expect(@code.find_hostclass("Ns::Klass")).to be_nil
-      end
-
-      it "already-loaded names at broader scopes should not shadow autoloaded names" do
-        @code.add Puppet::Resource::Type.new(:hostclass, "bar")
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "foo::bar").and_return(:foobar)
-        expect(@code.find_hostclass("foo::bar")).to eq(:foobar)
-      end
-
-      context 'when debugging' do
-        # This test requires that debugging is on, it will otherwise not make a call to debug,
-        # which is the easiest way to detect that that a certain path has been taken.
-        before(:each) do
-          Puppet.debug = true
-        end
-
-        after (:each) do
-          Puppet.debug = false
-        end
-
-        it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
-          Puppet[:ignoremissingtypes] = true
-          expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass").and_return(nil)
-          expect(@code.find_hostclass("ns::klass")).to be_nil
-          expect(Puppet).to receive(:debug).at_least(:once).with(/Not attempting to load hostclass/)
-          expect(@code.find_hostclass("ns::klass")).to be_nil
-        end
-      end
-    end
-  end
-
-  KINDS = %w{hostclass node definition}
-  KINDS.each do |data|
-    describe "behavior of add for #{data}" do
-
-      it "should return the added #{data}" do
-        loader = Puppet::Resource::TypeCollection.new(environment)
-        instance = Puppet::Resource::Type.new(data, "foo")
-
-        expect(loader.add(instance)).to equal(instance)
-      end
-
-      it "should retrieve #{data} insensitive to case" do
-        loader = Puppet::Resource::TypeCollection.new(environment)
-        instance = Puppet::Resource::Type.new(data, "Bar")
-
-        loader.add instance
-
-        expect(loader.send(data, "bAr")).to equal(instance)
-      end
-
-      it "should return nil when asked for a #{data} that has not been added" do
-        expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
-      end
-    end
-  end
-
-  describe "when finding a qualified instance" do
-    it "should return any found instance if the instance name is fully qualified" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
-      loader.add instance
-      expect(loader.find_hostclass("::foo::bar")).to equal(instance)
-    end
-
-    it "should return nil if the instance name is fully qualified and no such instance exists" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      expect(loader.find_hostclass("::foo::bar")).to be_nil
-    end
-
-    it "should be able to find classes in the base namespace" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo")
-      loader.add instance
-      expect(loader.find_hostclass("foo")).to equal(instance)
-    end
-
-    it "should return the unqualified object if it exists in a provided namespace" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
-      loader.add instance
-      expect(loader.find_hostclass("foo::bar")).to equal(instance)
-    end
-
-    it "should return nil if the object cannot be found" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      expect(loader.find_hostclass("foo::bar::eh")).to be_nil
-    end
-
-    describe "when topscope has a class that has the same name as a local class" do
-      before do
-        @loader = Puppet::Resource::TypeCollection.new(environment)
-        [ "foo::bar", "bar" ].each do |name|
-          @loader.add Puppet::Resource::Type.new(:hostclass, name)
-        end
-      end
-
-      it "looks up the given name, no more, no less" do
-        expect(@loader.find_hostclass("bar").name).to eq('bar')
-        expect(@loader.find_hostclass("::bar").name).to eq('bar')
-        expect(@loader.find_hostclass("foo::bar").name).to eq('foo::bar')
-        expect(@loader.find_hostclass("::foo::bar").name).to eq('foo::bar')
-      end
-    end
-
-    it "should not look in the local scope for classes when the name is qualified" do
-        @loader = Puppet::Resource::TypeCollection.new(environment)
-        @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
-
-        expect(@loader.find_hostclass("::bar")).to eq(nil)
-    end
-  end
-
-  it "should be able to find nodes" do
-    node = Puppet::Resource::Type.new(:node, "bar")
-    loader = Puppet::Resource::TypeCollection.new(environment)
-    loader.add(node)
-    expect(loader.find_node("bar")).to eq(node)
-  end
-
-  it "should indicate whether any nodes are defined" do
-    loader = Puppet::Resource::TypeCollection.new(environment)
-    loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
-    expect(loader).to be_nodes
-  end
-
-  it "should indicate whether no nodes are defined" do
-    expect(Puppet::Resource::TypeCollection.new(environment)).not_to be_nodes
-  end
-
-  describe "when finding nodes" do
-    before :each do
-      @loader = Puppet::Resource::TypeCollection.new(environment)
-    end
-
-    it "should return any node whose name exactly matches the provided node name" do
-      node = Puppet::Resource::Type.new(:node, "foo")
-      @loader << node
-
-      expect(@loader.node("foo")).to equal(node)
-    end
-
-    it "should return the first regex node whose regex matches the provided node name" do
-      node1 = Puppet::Resource::Type.new(:node, /\w/)
-      node2 = Puppet::Resource::Type.new(:node, /\d/)
-      @loader << node1 << node2
-
-      expect(@loader.node("foo10")).to equal(node1)
-    end
-
-    it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
-      node1 = Puppet::Resource::Type.new(:node, /\w/)
-      node2 = Puppet::Resource::Type.new(:node, "foo")
-      @loader << node1 << node2
-
-      expect(@loader.node("foo")).to equal(node2)
-    end
-  end
-
-  describe "when determining the configuration version" do
-    before do
-      @code = Puppet::Resource::TypeCollection.new(environment)
-    end
-
-    it "should default to the current time" do
-      time = Time.now
-
-      allow(Time).to receive(:now).and_return(time)
-      expect(@code.version).to eq(time.to_i)
-    end
-
-    context "when config_version script is specified" do
-      let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
-
-      it "should use the output of the environment's config_version setting if one is provided" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/my/foo"])
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("output\n", 0))
-        expect(@code.version).to be_instance_of(String)
-        expect(@code.version).to eq("output")
-      end
-
-      it "should raise a puppet parser error if executing config_version fails" do
-        expect(Puppet::Util::Execution).to receive(:execute).and_raise(Puppet::ExecutionFailure.new("msg"))
-
-        expect { @code.version }.to raise_error(Puppet::ParseError)
-      end
-    end
-  end
-end