r10k 3.5.2

data/spec/unit/environment/name_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require 'r10k/environment/name'
+
+describe R10K::Environment::Name do
+  describe "prefixing" do
+    it "uses the branch name as the dirname when prefixing is off" do
+      bn = described_class.new('mybranch', :source => 'source', :prefix => false)
+      expect(bn.dirname).to eq 'mybranch'
+    end
+
+    it "prepends the source name when prefixing is on" do
+      bn = described_class.new('mybranch', :source => 'source', :prefix => true)
+      expect(bn.dirname).to eq 'source_mybranch'
+    end
+
+    it "prepends the prefix name when prefixing is overridden" do
+      bn = described_class.new('mybranch', {:prefix => "bar", :sourcename => 'foo'})
+      expect(bn.dirname).to eq 'bar_mybranch'
+    end
+
+    it "uses the branch name as the dirname when prefixing is nil" do
+      bn = described_class.new('mybranch', {:prefix => nil, :sourcename => 'foo'})
+      expect(bn.dirname).to eq 'mybranch'
+    end
+  end
+
+  describe "determining the validate behavior with :invalid" do
+    [
+      ['correct_and_warn', {:validate => true, :correct => true}],
+      ['correct',          {:validate => false, :correct => true}],
+      ['error',            {:validate => true, :correct => false}],
+    ].each do |(setting, outcome)|
+      it "treats #{setting} as #{outcome.inspect}" do
+        bn = described_class.new('mybranch', :source => 'source', :invalid => setting)
+        expect(bn.validate?).to eq outcome[:validate]
+        expect(bn.correct?).to eq outcome[:correct]
+      end
+    end
+  end
+
+  describe "determining if a branch is a valid environment name" do
+    invalid_cases = [
+      'hyphenated-branch',
+      'dotted.branch',
+      'slashed/branch',
+      'at@branch',
+      'http://branch'
+    ]
+
+    valid_cases = [
+      'my_branchname',
+      'my_issue_346',
+    ]
+
+    describe "and validate is false" do
+      invalid_cases.each do |branch|
+        it "is valid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => false})
+          expect(bn).to be_valid
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "is valid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => false})
+          expect(bn).to be_valid
+        end
+      end
+    end
+
+    describe "and validate is true" do
+      invalid_cases.each do |branch|
+        it "is invalid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => true})
+          expect(bn).to_not be_valid
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "is valid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => true})
+          expect(bn).to be_valid
+        end
+      end
+
+    end
+  end
+
+  describe "correcting branch names" do
+    invalid_cases = [
+      'hyphenated-branch',
+      'dotted.branch',
+      'slashed/branch',
+      'at@branch',
+      'http://branch'
+    ]
+
+    valid_cases = [
+      'my_branchname',
+      'my_issue_346',
+    ]
+
+    describe "and correct is false" do
+      invalid_cases.each do |branch|
+        it "doesn't modify #{branch}" do
+          bn = described_class.new(branch.dup, {:correct => false})
+          expect(bn.dirname).to eq branch
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "doesn't modify #{branch}" do
+          bn = described_class.new(branch.dup, {:correct => false})
+          expect(bn.dirname).to eq branch
+        end
+      end
+    end
+
+    describe "and correct is true" do
+      invalid_cases.each do |branch|
+        it "replaces invalid characters in #{branch} with underscores" do
+          bn = described_class.new(branch.dup, {:correct => true})
+          expect(bn.dirname).to eq branch.gsub(/\W/, '_')
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "doesn't modify #{branch}" do
+          bn = described_class.new(branch.dup, {:correct => true})
+          expect(bn.dirname).to eq branch
+        end
+      end
+    end
+  end
+end

data/spec/unit/environment/svn_spec.rb

@@ -0,0 +1,133 @@
+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 "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
+      expect(subject.puppetfile).to receive(:load)
+      expect(subject.puppetfile).to receive(:modules).and_return [:modules]
+      expect(subject.modules).to eq([:modules])
+    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/errors/formatting_spec.rb

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,213 @@
+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