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

data/spec/unit/module_tool_spec.rb

@@ -1,304 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-require 'puppet/module_tool'
-
-describe Puppet::ModuleTool do
-  describe '.is_module_root?' do
-    it 'should return true if directory has a metadata.json file' do
-      expect(FileTest).to receive(:file?).with(have_attributes(to_s: '/a/b/c/metadata.json')).and_return(true)
-
-      expect(subject.is_module_root?(Pathname.new('/a/b/c'))).to be_truthy
-    end
-
-    it 'should return false if directory does not have a metadata.json file' do
-      expect(FileTest).to receive(:file?).with(have_attributes(to_s: '/a/b/c/metadata.json')).and_return(false)
-
-      expect(subject.is_module_root?(Pathname.new('/a/b/c'))).to be_falsey
-    end
-  end
-
-  describe '.find_module_root' do
-    let(:sample_path) { Pathname.new('/a/b/c').expand_path }
-
-    it 'should return the first path as a pathname when it contains a module file' do
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(sample_path).
-        and_return(true)
-
-      expect(subject.find_module_root(sample_path)).to eq(sample_path)
-    end
-
-    it 'should return a parent path as a pathname when it contains a module file' do
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(have_attributes(to_s: File.expand_path('/a/b/c'))).and_return(false)
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(have_attributes(to_s: File.expand_path('/a/b'))).and_return(true)
-
-      expect(subject.find_module_root(sample_path)).to eq(Pathname.new('/a/b').expand_path)
-    end
-
-    it 'should return nil when no module root can be found' do
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).at_least(:once).and_return(false)
-      expect(subject.find_module_root(sample_path)).to be_nil
-    end
-  end
-
-  describe '.format_tree' do
-    it 'should return an empty tree when given an empty list' do
-      expect(subject.format_tree([])).to eq('')
-    end
-
-    it 'should return a shallow when given a list without dependencies' do
-      list = [ { :text => 'first' }, { :text => 'second' }, { :text => 'third' } ]
-      expect(subject.format_tree(list)).to eq <<-TREE
-├── first
-├── second
-└── third
-TREE
-    end
-
-    it 'should return a deeply nested tree when given a list with deep dependencies' do
-      list = [
-        {
-          :text => 'first',
-          :dependencies => [
-            {
-              :text => 'second',
-              :dependencies => [
-                { :text => 'third' }
-              ]
-            }
-          ]
-        },
-      ]
-      expect(subject.format_tree(list)).to eq <<-TREE
-└─┬ first
-  └─┬ second
-    └── third
-TREE
-    end
-
-    it 'should show connectors when deep dependencies are not on the last node of the top level' do
-      list = [
-        {
-          :text => 'first',
-          :dependencies => [
-            {
-              :text => 'second',
-              :dependencies => [
-                { :text => 'third' }
-              ]
-            }
-          ]
-        },
-        { :text => 'fourth' }
-      ]
-      expect(subject.format_tree(list)).to eq <<-TREE
-├─┬ first
-│ └─┬ second
-│   └── third
-└── fourth
-TREE
-    end
-
-    it 'should show connectors when deep dependencies are not on the last node of any level' do
-      list = [
-        {
-          :text => 'first',
-          :dependencies => [
-            {
-              :text => 'second',
-              :dependencies => [
-                { :text => 'third' }
-              ]
-            },
-            { :text => 'fourth' }
-          ]
-        }
-      ]
-      expect(subject.format_tree(list)).to eq <<-TREE
-└─┬ first
-  ├─┬ second
-  │ └── third
-  └── fourth
-TREE
-    end
-
-    it 'should show connectors in every case when deep dependencies are not on the last node' do
-      list = [
-        {
-          :text => 'first',
-          :dependencies => [
-            {
-              :text => 'second',
-              :dependencies => [
-                { :text => 'third' }
-              ]
-            },
-            { :text => 'fourth' }
-          ]
-        },
-        { :text => 'fifth' }
-      ]
-      expect(subject.format_tree(list)).to eq <<-TREE
-├─┬ first
-│ ├─┬ second
-│ │ └── third
-│ └── fourth
-└── fifth
-TREE
-    end
-  end
-
-  describe '.set_option_defaults' do
-    let(:options) { {} }
-    let(:modulepath) { ['/env/module/path', '/global/module/path'] }
-    let(:environment_name) { :current_environment }
-    let(:environment) { Puppet::Node::Environment.create(environment_name, modulepath) }
-
-    subject do
-      described_class.set_option_defaults(options)
-      options
-    end
-
-    around do |example|
-      envs = Puppet::Environments::Static.new(environment)
-
-      Puppet.override(:environments => envs) do
-        example.run
-      end
-    end
-
-    describe ':environment' do
-      context 'as String' do
-        let(:options) { { :environment => "#{environment_name}" } }
-
-        it 'assigns the environment with the given name to :environment_instance' do
-          expect(subject).to include :environment_instance => environment
-        end
-      end
-
-      context 'as Symbol' do
-        let(:options) { { :environment => :"#{environment_name}" } }
-
-        it 'assigns the environment with the given name to :environment_instance' do
-          expect(subject).to include :environment_instance => environment
-        end
-      end
-
-      context 'as Puppet::Node::Environment' do
-        let(:env) { Puppet::Node::Environment.create('anonymous', []) }
-        let(:options) { { :environment => env } }
-
-        it 'assigns the given environment to :environment_instance' do
-          expect(subject).to include :environment_instance => env
-        end
-      end
-    end
-
-    describe ':modulepath' do
-      let(:options) do
-        { :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR) }
-      end
-
-      let(:paths) { options[:modulepath].split(File::PATH_SEPARATOR).map { |dir| File.expand_path(dir) } }
-
-      it 'is expanded to an absolute path' do
-        expect(subject[:environment_instance].full_modulepath).to eql paths
-      end
-
-      it 'is used to compute :target_dir' do
-        expect(subject).to include :target_dir => paths.first
-      end
-
-      context 'conflicts with :environment' do
-        let(:options) do
-          { :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR), :environment => environment_name }
-        end
-
-        it 'replaces the modulepath of the :environment_instance' do
-          expect(subject[:environment_instance].full_modulepath).to eql paths
-        end
-
-        it 'is used to compute :target_dir' do
-          expect(subject).to include :target_dir => paths.first
-        end
-      end
-    end
-
-    describe ':target_dir' do
-      let(:options) do
-        { :target_dir => 'foo' }
-      end
-
-      let(:target) { File.expand_path(options[:target_dir]) }
-
-      it 'is expanded to an absolute path' do
-        expect(subject).to include :target_dir => target
-      end
-
-      it 'is prepended to the modulepath of the :environment_instance' do
-        expect(subject[:environment_instance].full_modulepath.first).to eql target
-      end
-
-      context 'conflicts with :modulepath' do
-        let(:options) do
-          { :target_dir => 'foo', :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR) }
-        end
-
-        it 'is prepended to the modulepath of the :environment_instance' do
-          expect(subject[:environment_instance].full_modulepath.first).to eql target
-        end
-
-        it 'shares the provided :modulepath via the :environment_instance' do
-          paths = %w[foo] + options[:modulepath].split(File::PATH_SEPARATOR)
-          paths.map! { |dir| File.expand_path(dir) }
-          expect(subject[:environment_instance].full_modulepath).to eql paths
-        end
-      end
-
-      context 'conflicts with :environment' do
-        let(:options) do
-          { :target_dir => 'foo', :environment => environment_name }
-        end
-
-        it 'is prepended to the modulepath of the :environment_instance' do
-          expect(subject[:environment_instance].full_modulepath.first).to eql target
-        end
-
-        it 'shares the provided :modulepath via the :environment_instance' do
-          paths = %w[foo] + environment.full_modulepath
-          paths.map! { |dir| File.expand_path(dir) }
-          expect(subject[:environment_instance].full_modulepath).to eql paths
-        end
-      end
-
-      context 'when not passed' do
-        it 'is populated with the first component of the modulepath' do
-          expect(subject).to include :target_dir => subject[:environment_instance].full_modulepath.first
-        end
-      end
-    end
-  end
-
-  describe '.parse_module_dependency' do
-    it 'parses a dependency without a version range expression' do
-      name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar')
-      expect(name).to eql('foo-bar')
-      expect(range).to eql(SemanticPuppet::VersionRange.parse('>= 0.0.0'))
-      expect(expr).to eql('>= 0.0.0')
-    end
-
-    it 'parses a dependency with a version range expression' do
-      name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => '1.2.x')
-      expect(name).to eql('foo-bar')
-      expect(range).to eql(SemanticPuppet::VersionRange.parse('1.2.x'))
-      expect(expr).to eql('1.2.x')
-    end
-
-    it 'does not raise an error on invalid version range expressions' do
-      name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => 'nope')
-      expect(name).to eql('foo-bar')
-      expect(range).to eql(SemanticPuppet::VersionRange::EMPTY_RANGE)
-      expect(expr).to eql('nope')
-    end
-  end
-end

