aruba 1.0.0.pre.alpha.4 → 1.0.0.pre.alpha.5

data/lib/aruba/api/environment.rb

@@ -23,7 +23,8 @@ module Aruba
         aruba.environment[name] = value
         new_environment = aruba.environment.to_h
 
-        aruba.event_bus.notify Events::AddedEnvironmentVariable.new(old: old_environment, new: new_environment, changed: { name: name, value: value })
+        environment_change = { old: old_environment, new: new_environment, changed: { name: name, value: value } }
+        aruba.event_bus.notify Events::AddedEnvironmentVariable.new(environment_change)
 
         self
       end
@@ -45,7 +46,8 @@ module Aruba
         aruba.environment.append name, value
         new_environment = aruba.environment.to_h
 
-        aruba.event_bus.notify Events::ChangedEnvironmentVariable.new(old: old_environment, new: new_environment, changed: { name: name, value: value })
+        environment_change = { old: old_environment, new: new_environment, changed: { name: name, value: value } }
+        aruba.event_bus.notify Events::ChangedEnvironmentVariable.new(environment_change)
 
         self
       end
@@ -67,7 +69,8 @@ module Aruba
         aruba.environment.prepend name, value
         new_environment = aruba.environment.to_h
 
-        aruba.event_bus.notify Events::ChangedEnvironmentVariable.new(old: old_environment, new: new_environment, changed: { name: name, value: value })
+        environment_change = { old: old_environment, new: new_environment, changed: { name: name, value: value } }
+        aruba.event_bus.notify Events::ChangedEnvironmentVariable.new(environment_change)
 
         self
       end
@@ -85,7 +88,8 @@ module Aruba
         aruba.environment.delete name
         new_environment = aruba.environment.to_h
 
-        aruba.event_bus.notify Events::DeletedEnvironmentVariable.new(old: old_environment, new: new_environment, changed: { name: name, value: '' })
+        environment_change = { old: old_environment, new: new_environment, changed: { name: name, value: '' } }
+        aruba.event_bus.notify Events::ChangedEnvironmentVariable.new(environment_change)
 
         self
       end

data/lib/aruba/api/filesystem.rb

@@ -104,7 +104,9 @@ module Aruba
       #   The content of directory
       def list(name)
         fail ArgumentError, %(Path "#{name}" does not exist.) unless exist? name
-        fail ArgumentError, %(Only directories are supported. Path "#{name}" is not a directory.) unless directory? name
+        unless directory? name
+          fail ArgumentError, %(Only directories are supported. Path "#{name}" is not a directory.)
+        end
 
         existing_files            = Dir.glob(expand_path(File.join(name, '**', '*')))
         current_working_directory = ArubaPath.new(expand_path('.'))
@@ -181,8 +183,13 @@ module Aruba
           raise ArgumentError, %(The following source "#{s}" does not exist.) unless exist? s
         end
 
-        raise ArgumentError, "Using a fixture as destination (#{destination}) is not supported" if destination.start_with? aruba.config.fixtures_path_prefix
-        raise ArgumentError, 'Multiples sources can only be copied to a directory' if source.count > 1 && exist?(destination) && !directory?(destination)
+        if destination.start_with? aruba.config.fixtures_path_prefix
+          raise ArgumentError, "Using a fixture as destination (#{destination}) is not supported"
+        end
+
+        if source.count > 1 && exist?(destination) && !directory?(destination)
+          raise ArgumentError, 'Multiples sources can only be copied to a directory'
+        end
 
         source_paths     = source.map { |f| expand_path(f) }
         destination_path = expand_path(destination)
@@ -219,16 +226,22 @@ module Aruba
         source = args
 
         source.each do |s|
-          raise ArgumentError, "Using a fixture as source (#{source}) is not supported" if s.start_with? aruba.config.fixtures_path_prefix
+          if s.start_with? aruba.config.fixtures_path_prefix
+            raise ArgumentError, "Using a fixture as source (#{source}) is not supported"
+          end
         end
 
