aruba 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c57ab964ee2b570039772b4c25a48e5c29ac7f3
-  data.tar.gz: 2a3ae133538910c61a2abb9ec980fbe5a5ae03d8
+  metadata.gz: 7f0ef8ad9b9057dd75bbeb89727f93f569c84a63
+  data.tar.gz: d81765e3e79d77b131ab9385eab81acb329117fd
 SHA512:
-  metadata.gz: 3f4e0203537678fb2341a3d0f880805c98acf094317c6b5ac63bf7f1b5f5baba6d4c05eb51698eb1ff8a2b61972780ff22dc06b5466d8e7ec0d535e54a3af2f1
-  data.tar.gz: 1471f170b99a6569819d13b577f4178593a285c730e5cdf327e9d7d36bef3df96d6a07223962641e3158d7b454ca5b999b4aea42b4ed3569e6149bb2ded54593
+  metadata.gz: f4dd1b000f2356f5ba7f4e70a0c513aecdcfafecfdf0f15cb94703ae6ce608d858c43cf078f80c7fd8f2c91cdd800a3f11f6163e34a18389629759e9eea0af0c
+  data.tar.gz: 583fb0214abe43ce3976b1b124646b2ce5139bb439689b4d191458b13d44e6462d935e968c4ff3c5813473e79bd74a9c08f641e6a294f45993f012b3890e1820

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+- 2.1.2
 - 2.1.1
 - 2.1.0
 - 2.0.0

data/CONTRIBUTING.md

@@ -44,6 +44,8 @@ Now release it
     git commit -m "Release X.Y.Z"
     rake release
 
+Now email cukes@googlegroups.com with details of the new release. Just a copy / paste from the History.md file is normally fine.
+
 ## Gaining Release Karma
 
 To become a release manager, create a pull request adding your name to the list below, and include your Rubygems email address in the ticket. One of the existing Release managers will then add you.
@@ -57,4 +59,3 @@ Current release managers:
 To grant release karma, issue the following command:
 
     gem owner cucumber --add <NEW OWNER RUBYGEMS EMAIL>
-

data/History.md

@@ -1,8 +1,13 @@
-## [master](https://github.com/cucumber/aruba/compare/v0.6.0...master)
+## [master](https://github.com/cucumber/aruba/compare/v0.6.1...master)
+
+## [master](https://github.com/cucumber/aruba/compare/v0.6.0...v0.6.1)
+* Added support for ruby 2.1.2
+* Added support for ~ expansion
+* Added support for with_env
 
 ## [v0.6.0](https://github.com/cucumber/aruba/compare/v0.5.4...v0.6.0)
 * Dropped support for ruby 1.8
-* Added support for ruby 2.1.0
+* Added support for ruby 2.1.0 and 2.1.1
 * Added rspec 3.0.0 support
 
 ## [v0.5.4](https://github.com/cucumber/aruba/compare/v0.5.3...v0.5.4)

data/README.md

@@ -8,6 +8,8 @@ Aruba is Cucumber extension for testing command line applications written in any
 
 ## Usage
 
+### Cucumber
+
 If you have a `Gemfile`, add `aruba`. Otherwise, install it like this:
 
     gem install aruba
@@ -22,6 +24,38 @@ You now have a bunch of step definitions that you can use in your features. Look
 to see them all. Look at [`features/*.feature`](features/) for examples (which are also testing Aruba
 itself).
 
