r10k 1.4.2 → 1.5.1

data/spec/unit/settings/container_spec.rb

@@ -65,4 +65,21 @@ describe R10K::Settings::Container do
       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/source/git_spec.rb

@@ -149,126 +149,3 @@ describe R10K::Source::Git, 'registering as a source' do
     expect(R10K::Source.retrieve(nil)).to eq described_class
   end
 end
-
-describe R10K::Source::Git::BranchName do
-  describe "prefixing" do
-    it "uses the branch name as the dirname when prefixing is off" do
-      bn = described_class.new('mybranch', {:prefix => false, :sourcename => 'foo'})
-      expect(bn.dirname).to eq 'mybranch'
-    end
-
-    it "prepends the source name when prefixing is on" do
-      bn = described_class.new('mybranch', {:prefix => true, :sourcename => 'foo'})
-      expect(bn.dirname).to eq 'foo_mybranch'
-    end
-  end
-
-  describe "determining the validate behavior with :invalid" do
-    [
-      ['correct_and_warn', {:validate => true, :correct => true}],
-      ['correct',          {:validate => false, :correct => true}],
-      ['error',            {:validate => true, :correct => false}],
-    ].each do |(setting, outcome)|
-      it "treats #{setting} as #{outcome.inspect}" do
-        bn = described_class.new('mybranch', {:invalid => setting})
-        expect(bn.validate?).to eq outcome[:validate]
-        expect(bn.correct?).to eq outcome[:correct]
-      end
-    end
-  end
-
-  describe "determining if a branch is a valid environment name" do
-    invalid_cases = [
-      'hyphenated-branch',
-      'dotted.branch',
-      'slashed/branch',
-      'at@branch',
-      'http://branch'
-    ]
-
-    valid_cases = [
-      'my_branchname',
-      'my_issue_346',
-    ]
-
-    describe "and validate is false" do
-      invalid_cases.each do |branch|
-        it "is valid if the branch is #{branch}" do
-          bn = described_class.new(branch, {:validate => false})
-          expect(bn).to be_valid
-        end
-      end
-
-      valid_cases.each do |branch|
-        it "is valid if the branch is #{branch}" do
-          bn = described_class.new(branch, {:validate => false})
-          expect(bn).to be_valid
-        end
-      end
-    end
-
-    describe "and validate is true" do
-      invalid_cases.each do |branch|
-        it "is invalid if the branch is #{branch}" do
-          bn = described_class.new(branch, {:validate => true})
-          expect(bn).to_not be_valid
-        end
-      end
-
-      valid_cases.each do |branch|
-        it "is valid if the branch is #{branch}" do
-          bn = described_class.new(branch, {:validate => true})
-          expect(bn).to be_valid
-        end
-      end
-
-    end
-  end
-
-  describe "correcting branch names" do
-    invalid_cases = [
-      'hyphenated-branch',
-      'dotted.branch',
-      'slashed/branch',
-      'at@branch',
-      'http://branch'
-    ]
-
-    valid_cases = [
-      'my_branchname',
-      'my_issue_346',
-    ]
-
-    describe "and correct is false" do
-      invalid_cases.each do |branch|
-        it "doesn't modify #{branch}" do
-          bn = described_class.new(branch.dup, {:correct => false})
-          expect(bn.dirname).to eq branch
-        end
-      end
-
-      valid_cases.each do |branch|
-        it "doesn't modify #{branch}" do
-          bn = described_class.new(branch.dup, {:correct => false})
-          expect(bn.dirname).to eq branch
-        end
-      end
-    end
-
-    describe "and correct is true" do
-      invalid_cases.each do |branch|
-        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/, '_')
-        end
-      end
-
-      valid_cases.each do |branch|
-        it "doesn't modify #{branch}" do
-          bn = described_class.new(branch.dup, {:correct => true})
-          expect(bn.dirname).to eq branch
-        end
-      end
-    end
-  end
-end

data/spec/unit/source/svn_spec.rb

@@ -95,6 +95,72 @@ describe R10K::Source::SVN, 'when prefixing is enabled' do
   end
 end
 
