shell_test 0.1.0 → 0.2.0

data/History.rdoc

@@ -1,3 +1,12 @@
+== 0.2.0 2011/08/03
+
+* Split out a StringMethods module [issue #7]
+* Renamed assert_output_equal to assert_str_equal and assert_alike to 
+  assert_str_match.
+* Added FileMethods#_prepare and made prepare outdent content [issue #9]
+* Added content, mode, and glob to FileMethods [issue #10]
+* Added FileMethods#prepare_dir
+
 == 0.1.0 2011/07/07
 
 Initial release.

data/README.rdoc

@@ -130,7 +130,7 @@ ShellTest is available as a gem[http://rubygems.org/gems/shell_test].
 
 To get started, checkout the code from GitHub[http://github.com/thinkerbot/shell_test] and run:
 
-  git clone https://thinkerbot@github.com/thinkerbot/shell_test.git
+  git clone git://github.com/thinkerbot/shell_test.git
   cd shell_test
   rake test
 

data/lib/shell_test/file_methods.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'shell_test/string_methods'
 
 module ShellTest
   module FileMethods
@@ -124,17 +125,25 @@ module ShellTest
       end
     end
 
+    include StringMethods
     extend ModuleMethods
 
+    # Calls cleanup to remove any files left over from previous test runs (for
+    # instance by running with a flag to keep outputs).
     def setup
       super
       cleanup
     end
 
+    # Generic cleanup method.  Returns users to the user_dir then calls
+    # cleanup unless keep_outputs? returns true.  If cleanup is called, any
+    # empty directories under method_dir are also removed.
+    #
+    # Be sure to call super if teardown is overridden in a test case.
     def teardown
       Dir.chdir(user_dir)
 
-      unless ENV["KEEP_OUTPUTS"] == "true"
+      unless keep_outputs?
         cleanup
 
         dir = method_dir
@@ -147,50 +156,74 @@ module ShellTest
       super
     end
 
+    # Returns true if KEEP_OUTPUTS is set to 'true' in ENV.
+    def keep_outputs?
+      ENV["KEEP_OUTPUTS"] == "true"
+    end
+
+    # Returns the absolute path to the current working directory.
     def user_dir
       @user_dir   ||= File.expand_path('.')
     end
 
+    # Returns the absolute path to a directory specific to the current test
+    # class, specifically the class.class_dir expanded relative to the
+    # user_dir.
     def class_dir
       @class_dir  ||= File.expand_path(self.class.class_dir, user_dir)
     end
 
+    # Returns the absolute path to a directory specific to the current test
+    # method, specifically method_name expanded relative to class_dir.
     def method_dir
       @method_dir ||= File.expand_path(method_name.to_s, class_dir)
     end
 
+    # Returns the method name of the current test.
+    #
+    # Really this method is an alias for __name__ which is present in
+    # MiniTest::Unit and reproduces the method_name in Test::Unit.
+    # ShellTest::Unit ensures this method is set up correctly in those
+    # frameworks.  If this module is used in other frameworks, then
+    # method_name must be implemented separately.
     def method_name
       __name__
     end
 
-    def cleanup_methods
-      self.class.cleanup_methods
-    end
-
-    def cleanup
-      if cleanup_paths = cleanup_methods[method_name.to_sym]
-        cleanup_paths.each {|relative_path| remove(relative_path) }
-      end
-    end
-
+    # Expands relative_path relative to method_dir and returns the resulting
+    # absolute path.  Raises an error if the resulting path is not relative to
+    # method_dir.
     def path(relative_path)
-      path = File.expand_path(relative_path, method_dir)
+      full_path = File.expand_path(relative_path, method_dir)
 
-      unless path.index(method_dir) == 0
+      unless full_path.index(method_dir) == 0
         raise "does not make a path relative to method_dir: #{relative_path.inspect}"
       end
 
-      path
+      full_path
     end
 
-    def prepare(relative_path, content=nil, &block)
+    # Globs the pattern under method_dir.
+    def glob(pattern)
+      Dir.glob path(pattern)
+    end
+
+    # Creates a directory under method_dir.
+    def prepare_dir(relative_path)
+      target_dir = path(relative_path)
+      FileUtils.mkdir_p(target_dir)
+      target_dir
+    end
+
+    # Same as prepare but does not outdent content.
+    def _prepare(relative_path, content=nil, &block)
       target = path(relative_path)
 
       if File.exists?(target)
         FileUtils.rm(target)
       else
         target_dir = File.dirname(target)
-        FileUtils.mkdir_p(target_dir) unless File.exists?(target_dir)
+        FileUtils.mkdir_p(target_dir)
       end
 
       FileUtils.touch(target)
@@ -200,9 +233,54 @@ module ShellTest
       target
     end
 
+    # Creates a file under method_dir with the specified content, which may be
+    # provided as a string or with a block (the block recieves an open File).
+    # If no content is given, then an empty file is created.
+    #
+    # Content provided as a string is outdented (see StringMethods#outdent),
+    # so this syntax is possible:
+    #
+    #   path = prepare 'file', %{
+    #     line one
+    #     line two
+    #   }
+    #   File.read(path)  # => "line one\nline two\n"
+    #
+    # Returns the absolute path to the new file.
+    def prepare(relative_path, content=nil, &block)
+      content = outdent(content) if content
+      _prepare(relative_path, content, &block)
+    end
+
+    # Returns the content of the file under method_dir, if it exists.
+    def content(relative_path, length=nil, offset=nil)
+      full_path = path(relative_path)
+      File.exists?(full_path) ? File.read(full_path, length, offset) : nil
+    end
+
+    # Returns the formatted string mode (ex '100640') of the file under
+    # method_dir, if it exists.
+    def mode(relative_path)
+      full_path = path(relative_path)
+      File.exists?(full_path) ? sprintf("%o", File.stat(full_path).mode) : nil
+    end
+
+    # Removes a file or directory under method_dir, if it exists.
     def remove(relative_path)
       full_path = path(relative_path)
       FileUtils.rm_r(full_path) if File.exists?(full_path)
     end
+
+    # Shortcut to access the class.cleanup_methods.
+    def cleanup_methods
+      self.class.cleanup_methods
+    end
+
+    # Recursively removes paths specified for cleanup in cleanup_methods.
+    def cleanup
+      if cleanup_paths = cleanup_methods[method_name.to_sym]
+        cleanup_paths.each {|relative_path| remove(relative_path) }
+      end
+    end
   end
 end

data/lib/shell_test/shell_methods.rb

@@ -1,8 +1,11 @@
 require 'shell_test/regexp_escape'
 require 'shell_test/command_parser'
+require 'shell_test/string_methods'
 
 module ShellTest
   module ShellMethods
+    include StringMethods
+
     def setup
       super
       @notify_method_name = true
@@ -86,7 +89,7 @@ module ShellTest
       parse_script(script, options).each do |cmd, output, status|
         result = sh(cmd)
 
-        _assert_output_equal(output, result, cmd) if output
+        _assert_str_equal(output, result, cmd) if output
         assert_equal(status, $?.exitstatus, cmd)  if status
       end
     end
@@ -99,78 +102,9 @@ module ShellTest
       parse_script(script, options).each do |cmd, output, status|
         result = sh(cmd)
 
-        _assert_alike(output, result, cmd)       if output
+        _assert_str_match(output, result, cmd)       if output
         assert_equal(status, $?.exitstatus, cmd) if status
       end
     end
-
-    # Asserts whether or not the a and b strings are equal, with a more
-    # readable output than assert_equal for large strings (especially large
-    # strings with significant whitespace).
-    def assert_output_equal(a, b, msg=nil)
-      _assert_output_equal outdent(a), b, msg
-    end
-
-    def _assert_output_equal(a, b, msg=nil)
-      if a == b
-        assert true
-      else
-        flunk %Q{
-#{msg}
-==================== expected output ====================
-#{whitespace_escape(a)}
-======================== but was ========================
-#{whitespace_escape(b)}
-=========================================================
-}
-      end
-    end
-
-    # Asserts whether or not b is like a (which should be a Regexp), and
-    # provides a more readable output in the case of a failure as compared
-    # with assert_match.
-    #
-    # If a is a string it is turned into a RegexpEscape.
-    def assert_alike(a, b, msg=nil)
-      a = outdent(a) if a.kind_of?(String)
-      _assert_alike a, b, msg
-    end
-
-    def _assert_alike(a, b, msg=nil)
-      if a.kind_of?(String)
-        a = RegexpEscape.new(a)
-      end
-
-      if b =~ a
-        assert true
-      else
-        flunk %Q{
-#{msg}
-================= expected output like ==================
-#{whitespace_escape(a)}
-======================== but was ========================
-#{whitespace_escape(b)}
-=========================================================
-}
-      end
-    end
-
-    # helper for stripping indentation off a string
-    def outdent(str)
-      str =~ /\A(?:\s*?\n)( *)(.*)\z/m ? $2.gsub!(/^ {0,#{$1.length}}/, '') : str
-    end
-
-    # helper for formatting escaping whitespace into readable text
-    def whitespace_escape(str)
-      str.to_s.gsub(/\s/) do |match|
-        case match
-        when "\n" then "\\n\n"
-        when "\t" then "\\t"
-        when "\r" then "\\r"
-        when "\f" then "\\f"
-        else match
-        end
-      end
-    end
   end
 end

data/lib/shell_test/string_methods.rb

@@ -0,0 +1,72 @@
+module ShellTest
+  module StringMethods
+    # Asserts whether or not the a and b strings are equal, with a more
+    # readable output than assert_equal for large strings (especially large
+    # strings with significant whitespace).
+    def assert_str_equal(a, b, msg=nil)
+      _assert_str_equal outdent(a), b, msg
+    end
+
+    def _assert_str_equal(a, b, msg=nil)
+      if a == b
+        assert true
+      else
+        flunk %Q{
+#{msg}
+==================== expected output ====================
+#{whitespace_escape(a)}
+======================== but was ========================
+#{whitespace_escape(b)}
+=========================================================
+}
+      end
+    end
+
+    # Asserts whether or not b is like a (which should be a Regexp), and
+    # provides a more readable output in the case of a failure as compared
+    # with assert_match.
+    #
+    # If a is a string it is turned into a RegexpEscape.
+    def assert_str_match(a, b, msg=nil)
+      a = outdent(a) if a.kind_of?(String)
+      _assert_str_match a, b, msg
+    end
+
+    def _assert_str_match(a, b, msg=nil)
+      if a.kind_of?(String)
+        a = RegexpEscape.new(a)
+      end
+
+      if b =~ a
+        assert true
+      else
+        flunk %Q{
+#{msg}
+================= expected output like ==================
+#{whitespace_escape(a)}
+======================== but was ========================
+#{whitespace_escape(b)}
+=========================================================
+}
+      end
+    end
+
+    # helper for stripping indentation off a string
+    def outdent(str)
+      str =~ /\A(?:\s*?\n)( *)(.*)\z/m ? $2.gsub!(/^ {0,#{$1.length}}/, '') : str
+    end
+
+    # helper for formatting escaping whitespace into readable text
+    def whitespace_escape(str)
+      str.to_s.gsub(/\s/) do |match|
+        case match
+        when "\n" then "\\n\n"
+        when "\t" then "\\t"
+        when "\r" then "\\r"
+        when "\f" then "\\f"
+        else match
+        end
+      end
+    end
+  end
+end

data/lib/shell_test/unit/shim.rb

@@ -34,6 +34,8 @@ class Test::Unit::TestResult
     @skips ||= []
   end
 
+  alias shell_test_original_add_error add_error
+
   # Partition errors from a SkipException from other errors and records as
   # them as skips (the error is extended to display as a skip).
   def add_error(error)

data/lib/shell_test/version.rb

@@ -1,3 +1,3 @@
 module ShellTest
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shell_test
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-07 00:00:00 -06:00
+date: 2011-08-03 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -36,6 +36,7 @@ files:
 - lib/shell_test/file_methods.rb
 - lib/shell_test/regexp_escape.rb
 - lib/shell_test/shell_methods.rb
+- lib/shell_test/string_methods.rb
 - lib/shell_test/unit.rb
 - lib/shell_test/unit/shim.rb
 - lib/shell_test/version.rb