aruba 0.14.9 → 1.0.0

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

@@ -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

data/spec/aruba/matchers/deprecated_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Deprecated matchers' do
-  include_context 'uses aruba API'
-
-  before do
-    allow(Aruba.platform).to receive(:deprecated)
-  end
-
-  describe 'to_match_path_pattern' do
-    context 'when pattern is string' do
-      context 'when there is file which matches path pattern' do
-        before :each do
-          Aruba.platform.write_file(@file_path, '')
-        end
-
-        it { expect(all_paths).to match_path_pattern(expand_path(@file_name)) }
-      end
-
-      context 'when there is not file which matches path pattern' do
-        it { expect(all_paths).not_to match_path_pattern('test') }
-      end
-    end
-
-    context 'when pattern is regex' do
-      context 'when there is file which matches path pattern' do
-        before :each do
-          Aruba.platform.write_file(@file_path, '')
-        end
-
-        it { expect(all_paths).to match_path_pattern(/test/) }
-      end
-
-      context 'when there is not file which matches path pattern' do
-        it { expect(all_paths).not_to match_path_pattern(/test/) }
-      end
-    end
-  end
-
-  describe "to have_same_file_content_like" do
-    let(:file_name) { @file_name }
-    let(:file_path) { @file_path }
-
-    let(:reference_file) { 'fixture' }
-
-    before :each do
-      @aruba.write_file(@file_name, "foo bar baz")
-      @aruba.write_file(reference_file, reference_file_content)
-    end
-
-    context 'when files are the same' do
-      let(:reference_file_content) { 'foo bar baz' }
-
-      context 'and this is expected' do
-        it { expect(file_name).to have_same_file_content_like reference_file }
-      end
-
-      context 'and this is not expected' do
-        it do
-          expect { expect(file_name).not_to have_same_file_content_like reference_file }.to raise_error RSpec::Expectations::ExpectationNotMetError
-        end
-      end
-    end
-
-    context 'when files are not the same' do
-      let(:reference_file_content) { 'bar' }
-
-      context 'and this is expected' do
-        it { expect(file_name).not_to have_same_file_content_like reference_file }
-      end
-
-      context 'and this is not expected' do
-        it do
-          expect { expect(file_name).to have_same_file_content_like reference_file }.to raise_error RSpec::Expectations::ExpectationNotMetError
-        end
-      end
-    end
-  end
-
-  describe "include a_file_with_same_content_like" do
-    let(:reference_file) { 'fixture' }
-    let(:reference_file_content) { 'foo bar baz' }
-    let(:file_with_same_content) { 'file_a.txt' }
-    let(:file_with_different_content) { 'file_b.txt' }
-
-    before :each do
-      @aruba.write_file(file_with_same_content, reference_file_content)
-      @aruba.write_file(reference_file, reference_file_content)
-      @aruba.write_file(file_with_different_content, 'Some different content here...')
-    end
-
-    context 'when the array of files includes a file with the same content' do
-      let(:files) { [file_with_different_content, file_with_same_content] }
-
-      context 'and this is expected' do
-        it { expect(files).to include a_file_with_same_content_like reference_file }
-      end
-
-      context 'and this is not expected' do
-        it do
-          expect { expect(files).not_to include a_file_with_same_content_like reference_file }.to raise_error RSpec::Expectations::ExpectationNotMetError
-        end
-      end
-    end
-
-    context 'when the array of files does not include a file with the same content' do
-      let(:files) { [file_with_different_content] }
-
-      context 'and this is expected' do
-        it { expect(files).not_to include a_file_with_same_content_like reference_file }
-      end
-
-      context 'and this is not expected' do
-        it do
-          expect { expect(files).to include a_file_with_same_content_like reference_file }.to raise_error RSpec::Expectations::ExpectationNotMetError
-        end
-      end
-    end
-  end
-end

data/spec/aruba/matchers/directory_spec.rb

@@ -1,57 +0,0 @@
-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) { @aruba.expand_path(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) { @aruba.expand_path(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