aruba 0.14.14 → 1.0.0.pre.alpha.1

data/features/.nav

@@ -1,72 +0,0 @@
-- README.md
-- getting_started (Getting Started):
-    - install.feature (Install Aruba)
-    - supported_programming_languages.feature (Supportet Programming Languages)
-- ruby_api (Ruby API):
-    - expand_path.feature (#expand_path)
-    - cleanup_aruba_directory.feature (#setup_aruba)
-    - run.feature (#run)
-    - which.feature (#which)
-    - append_environment_variable.feature (#append_environment_variable)
-    - prepend_environment_variable.feature (#prepend_environment_variable)
-    - set_environment_variable.feature (#set_environment_variable)
-    - cd.feature (#cd)
-    - create_directory.feature (#create_directory)
-    - disk_usage.feature (#disk_usage)
-    - does_exist.feature (#exist?)
-    - is_absolute.feature (#absolute?)
-    - filesystem/is_directory.feature (#directory?)
-    - is_file.feature (#file?)
-    - is_relative.feature(#relative?)
-    - move.feature (#move)
-    - file_system_commands.feature
-    - command.feature (Before Hook)
-    - command.feature (After Hook)
-- cucumber (Cucumber):
-    - debug_command.feature (Debug Commmands)
-    - environment_variables.feature (Environment Variables)
-    - flushing.feature (Flush Output)
-    - interactive.feature (Interactive Commands)
-    - all_output.feature (Command Output)
-    - stdout.feature (STDOUT)
-- configuration (Configuration):
-    - exit_timeout.feature (Exit Timeout)
-    - fixtures_directories.feature (Fixtures Directories)
-    - fixtures_path_prefix.feature (Fixture Path Prefix)
-    - home_directory.feature (Home Directory)
-    - io_timeout.feature (IO Wait Timeout)
-    - keep_ansi.feature (Keep ANSI output)
-    - log_level.feature (Log Level)
-    - physical_block_size.feature (Physical Block Size)
-    - root_directory.feature (Root Directory)
-    - working_directory.feature (Working Directory)
-- rspec (RSpec):
-    - getting_started.feature (Integration)
-    - include_an_object.feature (Matcher: Include an Object)
-    - have_sub_directory.feature (Matcher: Have Sub Directory)
-    - be_existing_file.feature (Matcher: Be Existing File)
-    - have_file_content.feature (Matcher: Have File Content)
-    - have_file_size.feature (Matcher: Have File Size)
-    - be_an_absolute_path.feature (Matcher: Be Absolute Path)
-    - be_an_existing_path.feature (Matcher: Be Existing Path)
-    - have_permissions.feature (Matcher: Have Permissions)
-    - timeouts.feature (Matcher: Timeouts)
-- cucumber (Cucumber):
-    - announce.feature (Announce Information to User)
-    - exit_statuses.feature (Exit Status of Commands)
-    - in_process.feature (Start Commands in Process)
-    - run.feature (Run Commands)
-    - home_variable.feature (Modify HOME-Variable)
-    - set_environment_variable.feature (Set Environment variables)
-    - copy.feature (Copy files/directories)
-    - create_directory.feature (Create Directories)
-    - create_file.feature (Create Files)
-    - file_content.feature (Use File Content)
-    - move.feature (Move files/directories)
-    - overwrite_file.feature (Overwrite Files)
-    - use_fixture.feature (Use Fixtures)
-    - output.feature (Output)
-    - utf-8.feature (Support for UTF-8-strings)
-- development (Development):
-    - build.feature (Build Aruba)
-    - test.feature (Test Aruba)

data/features/01_getting_started_with_aruba/cleanup_working_directory.feature

@@ -1,57 +0,0 @@
-Feature: Cleanup Aruba Working Directory
-
-  By default Aruba removes its scratch directory *before* every scenario. This
-  isn't always the right thing to do, especially when the path to the default
-  directory has been changed. Use the `@no-clobber`-tag on your scenarios to
-  stop Aruba from cleaning up *before* it runs.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Clean up artifacts and pwd from a previous scenario
-    Given a file named "features/cleanup.feature" with:
-    """
-    Feature: Check
-      Scenario: Check #1
-        Given a file named "file.txt" with "content"
-        And a directory named "dir.d"
-        Then a file named "file.txt" should exist
-        And a directory named "dir.d" should exist
-        When I cd to "dir.d"
-        And I run `pwd`
-        Then the output should match %r</tmp/aruba/dir.d$>
-
-      Scenario: Check #2
-        Then a file named "file.txt" should not exist
-        And a directory named "dir.d" should not exist
-        When I run `pwd`
-        Then the output should match %r</tmp/aruba$>
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Do not clobber before run
-    The `@no-clobber` tag stops Aruba from clearing out its scratch directory.
-    Other setup steps are still performed, such as setting the current working
-    directory.
-
-    Given a file named "tmp/aruba/file.txt" with "content"
-    And a directory named "tmp/aruba/dir.d"
-    And a file named "features/cleanup.feature" with:
-    """
-    Feature: Check
-      Scenario: Check #1
-        Given a file named "file.txt" with "content"
-        And a directory named "dir.d"
-        Then a file named "file.txt" should exist
-        And a directory named "dir.d" should exist
-
-      @no-clobber
-      Scenario: Check #2
-        Then a file named "file.txt" should exist
-        And a directory named "dir.d" should exist
-        When I run `pwd`
-        Then the output should match %r</tmp/aruba$>
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/01_getting_started_with_aruba/run_commands.feature

@@ -1,217 +0,0 @@
-Feature: Run commands with Aruba
-
-  As long as you've got the neccessary programs, libraries, runtime
-  environments, interpreters installed, it doesn't matter in which programming
-  language your commandline application is implemented. You can even use POSIX
-  standard tools like "printf".
-
-  Below you find some examples of the "Hello, Aruba!"-application implemented
-  with different programming languages and a single example for a POSIX
-  standard tool. This is NOT an exclusive list. Every commandline application
-  should run with `aruba`.
-
-  Background:
-    Given I use a fixture named "getting-started-app"
-
-  @requires-bash
-  Scenario: Bash Program
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo "Hello, Aruba!"
-    """
-    And a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given I successfully run `aruba-test-cli`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-bash
-  Scenario: Bash Program run via bash
-    Given a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given a file named "cli.sh" with:
-        \"\"\"
-        echo "Hello, Aruba!"
-        \"\"\"
-        When I successfully run `bash ./cli.sh`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-ruby
-  Scenario: Ruby Program
-    Given an executable named "bin/aruba-test-cli" with:
-    """ruby
-    #!/usr/bin/env ruby
-
-    puts "Hello, Aruba!"
-    """
-    And a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given I successfully run `aruba-test-cli`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-ruby
-  Scenario: Ruby Program via "ruby"
-    Given a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given a file named "cli.rb" with:
-        \"\"\"
-        puts "Hello, Aruba!"
-        \"\"\"
-        When I successfully run `ruby ./cli.rb`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-python
-  Scenario: Python Program
-    Given an executable named "bin/aruba-test-cli" with:
-    """python
-    #!/usr/bin/env python
-
-    print("Hello, Aruba!")
-    """
-    And a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given I successfully run `aruba-test-cli`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-python
-  Scenario: Python Program via "python"
-    Given a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given a file named "cli.py" with:
-        \"\"\"
-        print("Hello, Aruba!")
-        \"\"\"
-        When I successfully run `python ./cli.py`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-perl
-  Scenario: Perl Program
-    Given an executable named "bin/aruba-test-cli" with:
-    """perl
-    #!/usr/bin/env perl
-
-    print "Hello, Aruba!\n";
-    """
-    And a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given I successfully run `aruba-test-cli`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-perl
-  Scenario: Perl Program via "perl"
-    Given a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given a file named "cli.pl" with:
-        \"\"\"perl
-        print "Hello, Aruba!\n";
-        \"\"\"
-        When I successfully run `perl ./cli.pl`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  @requires-java
-  Scenario: Java Program
-
-    It's even possible to compile and run Java programs with Aruba.
-
-    Given a file named "features/hello_aruba.feature" with:
-    """cucumber
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given a file named "tmp/HelloArubaApp.java" with:
-        \"\"\"
-        class HelloArubaApp {
-          public static void main(String[] args) {
-            System.out.println("Hello, Aruba!");
-          }
-        }
-        \"\"\"
-        And I successfully run `javac tmp/HelloArubaApp.java` for up to 20 seconds
-        And I cd to "tmp/"
-        And I successfully run `java HelloArubaApp`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber` for up to 21 seconds
-    Then the features should all pass
-
-  @requires-posix-standard-tools
-  Scenario: POSIX standard tools
-    Given a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given I successfully run `printf "%s" "Hello, Aruba!"`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass

data/features/01_getting_started_with_aruba/supported_testing_frameworks.feature

@@ -1,88 +0,0 @@
-Feature: Supported Testing Frameworks
-
-  You can use `aruba` with all major testing frameworks from the Ruby World:
-
-    \* Cucumber
-    \* RSpec
-    \* Minitest
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Use "aruba" with "Cucumber"
-    Given a file named "features/support/env.rb" with:
-    """
-    require 'aruba/cucumber'
-    """
-    And a file named "features/use_aruba_with_cucumber.feature" with:
-    """
-    Feature: Cucumber
-      Scenario: First Run
-        Given a file named "file.txt" with:
-        \"\"\"
-        Hello World
-        \"\"\"
-        Then the file "file.txt" should contain:
-        \"\"\"
-        Hello World
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Use "aruba" with "RSpec"
-    Given a file named "spec/spec_helper.rb" with:
-    """
-    $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-
-    require 'aruba/rspec'
-    """
-    And a file named "spec/use_aruba_with_rspec_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'First Run', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:content) { 'Hello World' }
-
-      before(:each) { write_file file, content }
-
-      it { expect(read(file)).to eq [content] }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-
-  Scenario: Use "aruba" with "Minitest"
-    Given a file named "test/test_helper.rb" with:
-    """
-    $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-
-    require 'aruba/api'
-    """
-    And a file named "test/use_aruba_with_minitest.rb" with:
-    """
-    $LOAD_PATH.unshift File.expand_path('../test', __FILE__)
-
-    require 'test_helper'
-    require 'minitest/autorun'
-
-    class FirstRun < Minitest::Test
-      include Aruba::Api
-
-      def setup
-        aruba_setup
-      end
-
-      def getting_started_with_aruba
-        file = 'file.txt'
-        content = 'Hello World'
-
-        write_file file, content
-        read(file).must_equal [content]
-      end
-    end
-    """
-    When I run `ruby -Ilib:test test/use_aruba_with_minitest.rb`
-    Then the tests should all pass

data/features/02_configure_aruba/activate_announcer_on_command_failure.feature

@@ -1,38 +0,0 @@
-Feature: Configure announcer activation on command failure
-
-  As a developer
-  I want to configure which announcers should get activated on command failure
-  In order to understand what caused a command to fail
-
-  Background:
-    Given I use the fixture "cli-app"
-
-  Scenario: Default value
-    Given a file named "features/support/aruba_config.rb" with:
-    """ruby
-    Aruba.configure do |config|
-      puts %(The default value is "#{config.activate_announcer_on_command_failure.inspect}")
-    end
-    """
-    When I successfully run `cucumber`
-    Then the output should contain:
-    """ruby
-    The default value is "[]"
-    """
-
-  Scenario: Modify value
-    Given a file named "features/support/aruba_config.rb" with:
-    """ruby
-    Aruba.configure do |config|
-      config.activate_announcer_on_command_failure = [:foo, :bar]
-    end
-
-    Aruba.configure do |config|
-      puts %(The value is "#{config.activate_announcer_on_command_failure.inspect}")
-    end
-    """
-    Then I successfully run `cucumber`
-    Then the output should contain:
-    """
-    The value is "[:foo, :bar]"
-    """