command_test 0.0.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+== 0.0.1 2010-08-25
+
+ * Hi.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 George Ogata
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,109 @@
+# Command Test
+
+Test that your app runs or does not run commands.
+
+## Why?
+
+Ruby has a bucket of ways to run commands:
+
+ * Kernel#system
+ * Kernel#`
+ * Kernel.open
+ * IO.popen
+ * Open3.popen3
+
+Mocking becomes impractical because you seldom care *how* a command is
+run, just that it *is* run (or not run). Methods that run the command
+through the shell are also tricky to mock correctly, as extra shell
+syntax can easily throw off the test.
+
+## How
+
+### RSpec
+
+    lambda do
+      ...
+    end.should run_command('convert', 'bad.gif', 'good.png')
+
+### Test::Unit
+
+    assert_runs_command 'convert', 'bad.gif', 'good.png' do
+      ...
+    end
+
+    assert_does_not_run_command 'convert', 'bad.gif', 'good.png' do
+      ...
+    end
+
+### Other frameworks
+
+Not really using them myself, but I'll bet they're easy to add. Patch
+me and be famous!
+
+## Tricks
+
+### Regexps
+
+You can match arguments against regexps:
+
+    lambda do
+      ...
+    end.should run_command('convert', /.gif\z/, /.png\z/)
+
+### Wildcards
+
+An integer, `n`, matches any `n` arguments:
+
+    lambda do
+      system 'diff', 'old.txt', 'new.txt')
+    end.should run_command('diff', 2)
+
+An range matches any number of arguments in that range:
+
+    lambda do
+      system 'diff', '-w', 'one.txt', 'two.txt', 'three.txt'
+    end.should run_command('diff', '-w', 2..3)
+
+`:*` matches any number of arguments:
+
+    lamdba do
+      system 'hostname'
+    end.should run_command('convert', :*, 'target.png')
+
+`:+` matches at least one argument:
+
+    lamdba do
+      system 'hostname'
+    end.should run_command('gem', 'install', :+)
+
+Any combination of wildcards can be used together.
+
+### Recording
+
+You can record the commands run during a block:
+
+    commands = CommandTest.record do
+      system 'convert', 'bad.gif', 'good.png'
+      system 'identify', 'good.png'
+    end
+    commands # [['convert', 'bad.gif', 'good.png'], ['identify', 'good.png']]
+
+And then match them yourself:
+
+    CommandTest.match?(commands.first, ['convert', :*])
+
+You can use this to check that commands were run in a certain order, a
+certain number of times, in a pretty pattern, ... the possibilities
+are endless!
+
+## Contributing
+
+ * Bug reports: http://github.com/oggy/command_test/issues
+ * Source: http://github.com/oggy/command_test
+ * Patches: Fork on Github, send pull request.
+   * Ensure patch includes tests.
+   * Leave the version alone, or bump it in a separate commit.
+
+## Copyright
+
+Copyright (c) 2010 George Ogata. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'ritual'
+
+spec_task :spec do |t|
+  t.pattern = 'spec/unit/**/*_spec.rb'
+  t.libs << 'lib' << 'spec'
+end
+
+cuke_task :cucumber

data/features/rspec_integration.feature

@@ -0,0 +1,60 @@
+Feature: RSpec Integration
+
+  As a developer who uses RSpec
+  I want to use Command Test
+  So I can write beautiful tests
+
+  Scenario: Using run_command
+  Given I have a file "spec.rb" containing:
+    """
+    require 'command_test'
+
+    describe "#run_command" do
+      describe "when using should" do
+        it "should pass if the command is run" do
+          lambda do
+            system 'sh', '-c', ''
+          end.should run_command('sh', '-c', '')
+        end
+
+        it "should fail if the command is not run" do
+          lambda do
+            system 'sh', '-c', 'true'
+          end.should run_command('sh', '-c', '')
+        end
+      end
+
+      describe "when using should_not" do
+        it "should pass if the command is not run" do
+          lambda do
+            system 'sh', '-c', 'true'
+          end.should_not run_command('sh', '-c', '')
+        end
+
+        it "should fail if the command is run" do
+          lambda do
+            system 'sh', '-c', ''
+          end.should_not run_command('sh', '-c', '')
+        end
+      end
+    end
+    """
+  When I run "spec" on "spec.rb"
+  Then the output should contain ".F.F"
+  And the output should contain:
+    """
+    This command should have been run, but was not:
+      "sh" "-c" ""
+    These were the commands run:
+      "sh" "-c" "true"
+    """
+  And the output should contain:
+    """
+    This command should not have been run, but was:
+      "sh" "-c" ""
+    These were the commands run:
+      "sh" "-c" ""
+    """
+  And the output should contain in this order
+    | This command should have been run, but was not |
+    | This command should not have been run, but was |

