akerl-r10k 3.14.2.1

data/spec/integration/git/stateful_repository_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'r10k/git'
+require 'r10k/git/stateful_repository'
+
+describe R10K::Git::StatefulRepository do
+  include_context 'Git integration'
+
+  let(:dirname) { 'working-repo' }
+
+  let(:cacherepo) { R10K::Git.cache.generate(remote) }
+  let(:thinrepo) { R10K::Git.thin_repository.new(basedir, dirname, cacherepo) }
+  let(:ref) { '0.9.x' }
+
+  subject { described_class.new(remote, basedir, dirname) }
+
+  describe 'status' do
+    describe "when the directory does not exist" do
+      it "is absent" do
+        expect(subject.status(ref)).to eq :absent
+      end
+    end
+
+    describe "when the directory is not a git repository" do
+      it "is mismatched" do
+        thinrepo.path.mkdir
+        expect(subject.status(ref)).to eq :mismatched
+      end
+    end
+
+    describe "when the directory has a .git file" do
+      it "is mismatched" do
+        thinrepo.path.mkdir
+        File.open("#{thinrepo.path}/.git", "w") {}
+        expect(subject.status(ref)).to eq :mismatched
+      end
+    end
+
+    describe "when the repository doesn't match the desired remote" do
+      it "is mismatched" do
+        thinrepo.clone(remote, {:ref => '1.0.0'})
+        allow(subject.repo).to receive(:origin).and_return('http://some.site/repo.git')
+        expect(subject.status(ref)).to eq :mismatched
+      end
+    end
+
+    describe "when the wrong ref is checked out" do
+      it "is outdated" do
+        thinrepo.clone(remote, {:ref => '1.0.0'})
+        expect(subject.status(ref)).to eq :outdated
+      end
+    end
+
+    describe "when the ref is a branch and the cache is not synced" do
+      it "is outdated" do
+        thinrepo.clone(remote, {:ref => ref})
+        cacherepo.reset!
+        expect(subject.status(ref)).to eq :outdated
+      end
+    end
+
+    describe "when the ref can't be resolved" do
+      let(:ref) { '1.1.x' }
+
+      it "is outdated" do
+        thinrepo.clone(remote, {:ref => '0.9.x'})
+        expect(subject.status(ref)).to eq :outdated
+      end
+    end
+
+    describe "when the workdir has local modifications" do
+      it "is dirty when workdir is up to date" do
+        thinrepo.clone(remote, {:ref => ref})
+        File.open(File.join(thinrepo.path, 'README.markdown'), 'a') { |f| f.write('local modifications!') }
+
+        expect(subject.status(ref)).to eq :dirty
+      end
+
+      it "is dirty when workdir is not up to date" do
+        thinrepo.clone(remote, {:ref => '1.0.0'})
+        File.open(File.join(thinrepo.path, 'README.markdown'), 'a') { |f| f.write('local modifications!') }
+
+        expect(subject.status(ref)).to eq :dirty
+      end
+    end
+
+    describe "when the workdir has spec dir modifications" do
+      before(:each) do
+        thinrepo.clone(remote, {:ref => ref})
+        FileUtils.mkdir_p(File.join(thinrepo.path, 'spec'))
+        File.open(File.join(thinrepo.path, 'spec', 'file_spec.rb'), 'a') { |f| f.write('local modifications!') }
+        thinrepo.stage_files(['spec/file_spec.rb'])
+      end
+      it "is dirty with exclude_spec false" do
+        expect(subject.status(ref, false)).to eq :dirty
+      end
+
+      it "is insync with exclude_spec true" do
+        expect(subject.status(ref, true)).to eq :insync
+      end
+    end
+
+    describe "if the right ref is checked out" do
+      it "is insync" do
+        thinrepo.clone(remote, {:ref => ref})
+        expect(subject.status(ref)).to eq :insync
+      end
+    end
+  end
+
+  describe "syncing" do
+    describe "when the ref is unresolvable" do
+      let(:ref) { '1.1.x' }
+
+      it "raises an error" do
+        expect {
+          subject.sync(ref)
+        }.to raise_error(R10K::Git::UnresolvableRefError)
+      end
+    end
+
+    describe "when the repo is absent" do
+      it "creates the repo" do
+        subject.sync(ref)
+        expect(subject.status(ref)).to eq :insync
+      end
+    end
+
+    describe "when the repo is mismatched" do
+      it "removes and recreates the repo" do
+        thinrepo.path.mkdir
+        subject.sync(ref)
+        expect(subject.status(ref)).to eq :insync
+      end
+    end
+
+    describe "when the repo is out of date" do
+      it "updates the repository" do
+        thinrepo.clone(remote, {:ref => '1.0.0'})
+        subject.sync(ref)
+        expect(subject.status(ref)).to eq :insync
+      end
+    end
+
+    describe "when the workdir is dirty" do
+      before(:each) do
+        thinrepo.clone(remote, {:ref => ref})
+        File.open(File.join(thinrepo.path, 'README.markdown'), 'a') { |f| f.write('local modifications!') }
+      end
+
+      context "when force == true" do
+        let(:force) { true }
+
+        it "warns and overwrites local modifications" do
+          expect(subject.logger).to receive(:warn).with(/overwriting local modifications/i)
+
+          subject.sync(ref, force)
+
+          expect(subject.status(ref)).to eq :insync
+        end
+      end
+
+      context "when force != true" do
+        let(:force) { false }
+
+        it "warns and does not overwrite local modifications" do
+          expect(subject.logger).to receive(:warn).with(/skipping.*due to local modifications/i)
+
+          subject.sync(ref, force)
+
+          expect(subject.status(ref)).to eq :dirty
+        end
+      end
+    end
+  end
+end

