r10k 3.5.2

data/spec/unit/settings_spec.rb

@@ -0,0 +1,246 @@
+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
+  end
+
+  describe "deploy settings" do
+    subject { described_class.deploy_settings }
+
+    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
+  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"})
+        expect(output[:forge]).to eq(:baseurl => "https://forge.tessier-ashpool.freeside", :proxy => "https://proxy.tessier-ashpool.freesize:3128")
+      end
+    end
+  end
+end

data/spec/unit/source/base_spec.rb

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

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

data/spec/unit/source/git_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+require 'r10k/source'
+
+describe R10K::Source::Git do
+
+  subject do
+    described_class.new('mysource', '/some/nonexistent/dir',
+                        {:remote => 'https://git-server/repo.git'})
+  end
+
+  it "stores the name" do
+    expect(subject.name).to eq 'mysource'
+  end
+
+  it "stores the basedir" do
+    expect(subject.basedir).to eq '/some/nonexistent/dir'
+  end
+
+  describe "preloading" do
+    it "fetches the git cache" do
+      expect(subject.cache).to receive(:sync)
+      subject.preload!
+    end
+  end
+
+  describe "lazily generating environments" do
+    it "returns an empty list of environments when the cache has not been created" do
+      allow(subject.cache).to receive(:cached?).and_return false
+      expect(subject.environments).to be_empty
+    end
+
+    it "generates environments when the cache is present and environments have not been loaded" do
+      allow(subject.cache).to receive(:cached?).and_return true
+      allow(subject).to receive(:generate_environments).and_return %w[hi]
+      expect(subject.environments.size).to eq(1)
+    end
+
+    it "doesn't recreate environments if they have already been loaded" do
+      allow(subject.cache).to receive(:cached?).and_return true
+      allow(subject).to receive(:generate_environments).once.and_return %w[hi]
+      expect(subject.environments.size).to eq(1)
+      expect(subject.environments.size).to eq(1)
+    end
+  end
+
+  describe "eagerly generating environments" do
+    before do
+      allow(subject.cache).to receive(:branches).and_return %w[master]
+    end
+
+    let(:master_env) { subject.generate_environments.first }
+
+    it "creates an environment for each branch" do
+      expect(subject.generate_environments.size).to eq(1)
+    end
+
+    it "copies the source remote to the environment" do
+      expect(master_env.remote).to eq subject.remote
+    end
+
+    it "uses the branch name as the directory by default" do
+      expect(master_env.dirname).to eq 'master'
+    end
+  end
+
+  describe "generate_environments respects ignore_branch_prefixes setting" do
+    before do
+      allow(subject.cache).to receive(:branches).and_return ['master', 'development', 'production', 'not_dev_test_me', 'dev_test', 'dev', 'test_2']
+      subject.instance_variable_set(:@ignore_branch_prefixes, ['dev', 'test'])
+    end
+
+    let(:environments) { subject.generate_environments }
+
+    it "creates an environment for each branch not in ignore_branch_prefixes" do
+      expect(subject.generate_environments.size).to eq(3)
+    end
+
+    it "copies the source remote to the environment" do
+      expect(environments[0].remote).to eq subject.remote
+      expect(environments[1].remote).to eq subject.remote
+      expect(environments[2].remote).to eq subject.remote
+    end
+
+    it "uses the branch name as the directory by default" do
+      expect(environments[0].dirname).to eq 'master'
+      expect(environments[1].dirname).to eq 'production'
+      expect(environments[2].dirname).to eq 'not_dev_test_me'
+    end
+  end
+
+  describe "filtering branches with ignore prefixes" do
+    let(:branches) { ['master', 'development', 'production', 'not_dev_test_me', 'dev_test', 'dev', 'test_2'] }
+    let(:ignore_prefixes) { ['dev', 'test'] }
+
+    it "filters branches" do
+      expect(subject.filter_branches(branches, ignore_prefixes)).to eq(['master', 'production', 'not_dev_test_me'])
+    end
+  end
+end
+
+describe R10K::Source::Git, "handling invalid branch names" do
+  %w[correct_and_warn correct].each do |setting|
+    describe "when invalid is #{setting}" do
+      subject do
+        described_class.new('/some/nonexistent/dir', 'mysource', {
+          :remote           => 'https://git-server/repo.git',
+          :invalid_branches => setting
+        })
+      end
+
+      before do
+        allow(subject.cache).to receive(:branches).and_return ['master', 'invalid-branch']
+      end
+
+      it "creates an environment for each branch" do
+        expect(subject.generate_environments.size).to eq(2)
+      end
+
+      it "removes invalid characters from branch names" do
+        invalid_env = subject.generate_environments.last
+        expect(invalid_env.dirname).to eq 'invalid_branch'
+      end
+    end
+  end
+
+  describe "when invalid is 'error'" do
+    subject do
+      described_class.new('/some/nonexistent/dir', 'mysource', {
+        :remote   => 'https://git-server/repo.git',
+        :invalid_branches => 'error',
+      })
+    end
+
+    before do
+      allow(subject.cache).to receive(:branches).and_return ['master', 'invalid-branch']
+    end
+
+    it "only creates an environment for valid branches" do
+      expect(subject.generate_environments.size).to eq(1)
+    end
+  end
+end
+
+# Since prefixing is an immutable property of a source, it's easier to create
+# a new context and duplicate stubs in a single location rather than packing a
+# single test with all the stubs that entirely recreate the source.
+describe R10K::Source::Git, 'when prefixing is enabled' do
+  subject do
+    described_class.new(
+      'prefixed',
+      '/some/nonexistent/dir',
+      {
+        :prefix => true,
+        :remote => 'https://git-server/repo.git',
+      })
+  end
+
+  describe "generating prefixed environments" do
+    before do
+      allow(subject.cache).to receive(:cached?).and_return true
+      allow(subject.cache).to receive(:branches).and_return %w[master other]
+    end
+
+    let(:environments) { subject.environments }
+
+    it "creates an environment for each branch" do
+      expect(subject.environments.size).to eq(2)
+    end
+
+    it "prefixes the source name to environments when prefixing is enabled" do
+      expect(environments[0].dirname).to eq 'prefixed_master'
+      expect(environments[1].dirname).to eq 'prefixed_other'
+    end
+  end
+end
+
+describe R10K::Source::Git, 'registering as a source' do
+  it "registers with the :git key" do
+    expect(R10K::Source.retrieve(:git)).to eq described_class
+  end
+
+  it "registers with the nil key" do
+    expect(R10K::Source.retrieve(nil)).to eq described_class
+  end
+end