aruba 0.14.14 → 1.0.0.pre.alpha.1

data/features/03_testing_frameworks/cucumber/steps/command/check_stderr_of_command.feature

@@ -1,68 +0,0 @@
-Feature: STDERR of commands which were executed
-
-  In order to specify expected output
-  As a developer using Cucumber
-  I want to use the "the stderr should contain" step
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Detect stderr from all processes
-    Given a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I run `bash -c 'printf "hello world!\n" >&2'`
-        And I run `bash -c 'cat >&2 '` interactively
-        And I type "hola"
-        And I type ""
-        Then the stderr should contain:
-        \"\"\"
-        hello world!
-        \"\"\"
-        And the stderr should contain:
-        \"\"\"
-        hola
-        \"\"\"
-        And the stdout should not contain anything
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect stderr from all processes
-    Given a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I run `bash -c 'printf "hello world!\n" >&2'`
-        And I run `bash -c 'cat >&2 '` interactively
-        And I type "hola"
-        And I type ""
-        Then the stderr should contain:
-        \"\"\"
-        hello world!
-        hola
-        \"\"\"
-        And the stdout should not contain anything
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect stderr from named source
-    Given a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I run `bash -c 'printf hello >&2'`
-        And I run `printf goodbye`
-        Then the stderr from "bash -c 'printf hello >&2'" should contain "hello"
-        And the stderr from "bash -c 'printf hello >&2'" should contain exactly "hello"
-        And the stderr from "bash -c 'printf hello >&2'" should contain exactly:
-        \"\"\"
-        hello
-        \"\"\"
-        And the stdout from "bash -c 'printf hello >&2'" should not contain "hello"
-        And the stderr from "printf goodbye" should not contain "hello"
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/03_testing_frameworks/cucumber/steps/command/check_stdout_of_command.feature

@@ -1,109 +0,0 @@
-Feature: STDOUT of commands which were executed
-
-  In order to specify expected output
-  As a developer using Cucumber
-  I want to use the "the stdout should contain" step
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Match output in stdout
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld"
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the stdout should contain "hello"
-        Then the stderr should not contain "hello"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Match stdout on several lines
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'GET /'
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the stdout should contain:
-        \"\"\"
-        GET /
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Match output on several lines where stdout contains quotes
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'GET "/"'
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the stdout should contain:
-        \"\"\"
-        GET "/"
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect stdout from all processes including interactive ones
-    Given a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I run `printf "hello world!\n"`
-        And I run `cat` interactively
-        And I type "hola"
-        And I type ""
-        Then the stdout should contain:
-        \"\"\"
-        hello world!
-        \"\"\"
-        And the stdout should contain:
-        \"\"\"
-        hola
-        \"\"\"
-        And the stderr should not contain anything
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect stdout from named source
-    Given a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I run `printf 'hello'`
-        And I run `printf 'goodbye'`
-        Then the stdout from "printf 'hello'" should contain "hello"
-        And the stdout from "printf 'hello'" should contain exactly "hello"
-        And the stdout from "printf 'hello'" should contain exactly:
-        \"\"\"
-        hello
-        \"\"\"
-        And the stderr from "printf 'hello'" should not contain "hello"
-        And the stdout from "printf 'goodbye'" should not contain "hello"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-

data/features/03_testing_frameworks/cucumber/steps/command/debug_your_command_in_aruba.feature