data/spec/integration/util/purageable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'r10k/util/purgeable'
+require 'r10k/util/cleaner'
+
+require 'tmpdir'
+
+RSpec.describe R10K::Util::Purgeable do
+  it 'purges only unmanaged files' do
+    Dir.mktmpdir do |envdir|
+      managed_directory = "#{envdir}/managed_one"
+      desired_contents = [
+        "#{managed_directory}/expected_1",
+        "#{managed_directory}/managed_subdir_1",
+        "#{managed_directory}/managed_symlink_dir",
+        "#{managed_directory}/managed_subdir_1/subdir_expected_1",
+        "#{managed_directory}/managed_subdir_1/managed_symlink_file",
+      ]
+
+      FileUtils.cp_r('spec/fixtures/unit/util/purgeable/managed_one/',
+                     managed_directory)
+
+      cleaner = R10K::Util::Cleaner.new([managed_directory], desired_contents)
+
+      cleaner.purge!({ recurse: true, whitelist: ["**/subdir_allowlisted_2"] })
+
+      # Files present after purge
+      expect(File.exist?("#{managed_directory}/expected_1")).to be true
+      expect(File.exist?("#{managed_directory}/managed_subdir_1")).to be true
+      expect(File.exist?("#{managed_directory}/managed_symlink_dir")).to be true
+      expect(File.exist?("#{managed_directory}/managed_subdir_1/subdir_expected_1")).to be true
+      expect(File.exist?("#{managed_directory}/managed_subdir_1/managed_symlink_file")).to be true
+      expect(File.exist?("#{managed_directory}/managed_subdir_1/subdir_allowlisted_2")).to be true
+
+      # Purged files
+      expect(File.exist?("#{managed_directory}/unmanaged_1")).to be false
+      expect(File.exist?("#{managed_directory}/managed_subdir_1/unmanaged_symlink_dir")).to be false
+      expect(File.exist?("#{managed_directory}/unmanaged_symlink_file")).to be false
+      expect(File.exist?("#{managed_directory}/managed_subdir_1/subdir_unmanaged_1")).to be false
+    end
+  end
+end

data/spec/matchers/exit_with.rb

@@ -0,0 +1,28 @@
+RSpec::Matchers.define :exit_with do |expected|
+
+  supports_block_expectations
+
+  match do |block|
+    actual = nil
+    begin
+      block.call
+    rescue SystemExit => e
+      actual = e.status
+    end
+    actual and actual == expected
+  end
+
+  failure_message do |actual|
+    "expected exit with code #{expected} but " +
+      (actual.nil? ? " exit was not called" : "we exited with #{actual} instead")
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that exit would not be called with #{expected}"
+  end
+
+  description do
+    "expect exit with #{expected}"
+  end
+end
+