+### RSpec
+
+Originally written for `cucumber`, `aruba` can be helpful in other contexts as
+well. One might want to use it together with `rspec`.
+
+1. Create a directory named `spec/support`
+2. Create a file named `spec/support/aruba.rb` with:
+
+   ```
+   require 'aruba/api
+   require 'aruba/reporting'
+
+    RSpec.configure do |c|
+      c.include Aruba::Api
+      c.after(:each) do
+        restore_env
+      end
+    end
+   ```
+
+## API
+
+`aruba` provides a wonderfull api to be used in your tests:
+
+* Creating files/directories
+* Deleting files/directories
+* Checking file size
+* Checking file existence/absence
+* ...
+
+A full documentation of the api can be found [here](http://www.rubydoc.info/github/cucumber/aruba/master/frames).
+
 ## Configuration
 
 Aruba has some default behaviour that you can change if you need to.
@@ -149,6 +183,17 @@ That's it! Everything will now run inside the same ruby process, making your sui
 a lot faster. Cucumber itself uses this approach to test itself, so check out the
 Cucumber source code for an example.
 
+*Pros*:
+
+* Very fast compared to spawning processes
+* You can use libraries like
+  [simplecov](https://github.com/colszowka/simplecov) more easily, because
+  there is only one "process" which adds data to `simplecov`'s database
+
+*Cons*:
+* You might oversee some bugs: You might forget to require libraries in your
+  "production" code, because you have required them in your testing code
+
 ### JRuby Tips
 
 Improve startup time by disabling JIT and forcing client JVM mode.  This can be accomplished by adding
@@ -247,16 +292,10 @@ Scenario: Make tea
   Given...
 ```
 
-## Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.  Note: the existing tests may fail
-* Commit, do not mess with Rakefile, gemspec or History.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+## Contributing
+
+Please see the `CONTRIBUTING.md`.
 
 ## Copyright
 
-Copyright (c) 2010,2011,2012,2013 Aslak Hellesøy, David Chelimsky and Mike Sassak. See LICENSE for details.
+Copyright (c) 2010,2011,2012,2013,2014 Aslak Hellesøy, David Chelimsky and Mike Sassak. See LICENSE for details.

data/aruba.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'aruba'
-  s.version     = '0.6.0'
+  s.version     = '0.6.1'
   s.authors     = ["Aslak Hellesøy", "David Chelimsky", "Mike Sassak", "Matt Wynne"]
   s.description = 'CLI Steps for Cucumber, hand-crafted for you in Aruba'
   s.summary     = "aruba-#{s.version}"

data/features/command_environment_variables.feature

@@ -13,3 +13,19 @@ Feature: Command environment variables
       """
       long_value
       """
+
+  Scenario: Mocked home directory
+    Given a mocked home directory
+    When I run `/usr/bin/env`
+    Then the output should contain:
+    """
+    tmp/aruba
+    """
+
+  @mocked_home_directory
+  Scenario: Mocked home directory
+    When I run `/usr/bin/env`
+    Then the output should contain:
+    """
+    tmp/aruba
+    """

data/features/file_system_commands.feature

@@ -166,6 +166,11 @@ Feature: file system commands
     When I remove the file "foo"
     Then the file "foo" should not exist
 
+  Scenario: Remove directory
+    Given a directory named "foo"
+    When I remove the directory "foo"
+    Then a directory named "foo" should not exist
+
   Scenario: Just a dummy for reporting
     Given an empty file named "a/b.txt"
     Given an empty file named "a/b/c.txt"

data/lib/aruba/api.rb

@@ -10,99 +10,223 @@ module Aruba
   module Api
     include RSpec::Matchers
 
+    # Execute block in current directory
+    #
+    # @yield
+    #   The block which should be run in current directory
     def in_current_dir(&block)
       _mkdir(current_dir)
       Dir.chdir(current_dir, &block)
     end
 
+    # Clean the current directory
     def clean_current_dir
       _rm_rf(current_dir)
       _mkdir(current_dir)
     end
 
+    # Get access to current dir
+    #
+    # @return
+    #   Current directory
     def current_dir
       File.join(*dirs)
     end
 
+    # Switch to directory
+    #
+    # @param [String] dir
+    #   The directory
     def cd(dir)
       dirs << dir
       raise "#{current_dir} is not a directory." unless File.directory?(current_dir)
     end
 
+    # The path to the directory which should contain all your test data
+    # You might want to overwrite this method to place your data else where.
+    #
+    # @return [Array]
+    #   The directory path: Each subdirectory is a member of an array
     def dirs
       @dirs ||= ['tmp', 'aruba']
     end
 
+    # Create a file with given content
+    #
+    # The method does not check if file already exists. If the file name is a
+    # path the method will create all neccessary directories.
+    #
+    # @param [String] file_name
+    #   The name of the file
+    #
+    # @param [String] file_content
+    #   The content which should be written to the file
     def write_file(file_name, file_content)
       _create_file(file_name, file_content, false)
     end
 
+    # Create a file with the given size
+    #
+    # The method does not check if file already exists. If the file name is a
+    # path the method will create all neccessary directories.
+    #
+    # @param [String] file_name
+    #   The name of the file
+    #
+    # @param [Integer] file_size
+    #   The size of the file
     def write_fixed_size_file(file_name, file_size)
       _create_fixed_size_file(file_name, file_size, false)
     end
 
+    # Create a file with given content
+    #
+    # The method does check if file already exists and fails if the file is
+    # missing. If the file name is a path the method will create all neccessary
+    # directories.
     def overwrite_file(file_name, file_content)
       _create_file(file_name, file_content, true)
     end
 
     def _create_file(file_name, file_content, check_presence)
       in_current_dir do
+        file_name = File.expand_path(file_name)
+
         raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
+
         _mkdir(File.dirname(file_name))
         File.open(file_name, 'w') { |f| f << file_content }
       end
     end
 
-    def chmod(mode, name)
+    # Change file system  permissions of file
+    #
+    # @param [Octal] mode
+    #   File system mode, eg. 0755
+    #
+    # @param [String] file_name
+    #   Name of file to be modified. This file needs to be present to succeed
+    def filesystem_permissions(mode, file_name)
       in_current_dir do
-        raise "expected #{name} to be present" unless FileTest.exists?(name)
+        file_name = File.expand_path(file_name)
+
+        raise "expected #{file_name} to be present" unless FileTest.exists?(file_name)
         if mode.kind_of? String
-          FileUtils.chmod(mode.to_i(8),name)
+          FileUtils.chmod(mode.to_i(8),file_name)
         else
-          FileUtils.chmod(mode,name)
+          FileUtils.chmod(mode, file_name)
         end
       end
     end
 
-    def mod?(mode, name)
+    def chmod(*args, &block)
+      warn('The use of "chmod" is deprecated. Use "filesystem_permissions" instead')
+
+      filesystem_permissions(*args, &block)
+    end
+
+    # Check file system permissions of file
+    #
+    # @param [Octal] mode
+    #   Expected file system permissions, e.g. 0755
+    # @param [String] file_name
+    #   Expected file system permissions, e.g. 0755
+    # @param [Boolean] expect_permissions
+    #   Are the permissions expected to be mode or are they expected not to be mode?
+    def check_filesystem_permissions(mode, file_name, expect_permissions)
       in_current_dir do
-        mode == sprintf( "%o", File::Stat.new(name).mode )[-4,4].to_i(8)
+        file_name = File.expand_path(file_name)
+
+        raise "expected #{file_name} to be present" unless FileTest.exists?(file_name)
+        if mode.kind_of? Integer
+          expected_mode = mode.to_s(8)
+        else
+          expected_mode = mode.gsub(/^0*/, '')
+        end
+
+        file_mode = sprintf( "%o", File::Stat.new(file_name).mode )[-4,4].gsub(/^0*/, '')
+
+        if expect_permissions
+          expect(file_mode).to eq expected_mode
+        else
+          expect(file_mode).not_to eq expected_mode
+        end
       end
     end
 
+    def mod?(*args, &block)
+      warn('The use of "mod?" is deprecated. Use "check_filesystem_permissions" instead')
+
+      check_filesystem_permissions(*args, &block)
+    end
+
     def _create_fixed_size_file(file_name, file_size, check_presence)
       in_current_dir do
+        file_name = File.expand_path(file_name)
+
         raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
         _mkdir(File.dirname(file_name))
         File.open(file_name, "wb"){ |f| f.seek(file_size - 1); f.write("\0") }
       end
     end
 
+    # Remove file
+    #
+    # @param [String] file_name
+    #    The file which should be deleted in current directory
     def remove_file(file_name)
       in_current_dir do
+        file_name = File.expand_path(file_name)
+
         FileUtils.rm(file_name)
       end
     end
 
+    # Append data to file
+    #
+    # @param [String] file_name
+    #   The name of the file to be used
+    #
+    # @param [String] file_content
+    #   The content which should be appended to file
     def append_to_file(file_name, file_content)
       in_current_dir do
+        file_name = File.expand_path(file_name)
+
         _mkdir(File.dirname(file_name))
         File.open(file_name, 'a') { |f| f << file_content }
       end
     end
 
-    def create_dir(dir_name)
+    # Create a directory in current directory
+    #
+    # @param [String] directory_name
+    #   The name of the directory which should be created
+    def create_dir(directory_name)
       in_current_dir do
-        _mkdir(dir_name)
+        _mkdir(directory_name)
       end
     end
 
+    # Remove directory
+    #
+    # @param [String] directory_name
+    #   The name of the directory which should be removed
     def remove_dir(directory_name)
       in_current_dir do
+        directory_name = File.expand_path(directory_name)
+
         FileUtils.rmdir(directory_name)
       end
     end
 
+    # Check if paths are present
+    #
+    # @param [#each] paths
+    #   The paths which should be checked
+    #
+    # @param [true,false] expect_presence
+    #   Should the given paths be present (true) or absent (false)
     def check_file_presence(paths, expect_presence)
       prep_for_fs_check do
         paths.each do |path|
@@ -113,6 +237,8 @@ module Aruba
               expect(Dir.glob('**/*')).not_to include_regexp(path)
             end
           else
+            path = File.expand_path(path)
+
             if expect_presence
               expect(File).to be_file(path)
             else
@@ -123,33 +249,78 @@ module Aruba
       end
     end
 
-    def pipe_in_file(file)
+    # Pipe data in file
+    #
+    # @param [String] file_name
+    #   The file which should be used to pipe in data
+    def pipe_in_file(file_name)
       in_current_dir do
-        File.open(file, 'r').each_line do |line|
+        file_name = File.expand_path(file_name)
+
+        File.open(file_name, 'r').each_line do |line|
           _write_interactive(line)
         end
       end
     end
 
+    # Check the file size of paths
+    #
+    # @params [Hash] paths_and_sizes
+    #   A hash containing the path (key) and the expected size (value)
+    #
+    # @example
+    #
+    #   paths_and_sizes = {
+    #     'file' => 10
+    #   }
+    #
+    #   check_file_size(paths_and_sizes)
+    #
     def check_file_size(paths_and_sizes)
       prep_for_fs_check do
         paths_and_sizes.each do |path, size|
+          path = File.expand_path(path)
+
           expect(File.size(path)).to eq size
         end
       end
     end
 
+    # Read content of file and yield the content to block
+    #
+    # @param [String) file
+    #   The name of file which should be read from
+    #
+    # @yield
+    #   Pass the content of the given file to this block
     def with_file_content(file, &block)
       prep_for_fs_check do
+        file = File.expand_path(file)
+
         content = IO.read(file)
         yield(content)
       end
     end
 
+    # Check the content of file
+    #
+    # It supports partial content as well. And it is up to you to decided if
+    # the content must be there or not.
+    #
+    # @param [String] file
+    #   The file to be checked
+    #
+    # @param [String] partial_content
+    #   The content which must/must not be in the file
+    #
+    # @param [true, false] expect_match
+    #   Must the content be in the file or not
     def check_file_content(file, partial_content, expect_match)
       regexp = regexp(partial_content)
       prep_for_fs_check do
+        file = File.expand_path(file)
         content = IO.read(file)
+
         if expect_match
           expect(content).to match regexp
         else
@@ -158,13 +329,29 @@ module Aruba
       end
     end
 
+    # Check if the exact content can be found in file
+    #
+    # @param [String] file
+    #   The file to be checked
+    #
+    # @param [String] exact_content
+    #   The content of the file
     def check_exact_file_content(file, exact_content)
       prep_for_fs_check { expect(IO.read(file)).to eq exact_content }
     end
 
+    # Check presence of a directory
+    #
+    # @param [Array] paths
+    #   The paths to be checked
+    #
+    # @param [true, false] expect_presence
+    #   Should the directory be there or should the directory not be there
     def check_directory_presence(paths, expect_presence)
       prep_for_fs_check do
         paths.each do |path|
+          path = File.expand_path(path)
+
           if expect_presence
             expect(File).to be_directory(path)
           else
@@ -180,13 +367,24 @@ module Aruba
     end
 
     def _mkdir(dir_name)
+      dir_name = File.expand_path(dir_name)
+
       FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
     end
 
     def _rm_rf(dir_name)
+      dir_name = File.expand_path(dir_name)
+
       FileUtils.rm_rf(dir_name)
     end
 
+    # Unescape string
+    #
+    # @param [String] string
+    #   The string which should be unescaped, e.g. the output of a command
+    #
+    # @return
+    #   The string stripped from escape sequences
     def unescape(string)
       string = string.gsub('\n', "\n").gsub('\"', '"').gsub('\e', "\e")
       string = string.gsub(/\e\[\d+(?>(;\d+)*)m/, '') unless @aruba_keep_ansi
@@ -197,16 +395,28 @@ module Aruba
       Regexp === string_or_regexp ? string_or_regexp : Regexp.compile(Regexp.escape(string_or_regexp))
     end
 
+    # Fetch output (stdout, stderr) from command
+    #
+    # @param [String] cmd
+    #   The comand
     def output_from(cmd)
       cmd = detect_ruby(cmd)
       get_process(cmd).output
     end
 
+    # Fetch stdout from command
+    #
+    # @param [String] cmd
+    #   The comand
     def stdout_from(cmd)
       cmd = detect_ruby(cmd)
       get_process(cmd).stdout
     end
 
+    # Fetch stderr from command
+    #
+    # @param [String] cmd
+    #   The comand
     def stderr_from(cmd)
       cmd = detect_ruby(cmd)
       get_process(cmd).stderr
@@ -331,6 +541,13 @@ module Aruba
       processes.collect{ |_, process| process }
     end
 
+    # Run given command and stop it if timeout is reached
+    #
+    # @param [String] cmd
+    #   The command which should be executed
+    #
+    # @param [Integer] timeout
+    #   If the timeout is reached the command will be killed
     def run(cmd, timeout = nil)
       timeout ||= exit_timeout
       @commands ||= []
@@ -372,15 +589,24 @@ module Aruba
       assert_exit_status(0) if fail_on_error
     end
 
+    # Run a command interactively
+    #
+    # @param [String] cmd
+    #   The command to by run
     def run_interactive(cmd)
       @interactive = run(cmd)
     end
 
+    # Provide data to command via stdin
+    #
+    # @param [String] input
+    #   The input for the command
     def type(input)
       return close_input if "" == input
       _write_interactive(_ensure_newline(input))
     end
 
+    # Close stdin
     def close_input
       @interactive.stdin.close
     end
@@ -447,15 +673,27 @@ module Aruba
       end
     end
 
+    # Set environment variable
+    #
+    # @param [String] key
+    #   The name of the environment variable as string, e.g. 'HOME'
+    #
+    # @param [String] value
+    #   The value of the environment variable. Needs to be a string.
     def set_env(key, value)
       announcer.env(key, value)
-      original_env[key] = ENV.delete(key)
+      original_env[key] = ENV.delete(key) unless original_env.key? key
       ENV[key] = value
     end
 
+    # Restore original process environment
     def restore_env
       original_env.each do |key, value|
-        ENV[key] = value
+        if value
+          ENV[key] = value
+        else
+          ENV.delete key
+        end
       end
     end
 
@@ -463,6 +701,14 @@ module Aruba
       @original_env ||= {}
     end
 
+    def with_env(env = {}, &block)
+      env.each do |k,v|
+        set_env k, v
+        block.call
+        restore_env
+      end
+    end
+
   # TODO: move some more methods under here!
   private
 

data/lib/aruba/cucumber.rb

@@ -23,7 +23,7 @@ end
 
 Given /^a directory named "([^"]*)" with mode "([^"]*)"$/ do |dir_name, dir_mode|
   create_dir(dir_name)
-  chmod(dir_mode, dir_name)
+  filesystem_permissions(dir_mode, dir_name)
 end
 
 Given /^a file named "([^"]*)" with:$/ do |file_name, file_content|
@@ -32,7 +32,7 @@ end
 
 Given /^a file named "([^"]*)" with mode "([^"]*)" and with:$/ do |file_name, file_mode, file_content|
   write_file(file_name, file_content)
-  chmod(file_mode, file_name)
+  filesystem_permissions(file_mode, file_name)
 end
 
 Given /^a (\d+) byte file named "([^"]*)"$/ do |file_size, file_name|
@@ -45,7 +45,7 @@ end
 
 Given /^an empty file named "([^"]*)" with mode "([^"]*)"$/ do |file_name, file_mode|
   write_file(file_name, "")
-  chmod(file_mode, file_name)
+  filesystem_permissions(file_mode, file_name)
 end
 
 When /^I write to "([^"]*)" with:$/ do |file_name, file_content|
@@ -68,6 +68,10 @@ When /^I remove the file "([^"]*)"$/ do |file_name|
   remove_file(file_name)
 end
 
+When(/^I remove the directory "(.*?)"$/) do |directory_name|
+  remove_dir(directory_name)
+end
+
 When /^I cd to "([^"]*)"$/ do |dir|
   cd(dir)
 end
@@ -360,6 +364,18 @@ Then /^the file "([^"]*)" should not match \/([^\/]*)\/$/ do |file, partial_cont
   check_file_content(file, /#{partial_content}/, false)
 end
 
-Then /^the mode of filesystem object "([^"]*)" should match "([^"]*)"$/ do |name, mode|
-  mod?(mode, name)
+Then /^the mode of filesystem object "([^"]*)" should match "([^"]*)"$/ do |file, mode|
+  check_filesystem_permissions(mode, file, true)
+end
+
+Given /^a mocked home directory$/ do
+  set_env 'HOME', File.expand_path(current_dir)
+end
+
+Before '@mocked_home_directory' do
+  set_env 'HOME', File.expand_path(current_dir)
+end
+
+After do
+  restore_env
 end

data/spec/aruba/api_spec.rb

@@ -1,7 +1,12 @@
 require 'spec_helper'
+require 'securerandom'
 
 describe Aruba::Api  do
 
+  def random_string(options = {})
+    options[:prefix].to_s + SecureRandom.hex + options[:suffix].to_s
+  end
+
   before(:each) do
     klass = Class.new {
       include Aruba::Api
@@ -51,27 +56,51 @@ describe Aruba::Api  do
   end
 
   describe 'directories' do
-    context 'delete directory' do
+    context '#remove_dir' do
       before(:each) do
         @directory_name = 'test_dir'
         @directory_path = File.join(@aruba.current_dir, @directory_name)
         Dir.mkdir(@directory_path)
       end
+
       it 'should delete directory' do
         @aruba.remove_dir(@directory_name)
         expect(File.exist?(@directory_path)).to eq false
       end
+
+      it "works with ~ in path name" do
+        directory_path = File.join('~', random_string)
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          Dir.mkdir(File.expand_path(directory_path))
+          @aruba.remove_dir(directory_path)
+
+          expect(File.exist?(File.expand_path(directory_path))).to eq false
+        end
+      end
     end
   end
 
   describe 'files' do
-    context 'fixed size' do
+    context '#write_fixed_size_file' do
       it "should write a fixed sized file" do
         @aruba.write_fixed_size_file(@file_name, @file_size)
         expect(File.exist?(@file_path)).to eq true
         expect(File.size(@file_path)).to eq @file_size
       end
 
+      it "works with ~ in path name" do
+        file_path = File.join('~', random_string)
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          @aruba.write_fixed_size_file(file_path, @file_size)
+
+          expect(File.exist?(File.expand_path(file_path))).to eq true
+          expect(File.size(File.expand_path(file_path))).to eq @file_size
+        end
+      end
+    end
+    context '#check_file_size' do
       it "should check an existing file size" do
         @aruba.write_fixed_size_file(@file_name, @file_size)
         @aruba.check_file_size([[@file_name, @file_size]])
@@ -81,33 +110,100 @@ describe Aruba::Api  do
         @aruba.write_fixed_size_file(@file_name, @file_size)
         expect { @aruba.check_file_size([[@file_name, @file_size + 1]]) }.to raise_error
       end
+
+      it "works with ~ in path name" do
+        file_path = File.join('~', random_string)
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          @aruba.write_fixed_size_file(file_path, @file_size)
+          @aruba.check_file_size([[file_path, @file_size]])
+        end
+      end
+
+      it "should check an existing file size and fail" do
+        @aruba.write_fixed_size_file(@file_name, @file_size)
+        expect { @aruba.check_file_size([[@file_name, @file_size + 1]]) }.to raise_error
+      end
     end
-    context 'existing' do
+    context '#filesystem_permissions' do
       before(:each) { File.open(@file_path, 'w') { |f| f << "" } }
-      it "should delete file" do
-        @aruba.remove_file(@file_name)
-        expect(File.exist?(@file_path)).to eq false
-      end
 
       it "should change a file's mode" do
-        @aruba.chmod(0644, @file_name)
+        @aruba.filesystem_permissions(0644, @file_name)
         result = sprintf( "%o" , File::Stat.new(@file_path).mode )[-4,4]
         expect(result).to eq('0644')
 
-        @aruba.chmod(0655, @file_name)
+        @aruba.filesystem_permissions(0655, @file_name)
         result = sprintf( "%o" , File::Stat.new(@file_path).mode )[-4,4]
         expect(result).to eq('0655')
 
-        @aruba.chmod("0655", @file_name)
+        @aruba.filesystem_permissions("0655", @file_name)
         result = sprintf( "%o" , File::Stat.new(@file_path).mode )[-4,4]
         expect(result).to eq('0655')
       end
 
-      it "should check the mode of a file" do
-        @aruba.chmod(0666, @file_name)
-        expect(@aruba.mod?(0666, @file_name) ).to eq(true)
+      it "supports a string representation of permission as well" do
+        @aruba.filesystem_permissions(0666, @file_name)
+        @aruba.check_filesystem_permissions('0666', @file_name, true)
+      end
+
+      it "should succeed if mode does not match but is expected to be different" do
+        @aruba.filesystem_permissions(0666, @file_name)
+        @aruba.check_filesystem_permissions(0755, @file_name, false)
+      end
+
+      it "should fail if mode matches and is expected to be different" do
+        @aruba.filesystem_permissions(0666, @file_name)
+        expect {
+          @aruba.check_filesystem_permissions(0666, @file_name, false)
+        }.to raise_error
       end
 
+      it "should fail if mode does not match but is expected to be equal" do
+        @aruba.filesystem_permissions(0666, @file_name)
+        expect {
+          @aruba.check_filesystem_permissions(0755, @file_name, true)
+        }.to raise_error
+      end
+
+      it "should succeed if mode matches and is expected to be equal" do
+        @aruba.filesystem_permissions(0666, @file_name)
+        @aruba.check_filesystem_permissions(0666, @file_name, true)
+      end
+
+      it "works with ~ in path name" do
+        file_name = "~/test_file"
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          File.open(File.expand_path(file_name), 'w') { |f| f << "" }
+
+          @aruba.filesystem_permissions(0666, file_name)
+          expect(@aruba.check_filesystem_permissions(0666, file_name, true) ).to eq(true)
+        end
+      end
+    end
+    context '#remove_file' do
+      before(:each) { File.open(@file_path, 'w') { |f| f << "" } }
+
+      it "should delete file" do
+        @aruba.remove_file(@file_name)
+        expect(File.exist?(@file_path)).to eq false
+      end
+
+      it "works with ~ in path name" do
+        file_path = File.join('~', random_string)
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          File.open(File.expand_path(file_path), 'w') { |f| f << "" }
+          @aruba.remove_file(file_path)
+          expect(File.exist?(file_path)).to eq false
+        end
+      end
+    end
+
+    context '#check_file_presence' do
+      before(:each) { File.open(@file_path, 'w') { |f| f << "" } }
+
       it "should check existence using plain match" do
         file_name = 'nested/dir/hello_world.txt'
         file_path = File.join(@aruba.current_dir, file_name)
@@ -143,6 +239,98 @@ describe Aruba::Api  do
         @aruba.check_file_presence([ /test123/, 'asdf' ], false )
       end
 
+      it "works with ~ in path name" do
+        file_path = File.join('~', random_string)
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          FileUtils.mkdir_p File.dirname(File.expand_path(file_path))
+          File.open(File.expand_path(file_path), 'w') { |f| f << "" }
+
+          @aruba.check_file_presence( [ file_path ], true )
+        end
+      end
+    end
+
+    context "#check_file_content" do
+      before :each do
+        @aruba.write_file(@file_name, "foo bar baz")
+      end
+
+      it "succeeds if file content matches" do
+        @aruba.check_file_content(@file_name, "foo bar baz", true)
+      end
+
+      it "succeeds if file content does not match" do
+        @aruba.check_file_content(@file_name, "hello world", false)
+      end
+
+      it "works with ~ in path name" do
+        file_path = File.join('~', random_string)
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          @aruba.write_file(file_path, "foo bar baz")
+          @aruba.check_file_content(file_path, "hello world", false)
+        end
+      end
+    end
+
+    context "#with_file_content" do
+      before :each do
+        @aruba.write_file(@file_name, "foo bar baz")
+      end
+
+      it "checks the given file's full content against the expectations in the passed block" do
+        @aruba.with_file_content @file_name do |full_content|
+          expect(full_content).to eq "foo bar baz"
+        end
+      end
+
+      it "works with ~ in path name" do
+        file_path = File.join('~', random_string)
+
+        with_env 'HOME' => File.expand_path(current_dir) do
+          @aruba.write_file(file_path, "foo bar baz")
+
+          @aruba.with_file_content file_path do |full_content|
+            expect(full_content).to eq "foo bar baz"
+          end
+        end
+      end
+
+      context "checking the file's content against the expectations in the block" do
+        it "is successful when the inner expectations match" do
+          expect do
+            @aruba.with_file_content @file_name do |full_content|
+              expect(full_content).to     match /foo/
+              expect(full_content).not_to match /zoo/
+            end
+          end . not_to raise_error
+        end
+
+        it "raises RSpec::Expectations::ExpectationNotMetError when the inner expectations don't match"  do
+          expect do
+            @aruba.with_file_content @file_name do |full_content|
+              expect(full_content).to     match /zoo/
+              expect(full_content).not_to match /foo/
+            end
+          end . to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+    end #with_file_content
+  end
+
+  describe 'process environment' do
+    context '#with_env' do
+      it 'modifies env for block' do
+        variable = 'THIS_IS_A_ENV_VAR'
+        ENV[variable] = '1'
+
+        with_env variable => '0' do
+          expect(ENV[variable]).to eq '0'
+        end
+
+        expect(ENV[variable]).to eq '1'
+      end
     end
   end
 
@@ -169,39 +357,6 @@ describe Aruba::Api  do
     end
   end
 
-  describe "#with_file_content" do
-    before :each do
-      @aruba.write_file(@file_name, "foo bar baz")
-    end
-
-    it "checks the given file's full content against the expectations in the passed block" do
-       @aruba.with_file_content @file_name do |full_content|
-         expect(full_content).to eq "foo bar baz"
-       end
-    end
-
-    context "checking the file's content against the expectations in the block" do
-      it "is successful when the inner expectations match" do
-        expect do
-          @aruba.with_file_content @file_name do |full_content|
-            expect(full_content).to     match /foo/
-            expect(full_content).not_to match /zoo/
-          end
-        end . not_to raise_error
-      end
-
-      it "raises RSpec::Expectations::ExpectationNotMetError when the inner expectations don't match"  do
-        expect do
-          @aruba.with_file_content @file_name do |full_content|
-            expect(full_content).to     match /zoo/
-            expect(full_content).not_to match /foo/
-          end
-        end . to raise_error RSpec::Expectations::ExpectationNotMetError
-      end
-    end
-
-  end #with_file_content
-
   describe "#assert_not_matching_output" do
     before(:each){ @aruba.run_simple("echo foo", false) }
     after(:each){ @aruba.stop_processes! }
@@ -255,14 +410,39 @@ describe Aruba::Api  do
     end
   end
 
-  describe "#run_simple" do
-    after(:each){@aruba.stop_processes!}
-    it "runs with different env" do
+  describe "#set_env" do
+    after(:each) do
+      @aruba.stop_processes!
+      @aruba.restore_env
+    end
+    it "set environment variable" do
       @aruba.set_env 'LONG_LONG_ENV_VARIABLE', 'true'
       @aruba.run "env"
-      expect(@aruba.all_output).to include("LONG_LONG_ENV_VARIABLE")
+      expect(@aruba.all_output).to include("LONG_LONG_ENV_VARIABLE=true")
     end
+    it "overwrites environment variable" do
+      @aruba.set_env 'LONG_LONG_ENV_VARIABLE', 'true'
+      @aruba.set_env 'LONG_LONG_ENV_VARIABLE', 'false'
+      @aruba.run "env"
+      expect(@aruba.all_output).to include("LONG_LONG_ENV_VARIABLE=false")
+    end
+  end
 
+  describe "#restore_env" do
+    after(:each){@aruba.stop_processes!}
+    it "restores environment variable" do
+      @aruba.set_env 'LONG_LONG_ENV_VARIABLE', 'true'
+      @aruba.restore_env
+      @aruba.run "env"
+      expect(@aruba.all_output).not_to include("LONG_LONG_ENV_VARIABLE")
+    end
+    it "restores environment variable that has been set multiple times" do
+      @aruba.set_env 'LONG_LONG_ENV_VARIABLE', 'true'
+      @aruba.set_env 'LONG_LONG_ENV_VARIABLE', 'false'
+      @aruba.restore_env
+      @aruba.run "env"
+      expect(@aruba.all_output).not_to include("LONG_LONG_ENV_VARIABLE")
+    end
   end
 
 end # Aruba::Api

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aruba
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Aslak Hellesøy
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-30 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -226,24 +226,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: aruba-0.6.0
-test_files:
-- features/before_cmd_hooks.feature
-- features/command_environment_variables.feature
-- features/custom_ruby_process.feature
-- features/exit_statuses.feature
-- features/file_system_commands.feature
-- features/flushing.feature
-- features/interactive.feature
-- features/no_clobber.feature
-- features/output.feature
-- features/step_definitions/aruba_dev_steps.rb
-- features/support/custom_main.rb
-- features/support/env.rb
-- features/support/jruby.rb
-- features/utf-8.feature
-- spec/aruba/api_spec.rb
-- spec/aruba/hooks_spec.rb
-- spec/aruba/jruby_spec.rb
-- spec/aruba/spawn_process_spec.rb
-- spec/spec_helper.rb
+summary: aruba-0.6.1
+test_files: []