aruba 0.14.14 → 1.0.0.pre.alpha.1

data/spec/aruba/api/runtime_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'aruba' do
-  describe '#config' do
-    subject(:config) { aruba.config }
-
-    if RUBY_VERSION >= '1.9'
-      context 'when initialized' do
-        it { is_expected.to eq Aruba.config }
-      end
-    end
-
-    context 'when changed earlier' do
-      context 'values when init' do
-        let(:value) { 20 }
-        before(:each) { aruba.config.io_wait_timeout = value }
-
-        it { expect(config.io_wait_timeout).to eq value }
-      end
-
-      context 'default value' do
-        let(:value) { 0.1 } # Aruba.config.io_wait_timeout
-
-        it { expect(config.io_wait_timeout).to eq value }
-      end
-    end
-  end
-end

data/spec/aruba/api_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-require 'aruba/api'
-require 'fileutils'
-require 'time'
-
-describe Aruba::Api do
-  include_context 'uses aruba API'
-
-  describe 'tags' do
-    describe '@announce_stdout' do
-      after(:each) { @aruba.all_commands.each(&:stop) }
-
-      context 'enabled' do
-        before :each do
-          @aruba.aruba.announcer = instance_double 'Aruba::Platforms::Announcer'
-          expect(@aruba.aruba.announcer).to receive(:announce).with(:stdout) { "hello world\n" }
-          allow(@aruba.aruba.announcer).to receive(:announce)
-        end
-
-        it "should announce to stdout exactly once" do
-          @aruba.run_command_and_stop('echo "hello world"')
-          expect(@aruba.last_command_started.output).to include('hello world')
-        end
-      end
-
-      context 'disabled' do
-        it "should not announce to stdout" do
-          result = capture(:stdout) do
-            @aruba.run_command_and_stop('echo "hello world"')
-          end
-
-          expect(result).not_to include('hello world')
-          expect(@aruba.last_command_started.output).to include('hello world')
-        end
-      end
-    end
-  end
-
-  describe 'fixtures' do
-    let(:api) do
-      klass = Class.new do
-        include Aruba::Api
-
-        def root_directory
-          expand_path('.')
-        end
-      end
-
-      klass.new
-    end
-  end
-
-  describe "#set_environment_variable" do
-    after(:each) do
-      @aruba.all_commands.each(&:stop)
-    end
-
-    it "set environment variable" do
-      @aruba.set_environment_variable 'LONG_LONG_ENV_VARIABLE', 'true'
-      @aruba.run_command_and_stop "env"
-      expect(@aruba.last_command_started.output).
-        to include("LONG_LONG_ENV_VARIABLE=true")
-    end
-
-    it "overwrites environment variable" do
-      @aruba.set_environment_variable 'LONG_LONG_ENV_VARIABLE', 'true'
-      @aruba.set_environment_variable 'LONG_LONG_ENV_VARIABLE', 'false'
-      @aruba.run_command_and_stop "env"
-      expect(@aruba.last_command_started.output).
-        to include("LONG_LONG_ENV_VARIABLE=false")
-    end
-  end
-end # Aruba::Api

