command_test 0.0.1

data/lib/command_test/core_extensions.rb

@@ -0,0 +1,76 @@
+require 'open3'
+
+module CommandTest
+  module CoreExtensions
+    def self.define_included_hook(mod, *methods) # :nodoc:
+      name_map = methods.last.is_a?(Hash) ? methods.pop : {}
+      methods.each{|m| name_map[m] = m}
+      aliasings = name_map.map do |name, massaged|
+        <<-EOS
+          unless method_defined?(:#{massaged}_without_command_test)
+            alias #{massaged}_without_command_test #{name}
+            alias #{name} #{massaged}_with_command_test
+          end
+        EOS
+      end.join("\n")
+
+      mod.module_eval <<-EOS
+        def self.included(base)
+          base.module_eval do
+            #{aliasings}
+          end
+        end
+
+        def self.extended(base)
+          included((class << base; self; end))
+        end
+      EOS
+    end
+
+    module Kernel
+      def system_with_command_test(*args, &block)
+        CommandTest.record_command(*args)
+        system_without_command_test(*args, &block)
+      end
+
+      def backtick_with_command_test(*args, &block)
+        (command = args.first) and
+          CommandTest.record_interpreted_command(command)
+        backtick_without_command_test(*args, &block)
+      end
+
+      def open_with_command_test(*args, &block)
+        (command = args.first) && command =~ /\A\|/ and
+          CommandTest.record_interpreted_command($')
+        open_without_command_test(*args, &block)
+      end
+    end
+
+    define_included_hook(Kernel, :system, :open, :'`' => :backtick)
+    ::Kernel.send :include, Kernel
+    ::Kernel.send :extend, Kernel
+
+    module IO
+      def popen_with_command_test(*args, &block)
+        command = args.first and
+          CommandTest.record_interpreted_command(command)
+        popen_without_command_test(*args, &block)
+      end
+    end
+
+    define_included_hook(IO, :popen)
+    ::IO.send :extend, IO
+
+    module Open3
+      def popen3_with_command_test(*args, &block)
+        command = args.first and
+          CommandTest.record_command(*args)
+        popen3_without_command_test(*args, &block)
+      end
+    end
+
+    define_included_hook(Open3, :popen3)
+    ::Open3.send :include, Open3
+    ::Open3.send :extend, Open3
+  end
+end

data/lib/command_test/matcher.rb

@@ -0,0 +1,43 @@
+module CommandTest
+  class Matcher
+    def match?(expected, actual, e=0, a=0)
+      while e < expected.length
+        case (specifier = expected[e])
+        when nil
+          return false  # passed end of actual
+        when String, Regexp
+          if specifier === actual[a]
+            a += 1
+          else
+            return false
+          end
+        when Integer
+          specifier >= 0 or
+            raise ArgumentError, "negative integer matcher: #{specifier}"
+          a += specifier
+        when Range, :*, :+
+          case specifier
+          when :*
+            specifier = 0...(actual.length - a)
+          when :+
+            specifier = 1...(actual.length - a)
+          end
+          specifier.end >= specifier.begin or
+            raise ArgumentError, "descending range matcher: #{specifier}"
+          specifier.begin >= 0 or
+            raise ArgumentError, "negative range bounds: #{specifier}"
+          specifier.each do |n|
+            if match?(expected, actual, e + 1, a + n)
+              return true
+            end
+          end
+          return false
+        else
+          raise ArgumentError, "invalid matcher: #{specifier}"
+        end
+        e += 1
+      end
+      a == actual.length
+    end
+  end
+end

data/lib/command_test/parser.rb

@@ -0,0 +1,62 @@
+module CommandTest
+  class Parser
+    #
+    # Parse the given command line into words.
+    #
+    # Supports backslash escaping, single quoting, double quoting, and
+    # redirects, a la bash.
+    #
+    def parse(line)
+      # Implementation heavily inspired by Ruby's Shellwords.
+      line = line.lstrip
+      words = []
+      while (word = extract_word_skipping_redirects(line))
+        words << word
+      end
+      words
+    end
+
+    def extract_word_skipping_redirects(line)
+      while true
+        if line.sub!(/\A\d*>>?(&\d+)?\s*/, '')
+          if $1.nil?
+            extract_word(line) or
+              raise ArgumentError, "missing redirection target: #{line}"
+          end
+          next
+        elsif line.sub!(/\A\d*<\s*/, '')
+          extract_word(line) or
+            raise ArgumentError, "missing redirection source: #{line}"
+          next
+        end
+
+        return extract_word(line)
+      end
+    end
+
+    def extract_word(line)
+      return nil if line.empty?
+      word = ''
+      loop do
+        if line.sub!(/\A"(([^"\\]|\\.)*)"/, '')
+          chunk = $1.gsub(/\\(.)/, '\1')
+        elsif line =~ /\A"/
+          raise ArgumentError, "unmatched double quote: #{line}"
+        elsif line.sub!(/\A'([^']*)'/, '')
+          chunk = $1
+        elsif line =~ /\A'/
+          raise ArgumentError, "unmatched single quote: #{line}"
+        elsif line.sub!(/\A\\(.)?/, '')
+          chunk = $1 || ''
+        elsif line.sub!(/\A([^\s\\'"<>]+)/, '')
+          chunk = $1
+        else
+          line.lstrip!
+          break
+        end
+        word << chunk
+      end
+      word
+    end
+  end
+end

data/lib/command_test/tests.rb

@@ -0,0 +1,39 @@
+module CommandTest
+  module Tests
+    class RunsCommand
+      def initialize(expected, &proc)
+        @expected = expected
+        @proc = proc
+      end
+
+      def matches?
+        @actual = CommandTest.record(&@proc)
+        @actual.any? do |actual|
+          CommandTest.match?(@expected, actual)
+        end
+      end
+
+      def positive_failure_message
+        expected_string = display_commands([@expected])
+        actual_string = display_commands(@actual)
+        "This command should have been run, but was not:\n#{expected_string}\n" <<
+          "These were the commands run:\n#{actual_string}\n"
+      end
+
+      def negative_failure_message
+        expected_string = display_commands([@expected])
+        actual_string = display_commands(@actual)
+        "This command should not have been run, but was:\n#{expected_string}\n" <<
+          "These were the commands run:\n#{actual_string}\n"
+      end
+
+      private
+
+      def display_commands(commands)
+        commands.map do |command|
+          command.map{|arg| arg.inspect}.join(' ')
+        end.join("\n").gsub(/^/, '  ')
+      end
+    end
+  end
+end

data/lib/command_test/version.rb

@@ -0,0 +1,11 @@
+module CommandTest
+  VERSION = [0, 0, 1]
+
+  class << VERSION
+    include Comparable
+
+    def to_s
+      join('.')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'command_test'
+
+ROOT = File.dirname(File.dirname(__FILE__))
+
+require 'support/temporary_directory'

data/spec/support/temporary_directory.rb

@@ -0,0 +1,48 @@
+require 'fileutils'
+
+module TemporaryDirectory
+  def create_temporary_directory
+    remove_temporary_directory
+    FileUtils.mkdir_p temporary_directory
+  end
+
+  def remove_temporary_directory
+    FileUtils.rm_rf temporary_directory
+  end
+
+  #
+  # Return the given path relative to the temporary directory.
+  #
+  def temporary_path(path=nil)
+    if path
+      File.join(temporary_directory, path)
+    else
+      temporary_directory
+    end
+  end
+
+  #
+  # Write to the given path in the temporary directory.
+  #
+  # Return the full path to the file.
+  #
+  def write_temporary_file(path, content)
+    path = temporary_path(path)
+    open(path, 'w') do |file|
+      file.print content
+    end
+    path
+  end
+
+  private  # ---------------------------------------------------------
+
+  def temporary_directory
+    "#{ROOT}/spec/tmp"
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.before { create_temporary_directory }
+  config.after(:all) { remove_temporary_directory }
+  config.include TemporaryDirectory
+end

data/spec/unit/command_test/core_extensions_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe CommandTest::CoreExtensions do
+  it "should not affect system" do
+    system 'true'
+    $?.success?.should be_true
+    system 'false'
+    $?.success?.should be_false
+  end
+
+  it "should not affect Kernel.system" do
+    Kernel.system 'true'
+    $?.success?.should be_true
+    Kernel.system 'false'
+    $?.success?.should be_false
+  end
+
+  it "should not affect `" do
+    `true`
+    $?.success?.should be_true
+    `false`
+    $?.success?.should be_false
+  end
+
+  it "should not affect Kernel.`" do
+    Kernel.send('`', 'true')
+    $?.success?.should be_true
+    Kernel.send('`', 'false')
+    $?.success?.should be_false
+  end
+
+  it "should not affect open with a pipe" do
+    open('|true'){}
+    $?.success?.should be_true
+    open('|false'){}
+    $?.success?.should be_false
+  end
+
+  it "should not affect open without a pipe" do
+    path = write_temporary_file('file', 'content')
+    content = nil
+    open(path){|f| content = f.read}
+    content.should == 'content'
+  end
+
+  it "should not affect Kernel.open with a pipe" do
+    Kernel.open('|true'){}
+    $?.success?.should be_true
+    Kernel.open('|false'){}
+    $?.success?.should be_false
+  end
+
+  it "should not affect Kernel.open without a pipe" do
+    path = write_temporary_file('file', 'content')
+    content = nil
+    Kernel.open(path){|f| content = f.read}
+    content.should == 'content'
+  end
+
+  it "should not affect IO.popen" do
+    IO.popen('true'){}
+    $?.success?.should be_true
+    IO.popen('false'){}
+    $?.success?.should be_false
+  end
+
+  it "should not affect popen3" do
+    out = nil
+    Class.new{include Open3}.new.instance_eval do
+      popen3('echo a'){|stdin, stdout, stderr| out = stdout.read}
+    end
+    out.should == "a\n"
+  end
+
+  it "should not affect Open3.popen3" do
+    out = nil
+    Class.new{include Open3}.new.instance_eval do
+      Open3.popen3('echo a'){|stdin, stdout, stderr| out = stdout.read}
+    end
+    out.should == "a\n"
+  end
+end

data/spec/unit/command_test/matcher_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe CommandTest::Matcher do
+  before do
+    @matcher = CommandTest::Matcher.new
+  end
+
+  describe "#match?" do
+    describe "when only Strings are in expected" do
+      it "should be true if expected is equal to actual" do
+        @matcher.match?(['a', 'b'], ['a', 'b']).should be_true
+      end
+
+      it "should be false if any element of expected is not the same as actual" do
+        @matcher.match?(['a', 'b'], ['a', 'x']).should be_false
+      end
+    end
+
+    describe "when a Regexp is present" do
+      it "should match the corresponding element in actual" do
+        @matcher.match?(['a', /\A.\z/], ['a', 'b']).should be_true
+      end
+
+      it "should return false if the Regexp does not match" do
+        @matcher.match?(['a', /\A..\z/], ['a', 'x']).should be_false
+      end
+    end
+
+    describe "when an Integer is present" do
+      it "should match n elements at that position in actual" do
+        @matcher.match?(['a', 2, 'z'], ['a', 'b', 'c', 'z']).should be_true
+      end
+
+      it "should support matching 0 elements" do
+        @matcher.match?(['a', 0, 'z'], ['a', 'z']).should be_true
+      end
+
+      it "should return false if there are not enough elements in actual" do
+        @matcher.match?(['a', 2, 'z'], ['a', 'z']).should be_false
+      end
+
+      it "should return false if there are too many elements in actual" do
+        @matcher.match?(['a', 2, 'z'], ['a', 'b', 'c', 'd', 'z']).should be_false
+      end
+
+      it "should raise ArgumentError if the integer is negative" do
+        lambda{@matcher.match?(['a', -1, 'b'], ['a', 'b'])}.should raise_error(ArgumentError, /negative/)
+      end
+    end
+
+    describe "when a Range, a..b, is present" do
+      it "should match a elements in the range at that position in actual" do
+        @matcher.match?(['a', 2..4, 'z'], ['a', 'b', 'c', 'z']).should be_true
+      end
+
+      it "should match b elements in the range at that position in actual" do
+        @matcher.match?(['a', 2..4, 'z'], ['a', 'b', 'c', 'd', 'e', 'z']).should be_true
+      end
+
+      it "should i elements, for in in a..b" do
+        @matcher.match?(['a', 2..4, 'z'], ['a', 'b', 'c', 'd', 'z']).should be_true
+      end
+
+      it "should return false if there are not enough elements in actual" do
+        @matcher.match?(['a', 2...4, 'z'], ['a', 'b', 'z']).should be_false
+      end
+
+      it "should return false if there are too many elements in actual" do
+        @matcher.match?(['a', 2...4, 'z'], ['a', 'b', 'c', 'd', 'e', 'f', 'z']).should be_false
+      end
+
+      it "should honor open-endedness of the range" do
+        @matcher.match?(['a', 2...4, 'z'], ['a', 'b', 'c', 'd', 'e', 'z']).should be_false
+      end
+
+      it "should raise ArgumentError if a is negative" do
+        lambda{@matcher.match?(['a', -2..4, 'b'], ['a', 'b'])}.should raise_error(ArgumentError, /negative/)
+      end
+
+      it "should raise ArgumentError if b is negative" do
+        lambda{@matcher.match?(['a', -4..-2, 'b'], ['a', 'b'])}.should raise_error(ArgumentError, /negative/)
+      end
+
+      it "should raise ArgumentError if the range is descending" do
+        lambda{@matcher.match?(['a', 4..2, 'b'], ['a', 'b'])}.should raise_error(ArgumentError, /descending/)
+      end
+
+      it "should return false if the range is empty" do
+        @matcher.match?(['a', 2...2, 'z'], ['a', 'z']).should be_false
+      end
+
+      it "should backtrack to find a match" do
+        @matcher.match?(['a', 1..3, 'm', 1..3, 'z'], ['a', 'b', 'c', 'd', 'm', 'n', 'o', 'p', 'z']).should be_true
+      end
+    end
+
+    describe "when :* is present" do
+      it "should match zero elements at that position in actual" do
+        @matcher.match?(['a', :*, 'z'], ['a', 'z']).should be_true
+      end
+
+      it "should match one element at that position in actual" do
+        @matcher.match?(['a', :*, 'z'], ['a', 'b', 'z']).should be_true
+      end
+
+      it "should match two elements at that position in actual" do
+        @matcher.match?(['a', :*, 'z'], ['a', 'b', 'c', 'z']).should be_true
+      end
+
+      it "should backtrack to find a match" do
+        @matcher.match?(['a', :*, 'm', :*, 'z'], ['a', 'b', 'c', 'd', 'm', 'n', 'o', 'p', 'z']).should be_true
+      end
+    end
+
+    describe "when :+ is present" do
+      it "should not match zero elements at that position in actual" do
+        @matcher.match?(['a', :+, 'z'], ['a', 'z']).should be_false
+      end
+
+      it "should match one element at that position in actual" do
+        @matcher.match?(['a', :+, 'z'], ['a', 'b', 'z']).should be_true
+      end
+
+      it "should match two elements at that position in actual" do
+        @matcher.match?(['a', :+, 'z'], ['a', 'b', 'c', 'z']).should be_true
+      end
+
+      it "should backtrack to find a match" do
+        @matcher.match?(['a', :+, 'm', :+, 'z'], ['a', 'b', 'c', 'd', 'e', 'm', 'n', 'o', 'p', 'q', 'z']).should be_true
+      end
+    end
+
+    describe "when junk is present" do
+      it "should raise an argument error" do
+        lambda{@matcher.match?(['a', Object.new, 'b'], ['a', 'b'])}.should raise_error(ArgumentError, /invalid/)
+      end
+    end
+  end
+end