r10k 3.15.0 → 4.1.0

data/spec/unit/deployment_spec.rb

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

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

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

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

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

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