akerl-r10k 3.14.2.1

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/bare_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Bare do
+  it "warns on initialization" do
+    logger_spy = spy('logger')
+    allow_any_instance_of(described_class).to receive(:logger).and_return(logger_spy)
+
+    described_class.new('envname', '/basedir', 'dirname', {})
+
+    expect(logger_spy).to have_received(:warn).with(%r{deprecated.*envname})
+  end
+end

data/spec/unit/environment/base_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Base do
+
+  let(:basepath) { '/some/imaginary/path' }
+  let(:envname) { 'env_name' }
+  let(:path) { File.join(basepath, envname) }
+  subject(:environment) { described_class.new('envname', basepath, envname, {}) }
+
+  it "can return the fully qualified path" do
+    expect(environment.path).to eq(Pathname.new(path))
+  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) }
+    let(:loader) do
+      instance_double("R10K::ModuleLoader::Puppetfile",
+                      :environment= => nil,
+                      :load => { :modules => @modules,
+                                  :managed_directories => @managed_dirs,
+                                  :desired_contents => @desired_contents,
+                                  :purge_exclusions => @purge_ex })
+    end
+
+    before(:each) do
+      @modules = []
+      @managed_dirs = []
+      @desired_contents = []
+      @purge_exclusions = []
+    end
+
+    it "excludes .r10k-deploy.json" do
+      allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+      subject.deploy
+
+      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',
+      ]
+
+      allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+      subject.deploy
+
+      exclusions = subject.purge_exclusions
+
+      @managed_dirs.each do |dir|
+        expect(exclusions).to include(dir)
+      end
+    end
+
+    describe "puppetfile desired contents" do
+
+      before(:each) do
+        @desired_contents = [ 'modules/apache', 'data/local/site' ].collect do |c|
+          File.join(path, c)
+        end
+
+        allow(File).to receive(:directory?).and_return true
+        allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+        subject.deploy
+      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,114 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Git do
+
+  subject do
+    described_class.new(
+      'myenv',
+      '/some/nonexistent/environmentdir',
+      'gitref',
+      {
+        :remote => 'https://git-server.site/my-repo.git',
+        :ref    => 'd026ea677116424d2968edb9cee8cbc24d09322b',
+      }
+    )
+  end
+
+  describe "initializing" do
+    subject do
+      described_class.new('name', '/dir', 'ref', {
+        :remote          => 'url',
+        :ref             => 'value',
+        :puppetfile_name => 'Puppetfile',
+        :moduledir       => 'modules',
+        :modules         => { },
+      })
+    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 'gitref'
+    end
+
+    it "can return the environment remote" do
+      expect(subject.remote).to eq 'https://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
+      loaded = { desired_contents: [], managed_directories: [], 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 "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

data/spec/unit/environment/name_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+require 'r10k/environment/name'
+
+describe R10K::Environment::Name do
+  describe "strip_component" do
+    it "does not modify the given name when no strip_component is given" do
+      bn = described_class.new('myenv', source: 'source', prefix: false)
+      expect(bn.dirname).to eq 'myenv'
+      expect(bn.name).to eq 'myenv'
+      expect(bn.original_name).to eq 'myenv'
+    end
+
+    it "removes the first occurance of a regex match when a regex is given" do
+      bn = described_class.new('myenv', source: 'source', prefix: false, strip_component: '/env/')
+      expect(bn.dirname).to eq 'my'
+      expect(bn.name).to eq 'my'
+      expect(bn.original_name).to eq 'myenv'
+    end
+
+    it "does not modify the given name when there is no regex match" do
+      bn = described_class.new('myenv', source: 'source', prefix: false, strip_component: '/bar/')
+      expect(bn.dirname).to eq 'myenv'
+      expect(bn.name).to eq 'myenv'
+      expect(bn.original_name).to eq 'myenv'
+    end
+
+    it "removes the given name's prefix when it matches strip_component" do
+      bn = described_class.new('env/prod', source: 'source', prefix: false, strip_component: 'env/')
+      expect(bn.dirname).to eq 'prod'
+      expect(bn.name).to eq 'prod'
+      expect(bn.original_name).to eq 'env/prod'
+    end
+
+    it "raises an error when given an integer" do
+      expect {
+        described_class.new('env/prod', source: 'source', prefix: false, strip_component: 4)
+      }.to raise_error(%r{Improper.*"4"})
+    end
+  end
+
+  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'
+      expect(bn.name).to eq 'mybranch'
+      expect(bn.original_name).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'
+      expect(bn.name).to eq 'mybranch'
+      expect(bn.original_name).to eq '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'
+      expect(bn.name).to eq 'mybranch'
+      expect(bn.original_name).to eq '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'
+      expect(bn.name).to eq 'mybranch'
+      expect(bn.original_name).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/, '_')
+          expect(bn.name).to eq branch
+          expect(bn.original_name).to eq branch
+        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/plain_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Plain do
+  it "initializes successfully" do
+    expect(described_class.new('envname', '/basedir', 'dirname', {})).to be_a_kind_of(described_class)
+  end
+end