aruba 0.14.9 → 0.14.10

data/features/matchers/collection/include_an_object.feature

@@ -1,72 +0,0 @@
-Feature: `include_an_object` Matcher
-
-  Use the `include_an_object` matcher to specify that a collection's objects include_an_object pass an expected matcher.
-  This works on include_an_object enumerable object.
-
-    ```ruby
-    expect([1, 4, 5]).to include_an_object( be_odd )
-    expect([1, 3, 'a']).to include_an_object( be_an(Integer) )
-    expect([1, 3, 11]).to include_an_object( be < 10 )
-    ```
-
-  The matcher also supports compound matchers:
-
-    ```ruby
-    expect([1, 'a', 11]).to include_an_object( be_odd.and be < 10 )
-    ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Array usage
-    Given a file named "spec/array_include_an_object_matcher_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      RSpec.describe [1, 4, 'a', 11] do
-        it { is_expected.to include_an_object( be_odd ) }
-        it { is_expected.to include_an_object( be_an(Integer) ) }
-        it { is_expected.to include_an_object( be < 10 ) }
-        it { is_expected.not_to include_an_object( eq 'b' ) }
-      end
-
-      RSpec.describe [14, 'a'] do
-        it { is_expected.to include_an_object( be_odd ) }
-        it { is_expected.to include_an_object( be_an(Symbol) ) }
-        it { is_expected.to include_an_object( be < 10 ) }
-        it { is_expected.not_to include_an_object( eq 'a' ) }
-      end
-      """
-    When I run `rspec`
-    Then the output should contain all of these lines:
-      | 8 examples, 4 failures                                      |
-      | expected [14, "a"] to include an object be odd              |
-      | expected [14, "a"] to include an object be a kind of Symbol |
-      | expected [14, "a"] to include an object be < 10             |
-      | expected [14, "a"] not to include an object eq "a"          |
-
-  Scenario: Compound Matcher Usage
-    Given a file named "spec/compound_include_an_object_matcher_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      RSpec.describe [1, 'anything', 'something'] do
-        it { is_expected.to include_an_object( be_a(String).and include("thing") ) }
-        it { is_expected.to include_an_object( be_a(String).and end_with("g") ) }
-        it { is_expected.to include_an_object( start_with("s").or include("y") ) }
-        it { is_expected.not_to include_an_object( start_with("b").or include("b") ) }
-      end
-
-      RSpec.describe ['anything', 'something'] do
-        it { is_expected.to include_an_object( be_a(Integer).and include("thing") ) }
-        it { is_expected.to include_an_object( be_a(Integer).and end_with("z") ) }
-        it { is_expected.to include_an_object( start_with("z").or include("1") ) }
-        it { is_expected.not_to include_an_object( start_with("a").or include("some") ) }
-      end
-      """
-    When I run `rspec`
-    Then the output should contain all of these lines:
-      | 8 examples, 4 failures                                                                           |
-      | expected ["anything", "something"] to include an object be a kind of Integer and include "thing" |
-      | expected ["anything", "something"] to include an object be a kind of Integer and end with "z"    |
-      | expected ["anything", "something"] to include an object start with "z" or include "1"            |

data/features/platforms/jruby.feature

@@ -1,14 +0,0 @@
-Feature: Support for JRuby
-
-  Improve startup time by disabling JIT and forcing client JVM mode.  This can
-  be accomplished by adding
-
-  ```ruby
-  require 'aruba/jruby'
-  ```
-
-  *Note* - no conflict resolution on the JAVA/JRuby environment options is
-  done; only merging. For more complex settings please manually set the
-  environment variables in the hook or externally.
-
-  Refer to http://blog.headius.com/2010/03/jruby-startup-time-tips.html for other tips on startup time.

data/features/step_definitions/aruba_dev_steps.rb

@@ -1,56 +0,0 @@
-When /^I do aruba (.*)$/ do |aruba_step|
-  @aruba_exception = StandardError.new
-
-  begin
-    step(aruba_step)
-  rescue => e
-    @aruba_exception = e
-  end
-end
-
-# Useful for debugging timing problems
-When /^sleep (\d+)$/ do |time|
-  sleep time.to_i
-end
-
-When /^I set env variable "(\w+)" to "([^"]*)"$/ do |var, value|
-  ENV[var] = value
-end
-
-Then /^aruba should fail with "([^"]*)"$/ do |error_message|
-  expect(@aruba_exception.message).to include sanitize_text(error_message)
-end
-
-Then /^the following step should fail with Spec::Expectations::ExpectationNotMetError:$/ do |multiline_step|
-  expect{steps multiline_step.to_s}.to raise_error(RSpec::Expectations::ExpectationNotMetError)
-end
-
-Given(/^the default executable$/) do
-  step 'an executable named "bin/cli" with:', <<-EOS
-#!/usr/bin/env ruby
-
-$LOAD_PATH << File.expand_path('../../lib', __FILE__)
-require 'cli/app'
-
-exit 0
-  EOS
-end
-
-Given(/^the default feature-test$/) do
-  step(
-    'a file named "features/default.feature" with:',
-    <<-EOS.strip_heredoc
-    Feature: Default Feature
-
-      This is the default feature
-
-      Scenario: Run command
-        Given I successfully run `cli`
-    EOS
-  )
-end
-
-Then(/^aruba should be installed on the local system$/) do
-  run_command('gem list aruba')
-  expect(last_command_started).to have_output(/aruba/)
-end

data/features/steps/command/shell.feature

@@ -1,155 +0,0 @@
-Feature: Running shell commands
-
-  You can run an *ad hoc* script with the following steps:
-  - `When I run the following script:`
-
-  Or you can run shell commands with:
-  - `I run the following (bash|zsh|...shell)? commands`
-  - `I run the following (bash|zsh|...shell)? commands (in|with) \`interpreter\``
-  - `I run the following (bash|zsh|...shell)? commands (in|with) \`/path/to/interpreter\``
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Creating and running scripts
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running ruby script
-        When I run the following script:
-        \"\"\"bash
-        #!/usr/bin/env ruby
-
-        puts "Hello"
-        \"\"\"
-        Then the output should contain "Hello"
-
-      Scenario: Running python script
-        When I run the following script:
-        \"\"\"bash
-        #!/usr/bin/env python
-
-        print("Hello")
-        \"\"\"
-        Then the output should contain exactly "Hello"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running shell commands
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running shell commands
-        When I run the following commands:
-        \"\"\"bash
-        echo "Hello shell"
-        \"\"\"
-        Then the output should contain exactly "Hello shell"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running bash commands
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running bash commands
-        When I run the following commands with `bash`:
-        \"\"\"bash
-        echo -n "Hello "
-        echo `echo bash` # subshell
-        \"\"\"
-        Then the output should contain exactly "Hello bash"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running zsh commands
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running zsh scripts
-      Scenario: Running zsh commands
-        When I run the following commands with `zsh`:
-        \"\"\"bash
-        echo "Hello \c"
-        echo $((2 + 2))
-        \"\"\"
-        Then the output should contain exactly "Hello 4"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running ruby commands
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running ruby commands
-        When I run the following commands with `ruby`:
-        \"\"\"ruby
-        puts "Hello, Aruba!"
-        \"\"\"
-        Then the output should contain "Hello, Aruba!"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running python commands
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running ruby commands
-        When I run the following commands with `python`:
-        \"\"\"ruby
-        print("Hello, Aruba!")
-        \"\"\"
-        Then the output should contain exactly "Hello, Aruba!"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running commands if full path to interpreter is given
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running full path zsh
-      Scenario: Running zsh commands #1
-        When I run the following commands with `/bin/zsh`:
-        \"\"\"bash
-        echo "Hello \c"
-        echo $((6 - 2))
-        \"\"\"
-        Then the output should contain exactly "Hello 4"
-
-      Scenario: Running zsh commands #1
-        When I run the following commands in `/bin/zsh`:
-        \"\"\"bash
-        echo "Hello \c"
-        echo $((6 - 2))
-        \"\"\"
-        Then the output should contain exactly "Hello 4"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running commands if only the name of interpreter is given
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running full path zsh
-      Scenario: Running zsh commands #1
-        When I run the following commands with `zsh`:
-        \"\"\"bash
-        echo "Hello \c"
-        echo $((6 - 2))
-        \"\"\"
-        Then the output should contain exactly "Hello 4"
-
-      Scenario: Running zsh commands #2
-        When I run the following commands in `zsh`:
-        \"\"\"bash
-        echo "Hello \c"
-        echo $((6 - 2))
-        \"\"\"
-        Then the output should contain exactly "Hello 4"
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/steps/filesystem/check_file_content.feature