data/features/step_definitions/test_steps.rb

@@ -0,0 +1,24 @@
+Given /^I have a file "(.*?)" containing:$/ do |file_name, content|
+  path = "#{TMP}/#{file_name}"
+  open(path, 'w'){|f| f.print content}
+end
+
+When /^I run "(.*?)" on "(.*?)"$/ do |command, file_name|
+  Dir.chdir ROOT do
+    @output = `#{command} #{TMP}/#{file_name} 2>&1`
+  end
+end
+
+Then /^the output should contain "(.*?)"$/ do |fragment|
+  @output.should include(fragment)
+end
+
+Then /^the output should contain:$/ do |fragment|
+  @output.should include(fragment)
+end
+
+Then /^the output should contain in this order$/ do |table|
+  table.raw.inject(0) do |index, row|
+    index && @output.index(row.first, index)
+  end.should_not be_nil
+end

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'fileutils'
+require 'spec/expectations'
+
+ROOT = File.dirname(File.dirname(File.dirname(__FILE__)))
+TMP = "#{ROOT}/features/tmp"
+
+Before do
+  FileUtils.mkdir_p(TMP)
+end
+
+After do
+  FileUtils.rm_rf(TMP)
+end

data/features/test_unit_integration.feature

@@ -0,0 +1,58 @@
+Feature: Test Unit Integration
+
+  As a developer who uses Test::Unit
+  I want to use Command Test
+  So I can write beautiful tests
+
+  Scenario: Using run_command
+  Given I have a file "test.rb" containing:
+    """
+    require 'test/unit'
+    require 'command_test'
+
+    class CommandTests < Test::Unit::TestCase
+      def test_assert_runs_command_passes_if_the_command_is_run
+        assert_runs_command 'sh', '-c', '' do
+          system 'sh', '-c', ''
+        end
+      end
+
+      def test_assert_runs_command_fails_if_the_command_is_not_run
+        assert_runs_command 'sh', '-c', '' do
+          system 'sh', '-c', 'true'
+        end
+      end
+
+      def test_assert_does_not_run_command_passes_if_the_command_is_not_run
+        assert_does_not_run_command 'sh', '-c', '' do
+          system 'sh', '-c', 'true'
+        end
+      end
+
+      def test_assert_does_not_run_command_fails_if_the_command_is_run
+        assert_does_not_run_command 'sh', '-c', '' do
+          system 'sh', '-c', ''
+        end
+      end
+    end
+    """
+  When I run "ruby -Ilib" on "test.rb"
+  # Test::Unit sorts tests alphabetically.
+  Then the output should contain "F.F."
+  And the output should contain:
+    """
+    This command should have been run, but was not:
+      "sh" "-c" ""
+    These were the commands run:
+      "sh" "-c" "true"
+    """
+  And the output should contain:
+    """
+    This command should not have been run, but was:
+      "sh" "-c" ""
+    These were the commands run:
+      "sh" "-c" ""
+    """
+  And the output should contain in this order
+    | This command should not have been run, but was |
+    | This command should have been run, but was not |

data/lib/command_test.rb

