r10k 3.5.2

data/spec/unit/action/visitor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'r10k/action/visitor'
+require 'r10k/logging'
+
+describe R10K::Action::Visitor do
+  let(:visitor_class) do
+    Class.new do
+      include R10K::Action::Visitor
+      include R10K::Logging
+      attr_accessor :trace
+
+      def visit_error(other)
+        raise ArgumentError, "no soup for you"
+      end
+    end
+  end
+
+  subject { visitor_class.new }
+
+  it "dispatches visit invocations to the type specific method" do
+    expect(subject).to receive(:visit_sym).with(:hi)
+    subject.visit(:sym, :hi)
+  end
+
+  describe "when a visit_ method raises an error" do
+
+    [true, false].each do |trace|
+      msg = trace ? "a" : "no"
+      it "logs the error with #{msg} backtrace when trace is #{trace}" do
+        subject.trace = trace
+        expect(R10K::Errors::Formatting).to(
+          receive(:format_exception).with(instance_of(ArgumentError), trace)
+        ).and_return("errmsg")
+        expect(subject.logger).to receive(:error).with('errmsg')
+        subject.visit(:error, :hi)
+      end
+    end
+  end
+end

data/spec/unit/cli_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe 'basic cli sanity check' do
+  it 'can load the R10K::CLI namespace' do
+    expect {
+      require 'r10k/cli'
+    }.not_to raise_exception
+  end
+end

data/spec/unit/deployment/config_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe R10K::Deployment::Config do
+  let(:loader) { instance_double('R10K::Settings::Loader') }
+  let(:initializer) { instance_double('R10K::Initializers::GlobalInitializer') }
+
+  describe "applying global settings" do
+    before do
+      expect(R10K::Settings::Loader).to receive(:new).and_return(loader)
+      expect(R10K::Initializers::GlobalInitializer).to receive(:new).and_return(initializer)
+    end
+
+    it 'runs application initialization' do
+      config = instance_double('Hash')
+      allow(loader).to receive(:read).and_return({})
+      expect(initializer).to receive(:call)
+      described_class.new('some/path')
+    end
+  end
+
+  describe "overriding settings" do
+    before do
+      expect(R10K::Settings::Loader).to receive(:new).and_return(loader)
+    end
+
+    it 'allows settings from config to be overridden' do
+      allow(loader).to receive(:read).and_return({:cachedir => 'fromfile'})
+      expect(R10K::Initializers::GlobalInitializer).to receive(:new).with(hash_including(:cachedir => 'fromoverride')).and_return(initializer)
+      expect(initializer).to receive(:call)
+      described_class.new('some/path', {:cachedir => 'fromoverride'})
+    end
+  end
+end