+describe R10K::Source::SVN, 'when prefixing is disabled' do
+  subject do
+    described_class.new(
+    'mysource',
+    '/some/nonexistent/dir',
+    {
+      :remote => 'https://svn-server.site/repo',
+      :prefix => false
+    }
+    )
+  end
+
+  describe "generating environments" do
+    before do
+      allow(subject.svn_remote).to receive(:branches).and_return %w[apache dns robobutler]
+    end
+
+    let(:environments) { subject.generate_environments }
+
+    it "creates an environment for each branch and the trunk" do
+      expect(environments.size).to eq(4)
+    end
+
+    it "does not prefix environments" do
+      expect(environments[0].dirname).to eq 'production'
+      expect(environments[1].dirname).to eq 'apache'
+      expect(environments[2].dirname).to eq 'dns'
+      expect(environments[3].dirname).to eq 'robobutler'
+    end
+  end
+end
+
+
+describe R10K::Source::SVN, 'when prefixing is overridden' do
+  subject do
+    described_class.new(
+    'mysource',
+    '/some/nonexistent/dir',
+    {
+      :remote => 'https://svn-server.site/repo',
+      :prefix => "tenant1"
+    }
+    )
+  end
+
+  describe "generating prefixed environments" do
+    before do
+      allow(subject.svn_remote).to receive(:branches).and_return %w[apache dns robobutler]
+    end
+
+    let(:environments) { subject.generate_environments }
+
+    it "creates an environment for each branch and the trunk" do
+      expect(environments.size).to eq(4)
+    end
+
+    it "prefixes the prefix name to environments" do
+      expect(environments[0].dirname).to eq 'tenant1_production'
+      expect(environments[1].dirname).to eq 'tenant1_apache'
+      expect(environments[2].dirname).to eq 'tenant1_dns'
+      expect(environments[3].dirname).to eq 'tenant1_robobutler'
+    end
+  end
+end
+
+
 describe R10K::Source::SVN, 'registering as a source' do
   it "registers with the :svn key" do
     expect(R10K::Source.retrieve(:svn)).to eq described_class

data/spec/unit/util/commands_spec.rb

@@ -0,0 +1,61 @@
+require 'r10k/util/commands'
+require 'r10k/util/exec_env'
+
+require 'tmpdir'
+
+describe R10K::Util::Commands do
+  describe "#which" do
+
+    before do
+      allow(File).to receive(:executable?).and_return false
+      allow(File).to receive(:file?).and_return false
+    end
+
+    def stub_executable(exe)
+      allow(File).to receive(:executable?).with(exe).and_return true
+      allow(File).to receive(:file?).with(exe).and_return true
+    end
+
+    describe "when ENV['PATHEXT'] is unset" do
+      let(:path) { Dir.mktmpdir }
+
+      around(:each) do |example|
+        R10K::Util::ExecEnv.withenv('PATHEXT' => nil, 'PATH' => path) do
+          example.run
+        end
+      end
+
+      it "returns the first matching command in PATH" do
+        exe = File.join(path, 'git')
+        stub_executable(exe)
+        expect(described_class.which("git")).to eq exe
+      end
+
+      it "returns nil if the command could not be found" do
+        exe = File.join(path, 'git')
+        expect(described_class.which("git")).to be_nil
+      end
+    end
+
+    describe "when ENV['PATHEXT'] is set" do
+      let(:path) { Dir.mktmpdir }
+
+      around(:each) do |example|
+        R10K::Util::ExecEnv.withenv('PATHEXT' => '.bat;.exe;.cmd', 'PATH' => path) do
+          example.run
+        end
+      end
+
+      it "returns the first matching command in PATH" do
+        exe = File.join(path, 'git.exe')
+        stub_executable(exe)
+        expect(described_class.which("git")).to eq exe
+      end
+
+      it "returns nil if the command could not be found" do
+        exe = File.join(path, 'git.exe')
+        expect(described_class.which("git")).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/util/exec_env_spec.rb

@@ -0,0 +1,56 @@
+require 'r10k/util/exec_env'
+
+describe R10K::Util::ExecEnv do
+  describe "withenv" do
+    it "adds the keys to the environment during the block" do
+      val = nil
+      described_class.withenv('VAL' => 'something') do
+        val = ENV['VAL']
+      end
+      expect(val).to eq 'something'
+    end
+
+    it "doesn't modify values that were not modified by the passed hash" do
+      origpath = ENV['PATH']
+      path = nil
+      described_class.withenv('VAL' => 'something') do
+        path = ENV['PATH']
+      end
+      expect(path).to eq origpath
+    end
+
+    it "removes new values after the block" do
+      val = nil
+      described_class.withenv('VAL' => 'something') { }
+      expect(ENV['VAL']).to be_nil
+    end
+
+    it "restores old values after the block" do
+      path = ENV['PATH']
+      described_class.withenv('PATH' => '/usr/bin') { }
+      expect(ENV['PATH']).to eq path
+    end
+  end
+
+  describe "reset" do
+
+    after { ENV.delete('VAL') }
+
+    it "replaces environment keys with the specified keys" do
+      ENV['VAL'] = 'hi'
+
+      newenv = ENV.to_hash
+      newenv['VAL'] = 'bye'
+
+      described_class.reset(newenv)
+      expect(ENV['VAL']).to eq 'bye'
+    end
+
+    it "removes any keys that were not provided" do
+      env = ENV.to_hash
+      ENV['VAL'] = 'hi'
+      described_class.reset(env)
+      expect(ENV['VAL']).to be_nil
+    end
+  end
+end

data/spec/unit/util/subprocess/runner/posix_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'r10k/util/subprocess/runner'
+
+describe R10K::Util::Subprocess::Runner::POSIX, :if => R10K::Util::Platform.posix? do
+  fixture_root = File.expand_path('spec/fixtures/unit/util/subprocess/posix/runner', PROJECT_ROOT)
+  it_behaves_like 'a subprocess runner', fixture_root
+end

data/spec/unit/util/subprocess/runner/pump_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'r10k/util/subprocess/runner/pump'
+
+describe R10K::Util::Subprocess::Runner::Pump do
+
+  let(:pair) { IO.pipe }
+  let(:r) { pair.first }
+  let(:w) { pair.last }
+
+  after do
+    pair.each { |io| io.close unless io.closed? }
+  end
+
+  subject { described_class.new(r) }
+
+  it "returns an empty string if nothing has been read" do
+    expect(subject.string).to eq('')
+  end
+
+  describe "reading all data in the stream" do
+    it "reads data until the stream reaches EOF" do
+      subject.start
+      w << "hello"
+      w << " "
+      w << "world!"
+      w.close
+      subject.wait
+      expect(subject.string).to eq("hello world!")
+    end
+  end
+
+  describe "halting" do
+    it "does not read any more information read off the pipe" do
+      subject.min_delay = 0.01
+      subject.start
+      w << "hello"
+
+      # This should ensure that we yield to the pumping thread. If this test
+      # sporadically fails then we may need to increase the timeout.
+      sleep 0.1
+      subject.halt!
+      w << " world!"
+
+      expect(subject.string).to eq("hello")
+    end
+  end
+
+  describe "backing off" do
+    it "does not back off more than the max delay time" do
+      max_delay = subject.min_delay * 2
+      subject.max_delay = max_delay
+      subject.start
+      sleep max_delay * 2
+
+      Timeout.timeout(max_delay * 1.5) do
+        subject.halt!
+      end
+
+    end
+  end
+
+  # Linux 2.6.11+ has a maximum pipe capacity of 64 KiB, and writing to the
+  # pipe when the pipe is at capacity will block. To make sure the pump is
+  # actively removing contents from the pipe we need to attempt to fill up
+  # the entire pipe.
+  #
+  # See man pipe(7)
+  it "does not block if more than 64 kilobytes are fed into the pipe" do
+    # The maximum pipe buffer size is 2 ** 16 bytes, so that's the minimum
+    # amount of data needed to cause further writes to block. We then double
+    # this value to make sure that we are continuously emptying the pipe.
+    pipe_buffer_size = 2 ** 17
+    blob = "buffalo!" * pipe_buffer_size
+    subject.start
+    Timeout.timeout(60) { w << blob }
+    w.close
+    subject.wait
+  end
+end

data/spec/unit/util/subprocess_spec.rb

@@ -6,11 +6,12 @@ describe R10K::Util::Subprocess do
   describe "selecting the runner implementation" do
     it "uses the windows implementation on Windows platforms" do
       expect(R10K::Util::Platform).to receive(:windows?).and_return true
-      expect(described_class.runner).to eq R10K::Util::Subprocess::Windows::Runner
+      expect(described_class.runner).to eq R10K::Util::Subprocess::Runner::Windows
     end
+
     it "uses the posix implementation when not on windows" do
       expect(R10K::Util::Platform).to receive(:windows?).and_return true
-      expect(described_class.runner).to eq R10K::Util::Subprocess::Windows::Runner
+      expect(described_class.runner).to eq R10K::Util::Subprocess::Runner::Windows
     end
   end
 

data/spec/unit/util/symbolize_keys_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'r10k/util/symbolize_keys'
+
+describe R10K::Util::SymbolizeKeys do
+  it "deletes all keys that are strings" do
+    hash = {'foo' => 'bar', :baz => 'quux'}
+    described_class.symbolize_keys!(hash)
+    expect(hash).to_not have_key('foo')
+  end
+
+  it "replaces the deleted keys with interned strings" do
+    hash = {'foo' => 'bar', :baz => 'quux'}
+
+    described_class.symbolize_keys!(hash)
+    expect(hash[:foo]).to eq 'bar'
+  end
+
+  it "raises an error if there is an existing symbol for a given string key" do
+    hash = {'foo' => 'bar', :foo => 'quux'}
+
+    expect {
+      described_class.symbolize_keys!(hash)
+    }.to raise_error(TypeError, /An existing interned key/)
+  end
+
+  it "does not modify existing symbol entries" do
+    hash = {'foo' => 'bar', :baz => 'quux'}
+
+    described_class.symbolize_keys!(hash)
+    expect(hash[:baz]).to eq 'quux'
+  end
+
+  it "does not modify keys that are not strings or symbols" do
+    key = %w[foo]
+    hash = {key => 'bar', :baz => 'quux'}
+    described_class.symbolize_keys!(hash)
+    expect(hash[key]).to eq 'bar'
+  end
+
+  it "can recursively symbolize keys in nested hash values" do
+    hash = {'foo' => {'bar' => 'baz'}}
+    described_class.symbolize_keys!(hash, true)
+    expect(hash).to eq({:foo => {:bar => 'baz'}})
+  end
+
+  it "recurses into hash values that had symbol keys" do
+    hash = {:foo => {'bar' => {'baz' => 'quux'}}}
+    described_class.symbolize_keys!(hash, true)
+    expect(hash).to eq({:foo => {:bar => {:baz => 'quux'}}})
+  end
+end