aruba 0.8.1 → 0.9.0.pre

data/features/api/core/expand_path.feature

@@ -38,6 +38,22 @@ Feature: Expand paths with aruba
     When I run `rspec`
     Then the specs should all pass
 
+  Scenario: Warn if aruba's working directory does not exist
+    Given a file named "spec/expand_path_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Expand path', :type => :aruba do
+      before(:each) { remove('.') }
+
+      let(:path) { 'path/to/dir' }
+
+      it { expect { expand_path(path) }.to output(/working directory does not exist/).to_stderr }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
   Scenario: Use ~ in path
 
     Now this useses the HOME-variable from your normal shell HOME-variable.

data/features/api/{cd.feature → filesystem/cd.feature}

@@ -42,6 +42,7 @@ Feature: Change current working directory
       before(:each) { run_simple 'pwd' }
 
       it { expect(last_command.output).to include 'new_dir.d' }
+      it { expect(last_command).to be_executed_in_time }
     end
     """
     When I run `rspec`
@@ -162,7 +163,7 @@ Feature: Change current working directory
 
       before :each do
         @pwd = cd('new_dir.d') do
-          cd('subdir.d') { run('pwd') }
+          cd('subdir.d') { run_simple('pwd') }
         end
       end
 

data/features/api/filesystem/create_directory.feature

@@ -0,0 +1,57 @@
+Feature: Create Directory
+
+  Use the `#create_directory`-method to create a directory within `aruba`'s
+  working directory.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.configure do |config|
+    config.include Aruba::Api
+  end
+
+  RSpec.describe 'Create directory' do
+    let(:directory) { 'dir.d' }
+    before(:each) { create_directory(directory) }
+
+    it { expect(directory).to be_an_existing_directory }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: New directory
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Create directory', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      before(:each) { create_directory(directory) }
+
+      it { expect(directory).to be_an_existing_directory }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Existing directory
+
+    It does not complain if a directory already exists.
+
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Create directory', :type => :aruba do
+      let(:directory) { 'dir.d' }
+
+      before(:each) { create_directory(directory) }
+      before(:each) { create_directory(directory) }
+
+      it { expect(directory).to be_an_existing_directory }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/filesystem/disk_usage.feature

@@ -0,0 +1,151 @@
+Feature: Report disk usage
+
+  Sometimes you need to check, what amount of disk space a file consumes. We do
+  NOT support "directories" with `#disk_usage`. This does not work reliably
+  over different systems. Here can help `'#disk_usage`. But be careful, by
+  default it uses a block size of "512" (physical block size) to calculate the
+  usage. You may need to adjust this by using `Aruba.configure { |config|
+  config.physical_block_size = 4_096 }`. Don't get confused, if you check the
+  block size by using `File::Stat` (in ruby). It reports the block size of your
+  filesystem, which can be "4_096" for example.
+
+  We're gonna use the (correct) IEC-notation
+  (https://en.wikipedia.org/wiki/Binary_prefix) here:
+
+    \* kilo => kibi
+    \* mega => mebi
+    \* giga => gibi
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Show disk usage for file
+    Given a file named "spec/disk_usage_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'disk usage', :type => :aruba do
+      let(:file) { 'file.txt' }
+
+      before(:each) do 
+        write_file file, 'a'
+      end
+
+      let(:size_of_single_block) { File::Stat.new(expand_path(file)).blksize }
+
+      it { expect(disk_usage(file)).to eq size_of_single_block }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Show disk usage for multiple files
+
+    `#disk_usage` creates the sum of all given objects' sizes.
+
+    Given a file named "spec/disk_usage_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'disk usage', :type => :aruba do
+      let(:file1) { 'file1.txt' }
+      let(:file2) { 'file2.txt' }
+
+      before(:each) do 
+        write_file file1, 'a'
+        write_file file2, 'a'
+      end
+
+      let(:size_of_single_block) { File::Stat.new(expand_path(file1)).blksize }
+
+      it { expect(disk_usage(file1, file2)).to eq size_of_single_block * 2 }
+      it { expect(disk_usage([file1, file2])).to eq size_of_single_block * 2 }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Convert reported disk usage to KibiByte
+    Given a file named "spec/disk_usage_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'disk usage', :type => :aruba do
+      let(:file) { 'file.txt' }
+
+      before(:each) do 
+        write_file file, 'a'
+      end
+
+      let(:converted_size) { File::Stat.new(expand_path(file)).blksize.to_f / 1_024 }
+
+      it { expect(disk_usage(file).to_kibi_byte).to eq converted_size }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Convert reported disk usage to MebiByte
+    Given a file named "spec/disk_usage_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'disk usage', :type => :aruba do
+      let(:file) { 'file.txt' }
+
+      before(:each) do 
+        write_file file, 'a'
+      end
+
+      let(:converted_size) { File::Stat.new(expand_path(file)).blksize.to_f / 1_024 / 1024 }
+
+      it { expect(disk_usage(file).to_mebi_byte).to eq converted_size }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Convert reported disk usage to GibiByte
+    Given a file named "spec/disk_usage_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'disk usage', :type => :aruba do
+      let(:file) { 'file.txt' }
+
+      before(:each) do 
+        write_file file, 'a'
+      end
+
+      let(:converted_size) { File::Stat.new(expand_path(file)).blksize.to_f / 1_024 / 1_024 / 1_024 }
+
+      it { expect(disk_usage(file).to_gibi_byte).to eq converted_size }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Compare two repored disk usages
+    Given a file named "spec/disk_usage_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'disk usage', :type => :aruba do
+      let(:file1) { 'file1.txt' }
+      let(:file2) { 'file2.txt' }
+
+      before(:each) do 
+        write_file file1, 'a' * 10_000
+        write_file file2, 'a'
+      end
+
+      before :each do
+        @size1 = disk_usage(file1)
+        @size2 = disk_usage(file2)
+      end
+
+      it { expect(@size1).to be > @size2 }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/filesystem/does_exist.feature

@@ -0,0 +1,62 @@
+Feature: Check existence of files and directories
+
+  Use the `#exist?` to check if a path exists within
+  `aruba`'s working directory. , May also want to look for `#file?` or
+  `#directory?` for some more specific tests.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.configure do |config|
+    config.include Aruba::Api
+  end
+
+  RSpec.describe 'Check if directory and file exist' do
+    let(:directory) { 'dir.d' }
+    let(:file) { 'file.txt' }
+
+    before(:each) { create_directory(directory) }
+    before(:each) { touch(file) }
+
+    it { expect(exist?(directory)).to be true }
+    it { expect(exist?(file)).to be true }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Is file or directory and exists
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory and file exist', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      let(:file) { 'file.txt' }
+
+      before(:each) { create_directory(directory) }
+      before(:each) { touch(file) }
+
+      it { expect(exist?(directory)).to be true }
+      it { expect(exist?(file)).to be true }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Is file or directory and does not exist
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory and file exist', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      let(:file) { 'file.txt' }
+
+      it { expect(exist?(directory)).to be false }
+      it { expect(exist?(file)).to be false }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/filesystem/is_absolute.feature

@@ -0,0 +1,48 @@
+Feature: Check if path is absolute
+
+  Use the `#absolute?`-method to check if a path is an absolute path.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.configure do |config|
+    config.include Aruba::Api
+  end
+
+  RSpec.describe 'Check if directory or file is absolute' do
+    let(:path) { '/path/to/file.txt' }
+
+    it { expect(absolute?(path)).to be true }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Is path absolute
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory or file is absolute', :type => :aruba do
+      let(:path) { '/path/to/file.txt' }
+
+      it { expect(absolute?(path)).to be true }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Path should be absolute, but it's relative
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory or file is absolute', :type => :aruba do
+      let(:path) { 'file.txt' }
+
+      it { expect(absolute?(path)).to be false }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/filesystem/is_directory.feature

@@ -0,0 +1,53 @@
+Feature: Check existence of directories
+
+  Use the `#directory?` to check if a path is a directory and exists within
+  `aruba`'s working directory.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.configure do |config|
+    config.include Aruba::Api
+  end
+
+  RSpec.describe 'Check if directory and file exist' do
+    let(:directory) { 'dir.d' }
+
+    before(:each) { create_directory(directory) }
+
+    it { expect(directory?(directory)).to be true }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Is directory and exist
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory and file exist', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      before(:each) { create_directory(directory) }
+
+      it { expect(directory?(directory)).to be true }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Is file, but should be directory and exist
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory and file exist', :type => :aruba do
+      let(:file) { 'file.txt' }
+      before(:each) { touch(file) }
+
+      it { expect(directory?(file)).to be false }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/filesystem/is_file.feature

@@ -0,0 +1,54 @@
+Feature: Check existence of files
+
+  Use the `#file?` to check if a path is a file and exists within `aruba`'s
+  working directory.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.configure do |config|
+    config.include Aruba::Api
+  end
+
+  RSpec.describe 'Check if directory and file exist' do
+    let(:file) { 'file.txt' }
+
+    before(:each) { touch(file) }
+
+    it { expect(file?(file)).to be true }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Is file and exist
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory and file exist', :type => :aruba do
+      let(:file) { 'file.txt' }
+
+      before(:each) { touch(file) }
+
+      it { expect(file?(file)).to be true }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Is directory, but should be file and exist
+    Given a file named "spec/create_directory_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory and file exist', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      before(:each) { create_directory(directory) }
+
+      it { expect(file?(directory)).to be false }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass