r10k 3.12.0 → 3.14.1

data/spec/unit/action/runner_spec.rb

@@ -159,10 +159,61 @@ describe R10K::Action::Runner do
   end
 
   describe "configuring logging" do
+    before(:each) do
+      R10K::Logging.outputters.clear
+    end
+
     it "sets the log level if :loglevel is provided" do
       runner = described_class.new({:opts => :yep, :loglevel => 'FATAL'}, %w[args yes], action_class)
-      expect(R10K::Logging).to receive(:level=).with('FATAL')
+      # The settings/overrides system causes the level to be set twice
+      expect(R10K::Logging).to receive(:level=).with('FATAL').twice
+      runner.call
+    end
+
+    # The logging fixture tests require a platform with syslog
+    if !R10K::Util::Platform.windows?
+      it "sets the log level if the logging.level setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        expect(R10K::Logging).to receive(:level=).with('FATAL')
+        runner.call
+      end
+
+      it "sets the outputters if logging.outputs is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml' }, %w[args yes], action_class)
+        expect(R10K::Logging).to receive(:add_outputters).with([
+          { type: 'file', parameters: { filename: 'r10k.log' } },
+          { type: 'syslog' }
+        ])
+        runner.call
+      end
+
+      it "disables the default outputter if the logging.disable_default_stderr setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        expect(R10K::Logging).to receive(:disable_default_stderr=).with(true)
+        runner.call
+      end
+
+      it "adds additional log outputs if the logging.outputs setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        runner.call
+        expect(R10K::Logging.outputters).to_not be_empty
+      end
+
+      it "disables the default output if the logging.disable_default_stderr setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        runner.call
+        expect(runner.logger.outputters).to satisfy { |outputs| outputs.any? { |output| output.is_a?(R10K::Logging::TerminalOutputter) && output.level == Log4r::OFF } }
+      end
+    end
+
+    it "doesn't add additional log outputs if the logging.outputs setting is not provided" do
+      runner.call
+      expect(R10K::Logging.outputters).to be_empty
+    end
+
+    it "includes the default stderr outputter" do
       runner.call
+      expect(runner.logger.outputters).to satisfy { |outputs| outputs.any? { |output| output.is_a? R10K::Logging::TerminalOutputter } }
     end
 
     it "does not modify the loglevel if :loglevel is not provided" do

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

@@ -6,21 +6,29 @@ describe R10K::Environment::Name 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
@@ -34,21 +42,29 @@ describe R10K::Environment::Name 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
 
@@ -149,6 +165,8 @@ describe R10K::Environment::Name do
         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
 

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

data/spec/unit/environment/tarball_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Tarball do
+  let(:tgz_path) do
+    File.expand_path('spec/fixtures/tarball/tarball.tar.gz', PROJECT_ROOT)
+  end
+
+  let(:checksum) { '36afcfc2378b8235902d6e647fce7479da6898354d620388646c595a1155ed67' }
+  let(:base_params) { { source: tgz_path, version: checksum, modules: { } } }
+
+  subject { described_class.new('envname', '/some/imaginary/path', 'dirname', base_params) }
+
+  describe "initializing" do
+    it "accepts valid base class initialization arguments" do
+      expect(subject.name).to eq 'envname'
+    end
+  end
+
+  describe "storing attributes" do
+    it "can return the environment name" do
+      expect(subject.name).to eq 'envname'
+    end
+
+    it "can return the environment basedir" do
+      expect(subject.basedir).to eq '/some/imaginary/path'
+    end
+
+    it "can return the environment dirname" do
+      expect(subject.dirname).to eq 'dirname'
+    end
+
+    it "can return the environment path" do
+      expect(subject.path.to_s).to eq '/some/imaginary/path/dirname'
+    end
+
+    it "can return the environment source" do
+      expect(subject.tarball.source).to eq tgz_path
+    end
+
+    it "can return the environment version" do
+      expect(subject.tarball.checksum).to eq checksum
+    end
+  end
+end

