aruba 0.14.9 → 1.0.0

data/spec/aruba/platform/windows_environment_variables_spec.rb

@@ -1,500 +0,0 @@
-require 'spec_helper'
-require 'aruba/platforms/windows_environment_variables'
-
-RSpec.describe Aruba::Platforms::WindowsEnvironmentVariables do
-  subject(:environment) { described_class.new(old_environment) }
-
-  describe '#[]' do
-    context 'when environment contains uppercase variable' do
-      let(:old_environment) { { 'MY_VARIABLE' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq nil }
-      end
-    end
-
-    context 'when environment contains lowercase variable' do
-      let(:old_environment) { { 'my_variable' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq nil }
-      end
-    end
-
-    context 'when environment contains mixed case variable' do
-      let(:old_environment) { { 'MY_variable' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq '1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq nil }
-      end
-    end
-  end
-
-  describe '#fetch' do
-    context 'when environment contains uppercase variable' do
-      let(:old_environment) { { 'MY_VARIABLE' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        context 'and no default is given' do
-          if RUBY_VERSION < '1.9'
-            it { expect { environment.fetch(variable) }.to raise_error IndexError }
-          else
-            unless defined? KeyError
-              class KeyError < StandardError; end
-            end
-
-            it { expect { environment.fetch(variable) }.to raise_error KeyError }
-          end
-        end
-
-        context 'and default is given' do
-          let(:default_value) { 'default_value' }
-
-          it { expect(environment.fetch(variable, default_value)).to eq default_value }
-        end
-      end
-    end
-
-    context 'when environment contains lowercase variable' do
-      let(:old_environment) { { 'my_variable' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        context 'and no default is given' do
-          if RUBY_VERSION < '1.9'
-            it { expect { environment.fetch(variable) }.to raise_error IndexError }
-          else
-            unless defined? KeyError
-              class KeyError < StandardError; end
-            end
-
-            it { expect { environment.fetch(variable) }.to raise_error KeyError }
-          end
-        end
-
-        context 'and default is given' do
-          let(:default_value) { 'default_value' }
-
-          it { expect(environment.fetch(variable, default_value)).to eq default_value }
-        end
-      end
-    end
-
-    context 'when environment contains mixed case variable' do
-      let(:old_environment) { { 'MY_variable' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment.fetch(variable)).to eq '1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        context 'and no default is given' do
-          if RUBY_VERSION < '1.9'
-            it { expect { environment.fetch(variable) }.to raise_error IndexError }
-          else
-            unless defined? KeyError
-              class KeyError < StandardError; end
-            end
-
-            it { expect { environment.fetch(variable) }.to raise_error KeyError }
-          end
-        end
-
-        context 'and default is given' do
-          let(:default_value) { 'default_value' }
-
-          it { expect(environment.fetch(variable, default_value)).to eq default_value }
-        end
-      end
-    end
-  end
-
-  describe '#key?' do
-    context 'when environment contains uppercase variable' do
-      let(:old_environment) { { 'MY_VARIABLE' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment).not_to be_key variable }
-      end
-    end
-
-    context 'when environment contains lowercase variable' do
-      let(:old_environment) { { 'my_variable' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment).not_to be_key variable }
-      end
-    end
-
-    context 'when environment contains mixed case variable' do
-      let(:old_environment) { { 'MY_variable' => '1' } }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment).to be_key variable }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment).not_to be_key variable }
-      end
-    end
-  end
-
-  describe '#append' do
-    let(:value) { 'NEW_VALUE' }
-
-    context 'when environment contains uppercase variable' do
-      let(:old_environment) { { 'MY_VARIABLE' => '1' } }
-
-      before(:each) { environment.append(variable, value) }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE' }
-      end
-    end
-
-    context 'when environment contains lowercase variable' do
-      let(:old_environment) { { 'my_variable' => '1' } }
-
-      before(:each) { environment.append(variable, value) }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE' }
-      end
-    end
-
-    context 'when environment contains mixed case variable' do
-      let(:old_environment) { { 'MY_variable' => '1' } }
-
-      before(:each) { environment.append(variable, value) }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq '1NEW_VALUE' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE' }
-      end
-    end
-  end
-
-  describe '#prepend' do
-    let(:value) { 'NEW_VALUE' }
-
-    context 'when environment contains uppercase variable' do
-      let(:old_environment) { { 'MY_VARIABLE' => '1' } }
-
-      before(:each) { environment.prepend(variable, value) }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE' }
-      end
-    end
-
-    context 'when environment contains lowercase variable' do
-      let(:old_environment) { { 'my_variable' => '1' } }
-
-      before(:each) { environment.prepend(variable, value) }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE' }
-      end
-    end
-
-    context 'when environment contains mixed case variable' do
-      let(:old_environment) { { 'MY_variable' => '1' } }
-
-      before(:each) { environment.prepend(variable, value) }
-
-      context 'when uppercase key is given' do
-        let(:variable) { 'MY_VARIABLE' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when lowercase key is given' do
-        let(:variable) { 'my_variable' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when mixed case key is given' do
-        let(:variable) { 'MY_variable' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE1' }
-      end
-
-      context 'when unknown variable is given' do
-        let(:variable) { 'unknown' }
-
-        it { expect(environment[variable]).to eq 'NEW_VALUE' }
-      end
-    end
-  end
-end

data/spec/aruba/platforms/unix_command_string_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::Platforms::UnixCommandString do
-  let(:command_string) { described_class.new(base_command) }
-
-  describe '#to_a' do
-    context 'with a command with a path' do
-      let(:base_command) { '/foo/bar' }
-      it { expect(command_string.to_a).to eq [base_command] }
-    end
-
-    context 'with a command with a path containing spaces' do
-      let(:base_command) { '/foo bar/baz' }
-      it { expect(command_string.to_a).to eq [base_command] }
-    end
-  end
-end

data/spec/aruba/platforms/windows_command_string_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::Platforms::WindowsCommandString do
-  let(:command_string) { described_class.new(base_command) }
-  let(:cmd_path) { 'C:\Some Path\cmd.exe' }
-
-  before do
-    allow(Aruba.platform).to receive(:which).with('cmd.exe').and_return(cmd_path)
-  end
-
-  describe '#to_a' do
-    context 'with a command with a path' do
-      let(:base_command) { 'C:\Foo\Bar' }
-      it { expect(command_string.to_a).to eq [cmd_path, '/c', base_command] }
-    end
-
-    context 'with a command with a path containing spaces' do
-      let(:base_command) { 'C:\Foo Bar\Baz' }
-      it { expect(command_string.to_a).to eq [cmd_path, '/c', base_command] }
-    end
-  end
-end

data/spec/aruba/rspec_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'RSpec Integration', :type => :aruba do
-  describe 'Configuration' do
-    subject(:config) { aruba.config }
-
-    context 'when io_wait_timeout is 0.5', :io_wait_timeout => 0.5 do
-      it { expect(config.io_wait_timeout).to eq 0.5 }
-    end
-
-    context 'when io_wait_timeout is 0.1' do
-      it { expect(config.io_wait_timeout).to eq 0.1 }
-    end
-  end
-end

data/spec/aruba/runtime_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::Runtime do
-  # describe '#fixtures_directory' do
-  #   context 'when no fixtures directories exist' do
-  #     it "should raise exception" do
-  #       expect { api.fixtures_directory }.to raise_error
-  #     end
-  #   end
-  #
-  #   context 'when "/features/fixtures"-directory exist' do
-  #     before(:each) { api.create_directory('features/fixtures') }
-  #
-  #     it { expect(api.fixtures_directory).to eq expand_path('features/fixtures') }
-  #   end
-  #
-  #   context 'when "/spec/fixtures"-directory exist' do
-  #     before(:each) { api.create_directory('spec/fixtures') }
-  #
-  #     it { expect(api.fixtures_directory).to eq expand_path('spec/fixtures') }
-  #   end
-  #
-  #   context 'when "/test/fixtures"-directory exist' do
-  #     before(:each) { api.create_directory('test/fixtures') }
-  #
-  #     it { expect(api.fixtures_directory.to_s).to eq expand_path('test/fixtures') }
-  #   end
-  # end
-end

data/spec/aruba/spawn_process_spec.rb

@@ -1,96 +0,0 @@
-require 'aruba/processes/spawn_process'
-
-RSpec.describe Aruba::Processes::SpawnProcess do
-  subject(:process) { described_class.new(command, exit_timeout, io_wait, working_directory, environment, main_class) }
-
-  let(:command) { 'echo "yo"' }
-  let(:exit_timeout) { 1 }
-  let(:io_wait) { 1 }
-  let(:working_directory) { Dir.getwd }
-  let(:environment) { ENV.to_hash.dup }
-  let(:main_class) { nil }
-
-  describe "#stdout" do
-    before(:each) { process.start }
-    before(:each) { process.stop }
-
-    context 'when invoked once' do
-      it { expect(process.stdout).to eq "yo\n" }
-    end
-
-    context 'when invoked twice' do
-      it { 2.times { expect(process.stdout).to eq "yo\n" } }
-    end
-  end
-
-  describe "#stderr" do
-    let(:command) { 'fixtures/spawn_process/stderr.sh yo' }
-
-    before(:each) { process.start }
-    before(:each) { process.stop }
-
-    context 'when invoked once' do
-      it { expect(process.stderr).to eq "yo\n" }
-    end
-
-    context 'when invoked twice' do
-      it { 2.times { expect(process.stderr).to eq "yo\n" } }
-    end
-  end
-
-  describe "#stop" do
-    before(:each) { process.start }
-
-    context 'when stopped successfully' do
-      it { process.stop }
-    end
-  end
-
-  describe "#start" do
-    context "when process run succeeds" do
-      it { expect { process.start }.not_to raise_error }
-    end
-
-    context "when process run fails" do
-      let(:command) { 'does_not_exists' }
-
-      it { expect {process.start}.to raise_error Aruba::LaunchError }
-    end
-
-    context 'with a command with a space in the path on unix' do
-      let(:child) { instance_double(ChildProcess::AbstractProcess).as_null_object }
-      let(:io) { instance_double(ChildProcess::AbstractIO).as_null_object }
-      let(:command) { 'foo' }
-      let(:command_path) { '/path with space/foo' }
-
-      before do
-        allow(Aruba.platform).to receive(:command_string).and_return Aruba::Platforms::UnixCommandString
-        allow(Aruba.platform).to receive(:which).with(command, anything).and_return(command_path)
-        allow(ChildProcess).to receive(:build).with(command_path).and_return(child)
-        allow(child).to receive(:io).and_return io
-        allow(child).to receive(:environment).and_return({})
-      end
-
-      it { expect { process.start }.to_not raise_error }
-    end
-
-    context 'with a command with a space in the path on windows' do
-      let(:child) { instance_double(ChildProcess::AbstractProcess).as_null_object }
-      let(:io) { instance_double(ChildProcess::AbstractIO).as_null_object }
-      let(:command) { 'foo' }
-      let(:cmd_path) { 'C:\Some Path\cmd.exe' }
-      let(:command_path) { 'D:\Bar Baz\foo' }
-
-      before do
-        allow(Aruba.platform).to receive(:command_string).and_return Aruba::Platforms::WindowsCommandString
-        allow(Aruba.platform).to receive(:which).with('cmd.exe').and_return(cmd_path)
-        allow(Aruba.platform).to receive(:which).with(command, anything).and_return(command_path)
-        allow(ChildProcess).to receive(:build).with(cmd_path, '/c', command_path).and_return(child)
-        allow(child).to receive(:io).and_return io
-        allow(child).to receive(:environment).and_return({})
-      end
-
-      it { expect { process.start }.to_not raise_error }
-    end
-  end
-end