aruba 0.6.2 → 0.7.0

data/lib/aruba/utils.rb

@@ -0,0 +1,21 @@
+module Aruba
+  module Utils
+    def detect_ruby(cmd)
+      if cmd =~ /^ruby\s/
+        cmd.gsub(/^ruby\s/, "#{current_ruby} ")
+      else
+        cmd
+      end
+    end
+
+    def current_ruby
+      File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    end
+
+    def ensure_newline(str)
+      str.chomp << "\n"
+    end
+
+    module_function :detect_ruby, :current_ruby, :ensure_newline
+  end
+end

data/script/bootstrap

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+info_msg="\e[0;32m[INFO]\e[0;30m"
+error_msg="\e[0;31mFAILED\e[0;30m"
+
+function output_error_log {
+  [[ -f error.log ]] && ( cat error.log >&2; rm error.log)
+}
+
+echo -ne "$info_msg Checking if ruby installed? "
+which 'ruby' >/dev/null 2>error.log || ( echo -e "$error_msg\n\nCould not find \`ruby\`. Please install ruby or add it to PATH"; output_error_log; exit 1 )
+echo OK
+
+echo -en "$info_msg rubygem \"bundler\" "
+gem install bundler >/dev/null 2>error.log || ( echo -e "$error_msg\n\nAn error occurred during installation of bundler. Run \`gem install bundler\` yourself."; output_error_log; exit 1 )
+echo OK
+
+echo -en "$info_msg \"bundle install\" "
+bundle install $* >/dev/null 2>error.log || ( echo -e "$error_msg\n\nAn error occurred during bundle install. Run \`bundle install\` yourself."; output_error_log; exit 1 )
+echo OK

data/script/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'pry'
+
+require 'aruba/api'
+require 'aruba/reporting'
+
+module Aruba
+  class MyConsole
+    include Aruba::Api
+  end
+end
+
+include Aruba
+Pry.start MyConsole.new

data/script/test

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+bundle exec rake test

data/spec/aruba/api_spec.rb

@@ -2,136 +2,714 @@ require 'spec_helper'
 require 'securerandom'
 
 describe Aruba::Api  do
+  include_context 'uses aruba API'
 
-  def random_string(options = {})
-    options[:prefix].to_s + SecureRandom.hex + options[:suffix].to_s
+  describe 'current_directory' do
+    it "should return the current dir as 'tmp/aruba'" do
+      expect(@aruba.current_directory).to match(/^tmp\/aruba$/)
+    end
+
+    it "can be cleared" do
+      write_file('test', 'test test test')
+
+      in_current_directory do
+        expect(File.exist?('test')).to be_truthy
+      end
+
+      clean_current_directory
+
+      in_current_directory do
+        expect(File.exist?('test')).to be_falsey
+      end
+    end
   end
 
-  before(:each) do
-    klass = Class.new {
-      include Aruba::Api
+  describe '#all_paths' do
+    let(:name) { @file_name }
+    let(:path) { @file_path }
 
-      def set_tag(tag_name, value)
-        self.instance_variable_set "@#{tag_name}", value
+    context 'when file exist' do
+      before :each do
+        File.write(path, '')
       end
 
-      def announce_or_puts(*args)
-        p caller[0..2]
+      it { expect(all_paths).to include expand_path(name) }
+    end
+
+    context 'when directory exist' do
+      let(:name) { 'test_dir' }
+      let(:path) { File.join(@aruba.current_directory, name) }
+
+      before :each do
+        FileUtils.mkdir_p path
       end
-    }
-    @aruba = klass.new
 
-    @file_name = "test.txt"
-    @file_size = 256
-    @file_path = File.join(@aruba.current_dir, @file_name)
+      it { expect(all_paths).to include expand_path(name) }
+    end
 
-    (@aruba.dirs.length - 1).times do |depth| #Ensure all parent dirs exists
-      dir = File.join(*@aruba.dirs[0..depth])
-      Dir.mkdir(dir) unless File.exist?(dir)
+    context 'when nothing exist' do
+      it { expect(all_paths).to eq [] }
     end
-    raise "We must work with relative paths, everything else is dangerous" if ?/ == @aruba.current_dir[0]
-    FileUtils.rm_rf(@aruba.current_dir)
-    Dir.mkdir(@aruba.current_dir)
   end
 
-  describe 'current_dir' do
-    it "should return the current dir as 'tmp/aruba'" do
-      expect(@aruba.current_dir).to match(/^tmp\/aruba$/)
+  describe '#all_files' do
+    let(:name) { @file_name }
+    let(:path) { @file_path }
+
+    context 'when file exist' do
+      before :each do
+        File.write(path, '')
+      end
+
+      it { expect(all_files).to include expand_path(name) }
     end
 
