aruba-win-fix 0.14.2

data/spec/aruba/aruba_path_spec.rb

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

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

data/spec/aruba/configuration_spec.rb

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

data/spec/aruba/hooks_spec.rb

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

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'aruba/api'
+
+describe "Aruba JRuby Startup Helper" do
+  before(:all) do
+    @fake_env = ENV.clone
+  end
+
+  before :each do
+    Aruba.config.reset
+
+    # Define before_cmd-hook
+    load 'aruba/config/jruby.rb'
+  end
+
+  before(:each) do
+    @fake_env['JRUBY_OPTS'] = "--1.9"
+    @fake_env['JAVA_OPTS'] = "-Xdebug"
+
+    stub_const('ENV', @fake_env)
+  end
+
+  context 'when some mri ruby' do
+    before :each do
+      stub_const('RUBY_PLATFORM', 'x86_64-chocolate')
+    end
+
+    before :each do
+      Aruba.config.before :command, self
+    end
+
+    it { expect(ENV['JRUBY_OPTS']).to eq '--1.9' }
+    it { expect(ENV['JAVA_OPTS']).to eq '-Xdebug' }
+  end
+
+  context 'when jruby ruby' do
+    before :each do
+      stub_const('RUBY_PLATFORM', 'java')
+    end
+
+    before :each do
+      rb_config = double('rb_config')
+      allow(rb_config).to receive(:[]).and_return('solaris')
+
+      stub_const 'RbConfig::CONFIG', rb_config
+    end
+
+    before :each do
+      Aruba.config.before :command, self
+    end
+
+    it { expect(ENV['JRUBY_OPTS']).to eq '--dev -X-C --1.9' }
+    it { expect(ENV['JAVA_OPTS']).to eq '-d32 -Xdebug' }
+  end
+end

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

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

@@ -0,0 +1,174 @@
+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(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(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(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(cmd)
+          run(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(cmd)
+          run('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 0755, expand_path('cmd.sh')
+        prepend_environment_variable 'PATH', "#{expand_path('.')}#{File::PATH_SEPARATOR}"
+      end
+
+      let(:cmd) { "cmd.sh #{output}" }
+
+      before(:each) { run(cmd) }
+
+      it { expect(last_command_started).to have_output output }
+    end
+
+    context 'when not has output' do
+      before(:each) { run(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(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 0755, expand_path('cmd.sh')
+        prepend_environment_variable 'PATH', "#{expand_path('.')}#{File::PATH_SEPARATOR}"
+      end
+
+      let(:cmd) { "cmd.sh #{output}" }
+
+      before(:each) { run(cmd) }
+
+      it { expect(last_command_started).not_to have_output_on_stdout output }
+    end
+
+    context 'when not has output' do
+      before(:each) { run(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(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 0755, expand_path('cmd.sh')
+        prepend_environment_variable 'PATH', "#{expand_path('.')}#{File::PATH_SEPARATOR}"
+      end
+
+      let(:cmd) { "cmd.sh #{output}" }
+
+      before(:each) { run(cmd) }
+
+      it { expect(last_command_started).to have_output_on_stderr output }
+    end
+
+    context 'when not has output' do
+      before(:each) { run(cmd) }
+
+      it { expect(last_command_started).not_to have_output_on_stderr 'hello universe' }
+    end
+  end
+end

data/spec/aruba/matchers/directory_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'aruba/matchers/directory'
+require 'fileutils'
+
+RSpec.describe 'Directory Matchers' do
+  include_context 'uses aruba API'
+  include_context 'needs to expand paths'
+
+  describe 'to_be_an_existing_directory' do
+    let(:name) { 'test.d' }
+    let(:path) { File.join(@aruba.current_directory, name) }
+
+    context 'when directory exists' do
+      before :each do
+        FileUtils.mkdir_p path
+      end
+
+      it { expect(name).to be_an_existing_directory }
+    end
+
+    context 'when directory does not exist' do
+      it { expect(name).not_to be_an_existing_directory }
+    end
+  end
+
+  describe 'to_have_sub_directory' do
+    let(:name) { 'test.d' }
+    let(:path) { File.join(@aruba.current_directory, name) }
+    let(:content) { %w(subdir.1.d subdir.2.d) }
+
+    context 'when directory exists' do
+      before :each do
+        FileUtils.mkdir_p path
+      end
+
+      before :each do
+        Array(content).each { |p| Dir.mkdir File.join(path, p) }
+      end
+
+      context 'when single directory' do
+        it { expect(name).to have_sub_directory('subdir.1.d') }
+      end
+
+      context 'when multiple directories' do
+        it { expect(name).to have_sub_directory(['subdir.1.d', 'subdir.2.d']) }
+      end
+
+      context 'when non existing directory' do
+        it { expect(name).not_to have_sub_directory('subdir.3.d') }
+      end
+    end
+
+    context 'when directory does not exist' do
+      it { expect(name).not_to have_sub_directory('subdir') }
+    end
+  end
+end