data/spec/matchers/match_realpath.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :match_realpath do |expected|
+
+  match do |actual|
+    actual == expected || realpath(actual) == realpath(expected)
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would have a real path of #{expected}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not have a real path of #{expected}"
+  end
+
+  def realpath(path)
+    Pathname.new(path).realpath.to_s
+  end
+end

data/spec/r10k-mocks/mock_config.rb

@@ -0,0 +1,33 @@
+require 'r10k/deployment/config'
+
+module R10K
+  class Deployment
+    class MockConfig
+
+      attr_accessor :hash
+
+      def initialize(hash)
+        @hash = hash.merge(deploy: {})
+      end
+
+      def configfile
+        "/some/nonexistent/config_file"
+      end
+
+      # Perform a scan for key and check for both string and symbol keys
+      def setting(key)
+        @hash[key]
+      end
+
+      alias [] setting
+
+      def settings
+        @hash
+      end
+
+      def merge(other)
+        hash.merge(other)
+      end
+    end
+  end
+end

data/spec/r10k-mocks/mock_env.rb

@@ -0,0 +1,18 @@
+require 'r10k/environment'
+require 'r10k/util/purgeable'
+
+class R10K::Environment::Mock < R10K::Environment::Base
+  include R10K::Util::Purgeable
+
+  def sync
+    "synced"
+  end
+
+  def status
+    :insync
+  end
+
+  def signature
+    "mock"
+  end
+end

data/spec/r10k-mocks/mock_source.rb

@@ -0,0 +1,17 @@
+require 'r10k/source'
+require 'r10k-mocks/mock_env'
+
+class R10K::Source::Mock < R10K::Source::Base
+  R10K::Source.register(:mock, self)
+
+  def environments
+    if @_environments.nil?
+      corrected_environment_names = @options[:environments].map do |env|
+        R10K::Environment::Name.new(env, :prefix => @prefix, :invalid => 'correct_and_warn')
+      end
+      @_environments = corrected_environment_names.map { |env| R10K::Environment::Mock.new(env.name, @basedir, env.dirname, { overrides: @options[:overrides] }) }
+    end
+
+    @_environments
+  end
+end

data/spec/r10k-mocks.rb

@@ -0,0 +1,3 @@
+require 'r10k-mocks/mock_env'
+require 'r10k-mocks/mock_source'
+require 'r10k-mocks/mock_config'

data/spec/shared-contexts/git-fixtures.rb

@@ -0,0 +1,55 @@
+require 'archive/tar/minitar'
+require 'tmpdir'
+
+shared_context "Git integration" do
+
+  # Use tmpdir for cached git repositories
+
+  before(:all) do
+    @old_cache_root = R10K::Git::Cache.settings[:cache_root]
+    R10K::Git::Cache.settings[:cache_root] = Dir.mktmpdir
+  end
+
+  after(:all) do
+    FileUtils.remove_entry_secure(R10K::Git::Cache.settings[:cache_root])
+    R10K::Git::Cache.settings[:cache_root] = @old_cache_root
+  end
+
+  # Create a mutable path for remote repositories
+
+  def fixture_path
+    File.join(PROJECT_ROOT, 'spec', 'fixtures', 'integration', 'git')
+  end
+
+  def remote_path
+    @remote_path
+  end
+
+  def populate_remote_path
+    Archive::Tar::Minitar.unpack(File.join(fixture_path, 'puppet-boolean-bare.tar'), remote_path)
+  end
+
+  def clear_remote_path
+    FileUtils.remove_entry_secure(remote_path)
+  end
+
+  before(:all) do
+    @remote_path = Dir.mktmpdir
+    populate_remote_path
+  end
+
+  after(:all) do
+    clear_remote_path
+    @remote_path = nil
+  end
+
+  let(:remote) { Pathname.new(File.join(remote_path, 'puppet-boolean.git')).realpath.to_s }
+
+  # Create a temp path for the git basedir and clean it up when finished
+
+  let(:basedir) { Dir.mktmpdir }
+
+  after do
+    FileUtils.remove_entry_secure(basedir)
+  end
+end

data/spec/shared-contexts/tarball.rb