-        raise ArgumentError, "Using a fixture as destination (#{destination}) is not supported" if destination.start_with? aruba.config.fixtures_path_prefix
+        if destination.start_with? aruba.config.fixtures_path_prefix
+          raise ArgumentError, "Using a fixture as destination (#{destination}) is not supported"
+        end
 
         source.each do |s|
           raise ArgumentError, %(The following source "#{s}" does not exist.) unless exist? s
         end
 
-        raise ArgumentError, 'Multiple sources can only be copied to a directory' if source.count > 1 && exist?(destination) && !directory?(destination)
+        if source.count > 1 && exist?(destination) && !directory?(destination)
+          raise ArgumentError, 'Multiple sources can only be copied to a directory'
+        end
 
         source_paths     = source.map { |f| expand_path(f) }
         destination_path = expand_path(destination)

data/lib/aruba/colorizer.rb

@@ -1,108 +1,19 @@
+# Aruba
 module Aruba
-  # The ANSIColor module can be used for namespacing and mixed into your own
-  # classes.
-  module AnsiColor
-    # :stopdoc:
-    ATTRIBUTES = [
-      [:clear,   0],
-      [:reset,   0], # synonym for :clear
-      [:bold,   1],
-      [:dark,   2],
-      [:italic, 3], # not widely implemented
-      [:underline, 4],
-      [:underscore, 4], # synonym for :underline
-      [:blink, 5],
-      [:rapid_blink, 6], # not widely implemented
-      [:negative, 7], # no reverse because of String#reverse
-      [:concealed, 8],
-      [:strikethrough, 9], # not widely implemented
-      [:black, 30],
-      [:red, 31],
-      [:green, 32],
-      [:yellow, 33],
-      [:blue, 34],
-      [:magenta, 35],
-      [:cyan, 36],
-      [:white, 37],
-      [:on_black, 40],
-      [:on_red, 41],
-      [:on_green, 42],
-      [:on_yellow, 43],
-      [:on_blue, 44],
-      [:on_magenta, 45],
-      [:on_cyan, 46],
-      [:on_white, 47]
-    ].freeze
-
-    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
-    # :startdoc:
-
-    # Returns true, if the coloring function of this module
-    # is switched on, false otherwise.
-    def self.coloring?
-      @coloring
-    end
-
-    # Turns the coloring on or off globally, so you can easily do
-    # this for example:
-    #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
-    def self.coloring=(val)
-      @coloring = val
-    end
-    self.coloring = true
-
-    ATTRIBUTES.each do |c, v|
-      define_method(c) do |string|
-        result = ''
-        result << "\e[#{v}m" if Aruba::AnsiColor.coloring?
-        if block_given?
-          result << yield
-        elsif string
-          result << string
-        elsif respond_to?(:to_str)
-          result << to_str
-        else
-          return result # only switch on
-        end
-        result << "\e[0m" if Aruba::AnsiColor.coloring?
-        result
-      end
-    end
-
-    # Regular expression that is used to scan for ANSI-sequences while
-    # uncoloring strings.
-    COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
-
-    def self.included(klass)
-      return unless klass == String
+  # Simple colorizer class. Only supports the color cyan
+  class Colorizer
+    class << self
+      attr_accessor :coloring
 
-      ATTRIBUTES.delete(:clear)
-      ATTRIBUTE_NAMES.delete(:clear)
+      alias coloring? coloring
     end
 
-    # Returns an uncolored version of the string, that is all
-    # ANSI-sequences are stripped from the string.
-    def uncolored(string = nil) # :yields:
-      if block_given?
-        yield.gsub(COLORED_REGEXP, '')
-      elsif string
-        string.gsub(COLORED_REGEXP, '')
-      elsif respond_to?(:to_str)
-        to_str.gsub(COLORED_REGEXP, '')
+    def cyan(string)
+      if self.class.coloring?
+        "\e[36m#{string}\e[0m"
       else
-        ''
+        string
       end
     end
-
-    # Returns an array of all Aruba::Platforms::AnsiColor attributes as symbols.
-    def attributes
-      ATTRIBUTE_NAMES
-    end
-  end
-end
-
-module Aruba
-  class Colorizer
-    include Aruba::AnsiColor
   end
 end

data/lib/aruba/config/jruby.rb