-    it "can be cleared" do
-      write_file('test', 'test test test')
+    context 'when directory exist' do
+      let(:name) { 'test_dir' }
+      let(:path) { File.join(@aruba.current_directory, name) }
 
-      in_current_dir do
-        expect(File.exist?('test')).to be_truthy
+      before :each do
+        FileUtils.mkdir_p path
       end
 
-      clean_current_dir
+      it { expect(all_files).to eq [] }
+    end
 
-      in_current_dir do
-        expect(File.exist?('test')).to be_falsey
+    context 'when nothing exist' do
+      it { expect(all_files).to eq [] }
+    end
+  end
+
+  describe '#all_directories' do
+    let(:name) { @file_name }
+    let(:path) { @file_path }
+
+    context 'when file exist' do
+      before :each do
+        File.write(path, '')
       end
 
+      it { expect(all_directories).to eq [] }
+    end
+
+    context 'when directory exist' do
+      let(:name) { 'test_dir' }
+      let(:path) { File.join(@aruba.current_directory, name) }
+
+      before :each do
+        FileUtils.mkdir_p path
+      end
+
+      it { expect(all_directories).to include expand_path(name) }
+    end
+
+    context 'when nothing exist' do
+      it { expect(all_directories).to eq [] }
     end
   end
 
   describe 'directories' do
     before(:each) do
       @directory_name = 'test_dir'
-      @directory_path = File.join(@aruba.current_dir, @directory_name)
+      @directory_path = File.join(@aruba.current_directory, @directory_name)
     end
 
-    context '#create_dir' do
+    context '#create_directory' do
       it 'creates a directory' do
-        @aruba.create_dir @directory_name
+        @aruba.create_directory @directory_name
         expect(File.exist?(File.expand_path(@directory_path))).to be_truthy
       end
     end
+  end
 
-    context '#remove_dir' do
-      before :each do
-        Dir.mkdir(@directory_path)
+  describe '#read' do
+    let(:name) { 'test.txt'}
+    let(:path) { File.join(@aruba.current_directory, name) }
+    let(:content) { 'asdf' }
+
+    before :each do
+      set_env 'HOME',  File.expand_path(@aruba.current_directory)
+    end
+
+    context 'when does not exist' do
+      it { expect { @aruba.read(name) }.to raise_error ArgumentError }
+    end
+
+    context 'when exists' do
+      context 'when file' do
+        before :each do
+          File.open(File.expand_path(path), 'w') { |f| f << content }
+        end
+
+        context 'when normal file' do
+          it { expect(@aruba.read(name)).to eq [content] }
+        end
+
+        context 'when binary file' do
+          let(:content) { "\u0000" }
+          it { expect(@aruba.read(name)).to eq [content] }
+        end
+
+        context 'when is empty file' do
+          let(:content) { '' }
+          it { expect(@aruba.read(name)).to eq [] }
+        end
+
+        context 'when path contains ~' do
+          let(:string) { random_string }
+          let(:name) { File.join('~', string) }
+          let(:path) { File.join(@aruba.current_directory, string) }
+
+          it { expect(@aruba.read(name)).to eq [content] }
+        end
       end
 
-      it 'should delete directory' do
-        @aruba.remove_dir(@directory_name)
-        expect(File.exist?(@directory_path)).to eq false
+      context 'when directory' do
+        let(:name) { 'test.d' }
+
+        before :each do
+          Array(path).each { |p| Dir.mkdir p }
+        end
+
+        it { expect { @aruba.read(name) }.to raise_error ArgumentError }
       end
+    end
+  end
 
-      it "works with ~ in path name" do
-        directory_path = File.join('~', random_string)
+  describe '#list' do
+    let(:name) { 'test.d' }
+    let(:content) { %w(subdir.1.d subdir.2.d) }
+    let(:path) { File.join(@aruba.current_directory, name) }
+
+    before :each do
+      set_env 'HOME',  File.expand_path(@aruba.current_directory)
+    end
+
+    context 'when does not exist' do
+      it { expect { @aruba.list(name) }.to raise_error ArgumentError }
+    end
+
+    context 'when exists' do
+      context 'when file' do
+        let(:name) { 'test.txt' }
+
+        before :each do
+          File.open(File.expand_path(path), 'w') { |f| f << content }
+        end
+
+        context 'when normal file' do
+          it { expect{ @aruba.list(name) }.to raise_error ArgumentError }
+        end
+      end
+
+      context 'when directory' do
+        before :each do
+          Array(path).each { |p| Dir.mkdir p }
+        end
 
-        with_env 'HOME' => File.expand_path(current_dir) do
-          Dir.mkdir(File.expand_path(directory_path))
-          @aruba.remove_dir(directory_path)
+        before :each do
+          Array(content).each { |p| Dir.mkdir File.join(path, p) }
+        end
+
+        context 'when has subdirectories' do
+          context 'when is simple path' do
+            let(:existing_files) { @aruba.list(name) }
+            let(:expected_files) { content.map { |c| File.join(name, c) }.sort  }
+
+            it { expect(expected_files - existing_files).to be_empty}
+          end
+
+          context 'when path contains ~' do
+            let(:string) { random_string }
+            let(:name) { File.join('~', string) }
+            let(:path) { File.join(@aruba.current_directory, string) }
+
+            let(:existing_files) { @aruba.list(name) }
+            let(:expected_files) { content.map { |c| File.join(string, c) } }
 
-          expect(File.exist?(File.expand_path(directory_path))).to eq false
+            it { expect(expected_files - existing_files).to be_empty}
+          end
+        end
+
+        context 'when has no subdirectories' do
+          let(:content) { [] }
+          it { expect(@aruba.list(name)).to eq [] }
+        end
+      end
+    end
+  end
+
+  describe '#remove' do
+    let(:name) { 'test.txt'}
+    let(:path) { File.join(@aruba.current_directory, name) }
+    let(:options) { {} }
+
+    before :each do
+      set_env 'HOME',  File.expand_path(@aruba.current_directory)
+    end
+
+    context 'when file' do
+      context 'when exists' do
+        before :each do
+          Array(path).each { |p| File.open(File.expand_path(p), 'w') { |f| f << "" } }
+        end
+
+        before :each do
+          @aruba.remove(name, options)
+        end
+
+        context 'when is a single file' do
+          it_behaves_like 'a non-existing file'
+        end
+
+        context 'when are multiple files' do
+          let(:file_name) { %w(file1 file2 file3) }
+          let(:file_path) { %w(file1 file2 file3).map { |p| File.join(@aruba.current_directory, p) } }
+
+          it_behaves_like 'a non-existing file'
+        end
+
+        context 'when path contains ~' do
+          let(:string) { random_string }
+          let(:file_name) { File.join('~', string) }
+          let(:file_path) { File.join(@aruba.current_directory, string) }
+
+          it_behaves_like 'a non-existing file'
+        end
+      end
+
+      context 'when does not exist' do
+        before :each do
+          @aruba.remove(name, options)
+        end
+
+        context 'when is forced to delete file' do
+          let(:options) { { force: true } }
+
+          it_behaves_like 'a non-existing file'
+        end
+      end
+    end
+
+    context 'when is directory' do
+      let(:name) { 'test.d' }
+
+      context 'when exists' do
+        before :each do
+          Array(path).each { |p| Dir.mkdir p }
+        end
+
+        before :each do
+          @aruba.remove(name, options)
+        end
+
+        context 'when is a single directory' do
+          it_behaves_like 'a non-existing directory'
+        end
+
+        context 'when are multiple directorys' do
+          let(:directory_name) { %w(directory1 directory2 directory3) }
+          let(:directory_path) { %w(directory1 directory2 directory3).map { |p| File.join(@aruba.current_directory, p) } }
+
+          it_behaves_like 'a non-existing directory'
+        end
+
+        context 'when path contains ~' do
+          let(:string) { random_string }
+          let(:directory_name) { File.join('~', string) }
+          let(:directory_path) { File.join(@aruba.current_directory, string) }
+
+          it_behaves_like 'a non-existing directory'
+        end
+      end
+
+      context 'when does not exist' do
+        before :each do
+          @aruba.remove(name, options)
+        end
+
+        context 'when is forced to delete directory' do
+          let(:options) { { force: true } }
+
+          it_behaves_like 'a non-existing directory'
         end
       end
     end
   end
 
   describe 'files' do
-    context '#touch_file' do
-      it 'creates an empty file' do
-        @aruba.touch_file(@file_name)
-        expect(File.exist?(@file_path)).to eq true
-        expect(File.size(@file_path)).to eq 0
+    describe '#touch' do
+      let(:name) { @file_name }
+      let(:path) { @file_path }
+      let(:options) { {} }
+
+      before :each do
+        set_env 'HOME',  File.expand_path(@aruba.current_directory)
       end
 
-      it 'supports an unexisting directory in path' do
-        path = 'directory/test'
-        full_path = File.join(@aruba.current_dir, path)
-        @aruba.touch_file(path)
+      context 'when file' do
+        before :each do
+          @aruba.touch(name, options)
+        end
+
+        context 'when does not exist' do
+          context 'and should be created in existing directory' do
+            it { expect(File.size(path)).to eq 0 }
+            it_behaves_like 'an existing file'
+          end
+
+          context 'and should be created in non-existing directory' do
+            let(:name) { 'directory/test' }
+            let(:path) { File.join(@aruba.current_directory, 'directory/test') }
+
+            it_behaves_like 'an existing file'
+          end
+
+          context 'and path includes ~' do
+            let(:string) { random_string }
+            let(:name) { File.join('~', string) }
+            let(:path) { File.join(@aruba.current_directory, string) }
+
+            it_behaves_like 'an existing file'
+          end
+
+          context 'and the mtime should be set statically' do
+            let(:time) { Time.parse('2014-01-01 10:00:00') }
+            let(:options) { { mtime: Time.parse('2014-01-01 10:00:00') } }
+
+            it_behaves_like 'an existing file'
+            it { expect(File.mtime(path)).to eq time }
+          end
 
