r10k 3.5.2

data/spec/unit/module_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'r10k/module'
+
+describe R10K::Module do
+  describe 'delegating to R10K::Module::Git' do
+    it "accepts args {:git => 'git url}" do
+      obj = R10K::Module.new('foo', '/modulepath', :git => 'git url')
+      expect(obj).to be_a_kind_of(R10K::Module::Git)
+    end
+  end
+
+  describe 'delegating to R10K::Module::Forge' do
+    [
+      ['bar/quux', nil],
+      ['bar-quux', nil],
+      ['bar/quux', '8.0.0'],
+    ].each do |scenario|
+      it "accepts a name matching #{scenario[0]} and args #{scenario[1].inspect}" do
+        expect(R10K::Module.new(scenario[0], '/modulepath', scenario[1])).to be_a_kind_of(R10K::Module::Forge)
+      end
+    end
+  end
+
+  it "raises an error if delegation fails" do
+    expect {
+      R10K::Module.new('bar!quux', '/modulepath', ["NOPE NOPE NOPE NOPE!"])
+    }.to raise_error RuntimeError, /doesn't have an implementation/
+  end
+end

data/spec/unit/puppetfile_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+require 'r10k/puppetfile'
+
+describe R10K::Puppetfile do
+
+  subject do
+    described_class.new(
+      '/some/nonexistent/basedir',
+      nil,
+      nil,
+      'Puppetfile.r10k'
+    )
+  end
+
+  describe "a custom puppetfile Puppetfile.r10k" do
+    it "is the basedir joined with '/Puppetfile.r10k' path" do
+      expect(subject.puppetfile_path).to eq '/some/nonexistent/basedir/Puppetfile.r10k'
+    end
+  end
+
+end
+
+describe R10K::Puppetfile do
+
+  subject do
+    described_class.new(
+      '/some/nonexistent/basedir'
+    )
+  end
+
+  describe "the default moduledir" do
+    it "is the basedir joined with '/modules' path" do
+      expect(subject.moduledir).to eq '/some/nonexistent/basedir/modules'
+    end
+  end
+
+  describe "the default puppetfile" do
+    it "is the basedir joined with '/Puppetfile' path" do
+      expect(subject.puppetfile_path).to eq '/some/nonexistent/basedir/Puppetfile'
+    end
+  end
+
+
+  describe "setting moduledir" do
+    it "changes to given moduledir if it is an absolute path" do
+      subject.set_moduledir('/absolute/path/moduledir')
+      expect(subject.moduledir).to eq '/absolute/path/moduledir'
+    end
+
+    it "joins the basedir with the given moduledir if it is a relative path" do
+      subject.set_moduledir('relative/moduledir')
+      expect(subject.moduledir).to eq '/some/nonexistent/basedir/relative/moduledir'
+    end
+  end
+
+  describe "adding modules" do
+    it "should accept Forge modules with a string arg" do
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, '1.2.3', anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', '1.2.3') }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should not accept Forge modules with a version comparison" do
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, '< 1.2.0', anything).and_call_original
+
+      expect {
+        subject.add_module('puppet/test_module', '< 1.2.0')
+      }.to raise_error(RuntimeError, /module puppet\/test_module.*doesn't have an implementation/i)
+
+      expect(subject.modules.collect(&:name)).not_to include('test_module')
+    end
+
+    it "should accept non-Forge modules with a hash arg" do
+      module_opts = { git: 'git@example.com:puppet/test_module.git' }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should accept non-Forge modules with a valid relative :install_path option" do
+      module_opts = {
+        install_path: 'vendor',
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', File.join(subject.basedir, 'vendor'), module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should accept non-Forge modules with a valid absolute :install_path option" do
+      install_path = File.join(subject.basedir, 'vendor')
+
+      module_opts = {
+        install_path: install_path,
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', install_path, module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should reject non-Forge modules with an invalid relative :install_path option" do
+      module_opts = {
+        install_path: '../../vendor',
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', File.join(subject.basedir, 'vendor'), module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to raise_error(R10K::Error, /cannot manage content.*is not within/i).and not_change { subject.modules }
+    end
+
+    it "should reject non-Forge modules with an invalid absolute :install_path option" do
+      module_opts = {
+        install_path: '/tmp/mydata/vendor',
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', File.join(subject.basedir, 'vendor'), module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to raise_error(R10K::Error, /cannot manage content.*is not within/i).and not_change { subject.modules }
+    end
+  end
+
+  describe "#purge_exclusions" do
+    let(:managed_dirs) { ['dir1', 'dir2'] }
+
+    before(:each) do
+      allow(subject).to receive(:managed_directories).and_return(managed_dirs)
+    end
+
+    it "includes managed_directories" do
+      expect(subject.purge_exclusions).to match_array(managed_dirs)
+    end
+
+    context "when belonging to an environment" do
+      let(:env_contents) { ['env1', 'env2' ] }
+
+      before(:each) do
+        mock_env = double(:environment, desired_contents: env_contents)
+        allow(subject).to receive(:environment).and_return(mock_env)
+      end
+
+      it "includes environment's desired_contents" do
+        expect(subject.purge_exclusions).to match_array(managed_dirs + env_contents)
+      end
+    end
+  end
+
+  describe "evaluating a Puppetfile" do
+    def expect_wrapped_error(orig, pf_path, wrapped_error)
+      expect(orig).to be_a_kind_of(R10K::Error)
+      expect(orig.message).to eq("Failed to evaluate #{pf_path}")
+      expect(orig.original).to be_a_kind_of(wrapped_error)
+    end
+
+    it "wraps and re-raises syntax errors" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'invalid-syntax')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect {
+        subject.load!
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, SyntaxError)
+      end
+    end
+
+    it "wraps and re-raises load errors" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'load-error')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect {
+        subject.load!
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, LoadError)
+      end
+    end
+
+    it "wraps and re-raises argument errors" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'argument-error')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect {
+        subject.load!
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, ArgumentError)
+      end
+    end
+
+    it "rejects Puppetfiles with duplicate module names" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'duplicate-module-error')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect {
+        subject.load!
+      }.to raise_error(R10K::Error, /Puppetfiles cannot contain duplicate module names/i)
+    end
+
+    it "wraps and re-raises name errors" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'name-error')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect {
+        subject.load!
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, NameError)
+      end
+    end
+
+    it "accepts a forge module with a version" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect { subject.load! }.not_to raise_error
+    end
+
+    it "accepts a forge module without a version" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-without-version')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect { subject.load! }.not_to raise_error
+    end
+
+    it "creates a git module and applies the default branch sepcified in the Puppetfile" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'default-branch-override')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect { subject.load! }.not_to raise_error
+      git_module = subject.modules[0]
+      expect(git_module.default_ref).to eq 'here_lies_the_default_branch'
+    end
+
+    it "creates a git module and applies the provided default_branch_override" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'default-branch-override')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      default_branch_override = 'default_branch_override_name'
+      expect { subject.load!(default_branch_override) }.not_to raise_error
+      git_module = subject.modules[0]
+      expect(git_module.default_ref).to eq default_branch_override
+    end
+  end
+
+  describe "accepting a visitor" do
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:puppetfile, subject)
+      subject.accept(visitor)
+    end
+
+    it "passes the visitor to each module if the visitor yields" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit) do |type, other, &block|
+        expect(type).to eq :puppetfile
+        expect(other).to eq subject
+        block.call
+      end
+
+      mod1 = spy('module')
+      expect(mod1).to receive(:accept).with(visitor)
+      mod2 = spy('module')
+      expect(mod2).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:modules).and_return([mod1, mod2])
+      subject.accept(visitor)
+    end
+
+    it "creates a thread pool to visit concurrently if pool_size setting is greater than one" do
+      pool_size = 3
+
+      subject.settings[:pool_size] = pool_size
+
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit) do |type, other, &block|
+        expect(type).to eq :puppetfile
+        expect(other).to eq subject
+        block.call
+      end
+
+      mod1 = spy('module')
+      expect(mod1).to receive(:accept).with(visitor)
+      mod2 = spy('module')
+      expect(mod2).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:modules).and_return([mod1, mod2])
+
+      expect(Thread).to receive(:new).exactly(pool_size).and_call_original
+      expect(Queue).to receive(:new).and_call_original
+
+      subject.accept(visitor)
+    end
+  end
+end