@@ -2,16 +2,26 @@ require 'rbconfig'
 
 # ideas taken from: http://blog.headius.com/2010/03/jruby-startup-time-tips.html
 Aruba.configure do |config|
-  config.before :command do
+  config.before :command do |command|
     next unless RUBY_PLATFORM == 'java'
 
+    env = command.environment
+
+    jruby_opts = env['JRUBY_OPTS'] || ''
+
     # disable JIT since these processes are so short lived
-    ENV['JRUBY_OPTS'] = "-X-C #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '') .include? '-X-C'
+    jruby_opts = "-X-C #{jruby_opts}" unless jruby_opts.include? '-X-C'
 
     # Faster startup for jruby
-    ENV['JRUBY_OPTS'] = "--dev #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '').include? '--dev'
+    jruby_opts = "--dev #{jruby_opts}" unless jruby_opts.include? '--dev'
+
+    env['JRUBY_OPTS'] = jruby_opts
+
+    if RbConfig::CONFIG['host_os'] =~ /solaris|sunos/i
+      java_opts = env['JAVA_OPTS'] || ''
 
-    # force jRuby to use client JVM for faster startup times
-    ENV['JAVA_OPTS'] = "-d32 #{ENV['JAVA_OPTS']}" if RbConfig::CONFIG['host_os'] =~ /solaris|sunos/i && !(ENV['JAVA_OPTS'] || '').include?('-d32')
+      # force jRuby to use client JVM for faster startup times
+      env['JAVA_OPTS'] = "-d32 #{java_opts}" unless java_opts.include?('-d32')
+    end
   end
 end

data/lib/aruba/config_wrapper.rb

@@ -30,7 +30,9 @@ module Aruba
     # If one method ends with "=", e.g. ":option1=", then notify the event
     # queue, that the user changes the value of "option1"
     def method_missing(name, *args, &block)
-      event_bus.notify Events::ChangedConfiguration.new(changed: { name: name.to_s.gsub(/=$/, ''), value: args.first }) if name.to_s.end_with? '='
+      if name.to_s.end_with? '='
+        event_bus.notify Events::ChangedConfiguration.new(changed: { name: name.to_s.gsub(/=$/, ''), value: args.first })
+      end
 
       config.send(name, *args, &block)
     end

data/lib/aruba/configuration.rb

@@ -19,7 +19,9 @@ module Aruba
   class Configuration < BasicConfiguration
     option_reader :root_directory, contract: { None => String }, default: Dir.getwd
 
-    option_accessor :working_directory, contract: { Aruba::Contracts::RelativePath => Aruba::Contracts::RelativePath }, default: 'tmp/aruba'
+    option_accessor :working_directory,
+                    contract: { Aruba::Contracts::RelativePath => Aruba::Contracts::RelativePath },
+                    default: 'tmp/aruba'
 
     option_reader :fixtures_path_prefix, contract: { None => String }, default: '%'
 
@@ -27,26 +29,36 @@ module Aruba
     option_accessor :stop_signal, contract: { Maybe[String] => Maybe[String] }, default: nil
     option_accessor :io_wait_timeout, contract: { Num => Num }, default: 0.1
     option_accessor :startup_wait_time, contract: { Num => Num }, default: 0
-    option_accessor :fixtures_directories, contract: { Array => ArrayOf[String] }, default: %w(features/fixtures spec/fixtures test/fixtures fixtures)
+    option_accessor :fixtures_directories,
+                    contract: { Array => ArrayOf[String] },
+                    default: %w(features/fixtures spec/fixtures test/fixtures fixtures)
+
     option_accessor :command_runtime_environment, contract: { Hash => Hash }, default: {}
-    # rubocop:disable Metrics/LineLength
-    option_accessor(:command_search_paths, contract: { ArrayOf[String] => ArrayOf[String] }) { |config| [File.join(config.root_directory.value, 'bin'), File.join(config.root_directory.value, 'exe')] }
-    # rubocop:enable Metrics/LineLength
+    option_accessor :command_search_paths,
+                    contract: { ArrayOf[String] => ArrayOf[String] } do |config|
+                      [File.join(config.root_directory.value, 'bin'), File.join(config.root_directory.value, 'exe')]
+                    end
     option_accessor :remove_ansi_escape_sequences, contract: { Bool => Bool }, default: true