data/spec/aruba/aruba_path_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'aruba/aruba_path'
-
-RSpec.describe Aruba::ArubaPath do
-  subject(:path) { described_class.new(new_path) }
-
-  let(:new_path) { 'path/to/dir' }
-
-  it { expect(path).to be }
-
-  describe '#to_s' do
-  end
-
-  describe '#to_s' do
-    context 'when string is used' do
-      it { expect(path.to_s).to eq new_path }
-    end
-
-    # make it compatible with the old API
-    context 'when array is used' do
-      let(:net_path) { %w(path to dir) }
-
-      it { expect(path.to_s).to eq File.join(*new_path) }
-    end
-  end
-
-  describe '#push' do
-    before(:each) { path.push 'subdir' }
-
-    it { expect(path.to_s).to eq 'path/to/dir/subdir' }
-  end
-
-  describe '#<<' do
-    before(:each) { path << 'subdir' }
-
-    it { expect(path.to_s).to eq 'path/to/dir/subdir' }
-  end
-
-  describe '#pop' do
-    before(:each) { path << 'subdir' }
-    before(:each) { path.pop }
-
-    it { expect(path.to_s).to eq 'path/to/dir' }
-  end
-
-  describe '#relative?' do
-    context 'when is relative' do
-      it { expect(path).to be_relative }
-    end
-
-    context 'when is absolute' do
-      let(:new_path) { '/absolute/path' }
-      it { expect(path).not_to be_relative }
-    end
-  end
-
-  describe '#[]' do
-    context 'when single index' do
-      it { expect(path[0]).to eq 'p' }
-    end
-
-    context 'when range' do
-      it { expect(path[0..1]).to eq 'pa' }
-    end
-  end
-
-  describe '#depth' do
-    context 'when relative path' do
-      it { expect(path.depth).to eq 3 }
-    end
-
-    context 'when absolute path' do
-      let(:new_path) { '/path/to/dir' }
-      it { expect(path.depth).to eq 3 }
-    end
-  end
-
-  describe '#end_with?' do
-    it { expect(path).to be_end_with 'dir' }
-  end
-
-  describe '#start_with?' do
-    it { expect(path).to be_start_with 'path/to' }
-  end
-
-  describe '#relative?' do
-    it { expect(path).to be_relative }
-  end
-
-  describe '#absolute?' do
-    let(:new_path) { '/path/to/dir' }
-    it { expect(path).to be_absolute }
-  end
-
-  describe '#blocks' do
-    let(:new_path) { expand_path('path/to/file') }
-
-    before(:each) { FileUtils.mkdir_p File.dirname(new_path) }
-    before(:each) { File.open(new_path, 'w') { |f| f.print 'a' } }
-
-    it { expect(path.blocks).to be > 0 }
-  end
-end

data/spec/aruba/basic_configuration_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::BasicConfiguration do
-  it_behaves_like 'a basic configuration'
-end

data/spec/aruba/configuration_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::Configuration do
-  it_behaves_like 'a basic configuration'
-end

data/spec/aruba/hooks_spec.rb

@@ -1,17 +0,0 @@
-require 'aruba/config'
-
-describe Aruba::Hooks do
-  it 'executes a stored hook' do
-    hook_was_run = false
-    subject.append :hook_label, lambda { hook_was_run = true }
-    subject.execute :hook_label, self
-    expect(hook_was_run).to be_truthy
-  end
-
-  it 'executes a stored hook that takes multiple arguments' do
-    hook_values = []
-    subject.append :hook_label, lambda { |a,b,c| hook_values = [a,b,c] }
-    subject.execute :hook_label, self, 1, 2, 3
-    expect(hook_values).to eq [1,2,3]
-  end
-end

data/spec/aruba/in_config_wrapper_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::InConfigWrapper do
-  subject(:wrapper) { described_class.new(config) }
-
-  let(:config) { {} }
-
-  context 'when option is defined' do
-    before :each do
-      config[:opt] = true
-    end
-
-    context 'when valid' do
-      it { expect(wrapper.opt).to be true }
-    end
-
-    context 'when one tries to pass arguments to option' do
-      it { expect{ wrapper.opt('arg') }.to raise_error ArgumentError, 'Options take no argument' }
-    end
-  end
-
-  context 'when option is not defined' do
-    it { expect{ wrapper.opt }.to raise_error ArgumentError, 'Option "opt" is unknown. Please use only earlier defined options' }
-  end
-end

