aruba 0.7.4 → 0.8.0.pre

data/features/matchers/path/be_an_existing_path.feature

@@ -0,0 +1,97 @@
+Feature: Check if path exists
+
+  If you need to check if a given path exists, you can use the
+  `be_an_existing_path`-matcher. It doesn't care if the path is a directory or
+  a path.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if path exists', :type => :aruba do
+    let(:path) { 'file.txt' }
+    before(:each) { touch(path) }
+
+    it { expect(path).to be_an_existing_path }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect single existing path
+    Given a file named "spec/existing_path_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path exists', :type => :aruba do
+      let(:path) { 'file.txt' }
+      before(:each) { touch(path) }
+      it { expect(path).to be_an_existing_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect single existing directory
+    Given a file named "spec/existing_path_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path exists', :type => :aruba do
+      let(:path) { 'dir.d' }
+      before(:each) { create_directory(path) }
+      it { expect(path).to be_an_existing_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect single non-existing path
+    Given a file named "spec/existing_path_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path exists', :type => :aruba do
+      let(:path) { 'file.txt' }
+      it { expect(path).not_to be_an_existing_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple existing paths
+    Given a file named "spec/existing_path_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path exists', :type => :aruba do
+      let(:paths) { %w(path1.txt path2.txt) }
+
+      before :each do
+        paths.each { |f| touch(f) }
+      end
+
+      it { expect(paths).to all be_an_existing_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect a least one existing path
+    Given a file named "spec/existing_path_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path exists', :type => :aruba do
+      let(:paths) { %w(path1.txt path2.txt) }
+
+      before :each do
+        touch(paths.first)
+      end
+
+      it { expect(paths).to include an_existing_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+

data/features/matchers/path/have_permissions.feature

@@ -0,0 +1,118 @@
+Feature: Check if path has permissions in filesystem
+
+  If you need to check if a given path has some permissions in filesystem, you
+  can use the `have_permissions`-matcher. It fails if the file or directory
+  does not exist. You need to pass it the permissions either as `Octal`
+  (`0700`) or `String` (`'0700'`).
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if path has permissions', :type => :aruba do
+    context 'when is file' do
+      let(:file) { 'file.txt' }
+      let(:permissions) { 0700 }
+
+      before(:each) { touch(file) }
+      before(:each) { chmod(permissions, file }
+
+      it { expect(file).to have_permissions permissions }
+    end
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect file with permissions
+    Given a file named "spec/path_with_permissions_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path has permissions', :type => :aruba do
+      let(:file) { 'file.txt' }
+      let(:permissions) { 0700 }
+
+      before(:each) { touch(file) }
+      before(:each) { chmod(permissions, file) }
+
+      it { expect(file).to have_permissions permissions }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect directory with permissions
+    Given a file named "spec/path_with_permissions_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path has permissions', :type => :aruba do
+      let(:directory) { 'directory.d' }
+      let(:permissions) { 0700 }
+
+      before(:each) { create_directory(directory) }
+      before(:each) { chmod(permissions, directory) }
+
+      it { expect(directory).to have_permissions permissions }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple files with given permissions
+    Given a file named "spec/path_with_permissions_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path has permissions', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+      let(:permissions) { 0700 }
+
+      before :each do
+        files.each do |f|
+          touch(f)
+          chmod(permissions, f)
+        end
+      end
+
+      it { expect(files).to all have_permissions permissions }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect a least one file with permissions
+    Given a file named "spec/path_with_permissions_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path has permissions', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+      let(:permissions) { 0700 }
+
+      before :each do
+        touch(files.first)
+        chmod(permissions, files.first)
+      end
+
+      it { expect(files).to include a_path_having_permissions permissions }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Fails if path does not exist
+    Given a file named "spec/path_with_permissions_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if path has permissions', :type => :aruba do
+      let(:path) { 'file.txt' }
+      let(:permissions) { 0777 }
+
+      it { expect(path).to have_permissions permissions }
+    end
+    """
+    When I run `rspec`
+    Then the specs should not all pass

data/features/matchers/timeouts.feature

@@ -0,0 +1,48 @@
+Feature: Check if a timeout occured during command execution
+
+  If you want to check if a command takes to long to finish it's work
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Check if command runs to long
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    sleep 1
+    """
+    And a file named "spec/timeout_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { aruba.config.exit_timeout = 0 }
+
+      before(:each) { run('cli') }
+
+      it { expect(last_command).to run_too_long }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Check if command finishes in time
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "spec/timeout_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Short running command', :type => :aruba do
+      before(:each) { aruba.config.exit_timeout = 5 }
+
+      before(:each) { run('cli') }
+
+      it { expect(last_command).to have_finished_in_time }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/step_definitions/aruba_dev_steps.rb

@@ -1,7 +1,9 @@
 When /^I do aruba (.*)$/ do |aruba_step|
+  @aruba_exception = StandardError.new
+
   begin
     step(aruba_step)
-  rescue Exception => e
+  rescue => e
     @aruba_exception = e
   end
 end
@@ -26,3 +28,69 @@ end
 Then /^the output should be (\d+) bytes long$/ do |length|
   expect(all_output.length).to eq length.to_i
 end
+
+Then /^the feature(?:s)? should( not)?(?: all)? pass$/ do |negated|
+  if negated
+    step 'the output should contain " failed)"'
+    step 'the exit status should be 1'
+  else
+    step 'the output should not contain " failed)"'
+    step 'the exit status should be 0'
+  end
+end
+
+Then /^the feature(?:s)? should( not)?(?: all)? pass with:$/ do |negated, string|
+  if negated
+    step 'the output should contain " failed)"'
+    step 'the exit status should be 1'
+  else
+    step 'the output should not contain " failed)"'
+    step 'the exit status should be 0'
+  end
+
+  step 'the output should contain:', string if string
+end
+
+Then /^the spec(?:s)? should( not)?(?: all)? pass$/ do |negated|
+  if negated
+    step 'the output should not contain "0 failures"'
+    step 'the exit status should be 1'
+  else
+    step 'the output should contain "0 failures"'
+    step 'the exit status should be 0'
+  end
+end
+
+Then /^the spec(?:s)? should( not)?(?: all)? pass with:$/ do |negated, string|
+  if negated
+    step 'the output should contain " failed)"'
+    step 'the exit status should be 1'
+  else
+    step 'the output should not contain " failed)"'
+    step 'the exit status should be 0'
+  end
+
+  step 'the output should contain:', string if string
+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
+
+Before do
+  aruba.config.exit_timeout = 15
+end
+
+Given(/^(?:an|the) executable(?: named)? "([^"]*)" with:$/) do |file_name, file_content|
+  step %(a file named "#{file_name}" with mode "0755" and with:), file_content
+end

data/features/steps/commands/exit_statuses.feature

@@ -0,0 +1,136 @@
+Feature: Check exit status of commands
+
+  Use the `the exit status should be \d`-step to check the exit status of the
+  last command which was executed.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Test for exit status of 0
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Exit status
+      Scenario: Run command
+        When I run `cli`
+        Then the exit status should be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Test for exit status 1
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I run `cli`
+        Then the exit status should be 1
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Test for non-zero exit status
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I run `cli`
+        Then the exit status should not be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Successfully run something
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I successfully run `cli`
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Fail to run something successfully
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I successfully run `cli`
+    """
+    When I run `cucumber`
+    Then the features should not all pass
+
+  Scenario: Overwrite the default exit timeout via step
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    sleep 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        Given the default aruba timeout is 2 seconds
+        When I successfully run `cli`
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Successfully run something longer then the default time
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    sleep 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        Given the default aruba timeout is 0 seconds
+        When I successfully run `cli` for up to 2 seconds
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Unsuccessfully run something that takes too long
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    sleep 2
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        Given the default aruba timeout is 0 seconds
+        When I successfully run `cli` for up to 1 seconds
+    """
+    When I run `cucumber`
+    Then the features should not all pass with:
+    """
+    expected "cli" to have finished in time
+    """