data/spec/unit/environment/with_modules_spec.rb

@@ -8,7 +8,7 @@ describe R10K::Environment::WithModules do
       '/some/nonexistent/environmentdir',
       'prefix_release42',
       {
-        :type             => 'bare',
+        :type             => 'plain',
         :modules          => {
           'puppetlabs-stdlib' => { local: true },
           'puppetlabs-concat' => { local: true },

data/spec/unit/git/cache_spec.rb

@@ -21,7 +21,8 @@ describe R10K::Git::Cache do
     end
   end
 
-  subject { subclass.new('git://some/git/remote') }
+  let(:remote) { 'git://some/git/remote' }
+  subject { subclass.new(remote) }
 
   describe "updating the cache" do
     it "only updates the cache once" do
@@ -62,18 +63,4 @@ describe R10K::Git::Cache do
       subject.cached?
     end
   end
-
-  describe "dirname sanitization" do
-    it 'sanitizes cache directory name' do
-      expect(subject.sanitized_dirname).to eq('git---some-git-remote')
-    end
-
-    context 'with username and password' do
-      subject { subclass.new('https://"user:pa$$w0rd:@some/git/remote') }
-
-      it 'sanitizes cache directory name' do
-        expect(subject.sanitized_dirname).to eq('https---some-git-remote')
-      end
-    end
-  end
 end

data/spec/unit/git/rugged/cache_spec.rb

@@ -26,4 +26,23 @@ describe R10K::Git::Rugged::Cache, :unless => R10K::Util::Platform.jruby? do
       expect(described_class.settings[:cache_root]).to eq '/some/path'
     end
   end
+
+  describe "remote url updates" do
+    before do
+      allow(subject.repo).to receive(:exist?).and_return true
+      allow(subject.repo).to receive(:fetch)
+      allow(subject.repo).to receive(:remotes).and_return({ 'origin' => 'git://some/git/remote' })
+    end
+
+    it "does not update the URLs if they match" do
+      expect(subject.repo).to_not receive(:update_remote)
+      subject.sync!
+    end
+
+    it "updates the remote URL if they do not match" do
+      allow(subject.repo).to receive(:remotes).and_return({ 'origin' => 'foo'})
+      expect(subject.repo).to receive(:update_remote)
+      subject.sync!
+    end
+  end
 end

data/spec/unit/module/forge_spec.rb

@@ -33,21 +33,17 @@ describe R10K::Module::Forge do
 
   describe "implementing the Puppetfile spec" do
     it "should implement 'branan/eight_hundred', '8.0.0'" do
-      expect(described_class).to be_implement('branan/eight_hundred', { version: '8.0.0' })
+      expect(described_class).to be_implement('branan/eight_hundred', { type: 'forge', version: '8.0.0' })
     end
 
     it "should implement 'branan-eight_hundred', '8.0.0'" do
-      expect(described_class).to be_implement('branan-eight_hundred', { version: '8.0.0' })
-    end
-
-    it "should fail with an invalid title" do
-      expect(described_class).to_not be_implement('branan!eight_hundred', { version: '8.0.0' })
+      expect(described_class).to be_implement('branan-eight_hundred', { type: 'forge', version: '8.0.0' })
     end
   end
 
   describe "implementing the standard options interface" do
     it "should implement {type: forge}" do
-      expect(described_class).to be_implement('branan-eight_hundred', {type: 'forge', version: '8.0.0', source: 'not implemented'})
+      expect(described_class).to be_implement('branan-eight_hundred', { type: 'forge', version: '8.0.0', source: 'not implemented' })
     end
   end
 
@@ -71,6 +67,12 @@ describe R10K::Module::Forge do
     end
   end
 
+  describe "invalid attributes" do
+    it "errors on invalid versions" do
+      expect { described_class.new('branan/eight_hundred', '/moduledir', { version: '_8.0.0_' }) }.to raise_error ArgumentError, /version/
+    end
+  end
+
   describe "properties" do
     subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
 

data/spec/unit/module/tarball_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'r10k/module'
+require 'fileutils'
+
+describe R10K::Module::Tarball do
+  include_context 'Tarball'
+
+  let(:base_params) { { type: 'tarball', source: fixture_tarball, version: fixture_checksum } }
+
+  subject do
+    described_class.new(
+      'fixture-tarball',
+      moduledir,
+      base_params,
+    )
+  end
+
+  describe "setting the owner and name" do
+    describe "with a title of 'fixture-tarball'" do
+      it "sets the owner to 'fixture'" do
+        expect(subject.owner).to eq 'fixture'
+      end
+
+      it "sets the name to 'tarball'" do
+        expect(subject.name).to eq 'tarball'
+      end
+
+      it "sets the path to the given moduledir + modname" do
+        expect(subject.path.to_s).to eq(File.join(moduledir, 'tarball'))
+      end
+    end
+  end
+
+  describe "properties" do
+    it "sets the module type to :tarball" do
+      expect(subject.properties).to include(type: :tarball)
+    end
+
+    it "sets the version" do
+      expect(subject.properties).to include(expected: fixture_checksum)
+    end
+  end
+
+  describe 'syncing the module' do
+    it 'defaults to keeping the spec dir' do
+      subject.sync
+      expect(Dir.exist?(File.join(moduledir, 'tarball', 'spec'))).to be(true)
+    end
+  end
+
+  describe "determining the status" do
+    it "delegates to R10K::Tarball" do
+      expect(subject).to receive(:tarball).twice.and_return instance_double('R10K::Tarball', cache_valid?: true, insync?: true)
+      expect(subject).to receive(:path).twice.and_return instance_double('Pathname', exist?: true)
+
+      expect(subject.status).to eq(:insync)
+    end
+  end
+
+  describe "option parsing" do
+    describe "version" do
+      context "when no version is given" do
+        subject { described_class.new('fixture-tarball', moduledir, base_params.reject { |k| k.eql?(:version) }) }
+        it "does not require a version" do
+          expect(subject).to be_kind_of(described_class)
+        end
+      end
+    end
+  end
+end

data/spec/unit/module_loader/puppetfile_spec.rb

@@ -80,7 +80,8 @@ describe R10K::ModuleLoader::Puppetfile do
   describe 'adding modules' do
     let(:basedir) { '/test/basedir' }
 
-    subject { R10K::ModuleLoader::Puppetfile.new(basedir: basedir) }
+    subject { R10K::ModuleLoader::Puppetfile.new(basedir: basedir,
+                                                 overrides: {modules: {exclude_spec: true}}) }
 
     it 'should transform Forge modules with a string arg to have a version key' do
       expect(R10K::Module).to receive(:from_metadata).with('puppet/test_module', subject.moduledir, hash_including(version: '1.2.3'), anything).and_call_original
@@ -94,11 +95,23 @@ describe R10K::ModuleLoader::Puppetfile do
 
       expect {
         subject.add_module('puppet/test_module', '< 1.2.0')
-      }.to raise_error(RuntimeError, /module puppet\/test_module.*doesn't have an implementation/i)
+      }.to raise_error(ArgumentError, /module version .* is not a valid forge module version/i)
 
       expect(subject.modules.collect(&:name)).not_to include('test_module')
     end
 
+    it 'should not modify the overrides when adding modules' do
+      module_opts = { git: 'git@example.com:puppet/test_module.git' }
+      subject.add_module('puppet/test_module', module_opts)
+      expect(subject.instance_variable_get("@overrides")[:modules]).to eq({exclude_spec: true})
+    end
+
+    it 'should read the `exclude_spec` setting in the module definition and override the overrides' do
+      module_opts = { git: 'git@example.com:puppet/test_module.git', exclude_spec: false }
+      subject.add_module('puppet/test_module', module_opts)
+      expect(subject.modules[0].instance_variable_get("@exclude_spec")).to be false
+    end
+
     it 'should set :spec_deletable to true for modules in the basedir' do
       module_opts = { git: 'git@example.com:puppet/test_module.git' }
       subject.add_module('puppet/test_module', module_opts)
@@ -167,6 +180,7 @@ describe R10K::ModuleLoader::Puppetfile do
     it 'should disable and not add modules that conflict with the environment' do
       env = instance_double('R10K::Environment::Base')
       mod = instance_double('R10K::Module::Base', name: 'conflict', origin: :puppetfile, 'origin=': nil)
+      allow(env).to receive(:name).and_return('conflict')
       loader = R10K::ModuleLoader::Puppetfile.new(basedir: basedir, environment: env)
       allow(env).to receive(:'module_conflicts?').with(mod).and_return(true)
       allow(mod).to receive(:spec_deletable=)
@@ -187,7 +201,9 @@ describe R10K::ModuleLoader::Puppetfile do
     context 'when belonging to an environment' do
       let(:env_contents) { ['env1', 'env2' ] }
       let(:env) { double(:environment, desired_contents: env_contents) }
-
+      before {
+        allow(env).to receive(:name).and_return('env1')
+      }
       subject { R10K::ModuleLoader::Puppetfile.new(basedir: '/test/basedir', environment: env) }
 
       it "includes environment's desired_contents" do
@@ -366,6 +382,7 @@ describe R10K::ModuleLoader::Puppetfile do
         expect(metadata['baz']).to eq('123abc456')
         expect(metadata['fizz']).to eq('1234567890abcdef1234567890abcdef12345678')
         expect(metadata['buzz']).to eq(nil)
+        expect(metadata['canary']).to eq('0.0.0')
       end
 
       it 'does not load module implementations for static versioned' do
@@ -381,6 +398,7 @@ describe R10K::ModuleLoader::Puppetfile do
         expect(modules['baz']).to be_a_kind_of(R10K::Module::Definition)
         expect(modules['fizz']).to be_a_kind_of(R10K::Module::Definition)
         expect(modules['buzz']).to be_a_kind_of(R10K::Module::Git)
+        expect(modules['canary']).to be_a_kind_of(R10K::Module::Definition)
       end
 
       it 'loads module implementations whose static versions are different' do

data/spec/unit/module_spec.rb

@@ -31,12 +31,11 @@ describe R10K::Module do
       'bar-quux',
     ].each do |scenario|
       it "accepts a name matching #{scenario} and version nil" do
-        obj = R10K::Module.new(scenario, '/modulepath', { version: nil })
+        obj = R10K::Module.new(scenario, '/modulepath', { type: 'forge', version: nil })
         expect(obj).to be_a_kind_of(R10K::Module::Forge)
       end
     end
-    [ {version: '8.0.0'},
-      {type: 'forge', version: '8.0.0'},
+    [ {type: 'forge', version: '8.0.0'},
     ].each do |scenario|
       it "accepts a name matching bar-quux and args #{scenario.inspect}" do
         obj = R10K::Module.new('bar-quux', '/modulepath', scenario)
@@ -65,7 +64,7 @@ describe R10K::Module do
       end
 
       it 'sets the expected version to what is found in the metadata' do
-        obj = R10K::Module.new(@title, @dirname, {version: nil})
+        obj = R10K::Module.new(@title, @dirname, {type: 'forge', version: nil})
         expect(obj.send(:instance_variable_get, :'@expected_version')).to eq('1.2.0')
       end
     end
@@ -82,7 +81,6 @@ describe R10K::Module do
       ['name', {type: 'git', source: 'git url'}],
       ['name', {svn: 'svn url'}],
       ['name', {type: 'svn', source: 'svn url'}],
-      ['namespace-name', {version: '8.0.0'}],
       ['namespace-name', {type: 'forge', version: '8.0.0'}]
     ].each do |(name, options)|
       it 'can handle the default_branch_override option' do
@@ -92,12 +90,21 @@ describe R10K::Module do
         }.not_to raise_error
       end
       describe 'the exclude_spec setting' do
+        it 'sets the exclude_spec instance variable to false by default' do
+          obj = R10K::Module.new(name, '/modulepath', options)
+          expect(obj.instance_variable_get("@exclude_spec")).to eq(false)
+        end
         it 'sets the exclude_spec instance variable' do
           obj = R10K::Module.new(name, '/modulepath', options.merge({exclude_spec: true}))
           expect(obj.instance_variable_get("@exclude_spec")).to eq(true)
         end
-        it 'can be overridden by the overrides map' do
-          options = options.merge({exclude_spec: false, overrides: {modules: {exclude_spec: true}}})
+        it 'cannot be overridden by the settings from the cli, r10k.yaml, or settings default' do
+          options = options.merge({exclude_spec: true, overrides: {modules: {exclude_spec: false}}})
+          obj = R10K::Module.new(name, '/modulepath', options)
+          expect(obj.instance_variable_get("@exclude_spec")).to eq(true)
+        end
+        it 'reads the setting from the cli, r10k.yaml, or settings default when not provided directly' do
+          options = options.merge({overrides: {modules: {exclude_spec: true}}})
           obj = R10K::Module.new(name, '/modulepath', options)
           expect(obj.instance_variable_get("@exclude_spec")).to eq(true)
         end

data/spec/unit/tarball_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'r10k/tarball'
+
+describe R10K::Tarball do
+  include_context 'Tarball'
+
+  subject { described_class.new('fixture-tarball', fixture_tarball, checksum: fixture_checksum) }
+
+  describe 'initialization' do
+    it 'initializes' do
+      expect(subject).to be_kind_of(described_class)
+    end
+  end
+
+  describe 'downloading and caching' do
+    it 'downloads the source to the cache' do
+      # No cache present initially
+      expect(File.exist?(subject.cache_path)).to be(false)
+      expect(subject.cache_valid?).to be(false)
+
+      subject.get
+
+      expect(subject.cache_valid?).to be(true)
+      expect(File.exist?(subject.cache_path)).to be(true)
+    end
+
+    let(:raw_content) {[
+      './',
+      './Puppetfile',
+      './metadata.json',
+      './spec/',
+      './environment.conf',
+      './spec/1',
+    ]}
+
+    let(:clean_content) {[
+      'Puppetfile',
+      'metadata.json',
+      'spec',
+      'environment.conf',
+      'spec/1',
+    ]}
+
+    it 'returns clean paths when listing cached tarball content' do
+      iterator = allow(subject).to receive(:each_tarball_entry)
+      raw_content.each { |entry| iterator.and_yield(entry) }
+
+      expect(subject.paths).to eq(clean_content)
+    end
+  end
+
+  describe 'http sources'
+
+  describe 'file sources'
+
+  describe 'syncing'
+end

data/spec/unit/util/cacheable_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'r10k/util/cacheable'
+
+RSpec.describe R10K::Util::Cacheable do
+
+  subject { Object.new.extend(R10K::Util::Cacheable) }
+
+  describe "dirname sanitization" do
+    let(:input) { 'git://some/git/remote' }
+
+    it 'sanitizes URL to directory name' do
+      expect(subject.sanitized_dirname(input)).to eq('git---some-git-remote')
+    end
+
+    context 'with username and password' do
+      let(:input) { 'https://"user:pa$$w0rd:@authenticated/git/remote' }
+
+      it 'sanitizes authenticated URL to directory name' do
+        expect(subject.sanitized_dirname(input)).to eq('https---authenticated-git-remote')
+      end
+    end
+  end
+end