@@ -0,0 +1,32 @@
+require 'tmpdir'
+require 'fileutils'
+
+shared_context "Tarball" do
+  # Suggested subject:
+  #
+  #   subject { described_class.new('fixture-tarball', fixture_tarball, checksum: fixture_checksum) }
+  #
+  let(:fixture_tarball) do
+    File.expand_path('spec/fixtures/tarball/tarball.tar.gz', PROJECT_ROOT)
+  end
+
+  let(:fixture_checksum) { '292e692ad18faabd4f9b21037d51f0185e04b69f82c522a54af91fb5b88c2d3b' }
+
+  # Use tmpdir for cached tarballs
+  let(:tmpdir) { Dir.mktmpdir }
+
+  # `moduledir` and `cache_root` are available for examples to use in creating
+  # their subjects
+  let(:moduledir) { File.join(tmpdir, 'modules').tap { |path| Dir.mkdir(path) } }
+  let(:cache_root) { File.join(tmpdir, 'cache').tap { |path| Dir.mkdir(path) } }
+
+  around(:each) do |example|
+    if subject.is_a?(R10K::Tarball)
+      subject.settings[:cache_root] = cache_root
+    elsif subject.respond_to?(:tarball) && subject.tarball.is_a?(R10K::Tarball)
+      subject.tarball.settings[:cache_root] = cache_root
+    end
+    example.run
+    FileUtils.remove_entry_secure(tmpdir)
+  end
+end

data/spec/shared-examples/deploy-actions.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+require 'r10k/deployment'
+
+shared_examples_for "a deploy action that requires a config file" do
+  let(:config) do
+    R10K::Deployment::MockConfig.new(
+      :sources => {
+        :control => {
+          :type => :mock,
+          :basedir => '/some/nonexistent/path/control',
+          :environments => %w[first second third],
+        },
+        :hiera => {
+          :type => :mock,
+          :basedir => '/some/nonexistent/path/hiera',
+          :environments => %w[fourth fifth sixth],
+        }
+      }
+    )
+  end
+
+  let(:deployment) { R10K::Deployment.new(config) }
+
+  before do
+    allow(R10K::Deployment).to receive(:new).and_return(deployment)
+  end
+
+  it "exits when no config file was provided or found" do
+    subject.instance_variable_set(:@config, nil)
+    expect {
+      subject.call
+    }.to exit_with(8)
+  end
+end
+
+shared_examples_for "a deploy action that can be write locked" do
+
+  let(:config) do
+    R10K::Deployment::MockConfig.new(
+      :sources => {
+        :control => {
+          :type => :mock,
+          :basedir => '/some/nonexistent/path/control',
+          :environments => %w[first second third],
+        },
+        :hiera => {
+          :type => :mock,
+          :basedir => '/some/nonexistent/path/hiera',
+          :environments => %w[fourth fifth sixth],
+        }
+      }
+    )
+  end
+
+  let(:deployment) { R10K::Deployment.new(config) }
+
+  before do
+    allow(R10K::Deployment).to receive(:new).and_return(deployment)
+    subject.settings = {deploy: {write_lock: "Disabled, yo"}}
+  end
+
+  it "exits without running when the write lock is set" do
+    expect(subject).to_not receive(:visit_deployment)
+    expect {
+      subject.call
+    }.to exit_with(16)
+  end
+end

data/spec/shared-examples/git/bare_repository.rb

