aruba 0.14.9 → 1.0.0

data/features/api/filesystem/disk_usage.feature

@@ -1,152 +0,0 @@
-@unsupported-on-ruby-older-19
-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:
-    """ruby
-    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:
-    """ruby
-    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:
-    """ruby
-    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:
-    """ruby
-    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:
-    """ruby
-    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:
-    """ruby
-    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

@@ -1,62 +0,0 @@
-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:
-    """ruby
-    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:
-    """ruby
-    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/fixtures.feature

@@ -1,104 +0,0 @@
-Feature: Use fixtures in your tests
-
-  Sometimes your tests need existing files to work - e.g binary data files you
-  cannot create programmatically. Since `aruba` >= 0.6.3 includes some basic
-  support for fixtures. All you need to do is the following:
-  
-  1. Create a `fixtures`-directory
-  2. Create fixture files in this directory
-  
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Use a fixture for your tests
-    Given a file named "features/fixtures.feature" with:
-    """
-    Feature: Fixture
-      Scenario: Fixture
-        Given a file named "fixtures_spec.rb" with:
-        \"\"\"
-        RSpec.describe 'My Feature' do
-          describe '#read_music_file' do
-            context 'when the file exists' do
-              before :each { copy '%/song.mp3', 'file.mp3' }
-
-              it { expect('file.mp3').to be_an_existing_file }
-            end
-          end
-        end
-        \"\"\"
-    """
-    And a directory named "fixtures"
-    And an empty file named "fixtures/fixtures-app/test.txt"
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Use a fixture for your tests in test/
-    Given a file named "features/fixtures.feature" with:
-    """
-    Feature: Fixture
-      Scenario: Fixture
-        Given a file named "fixtures_spec.rb" with:
-        \"\"\"
-        RSpec.describe 'My Feature' do
-          describe '#read_music_file' do
-            context 'when the file exists' do
-              before :each { copy '%/song.mp3', 'file.mp3' }
-
-              it { expect('file.mp3').to be_an_existing_file }
-            end
-          end
-        end
-        \"\"\"
-    """
-    And a directory named "test/fixtures"
-    And an empty file named "test/fixtures/fixtures-app/test.txt"
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Use a fixture for your tests in spec/
-    Given a file named "features/fixtures.feature" with:
-    """
-    Feature: Fixture
-      Scenario: Fixture
-        Given a file named "fixtures_spec.rb" with:
-        \"\"\"
-        RSpec.describe 'My Feature' do
-          describe '#read_music_file' do
-            context 'when the file exists' do
-              before :each { copy '%/song.mp3', 'file.mp3' }
-
-              it { expect('file.mp3').to be_an_existing_file }
-            end
-          end
-        end
-        \"\"\"
-    """
-    And a directory named "spec/fixtures"
-    And an empty file named "spec/fixtures/fixtures-app/test.txt"
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Use a fixture for your tests in features/
-    Given a file named "features/fixtures.feature" with:
-    """
-    Feature: Fixture
-      Scenario: Fixture
-        Given a file named "fixtures_spec.rb" with:
-        \"\"\"
-        RSpec.describe 'My Feature' do
-          describe '#read_music_file' do
-            context 'when the file exists' do
-              before :each { copy '%/song.mp3', 'file.mp3' }
-
-              it { expect('file.mp3').to be_an_existing_file }
-            end
-          end
-        end
-        \"\"\"
-    """
-    And a directory named "features/fixtures"
-    And an empty file named "features/fixtures/fixtures-app/test.txt"
-    When I run `rspec`
-    Then the specs should all pass

data/features/api/filesystem/is_absolute.feature

@@ -1,48 +0,0 @@
-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:
-    """ruby
-    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:
-    """ruby
-    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

@@ -1,53 +0,0 @@
-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:
-    """ruby
-    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:
-    """ruby
-    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

@@ -1,54 +0,0 @@
-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:
-    """ruby
-    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:
-    """ruby
-    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

data/features/api/filesystem/is_relative.feature

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

data/features/api/filesystem/move.feature

@@ -1,119 +0,0 @@
-Feature: Move file/directory
-
-  If you need to move some files/directories you can use the `#move`-method
-  command. If multiple arguments are given, the last one needs to be a directory.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Non-existing destination
-    Given a file named "spec/cd_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Move', :type => :aruba do
-      let(:old_location) { 'old_dir.d' }
-      let(:new_location) { 'new_dir.d' }
-
-      before(:each) do 
-        create_directory old_location
-        move old_location, new_location
-      end
-
-      it { expect(new_location).to be_an_existing_directory }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Existing destination
-    Given a file named "spec/cd_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Move', :type => :aruba do
-      let(:old_location) { 'old_dir.d' }
-      let(:new_location) { 'new_dir.d' }
-
-      before(:each) do 
-        create_directory old_location
-        create_directory new_location
-
-        move old_location, new_location
-      end
-
-      it { expect(File.join(new_location, old_location)).to be_an_existing_directory }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Source is fixture path
-    Given a file named "spec/cd_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Move', :type => :aruba do
-      let(:old_location) { '%/old_dir.d' }
-      let(:new_location) { 'new_dir.d' }
-
-      it { expect { move old_location, new_location }.to raise_error ArgumentError, /fixture/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Destination is fixture path
-    Given a file named "spec/cd_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Move', :type => :aruba do
-      let(:old_location) { 'old_dir.d' }
-      let(:new_location) { '%/new_dir.d' }
-
-      it { expect { move old_location, new_location }.to raise_error ArgumentError, /fixture/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Multiple sources and destination is directory
-    Given a file named "spec/cd_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Move', :type => :aruba do
-      let(:old_location) { %w(old_dir1.d old_dir2.d) }
-      let(:new_location) { 'new_dir.d' }
-
-      before :each do
-        old_location.each { |l| create_directory l }
-        move old_location, new_location
-      end
-
-      it { expect(old_location.map { |l| File.join(new_location, l) }).to all be_an_existing_directory }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Multiple sources and destination is file
-    Given a file named "spec/cd_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Move', :type => :aruba do
-      let(:old_location) { %w(old_dir1.d old_dir2.d) }
-      let(:new_location) { 'new_file.txt' }
-
-      before :each do
-        old_location.each { |l| create_directory l }
-        touch new_location
-      end
-
-      it { expect { move old_location, new_location }.to raise_error ArgumentError, /Multiple sources/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass