r10k 3.15.0 → 4.1.0

data/spec/unit/environment/svn_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-require 'r10k/environment'
-
-describe R10K::Environment::SVN do
-
-  subject do
-    described_class.new(
-      'myenv',
-      '/some/nonexistent/environmentdir',
-      'svn-dirname',
-      {
-        :remote => 'https://svn-server.site/svn-repo/trunk'
-      }
-    )
-  end
-
-  let(:working_dir) { subject.working_dir }
-
-  describe "initializing" do
-    subject do
-      described_class.new('name', '/dir', 'ref', {
-        :puppetfile_name => 'Puppetfile',
-      })
-    end
-
-    it "accepts valid base class initialization arguments" do
-      expect(subject.name).to eq 'name'
-    end
-  end
-
-  describe "storing attributes" do
-    it "can return the environment name" do
-      expect(subject.name).to eq 'myenv'
-    end
-
-    it "can return the environment basedir" do
-      expect(subject.basedir).to eq '/some/nonexistent/environmentdir'
-    end
-
-    it "can return the environment dirname" do
-      expect(subject.dirname).to eq 'svn-dirname'
-    end
-
-    it "can return the environment remote" do
-      expect(subject.remote).to eq 'https://svn-server.site/svn-repo/trunk'
-    end
-  end
-
-  describe "synchronizing the environment" do
-    it "checks out the working directory when creating a new environment" do
-      allow(working_dir).to receive(:is_svn?).and_return(false)
-      expect(working_dir).to receive(:checkout)
-      subject.sync
-    end
-
-    it "updates the working directory when updating an existing environment" do
-      allow(working_dir).to receive(:is_svn?).and_return(true)
-      expect(working_dir).to receive(:update)
-      subject.sync
-    end
-  end
-
-  describe "generating a puppetfile for the environment" do
-    let(:puppetfile) { subject.puppetfile }
-
-    it "creates a puppetfile at the full path to the environment" do
-      expect(puppetfile.basedir).to eq '/some/nonexistent/environmentdir/svn-dirname'
-    end
-
-    it "sets the moduledir to 'modules' relative to the environment path" do
-      expect(puppetfile.moduledir).to eq '/some/nonexistent/environmentdir/svn-dirname/modules'
-    end
-
-    it "sets the puppetfile path to 'Puppetfile' relative to the environment path" do
-      expect(puppetfile.puppetfile_path).to eq '/some/nonexistent/environmentdir/svn-dirname/Puppetfile'
-    end
-  end
-
-  describe "enumerating modules" do
-    it "loads the Puppetfile and returns modules in that puppetfile" do
-      loaded = { managed_directories: [], desired_contents: [], purge_exclusions: [] }
-      mod = double('A module', :name => 'dbl')
-      expect(subject.loader).to receive(:load).and_return(loaded.merge(modules: [mod]))
-      expect(subject.modules).to eq([mod])
-    end
-  end
-
-  describe "determining the status" do
-    it "is absent if the working directory is absent" do
-      expect(subject.path).to receive(:exist?).and_return(false)
-      expect(subject.status).to eq :absent
-    end
-
-    it "is mismatched if the working directory is not an SVN repo" do
-      expect(subject.path).to receive(:exist?).and_return(true)
-      expect(working_dir).to receive(:is_svn?).and_return(false)
-      expect(subject.status).to eq :mismatched
-    end
-
-    it "is mismatched if the working directory remote doesn't match the expected remote" do
-      expect(subject.path).to receive(:exist?).and_return(true)
-      expect(working_dir).to receive(:is_svn?).and_return(true)
-      expect(working_dir).to receive(:url).and_return 'https://svn-server.site/another-svn-repo/trunk'
-      expect(subject.status).to eq :mismatched
-    end
-
-    it "is outdated when the the working directory has not synced" do
-      expect(subject.path).to receive(:exist?).and_return(true)
-      expect(working_dir).to receive(:is_svn?).and_return(true)
-      expect(working_dir).to receive(:url).and_return 'https://svn-server.site/svn-repo/trunk'
-      expect(subject.status).to eq :outdated
-    end
-
-    it "is insync when the working directory has been synced" do
-      expect(subject.path).to receive(:exist?).and_return(true)
-      expect(working_dir).to receive(:is_svn?).twice.and_return(true)
-      expect(working_dir).to receive(:url).and_return 'https://svn-server.site/svn-repo/trunk'
-
-      expect(working_dir).to receive(:update)
-
-      subject.sync
-
-      expect(subject.status).to eq :insync
-    end
-  end
-
-  describe "environment signature" do
-    it "returns the svn revision of the branch" do
-      expect(working_dir).to receive(:revision).and_return '1337'
-      expect(subject.signature).to eq '1337'
-    end
-  end
-
-  describe "info hash" do
-    let(:info_hash) { subject.info }
-
-    before(:each) do
-      expect(working_dir).to receive(:revision).and_return '1337'
-    end
-
-    it "includes name and signature" do
-      expect(info_hash.keys).to include :name, :signature
-      expect(info_hash).not_to have_value(nil)
-    end
-  end
-end

data/spec/unit/environment/tarball_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'r10k/environment'
-
-describe R10K::Environment::Tarball do
-  let(:tgz_path) do
-    File.expand_path('spec/fixtures/tarball/tarball.tar.gz', PROJECT_ROOT)
-  end
-
-  let(:checksum) { '36afcfc2378b8235902d6e647fce7479da6898354d620388646c595a1155ed67' }
-  let(:base_params) { { source: tgz_path, version: checksum, modules: { } } }
-
-  subject { described_class.new('envname', '/some/imaginary/path', 'dirname', base_params) }
-
-  describe "initializing" do
-    it "accepts valid base class initialization arguments" do
-      expect(subject.name).to eq 'envname'
-    end
-  end
-
-  describe "storing attributes" do
-    it "can return the environment name" do
-      expect(subject.name).to eq 'envname'
-    end
-
-    it "can return the environment basedir" do
-      expect(subject.basedir).to eq '/some/imaginary/path'
-    end
-
-    it "can return the environment dirname" do
-      expect(subject.dirname).to eq 'dirname'
-    end
-
-    it "can return the environment path" do
-      expect(subject.path.to_s).to eq '/some/imaginary/path/dirname'
-    end
-
-    it "can return the environment source" do
-      expect(subject.tarball.source).to eq tgz_path
-    end
-
-    it "can return the environment version" do
-      expect(subject.tarball.checksum).to eq checksum
-    end
-  end
-end

data/spec/unit/environment/with_modules_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-require 'r10k/environment'
-
-describe R10K::Environment::WithModules do
-  subject do
-    described_class.new(
-      'release42',
-      '/some/nonexistent/environmentdir',
-      'prefix_release42',
-      {
-        :type             => 'plain',
-        :modules          => {
-          'puppetlabs-stdlib' => { local: true },
-          'puppetlabs-concat' => { local: true },
-          'puppetlabs-exec'   => { local: true },
-        }
-      }.merge(subject_params)
-    )
-  end
-
-  # Default no additional params
-  let(:subject_params) { {} }
-
-  describe "dealing with module conflicts" do
-    context "with no module conflicts" do
-      it "validates when there are no conflicts" do
-        mod = instance_double('R10K::Module::Base', name: 'nonconflict', origin: :puppetfile)
-        expect(subject.module_conflicts?(mod)).to eq false
-      end
-    end
-
-    context "with module conflicts and default behavior" do
-      it "does not raise an error" do
-        mod = instance_double('R10K::Module::Base', name: 'stdlib', origin: :puppetfile)
-        expect(subject.logger).to receive(:warn).with(/Puppetfile.*both define.*ignored/i)
-        expect(subject.module_conflicts?(mod)).to eq true
-      end
-    end
-
-    context "with module conflicts and 'error' behavior" do
-      let(:subject_params) {{ :module_conflicts => 'error' }}
-      it "raises an error" do
-        mod = instance_double('R10K::Module::Base', name: 'stdlib', origin: :puppetfile)
-        expect { subject.module_conflicts?(mod) }.to raise_error(R10K::Error, /Puppetfile.*both define.*/i)
-      end
-    end
-
-    context "with module conflicts and 'override' behavior" do
-      let(:subject_params) {{ :module_conflicts => 'override' }}
-      it "does not raise an error" do
-        mod = instance_double('R10K::Module::Base', name: 'stdlib', origin: :puppetfile)
-        expect(subject.logger).to receive(:debug).with(/Puppetfile.*both define.*ignored/i)
-        expect(subject.module_conflicts?(mod)).to eq true
-      end
-    end
-
-    context "with module conflicts and invalid configuration" do
-      let(:subject_params) {{ :module_conflicts => 'batman' }}
-      it "raises an error" do
-        mod = instance_double('R10K::Module::Base', name: 'stdlib', origin: :puppetfile)
-        expect { subject.module_conflicts?(mod) }.to raise_error(R10K::Error, /Unexpected value.*module_conflicts.*/i)
-      end
-    end
-  end
-
-  describe "modules method" do
-    it "returns the configured modules, and Puppetfile modules" do
-      loaded = { managed_directories: [], desired_contents: [], purge_exclusions: [] }
-      puppetfile_mod = instance_double('R10K::Module::Base', name: 'zebra')
-      expect(subject.loader).to receive(:load).and_return(loaded.merge(modules: [puppetfile_mod]))
-      returned_modules = subject.modules
-      expect(returned_modules.map(&:name).sort).to eq(%w[concat exec stdlib zebra])
-    end
-  end
-
-  describe "module options" do
-    let(:subject_params) {{
-      :modules => {
-        'hieradata' => {
-          :type => 'git',
-          :source => 'git@git.example.com:site_data.git',
-          :install_path => ''
-        },
-        'site_data_2' => {
-          :type => 'git',
-          :source => 'git@git.example.com:site_data.git',
-          :install_path => 'subdir'
-        },
-
-      }
-    }}
-
-    it "should support empty install_path" do
-      modules = subject.modules
-      expect(modules[0].title).to eq 'hieradata'
-      expect(modules[0].path).to eq Pathname.new('/some/nonexistent/environmentdir/prefix_release42/hieradata')
-
-    end
-
-    it "should support install_path" do
-      modules = subject.modules
-      expect(modules[1].title).to eq 'site_data_2'
-      expect(modules[1].path).to eq Pathname.new('/some/nonexistent/environmentdir/prefix_release42/subdir/site_data_2')
-    end
-
-    context "with invalid configuration" do
-      let(:subject_params) {{
-      :modules => {
-          'site_data_2' => {
-            :type => 'git',
-            :source => 'git@git.example.com:site_data.git',
-            :install_path => '/absolute_path_outside_of_containing_environment'
-          }
-        }
-      }}
-
-      it "raises an error" do
-        expect{ subject.modules }.to raise_error(R10K::Error, /Environment cannot.*outside of containing environment.*/i)
-      end
-    end
-  end
-end

data/spec/unit/errors/formatting_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-require 'r10k/errors/formatting'
-
-describe R10K::Errors::Formatting do
-
-  describe "without a nested exception" do
-    let(:exc) do
-      ArgumentError.new("ArgumentError message").tap do |a|
-        a.set_backtrace(%w[/backtrace/line:1 /backtrace/line:2])
-      end
-    end
-
-    describe "and without a backtrace" do
-      subject do
-        described_class.format_exception(exc, false)
-      end
-
-      it "formats the exception with the message" do
-        expect(subject).to eq("ArgumentError message")
-      end
-    end
-
-    describe "and with a backtrace" do
-      subject do
-        described_class.format_exception(exc, true)
-      end
-
-      it "formats the exception with the message and backtrace" do
-        expect(subject).to eq([
-          "ArgumentError message",
-          "/backtrace/line:1",
-          "/backtrace/line:2",
-        ].join("\n"))
-      end
-    end
-  end
-
-  describe "with a nested exception" do
-
-    let(:nestee) do
-      ArgumentError.new("ArgumentError message").tap do |a|
-        a.set_backtrace(%w[/backtrace/line:1 /backtrace/line:2])
-      end
-    end
-
-    let(:exc) do
-      R10K::Error.wrap(nestee, "R10K::Error message").tap do |r|
-        r.set_backtrace(%w[/another/backtrace/line:1 /another/backtrace/line:2])
-      end
-    end
-
-    describe "and without a backtrace" do
-      subject do
-        described_class.format_exception(exc, false)
-      end
-
-      it "formats the exception with the message and original message" do
-        expect(subject).to eq([
-          "R10K::Error message",
-          "Original exception:",
-          "ArgumentError message"
-        ].join("\n"))
-      end
-    end
-
-    describe "and with a backtrace" do
-      subject do
-        described_class.format_exception(exc, true)
-      end
-
-      it "formats the exception with the message, backtrace, original message, and original backtrace" do
-        expect(subject).to eq([
-          "R10K::Error message",
-          "/another/backtrace/line:1",
-          "/another/backtrace/line:2",
-          "Original exception:",
-          "ArgumentError message",
-          "/backtrace/line:1",
-          "/backtrace/line:2",
-        ].join("\n"))
-      end
-    end
-  end
-end

data/spec/unit/feature_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'r10k/feature'
-
-describe R10K::Feature do
-  describe "confining a feature to a library" do
-    it "is available if the library can be loaded" do
-      feature = described_class.new(:r10k, :libraries => 'r10k')
-      expect(feature.available?).to be_truthy
-    end
-
-    it "is unavailable if the library cannot be loaded" do
-      feature = described_class.new(:squidlibs, :libraries => 'squid/libs')
-      expect(feature.available?).to be_falsey
-    end
-  end
-
-  describe "confining a feature to a block" do
-    it "is available if the block is true" do
-      feature = described_class.new(:blockfeature) { true }
-      expect(feature.available?).to be_truthy
-    end
-
-    it "is unavailable if the block is false" do
-      feature = described_class.new(:blockfeature) { false }
-      expect(feature.available?).to be_falsey
-    end
-  end
-
-  describe  "confining a feature to both a block and libraries" do
-    it "is unavailable if the block returns false and libraries are absent" do
-      feature = described_class.new(:nope, :libraries => 'nope/nope') { false }
-      expect(feature.available?).to be_falsey
-    end
-
-    it "is unavailable if the block returns true and libraries are absent" do
-      feature = described_class.new(:nope, :libraries => 'nope/nope') { true }
-      expect(feature.available?).to be_falsey
-    end
-
-    it "is unavailable if the block returns false and libraries are present" do
-      feature = described_class.new(:nope, :libraries => 'r10k') { false }
-      expect(feature.available?).to be_falsey
-    end
-
-    it "is available if the block returns true and libraries are present" do
-      feature = described_class.new(:yep, :libraries => 'r10k') { true }
-      expect(feature.available?).to be_truthy
-    end
-  end
-end

data/spec/unit/forge/module_release_spec.rb