-        expect(File.exist?(full_path)).to eq true
+          context 'and multiple file names are given' do
+            let(:name) { %w(file1 file2 file3) }
+            let(:path) { %w(file1 file2 file3).map { |p| File.join(@aruba.current_directory, p) } }
+            it_behaves_like 'an existing file'
+          end
+        end
       end
 
-      it "works with ~ in path name" do
-        file_path = File.join('~', random_string)
+      context 'when directory' do
+        let(:name) { %w(directory1) }
+        let(:path) { Array(name).map { |p| File.join(@aruba.current_directory, p) } }
 
-        with_env 'HOME' => File.expand_path(current_dir) do
-          @aruba.touch_file(file_path)
-          expect(File.exist?(File.expand_path(file_path))).to eq true
+        context 'when exist' do
+          before(:each) { Array(path).each { |p| FileUtils.mkdir_p p } }
+
+          before :each do
+            @aruba.touch(name, options)
+          end
+
+          context 'and the mtime should be set statically' do
+            let(:time) { Time.parse('2014-01-01 10:00:00') }
+            let(:options) { { mtime: Time.parse('2014-01-01 10:00:00') } }
+
+            it_behaves_like 'an existing directory'
+            it { Array(path).each { |p| expect(File.mtime(p)).to eq time } }
+          end
+        end
+      end
+    end
+
+    describe '#absolute?' do
+      let(:name) { @file_name }
+      let(:path) { File.expand_path(File.join(@aruba.current_directory, name)) }
+
+      context 'when is absolute path' do
+        it { expect(@aruba).to be_absolute(path) }
+      end
+
+      context 'when is relative path' do
+        it { expect(@aruba).not_to be_absolute(name) }
+      end
+    end
+
+    describe '#relative?' do
+      let(:name) { @file_name }
+      let(:path) { File.expand_path(File.join(@aruba.current_directory, name)) }
+
+      context 'when is absolute path' do
+        it { expect(@aruba).not_to be_relative(path) }
+      end
+
+      context 'when is relative path' do
+        it { expect(@aruba).to be_relative(name) }
+      end
+    end
+
+    describe '#exist?' do
+      context 'when is file' do
+        let(:name) { @file_name }
+        let(:path) { @file_path }
+
+        context 'when exists' do
+          before :each do
+            File.write(path, '')
+          end
+
+          it { expect(@aruba).to be_exist(name) }
+        end
+
+        context 'when does not exist' do
+          it { expect(@aruba).not_to be_exist(name) }
+        end
+      end
+
+      context 'when is directory' do
+        let(:name) { 'test.d' }
+        let(:path) { File.join(@aruba.current_directory, name) }
+
+        context 'when exists' do
+          before :each do
+            FileUtils.mkdir_p path
+          end
+
+          it { expect(@aruba).to be_exist(name) }
+        end
+
+        context 'when does not exist' do
+          it { expect(@aruba).not_to be_exist(name) }
+        end
+      end
+    end
+
+    describe '#file?' do
+      context 'when is file' do
+        let(:name) { @file_name }
+        let(:path) { @file_path }
+
+        context 'when exists' do
+          before :each do
+            File.write(path, '')
+          end
+
+          it { expect(@aruba).to be_file(name) }
+        end
+
+        context 'when does not exist' do
+          it { expect(@aruba).not_to be_file(name) }
+        end
+      end
+
+      context 'when is directory' do
+        let(:name) { 'test.d' }
+        let(:path) { File.join(@aruba.current_directory, name) }
+
+        context 'when exists' do
+          before :each do
+            FileUtils.mkdir_p path
+          end
+
+          it { expect(@aruba).not_to be_file(name) }
+        end
+
+        context 'when does not exist' do
+          it { expect(@aruba).not_to be_file(name) }
+        end
+      end
+    end
+
+    describe '#directory?' do
+      context 'when is file' do
+        let(:name) { @file_name }
+        let(:path) { @file_path }
+
+        context 'when exists' do
+          before :each do
+            File.write(path, '')
+          end
+
+          it { expect(@aruba).not_to be_directory(name) }
+        end
+
+        context 'when does not exist' do
+          it { expect(@aruba).not_to be_directory(name) }
+        end
+      end
+
+      context 'when is directory' do
+        let(:name) { 'test.d' }
+        let(:path) { File.join(@aruba.current_directory, name) }
+
+        context 'when exists' do
+          before :each do
+            FileUtils.mkdir_p path
+          end
+
+          it { expect(@aruba).to be_directory(name) }
+        end
+
+        context 'when does not exist' do
+          it { expect(@aruba).not_to be_directory(name) }
+        end
+      end
+    end
+
+    describe '#copy' do
+      let(:source) { 'file.txt' }
+      let(:destination) { 'file1.txt' }
+
+      context 'when source is existing' do
+        context 'when destination is non-existing' do
+          context 'when source is file' do
+            before(:each) { create_test_files(source) }
+
+            before :each do
+              @aruba.copy source, destination
+            end
+
+            context 'when source is plain file' do
+              it { expect(destination).to be_existing_file }
+            end
+
+            context 'when source is contains "~" in path' do
+              let(:source) { '~/file.txt' }
+              it { expect(destination).to be_existing_file }
+            end
+
+            context 'when source is fixture' do
+              let(:source) { '%/copy/file.txt' }
+              let(:destination) { 'file.txt' }
+              it { expect(destination).to be_existing_file }
+            end
+
+            context 'when source is list of files' do
+              let(:source) { %w(file1.txt file2.txt file3.txt) }
+              let(:destination) { 'file.d' }
+              let(:destination_files) { source.map { |s| File.join(destination, s) } }
+
+              it { expect(destination_files).to be_existing_files }
+            end
+          end
+
+          context 'when source is directory' do
+            let(:source) { 'src.d' }
+            let(:destination) { 'dst.d' }
+
+            before :each do
+              FileUtils.mkdir_p File.join(@aruba.current_directory, source)
+            end
+
+            before :each do
+              @aruba.copy source, destination
+            end
+
+            context 'when source is single directory' do
+              it { expect(destination).to be_existing_directory }
+            end
+
+            context 'when source is nested directory' do
+              let(:source) { 'src.d/subdir.d' }
+              let(:destination) { 'dst.d/' }
+
+              it { expect(destination).to be_existing_directory }
+            end
+          end
+        end
+
+        context 'when destination is existing' do
+          context 'when source is list of files' do
+            before(:each) { create_test_files(source) }
+
+            context 'when destination is directory' do
+              let(:source) { %w(file1.txt file2.txt file3.txt) }
+              let(:destination) { 'file.d' }
+              let(:destination_files) { source.map { |s| File.join(destination, s) } }
+
+              before :each do
+                FileUtils.mkdir_p File.join(@aruba.current_directory, destination)
+              end
+
+              before :each do
+                @aruba.copy source, destination
+              end
+
+              it { source.each { |s| expect(destination_files).to be_existing_files } }
+            end
+
+            context 'when destination is not a directory' do
+              let(:source) { %w(file1.txt file2.txt file3.txt) }
+              let(:destination) { 'file.txt' }
+
+              before(:each) { create_test_files(destination) }
+
+              it { expect { @aruba.copy source, destination }.to raise_error ArgumentError, "Multiples sources can only be copied to a directory" }
+            end
+
+            context 'when a source is the same like destination' do
+              let(:source) { 'file1.txt' }
+              let(:destination) { 'file1.txt' }
+
+              before(:each) { create_test_files(source) }
+
+              # rubocop:disable Metrics/LineLength
+              it { expect { @aruba.copy source, destination }.to raise_error ArgumentError, %(same file: #{File.expand_path(File.join(@aruba.current_directory, source))} and #{File.expand_path(File.join(@aruba.current_directory, destination))}) }
+              # rubocop:enable Metrics/LineLength
+            end
+
+            context 'when a fixture is destination' do
+              let(:source) { '%/copy/file.txt' }
+              let(:destination) { '%/copy/file.txt' }
+
+              it { expect { @aruba.copy source, destination }.to raise_error ArgumentError, "Using a fixture as destination (#{destination}) is not supported" }
+            end
+          end
+        end
+
+        context 'when source is non-existing' do
+          it { expect { @aruba.copy source, destination }.to raise_error ArgumentError}
         end
       end
     end
 
     context '#absolute_path' do
-      it 'expands and returns path' do
-        expect(@aruba.absolute_path(@file_name)).to eq File.expand_path(@file_path)
+      context 'when file_name is array of path names' do
+        it { silence(:stderr) { expect(@aruba.absolute_path(['path', @file_name])).to eq File.expand_path(File.join(current_directory, 'path', @file_name)) } }
+      end
+    end
+
+    context '#expand_path' do
+      context 'when file_name is given' do
+        it { expect(@aruba.expand_path(@file_name)).to eq File.expand_path(@file_path) }
+      end
+
+      context 'when path contains "."' do
+        it { expect(@aruba.expand_path('.')).to eq File.expand_path(current_directory) }
+      end
+
+      context 'when path contains ".."' do
+        it { expect(@aruba.expand_path('path/..')).to eq File.expand_path(File.join(current_directory)) }
+      end
+
+      context 'when path is nil' do
+        it { expect { @aruba.expand_path(nil) }.to raise_error ArgumentError }
       end
 
-      it 'removes "."' do
-        expect(@aruba.absolute_path('.')).to eq File.expand_path(current_dir)
+      context 'when path is empty' do
+        it { expect { @aruba.expand_path('') }.to raise_error ArgumentError }
       end
 
-      it 'removes ".."' do
-        expect(@aruba.absolute_path('..')).to eq File.expand_path(File.join(current_dir, '..'))
+      context 'when dir_path is given similar to File.expand_path ' do
+        it { expect(@aruba.expand_path(@file_name, 'path')).to eq File.expand_path(File.join(current_directory, 'path', @file_name)) }
       end
 
-      it 'joins multiple arguments' do
-        expect(@aruba.absolute_path('path', @file_name)).to eq File.expand_path(File.join(current_dir, 'path', @file_name))
+      context 'when file_name contains fixtures "%" string' do
+        let(:klass) do
+          Class.new do
+            include Aruba::Api
+
+            def root_directory
+              File.expand_path(current_directory)
+            end
+          end
+        end
+
+        before :each do
+          @aruba = klass.new
+          @aruba.touch_file 'spec/fixtures/file1'
+        end
+
+        it { expect(@aruba.expand_path('%/file1')).to eq File.expand_path(File.join(current_directory, 'spec', 'fixtures', 'file1')) }
       end
     end
 
@@ -153,7 +731,7 @@ describe Aruba::Api  do
       it "works with ~ in path name" do
         file_path = File.join('~', random_string)
 
-        with_env 'HOME' => File.expand_path(current_dir) do
+        with_env 'HOME' => File.expand_path(current_directory) do
           @aruba.write_fixed_size_file(file_path, @file_size)
 
           expect(File.exist?(File.expand_path(file_path))).to eq true
@@ -176,7 +754,7 @@ describe Aruba::Api  do
       it "works with ~ in path name" do
         file_path = File.join('~', random_string)
 
-        with_env 'HOME' => File.expand_path(current_dir) do
+        with_env 'HOME' => File.expand_path(current_directory) do
           @aruba.write_fixed_size_file(file_path, @file_size)
           @aruba.check_file_size([[file_path, @file_size]])
         end
@@ -188,78 +766,100 @@ describe Aruba::Api  do
       end
     end
 
-    context '#filesystem_permissions' do
-      before(:each) { File.open(@file_path, 'w') { |f| f << "" } }
-
-      it "should change a file's mode" do
-        @aruba.filesystem_permissions(0644, @file_name)
-        result = sprintf( "%o" , File::Stat.new(@file_path).mode )[-4,4]
-        expect(result).to eq('0644')
+    describe '#filesystem_permissions' do
+      def actuctual_permissions
+        format( "%o" , File::Stat.new(file_path).mode )[-4,4]
+      end
 
-        @aruba.filesystem_permissions(0655, @file_name)
-        result = sprintf( "%o" , File::Stat.new(@file_path).mode )[-4,4]
-        expect(result).to eq('0655')
+      let(:file_name) { @file_name }
+      let(:file_path) { @file_path }
+      let(:permissions) { '0655' }
 
-        @aruba.filesystem_permissions("0655", @file_name)
-        result = sprintf( "%o" , File::Stat.new(@file_path).mode )[-4,4]
-        expect(result).to eq('0655')
+      before(:each) do
+        File.open(file_path, 'w') { |f| f << "" }
       end
 
-      it "supports a string representation of permission as well" do
-        @aruba.filesystem_permissions(0666, @file_name)
-        @aruba.check_filesystem_permissions('0666', @file_name, true)
+      before(:each) do
+        @aruba.filesystem_permissions(permissions, file_name)
       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)
+      context 'when file exists' do
+        context 'and permissions are given as string' do
+          it { expect(actuctual_permissions).to eq('0655') }
+        end
+
+        context 'and permissions are given as octal number' do
+          let(:permissions) { 0655 }
+          it { expect(actuctual_permissions).to eq('0655') }
+        end
+
+        context 'and path has ~ in it' do
+          let(:string) { random_string }
+          let(:file_name) { File.join('~', string) }
+          let(:file_path) { File.join(@aruba.current_directory, string) }
+
+          it { expect(actuctual_permissions).to eq('0655') }
+        end
       end
+    end
+
+    describe '#check_filesystem_permissions' do
+      let(:file_name) { @file_name }
+      let(:file_path) { @file_path }
 
-      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
+      let(:permissions) { '0655' }
+
+      before :each do
+        set_env 'HOME',  File.expand_path(@aruba.current_directory)
       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
+      before(:each) do
+        File.open(file_path, 'w') { |f| f << "" }
       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)
+      before(:each) do
+        @aruba.filesystem_permissions(permissions, file_name)
       end
 
-      it "works with ~ in path name" do
-        file_name = "~/test_file"
+      context 'when file exists' do
+        context 'and should have permissions' do
+          context 'and permissions are given as string' do
+            it { @aruba.check_filesystem_permissions(permissions, file_name, true) }
+          end
+
+          context 'and permissions are given as octal number' do
+            let(:permissions) { 0666 }
+
+            it { @aruba.check_filesystem_permissions(permissions, file_name, true) }
+          end
 
-        with_env 'HOME' => File.expand_path(current_dir) do
-          File.open(File.expand_path(file_name), 'w') { |f| f << "" }
+          context 'and path includes ~' do
+            let(:string) { random_string }
+            let(:file_name) { File.join('~', string) }
+            let(:file_path) { File.join(@aruba.current_directory, string) }
 
-          @aruba.filesystem_permissions(0666, file_name)
-          expect(@aruba.check_filesystem_permissions(0666, file_name, true) ).to eq(true)
+            it { @aruba.check_filesystem_permissions(permissions, file_name, true) }
+          end
+
+          context 'but fails because the permissions are different' do
+            let(:expected_permissions) { 0666 }
+
+            it { expect { @aruba.check_filesystem_permissions(expected_permissions, file_name, true) }.to raise_error }
+          end
         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