@@ -1,118 +0,0 @@
-Feature: Debug your command in cucumber-test-run
-
-  As a developer
-  I want to use some debugger in my code and therefor need system() to execute my program
-  In order to find a bug
-
-  Background:
-    Given I use a fixture named "cli-app"
-    And the default aruba exit timeout is 60 seconds
-
-  Scenario: Can handle exit status 0
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    exit 0
-    """
-    And a file named "features/debug.feature" with:
-    """cucumber
-    Feature: Exit status in debug environment
-
-      @debug
-      Scenario: Run program with debug code
-        When I run `aruba-test-cli`
-        Then the exit status should be 0
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  Scenario: Can handle exit status 1
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    exit 1
-    """
-    And a file named "features/debug.feature" with:
-    """cucumber
-    Feature: Exit status in debug environment
-
-      @debug
-      Scenario: Run program with debug code
-        When I run `aruba-test-cli`
-        Then the exit status should be 1
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  Scenario: You can use a debug repl in your cli program
-
-    If you want to debug a strange error, which only occures in one of your
-    `cucumber`-tests, the `@debug`-tag becomes handy. You can add `@debug` in
-    front of your feature/scenario to make `binding.pry` or `byebug` work in
-    your program.
-
-    Please make sure, that there's a statement after the `binding.pry`-call.
-    Otherwise you might not get an interactive shell, because your program will
-    just exit.
-
-    We are going to demonstrate this using `pry`, but any other interactive
-    debugger for any other programming language should also work.
-
-    Given an executable named "bin/aruba-test-cli" with:
-    """ruby
-    #!/usr/bin/env ruby
-
-    $stderr.sync = true
-    $stdout.sync = true
-
-    require 'pry'
-    binding.pry
-
-    exit 0
-    """
-    And a file named "features/debug.feature" with:
-    """cucumber
-    Feature: Exit status in debug environment
-
-      @debug
-      Scenario: Run program with debug code
-        When I run `aruba-test-cli`
-        Then the exit status should be 0
-    """
-    When I run `cucumber` interactively
-    And I stop the command started last if output contains:
-    """
-    pry(main)>
-    """
-    Then the output should match:
-    """
-    7:\s+binding.pry
-    """
-
-  Scenario: Can handle announcers
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    exit 0
-    """
-    And a file named "features/debug.feature" with:
-    """cucumber
-    Feature: Exit status in debug environment
-
-      @debug
-      @announce
-      Scenario: Run program with debug code
-        When I run `aruba-test-cli`
-        Then the exit status should be 0
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-    And the output should contain:
-    """
-    <<-STDOUT
-    This is the debug launcher on STDOUT. If this output is unexpected, please check your setup.
-    STDOUT
-    """

data/features/03_testing_frameworks/cucumber/steps/command/run_a_command.feature

@@ -1,66 +0,0 @@
-Feature: Run commands
-
-  There are several steps to run commands with `aruba`.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Run command found in path
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        When I run `aruba-test-cli`
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Activate desired announcers when running command fails
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo "Hello, I'm STDOUT"
-    exit 1
-    """
-    And a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        When I successfully run `aruba-test-cli`
-    """
-    And I append to "features/support/env.rb" with:
-    """
-    Before do
-      aruba.config.activate_announcer_on_command_failure = [:stdout]
-    end
-    """
-    When I run `cucumber`
-    Then the features should not pass
-    And the output should contain:
-    """
-    <<-STDOUT
-    Hello, I'm STDOUT
-
-    STDOUT
-    """
-
-  Scenario: Run command found in "bin"-directory which is found in the current directory
-    Given a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        Given an executable named "bin/local_cli" with:
-        \"\"\"
-        #!/bin/bash
-        exit 0
-        \"\"\"
-        And I look for executables in "bin" within the current directory
-        When I successfully run `local_cli`
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/03_testing_frameworks/cucumber/steps/command/run_command_in_process.feature

