r10k 3.14.1 → 5.0.1

data/spec/unit/settings/list_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'r10k/settings/list'
-require 'r10k/settings/collection'
-require 'r10k/settings/definition'
-require 'r10k/settings/uri_definition'
-
-describe R10K::Settings::List do
-  let(:item_proc) do
-    lambda { R10K::Settings::URIDefinition.new(nil, { :desc => "A URI in a list" }) }
-  end
-
-  subject do
-    described_class.new(:test_list, item_proc, { :desc => "A test setting list" })
-  end
-
-  it_behaves_like "a setting with ancestors"
-
-  describe '#assign' do
-    it "calls item_proc for each item assigned" do
-      expect(R10K::Settings::URIDefinition).to receive(:new).and_call_original.exactly(3).times
-
-      subject.assign([ "uri_1", "uri_2", "uri_3"])
-    end
-
-    it "claims ownership of newly added items" do
-      subject.assign([ "uri_1", "uri_2", "uri_3"])
-
-      item_parents = subject.instance_variable_get(:@items).collect { |i| i.parent }
-      expect(item_parents).to all(eq subject)
-    end
-
-    it "assigns value to each item" do
-      new_values = [ "uri_1", "uri_2", "uri_3"]
-      subject.assign(new_values)
-
-      item_values = subject.instance_variable_get(:@items).collect { |i| i.value }
-      expect(item_values).to eq new_values
-    end
-
-    it "silently ignores attempts to assign nil" do
-      subject.assign(nil)
-    end
-  end
-
-  describe '#validate' do
-    it "raises an error containing a list of every item with validation errors" do
-      subject.assign([ "uri 1", "uri 2", "http://www.example.com"])
-
-      expect { subject.validate }.to raise_error do |error|
-        expect(error).to be_a_kind_of(R10K::Settings::List::ValidationError)
-        errors = error.errors.collect { |key, val| val }
-        expect(errors.size).to eq 2
-        expect(errors).to all(be_a_kind_of(ArgumentError))
-        expect(errors.collect { |e| e.message }).to all(match /requires a URL.*could not be parsed/i)
-      end
-    end
-
-    it "it does not raise an error if no errors were found" do
-      subject.assign([ "http://www.example.com" ])
-      expect(subject.validate).to be_nil
-    end
-  end
-
-  describe '#resolve' do
-    it "returns a frozen list of all items" do
-      subject.assign([ "uri_1", "uri_2" ])
-
-      rv = subject.resolve
-
-      expect(rv).to be_frozen
-      expect(rv).to eq([ "uri_1", "uri_2" ])
-    end
-  end
-end
-
-describe R10K::Settings::List::ValidationError do
-  subject do
-    described_class.new("Sample List Validation Errors", errors: {
-      2 => ArgumentError.new("Sample List Item Error"),
-    })
-  end
-
-  it "generates a human readable error message for the invalid item" do
-    message = subject.format
-
-    expect(message).to match /sample list validation errors.*item 2.*sample list item error/im
-  end
-end

data/spec/unit/settings/loader_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-require 'r10k/settings/loader'
-
-describe R10K::Settings::Loader do
-
-  context 'populate_loadpath' do
-    it 'includes /etc/puppetlabs/r10k/r10k.yaml in the loadpath' do
-      expect(subject.loadpath).to include('/etc/puppetlabs/r10k/r10k.yaml')
-    end
-
-    it 'includes /etc/r10k.yaml in the loadpath' do
-      expect(subject.loadpath).to include('/etc/r10k.yaml')
-    end
-
-    it 'does include the current working directory in the loadpath' do
-      allow(Dir).to receive(:getwd).and_return '/some/random/path/westvletren'
-      expect(subject.loadpath).to include('/some/random/path/westvletren/r10k.yaml')
-    end
-
-    it 'does not include /some/random/path/atomium/r10k.yaml in the loadpath' do
-      expect(subject.loadpath).not_to include('/some/random/path/atomium/r10k.yaml')
-    end
-
-  end
-
-  context 'search' do
-    it 'returns the correct default location' do
-      allow(File).to receive(:file?).and_return false
-      allow(File).to receive(:file?).with('/etc/puppetlabs/r10k/r10k.yaml').and_return true
-      allow(File).to receive(:file?).with('/etc/r10k.yaml').and_return true
-      expect(subject.search).to eq '/etc/puppetlabs/r10k/r10k.yaml'
-    end
-
-    it 'issues a warning if both default locations are present' do
-      allow(File).to receive(:file?).and_return false
-      allow(File).to receive(:file?).with('/etc/puppetlabs/r10k/r10k.yaml').and_return true
-      allow(File).to receive(:file?).with('/etc/r10k.yaml').and_return true
-
-      logger_dbl = double('Logging')
-      allow(subject).to receive(:logger).and_return logger_dbl
-
-      expect(logger_dbl).to receive(:warn).with('Both /etc/puppetlabs/r10k/r10k.yaml and /etc/r10k.yaml configuration files exist.')
-      expect(logger_dbl).to receive(:warn).with('/etc/puppetlabs/r10k/r10k.yaml will be used.')
-
-      subject.search
-    end
-
-    it 'issues a warning if the old location is used' do
-      allow(File).to receive(:file?).and_return false
-      allow(File).to receive(:file?).with('/etc/puppetlabs/r10k/r10k.yaml').and_return false
-      allow(File).to receive(:file?).with('/etc/r10k.yaml').and_return true
-
-      logger_dbl = double('Logging')
-      allow(subject).to receive(:logger).and_return logger_dbl
-
-      expect(logger_dbl).to receive(:warn).with("The r10k configuration file at /etc/r10k.yaml is deprecated.")
-      expect(logger_dbl).to receive(:warn).with('Please move your r10k configuration to /etc/puppetlabs/r10k/r10k.yaml.')
-
-      subject.search
-    end
-
-    describe 'using an override value' do
-      it 'uses the override when set and ignores files in the load path' do
-        expect(File).to_not receive(:file?)
-        expect(subject.search('/some/override/r10k.yaml')).to eq '/some/override/r10k.yaml'
-      end
-
-      it 'ignores a nil override value' do
-        allow(File).to receive(:file?).and_return false
-        allow(File).to receive(:file?).with('/etc/puppetlabs/r10k/r10k.yaml').and_return true
-        allow(File).to receive(:file?).with('/etc/r10k.yaml').and_return true
-        expect(subject.search(nil)).to eq('/etc/puppetlabs/r10k/r10k.yaml')
-      end
-    end
-  end
-
-  context '#read' do
-    it "raises an error if no config file could be found" do
-      expect(subject).to receive(:search).and_return nil
-      expect {
-        subject.read
-      }.to raise_error(R10K::Settings::Loader::ConfigError, "No configuration file given, no config file found in current directory, and no global config present")
-    end
-
-    it "raises an error if the YAML file load raises an error" do
-      expect(subject).to receive(:search).and_return '/some/path/r10k.yaml'
-      expect(YAML).to receive(:load_file).and_raise(Errno::ENOENT, "/no/such/file")
-      expect {
-        subject.read
-      }.to raise_error(R10K::Settings::Loader::ConfigError, "Couldn't load config file: No such file or directory - /no/such/file")
-    end
-
-    it "recursively replaces string keys with symbol keys in the parsed structure" do
-      expect(subject).to receive(:search).and_return '/some/path/r10k.yaml'
-      expect(YAML).to receive(:load_file).and_return({
-        'cachedir' => '/var/cache/r10k',
-        'git' => {
-          'provider' => 'rugged',
-        }
-      })
-
-      expect(subject.read).to eq({
-        :cachedir => '/var/cache/r10k',
-        :git => {
-          :provider => 'rugged',
-        }
-      })
-    end
-  end
-end

data/spec/unit/settings/uri_definition_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-require 'r10k/settings/uri_definition'
-
-describe R10K::Settings::URIDefinition do
-
-  subject { described_class.new(:uri) }
-
-  it "passes validation if a value has not been set" do
-    expect(subject.validate).to be_nil
-  end
-
-  it "passes validation when given a valid url" do
-    subject.assign("http://definitely.a/url")
-    expect(subject.validate).to be_nil
-  end
-
-  it "raises an error when given an invalid URL" do
-    subject.assign("That's no URI!")
-    expect {
-      subject.validate
-    }.to raise_error(ArgumentError, "Setting uri requires a URL but 'That's no URI!' could not be parsed as a URL")
-  end
-end

data/spec/unit/settings_spec.rb

@@ -1,303 +0,0 @@
-require 'spec_helper'
-require 'r10k/settings'
-require 'r10k/util/exec_env'
-
-describe R10K::Settings do
-  describe "git settings" do
-    subject { described_class.git_settings }
-
-    describe "provider" do
-      it "normalizes valid values to a symbol" do
-        output = subject.evaluate("provider" => "rugged")
-        expect(output[:provider]).to eq(:rugged)
-      end
-    end
-
-    describe "username" do
-      it "defaults to the current user" do
-        expect(Etc).to receive(:getlogin).and_return("puppet")
-        output = subject.evaluate({})
-        expect(output[:username]).to eq("puppet")
-      end
-
-      it "passes values through unchanged" do
-        output = subject.evaluate("username" => "git")
-        expect(output[:username]).to eq("git")
-      end
-    end
-
-    describe "private_key" do
-      it "passes values through unchanged" do
-        output = subject.evaluate("private_key" => "/etc/puppetlabs/r10k/id_rsa")
-        expect(output[:private_key]).to eq("/etc/puppetlabs/r10k/id_rsa")
-      end
-    end
-
-    describe "proxy" do
-      it "accepts valid URIs" do
-        output = subject.evaluate("proxy" => "http://proxy.tessier-ashpool.freeside:3128")
-        expect(output[:proxy]).to eq "http://proxy.tessier-ashpool.freeside:3128"
-      end
-
-      it "rejects invalid URIs" do
-        expect {
-          subject.evaluate("proxy" => "that's no proxy!")
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'git' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:proxy]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:proxy].message).to match(/could not be parsed as a URL/)
-        end
-      end
-    end
-  end
-
-  describe "forge settings" do
-    subject { described_class.forge_settings }
-
-    describe "proxy" do
-      it "accepts valid URIs" do
-        output = subject.evaluate("proxy" => "http://proxy.tessier-ashpool.freeside:3128")
-        expect(output[:proxy]).to eq "http://proxy.tessier-ashpool.freeside:3128"
-      end
-
-      it "rejects invalid URIs" do
-        expect {
-          subject.evaluate("proxy" => "that's no proxy!")
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'forge' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:proxy]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:proxy].message).to match(/could not be parsed as a URL/)
-        end
-      end
-    end
-
-    describe "baseurl" do
-      it "accepts valid URIs" do
-        output = subject.evaluate("baseurl" => "https://forge.tessier-ashpool.freeside")
-        expect(output[:baseurl]).to eq "https://forge.tessier-ashpool.freeside"
-      end
-
-      it "rejects invalid URIs" do
-        expect {
-          subject.evaluate("baseurl" => "that's no forge!")
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'forge' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:baseurl]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:baseurl].message).to match(/could not be parsed as a URL/)
-        end
-      end
-    end
-
-    describe "allow_puppetfile_override" do
-      it 'is false by default' do
-        expect(subject.evaluate({})[:allow_puppetfile_override]).to eq(false)
-      end
-
-      it 'can be set to true' do
-        expect(subject.evaluate({"allow_puppetfile_override" => true})[:allow_puppetfile_override]).to eq(true)
-      end
-
-      it "raises an error for non-boolean values" do
-        expect {
-          subject.evaluate({"allow_puppetfile_override" => 'invalid_string'})
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'forge' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:allow_puppetfile_override]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:allow_puppetfile_override].message).to match(/`allow_puppetfile_override` can only be a boolean value, not 'invalid_string'/)
-        end
-      end
-    end
-  end
-
-  describe "deploy settings" do
-    subject { described_class.deploy_settings }
-
-    describe 'exclude_spec' do
-      it 'is false by default' do
-        expect(subject.evaluate({})[:exclude_spec]).to eq(false)
-      end
-      it 'can be set to true' do
-        expect(subject.evaluate({"exclude_spec" => true})[:exclude_spec]).to eq(true)
-      end
-      it "raises an error for non-boolean values" do
-        expect {
-          subject.evaluate({"exclude_spec" => 'invalid_string'})
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'deploy' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:exclude_spec]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:exclude_spec].message).to match(/`exclude_spec` can only be a boolean value, not 'invalid_string'/)
-        end
-      end
-    end
-    describe "write_lock" do
-      it "accepts a string with a reason for the write lock" do
-        output = subject.evaluate("write_lock" => "No maintenance window active, code freeze till 2038-01-19")
-        expect(output[:write_lock]).to eq("No maintenance window active, code freeze till 2038-01-19")
-      end
-
-      it "accepts false and null values for the write lock" do
-        output = subject.evaluate("write_lock" => false)
-        expect(output[:write_lock]).to eq false
-      end
-
-      it "rejects non-string truthy values for the write lock" do
-        expect {
-          subject.evaluate("write_lock" => %w[list of reasons why deploys are locked])
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'deploy' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:write_lock]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:write_lock].message).to match(/should be a string containing the reason/)
-        end
-      end
-    end
-
-    describe 'puppet_path' do
-      it 'when executable raises no error' do
-        expect(File).to receive(:executable?).with('/nonexistent').and_return(true)
-        expect { subject.evaluate('puppet_path' => '/nonexistent') }.not_to raise_error
-      end
-
-      it 'when not executable raises error' do
-        expect(File).to receive(:executable?).with('/nonexistent')
-        expect { subject.evaluate('puppet_path' => '/nonexistent') }.to raise_error(R10K::Settings::Collection::ValidationError)
-      end
-    end
-
-    describe 'puppet_conf' do
-      it 'when file raises no error' do
-        allow(File).to receive(:readable?).with('/nonexistent').and_return(true)
-        expect { subject.evaluate('puppet_conf' => '/nonexistent') }.not_to raise_error
-      end
-
-      it 'when not file raises error' do
-        allow(File).to receive(:readable?).with('/nonexistent').and_return(false)
-        expect { subject.evaluate('puppet_conf' => '/nonexistent') }.to raise_error(R10K::Settings::Collection::ValidationError)
-      end
-    end
-  end
-
-  describe "global settings" do
-    subject { described_class.global_settings }
-    describe "sources" do
-      it "passes values through unchanged" do
-        output = subject.evaluate("sources" => {"puppet" => {"remote" => "https://git.tessier-ashpool.freeside"}})
-        expect(output[:sources]).to eq({"puppet" => {"remote" => "https://git.tessier-ashpool.freeside"}})
-      end
-    end
-
-    describe "cachedir" do
-      it "passes values through unchanged" do
-        output = subject.evaluate("cachedir" => "/srv/r10k/git")
-        expect(output[:cachedir]).to eq("/srv/r10k/git")
-      end
-    end
-
-    describe "postrun" do
-      it "accepts an argument vector" do
-        output = subject.evaluate("postrun" => ["curl", "-F", "deploy=done", "http://reporting.tessier-ashpool.freeside/r10k"])
-        expect(output[:postrun]).to eq(["curl", "-F", "deploy=done", "http://reporting.tessier-ashpool.freeside/r10k"])
-      end
-
-      it "rejects a string command" do
-        expect {
-          subject.evaluate("postrun" => "curl -F 'deploy=done' https://reporting.tessier-ashpool.freeside/r10k")
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'global' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:postrun]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:postrun].message).to eq("The postrun setting should be an array of strings, not a String")
-        end
-      end
-    end
-
-    describe "pool_size" do
-      it "accepts integers greater than zero" do
-        output = subject.evaluate("pool_size" => 5)
-        expect(output[:pool_size]).to eq 5
-      end
-
-      it "rejects non integer values" do
-        expect {
-          subject.evaluate("pool_size" => "5")
-        }.to raise_error do |err|
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:pool_size]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:pool_size].message).to match(/The pool_size setting should be an integer/)
-        end
-      end
-
-      it "rejects integers smaller than one" do
-        expect {
-          subject.evaluate("pool_size" => 0)
-        }.to raise_error do |err|
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:pool_size]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:pool_size].message).to match(/The pool_size setting should be greater than zero/)
-        end
-
-        expect {
-          subject.evaluate("pool_size" => -3)
-        }.to raise_error do |err|
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:pool_size]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:pool_size].message).to match(/The pool_size setting should be greater than zero/)
-        end
-      end
-    end
-
-    describe "proxy" do
-      it "accepts valid URIs" do
-        output = subject.evaluate("proxy" => "http://proxy.tessier-ashpool.freeside:3128")
-        expect(output[:proxy]).to eq "http://proxy.tessier-ashpool.freeside:3128"
-      end
-
-      it "rejects invalid URIs" do
-        expect {
-          subject.evaluate("proxy" => "that's no proxy!")
-        }.to raise_error do |err|
-          expect(err.message).to match(/Validation failed for 'global' settings group/)
-          expect(err.errors.size).to eq 1
-          expect(err.errors[:proxy]).to be_a_kind_of(ArgumentError)
-          expect(err.errors[:proxy].message).to match(/could not be parsed as a URL/)
-        end
-      end
-
-      describe "setting a default value" do
-        %w[HTTPS_PROXY https_proxy HTTP_PROXY http_proxy].each do |env_var|
-          it "respects the #{env_var} environment variable" do
-            R10K::Util::ExecEnv.withenv(env_var => "http://proxy.value/#{env_var}") do
-              output = subject.evaluate({})
-              expect(output[:proxy]).to eq("http://proxy.value/#{env_var}")
-            end
-          end
-        end
-      end
-    end
-
-    describe "git settings" do
-      it "passes settings through to the git settings" do
-        output = subject.evaluate("git" => {"provider" => "shellgit", "username" => "git"})
-        expect(output[:git]).to include(:provider => :shellgit, :username => "git")
-      end
-    end
-
-    describe "forge settings" do
-      it "passes settings through to the forge settings" do
-        output = subject.evaluate("forge" => {"baseurl" => "https://forge.tessier-ashpool.freeside",
-                                              "proxy" => "https://proxy.tessier-ashpool.freesize:3128",
-                                              "authorization_token" => "faketoken",
-                                              "allow_puppetfile_override" => true})
-        expect(output[:forge]).to eq(:baseurl => "https://forge.tessier-ashpool.freeside",
-                                     :proxy => "https://proxy.tessier-ashpool.freesize:3128",
-                                     :authorization_token => "faketoken",
-                                     :allow_puppetfile_override => true)
-      end
-    end
-  end
-end

data/spec/unit/source/base_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-require 'r10k/source'
-
-describe R10K::Source::Base do
-  subject { described_class.new('base', '/some/nonexistent/path') }
-
-  describe "accepting a visitor" do
-    it "passes itself to the visitor" do
-      visitor = spy('visitor')
-      expect(visitor).to receive(:visit).with(:source, 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 :source
-        expect(other).to eq subject
-        block.call
-      end
-
-      env1 = spy('environment')
-      expect(env1).to receive(:accept).with(visitor)
-      env2 = spy('environment')
-      expect(env2).to receive(:accept).with(visitor)
-
-      expect(subject).to receive(:environments).and_return([env1, env2])
-      subject.accept(visitor)
-    end
-  end
-end

data/spec/unit/source/exec_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-require 'r10k/source'
-require 'json'
-require 'yaml'
-
-describe R10K::Source::Exec do
-
-  let(:environments_hash) do
-    {
-      'production' => {
-        'remote'  => 'https://git.example.com/puppet/control-repo.git',
-        'ref'     => 'release-141',
-        'modules' => {
-          'puppetlabs-stdlib' => '6.1.0',
-          'puppetlabs-ntp' => '8.1.0',
-          'example-myapp1' => {
-            'git' => 'https://git.example.com/puppet/example-myapp1.git',
-            'ref' => 'v1.3.0'
-          }
-        }
-      },
-      'development' => {
-        'remote'  => 'https://git.example.com/puppet/control-repo.git',
-        'ref'     => 'master',
-        'modules' => {
-          'puppetlabs-stdlib' => '6.1.0',
-          'puppetlabs-ntp' => '8.1.0',
-          'example-myapp1' => {
-            'git' => 'https://git.example.com/puppet/example-myapp1.git',
-            'ref' => 'v1.3.1'
-          }
-        }
-      }
-    }
-  end
-
-  describe 'initialize' do
-    context 'with a valid command' do
-      context 'that produces valid output' do
-        it 'accepts json' do
-          allow_any_instance_of(R10K::Util::Subprocess)
-            .to receive(:execute)
-            .and_return(double('result', stdout: environments_hash.to_json))
-
-          source = described_class.new('execsource', '/some/nonexistent/dir', command: '/path/to/command')
-          expect(source.environments.map(&:name)).to contain_exactly('production', 'development')
-        end
-
-        it 'accepts yaml' do
-          allow_any_instance_of(R10K::Util::Subprocess)
-            .to receive(:execute)
-            .and_return(double('result', stdout: environments_hash.to_yaml))
-
-          source = described_class.new('execsource', '/some/nonexistent/dir', command: '/path/to/command')
-          expect(source.environments.map(&:name)).to contain_exactly('production', 'development')
-        end
-
-      end
-
-      context 'that produces invalid output' do
-        it 'raises an error for non-json, non-yaml data' do
-          allow_any_instance_of(R10K::Util::Subprocess)
-            .to receive(:execute)
-            .and_return(double('result', stdout: "one:\ntwo\n"))
-
-          source = described_class.new('execsource', '/some/nonexistent/dir', command: '/path/to/command')
-          expect { source.environments }.to raise_error(/Error parsing command output/)
-        end
-
-        it 'raises an error for yaml data that is not a hash' do
-          allow_any_instance_of(R10K::Util::Subprocess)
-            .to receive(:execute)
-            .and_return(double('result', stdout: "[one, two]"))
-
-          source = described_class.new('execsource', '/some/nonexistent/dir', command: '/path/to/command')
-          expect { source.environments }.to raise_error(R10K::Error, /Environment source execsource.*did not return valid environment data.*one.*two.*/m)
-        end
-      end
-    end
-  end
-end