@@ -1,213 +0,0 @@
-require 'spec_helper'
-require 'r10k/forge/module_release'
-require 'r10k/util/exec_env'
-require 'puppet_forge'
-
-describe R10K::Forge::ModuleRelease do
-  subject { described_class.new('branan-eight_hundred', '8.0.0') }
-
-  let(:forge_release_class) { PuppetForge::V3::Release }
-  let(:sha256_digest_class) { Digest::SHA256 }
-  let(:md5_digest_class) { Digest::MD5 }
-
-  let(:download_path) { instance_double('Pathname') }
-  let(:tarball_cache_path) { instance_double('Pathname') }
-  let(:tarball_cache_root) { instance_double('Pathname') }
-  let(:unpack_path) { instance_double('Pathname') }
-  let(:target_dir) { instance_double('Pathname') }
-  let(:tarball_cache_path) { instance_double('Pathname') }
-  let(:md5_file_path) { instance_double('Pathname') }
-  let(:sha256_file_path) { instance_double('Pathname') }
-
-  let(:file_lists) { {:valid=>['valid_ex'], :invalid=>[], :symlinks=>['symlink_ex']} }
-
-  let(:file_contents) { "skeletor's closet" }
-  let(:sha256_digest) { instance_double('Digest::SHA256') }
-  let(:sha256_of_tarball) { "sha256_hash" }
-  let(:md5_digest) { instance_double('Digest::MD5') }
-  let(:md5_of_tarball) { "md5_hash" }
-  let(:good_md5) { md5_of_tarball }
-  let(:good_sha256) { sha256_of_tarball }
-  let(:bad_sha256) { "bad_sha256_hash" }
-  let(:bad_md5) { "bad_md5_hash" }
-
-  before do
-    subject.download_path = download_path
-    subject.tarball_cache_path = tarball_cache_path
-    subject.tarball_cache_root = tarball_cache_root
-    subject.unpack_path = unpack_path
-    subject.md5_file_path = md5_file_path
-    subject.sha256_file_path = sha256_file_path
-  end
-
-  context "no cached tarball" do
-    describe '#download' do
-      it "downloads the module from the forge into `download_path`" do
-        expect(tarball_cache_path).to receive(:exist?).and_return(false)
-        expect(subject.forge_release).to receive(:download).with(download_path)
-        allow(FileUtils).to receive(:mkdir_p).with(tarball_cache_root)
-        expect(FileUtils).to receive(:mv).with(download_path, tarball_cache_path)
-        subject.download
-      end
-    end
-  end
-
-  context "with cached tarball" do
-    describe '#download' do
-      it "does not download a new tarball" do
-        expect(tarball_cache_path).to receive(:exist?).and_return(true)
-        expect(subject.forge_release).not_to receive(:download).with(download_path)
-        subject.download
-      end
-    end
-  end
-
-  describe '#verify' do
-
-    it "verifies using the file SHA256, if that exists" do
-      allow(sha256_digest_class).to receive(:file).and_return(sha256_digest)
-      allow(sha256_digest).to receive(:hexdigest).and_return(sha256_of_tarball)
-      allow(sha256_file_path).to receive(:exist?).and_return(true)
-      expect(subject).to receive(:verify_from_file).with(sha256_of_tarball, sha256_file_path)
-      subject.verify
-    end
-
-    it "verifies using the forge file_sha256, if no sha256 file exists" do
-      allow(sha256_digest_class).to receive(:file).and_return(sha256_digest)
-      allow(sha256_digest).to receive(:hexdigest).and_return(sha256_of_tarball)
-      allow(sha256_file_path).to receive(:exist?).and_return(false)
-      allow(subject.forge_release).to receive(:respond_to?).and_return(true)
-      allow(subject.forge_release).to receive(:sha256_file).and_return(sha256_of_tarball)
-      expect(subject).to receive(:verify_from_forge)
-      subject.verify
-    end
-
-    it "falls back to md5 verification when not in FIPS mode and no sha256 available" do
-      expect(R10K::Util::Platform).to receive(:fips?).and_return(false)
-      # failed sha256 verification
-      allow(sha256_digest_class).to receive(:file).and_return(sha256_digest)
-      allow(sha256_digest).to receive(:hexdigest).and_return(sha256_of_tarball)
-      allow(sha256_file_path).to receive(:exist?).and_return(false)
-      allow(subject.forge_release).to receive(:respond_to?).and_return(false)
-      allow(subject).to receive(:verify_from_forge)
-      # md5 verification
-      allow(md5_digest_class).to receive(:file).and_return(md5_digest)
-      allow(md5_digest).to receive(:hexdigest).and_return(md5_of_tarball)
-      allow(md5_file_path).to receive(:exist?).and_return(true)
-      expect(subject).to receive(:verify_from_file)
-      subject.verify
-    end
-
-    it "errors when in FIPS mode and no sha256 is available" do
-      expect(R10K::Util::Platform).to receive(:fips?).and_return(true)
-      allow(sha256_digest_class).to receive(:file).and_return(sha256_digest)
-      allow(sha256_digest).to receive(:hexdigest).and_return(sha256_of_tarball)
-      allow(sha256_file_path).to receive(:exist?).and_return(false)
-      allow(subject.forge_release).to receive(:respond_to?).and_return(false)
-      allow(subject).to receive(:verify_from_forge)
-      expect { subject.verify }.to raise_error(R10K::Error)
-    end
-  end
-
-  describe '#verify_from_file' do
-
-    it "does nothing when the checksums match" do
-      expect(File).to receive(:read).with(sha256_file_path).and_return(good_sha256)
-      expect(subject).not_to receive(:cleanup_cached_tarball_path)
-      subject.verify_from_file(sha256_of_tarball, sha256_file_path)
-    end
-
-    it "raises an error and cleans up when the checksums do not match" do
-      expect(File).to receive(:read).with(sha256_file_path).and_return(bad_sha256)
-      expect(tarball_cache_path).to receive(:delete)
-      expect(sha256_file_path).to receive(:delete)
-      expect { subject.verify_from_file(sha256_of_tarball, sha256_file_path) }.to raise_error(PuppetForge::V3::Release::ChecksumMismatch)
-    end
-  end
-
-  describe '#verify_from_forge' do
-    it "write the checksum to file when the checksums match" do
-      expect(tarball_cache_path).not_to receive(:delete)
-      expect(File).to receive(:write).with(sha256_file_path, good_sha256)
-      subject.verify_from_forge(sha256_of_tarball, good_sha256, sha256_file_path)
-    end
-
-    it "raises an error and cleans up when the checksums do not match" do
-      expect(tarball_cache_path).to receive(:delete)
-      expect { subject.verify_from_forge(sha256_of_tarball, bad_sha256, sha256_file_path) }
-        .to raise_error(PuppetForge::V3::Release::ChecksumMismatch)
-    end
-  end
-
-  describe '#unpack' do
-    it "unpacks the module tarball in `tarball_cache_path` into the provided target path" do
-      expect(PuppetForge::Unpacker).to receive(:unpack).with(tarball_cache_path.to_s, target_dir.to_s, unpack_path.to_s).\
-          and_return({:valid=>["extractedmodule/metadata.json"], :invalid=>[], :symlinks=>[]})
-      subject.unpack(target_dir)
-    end
-
-    it "logs a warning if symlinks are present during the unpacking process" do
-      logger_dbl = double(Log4r::Logger, debug1: true, debug2: true)
-      allow(subject).to receive(:logger).and_return(logger_dbl)
-      allow(PuppetForge::Unpacker).to receive(:unpack).and_return(file_lists)
-
-      expect(logger_dbl).to receive(:warn).with(/symlinks are unsupported.*#{Regexp.escape(subject.forge_release.slug)}/i)
-
-      subject.unpack(target_dir)
-    end
-  end
-
-  describe "#cleanup" do
-    it "cleans up the unpack paths" do
-      expect(subject).to receive(:cleanup_unpack_path)
-      expect(subject).to receive(:cleanup_download_path)
-      subject.cleanup
-    end
-  end
-
-  describe "#cleanup_unpack_path" do
-    it "ignores the unpack_path if the parent doesn't exist" do
-      parent = instance_double('Pathname')
-      expect(parent).to receive(:exist?).and_return false
-      expect(parent).to_not receive(:rmtree)
-      expect(unpack_path).to receive(:parent).and_return(parent)
-      subject.cleanup_unpack_path
-    end
-
-    it "removes the containing directory of unpack_path if it exists" do
-      parent = instance_double('Pathname')
-      expect(parent).to receive(:rmtree)
-      expect(parent).to receive(:exist?).and_return true
-      expect(unpack_path).to receive(:parent).and_return(parent).exactly(2).times
-      subject.cleanup_unpack_path
-    end
-  end
-
-  describe "#cleanup_download_path" do
-    it "ignores the download_path if the parent doesn't exist" do
-      parent = instance_double('Pathname')
-      expect(parent).to receive(:exist?).and_return false
-      expect(parent).to_not receive(:rmtree)
-      expect(download_path).to receive(:parent).and_return(parent)
-      subject.cleanup_download_path
-    end
-
-    it "removes the containing directory of download_path if it exists" do
-      parent = instance_double('Pathname')
-      expect(parent).to receive(:rmtree)
-      expect(parent).to receive(:exist?).and_return true
-      expect(download_path).to receive(:parent).and_return(parent).exactly(2).times
-      subject.cleanup_download_path
-    end
-  end
-
-  describe '#install' do
-    it "performs all steps needed to install the module" do
-      expect(subject).to receive(:download)
-      expect(subject).to receive(:verify)
-      expect(subject).to receive(:unpack).with(target_dir)
-      expect(subject).to receive(:cleanup)
-      subject.install(target_dir)
-    end
-  end
-end