data/spec/aruba/jruby_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-require 'aruba/api'
-
-describe "Aruba JRuby Startup Helper" do
-  include Aruba::Api
-
-  let(:rb_config) { double('RbConfig::CONFIG') }
-  let(:command) do
-    instance_double(Aruba::Processes::BasicProcess, :environment => command_environment)
-  end
-  let(:command_environment) { { 'JRUBY_OPTS' => '--1.9', 'JAVA_OPTS' => '-Xdebug' } }
-
-  before do
-    Aruba.config.reset
-
-    # Define before :command hook
-    load 'aruba/config/jruby.rb'
-  end
-
-  context 'when running under some MRI Ruby' do
-    before do
-      stub_const('RUBY_PLATFORM', 'x86_64-chocolate')
-    end
-
-    it 'keeps the existing JRUBY_OPTS and JAVA_OPTS environment values' do
-      # Run defined before :command hook
-      Aruba.config.before :command, self, command
-
-      aggregate_failures do
-        expect(command_environment['JRUBY_OPTS']).to eq '--1.9'
-        expect(command_environment['JAVA_OPTS']).to eq '-Xdebug'
-      end
-    end
-  end
-
-  context 'when running under JRuby but not on Solaris' do
-    before do
-      stub_const 'RUBY_PLATFORM', 'java'
-      stub_const 'RbConfig::CONFIG', rb_config
-
-      allow(rb_config).to receive(:[]).with('host_os').and_return('foo-os')
-    end
-
-    it 'updates the existing JRuby but not Java option values' do
-      # Run defined before :command hook
-      Aruba.config.before :command, self, command
-
-      aggregate_failures do
-        expect(command_environment['JRUBY_OPTS']).to eq '--dev -X-C --1.9'
-        expect(command_environment['JAVA_OPTS']).to eq '-Xdebug'
-      end
-    end
-  end
-
-  context 'when running under JRuby on Solaris' do
-    before :each do
-      stub_const 'RUBY_PLATFORM', 'java'
-      stub_const 'RbConfig::CONFIG', rb_config
-
-      allow(rb_config).to receive(:[]).with('host_os').and_return('solaris')
-    end
-
-    it 'keeps the existing JRuby and Java option values' do
-      # Run defined before :command hook
-      Aruba.config.before :command, self, command
-
-      aggregate_failures do
-        expect(command_environment['JRUBY_OPTS']).to eq '--dev -X-C --1.9'
-        expect(command_environment['JAVA_OPTS']).to eq '-d32 -Xdebug'
-      end
-    end
-  end
-end

data/spec/aruba/matchers/command/have_output_size_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Output Matchers' do
-  include_context 'uses aruba API'
-
-  def expand_path(*args)
-    @aruba.expand_path(*args)
-  end
-
-  describe '#to_have_output_size' do
-    let(:obj) { 'string' }
-
-    context 'when has size' do
-      context 'when is string' do
-        it { expect(obj).to have_output_size 6 }
-      end
-    end
-
-    context 'when does not have size' do
-      let(:obj) { 'string' }
-
-      it { expect(obj).not_to have_output_size(-1) }
-    end
-  end
-end

data/spec/aruba/matchers/command_spec.rb