@@ -0,0 +1,132 @@
+RSpec.shared_examples "a git bare repository" do
+
+  describe "checking for the presence of the repo" do
+    it "exists if the repo is present" do
+      subject.clone(remote)
+      expect(subject.exist?).to be_truthy
+    end
+
+    it "doesn't exist if the repo is not present" do
+      expect(subject.exist?).to be_falsey
+    end
+  end
+
+  describe "cloning the repo" do
+    it "creates the repo at the expected location" do
+      subject.clone(remote)
+      config = File.read(File.join(basedir, dirname, 'config'))
+      expect(config).to match(remote)
+    end
+
+    context "without a proxy" do
+      before(:each) do
+        allow(R10K::Git).to receive(:get_proxy_for_remote).with(remote).and_return(nil)
+      end
+
+      it 'does not change proxy ENV' do
+        expect(ENV).to_not receive(:[]=)
+        expect(ENV).to_not receive(:update)
+
+        subject.clone(remote)
+      end
+    end
+
+    context "with a proxy" do
+      before(:each) do
+        allow(R10K::Git).to receive(:get_proxy_for_remote).with(remote).and_return('http://proxy.example.com:3128')
+      end
+
+      it "manages proxy-related ENV vars" do
+        # Sets proxy settings.
+        ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy'].each do |var|
+          expect(ENV).to receive(:[]=).with(var, 'http://proxy.example.com:3128')
+        end
+
+        # Resets proxy settings when done.
+        expect(ENV).to receive(:update).with(hash_including('HTTPS_PROXY' => nil))
+
+        subject.clone(remote)
+      end
+    end
+  end
+
+  describe "updating the repo" do
+    let(:tag_090) { subject.git_dir + 'refs' + 'tags' + '0.9.0' }
+    let(:packed_refs) { subject.git_dir + 'packed-refs' }
+
+    before do
+      subject.clone(remote)
+      tag_090.delete if tag_090.exist?
+      packed_refs.delete if packed_refs.exist?
+    end
+
+    it "fetches objects from the remote" do
+      expect(subject.tags).to_not include('0.9.0')
+      subject.fetch
+      expect(subject.tags).to include('0.9.0')
+    end
+
+    context "without a proxy" do
+      before(:each) do
+        allow(R10K::Git).to receive(:get_proxy_for_remote).with(remote).and_return(nil)
+      end
+
+      it 'does not change proxy ENV' do
+        expect(ENV).to_not receive(:[]=)
+        expect(ENV).to_not receive(:update)
+
+        subject.fetch
+      end
+    end
+
+    context "with a proxy" do
+      before(:each) do
+        allow(R10K::Git).to receive(:get_proxy_for_remote).with(remote).and_return('http://proxy.example.com:3128')
+      end
+
+      it "manages proxy-related ENV vars" do
+        # Sets proxy settings.
+        ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy'].each do |var|
+          expect(ENV).to receive(:[]=).with(var, 'http://proxy.example.com:3128')
+        end
+
+        # Resets proxy settings when done.
+        expect(ENV).to receive(:update).with(hash_including('HTTPS_PROXY' => nil))
+
+        subject.fetch
+      end
+    end
+  end
+
+  describe "listing branches" do
+    before do
+      subject.clone(remote)
+    end
+
+    it "lists all branches in alphabetical order" do
+      expect(subject.branches).to eq(%w[0.9.x master])
+    end
+  end
+
+  describe "determining ref type" do
+    before do
+      subject.clone(remote)
+    end
+
+    it "can infer the type of a branch ref" do
+      expect(subject.ref_type('master')).to eq :branch
+    end
+
+    it "can infer the type of a tag ref" do
+      expect(subject.ref_type('1.0.0')).to eq :tag
+    end
+
+    it "can infer the type of a commit" do
+      expect(subject.ref_type('3084373e8d181cf2fea5b4ade2690ba22872bd67')).to eq :commit
+    end
+
+    it "returns :unknown when the type cannot be inferred" do
+      expect(subject.ref_type('1.2.3')).to eq :unknown
+    end
+  end
+end

data/spec/shared-examples/git/thin_repository.rb

@@ -0,0 +1,26 @@
+RSpec.shared_examples "a git thin repository" do
+  describe "cloning" do
+    it "creates a working copy of the repo" do
+      subject.clone(remote)
+      expect(subject.exist?).to be_truthy
+    end
+
+    it "sets the remote origin url to the provided url" do
+      subject.clone(remote)
+      expect(subject.origin).to eq remote
+    end
+
+    it "sets the remote cache url to the path to the cache repo" do
+      subject.clone(remote)
+      expect(subject.cache).to eq cacherepo.git_dir.to_s
+    end
+
+    it "adds the cache repo to the alternates file" do
+      subject.clone(remote)
+      objectpath = cacherepo.git_dir + 'objects'
+      alternates = subject.alternates.to_a
+      expect(alternates.size).to eq 1
+      expect(alternates[0]).to match_realpath objectpath
+    end
+  end
+end