r10k 3.15.0 → 4.1.0

data/spec/unit/util/subprocess/result_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'r10k/util/subprocess'
-
-describe R10K::Util::Subprocess::Result do
-  describe "formatting" do
-    it "includes the exit code" do
-      result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
-      expect(result.format).to match(%r[Exit code: 42])
-    end
-
-    describe "stdout" do
-      it "is omitted when empty" do
-        result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
-        expect(result.format).to_not match(%r[Stdout])
-      end
-      it "is included when non-empty" do
-        result = described_class.new(%w[/usr/bin/gti --zoom], 'stuff here', '', 42)
-        expect(result.format).to match(%r[Stdout:])
-        expect(result.format).to match(%r[stuff here])
-      end
-    end
-
-    describe "stderr" do
-      it "is omitted when empty" do
-        result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
-        expect(result.format).to_not match(%r[Stderr])
-      end
-
-      it "is included when non-empty" do
-        result = described_class.new(%w[/usr/bin/gti --zoom], '', 'other stuff', 42)
-        expect(result.format).to match(%r[Stderr:])
-        expect(result.format).to match(%r[other stuff])
-      end
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-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/runner', PROJECT_ROOT)
-  it_behaves_like 'a subprocess runner', fixture_root
-end

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

@@ -1,79 +0,0 @@
-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/runner/windows_spec.rb

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

data/spec/unit/util/subprocess/subprocess_error_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'r10k/util/subprocess'
-
-describe R10K::Util::Subprocess::SubprocessError do
-  let(:result) do
-    R10K::Util::Subprocess::Result.new(%w[/usr/bin/gti --zoom], "zooming on stdout", "zooming on stderr", 42)
-  end
-
-  describe "formatting the message" do
-    subject(:message) { described_class.new("Execution failed", :result => result).message }
-
-    it "includes the exception message and formatted result" do
-      expect(message).to eq(
-        [
-          "Execution failed:",
-          "Command: /usr/bin/gti --zoom",
-          "Stdout:",
-          "zooming on stdout",
-          "Stderr:",
-          "zooming on stderr",
-          "Exit code: 42",
-        ].join("\n")
-      )
-    end
-  end
-end

data/spec/unit/util/subprocess_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-require 'r10k/util/subprocess'
-
-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::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::Runner::Windows
-    end
-  end
-
-  describe "running commands" do
-    subject { described_class.new(['/bin/echo', 'hello', 'world']) }
-
-    let(:runner) do
-      double('R10K::Util::Subprocess::Runner').tap do |i|
-        allow(i).to receive(:run).and_return(result)
-      end
-    end
-
-    let(:result) { double('R10K::Util::Subprocess::Result').as_null_object }
-
-    before do
-      allow(described_class).to receive(:runner).and_return(double(:new => runner))
-    end
-
-    it "copies the cwd to the runner if a cwd is given" do
-      expect(runner).to receive(:cwd=).with('/tmp')
-      subject.cwd = '/tmp'
-      subject.execute
-    end
-
-    it "returns the result from the execution" do
-      expect(subject.execute).to eq result
-    end
-
-    describe "when the command returned with a non-zero exit status" do
-      before do
-        allow(runner).to receive(:crashed?).and_return true
-      end
-
-      it "raises an exception if raise_on_fail is true" do
-        subject.raise_on_fail = true
-
-        allow(result).to receive(:exit_code).and_return(255)
-        allow(result).to receive(:stderr).and_return('Command not found')
-
-        expect {
-          subject.execute
-        }.to raise_error(R10K::Util::Subprocess::SubprocessError, /Command exited with non-zero exit code/)
-      end
-
-      it "doesn't raise an exception if raise_on_fail is false" do
-        subject.raise_on_fail = false
-        expect { subject.execute }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/unit/util/symbolize_keys_spec.rb

@@ -1,67 +0,0 @@
-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
-
-  context "when symbolizing recursively" do
-    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
-
-    it "recurses into array values whose items are hashes" do
-      hash = {'foo' => [ {'item1_key' => 'val'}, {'item2_key' => 'val'} ]}
-
-      described_class.symbolize_keys!(hash, true)
-      expect(hash).to eq({:foo => [ {:item1_key => 'val'}, {:item2_key => 'val'} ]})
-    end
-
-    it "ignores nested array items that are not hashes" do
-      hash = {'foo' => [ {'item1_key' => 'val'}, 'banana' ]}
-
-      described_class.symbolize_keys!(hash, true)
-      expect(hash).to eq({:foo => [ {:item1_key => 'val'}, 'banana' ]})
-    end
-  end
-end