+        context 'and should not have permissions' do
+          context 'and succeeds when the difference is expected and permissions are different' do
+            let(:different_permissions) { 0666 }
 
-      it "works with ~ in path name" do
-        file_path = File.join('~', random_string)
+            it { @aruba.check_filesystem_permissions(different_permissions, file_name, false) }
+          end
 
-        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
+          context 'and fails because the permissions are the same although they should be different' do
+            let(:different_permissions) { 0655 }
+
+            it { expect { @aruba.check_filesystem_permissions(different_permissions, file_name, false) }.to raise_error }
+          end
         end
       end
     end
@@ -269,7 +869,7 @@ describe Aruba::Api  do
 
       it "should check existence using plain match" do
         file_name = 'nested/dir/hello_world.txt'
-        file_path = File.join(@aruba.current_dir, file_name)
+        file_path = File.join(@aruba.current_directory, file_name)
 
         FileUtils.mkdir_p File.dirname( file_path )
         File.open(file_path, 'w') { |f| f << "" }
@@ -282,7 +882,7 @@ describe Aruba::Api  do
 
       it "should check existence using regex" do
         file_name = 'nested/dir/hello_world.txt'
-        file_path = File.join(@aruba.current_dir, file_name)
+        file_path = File.join(@aruba.current_directory, file_name)
 
         FileUtils.mkdir_p File.dirname( file_path )
         File.open(file_path, 'w') { |f| f << "" }
@@ -295,7 +895,7 @@ describe Aruba::Api  do
 
       it "is no problem to mix both" do
         file_name = 'nested/dir/hello_world.txt'
-        file_path = File.join(@aruba.current_dir, file_name)
+        file_path = File.join(@aruba.current_directory, file_name)
 
         FileUtils.mkdir_p File.dirname( file_path )
         File.open(file_path, 'w') { |f| f << "" }
@@ -307,7 +907,7 @@ describe Aruba::Api  do
       it "works with ~ in path name" do
         file_path = File.join('~', random_string)
 
-        with_env 'HOME' => File.expand_path(current_dir) do
+        with_env 'HOME' => File.expand_path(current_directory) do
           FileUtils.mkdir_p File.dirname(File.expand_path(file_path))
           File.open(File.expand_path(file_path), 'w') { |f| f << "" }
 
@@ -321,20 +921,38 @@ describe Aruba::Api  do
         @aruba.write_file(@file_name, "foo bar baz")
       end
 
-      context "#check_binary_file_content" do
-        it "succeeds if file content matches" do
-          @aruba.write_file("fixture", "foo bar baz")
-          @aruba.check_binary_file_content(@file_name, "fixture")
-          @aruba.check_binary_file_content(@file_name, "fixture", true)
+      describe "#check_binary_file_content" do
+        let(:file_name) { @file_name }
+        let(:file_path) { @file_path }
+
+        let(:reference_file) { 'fixture' }
+        let(:reference_file_content) { 'foo bar baz' }
+
+        before :each do
+          @aruba.write_file(reference_file, reference_file_content)
         end
 