data/spec/unit/network/authconfig_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/authconfig'
-
-describe Puppet::Network::AuthConfig do
-  it "accepts an auth provider class" do
-    Puppet::Network::AuthConfig.authprovider_class = Object
-  end
-end

data/spec/unit/network/authorization_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/authorization'
-
-describe Puppet::Network::Authorization do
-  it "accepts an auth config loader class" do
-    Puppet::Network::Authorization.authconfigloader_class = Object
-  end
-end

data/spec/unit/network/format_handler_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/network/format_handler'
-
-describe Puppet::Network::FormatHandler do
-  before(:each) do
-    @saved_formats = Puppet::Network::FormatHandler.instance_variable_get(:@formats).dup
-    Puppet::Network::FormatHandler.instance_variable_set(:@formats, {})
-  end
-
-  after(:each) do
-    Puppet::Network::FormatHandler.instance_variable_set(:@formats, @saved_formats)
-  end
-
-  describe "when creating formats" do
-    it "should instance_eval any block provided when creating a format" do
-      format = Puppet::Network::FormatHandler.create(:test_format) do
-        def asdfghjkl; end
-      end
-      expect(format).to respond_to(:asdfghjkl)
-    end
-  end
-
-  describe "when retrieving formats" do
-    let!(:format) { Puppet::Network::FormatHandler.create(:the_format, :extension => "foo", :mime => "foo/bar") }
-
-    it "should be able to retrieve a format by name" do
-      expect(Puppet::Network::FormatHandler.format(:the_format)).to equal(format)
-    end
-
-    it "should be able to retrieve a format by extension" do
-      expect(Puppet::Network::FormatHandler.format_by_extension("foo")).to equal(format)
-    end
-
-    it "should return nil if asked to return a format by an unknown extension" do
-      expect(Puppet::Network::FormatHandler.format_by_extension("yayness")).to be_nil
-    end
-
-    it "should be able to retrieve formats by name irrespective of case" do
-      expect(Puppet::Network::FormatHandler.format(:The_Format)).to equal(format)
-    end
-
-    it "should be able to retrieve a format by mime type" do
-      expect(Puppet::Network::FormatHandler.mime("foo/bar")).to equal(format)
-    end
-
-    it "should be able to retrieve a format by mime type irrespective of case" do
-      expect(Puppet::Network::FormatHandler.mime("Foo/Bar")).to equal(format)
-    end
-  end
-
-  describe "#most_suitable_formats_for" do
-    before :each do
-      Puppet::Network::FormatHandler.create(:one, :extension => "foo", :mime => "text/one")
-      Puppet::Network::FormatHandler.create(:two, :extension => "bar", :mime => "application/two")
-    end
-
-    let(:format_one) { Puppet::Network::FormatHandler.format(:one) }
-    let(:format_two) { Puppet::Network::FormatHandler.format(:two) }
-
-    def suitable_in_setup_formats(accepted)
-      Puppet::Network::FormatHandler.most_suitable_formats_for(accepted, [:one, :two])
-    end
-
-    it "finds the most preferred format when anything is acceptable" do
-      expect(Puppet::Network::FormatHandler.most_suitable_formats_for(["*/*"], [:two, :one])).to eq([format_two])
-    end
-
-    it "finds no format when none are acceptable" do
-      expect(suitable_in_setup_formats(["three"])).to eq([])
-    end
-
-    it "returns only the accepted and supported format" do
-      expect(suitable_in_setup_formats(["three", "two"])).to eq([format_two])
-    end
-
-    it "returns only accepted and supported formats, in order of accepted" do
-      expect(suitable_in_setup_formats(["three", "two", "one"])).to eq([format_two, format_one])
-    end
-
-    it "allows specifying acceptable formats by mime type" do
-      expect(suitable_in_setup_formats(["text/one"])).to eq([format_one])
-    end
-
-    it "ignores quality specifiers" do
-      expect(suitable_in_setup_formats(["two;q=0.8", "text/one;q=0.9"])).to eq([format_two, format_one])
-    end
-
-    it "allows specifying acceptable formats by canonical name" do
-      expect(suitable_in_setup_formats([:one])).to eq([format_one])
-    end
-  end
-end

