RubyGems - puppet - Versions diffs - 7.27.0 → 7.29.0 - Mend

puppet 7.27.0 → 7.29.0

Files changed (1286) hide show

data/spec/unit/indirector/terminus_spec.rb DELETED Viewed

@@ -1,264 +0,0 @@
-require 'spec_helper'
-require 'puppet/defaults'
-require 'puppet/indirector'
-require 'puppet/indirector/memory'
-describe Puppet::Indirector::Terminus do
-  before :all do
-    class Puppet::AbstractConcept
-      extend Puppet::Indirector
-      indirects :abstract_concept
-      attr_accessor :name
-      def initialize(name = "name")
-        @name = name
-      end
-    end
-    class Puppet::AbstractConcept::Freedom < Puppet::Indirector::Code
-    end
-  end
-  after :all do
-    # Remove the class, unlinking it from the rest of the system.
-    Puppet.send(:remove_const, :AbstractConcept) if Puppet.const_defined?(:AbstractConcept)
-  end
-  let :terminus_class do Puppet::AbstractConcept::Freedom end
-  let :terminus       do terminus_class.new end
-  let :indirection    do Puppet::AbstractConcept.indirection end
-  let :model          do Puppet::AbstractConcept end
-  it "should provide a method for setting terminus class documentation" do
-    expect(terminus_class).to respond_to(:desc)
-  end
-  it "should support a class-level name attribute" do
-    expect(terminus_class).to respond_to(:name)
-  end
-  it "should support a class-level indirection attribute" do
-    expect(terminus_class).to respond_to(:indirection)
-  end
-  it "should support a class-level terminus-type attribute" do
-    expect(terminus_class).to respond_to(:terminus_type)
-  end
-  it "should support a class-level model attribute" do
-    expect(terminus_class).to respond_to(:model)
-  end
-  it "should accept indirection instances as its indirection" do
-    # The test is that this shouldn't raise, and should preserve the object
-    # instance exactly, hence "equal", not just "==".
-    terminus_class.indirection = indirection
-    expect(terminus_class.indirection).to equal indirection
-  end
-  it "should look up indirection instances when only a name has been provided" do
-    terminus_class.indirection = :abstract_concept
-    expect(terminus_class.indirection).to equal indirection
-  end
-  it "should fail when provided a name that does not resolve to an indirection" do
-    expect {
-      terminus_class.indirection = :exploding_whales
-    }.to raise_error(ArgumentError, /Could not find indirection instance/)
-    # We should still have the default indirection.
-    expect(terminus_class.indirection).to equal indirection
-  end
-  describe "when a terminus instance" do
-    it "should return the class's name as its name" do
-      expect(terminus.name).to eq(:freedom)
-    end
-    it "should return the class's indirection as its indirection" do
-      expect(terminus.indirection).to equal indirection
-    end
-    it "should set the instances's type to the abstract terminus type's name" do
-      expect(terminus.terminus_type).to eq(:code)
-    end
-    it "should set the instances's model to the indirection's model" do
-      expect(terminus.model).to equal indirection.model
-    end
-  end
-  describe "when managing terminus classes" do
-    it "should provide a method for registering terminus classes" do
-      expect(Puppet::Indirector::Terminus).to respond_to(:register_terminus_class)
-    end
-    it "should provide a method for returning terminus classes by name and type" do
-      terminus = double('terminus_type', :name => :abstract, :indirection_name => :whatever)
-      Puppet::Indirector::Terminus.register_terminus_class(terminus)
-      expect(Puppet::Indirector::Terminus.terminus_class(:whatever, :abstract)).to equal(terminus)
-    end
-    it "should set up autoloading for any terminus class types requested" do
-      expect(Puppet::Indirector::Terminus).to receive(:instance_load).with(:test2, "puppet/indirector/test2")
-      Puppet::Indirector::Terminus.terminus_class(:test2, :whatever)
-    end
-    it "should load terminus classes that are not found" do
-      # Set up instance loading; it would normally happen automatically
-      Puppet::Indirector::Terminus.instance_load :test1, "puppet/indirector/test1"
-      expect(Puppet::Indirector::Terminus.instance_loader(:test1)).to receive(:load).with(:yay, anything)
-      Puppet::Indirector::Terminus.terminus_class(:test1, :yay)
-    end
-    it "should fail when no indirection can be found" do
-      expect(Puppet::Indirector::Indirection).to receive(:instance).with(:abstract_concept).and_return(nil)
-      expect {
-        class Puppet::AbstractConcept::Physics < Puppet::Indirector::Code
-        end
-      }.to raise_error(ArgumentError, /Could not find indirection instance/)
-    end
-    it "should register the terminus class with the terminus base class" do
-      expect(Puppet::Indirector::Terminus).to receive(:register_terminus_class) do |type|
-        expect(type.indirection_name).to eq(:abstract_concept)
-        expect(type.name).to eq(:intellect)
-      end
-      begin
-        class Puppet::AbstractConcept::Intellect < Puppet::Indirector::Code
-        end
-      ensure
-        Puppet::AbstractConcept.send(:remove_const, :Intellect) rescue nil
-      end
-    end
-  end
-  describe "when parsing class constants for indirection and terminus names" do
-    before :each do
-      allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
-    end
-    let :subclass do
-      subclass = double('subclass')
-      allow(subclass).to receive(:to_s).and_return("TestInd::OneTwo")
-      allow(subclass).to receive(:mark_as_abstract_terminus)
-      subclass
-    end
-    it "should fail when anonymous classes are used" do
-      expect {
-        Puppet::Indirector::Terminus.inherited(Class.new)
-      }.to raise_error(Puppet::DevError, /Terminus subclasses must have associated constants/)
-    end
-    it "should use the last term in the constant for the terminus class name" do
-      expect(subclass).to receive(:name=).with(:one_two)
-      allow(subclass).to receive(:indirection=)
-      Puppet::Indirector::Terminus.inherited(subclass)
-    end
-    it "should convert the terminus name to a downcased symbol" do
-      expect(subclass).to receive(:name=).with(:one_two)
-      allow(subclass).to receive(:indirection=)
-      Puppet::Indirector::Terminus.inherited(subclass)
-    end
-    it "should use the second to last term in the constant for the indirection name" do
-      expect(subclass).to receive(:indirection=).with(:test_ind)
-      allow(subclass).to receive(:name=)
-      allow(subclass).to receive(:terminus_type=)
-      Puppet::Indirector::Memory.inherited(subclass)
-    end
-    it "should convert the indirection name to a downcased symbol" do
-      expect(subclass).to receive(:indirection=).with(:test_ind)
-      allow(subclass).to receive(:name=)
-      allow(subclass).to receive(:terminus_type=)
-      Puppet::Indirector::Memory.inherited(subclass)
-    end
-    it "should convert camel case to lower case with underscores as word separators" do
-      expect(subclass).to receive(:name=).with(:one_two)
-      allow(subclass).to receive(:indirection=)
-      Puppet::Indirector::Terminus.inherited(subclass)
-    end
-  end
-  describe "when creating terminus class types" do
-    before :each do
-      allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
-      class Puppet::Indirector::Terminus::TestTerminusType < Puppet::Indirector::Terminus
-      end
-    end
-    after :each do
-      Puppet::Indirector::Terminus.send(:remove_const, :TestTerminusType)
-    end
-    let :subclass do
-      Puppet::Indirector::Terminus::TestTerminusType
-    end
-    it "should set the name of the abstract subclass to be its class constant" do
-      expect(subclass.name).to eq(:test_terminus_type)
-    end
-    it "should mark abstract terminus types as such" do
-      expect(subclass).to be_abstract_terminus
-    end
-    it "should not allow instances of abstract subclasses to be created" do
-      expect { subclass.new }.to raise_error(Puppet::DevError)
-    end
-  end
-  describe "when listing terminus classes" do
-    it "should list the terminus files available to load" do
-      allow_any_instance_of(Puppet::Util::Autoload).to receive(:files_to_load).and_return(["/foo/bar/baz", "/max/runs/marathon"])
-      expect(Puppet::Indirector::Terminus.terminus_classes('my_stuff')).to eq([:baz, :marathon])
-    end
-  end
-  describe "when validating a request" do
-    let :request do
-      Puppet::Indirector::Request.new(indirection.name, :find, "the_key", instance)
-    end
-    describe "`instance.name` does not match the key in the request" do
-      let(:instance) { model.new("wrong_key") }
-      it "raises an error " do
-        expect {
-          terminus.validate(request)
-        }.to raise_error(
-          Puppet::Indirector::ValidationError,
-          /Instance name .* does not match requested key/
-        )
-      end
-    end
-    describe "`instance` is not an instance of the model class" do
-      let(:instance) { double("instance") }
-      it "raises an error" do
-        expect {
-          terminus.validate(request)
-        }.to raise_error(
-          Puppet::Indirector::ValidationError,
-          /Invalid instance type/
-        )
-      end
-    end
-    describe "the instance key and class match the request key and model class" do
-      let(:instance) { model.new("the_key") }
-      it "passes" do
-        terminus.validate(request)
-      end
-    end
-  end
-end

data/spec/unit/indirector/yaml_spec.rb DELETED Viewed

@@ -1,188 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/yaml'
-describe Puppet::Indirector::Yaml do
-  include PuppetSpec::Files
-  before(:all) do
-    class Puppet::YamlTestModel
-      extend Puppet::Indirector
-      indirects :yaml_test_model
-      attr_reader :name
-      def initialize(name)
-        @name = name
-      end
-    end
-    class Puppet::YamlTestModel::Yaml < Puppet::Indirector::Yaml; end
-    Puppet::YamlTestModel.indirection.terminus_class = :yaml
-  end
-  after(:all) do
-    Puppet::YamlTestModel.indirection.delete
-    Puppet.send(:remove_const, :YamlTestModel)
-  end
-  let(:model) { Puppet::YamlTestModel }
-  let(:subject) { model.new(:me) }
-  let(:indirection) { model.indirection }
-  let(:terminus) { indirection.terminus(:yaml) }
-  let(:dir) { tmpdir("yaml_indirector") }
-  let(:indirection_dir) { File.join(dir, indirection.name.to_s) }
-  let(:serverdir) { File.expand_path("/server/yaml/dir") }
-  let(:clientdir) { File.expand_path("/client/yaml/dir") }
-  before :each do
-    Puppet[:clientyamldir] = dir
-    allow(Puppet.run_mode).to receive(:server?).and_return(false)
-  end
-  describe "when choosing file location" do
-    it "should use the server_datadir if the run_mode is server" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      Puppet[:yamldir] = serverdir
-      expect(terminus.path(:me)).to match(/^#{serverdir}/)
-    end
-    it "should use the client yamldir if the run_mode is not server" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(false)
-      Puppet[:clientyamldir] = clientdir
-      expect(terminus.path(:me)).to match(/^#{clientdir}/)
-    end
-    it "should use the extension if one is specified" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      Puppet[:yamldir] = serverdir
-      expect(terminus.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
-    end
-    it "should assume an extension of .yaml if none is specified" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      Puppet[:yamldir] = serverdir
-      expect(terminus.path(:me)).to match(%r{\.yaml$})
-    end
-    it "should store all files in a single file root set in the Puppet defaults" do
-      expect(terminus.path(:me)).to match(%r{^#{dir}})
-    end
-    it "should use the terminus name for choosing the subdirectory" do
-      expect(terminus.path(:me)).to match(%r{^#{dir}/yaml_test_model})
-    end
-    it "should use the object's name to determine the file name" do
-      expect(terminus.path(:me)).to match(%r{me.yaml$})
-    end
-    ['../foo', '..\\foo', './../foo', '.\\..\\foo',
-     '/foo', '//foo', '\\foo', '\\\\goo',
-     "test\0/../bar", "test\0\\..\\bar",
-     "..\\/bar", "/tmp/bar", "/tmp\\bar", "tmp\\bar",
-     " / bar", " /../ bar", " \\..\\ bar",
-     "c:\\foo", "c:/foo", "\\\\?\\UNC\\bar", "\\\\foo\\bar",
-     "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
-     "//?/c:/foo",
-    ].each do |input|
-      it "should resist directory traversal attacks (#{input.inspect})" do
-        expect { terminus.path(input) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-  describe "when storing objects as YAML" do
-    it "should only store objects that respond to :name" do
-      request = indirection.request(:save, "testing", Object.new)
-      expect { terminus.save(request) }.to raise_error(ArgumentError)
-    end
-  end
-  describe "when retrieving YAML" do
-    it "should read YAML in from disk and convert it to Ruby objects" do
-      terminus.save(indirection.request(:save, "testing", subject))
-      yaml = terminus.find(indirection.request(:find, "testing", nil))
-      expect(yaml.name).to eq(:me)
-    end
-    it "should fail coherently when the stored YAML is invalid" do
-      terminus.save(indirection.request(:save, "testing", subject))
-      # overwrite file
-      File.open(terminus.path('testing'), "w") do |file|
-        file.puts "{ invalid"
-      end
-      expect {
-        terminus.find(indirection.request(:find, "testing", nil))
-      }.to raise_error(Puppet::Error, /Could not parse YAML data/)
-    end
-  end
-  describe "when searching" do
-    before :each do
-      Puppet[:clientyamldir] = dir
-    end
-    def dir_containing_instances(instances)
-      Dir.mkdir(indirection_dir)
-      instances.each do |hash|
-        File.open(File.join(indirection_dir, "#{hash['name']}.yaml"), 'wb') do |f|
-          f.write(YAML.dump(hash))
-        end
-      end
-    end
-    it "should return an array of fact instances with one instance for each file when globbing *" do
-      one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
-      two = { 'name' => 'two', 'values' => { 'foo' => 'baz' } }
-      dir_containing_instances([one, two])
-      request = indirection.request(:search, "*", nil)
-      expect(terminus.search(request)).to contain_exactly(one, two)
-    end
-    it "should return an array containing a single instance of fact when globbing 'one*'" do
-      one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
-      two = { 'name' => 'two', 'values' => { 'foo' => 'baz' } }
-      dir_containing_instances([one, two])
-      request = indirection.request(:search, "one*", nil)
-      expect(terminus.search(request)).to eq([one])
-    end
-    it "should return an empty array when the glob doesn't match anything" do
-      one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
-      dir_containing_instances([one])
-      request = indirection.request(:search, "f*ilglobcanfail*", nil)
-      expect(terminus.search(request)).to eq([])
-    end
-    describe "when destroying" do
-      let(:path) { File.join(indirection_dir, "one.yaml") }
-      before :each do
-        Puppet[:clientyamldir] = dir
-        one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
-        dir_containing_instances([one])
-      end
-      it "should unlink the right yaml file if it exists" do
-        request = indirection.request(:destroy, "one", nil)
-        terminus.destroy(request)
-        expect(Puppet::FileSystem).to_not exist(path)
-      end
-      it "should not unlink the yaml file if it does not exists" do
-        request = indirection.request(:destroy, "doesntexist", nil)
-        terminus.destroy(request)
-        expect(Puppet::FileSystem).to exist(path)
-      end
-    end
-  end
-end

data/spec/unit/indirector_spec.rb DELETED Viewed

@@ -1,148 +0,0 @@
-require 'spec_helper'
-require 'puppet/defaults'
-require 'puppet/indirector'
-describe Puppet::Indirector, "when configuring routes" do
-  before :each do
-    Puppet::Node.indirection.reset_terminus_class
-    Puppet::Node.indirection.cache_class = nil
-  end
-  after :each do
-    Puppet::Node.indirection.reset_terminus_class
-    Puppet::Node.indirection.cache_class = nil
-  end
-  it "should configure routes as requested" do
-    routes = {
-      "node" => {
-        "terminus" => "exec",
-        "cache"    => "plain"
-      }
-    }
-    Puppet::Indirector.configure_routes(routes)
-    expect(Puppet::Node.indirection.terminus_class).to eq("exec")
-    expect(Puppet::Node.indirection.cache_class).to    eq("plain")
-  end
-  it "should fail when given an invalid indirection" do
-    routes = {
-      "fake_indirection" => {
-        "terminus" => "exec",
-        "cache"    => "plain"
-      }
-    }
-    expect { Puppet::Indirector.configure_routes(routes) }.to raise_error(/fake_indirection does not exist/)
-  end
-  it "should fail when given an invalid terminus" do
-    routes = {
-      "node" => {
-        "terminus" => "fake_terminus",
-        "cache"    => "plain"
-      }
-    }
-    expect { Puppet::Indirector.configure_routes(routes) }.to raise_error(/Could not find terminus fake_terminus/)
-  end
-  it "should fail when given an invalid cache" do
-    routes = {
-      "node" => {
-        "terminus" => "exec",
-        "cache"    => "fake_cache"
-      }
-    }
-    expect { Puppet::Indirector.configure_routes(routes) }.to raise_error(/Could not find terminus fake_cache/)
-  end
-end
-describe Puppet::Indirector, " when available to a model" do
-  before do
-    @thingie = Class.new do
-      extend Puppet::Indirector
-    end
-  end
-  it "should provide a way for the model to register an indirection under a name" do
-    expect(@thingie).to respond_to(:indirects)
-  end
-end
-describe Puppet::Indirector, "when registering an indirection" do
-  before do
-    @thingie = Class.new do
-      extend Puppet::Indirector
-      # override Class#name, since we're not naming this ephemeral class
-      def self.name
-        'Thingie'
-      end
-      attr_reader :name
-      def initialize(name)
-        @name = name
-      end
-    end
-  end
-  it "should require a name when registering a model" do
-    expect {@thingie.send(:indirects) }.to raise_error(ArgumentError)
-  end
-  it "should create an indirection instance to manage each indirecting model" do
-    @indirection = @thingie.indirects(:test)
-    expect(@indirection).to be_instance_of(Puppet::Indirector::Indirection)
-  end
-  it "should not allow a model to register under multiple names" do
-    # Keep track of the indirection instance so we can delete it on cleanup
-    @indirection = @thingie.indirects :first
-    expect { @thingie.indirects :second }.to raise_error(ArgumentError)
-  end
-  it "should make the indirection available via an accessor" do
-    @indirection = @thingie.indirects :first
-    expect(@thingie.indirection).to equal(@indirection)
-  end
-  it "should pass any provided options to the indirection during initialization" do
-    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:doc => 'some docs', :indirected_class => 'Thingie'})
-    @indirection = @thingie.indirects :first, :doc => 'some docs'
-  end
-  it "should extend the class to handle serialization" do
-    @indirection = @thingie.indirects :first
-    expect(@thingie).to respond_to(:convert_from)
-  end
-  after do
-    @indirection.delete if @indirection
-  end
-end
-describe Puppet::Indirector, "when redirecting a model" do
-  before do
-    @thingie = Class.new do
-      extend Puppet::Indirector
-      attr_reader :name
-      def initialize(name)
-        @name = name
-      end
-    end
-    @indirection = @thingie.send(:indirects, :test)
-  end
-  it "should include the Envelope module in the model" do
-    expect(@thingie.ancestors).to be_include(Puppet::Indirector::Envelope)
-  end
-  after do
-    @indirection.delete
-  end
-end