-        it "succeeds if file content does not match" do
-          @aruba.write_file("wrong_fixture", "bar")
-          @aruba.check_binary_file_content(@file_name, "wrong_fixture", false)
+        context 'when files are the same' do
+          context 'and this is expected' do
+            it { @aruba.check_binary_file_content(file_name, reference_file) }
+            it { @aruba.check_binary_file_content(file_name, reference_file, true) }
+          end
+
+          context 'and this is not expected' do
+            it { expect { @aruba.check_binary_file_content(file_name, reference_file, false) }.to raise_error }
+          end
         end
 
-        it "raises if file does not exist" do
-          expect{@aruba.check_binary_file_content(@file_name, "non_existing", false)}.to raise_error
+        context 'when files are not the same' do
+          let(:reference_file_content) { 'bar' }
+
+          context 'and this is expected' do
+            it { @aruba.check_binary_file_content(file_name, reference_file, false) }
+          end
+
+          context 'and this is not expected' do
+            it { expect { @aruba.check_binary_file_content(file_name, reference_file, true) }.to raise_error }
+          end
         end
       end
 
@@ -354,7 +972,7 @@ describe Aruba::Api  do
           it "works with ~ in path name" do
             file_path = File.join('~', random_string)
 
-            with_env 'HOME' => File.expand_path(current_dir) do
+            with_env 'HOME' => File.expand_path(current_directory) do
               @aruba.write_file(file_path, "foo bar baz")
               @aruba.check_file_content(file_path, non_matching_content, false)
             end
@@ -375,7 +993,7 @@ describe Aruba::Api  do
           it "works with ~ in path name" do
             file_path = File.join('~', random_string)
 
-            with_env 'HOME' => File.expand_path(current_dir) do
+            with_env 'HOME' => File.expand_path(current_directory) do
               @aruba.write_file(file_path, "foo bar baz")
               @aruba.check_file_content(file_path, non_matching_content, false)
             end
@@ -398,7 +1016,7 @@ describe Aruba::Api  do
       it "works with ~ in path name" do
         file_path = File.join('~', random_string)
 
-        with_env 'HOME' => File.expand_path(current_dir) do
+        with_env 'HOME' => File.expand_path(current_directory) do
           @aruba.write_file(file_path, "foo bar baz")
 
           @aruba.with_file_content file_path do |full_content|
@@ -448,20 +1066,28 @@ describe Aruba::Api  do
     describe '@announce_stdout' do
       after(:each){@aruba.stop_processes!}
       context 'enabled' do
+        before :each do
+          @aruba.send(:announcer).activate(:stdout)
+        end
+
         it "should announce to stdout exactly once" do
-          expect(@aruba).to receive(:announce_or_puts).once
-          @aruba.set_tag(:announce_stdout, true)
-          @aruba.run_simple('echo "hello world"', false)
-          expect(@aruba.all_output).to match(/hello world/)
+          result = capture(:stdout) do
+            @aruba.run_simple('echo "hello world"', false)
+          end
+
+          expect(result).to include('hello world')
+          expect(@aruba.all_output).to include('hello world')
         end
       end
 
       context 'disabled' do
         it "should not announce to stdout" do
-          expect(@aruba).not_to receive(:announce_or_puts)
-          @aruba.set_tag(:announce_stdout, false)
-          @aruba.run_simple('echo "hello world"', false)
-          expect(@aruba.all_output).to match(/hello world/)
+          result = capture(:stdout) do
+            @aruba.run_simple('echo "hello world"', false)
+          end
+
+          expect(result).not_to include('hello world')
+          expect(@aruba.all_output).to include('hello world')
         end
       end
     end
@@ -520,6 +1146,46 @@ describe Aruba::Api  do
     end
   end
 
+  describe 'fixtures' do
+    let(:aruba) do
+      klass = Class.new do
+        include Aruba::Api
+
+        def root_directory
+          expand_path('.')
+        end
+      end
+
+      klass.new
+    end
+
+    describe '#fixtures_directory' do
+      context 'when no fixtures directories exist' do
+        it "should raise exception" do
+          expect { aruba.fixtures_directory }.to raise_error
+        end
+      end
+
+      context 'when "/features/fixtures"-directory exist' do
+        before(:each) { aruba.create_directory('features/fixtures') }
+
+        it { expect(aruba.fixtures_directory).to eq expand_path('features/fixtures') }
+      end
+
+      context 'when "/spec/fixtures"-directory exist' do
+        before(:each) { aruba.create_directory('spec/fixtures') }
+
+        it { expect(aruba.fixtures_directory).to eq expand_path('spec/fixtures') }
+      end
+
+      context 'when "/test/fixtures"-directory exist' do
+        before(:each) { aruba.create_directory('test/fixtures') }
+
+        it { expect(aruba.fixtures_directory).to eq expand_path('test/fixtures') }
+      end
+    end
+  end
+
   describe "#set_env" do
     after(:each) do
       @aruba.stop_processes!