aruba-win-fix 0.14.2

data/spec/aruba/matchers/file_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'aruba/matchers/file'
+
+RSpec.describe 'File Matchers' do
+  include_context 'uses aruba API'
+  include_context 'needs to expand paths'
+
+  describe 'to_be_an_existing_file' do
+    let(:name) { @file_name }
+
+    context 'when file exists' do
+      before(:each) { create_test_files(name) }
+
+      it { expect(name).to be_an_existing_file }
+    end
+
+    context 'when file does not exist' do
+      it { expect(name).not_to be_an_existing_file }
+    end
+
+    context 'when contains ~' do
+      let(:name) { File.join('~', random_string) }
+
+      before(:each) do
+        @aruba.with_environment 'HOME' => expand_path('.') do
+          create_test_files(name)
+        end
+      end
+
+      it do
+        @aruba.with_environment 'HOME' => expand_path('.') do
+          expect(name).to be_an_existing_file
+        end
+      end
+    end
+  end
+
+  describe 'to_have_file_content' do
+    context 'when file exists' do
+      before :each do
+        Aruba.platform.write_file(@file_path, 'aba')
+      end
+
+      context 'and file content is exactly equal string ' do
+        it { expect(@file_name).to have_file_content('aba') }
+      end
+
+      context 'and file content contains string' do
+        it { expect(@file_name).to have_file_content(/b/) }
+      end
+
+      context 'and file content is not exactly equal string' do
+        it { expect(@file_name).not_to have_file_content('c') }
+      end
+
+      context 'and file content not contains string' do
+        it { expect(@file_name).not_to have_file_content(/c/) }
+      end
+
+      context 'when other matchers is given which matches a string start with "a"' do
+        it { expect(@file_name).to have_file_content(a_string_starting_with('a')) }
+      end
+    end
+
+    context 'when file does not exist' do
+      it { expect(@file_name).not_to have_file_content('a') }
+    end
+
+    describe "description" do
+      context "when string" do
+        it { expect(have_file_content("a").description).to eq('have file content: "a"') }
+      end
+
+      context "when regexp" do
+        it { expect(have_file_content(/a/).description).to eq('have file content: /a/') }
+      end
+
+      context "when matcher" do
+        it { expect(have_file_content(a_string_starting_with("a")).description).to eq('have file content: a string starting with "a"') }
+      end
+    end
+
+    describe 'failure messages' do
+      def fail_with(message)
+        raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+      end
+
+      example 'for a string' do
+        expect do
+          expect(@file_name).to have_file_content("z")
+        end.to fail_with('expected "test.txt" to have file content: "z"')
+      end
+
+      example 'for a string' do
+        expect do
+          expect(@file_name).to have_file_content(/z/)
+        end.to fail_with('expected "test.txt" to have file content: /z/')
+      end
+
+      example 'for a matcher' do
+        expect do
+          expect(@file_name).to have_file_content(a_string_starting_with("z"))
+        end.to fail_with('expected "test.txt" to have file content: a string starting with "z"')
+      end
+    end
+  end
+
+  describe 'to_have_file_size' do
+    context 'when file exists' do
+      before :each do
+        Aruba.platform.write_file(@file_path, '')
+      end
+
+      context 'and file size is equal' do
+        it { expect(@file_name).to have_file_size(0) }
+      end
+
+      context 'and file size is not equal' do
+        it { expect(@file_name).not_to have_file_size(1) }
+      end
+    end
+
+    context 'when file does not exist' do
+      it { expect(@file_name).not_to have_file_size(0) }
+    end
+  end
+end

data/spec/aruba/matchers/path_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+require 'fileutils'
+require 'aruba/matchers/path'
+
+RSpec.describe 'Path Matchers' do
+  include_context 'uses aruba API'
+
+  def expand_path(*args)
+    @aruba.expand_path(*args)
+  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_be_an_absolute_path' do
+    let(:name) { @file_name }
+    let(:path) { File.expand_path(File.join(@aruba.current_directory, name)) }
+
+    context 'when is absolute path' do
+      it { expect(path).to be_an_absolute_path }
+    end
+
+    context 'when is relative path' do
+      it { expect(name).not_to be_an_absolute_path }
+    end
+  end
+
+  describe 'to_be_an_existing_path' do
+    context 'when file' do
+      context 'exists' do
+        before :each do
+          Aruba.platform.write_file(@file_path, '')
+        end
+
+        it { expect(@file_name).to be_an_existing_path }
+      end
+
+      context 'does not exist' do
+        it { expect(@file_name).not_to be_an_existing_path }
+      end
+    end
+
+    context 'when directory' do
+      let(:name) { 'test.d' }
+      let(:path) { File.join(@aruba.current_directory, name) }
+
+      context 'exists' do
+        before :each do
+          FileUtils.mkdir_p path
+        end
+
+        it { expect(name).to be_an_existing_path }
+      end
+
+      context 'does not exist' do
+        it { expect(name).not_to be_an_existing_path }
+      end
+    end
+  end
+end

data/spec/aruba/platform/simple_table_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'aruba/platform'
+
+RSpec.describe '.simple_table' do
+  context 'when valid hash' do
+    let(:hash) do
+      {
+        :key1 => 'value',
+        :key2 => 'value'
+      }
+    end
+    let(:rows) { ['# key1 => value', '# key2 => value'] }
+
+    it { expect(Aruba.platform.simple_table(hash).to_s).to eq rows.join("\n") }
+  end
+
+  context 'when empty hash' do
+    let(:hash) { {} }
+    let(:rows) { [] }
+
+    it { expect(Aruba.platform.simple_table(hash).to_s).to eq rows.join("\n") }
+  end
+end

data/spec/aruba/platform/windows_environment_variables_spec.rb

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