aruba 0.14.10 → 1.0.0

data/features/04_aruba_api/filesystem/report_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/04_aruba_api/filesystem/use_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/04_aruba_api/text/extract_text.feature

@@ -1,87 +0,0 @@
-Feature: Extract text from output
-
-  If you need to strip down some command output to plain text, you can use the
-  `#extract_text`-method for this.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Output contains ansi escape codes prefixed by \e
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n "\e[31mText"
-    """
-    And a file named "spec/extract_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(extract_text(unescape_text(last_command.output))).to eq "Text" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains ansi escape codes prefixed by \033
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n "\033[31mText"
-    """
-    And a file named "spec/extract_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(extract_text(unescape_text(last_command.output))).to eq "Text" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-    # Scenario: Output contains ansi escape code \016
-    #   Given an executable named "bin/aruba-test-cli" with:
-    #   """
-    #   #!/bin/bash
-    #   echo -n "\016Text"
-    #   """
-    #   And a file named "spec/extract_text_spec.rb" with:
-    #   """
-    #   require 'spec_helper'
-    #
-    #   RSpec.describe 'Run command', :type => :aruba do
-    #     before(:each) { run_command('aruba-test-cli') }
-    #     before(:each) { stop_all_commands }
-    #
-    #     it { expect(extract_text(unescape_text(last_command.output))).to eq "Text" }
-    #   end
-    #   """
-    #   When I run `rspec`
-    #   Then the specs should all pass
-
-    # Scenario: Output contains ansi escape code \017
-    #   Given an executable named "bin/aruba-test-cli" with:
-    #   """
-    #   #!/bin/bash
-    #   echo -n "\017Text"
-    #   """
-    #   And a file named "spec/extract_text_spec.rb" with:
-    #   """
-    #   require 'spec_helper'
-    #
-    #   RSpec.describe 'Run command', :type => :aruba do
-    #     before(:each) { run_command('aruba-test-cli') }
-    #     before(:each) { stop_all_commands }
-    #
-    #     it { expect(extract_text(unescape_text(last_command.output))).to eq "Text" }
-    #   end
-    #   """
-    #   When I run `rspec`
-    #   Then the specs should all pass

data/features/04_aruba_api/text/replace_variables.feature

@@ -1,45 +0,0 @@
-@experimental
-Feature: Replace variables
-
-  There are use cases where you need access to some information from aruba in
-  your command line. The `#replace_variables`-method makes this information
-  available.
-
-  Please note, this feature is experimental for now. The implementation of this
-  feature and the name of variables may change without further notice.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: PID of last command started
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "spec/replace_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
- 
-      it { expect(replace_variables('<pid-last-command-started>')).to eq last_command_started.pid.to_s }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: No last command started
-    Given a file named "spec/replace_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      it { expect { replace_variables('<pid-last-command-started>') }.to raise_error Aruba::NoCommandHasBeenStartedError }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-

data/features/04_aruba_api/text/sanitize_text.feature

@@ -1,228 +0,0 @@
-Feature: Sanitize text from output
-
-  If have got some text include \n, \t and the like and need them to become
-  special characters again and also want the text to be stripped down to bare
-  text, you can use the `#sanitize_text`-method for this.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Output contains \n
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\ntext'
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "text\ntext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \e
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\etext'
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \"
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\"text'
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "text\"text" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \033
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\033text'
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \017
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\017text'
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \016
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\016text'
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains ansi escape codes prefixed by \e
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n "\e[31mText"
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "Text" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains ansi escape codes prefixed by \033
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n "\033[31mText"
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "Text" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains ansi escape codes prefixed by \e, but removable is disabled by configuration
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n "\e[31mText"
-    """
-    And a file named "spec/sanitize_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :remove_ansi_escape_sequences => false, :keep_ansi => true do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(sanitize_text(last_command_started.output)).to eq "\e[31mText" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-    # Scenario: Output contains ansi escape code \016
-    #   Given an executable named "bin/aruba-test-cli" with:
-    #   """
-    #   #!/bin/bash
-    #   echo -n "\016Text"
-    #   """
-    #   And a file named "spec/sanitize_spec.rb" with:
-    #   """
-    #   require 'spec_helper'
-    #
-    #   RSpec.describe 'Run command', :type => :aruba do
-    #     before(:each) { run_command('aruba-test-cli') }
-    #     before(:each) { stop_all_commands }
-    #
-    #     it { expect(sanitize_text(last_command_started.output)).to eq "Text" }
-    #   end
-    #   """
-    #   When I run `rspec`
-    #   Then the specs should all pass
-
-    # Scenario: Output contains ansi escape code \017
-    #   Given an executable named "bin/aruba-test-cli" with:
-    #   """
-    #   #!/bin/bash
-    #   echo -n "\017Text"
-    #   """
-    #   And a file named "spec/sanitize_spec.rb" with:
-    #   """
-    #   require 'spec_helper'
-    #
-    #   RSpec.describe 'Run command', :type => :aruba do
-    #     before(:each) { run_command('aruba-test-cli') }
-    #     before(:each) { stop_all_commands }
-    #
-    #     it { expect(sanitize_text(last_command_started.output)).to eq "Text" }
-    #   end
-    #   """
-    #   When I run `rspec`
-    #   Then the specs should all pass