aruba 0.8.1 → 0.9.0.pre

data/lib/aruba/version.rb

@@ -1,3 +1,3 @@
 module Aruba
-  VERSION = '0.8.1'
+  VERSION = '0.9.0.pre'
 end

data/spec/aruba/api_spec.rb

@@ -32,7 +32,7 @@ describe Aruba::Api  do
 
     context 'when file exist' do
       before :each do
-        Aruba::Platform.write_file(path, '')
+        Aruba.platform.write_file(path, '')
       end
 
       it { expect(all_paths).to include expand_path(name) }
@@ -43,7 +43,7 @@ describe Aruba::Api  do
       let(:path) { File.join(@aruba.aruba.current_directory, name) }
 
       before :each do
-        Aruba::Platform.mkdir(path)
+        Aruba.platform.mkdir(path)
       end
 
       it { expect(all_paths).to include expand_path(name) }
@@ -60,7 +60,7 @@ describe Aruba::Api  do
 
     context 'when file exist' do
       before :each do
-        Aruba::Platform.write_file(path, '')
+        Aruba.platform.write_file(path, '')
       end
 
       it { expect(all_files).to include expand_path(name) }
@@ -71,7 +71,7 @@ describe Aruba::Api  do
       let(:path) { File.join(@aruba.aruba.current_directory, name) }
 
       before :each do
-        Aruba::Platform.mkdir(path)
+        Aruba.platform.mkdir(path)
       end
 
       it { expect(all_files).to eq [] }
@@ -88,7 +88,7 @@ describe Aruba::Api  do
 
     context 'when file exist' do
       before :each do
-        Aruba::Platform.write_file(path, '')
+        Aruba.platform.write_file(path, '')
       end
 
       it { expect(all_directories).to eq [] }
@@ -99,7 +99,7 @@ describe Aruba::Api  do
       let(:path) { File.join(@aruba.aruba.current_directory, name) }
 
       before :each do
-        Aruba::Platform.mkdir(path)
+        Aruba.platform.mkdir(path)
       end
 
       it { expect(all_directories).to include expand_path(name) }
@@ -170,7 +170,7 @@ describe Aruba::Api  do
         let(:name) { 'test.d' }
 
         before :each do
-          Array(path).each { |p| Aruba::Platform.mkdir p }
+          Array(path).each { |p| Aruba.platform.mkdir p }
         end
 
         it { expect { @aruba.read(name) }.to raise_error ArgumentError }
@@ -206,11 +206,11 @@ describe Aruba::Api  do
 
       context 'when directory' do
         before :each do
-          Array(path).each { |p| Aruba::Platform.mkdir p }
+          Array(path).each { |p| Aruba.platform.mkdir p }
         end
 
         before :each do
-          Array(content).each { |p| Aruba::Platform.mkdir File.join(path, p) }
+          Array(content).each { |p| Aruba.platform.mkdir File.join(path, p) }
         end
 
         context 'when has subdirectories' do
@@ -298,7 +298,7 @@ describe Aruba::Api  do
 
       context 'when exists' do
         before :each do
-          Array(path).each { |p| Aruba::Platform.mkdir p }
+          Array(path).each { |p| Aruba.platform.mkdir p }
         end
 
         before :each do
@@ -396,7 +396,7 @@ describe Aruba::Api  do
         let(:path) { Array(name).map { |p| File.join(@aruba.aruba.current_directory, p) } }
 
         context 'when exist' do
-          before(:each) { Array(path).each { |p| Aruba::Platform.mkdir p } }
+          before(:each) { Array(path).each { |p| Aruba.platform.mkdir p } }
 
           before :each do
             @aruba.touch(name, options)
@@ -446,7 +446,7 @@ describe Aruba::Api  do
 
         context 'when exists' do
           before :each do
-            Aruba::Platform.write_file(path, '')
+            Aruba.platform.write_file(path, '')
           end
 
           it { expect(@aruba).to be_exist(name) }
@@ -463,7 +463,7 @@ describe Aruba::Api  do
 
         context 'when exists' do
           before :each do
-            Aruba::Platform.mkdir(path)
+            Aruba.platform.mkdir(path)
           end
 
           it { expect(@aruba).to be_exist(name) }
@@ -482,7 +482,7 @@ describe Aruba::Api  do
 
         context 'when exists' do
           before :each do
-            Aruba::Platform.write_file(path, '')
+            Aruba.platform.write_file(path, '')
           end
 
           it { expect(@aruba).to be_file(name) }
@@ -499,7 +499,7 @@ describe Aruba::Api  do
 
         context 'when exists' do
           before :each do
-            Aruba::Platform.mkdir(path)
+            Aruba.platform.mkdir(path)
           end
 
           it { expect(@aruba).not_to be_file(name) }
@@ -518,7 +518,7 @@ describe Aruba::Api  do
 
         context 'when exists' do
           before :each do
-            Aruba::Platform.write_file(path, '')
+            Aruba.platform.write_file(path, '')
           end
 
           it { expect(@aruba).not_to be_directory(name) }
@@ -535,7 +535,7 @@ describe Aruba::Api  do
 
         context 'when exists' do
           before :each do
-            Aruba::Platform.mkdir(path)
+            Aruba.platform.mkdir(path)
           end
 
           it { expect(@aruba).to be_directory(name) }
@@ -589,7 +589,7 @@ describe Aruba::Api  do
             let(:destination) { 'dst.d' }
 
             before :each do
-              Aruba::Platform.mkdir(File.join(@aruba.aruba.current_directory, source))
+              Aruba.platform.mkdir(File.join(@aruba.aruba.current_directory, source))
             end
 
             before :each do
@@ -619,7 +619,7 @@ describe Aruba::Api  do
               let(:destination_files) { source.map { |s| File.join(destination, s) } }
 
               before :each do
-                Aruba::Platform.mkdir(File.join(@aruba.aruba.current_directory, destination))
+                Aruba.platform.mkdir(File.join(@aruba.aruba.current_directory, destination))
               end
 
               before :each do
@@ -714,6 +714,8 @@ describe Aruba::Api  do
 
         before :each do
           allow(config).to receive(:fixtures_path_prefix).and_return('%')
+          allow(config).to receive(:root_directory).and_return aruba.config.root_directory
+          allow(config).to receive(:working_directory).and_return aruba.config.working_directory
         end
 
         before :each do
@@ -901,7 +903,7 @@ describe Aruba::Api  do
         file_name = 'nested/dir/hello_world.txt'
         file_path = File.join(@aruba.aruba.current_directory, file_name)
 
-        Aruba::Platform.mkdir(File.dirname(file_path))
+        Aruba.platform.mkdir(File.dirname(file_path))
         File.open(file_path, 'w') { |f| f << "" }
 
         @aruba.check_file_presence(file_name)
@@ -914,7 +916,7 @@ describe Aruba::Api  do
         file_name = 'nested/dir/hello_world.txt'
         file_path = File.join(@aruba.aruba.current_directory, file_name)
 
-        Aruba::Platform.mkdir(File.dirname(file_path))
+        Aruba.platform.mkdir(File.dirname(file_path))
         File.open(file_path, 'w') { |f| f << "" }
 
         @aruba.check_file_presence([ /test123/ ], false )
@@ -927,7 +929,7 @@ describe Aruba::Api  do
         file_name = 'nested/dir/hello_world.txt'
         file_path = File.join(@aruba.aruba.current_directory, file_name)
 
-        Aruba::Platform.mkdir(File.dirname(file_path))
+        Aruba.platform.mkdir(File.dirname(file_path))
         File.open(file_path, 'w') { |f| f << "" }
 
         @aruba.check_file_presence([ file_name, /nested/  ], true )
@@ -938,7 +940,7 @@ describe Aruba::Api  do
         file_path = File.join('~', random_string)
 
         @aruba.with_environment 'HOME' => File.expand_path(@aruba.aruba.current_directory) do
-          Aruba::Platform.mkdir(File.dirname(File.expand_path(file_path)))
+          Aruba.platform.mkdir(File.dirname(File.expand_path(file_path)))
           File.open(File.expand_path(file_path), 'w') { |f| f << "" }
 
           @aruba.check_file_presence( [ file_path ], true )

data/spec/aruba/aruba_path_spec.rb

@@ -63,4 +63,41 @@ RSpec.describe Aruba::ArubaPath 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/jruby_spec.rb

@@ -49,7 +49,7 @@ describe "Aruba JRuby Startup Helper"  do
       Aruba.config.before :command, self
     end
 
-    it { expect(ENV['JRUBY_OPTS']).to eq '-X-C --1.9' }
+    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/file_spec.rb

@@ -38,7 +38,7 @@ RSpec.describe 'File Matchers' do
   describe 'to_have_file_content' do
     context 'when file exists' do
       before :each do
-        Aruba::Platform.write_file(@file_path, 'aba')
+        Aruba.platform.write_file(@file_path, 'aba')
       end
 
       context 'and file content is exactly equal string ' do
@@ -108,7 +108,7 @@ RSpec.describe 'File Matchers' do
   describe 'to_have_file_size' do
     context 'when file exists' do
       before :each do
-        Aruba::Platform.write_file(@file_path, '')
+        Aruba.platform.write_file(@file_path, '')
       end
 
       context 'and file size is equal' do

data/spec/aruba/matchers/path_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe 'Path Matchers' 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, '')
+          Aruba.platform.write_file(@file_path, '')
         end
 
         it { expect(all_paths).to match_path_pattern(expand_path(@file_name)) }
@@ -28,7 +28,7 @@ RSpec.describe 'Path Matchers' do
     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, '')
+          Aruba.platform.write_file(@file_path, '')
         end
 
         it { expect(all_paths).to match_path_pattern(/test/) }
@@ -57,7 +57,7 @@ RSpec.describe 'Path Matchers' do
     context 'when file' do
       context 'exists' do
         before :each do
-          Aruba::Platform.write_file(@file_path, '')
+          Aruba.platform.write_file(@file_path, '')
         end
 
         it { expect(@file_name).to be_an_existing_path }

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 eq rows }
+  end
+
+  context 'when empty hash' do
+    let(:hash) { {} }
+    let(:rows) { [] }
+
+    it { expect(Aruba.platform.simple_table(hash)).to eq rows }
+  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