-    # rubocop:disable Metrics/LineLength
-    option_accessor :command_launcher, contract: { Aruba::Contracts::Enum[:in_process, :spawn, :debug] => Aruba::Contracts::Enum[:in_process, :spawn, :debug] }, default: :spawn
+    option_accessor :command_launcher,
+                    contract: { Aruba::Contracts::Enum[:in_process, :spawn, :debug] => Aruba::Contracts::Enum[:in_process, :spawn, :debug] },
+                    default: :spawn
     option_accessor :main_class, contract: { Class => Maybe[Class] }, default: nil
 
-    option_accessor :home_directory, contract: { Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath] => Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath] } do |config|
-      File.join(config.root_directory.value, config.working_directory.value)
-    end
+    option_accessor :home_directory,
+                    contract: { Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath] => Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath] } do |config|
+                      File.join(config.root_directory.value, config.working_directory.value)
+                    end
 
-    option_accessor :log_level, contract: { Aruba::Contracts::Enum[:fatal, :warn, :debug, :info, :error, :unknown, :silent] => Aruba::Contracts::Enum[:fatal, :warn, :debug, :info, :error, :unknown, :silent] }, default: :info
+    option_accessor :log_level,
+                    contract: { Aruba::Contracts::Enum[:fatal, :warn, :debug, :info, :error, :unknown, :silent] => Aruba::Contracts::Enum[:fatal, :warn, :debug, :info, :error, :unknown, :silent] },
+                    default: :info
 
     # TODO: deprecate this value and replace with "filesystem allocation unit"
     # equal to 4096 by default. "filesystem allocation unit" would represent
     # the actual MINIMUM space taken in bytes by a 1-byte file
-    option_accessor :physical_block_size, contract: { Aruba::Contracts::IsPowerOfTwo => Aruba::Contracts::IsPowerOfTwo }, default: 512
+    option_accessor :physical_block_size,
+                    contract: { Aruba::Contracts::IsPowerOfTwo => Aruba::Contracts::IsPowerOfTwo },
+                    default: 512
     option_accessor :console_history_file, contract: { String => String }, default: '~/.aruba_history'
 
     option_accessor :activate_announcer_on_command_failure, contract: { ArrayOf[Symbol] => ArrayOf[Symbol] }, default: []

data/lib/aruba/cucumber.rb

@@ -1,8 +1,6 @@
 require 'aruba/version'
 
 require 'aruba/api'
-World(Aruba::Api)
-
 require 'aruba/cucumber/hooks'
 require 'aruba/cucumber/command'
 require 'aruba/cucumber/environment'

data/lib/aruba/cucumber/command.rb

