r10k 3.14.1 → 5.0.1

data/spec/unit/puppetfile_spec.rb

@@ -1,304 +0,0 @@
-require 'spec_helper'
-require 'r10k/puppetfile'
-
-describe R10K::Puppetfile do
-
-  subject do
-    described_class.new(
-      '/some/nonexistent/basedir',
-      {puppetfile_name: 'Puppetfile.r10k'}
-    )
-  end
-
-  describe "a custom puppetfile_name" 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
-
-  describe "a custom relative puppetfile_path" do
-    it "is the basedir joined with the puppetfile_path" do
-      relative_subject = described_class.new('/some/nonexistent/basedir',
-                                             {puppetfile_path: 'relative/Puppetfile'})
-      expect(relative_subject.puppetfile_path).to eq '/some/nonexistent/basedir/relative/Puppetfile'
-    end
-  end
-
-  describe "a custom absolute puppetfile_path" do
-    it "is the puppetfile_path as given" do
-      absolute_subject = described_class.new('/some/nonexistent/basedir',
-                                             {puppetfile_path: '/some/absolute/custom/Puppetfile'})
-      expect(absolute_subject.puppetfile_path).to eq '/some/absolute/custom/Puppetfile'
-    end
-  end
-end
-
-describe R10K::Puppetfile do
-
-  subject do
-    described_class.new( '/some/nonexistent/basedir', {})
-  end
-
-  describe "backwards compatibility with older calling conventions" do
-    it "honors all arguments correctly" do
-      puppetfile = described_class.new('/some/nonexistant/basedir', '/some/nonexistant/basedir/site-modules', nil, 'Pupupupetfile', true)
-      expect(puppetfile.force).to eq(true)
-      expect(puppetfile.moduledir).to eq('/some/nonexistant/basedir/site-modules')
-      expect(puppetfile.puppetfile_path).to eq('/some/nonexistant/basedir/Pupupupetfile')
-      expect(puppetfile.overrides).to eq({})
-    end
-
-    it "handles defaults correctly" do
-      puppetfile = described_class.new('/some/nonexistant/basedir', nil, nil, nil)
-      expect(puppetfile.force).to eq(false)
-      expect(puppetfile.moduledir).to eq('/some/nonexistant/basedir/modules')
-      expect(puppetfile.puppetfile_path).to eq('/some/nonexistant/basedir/Puppetfile')
-      expect(puppetfile.overrides).to eq({})
-    end
-  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 "loading a Puppetfile" do
-    context 'using load' do
-      it "returns the loaded content" do
-        path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
-        subject = described_class.new(path, {})
-
-        loaded_content = subject.load
-        expect(loaded_content).to be_an_instance_of(Hash)
-
-        has_some_data = loaded_content.values.none?(&:empty?)
-        expect(has_some_data).to be true
-      end
-
-      it "handles a relative basedir" do
-        path = File.join('spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
-        subject = described_class.new(path, {})
-
-        loaded_content = subject.load
-        expect(loaded_content).to be_an_instance_of(Hash)
-
-        has_some_data = loaded_content.values.none?(&:empty?)
-        expect(has_some_data).to be true
-      end
-
-      it "is idempotent" do
-        path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
-        subject = described_class.new(path, {})
-
-        expect(subject.loader).to receive(:load!).and_call_original.once
-
-        loaded_content1 = subject.load
-        expect(subject.loaded?).to be true
-        loaded_content2 = subject.load
-
-        expect(loaded_content2).to eq(loaded_content1)
-      end
-
-      it "returns nil if Puppetfile doesn't exist" do
-        path = '/rando/path/that/wont/exist'
-        subject = described_class.new(path, {})
-        expect(subject.load).to eq nil
-      end
-    end
-
-    context 'using load!' do
-      it "returns the loaded content" do
-        path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
-        subject = described_class.new(path, {})
-
-        loaded_content = subject.load!
-        expect(loaded_content).to be_an_instance_of(Hash)
-
-        has_some_data = loaded_content.values.none?(&:empty?)
-        expect(has_some_data).to be true
-      end
-
-      it "raises if Puppetfile doesn't exist" do
-        path = '/rando/path/that/wont/exist'
-        subject = described_class.new(path, {})
-        expect {
-          subject.load!
-        }.to raise_error(/No such file or directory.*\/rando\/path\/.*/)
-      end
-    end
-  end
-
-  describe 'default_branch_override' do
-    it 'is passed correctly to module loader init' do
-      # This path doesn't matter so long as it has a Puppetfile within it
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
-      subject = described_class.new(path, {overrides: {environments: {default_branch_override: 'foo'}}})
-
-      repo = instance_double('R10K::Git::StatefulRepository')
-      allow(repo).to receive(:resolve).with('foo').and_return(true)
-      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
-
-      allow(subject.loader).to receive(:puppetfile_content).and_return <<-EOPF
-        # Track control branch and fall-back to main if no matching branch.
-        mod 'hieradata',
-          :git => 'git@git.example.com:organization/hieradata.git',
-          :branch => :control_branch,
-          :default_branch => 'main'
-        EOPF
-
-      expect(subject.logger).not_to receive(:warn).
-        with(/Mismatch between passed and initialized.*preferring passed value/)
-
-      subject.load
-
-      loaded_module = subject.modules.first
-      expect(loaded_module.version).to eq('foo')
-    end
-
-    it 'overrides module loader init if needed' do
-      # This path doesn't matter so long as it has a Puppetfile within it
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
-      subject = described_class.new(path, {overrides: {environments: {default_branch_override: 'foo'}}})
-
-      repo = instance_double('R10K::Git::StatefulRepository')
-      allow(repo).to receive(:resolve).with('bar').and_return(true)
-      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
-
-      allow(subject.loader).to receive(:puppetfile_content).and_return <<-EOPF
-        # Track control branch and fall-back to main if no matching branch.
-        mod 'hieradata',
-          :git => 'git@git.example.com:organization/hieradata.git',
-          :branch => :control_branch,
-          :default_branch => 'main'
-        EOPF
-
-      expect(subject.logger).to receive(:warn).
-        with(/Mismatch between passed and initialized.*preferring passed value/)
-
-      subject.load('bar')
-      loaded_module = subject.modules.first
-      expect(loaded_module.version).to eq('bar')
-    end
-
-    it 'does not warn if passed and initialized default_branch_overrides match' do
-      # This path doesn't matter so long as it has a Puppetfile within it
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
-      subject = described_class.new(path, {overrides: {environments: {default_branch_override: 'foo'}}})
-
-      repo = instance_double('R10K::Git::StatefulRepository')
-      allow(repo).to receive(:resolve).with('foo').and_return(true)
-      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
-
-      allow(subject.loader).to receive(:puppetfile_content).and_return <<-EOPF
-        # Track control branch and fall-back to main if no matching branch.
-        mod 'hieradata',
-          :git => 'git@git.example.com:organization/hieradata.git',
-          :branch => :control_branch,
-          :default_branch => 'main'
-        EOPF
-
-      expect(subject.logger).not_to receive(:warn).
-        with(/Mismatch between passed and initialized.*preferring passed value/)
-
-      subject.load('foo')
-      loaded_module = subject.modules.first
-      expect(loaded_module.version).to eq('foo')
-    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 "synchronizes 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 = instance_double('R10K::Module::Base', :cachedir => :none)
-      mod2 = instance_double('R10K::Module::Base', :cachedir => :none)
-      expect(mod1).to receive(:sync)
-      expect(mod2).to receive(:sync)
-      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 = instance_double('R10K::Module::Base', :cachedir => :none)
-      mod2 = instance_double('R10K::Module::Base', :cachedir => :none)
-      expect(mod1).to receive(:sync)
-      expect(mod2).to receive(:sync)
-      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.twice
-
-      subject.accept(visitor)
-    end
-
-    it "Creates queues of modules grouped by cachedir" 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
-
-      m1 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/A')
-      m2 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/B')
-      m3 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/C')
-      m4 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/C')
-      m5 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/D')
-      m6 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/D')
-
-      modules = [m1, m2, m3, m4, m5, m6]
-
-      queue = R10K::ContentSynchronizer.modules_visit_queue(modules, visitor, subject)
-      expect(queue.length).to be 4
-      queue_array = 4.times.map { queue.pop }
-      expect(queue_array).to match_array([[m1], [m2], [m3, m4], [m5, m6]])
-    end
-  end
-end

data/spec/unit/settings/collection_spec.rb

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

data/spec/unit/settings/container_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-require 'r10k/settings'
-
-describe R10K::Settings::Container do
-
-  describe 'validating keys' do
-    it 'can add new valid keys' do
-      subject.add_valid_key(:v)
-      subject[:v]
-    end
-
-    it 'can check if a key is valid' do
-      subject.add_valid_key(:v)
-      expect(subject.valid_key?(:v)).to be_truthy
-    end
-
-    it 'can list all valid keys' do
-      subject.add_valid_key(:v)
-      subject.add_valid_key(:w)
-
-      expect(subject.valid_keys).to include :v
-      expect(subject.valid_keys).to include :w
-    end
-  end
-
-  describe 'specifying settings' do
-    it 'fails if a setting application uses an invalid key' do
-      expect { subject[:invalid] = 'fail' }.to raise_error R10K::Settings::Container::InvalidKey
-    end
-
-    it 'can look up values that it sets' do
-      subject.add_valid_key :v
-      subject[:v] = 'set'
-      expect(subject[:v]).to eq 'set'
-    end
-  end
-
-  describe 'looking up settings' do
-    before do
-      subject.add_valid_key :v
-    end
-
-    it 'fails if a setting lookup uses an invalid key' do
-      expect { subject[:invalid] }.to raise_error R10K::Settings::Container::InvalidKey
-    end
-
-    it 'returns nil if a key is valid but no setting is present' do
-      expect(subject[:v]).to be_nil
-    end
-
-    describe 'with a parent container' do
-      let(:parent) { described_class.new.tap { |p| p.add_valid_key :v } }
-      subject { described_class.new(parent) }
-
-      it 'uses its setting over a parent value' do
-        subject[:v] = 'child'
-        parent[:v] = 'parent'
-        expect(subject[:v]).to eq 'child'
-      end
-
-      it 'duplicates and stores the parent object to avoid modifying the parent object' do
-        parent[:v] = {}
-        subject[:v][:hello] = "world"
-        expect(subject[:v]).to eq({hello: "world"})
-        expect(parent[:v]).to eq({})
-      end
-
-      it 'falls back to the parent value if it does not have a value' do
-        parent[:v] = 'parent'
-        expect(subject[:v]).to eq 'parent'
-      end
-    end
-  end
-
-  describe "resetting" do
-    before do
-      subject.add_valid_key :v
-    end
-
-    it "unsets all settings" do
-      subject[:v] = "hi"
-      subject.reset!
-      expect(subject[:v]).to be_nil
-    end
-
-    it "doesn't remove valid values" do
-      subject.reset!
-      expect(subject.valid_key?(:v)).to be_truthy
-    end
-  end
-end

data/spec/unit/settings/definition_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-require 'r10k/settings/definition'
-require 'r10k/settings/collection'
-require 'r10k/settings/list'
-
-describe R10K::Settings::Definition do
-  subject { described_class.new(:setting) }
-
-  it_behaves_like "a setting with ancestors"
-
-  describe "#evaluate" do
-    it "assigns a value, validates it, and resolves a final value" do
-      expect(subject).to receive(:assign).with("myvalue")
-      expect(subject).to receive(:validate)
-      expect(subject).to receive(:resolve)
-      subject.evaluate("myvalue")
-    end
-  end
-
-  describe "#assign" do
-    it 'stores the provided value' do
-      subject.assign("I'm the value")
-      expect(subject.value).to eq "I'm the value"
-    end
-
-    it "normalizes the stored value when a normalize hook is set" do
-      subject = described_class.new(:setting, :normalize => lambda { |input| input.to_sym })
-      subject.assign("symbolizeme")
-      expect(subject.value).to eq :symbolizeme
-    end
-  end
-
-  describe "#validate" do
-    it "does nothing if a value has not been assigned" do
-      subject = described_class.new(:setting, :validate => lambda { |_| raise "Shouldn't be called" })
-      subject.validate
-    end
-
-    it "does nothing if a validate hook has not been assigned" do
-      subject.assign("I'm the value")
-      subject.validate
-    end
-
-    it "raises up errors raised from the validate hook" do
-      subject = described_class.new(:satellite, :validate => lambda { |input| raise ArgumentError, "Invalid value #{input}: that's no moon!" })
-      subject.assign("Alderaan")
-      expect {
-        subject.validate
-      }.to raise_error(ArgumentError, "Invalid value Alderaan: that's no moon!")
-    end
-
-    it "returns if the validate hook did not raise an error" do
-      subject = described_class.new(:setting, :validate => lambda { |_| "That's a moon" })
-      subject.assign("Mun")
-      subject.validate
-    end
-  end
-
-  describe "#resolve" do
-    it "returns the value when the value has been given" do
-      subject.assign("Mun")
-      expect(subject.resolve).to eq "Mun"
-    end
-
-    it "resolves the default when the default is a proc" do
-      subject = described_class.new(:setting, :default => lambda { "Minmus" })
-      expect(subject.resolve).to eq "Minmus"
-    end
-
-    it "returns the default when the default is not a proc" do
-      subject = described_class.new(:setting, :default => "Ike")
-      expect(subject.resolve).to eq "Ike"
-    end
-
-    it "returns nil when there is no value nor default" do
-      expect(subject.resolve).to be_nil
-    end
-  end
-end

data/spec/unit/settings/enum_definition_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'r10k/settings/enum_definition'
-
-describe R10K::Settings::EnumDefinition do
-
-  subject { described_class.new(:enum, :enum => %w[one two three]) }
-
-  describe '#validate' do
-    it "doesn't raise an error when given an expected value" do
-      subject.assign('two')
-      subject.validate
-    end
-    it "raises an error when given a value outside the enum" do
-      subject.assign('dos')
-      expect {
-        subject.validate
-      }.to raise_error(ArgumentError, "Setting enum should be one of #{%w[one two three].inspect}, not 'dos'")
-    end
-  end
-end

data/spec/unit/settings/inheritance_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'r10k/settings/collection'
-require 'r10k/settings/definition'
-
-RSpec.describe 'R10K::Settings inheritance' do
-  subject do
-    R10K::Settings::Collection.new(:parent_settings, [
-      R10K::Settings::Definition.new(:banana, {
-        :default => 'cavendish',
-      }),
-
-      R10K::Settings::Collection.new(:child_settings, [
-        R10K::Settings::Definition.new(:banana, {
-          :default => :inherit,
-        }),
-      ]),
-    ])
-  end
-
-  describe "child settings" do
-    let(:setting) { subject[:child_settings][:banana] }
-
-    context "when child value is not set" do
-      it "should resolve to default value from parent" do
-        expect(setting.value).to be_nil
-        expect(setting.resolve).to eq 'cavendish'
-      end
-    end
-
-    context "when child value is set" do
-      before(:each) { setting.assign('gros michel') }
-
-      it "should resolve to child value" do
-        expect(setting.resolve).to eq 'gros michel'
-      end
-    end
-  end
-end