@@ -1,61 +0,0 @@
-Feature: Check file content
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Check file contents with plain text
-    Given a file named "features/non-existence.feature" with:
-    """
-    Feature: Check
-      Scenario: Check
-        Given a file named "foo" with:
-        \"\"\"
-        hello world
-        \"\"\"
-        Then the file "foo" should contain "hello world"
-        And the file "foo" should not contain "HELLO WORLD"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Check file contents with regular expression
-    Given a file named "features/non-existence.feature" with:
-    """
-    Feature: Check
-      Background:
-        Given a file named "foo" with:
-        \"\"\"
-        hello world
-        \"\"\"
-
-      Scenario: Check #1
-        Then the file "foo" should match /hel.o world/
-        And the file "foo" should not match /HELLO WORLD/
-
-      Scenario: Check #2
-        Then the file "foo" should match %r<hel.o world>
-        And the file "foo" should not match %r<HELLO WORLD>
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario:  Check file contents with cucumber doc string
-    Given a file named "features/non-existence.feature" with:
-    """
-    Feature: Existence
-      Scenario: Existence
-        Given a file named "foo" with:
-        \"\"\"
-        foo
-        bar
-        baz
-        foobar
-        \"\"\"
-        Then the file "foo" should contain:
-        \"\"\"
-        bar
-        baz
-        \"\"\"
-        """
-    When I run `cucumber`
-    Then the features should all pass