data/spec/unit/settings/collection_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'r10k/settings/collection'
+require 'r10k/settings/definition'
+
+describe R10K::Settings::Collection do
+
+  let(:symbol_defn) { R10K::Settings::Definition.new(:symbol_defn, :validate => lambda { |x| raise TypeError unless x.is_a?(Symbol) }) }
+  let(:default_defn) { R10K::Settings::Definition.new(:default_defn, :default => lambda { "Defaults are fun" }) }
+
+  subject do
+    described_class.new(:collection, [symbol_defn, default_defn])
+  end
+
+  it_behaves_like "a setting with ancestors"
+
+  describe "#evaluate" do
+    it "assigns values, validates them, and resolves a final value" do
+      expect(subject).to receive(:assign).with({:default_defn => :squid})
+      expect(subject).to receive(:validate)
+      expect(subject).to receive(:resolve)
+      subject.evaluate({:default_defn => :squid})
+    end
+  end
+
+  describe '#assign' do
+    it "assigns values to the appropriate setting" do
+      subject.assign({:symbol_defn => :hello})
+      expect(symbol_defn.value).to eq :hello
+    end
+
+    it "can accept invalid settings" do
+      subject.assign({:hardly_a_setting => "nope nope nope"})
+    end
+
+    it "silently ignores attempts to assign nil" do
+      subject.assign(nil)
+    end
+  end
+
+  describe '#validate' do
+    it "raises an error containing a hash of nested validation errors" do
+      subject.assign({:symbol_defn => "Definitely not a symbol"})
+      expect {
+        errors = subject.validate
+      }.to raise_error do |error|
+        expect(error).to be_a_kind_of(R10K::Settings::Collection::ValidationError)
+        errors = error.errors
+        expect(errors.size).to eq 1
+        expect(errors[:symbol_defn]).to be_a_kind_of(TypeError)
+      end
+    end
+
+    it "it does not raise an error if no errors were found" do
+      subject.assign({:default_defn => "yep"})
+      expect(subject.validate).to be_nil
+    end
+  end
+
+  describe '#resolve' do
+    it "returns a frozen hash of all settings" do
+      subject.assign({:symbol_defn => :some_value})
+      rv = subject.resolve
+      expect(rv).to be_frozen
+      expect(rv).to eq({:symbol_defn => :some_value, :default_defn => "Defaults are fun"})
+    end
+  end
+end
+
+describe R10K::Settings::Collection::ValidationError do
+
+
+  let(:flat_errors) do
+    described_class.new("Validation failures for some group", errors: {
+      some_defn: ArgumentError.new("some_defn is wrong, somehow."),
+      uri_setting: ArgumentError.new("uri_setting NOTAURI is not a URI.")
+    })
+  end
+
+  let(:flat_error_text) do
+    [
+      "Validation failures for some group:",
+      "    some_defn:",
+      "        some_defn is wrong, somehow.",
+      "    uri_setting:",
+      "        uri_setting NOTAURI is not a URI."]
+    .join("\n")
+  end
+
+  let(:nested_errors) do
+    described_class.new("Validation failures for some nesting group", errors: {
+      file_setting: ArgumentError.new("file_setting is a potato, not a file."),
+      nested: flat_errors
+    })
+  end
+
+  let(:nested_error_text) do
+    [
+      "Validation failures for some nesting group:",
+      "    file_setting:",
+      "        file_setting is a potato, not a file.",
+      "    nested:",
+      "        Validation failures for some group:",
+      "            some_defn:",
+      "                some_defn is wrong, somehow.",
+      "            uri_setting:",
+      "                uri_setting NOTAURI is not a URI."
+    ].join("\n")
+  end
+
+  describe "formatting a human readable error message" do
+    describe "no with no nested validation errors" do
+      it "generates a human readable set of validation errors." do
+        expect(flat_errors.format).to eq flat_error_text
+      end
+    end
+
+    describe "with nested validation errors" do
+      it "generates a human readable set of validation errors." do
+        expect(nested_errors.format).to eq nested_error_text
+      end
+    end
+  end
+end