@@ -23,8 +23,7 @@ When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) do
 end
 
 When(/^I run `([^`]*)` interactively$/) do |cmd|
-  cmd = sanitize_text(cmd)
-  @interactive = run_command(cmd)
+  run_command(sanitize_text(cmd))
 end
 
 # Merge interactive and background after refactoring with event queue
@@ -119,7 +118,25 @@ Then(/^the output should be (\d+) bytes long$/) do |size|
   expect(last_command_started.output).to have_output_size size.to_i
 end
 
-Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain( exactly)? "([^"]*)"$/) do |channel, cmd, negated, exactly, expected|
+## the stderr should contain "hello"
+Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)? "([^"]*)"$/) do |channel, negated, exactly, expected|
+  combined_output = send("all_#{channel}")
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          end
+
+  if negated
+    expect(combined_output).not_to send(output_string_matcher, expected)
+  else
+    expect(combined_output).to send(output_string_matcher, expected)
+  end
+end
+
+## the stderr from "echo -n 'Hello'" should contain "hello"
+Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should( not)? contain( exactly)? "([^"]*)"$/) do |channel, cmd, negated, exactly, expected|
   matcher = case channel.to_sym
             when :output
               :have_output
@@ -129,11 +146,7 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
               :have_output_on_stdout
             end
 
-  commands = if cmd
-               [aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))]
-             else
-               all_commands
-             end
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
   output_string_matcher = if exactly
                             :an_output_string_being_eq
@@ -142,17 +155,62 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
                           end
 
   if negated
-    expect(commands).not_to include_an_object send(matcher, send(output_string_matcher, expected))
+    expect(command).not_to send(matcher, send(output_string_matcher, expected))
   else
-    expect(commands).to include_an_object send(matcher, send(output_string_matcher, expected))
+    expect(command).to send(matcher, send(output_string_matcher, expected))
   end
 end
 
-## the stderr should contain "hello"
-## the stderr from "echo -n 'Hello'" should contain "hello"
+## the stderr should not contain exactly:
+Then(/^(?:the )?(output|stderr|stdout) should not contain( exactly)?:$/) do |channel, exactly, expected|
+  combined_output = send("all_#{channel}")
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          end
+
+  expect(combined_output).not_to send(output_string_matcher, expected)
+end
+
 ## the stderr should contain exactly:
+Then(/^(?:the )?(output|stderr|stdout) should contain( exactly)?:$/) do |channel, exactly, expected|
+  combined_output = send("all_#{channel}")
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          end
+
+  expect(combined_output).to send(output_string_matcher, expected)
+end
+
+## the stderr from "echo -n 'Hello'" should not contain exactly:
+Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactly)?:$/) do |channel, cmd, exactly, expected|
+  matcher = case channel.to_sym
+            when :output
+              :have_output
+            when :stderr
+              :have_output_on_stderr
+            when :stdout
+              :have_output_on_stdout
+            end
+
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          end
+
+  expect(command).not_to send(matcher, send(output_string_matcher, expected))
+end
+
 ## the stderr from "echo -n 'Hello'" should contain exactly:
-Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain( exactly)?:$/) do |channel, cmd, negated, exactly, expected|
+Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should contain( exactly)?:$/) do |channel, cmd, exactly, expected|
   matcher = case channel.to_sym
             when :output
               :have_output
@@ -160,15 +218,9 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
               :have_output_on_stderr
             when :stdout
               :have_output_on_stdout
-            else
-              fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stderr" or "stdout" are allowed.)
             end
 
-  commands = if cmd
-               [aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))]
-             else
-               all_commands
-             end
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
   output_string_matcher = if exactly
                             :an_output_string_being_eq
@@ -176,11 +228,7 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
                             :an_output_string_including
                           end
 
-  if negated
-    expect(commands).not_to include_an_object send(matcher, send(output_string_matcher, expected))
-  else
-    expect(commands).to include_an_object send(matcher, send(output_string_matcher, expected))
-  end
+  expect(command).to send(matcher, send(output_string_matcher, expected))
 end
 
 # "the output should match" allows regex in the partial_output, if
@@ -223,7 +271,7 @@ Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
   end
 end
 
-Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -232,14 +280,22 @@ Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expe
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+end
+
+Then(/^it should (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_including(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_including(expected)
 end
 
-Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with:$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -248,14 +304,22 @@ Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+end
+
+Then(/^it should (pass|fail) with:$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_including(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_including(expected)
 end
 
-Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with exactly:$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -264,14 +328,22 @@ Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, exp
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_eq(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_eq(expected)
+end
+
+Then(/^it should (pass|fail) with exactly:$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_being_eq(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_being_eq(expected)
 end
 
-Then(/^it should( not)? (pass|fail) (?:with regexp?|matching):$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -280,11 +352,19 @@ Then(/^it should( not)? (pass|fail) (?:with regexp?|matching):$/) do |negated, p
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_matching(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_matching(expected)
+end
+
+Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_matching(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_matching(expected)
 end
 
 Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channel|
@@ -295,8 +375,6 @@ Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channe
               :have_output_on_stderr
             when :stdout
               :have_output_on_stdout
-            else
-              fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
             end
 
   expect(all_commands).to include_an_object send(matcher, be_nil.or(be_empty))
@@ -311,10 +389,10 @@ Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:
       :have_output_on_stderr
     when :stdout
       :have_output_on_stdout
-    else
-      fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
     end
 
+    # TODO: This isn't actually using the above. It's hardcoded to use have_output only
+
     if negated
       expect(all_commands).not_to include_an_object have_output an_output_string_including(expected)
     else