aruba 0.14.9 → 1.0.0

data/features/configuration/usage.feature

@@ -1,159 +0,0 @@
-Feature: Usage of configuration
-
-  You can configure `aruba` in two ways:
-
-  1. Using `Aruba.configure`-block
-  2. Using `aruba.config.<option> = <value>`
-
-  The first (1.) should be used to set defaults for ALL your tests. It changes
-  values on loadtime. The latter (2.) should be used to change options only for
-  specific tests during runtime. `aruba.config` contains the runtime
-  configuration of aruba which is reset to the loadtime configuration before
-  each test is run.
-
-  Background:
-    Given I use a fixture named "cli-app"
-    And an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    trap "exit 128" SIGTERM SIGINT
-    sleep $*
-    """
-
-  Scenario: Setting default values for option for RSpec
-    Given a file named "spec/support/aruba.rb" with:
-    """ruby
-    require 'aruba/rspec'
-
-    Aruba.configure do |config|
-      config.exit_timeout = 1
-    end
-    """
-    And a file named "spec/usage_configuration_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      context 'when fast command' do
-        before(:each) { run_command('cli 0') }
-        it { expect(last_command_started).to be_successfully_executed }
-      end
-
-      context 'when slow command' do
-        before(:each) { run_command('cli 2') }
-        it { expect(last_command_started).not_to be_successfully_executed }
-      end
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Setting option during runtime for RSpec
-
-    Maybe there are some long running tests, which need longer. You may not
-    want to set the default timeout for all commands to the maximum value only
-    to prevent those commands from failing.
-
-    Given a file named "spec/support/aruba.rb" with:
-    """ruby
-    require 'aruba/rspec'
-
-    Aruba.configure do |config|
-      config.exit_timeout = 1
-    end
-    """
-    And a file named "spec/support/hooks.rb" with:
-    """ruby
-    RSpec.configure do |config|
-      config.before :each do |example|
-        next unless example.metadata.key? :slow_command
-
-        aruba.config.exit_timeout = 5
-      end
-    end
-    """
-    And a file named "spec/usage_configuration_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      context 'when fast command' do
-        before(:each) { run_command('cli 0') }
-        it { expect(last_command_started).to be_successfully_executed }
-      end
-
-      context 'when slow command and this is known by the developer', :slow_command => true do
-        before(:each) { run_command('cli 2') }
-        it { expect(last_command_started).to be_successfully_executed }
-      end
-
-      context 'when slow command, but this might be a failure' do
-        before(:each) { run_command('cli 2') }
-        it { expect(last_command_started).not_to be_successfully_executed }
-      end
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Setting default values for option for Cucumber
-    Given a file named "features/support/aruba.rb" with:
-    """ruby
-    require 'aruba/cucumber'
-
-    Aruba.configure do |config|
-      config.exit_timeout = 1
-    end
-    """
-    And a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Fast command
-        When I run `cli 0`
-        Then the exit status should be 0
-
-      Scenario: Slow command
-        When I run `cli 2`
-        Then the exit status should be 128
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Setting option during runtime for Cucumber
-
-    Maybe there are some long running tests, which need longer. You may not
-    want to set the default timeout for all commands to the maximum value only
-    to prevent those commands from failing.
-
-    Given a file named "features/support/aruba.rb" with:
-    """ruby
-    require 'aruba/cucumber'
-
-    Aruba.configure do |config|
-      config.exit_timeout = 1
-    end
-    """
-    And a file named "features/support/hooks.rb" with:
-    """ruby
-    Before '@slow-command' do
-      aruba.config.exit_timeout = 5
-    end
-    """
-    And a file named "features/usage_configuration.feature" with:
-    """
-    Feature: Run it
-      Scenario: Fast command
-        When I run `cli 0`
-        Then the exit status should be 0
-
-      @slow-command
-      Scenario: Slow command known by the developer
-        When I run `cli 2`
-        Then the exit status should be 0
-
-      Scenario: Slow command which might be a failure
-        When I run `cli 3`
-        Then the exit status should be 128
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/configuration/working_directory.feature

@@ -1,33 +0,0 @@
-Feature: Configure working directory of aruba
-
-  As a developer
-  I want to configure the working directory of aruba
-  In order to have a test directory for each used spec runner - e.g. cucumber or rspec
-
-  Background:
-    Given I use the fixture "cli-app"
-
-  Scenario: Default value
-    Given a file named "features/support/aruba.rb" with:
-    """
-    Aruba.configure do |config|
-      puts %(The default value is "#{config.working_directory}")
-    end
-    """
-    When I successfully run `cucumber`
-    Then the output should contain:
-    """
-    The default value is "tmp/aruba"
-    """
-
-  Scenario: Modify value
-    Given a file named "features/support/aruba.rb" with:
-    """
-    Aruba.configure do |config|
-      config.working_directory = 'tmp/cucumber'
-    end
-    """
-    And the default feature-test
-    And the default executable
-    When I successfully run `cucumber`
-    Then a directory named "tmp/cucumber" should exist