@@ -0,0 +1,70 @@
+require 'shellwords'
+require 'command_test/core_extensions'
+require 'command_test/parser'
+require 'command_test/matcher'
+require 'command_test/adapters'
+require 'command_test/tests'
+
+module CommandTest
+  class << self
+    #
+    # Return the list of commands run during the given block.
+    #
+    # Each command is an Array of "words" (command and arguments).
+    #
+    def record
+      commands = []
+      recorders << lambda{|c| commands << c}
+      begin
+        yield
+      ensure
+        recorders.pop
+      end
+      commands
+    end
+
+    #
+    # Return true if the given +actual+ command matches the +expected+
+    # spec.
+    #
+    # The elements of +expected+ may be one of these:
+    #
+    #  * A String in +expected+ matches the corresponding element in
+    #    +actual+.
+    #  * A Regexp must match the corresponding element in +actual+.
+    #  * An Integer, n, matches the next n elements of +actual+.
+    #  * A Range, a...b, can match the next i elements of +actual+,
+    #    for a <= i < b.
+    #  * :+ can match 1 or more elements in +actual+.
+    #  * :* can match any number of elements (including zero) in
+    #    +actual+.
+    #
+    def match?(expected, actual)
+      matcher.match?(expected, actual)
+    end
+
+    def record_command(command, *args) # :nodoc:
+      words = Shellwords.shellwords(command).concat(args)
+      recorders.each{|r| r.call(words)}
+    end
+
+    def record_interpreted_command(command) # :nodoc:
+      words = parser.parse(command)
+      recorders.each{|r| r.call(words)}
+    end
+
+    private
+
+    def recorders
+      Thread.current[:command_recorders] ||= []
+    end
+
+    def parser
+      @parser ||= Parser.new
+    end
+
+    def matcher
+      @matcher ||= Matcher.new
+    end
+  end
+end

data/lib/command_test/adapters.rb

@@ -0,0 +1,2 @@
+require 'command_test/adapters/rspec' if Object.const_defined?(:Spec)
+require 'command_test/adapters/test_unit' if Object.const_defined?(:Test) && Test.const_defined?(:Unit)

data/lib/command_test/adapters/rspec.rb

@@ -0,0 +1,41 @@
+module CommandTest
+  module RSpec
+    module Matchers
+      #
+      # Matches if the proc runs the given command.
+      #
+      #     lambda do
+      #       ...
+      #     end.should run_command('convert', 'evil.gif', 'good.png')
+      #
+      # Commands are matched according to CommandTest.match? .
+      #
+      def run_command(*command)
+        RunCommand.new(command)
+      end
+    end
+
+    class RunCommand
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(proc)
+        @test = Tests::RunsCommand.new(@expected, &proc)
+        @test.matches?
+      end
+
+      def failure_message_for_should
+        @test.positive_failure_message
+      end
+
+      def failure_message_for_should_not
+        @test.negative_failure_message
+      end
+    end
+
+    ::Spec::Runner.configure do |config|
+      config.send :include, Matchers
+    end
+  end
+end

data/lib/command_test/adapters/test_unit.rb

@@ -0,0 +1,43 @@
+module CommandTest
+  module Adapters
+    module TestUnit
+      module Assertions
+        #
+        # Passes if the block runs the given command.
+        #
+        #     assert_runs_command 'convert', 'evil.gif', 'good.png' do
+        #       ...
+        #     end
+        #
+        # Commands are matched according to CommandTest.match? .
+        #
+        def assert_runs_command(*expected, &block)
+          result = Tests::RunsCommand.new(expected, &block)
+          matches = result.matches?
+          assert_block(matches ? nil : result.positive_failure_message) do
+            matches
+          end
+        end
+
+        #
+        # Passes if the block does not run the given command.
+        #
+        #     assert_does_not_run_command 'convert', 'evil.gif', 'good.png' do
+        #       ...
+        #     end
+        #
+        # Commands are matched according to CommandTest.match? .
+        #
+        def assert_does_not_run_command(*expected, &block)
+          result = Tests::RunsCommand.new(expected, &block)
+          matches = result.matches?
+          assert_block(matches ? result.negative_failure_message : nil) do
+            !matches
+          end
+        end
+      end
+
+      ::Test::Unit::TestCase.send :include, Assertions
+    end
+  end
+end