@@ -1,485 +0,0 @@
-Feature: Run commands in ruby process
-  Running a lot of scenarios where each scenario uses Aruba
-  to spawn a new ruby process can be time consuming.
-
-  Aruba lets you plug in your own process class that can
-  run a command in the same ruby process as Cucumber/Aruba.
-
-  We expect that the command supports the following API. It needs to accept:
-  argv, stdin, stdout, stderr and kernel on `#initialize` and it needs to have
-  an `execute!`-method.
-
-  ```ruby
-  module Cli
-    module App
-      class Runner
-        def initialize(argv, stdin, stdout, stderr, kernel)
-          \@argv   = argv
-          \@stdin  = stdin
-          \@stdout = stdout
-          \@stderr = stderr
-          \@kernel = kernel
-        end
-
-        def execute!
-        end
-      end
-    end
-  end
-  ```
-
-  The switch to the working directory takes place around the `execute!`-method.
-  If needed make sure, that you determine the current working directory within
-  code called by the `execute!`-method or just use `Dir.getwd` during "runtime"
-  and not during "loadtime", when the `ruby`-interpreter reads in you class
-  files.
-
-  *Pros*:
-  * Very fast compared to spawning processes
-  * You can use libraries like
-    [simplecov](https://github.com/colszowka/simplecov) more easily, because
-    there is only one "process" which adds data to `simplecov`'s database
-
-  *Cons*:
-  * You might oversee some bugs: You might forget to require libraries in your
-    "production" code, because you have required them in your testing code
-  * Using `:in_process` interactively is not supported
-
-  **WARNING**: Using `:in_process` interactively is not supported
-
-  Background:
-    Given I use a fixture named "cli-app"
-    And a file named "features/support/cli_app.rb" with:
-    """
-    require 'cli/app/runner'
-    """
-    And a file named "features/support/in_proccess.rb" with:
-    """
-    require 'aruba/cucumber'
-
-    Before('@in-process') do
-      aruba.config.command_launcher = :in_process
-      aruba.config.main_class = Cli::App::Runner
-    end
-
-    After('@in-process') do
-      aruba.config.command_launcher = :spawn
-    end
-    """
-
-  Scenario: Run custom code
-    Given a file named "lib/cli/app/runner.rb" with:
-    """
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            @stdin  = stdin
-            @stdout = stdout
-            @stderr = stderr
-            @kernel = kernel
-          end
-
-          def execute!
-            @stdout.puts(@argv.map(&:reverse).join(' '))
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        When I run `reverse.rb Hello World`
-        Then the output should contain:
-        \"\"\"
-        olleH dlroW
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Mixing custom code and normal cli
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo $*
-    """
-    And a file named "lib/cli/app/runner.rb" with:
-    """
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            @stdin  = stdin
-            @stdout = stdout
-            @stderr = stderr
-            @kernel = kernel
-          end
-
-          def execute!
-            @stdout.puts(@argv.map(&:reverse).join(' '))
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command in process
-        When I run `reverse.rb Hello World`
-        Then the output should contain:
-        \"\"\"
-        olleH dlroW
-        \"\"\"
-
-      Scenario: Run command
-        When I run `aruba-test-cli Hello World`
-        Then the output should contain:
-        \"\"\"
-        Hello World
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: The current working directory is changed as well
-    Given a file named "lib/cli/app/runner.rb" with:
-    """
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            @stdin  = stdin
-            @stdout = stdout
-            @stderr = stderr
-            @kernel = kernel
-          end
-
-          def execute!
-            @stdout.puts("PWD-ENV is " + Dir.getwd)
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        When I run `pwd.rb`
-        Then the output should match %r<PWD-ENV.*tmp/aruba>
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: The PWD environment is changed to current working directory
-    Given a file named "lib/cli/app/runner.rb" with:
-    """
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            @stdin  = stdin
-            @stdout = stdout
-            @stderr = stderr
-            @kernel = kernel
-          end
-
-          def execute!
-            @stdout.puts("PWD-ENV is " + ENV['PWD'])
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        When I run `pwd.rb`
-        Then the output should match %r<PWD-ENV.*tmp/aruba>
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Set runner via "Aruba.process ="-method (deprecated)
-    Given a file named "features/support/in_proccess.rb" with:
-    """
-    require 'aruba/cucumber'
-    require 'aruba/processes/in_process'
-
-    Before('@in-process') do
-      Aruba.process = Aruba::Processes::InProcess
-      Aruba.process.main_class = Cli::App::Runner
-    end
-
-    After('@in-process') do
-      Aruba.process = Aruba::Processes::SpawnProcess
-    end
-    """
-    Given a file named "lib/cli/app/runner.rb" with:
-    """
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            @stdin  = stdin
-            @stdout = stdout
-            @stderr = stderr
-            @kernel = kernel
-          end
-
-          def execute!
-            @stdout.puts(@argv.map(&:reverse).join(' '))
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        When I run `reverse.rb Hello World`
-        Then the output should contain:
-        \"\"\"
-        olleH dlroW
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Set runner via "Aruba.process ="-method and use old class name Aruba::InProcess (deprecated)
-    Given a file named "features/support/in_proccess.rb" with:
-    """
-    require 'aruba/cucumber'
-    require 'aruba/in_process'
-    require 'aruba/spawn_process'
-
-    Before('@in-process') do
-      Aruba.process = Aruba::InProcess
-      Aruba.process.main_class = Cli::App::Runner
-    end
-
-    After('@in-process') do
-      Aruba.process = Aruba::SpawnProcess
-    end
-    """
-    Given a file named "lib/cli/app/runner.rb" with:
-    """
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            @stdin  = stdin
-            @stdout = stdout
-            @stderr = stderr
-            @kernel = kernel
-          end
-
-          def execute!
-            @stdout.puts(@argv.map(&:reverse).join(' '))
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        When I run `reverse.rb Hello World`
-        Then the output should contain:
-        \"\"\"
-        olleH dlroW
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Use $stderr, $stdout and $stdin to access IO
-
-    May may need/want to use the default `STDERR`, `STDOUT`, `STDIN`-constants
-    to access IO from within your script. Unfortunately this does not work with
-    the `:in_process`-command launcher. You need to use `$stderr`, `$stdout`
-    and `$stdin` instead.
-
-    For this example I chose `thor` to parse ARGV. Its `.start`-method accepts
-    an "Array" as ARGV and a "Hash" for some other options &ndash; `.start <ARGV>, <OPTIONS>`
-
-    Given a file named "lib/cli/app/runner.rb" with:
-    """
-    require 'cli/app/cli_parser'
-
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            $kernel = kernel
-            $stdin  = stdin
-            $stdout = stdout
-            $stderr = stderr
-          end
-
-          def execute!
-            Cli::App::CliParser.start @argv
-          end
-        end
-      end
-    end
-    """
-    And a file named "lib/cli/app/cli_parser.rb" with:
-    """
-    require 'thor'
-
-    module Cli
-      module App
-        class CliParser < Thor
-          def self.exit_on_failure?
-            true
-          end
-
-          desc 'do_it', 'Reverse input'
-          def do_it(*args)
-            $stderr.puts 'Hey ya, Hey ya, check, check, check'
-            $stdout.puts(args.flatten.map(&:reverse).join(' '))
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        When I run `reverse.rb do_it Hello World`
-        Then the stdout should contain:
-        \"\"\"
-        olleH dlroW
-        \"\"\"
-        And the stderr should contain:
-        \"\"\"
-        Hey ya, Hey ya, check, check, check
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Use $kernel to use Kernel to capture exit code
-
-    Ruby's `Kernel`-module provides some helper methods like `exit`.
-    Unfortunately running `#exit` with `:in_process` would make the whole ruby
-    interpreter exit. So you might want to use our `FakeKernel`-module module
-    instead which overwrites `#exit`. This will also make our tests for
-    checking the exit code work. This example also uses the `thor`-library.
-
-    Given a file named "lib/cli/app/runner.rb" with:
-    """
-    require 'cli/app/cli_parser'
-
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @argv   = argv
-            $kernel = kernel
-            $stdin  = stdin
-            $stdout = stdout
-            $stderr = stderr
-          end
-
-          def execute!
-            Cli::App::CliParser.start @argv
-          end
-        end
-      end
-    end
-    """
-    And a file named "lib/cli/app/cli_parser.rb" with:
-    """
-    require 'thor'
-
-    module Cli
-      module App
-        class CliParser < Thor
-          def self.exit_on_failure?
-            true
-          end
-
-          desc 'do_it', 'Reverse input'
-          def do_it(*args)
-            $kernel.exit 5
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        When I run `reverse.rb do_it`
-        Then the exit status should be 5
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Using `:in_process` interactively is not supported
-
-    Reading from STDIN blocks ruby from going on. But writing to STDIN - e.g.
-    type some letters on keyboard - can only appear later, but this point is
-    never reached, because ruby is blocked.
-
-    Given the default aruba exit timeout is 5 seconds
-    And a file named "lib/cli/app/runner.rb" with:
-    """
-    module Cli
-      module App
-        class Runner
-          def initialize(argv, stdin, stdout, stderr, kernel)
-            @stdin  = stdin
-          end
-
-          def execute!
-            while res = @stdin.gets.to_s.chomp
-              break if res == 'quit'
-              puts res.reverse
-            end
-          end
-        end
-      end
-    end
-    """
-    And a file named "features/in_process.feature" with:
-    """
-    Feature: Run a command in process
-      @in-process
-      Scenario: Run command
-        Given the default aruba exit timeout is 2 seconds
-        When I run `reverse.rb do_it` interactively
-        When I type "hello"
-        Then the output should contain:
-        \"\"\"
-        hello
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the exit status should not be 0