data/spec/unit/deployment_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'r10k/deployment'
+require 'tmpdir'
+
+describe R10K::Deployment do
+
+  let(:confdir) { Dir.mktmpdir }
+
+  let(:config) do
+    R10K::Deployment::MockConfig.new(
+      :sources => {
+        :control => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'environments'),
+          :environments => %w[first second third],
+        },
+        :hiera => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'hiera'),
+          :environments => %w[fourth fifth sixth],
+        }
+      }
+    )
+  end
+
+  subject(:deployment) { described_class.new(config) }
+
+  let(:control) { deployment.sources.find { |source| source.name == :control } }
+  let(:hiera)   { deployment.sources.find { |source| source.name == :hiera } }
+
+  describe "loading" do
+    describe "sources" do
+      it "creates a source for each key in the ':sources' config entry" do
+        expect(control.basedir).to eq(File.join(confdir, 'environments'))
+        expect(hiera.basedir).to eq(File.join(confdir, 'hiera'))
+      end
+    end
+
+    describe "loading environments" do
+      it "loads environments from each source" do
+        %w[first second third fourth fifth sixth].each do |env|
+          expect(deployment.environments.map(&:name)).to include(env)
+        end
+      end
+    end
+  end
+
+  describe "preloading" do
+    it "invokes #preload! on each source" do
+      deployment.sources.each do |source|
+        expect(source).to receive(:preload!)
+      end
+      deployment.preload!
+    end
+  end
+
+  describe "paths" do
+    it "retrieves the path for each source" do
+      expect(deployment.paths).to include(File.join(confdir, 'environments'))
+      expect(deployment.paths).to include(File.join(confdir, 'hiera'))
+    end
+  end
+
+  describe "paths and sources" do
+    it "retrieves the path for each source" do
+      p_a_s = deployment.paths_and_sources
+
+      expect(p_a_s[File.join(confdir, 'environments')]).to eq([control])
+      expect(p_a_s[File.join(confdir, 'hiera')]).to eq([hiera])
+    end
+  end
+
+  describe "purging" do
+    it "purges each managed directory" do
+      env_basedir = double("basedir environments")
+      hiera_basedir = double("basedir hiera")
+
+      expect(env_basedir).to receive(:purge!)
+      expect(hiera_basedir).to receive(:purge!)
+
+      expect(R10K::Util::Basedir).to receive(:new).with(File.join(confdir, 'environments'), [control]).and_return(env_basedir)
+      expect(R10K::Util::Basedir).to receive(:new).with(File.join(confdir, 'hiera'), [hiera]).and_return(hiera_basedir)
+
+      deployment.purge!
+    end
+  end
+
+  describe "accepting a visitor" do
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:deployment, subject)
+      subject.accept(visitor)
+    end
+
+    it "passes the visitor to each environment if the visitor yields" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit) do |type, other, &block|
+        expect(type).to eq :deployment
+        expect(other).to eq subject
+        block.call
+      end
+
+      source1 = spy('source')
+      expect(source1).to receive(:accept).with(visitor)
+      source2 = spy('source')
+      expect(source2).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:sources).and_return([source1, source2])
+      subject.accept(visitor)
+    end
+  end
+end
+
+describe R10K::Deployment, "with environment collisions" do
+
+  let(:confdir) { Dir.mktmpdir }
+
+  let(:config) do
+    R10K::Deployment::MockConfig.new(
+      :sources => {
+        :s1 => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'environments'),
+          :environments => %w[first second third],
+        },
+        :s2 => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'environments'),
+          :environments => %w[third fourth fifth],
+        }
+      }
+    )
+  end
+
+  subject(:deployment) { described_class.new(config) }
+
+  it "raises an error when validating" do
+    expect {
+      deployment.validate!
+    }.to raise_error(R10K::Error, /Environment collision at .* between s\d:third and s\d:third/)
+  end
+end
+
+describe R10K::Deployment, "checking the 'sources' key" do
+
+  {
+    "when missing" => {},
+    "when empty" => {:sources => []},
+  }.each_pair do |desc, config_hash|
+    describe desc do
+
+      let(:config) { R10K::Deployment::MockConfig.new(config_hash) }
+      subject(:deployment) { described_class.new(config) }
+
+      it "raises an error when enumerating sources" do
+        expect {
+          deployment.sources
+        }.to raise_error(R10K::Error, "Unable to load sources; the supplied configuration does not define the 'sources' key")
+      end
+    end
+  end
+end