data/features/steps/filesystem/fixtures.feature

@@ -1,64 +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 I use a fixture named "fixtures-app"
-        Then a file named "test.txt" should exist
-    """
-    And a directory named "fixtures"
-    And an empty file named "fixtures/fixtures-app/test.txt"
-    When I run `cucumber`
-    Then the features 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 I use a fixture named "fixtures-app"
-        Then a file named "test.txt" should exist
-    """
-    And a directory named "test/fixtures"
-    And an empty file named "test/fixtures/fixtures-app/test.txt"
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Use a fixture for your tests in specs/
-    Given a file named "features/fixtures.feature" with:
-    """
-    Feature: Fixture
-      Scenario: Fixture
-        Given I use a fixture named "fixtures-app"
-        Then a file named "test.txt" should exist
-    """
-    And a directory named "spec/fixtures"
-    And an empty file named "spec/fixtures/fixtures-app/test.txt"
-    When I run `cucumber`
-    Then the features 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 I use a fixture named "fixtures-app"
-        Then a file named "test.txt" should exist
-    """
-    And a directory named "features/fixtures"
-    And an empty file named "features/fixtures/fixtures-app/test.txt"
-    When I run `cucumber`
-    Then the features should all pass

data/features/steps/overview.feature

@@ -1,25 +0,0 @@
-Feature: Overview of steps
-
-  Given you're a system administrator
-  Who would like to use `aruba`
-  But didn't know which steps are available
-
-  Scenario: Use cucumber output formatter
-    Given I use a fixture named "cli-app"
-    And a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        Given a directory named "features"
-        And a file named "features/support/env.rb" with:
-        \"\"\"
-        require 'aruba/cucumber'
-        \"\"\"
-        When I run `cucumber --format stepdefs`
-        Then the output should contain:
-        \"\"\"
-        NOT MATCHED BY ANY STEPS
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass