puppet 7.28.0 → 7.29.1

data/spec/unit/module_tool/installed_modules_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool/installed_modules'
-require 'puppet_spec/modules'
-
-describe Puppet::ModuleTool::InstalledModules do
-  include PuppetSpec::Files
-
-  around do |example|
-    dir = tmpdir("deep_path")
-
-    FileUtils.mkdir_p(@modpath = File.join(dir, "modpath"))
-
-    @env = Puppet::Node::Environment.create(:env, [@modpath])
-    Puppet.override(:current_environment => @env) do
-      example.run
-    end
-  end
-
-  it 'works when given a semantic version' do
-    mod = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
-    installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))
-  end
-
-  it 'defaults when not given a semantic version' do
-    mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
-    expect(Puppet).to receive(:warning).with(/Semantic Version/)
-    installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
-  end
-
-  it 'defaults when not given a full semantic version' do
-    mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => '1.2'})
-    expect(Puppet).to receive(:warning).with(/Semantic Version/)
-    installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
-  end
-
-  it 'still works if there is an invalid version in one of the modules' do
-    mod1 = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
-    mod2 = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
-    mod3 = PuppetSpec::Modules.create('notquitesemver', @modpath, :metadata => {:version => '1.2'})
-    expect(Puppet).to receive(:warning).with(/Semantic Version/).twice
-    installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
-    expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))
-    expect(installed.modules["puppetlabs-#{mod3.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
-  end
-end

data/spec/unit/module_tool/metadata_spec.rb

@@ -1,330 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool'
-
-describe Puppet::ModuleTool::Metadata do
-  let(:data) { {} }
-  let(:metadata) { Puppet::ModuleTool::Metadata.new }
-
-  describe 'property lookups' do
-    subject { metadata }
-
-    %w[ name version author summary license source project_page issues_url
-    dependencies dashed_name release_name description data_provider].each do |prop|
-      describe "##{prop}" do
-        it "responds to the property" do
-          subject.send(prop)
-        end
-      end
-    end
-  end
-
-  describe "#update" do
-    subject { metadata.update(data) }
-
-    context "with a valid name" do
-      let(:data) { { 'name' => 'billgates-mymodule' } }
-
-      it "extracts the author name from the name field" do
-        expect(subject.to_hash['author']).to eq('billgates')
-      end
-
-      it "extracts a module name from the name field" do
-        expect(subject.module_name).to eq('mymodule')
-      end
-
-      context "and existing author" do
-        before { metadata.update('author' => 'foo') }
-
-        it "avoids overwriting the existing author" do
-          expect(subject.to_hash['author']).to eq('foo')
-        end
-      end
-    end
-
-    context "with a valid name and author" do
-      let(:data) { { 'name' => 'billgates-mymodule', 'author' => 'foo' } }
-
-      it "use the author name from the author field" do
-        expect(subject.to_hash['author']).to eq('foo')
-      end
-
-      context "and preexisting author" do
-        before { metadata.update('author' => 'bar') }
-
-        it "avoids overwriting the existing author" do
-          expect(subject.to_hash['author']).to eq('foo')
-        end
-      end
-    end
-
-    context "with an invalid name" do
-      context "(short module name)" do
-        let(:data) { { 'name' => 'mymodule' } }
-
-        it "raises an exception" do
-          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
-        end
-      end
-
-      context "(missing namespace)" do
-        let(:data) { { 'name' => '/mymodule' } }
-
-        it "raises an exception" do
-          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
-        end
-      end
-
-      context "(missing module name)" do
-        let(:data) { { 'name' => 'namespace/' } }
-
-        it "raises an exception" do
-          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
-        end
-      end
-
-      context "(invalid namespace)" do
-        let(:data) { { 'name' => "dolla'bill$-mymodule" } }
-
-        it "raises an exception" do
-          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the namespace contains non-alphanumeric characters")
-        end
-      end
-
-      context "(non-alphanumeric module name)" do
-        let(:data) { { 'name' => "dollabils-fivedolla'" } }
-
-        it "raises an exception" do
-          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name contains non-alphanumeric (or underscore) characters")
-        end
-      end
-
-      context "(module name starts with a number)" do
-        let(:data) { { 'name' => "dollabills-5dollars" } }
-
-        it "raises an exception" do
-          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name must begin with a letter")
-        end
-      end
-    end
-
-
-    context "with an invalid version" do
-      let(:data) { { 'version' => '3.0' } }
-
-      it "raises an exception" do
-        expect { subject }.to raise_error(ArgumentError, "Invalid 'version' field in metadata.json: version string cannot be parsed as a valid Semantic Version")
-      end
-    end
-
-    context "with a valid source" do
-      context "which is a GitHub URL" do
-        context "with a scheme" do
-          before { metadata.update('source' => 'https://github.com/billgates/amazingness') }
-
-          it "predicts a default project_page" do
-            expect(subject.to_hash['project_page']).to eq('https://github.com/billgates/amazingness')
-          end
-
-          it "predicts a default issues_url" do
-            expect(subject.to_hash['issues_url']).to eq('https://github.com/billgates/amazingness/issues')
-          end
-        end
-
-        context "without a scheme" do
-          before { metadata.update('source' => 'github.com/billgates/amazingness') }
-
-          it "predicts a default project_page" do
-            expect(subject.to_hash['project_page']).to eq('https://github.com/billgates/amazingness')
-          end
-
-          it "predicts a default issues_url" do
-            expect(subject.to_hash['issues_url']).to eq('https://github.com/billgates/amazingness/issues')
-          end
-        end
-      end
-
-      context "which is not a GitHub URL" do
-        before { metadata.update('source' => 'https://notgithub.com/billgates/amazingness') }
-
-        it "does not predict a default project_page" do
-          expect(subject.to_hash['project_page']).to be nil
-        end
-
-        it "does not predict a default issues_url" do
-          expect(subject.to_hash['issues_url']).to be nil
-        end
-      end
-
-      context "which is not a URL" do
-        before { metadata.update('source' => 'my brain') }
-
-        it "does not predict a default project_page" do
-          expect(subject.to_hash['project_page']).to be nil
-        end
-
-        it "does not predict a default issues_url" do
-          expect(subject.to_hash['issues_url']).to be nil
-        end
-      end
-
-    end
-
-    context "with a valid dependency" do
-      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-goodmodule'}] }}
-
-      it "adds the dependency" do
-        expect(subject.dependencies.size).to eq(1)
-      end
-    end
-
-    context "with a invalid dependency name" do
-      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule'}] }}
-
-      it "raises an exception" do
-        expect { subject }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "with a valid dependency version range" do
-      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-badmodule', 'version_requirement' => '>= 2.0.0'}] }}
-
-      it "adds the dependency" do
-        expect(subject.dependencies.size).to eq(1)
-      end
-    end
-
-    context "with a invalid version range" do
-      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule', 'version_requirement' => '>= banana'}] }}
-
-      it "raises an exception" do
-        expect { subject }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "with duplicate dependencies" do
-      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-dupmodule', 'version_requirement' => '1.0.0'},
-        {'name' => 'puppetlabs-dupmodule', 'version_requirement' => '0.0.1'}] }
-      }
-
-      it "raises an exception" do
-        expect { subject }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "adding a duplicate dependency" do
-      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-origmodule', 'version_requirement' => '1.0.0'}] }}
-
-      it "with a different version raises an exception" do
-        metadata.add_dependency('puppetlabs-origmodule', '>= 0.0.1')
-        expect { subject }.to raise_error(ArgumentError)
-      end
-
-      it "with the same version does not add another dependency" do
-        metadata.add_dependency('puppetlabs-origmodule', '1.0.0')
-        expect(subject.dependencies.size).to eq(1)
-      end
-    end
-
-    context 'with valid data_provider' do
-      let(:data) { {'data_provider' => 'the_name'} }
-
-      it 'validates the provider correctly' do
-        expect { subject }.not_to raise_error
-      end
-
-      it 'returns the provider' do
-        expect(subject.data_provider).to eq('the_name')
-      end
-    end
-
-    context 'with invalid data_provider' do
-      let(:data) { }
-
-      it "raises exception unless argument starts with a letter" do
-        expect { metadata.update('data_provider' => '_the_name') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
-        expect { metadata.update('data_provider' => '') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
-      end
-
-      it "raises exception if argument contains non-alphanumeric characters" do
-        expect { metadata.update('data_provider' => 'the::name') }.to raise_error(ArgumentError, /field 'data_provider' contains non-alphanumeric characters/)
-      end
-
-      it "raises exception unless argument is a string" do
-        expect { metadata.update('data_provider' => 23) }.to raise_error(ArgumentError, /field 'data_provider' must be a string/)
-      end
-    end
-  end
-
-  describe '#dashed_name' do
-    it 'returns nil in the absence of a module name' do
-      expect(metadata.update('version' => '1.0.0').release_name).to be_nil
-    end
-
-    it 'returns a hyphenated string containing namespace and module name' do
-      data = metadata.update('name' => 'foo-bar')
-      expect(data.dashed_name).to eq('foo-bar')
-    end
-
-    it 'properly handles slash-separated names' do
-      data = metadata.update('name' => 'foo/bar')
-      expect(data.dashed_name).to eq('foo-bar')
-    end
-
-    it 'is unaffected by author name' do
-      data = metadata.update('name' => 'foo/bar', 'author' => 'me')
-      expect(data.dashed_name).to eq('foo-bar')
-    end
-  end
-
-  describe '#release_name' do
-    it 'returns nil in the absence of a module name' do
-      expect(metadata.update('version' => '1.0.0').release_name).to be_nil
-    end
-
-    it 'returns nil in the absence of a version' do
-      expect(metadata.update('name' => 'foo/bar').release_name).to be_nil
-    end
-
-    it 'returns a hyphenated string containing module name and version' do
-      data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0')
-      expect(data.release_name).to eq('foo-bar-1.0.0')
-    end
-
-    it 'is unaffected by author name' do
-      data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0', 'author' => 'me')
-      expect(data.release_name).to eq('foo-bar-1.0.0')
-    end
-  end
-
-  describe "#to_hash" do
-    subject { metadata.to_hash }
-
-    it "contains the default set of keys" do
-      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies data_provider].sort)
-    end
-
-    describe "['license']" do
-      it "defaults to Apache 2" do
-        expect(subject['license']).to eq("Apache-2.0")
-      end
-    end
-
-    describe "['dependencies']" do
-      it "defaults to an empty set" do
-        expect(subject['dependencies']).to eq(Set.new)
-      end
-    end
-
-    context "when updated with non-default data" do
-      subject { metadata.update('license' => 'MIT', 'non-standard' => 'yup').to_hash }
-
-      it "overrides the defaults" do
-        expect(subject['license']).to eq('MIT')
-      end
-
-      it 'contains unanticipated values' do
-        expect(subject['non-standard']).to eq('yup')
-      end
-    end
-  end
-end