data/spec/unit/environment/base_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Base do
+
+  subject(:environment) { described_class.new('envname', '/some/imaginary/path', 'env_name', {}) }
+
+  it "can return the fully qualified path" do
+    expect(environment.path).to eq(Pathname.new('/some/imaginary/path/env_name'))
+  end
+
+  it "raises an exception when #sync is called" do
+    expect { environment.sync }.to raise_error(NotImplementedError)
+  end
+
+  describe "accepting a visitor" do
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:environment, subject)
+      subject.accept(visitor)
+    end
+
+    it "passes the visitor to the puppetfile if the visitor yields" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit) do |type, other, &block|
+        expect(type).to eq :environment
+        expect(other).to eq subject
+        block.call
+      end
+
+      pf = spy('puppetfile')
+      expect(pf).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:puppetfile).and_return(pf)
+      subject.accept(visitor)
+    end
+  end
+
+  describe "#whitelist" do
+    let(:whitelist) do
+      ['**/*.xpp', 'custom', '*.tmp']
+    end
+
+    it "combines given patterns with full_path to env" do
+      expect(subject.whitelist(whitelist)).to all(start_with(subject.path.to_s))
+    end
+  end
+
+  describe "#purge_exclusions" do
+    let(:mock_env) { instance_double("R10K::Environment::Base") }
+    let(:mock_puppetfile) { instance_double("R10K::Puppetfile", :environment= => true, :environment => mock_env) }
+
+    before(:each) do
+      allow(mock_puppetfile).to receive(:managed_directories).and_return([])
+      allow(mock_puppetfile).to receive(:desired_contents).and_return([])
+      allow(R10K::Puppetfile).to receive(:new).and_return(mock_puppetfile)
+    end
+
+    it "excludes .r10k-deploy.json" do
+      expect(subject.purge_exclusions).to include(/r10k-deploy\.json/)
+    end
+
+    it "excludes puppetfile managed directories" do
+      managed_dirs = [
+        '/some/imaginary/path/env_name/modules',
+        '/some/imaginary/path/env_name/data',
+      ]
+
+      expect(mock_puppetfile).to receive(:managed_directories).and_return(managed_dirs)
+
+      exclusions = subject.purge_exclusions
+
+      managed_dirs.each do |dir|
+        expect(exclusions).to include(dir)
+      end
+    end
+
+    describe "puppetfile desired contents" do
+      let(:desired_contents) do
+        basedir = subject.path.to_s
+
+        [ 'modules/apache', 'data/local/site' ].collect do |c|
+          File.join(basedir, c)
+        end
+      end
+
+      before(:each) do
+        allow(File).to receive(:directory?).with(/^\/some\/imaginary\/path/).and_return(true)
+
+        expect(mock_puppetfile).to receive(:desired_contents).and_return(desired_contents)
+      end
+
+      it "excludes desired directory contents with glob" do
+        exclusions = subject.purge_exclusions
+
+        expect(exclusions).to include(/#{Regexp.escape(File.join('apache', '**', '*'))}$/)
+        expect(exclusions).to include(/#{Regexp.escape(File.join('site', '**', '*'))}$/)
+      end
+
+      it "excludes ancestors of desired directories" do
+        exclusions = subject.purge_exclusions
+
+        expect(exclusions).to include(/modules$/)
+        expect(exclusions).to include(/data\/local$/)
+        expect(exclusions).to include(/data$/)
+      end
+    end
+  end
+end

data/spec/unit/environment/git_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Git do
+
+  subject do
+    described_class.new(
+      'myenv',
+      '/some/nonexistent/environmentdir',
+      'gitref',
+      {
+        :remote => 'git://git-server.site/my-repo.git',
+        :ref    => 'd026ea677116424d2968edb9cee8cbc24d09322b',
+      }
+    )
+  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 'gitref'
+    end
+
+    it "can return the environment remote" do
+      expect(subject.remote).to eq 'git://git-server.site/my-repo.git'
+    end
+
+    it "can return the environment ref" do
+      expect(subject.ref).to eq 'd026ea677116424d2968edb9cee8cbc24d09322b'
+    end
+  end
+
+  describe "synchronizing the environment" do
+    it "syncs the git repository" do
+      expect(subject.repo).to receive(:sync)
+      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/gitref'
+    end
+
+    it "sets the moduledir to 'modules' relative to the environment path" do
+      expect(puppetfile.moduledir).to eq '/some/nonexistent/environmentdir/gitref/modules'
+    end
+
+    it "sets the puppetfile path to 'Puppetfile' relative to the environment path" do
+      expect(puppetfile.puppetfile_path).to eq '/some/nonexistent/environmentdir/gitref/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 "delegates to the repo" do
+      expect(subject.repo).to receive(:status).and_return :some_status
+      expect(subject.status).to eq :some_status
+    end
+  end
+
+  describe "environment signature" do
+    it "returns the git sha of HEAD" do
+      expect(subject.repo).to receive(:head).and_return 'f00b00'
+      expect(subject.signature).to eq 'f00b00'
+    end
+  end
+
+  describe "info hash" do
+    let(:info_hash) { subject.info }
+
+    before(:each) do
+      allow(subject.repo).to receive(:head).and_return 'f00b00'
+    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