data/spec/unit/network/format_spec.rb

@@ -1,205 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/network/format'
-
-# A class with all of the necessary
-# hooks.
-class FormatRenderer
-  def self.to_multiple_my_format(list)
-  end
-
-  def self.from_multiple_my_format(text)
-  end
-
-  def self.from_my_format(text)
-  end
-
-  def to_my_format
-  end
-end
-
-describe Puppet::Network::Format do
-  describe "when initializing" do
-    it "should require a name" do
-      expect { Puppet::Network::Format.new }.to raise_error(ArgumentError)
-    end
-
-    it "should be able to provide its name" do
-      expect(Puppet::Network::Format.new(:my_format).name).to eq(:my_format)
-    end
-
-    it "should always convert its name to a downcased symbol" do
-      expect(Puppet::Network::Format.new(:My_Format).name).to eq(:my_format)
-    end
-
-    it "should be able to set its downcased mime type at initialization" do
-      format = Puppet::Network::Format.new(:my_format, :mime => "Foo/Bar")
-      expect(format.mime).to eq("foo/bar")
-    end
-
-    it "should default to text plus the name of the format as the mime type" do
-      expect(Puppet::Network::Format.new(:my_format).mime).to eq("text/my_format")
-    end
-
-    it "should fail if unsupported options are provided" do
-      expect { Puppet::Network::Format.new(:my_format, :foo => "bar") }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "instances" do
-    before do
-      @format = Puppet::Network::Format.new(:my_format)
-    end
-
-    it "should support being confined" do
-      expect(@format).to respond_to(:confine)
-    end
-
-    it "should not be considered suitable if confinement conditions are not met" do
-      @format.confine :true => false
-      expect(@format).not_to be_suitable
-    end
-
-    it "should be able to determine if a class is supported" do
-      expect(@format).to respond_to(:supported?)
-    end
-
-    it "should consider a class to be supported if it has the individual and multiple methods for rendering and interning" do
-      expect(@format).to be_supported(FormatRenderer)
-    end
-
-    it "should default to its required methods being the individual and multiple methods for rendering and interning" do
-      expect(Puppet::Network::Format.new(:foo).required_methods.sort { |a,b| a.to_s <=> b.to_s }).to eq([:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].sort { |a,b| a.to_s <=> b.to_s })
-    end
-
-    it "should consider a class supported if the provided class has all required methods present" do
-      format = Puppet::Network::Format.new(:foo)
-      [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
-        expect(format).to receive(:required_method_present?).with(method, String, anything).and_return(true)
-      end
-
-      expect(format).to be_required_methods_present(String)
-    end
-
-    it "should consider a class not supported if any required methods are missing from the provided class" do
-      format = Puppet::Network::Format.new(:foo)
-      allow(format).to receive(:required_method_present?).and_return(true)
-      expect(format).to receive(:required_method_present?).with(:intern_method, anything, anything).and_return(false)
-      expect(format).not_to be_required_methods_present(String)
-    end
-
-    it "should be able to specify the methods required for support" do
-      expect(Puppet::Network::Format.new(:foo, :required_methods => [:render_method, :intern_method]).required_methods).to eq([:render_method, :intern_method])
-    end
-
-    it "should only test for required methods if specific methods are specified as required" do
-      format = Puppet::Network::Format.new(:foo, :required_methods => [:intern_method])
-      expect(format).to receive(:required_method_present?).with(:intern_method, anything, anything)
-
-      format.required_methods_present?(String)
-    end
-
-    it "should not consider a class supported unless the format is suitable" do
-      expect(@format).to receive(:suitable?).and_return(false)
-      expect(@format).not_to be_supported(FormatRenderer)
-    end
-
-    it "should always downcase mimetypes" do
-      @format.mime = "Foo/Bar"
-      expect(@format.mime).to eq("foo/bar")
-    end
-
-    it "should support having a weight" do
-      expect(@format).to respond_to(:weight)
-    end
-
-    it "should default to a weight of of 5" do
-      expect(@format.weight).to eq(5)
-    end
-
-    it "should be able to override its weight at initialization" do
-      expect(Puppet::Network::Format.new(:foo, :weight => 1).weight).to eq(1)
-    end
-
-    it "should default to its extension being equal to its name" do
-      expect(Puppet::Network::Format.new(:foo).extension).to eq("foo")
-    end
-
-    it "should support overriding the extension" do
-      expect(Puppet::Network::Format.new(:foo, :extension => "bar").extension).to eq("bar")
-    end
-
-    it "doesn't support charset by default" do
-      expect(Puppet::Network::Format.new(:foo).charset).to be_nil
-    end
-
-    it "allows charset to be set to 'utf-8'" do
-      expect(Puppet::Network::Format.new(:foo, :charset => Encoding::UTF_8).charset).to eq(Encoding::UTF_8)
-    end
-
-    [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
-      it "should allow assignment of the #{method}" do
-        expect(Puppet::Network::Format.new(:foo, method => :foo).send(method)).to eq(:foo)
-      end
-    end
-  end
-
-  describe "when converting between instances and formatted text" do
-    before do
-      @format = Puppet::Network::Format.new(:my_format)
-      @instance = FormatRenderer.new
-    end
-
-    it "should have a method for rendering a single instance" do
-      expect(@format).to respond_to(:render)
-    end
-
-    it "should have a method for rendering multiple instances" do
-      expect(@format).to respond_to(:render_multiple)
-    end
-
-    it "should have a method for interning text" do
-      expect(@format).to respond_to(:intern)
-    end
-
-    it "should have a method for interning text into multiple instances" do
-      expect(@format).to respond_to(:intern_multiple)
-    end
-
-    it "should return the results of calling the instance-specific render method if the method is present" do
-      expect(@instance).to receive(:to_my_format).and_return("foo")
-      expect(@format.render(@instance)).to eq("foo")
-    end
-
-    it "should return the results of calling the class-specific render_multiple method if the method is present" do
-      expect(@instance.class).to receive(:to_multiple_my_format).and_return(["foo"])
-      expect(@format.render_multiple([@instance])).to eq(["foo"])
-    end
-
-    it "should return the results of calling the class-specific intern method if the method is present" do
-      expect(FormatRenderer).to receive(:from_my_format).with("foo").and_return(@instance)
-      expect(@format.intern(FormatRenderer, "foo")).to equal(@instance)
-    end
-
-    it "should return the results of calling the class-specific intern_multiple method if the method is present" do
-      expect(FormatRenderer).to receive(:from_multiple_my_format).with("foo").and_return([@instance])
-      expect(@format.intern_multiple(FormatRenderer, "foo")).to eq([@instance])
-    end
-
-    it "should fail if asked to render and the instance does not respond to 'to_<format>'" do
-      expect { @format.render("foo") }.to raise_error(NotImplementedError)
-    end
-
-    it "should fail if asked to intern and the class does not respond to 'from_<format>'" do
-      expect { @format.intern(String, "foo") }.to raise_error(NotImplementedError)
-    end
-
-    it "should fail if asked to intern multiple and the class does not respond to 'from_multiple_<format>'" do
-      expect { @format.intern_multiple(String, "foo") }.to raise_error(NotImplementedError)
-    end
-
-    it "should fail if asked to render multiple and the instance does not respond to 'to_multiple_<format>'" do
-      expect { @format.render_multiple(["foo", "bar"]) }.to raise_error(NotImplementedError)
-    end
-  end
-end