data/spec/unit/module_tool/tar/gnu_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool'
-
-describe Puppet::ModuleTool::Tar::Gnu do
-  let(:sourcefile) { '/space path/the/module.tar.gz' }
-  let(:destdir)    { '/space path/the/dest/dir' }
-  let(:sourcedir)  { '/space path/the/src/dir' }
-  let(:destfile)   { '/space path/the/dest/file.tar.gz' }
-
-  it "unpacks a tar file" do
-    expect(Dir).to receive(:chdir).with(File.expand_path(destdir)).and_yield
-    expect(Puppet::Util::Execution).to receive(:execute).with("gzip -dc #{Shellwords.shellescape(File.expand_path(sourcefile))} | tar xof -")
-    expect(Puppet::Util::Execution).to receive(:execute).with("find . -type d -exec chmod 755 {} +")
-    expect(Puppet::Util::Execution).to receive(:execute).with("find . -type f -exec chmod u+rw,g+r,a-st {} +")
-    expect(Puppet::Util::Execution).to receive(:execute).with("chown -R <owner:group> .")
-    subject.unpack(sourcefile, destdir, '<owner:group>')
-  end
-
-  it "packs a tar file" do
-    expect(Puppet::Util::Execution).to receive(:execute).with("tar cf - #{sourcedir} | gzip -c > #{File.basename(destfile)}")
-    subject.pack(sourcedir, destfile)
-  end
-end

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool'
-
-describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Puppet.features.zlib?) do
-  let(:sourcefile) { '/the/module.tar.gz' }
-  let(:destdir)    { File.expand_path '/the/dest/dir' }
-  let(:sourcedir)  { '/the/src/dir' }
-  let(:destfile)   { '/the/dest/file.tar.gz' }
-  let(:minitar)    { described_class.new }
-
-  class MockFileStatEntry
-    def initialize(mode = 0100)
-      @mode = mode
-    end
-  end
-
-  it "unpacks a tar file with correct permissions" do
-    entry = unpacks_the_entry(:file_start, 'thefile')
-
-    minitar.unpack(sourcefile, destdir, 'uid')
-    expect(entry.instance_variable_get(:@mode)).to eq(0755)
-  end
-
-  it "does not allow an absolute path" do
-    unpacks_the_entry(:file_start, '/thefile')
-
-    expect {
-      minitar.unpack(sourcefile, destdir, 'uid')
-    }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file with an invalid path into \"/thefile\" under \"#{destdir}\"")
-  end
-
-  it "does not allow a file to be written outside the destination directory" do
-    unpacks_the_entry(:file_start, '../../thefile')
-
-    expect {
-      minitar.unpack(sourcefile, destdir, 'uid')
-    }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
-  end
-
-  it "does not allow a directory to be written outside the destination directory" do
-    unpacks_the_entry(:dir, '../../thedir')
-
-    expect {
-      minitar.unpack(sourcefile, destdir, 'uid')
-    }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
-  end
-
-  it "unpacks on Windows" do
-    unpacks_the_entry(:file_start, 'thefile', nil)
-
-    entry = minitar.unpack(sourcefile, destdir, 'uid')
-    # Windows does not use these permissions.
-    expect(entry.instance_variable_get(:@mode)).to eq(nil)
-  end
-
-  it "packs a tar file" do
-    writer = double('GzipWriter')
-
-    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
-    stats = {:mode => 0222}
-    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer).and_yield(:file_start, 'abc', stats)
-
-    minitar.pack(sourcedir, destfile)
-  end
-
-  it "packs a tar file on Windows" do
-    writer = double('GzipWriter')
-
-    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
-    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer).
-        and_yield(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
-
-    minitar.pack(sourcedir, destfile)
-  end
-
-  def unpacks_the_entry(type, name, mode = 0100)
-    reader = double('GzipReader')
-
-    expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
-    expect(minitar).to receive(:find_valid_files).with(reader).and_return([name])
-    entry = MockFileStatEntry.new(mode)
-    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name], {:fsync => false}).
-        and_yield(type, name, {:entry => entry})
-    entry
-  end
-
-  describe "Extracts tars with long and short pathnames" do
-    let (:sourcetar) { fixtures('module.tar.gz') }
-    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
-    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
-
-    it "unpacks a tar with a short path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
-    end
-
-    it "unpacks a tar with a long path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
-    end
-  end
-end

data/spec/unit/module_tool/tar_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool/tar'
-
-describe Puppet::ModuleTool::Tar do
-  [
-    { :name => 'ObscureLinuxDistro', :win => false }, 
-    { :name => 'Windows', :win => true }
-  ].each do |os|
-    it "always prefers minitar if it and zlib are present, even with tar available" do
-      allow(Facter).to receive(:value).with('osfamily').and_return(os[:name])
-      allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(os[:win])
-      allow(Puppet).to receive(:features).and_return(double(:minitar? => true, :zlib? => true))
-
-      expect(described_class.instance).to be_a_kind_of Puppet::ModuleTool::Tar::Mini
-    end
-  end
-
-  it "falls back to tar when minitar not present and not on Windows" do
-    allow(Facter).to receive(:value).with('osfamily').and_return('ObscureLinuxDistro')
-    allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
-    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-    allow(Puppet).to receive(:features).and_return(double(:minitar? => false))
-
-    expect(described_class.instance).to be_a_kind_of Puppet::ModuleTool::Tar::Gnu
-  end
-
-  it "fails when there is no possible implementation" do
-    allow(Facter).to receive(:value).with('osfamily').and_return('Windows')
-    allow(Puppet::Util).to receive(:which).with('tar')
-    allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
-    allow(Puppet).to receive(:features).and_return(double(:minitar? => false, :zlib? => false))
-
-    expect { described_class.instance }.to raise_error RuntimeError, /No suitable tar/
-  end
-end