data/features/development/build.feature

@@ -1,15 +0,0 @@
-Feature: Build Aruba Gem
-
-  As a aruba developer
-  I want to build the `aruba` gem
-  In order to install it
-
-  Scenario: Building aruba using rake task
-
-    To build the `aruba`-gem you can use the `build`-rake task.
-
-    Given I successfully run `rake -T build`
-    Then the output should contain:
-    """
-    build
-    """

data/features/getting_started/cleanup.feature

@@ -1,58 +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 @no-clobber to stop Aruba from
-  cleaning up after itself.
-
-  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/getting_started/run_commands.feature

@@ -1,187 +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"
-    And a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given I successfully run `cli`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-
-  @requires-bash
-  Scenario: Bash Program
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo "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/cli" with:
-    """ruby
-    #!/usr/bin/env ruby
-
-    puts "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/cli" with:
-    """python
-    #!/usr/bin/env python
-
-    print("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/cli" with:
-    """perl
-    #!/usr/bin/env perl
-
-    print "Hello, Aruba!\n";
-    """
-    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`
-        And I cd to "tmp/"
-        And I successfully run `java HelloArubaApp`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    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/getting_started/supported_testing_frameworks.feature

@@ -1,104 +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/support/aruba.rb" with:
-    """
-    require 'aruba/rspec'
-    """
-    And a file named "spec/spec_helper.rb" with:
-    """
-    $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-
-    if RUBY_VERSION < '1.9.3'
-      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
-    else
-      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require_relative f }
-    end
-    """
-    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/support/aruba.rb" with:
-    """
-    require 'aruba/api'
-    """
-    And a file named "test/test_helper.rb" with:
-    """
-    $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-
-    if RUBY_VERSION < '1.9.3'
-      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
-    else
-      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require_relative f }
-    end
-    """
-    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/getting_started/writing_good_feature_tests.feature

@@ -1,38 +0,0 @@
-Feature: Writing good feature tests with aruba to create documentations
-
-  You can use Markdown within your feature tests. This is quite good to write a
-  living documentation.
-
-  There are some edge cases where Gherkin and Markdown don't agree. Bullet lists
-  using `*` is one example. The `*` is also an alias for step keywords in
-  Gherkin. Markdown headers (the kind starting with a `#`) is another example.
-  They are parsed as comments by Gherkin. To use either of these, just escape
-  them with a backslash. Alternatively just use the "-".
-
-  You'd write:
-
-  ```gherkin
-  Scenario: Make tea
-    \## Making tea
-    \* Get a pot
-    \* And some hot water
-
-    Given...
-  ```
-
-  This way Gherkin won't recognize these lines as special tokens, and the
-  reporter will render them as Markdown. (The reporter strips away any leading
-  the backslashes before handing it off to the Markdown parser).
-
-  Another option is to use alternative Markdown syntax and omit conflicts and
-  escaping altogether:
-
-  ```gherkin
-  Scenario: Make tea
-    Making tea
-    ----------
-    - Get a pot
-    - And some hot water
-
-    Given...
-  ```

data/features/hooks/after/command.feature

@@ -1,46 +0,0 @@
-Feature: After command hooks
-
-  You can configure Aruba to run blocks of code after it has run
-  a command. The command will be passed to the block.
-
-  You can hook into Aruba's lifecycle just before it runs a command and after it has run the command:
-
-  ```ruby
-  Aruba.configure do |config|
-    config.after :command do |cmd|
-      puts "After the run of '#{cmd}'"
-    end
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Run a simple command with an "after(:command)"-hook
-    Given a file named "spec/support/hooks.rb" with:
-    """
-    require 'aruba'
-
-    Aruba.configure do |config|
-      config.after :command do |cmd|
-        puts "after the run of `#{cmd.commandline}`"
-      end
-    end
-    """
-    And a file named "spec/hook_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Hooks', :type => :aruba do
-      before(:each) { run_command_and_stop 'echo running' }
-
-      it { expect(last_command_started.stdout.chomp).to eq 'running' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-    And the output should contain:
-    """
-    after the run of `echo running`
-    """
-