@@ -1,174 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Command Matchers' do
-  include_context 'uses aruba API'
-
-  def expand_path(*args)
-    @aruba.expand_path(*args)
-  end
-
-  def announcer(*args)
-    @aruba.send(:announcer, *args)
-  end
-
-  describe '#to_have_exit_status' do
-    let(:cmd) { 'true' }
-
-    before(:each) { run_command(cmd) }
-
-    context 'when has exit 0' do
-      it { expect(last_command_started).to have_exit_status 0 }
-    end
-
-    context 'when has exit 0' do
-      let(:cmd) { 'false' }
-      it { expect(last_command_started).not_to have_exit_status 0 }
-    end
-  end
-
-  describe '#to_be_successfully_executed_' do
-    let(:cmd) { 'true' }
-
-    before(:each) { run_command(cmd) }
-
-    context 'when has exit 0' do
-      it { expect(last_command_started).to be_successfully_executed }
-    end
-
-    context 'when has exit 0' do
-      let(:cmd) { 'false' }
-      it { expect(last_command_started).not_to be_successfully_executed }
-    end
-  end
-
-  describe '#to_have_output' do
-    let(:cmd) { "echo #{output}" }
-    let(:output) { 'hello world' }
-
-    context 'when have output hello world on stdout' do
-      before(:each) { run_command(cmd) }
-      it { expect(last_command_started).to have_output output }
-    end
-
-    context 'when multiple commands output hello world on stdout' do
-      context 'and all comands must have the output' do
-        before(:each) do
-          run_command(cmd)
-          run_command(cmd)
-        end
-
-        it { expect(all_commands).to all have_output output }
-      end
-
-      context 'and any comand can have the output' do
-        before(:each) do
-          run_command(cmd)
-          run_command('echo hello universe')
-        end
-
-        it { expect(all_commands).to include have_output(output) }
-      end
-    end
-
-    context 'when have output hello world on stderr' do
-      before :each do
-        string = <<-EOS.strip_heredoc
-        #!/usr/bin/env bash
-
-        echo $* >&2
-        EOS
-
-        File.open(expand_path('cmd.sh'), 'w') { |f| f.puts string }
-
-        File.chmod 0o755, expand_path('cmd.sh')
-        prepend_environment_variable 'PATH', "#{expand_path('.')}#{File::PATH_SEPARATOR}"
-      end
-
-      let(:cmd) { "cmd.sh #{output}" }
-
-      before(:each) { run_command(cmd) }
-
-      it { expect(last_command_started).to have_output output }
-    end
-
-    context 'when not has output' do
-      before(:each) { run_command(cmd) }
-
-      it { expect(last_command_started).not_to have_output 'hello universe' }
-    end
-  end
-
-  describe '#to_have_output_on_stdout' do
-    let(:cmd) { "echo #{output}" }
-    let(:output) { 'hello world' }
-
-    context 'when have output hello world on stdout' do
-      before(:each) { run_command(cmd) }
-      it { expect(last_command_started).to have_output_on_stdout output }
-    end
-
-    context 'when have output hello world on stderr' do
-      before :each do
-        string = <<-EOS.strip_heredoc
-        #!/usr/bin/env bash
-
-        echo $* >&2
-        EOS
-
-        File.open(expand_path('cmd.sh'), 'w') { |f| f.puts string }
-
-        File.chmod 0o755, expand_path('cmd.sh')
-        prepend_environment_variable 'PATH', "#{expand_path('.')}#{File::PATH_SEPARATOR}"
-      end
-
-      let(:cmd) { "cmd.sh #{output}" }
-
-      before(:each) { run_command(cmd) }
-
-      it { expect(last_command_started).not_to have_output_on_stdout output }
-    end
-
-    context 'when not has output' do
-      before(:each) { run_command(cmd) }
-
-      it { expect(last_command_started).not_to have_output_on_stdout 'hello universe' }
-    end
-  end
-
-  describe '#to_have_output_on_stderr' do
-    let(:cmd) { "echo #{output}" }
-    let(:output) { 'hello world' }
-
-    context 'when have output hello world on stdout' do
-      before(:each) { run_command(cmd) }
-      it { expect(last_command_started).not_to have_output_on_stderr output }
-    end
-
-    context 'when have output hello world on stderr' do
-      before :each do
-        string = <<-EOS.strip_heredoc
-        #!/usr/bin/env bash
-
-        echo $* >&2
-        EOS
-
-        File.open(expand_path('cmd.sh'), 'w') { |f| f.puts string }
-
-        File.chmod 0o755, expand_path('cmd.sh')
-        prepend_environment_variable 'PATH', "#{expand_path('.')}#{File::PATH_SEPARATOR}"
-      end
-
-      let(:cmd) { "cmd.sh #{output}" }
-
-      before(:each) { run_command(cmd) }
-
-      it { expect(last_command_started).to have_output_on_stderr output }
-    end
-
-    context 'when not has output' do
-      before(:each) { run_command(cmd) }
-
-      it { expect(last_command_started).not_to have_output_on_stderr 'hello universe' }
-    end
-  end
-end