quarry 0.3.0 → 0.4.0

data/work/sandbox/build/test.rb

@@ -0,0 +1,521 @@
+require 'quarry/build'
+
+require 'facets/hash/rekey'
+require 'facets/string/tabs'
+require 'facets/progressbar'
+
+
+module Quarry
+
+  #
+
+  class Test < Build
+
+    attr_accessor :live
+    attr_accessor :libpath
+    attr_accessor :tests
+    attr_accessor :requires
+
+    def defaults
+      @libpath = "lib"
+      @tests   = 'test/**/test_*.rb'
+    end
+
+    def loadpath
+      @loadpath ||= ["lib"]
+    end
+
+    def test_files
+      Dir.glob(tests)
+    end
+
+    # Basic unit test run.
+
+    def unit_test(options)
+      options = TestOptions.new(configuration['test'], options)
+
+      live    = options.live
+      libpath = options.libpath
+
+      unless live
+        libpath.each do |lp|
+          $LOAD_PATH.unshift(File.expand_path(lp))
+        end
+      end
+
+      if find = argv[0]
+        unless file?(find)
+          find = File.join(find, '**', 'test_*.rb')
+        end
+      else
+        find = 'test/**/test_*.rb'
+      end
+
+      Dir.glob(find).each do |file|
+        next if dir?(file)
+        load file
+      end
+    end
+
+    #alias_method :call, :run
+
+    # Run unit-tests. Each test is run in a separate interpretor
+    # to prevent script clash. This makes for a more robust test
+    # facility and prevents potential conflicts between test scripts.
+    #
+    #   tests     Test files (eg. test/tc_**/*.rb) [test/**/*]
+    #   libs      Directories to include in load path.
+    #             ('./lib' is always included)
+    #   live      Deactive use of local libs and test against install.
+    #   reqs      List of files to require prior to running tests.
+    #   extract   Extract embedded tests first? [false]
+    #
+    # To isolate tests this tool marshals test results across a
+    # stdout->stdin shell pipe. This prevents interfence of one
+    # script's tests on another. But consequently it is not always
+    # possible to send debug info to stdout in the tests themselves
+    # (eg. #p and #puts).
+
+    def solo #(config)
+      require 'test/unit/ui/testrunnermediator' #require 'test/unit'
+      ::Test::Unit.run = true # Don't autorun tests!
+
+      #tests   = config['files'] || 'test/unit/**/test_*.rb'
+      #libs    = libpath #config['libpath']
+      reqs    = requires #config['require']
+      #live    = config['live']
+      #extract = config['extract']
+
+      tests = [ tests() ].flatten
+      libs  = [ libpath() ].flatten
+
+      #files = [ @files ].flatten
+      #extract_tests if extract
+
+      results  = TestResults.new #(style)
+
+      # get test files
+      test_libs  = libs.join(':')
+      test_files = Dir.multiglob( *tests )
+      if test_files.empty?
+        puts "Tests        [NONE]"
+        return
+      end
+
+      # run tests
+
+      if trace?
+        pbar = nil
+        size = test_files.collect{|f| f.size}.max + 5
+        dots = '.' * size
+      else
+        pbar = Console::ProgressBar.new( 'Testing', test_files.size )
+        pbar.inc
+      end
+
+      test_files.each do |test_file|
+        pbar.inc if pbar
+        if ! File.file?(test_file)
+          next #r = nil
+        else
+          unless pbar
+            print test_file + dots[test_file.size..-1]
+            $stdout.flush
+          end
+          r = fork_test( test_file, :libs=>libs, :reqs=>reqs, :live=>live )
+          unless pbar
+            puts r.passed? ? "[PASS]" : "[FAIL]"
+          end
+        end
+        results << r
+      end
+
+      pbar.finish if pbar
+
+      # display results
+      puts results
+
+      fails, errrs = results.failure_count, results.error_count
+      #CHECKLIST << :test if fails > 0
+      #CHECKLIST << :test if errrs > 0
+      return (fails + errrs > 0)
+    end
+
+    # run cross comparison tests
+    #
+    # This tool runs unit tests in pairs to make
+    # sure there is cross library compatibility.
+    #
+    # Run unit-tests. Each test is run in a separate interpretor
+    # to prevent script clash. This makes for a more robust test
+    # facility and prevents potential conflicts between test scripts.
+    #
+    #   tests     Test files (eg. test/tc_**/*.rb) [test/**/*]
+    #   libs      Directories to include in load path.
+    #             ('./lib' is always included)
+    #   live      Deactive use of local libs and test against install.
+    #   reqs      List of files to require prior to running tests.
+    #   extract   Extract embedded tests first? [false]
+    #
+    # To isolate tests this tool marshals test results across a
+    # stdout->stdin shell pipe. This prevents interfence of one
+    # script's tests on another. But consequently it is not always
+    # possible to send debug info to stdout in the tests themselves
+    # (eg. #p and #puts).
+
+    def cross #(config)
+      require 'test/unit/ui/testrunnermediator' #require 'test/unit'
+      ::Test::Unit.run = true # Don't autorun tests!
+
+      #tests   = config['tests'] || 'test/**/test_*.rb'
+      reqs    = requires #config['require']
+      #libs    = config['libpath']
+      #live    = config['live']
+      #extract = info['extract']
+
+      tests = [ tests() ].flatten
+      libs  = [ libpath() ].flatten
+
+      results  = TestResults.new #(style)
+
+      # get test files
+      test_libs  = libs.join(':')
+      test_files = Dir.multiglob( *tests )
+      if test_files.empty?
+        puts "Tests        [NONE]"
+        return
+      end
+
+      # run tests
+
+      if trace?
+        pbar = nil
+        size = test_files.collect{|f| f.size}.max * 2 + 5
+        dots = '.' * size
+      else
+        pbar = Console::ProgressBar.new('Testing', test_files.size ** 2)
+        pbar.inc
+      end
+
+      test_files.each do |test_file|
+        next unless File.file?(test_file)
+
+        test_files.each do |test_file_x|
+          next unless File.file?(test_file_x)
+          next if test_file == test_file_x
+
+          pbar.inc if pbar
+          unless pbar
+            out = test_file +' : ' + test_file_x
+            print out + dots[out.size..-1]
+            $stdout.flush
+          end
+
+          r = fork_crosstest( test_file, test_file_x, :libs=>libs, :reqs=>reqs, :live=>live )
+
+          unless pbar
+            puts r.passed? ? "[PASS]" : "[FAIL]"
+          end
+
+          results << r
+        end
+      end
+
+      pbar.finish if pbar
+
+      # display results
+      puts results
+
+      fails, errrs = results.failure_count, results.error_count
+      #CHECKLIST << :test if fails > 0
+      #CHECKLIST << :test if errrs > 0
+      return (fails + errrs > 0)
+    end
+
+    private
+
+    # Run a test in a separate process.
+    #
+    # Currently send program output to null device.
+    # Could send to a logger in future version.
+    #
+    # Key parameters are libs, reqs, live.
+
+    def fork_crosstest( file, xfile, keys )
+      keys = keys.rekey(:to_s)
+
+      libs = keys['lib'] || []
+      reqs = keys['req'] || []
+      live = keys['live']
+
+      src = ''
+
+      unless live
+        l = File.join( Dir.pwd, 'lib' )
+        if File.directory?( l )
+          src << %{$:.unshift('#{l}')\n}
+        end
+        libs.each { |r| src << %{$:.unshift('#{r}')\n} }
+      end
+
+      src << %{
+        #require 'test/unit'
+        require 'test/unit/collector'
+        require 'test/unit/collector/objectspace'
+        require 'test/unit/ui/testrunnermediator'
+      }
+
+      reqs.each do |fix|
+        src << %Q{
+          require '#{fix}'
+        }
+      end
+
+      src << %{
+        def warn(*null); end  # silence warnings
+
+        output = STDOUT.dup
+        STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
+
+        load('#{file}')
+        load('#{xfile}')
+
+        tests = Test::Unit::Collector::ObjectSpace.new.collect
+        runner = Test::Unit::UI::TestRunnerMediator.new( tests )
+        result = runner.run_suite
+
+        begin
+          marshalled = Marshal.dump(result)
+        rescue TypeError => e
+          $stderr << "MARSHAL ERROR\n"
+          $stderr << "TEST: #{file}\n"
+          $stderr << "XTEST: #{xfile}\n"
+          $stderr << "DATA:" << result.inspect
+          exit -1
+        end
+        output << marshalled
+
+        STDOUT.reopen(output)
+        output.close
+      }
+
+      result = IO.popen("ruby","w+") do |ruby|
+        ruby.puts src
+        ruby.close_write
+        ruby.read
+      end
+
+      begin
+        marsh = Marshal.load(result)
+      rescue ArgumentError
+        $stderr << "\nCannot load marshalled test data.\n"
+        $stderr << result << "\n"
+        exit -1
+      end
+
+      return marsh
+    end
+
+    # Run a test in a separate process.
+    #
+    # Currently send program output to null device.
+    # Could send to a logger in future version.
+    #
+    # Key parameters are libs, reqs, live.
+
+    def fork_test( file, keys )
+      keys = keys.rekey(:to_s)
+
+      libs = keys['lib'] || []
+      reqs = keys['req'] || []
+      live = keys['live']
+
+      src = ''
+
+      unless live
+        l = File.join( Dir.pwd, 'lib' )
+        if File.directory?( l )
+          src << %{$:.unshift('#{l}')\n}
+        end
+        libs.each { |r| src << %{$:.unshift('#{r}')\n} }
+      end
+
+      src << %{
+        #require 'test/unit'
+        require 'test/unit/collector'
+        require 'test/unit/collector/objectspace'
+        require 'test/unit/ui/testrunnermediator'
+      }
+
+      reqs.each do |fix|
+        src << %Q{
+          require '#{fix}'
+        }
+      end
+
+      src << %{
+        def warn(*null); end  # silence warnings
+
+        output = STDOUT.dup
+        STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
+
+        load('#{file}')
+
+        tests = Test::Unit::Collector::ObjectSpace.new.collect
+        runner = Test::Unit::UI::TestRunnerMediator.new( tests )
+        result = runner.run_suite
+
+        begin
+          marshalled = Marshal.dump(result)
+        rescue TypeError => e
+          $stderr << "MARSHAL ERROR\n"
+          $stderr << "TEST: #{file}\n"
+          $stderr << "DATA:" << result.inspect
+          exit -1
+        end
+        output << marshalled
+
+        STDOUT.reopen(output)
+        output.close
+      }
+
+      result = IO.popen("ruby","w+") do |ruby|
+        ruby.puts src
+        ruby.close_write
+        ruby.read
+      end
+
+      begin
+        marsh = Marshal.load(result)
+      rescue ArgumentError
+        $stderr << "\nCannot load marshalled test data.\n"
+        $stderr << result << "\n"
+        exit -1
+      end
+
+      return marsh
+    end
+
+    # = Test Results
+    #
+    # Support class for collecting test results.
+
+    class TestResults
+      attr_reader :assertion_count,
+                  :run_count,
+                  :failure_count,
+                  :error_count
+
+      attr_accessor :style
+
+      def initialize( style=nil )
+        @style = style
+
+        @results = []
+
+        @assertion_count = 0
+        @run_count = 0
+        @failure_count = 0
+        @error_count = 0
+      end
+
+      # Add a result to the results collection.
+
+      def <<( result )
+        @results << result
+
+        @assertion_count += result.assertion_count
+        @run_count += result.run_count
+        @failure_count += result.failure_count
+        @error_count += result.error_count
+      end
+
+      #
+
+      def errors
+        errors = []
+        @results.each do |r|
+          unless r.passed?
+            errors << r.instance_variable_get('@errors')
+          end
+        end
+        errors.reject! { |e| e == [] }
+        errors
+      end
+
+      #
+
+      def failures
+        failures = []
+        @results.each do |r|
+          unless r.passed?
+            failures << r.instance_variable_get('@failures')
+          end
+        end
+        failures.reject! { |e| e == [] }
+        failures
+      end
+
+      # Output format for test results.
+
+      def to_s
+        return @results.to_s if style == 'pease'
+
+        s = []
+        # Display failures
+        unless failures.empty?
+          s << ''
+          s << "FAILURES:"
+          failures.reverse.each do |fails|
+            fails.reverse.each do |failure|
+              #puts
+              s << %{  - test      : #{failure.test_name}}
+              s << %{    location  : #{failure.location}}
+              if failure.message.index("\n")
+                s << %{    message   : >}
+                s << failure.message.tabto(6)
+              else
+                s << %{    message   : #{failure.message}}
+              end
+            end
+          end
+        end
+
+        # Display errors
+        unless errors.empty?
+          s << ''
+          s << "ERRORS:"
+          errors.reverse.each do |errs|
+            errs.reverse.each do |err|
+              s << ''
+              s << %{  - test      : #{err.test_name}}
+              s << %{    message   : #{err.exception.message}}
+              s << %{    backtrace :}
+              err.exception.backtrace[0...-1].each { |bt| s << %Q{      - #{bt}} }
+            end
+          end
+        end
+
+        # Display final results
+        s << ''
+        s << "Summary:"
+        s << "  Tests      : #{@run_count}"
+        s << "  Assertions : #{@assertion_count}"
+        s << "  Failures   : #{@failure_count}"
+        s << "  Errors     : #{@error_count}"
+        s << ''
+        s << ''
+
+        return s.join("\n")
+      end
+
+      # Delegate missing call to the results array.
+
+      def method_missing(*a,&b)
+        @results.send(*a,&b)
+      end
+    end
+
+  end
+
+end

data/work/sandbox/design.rb

@@ -0,0 +1,200 @@
+#require 'facet/kernel/within?'
+require 'ratchets/test/assert'
+
+at_exit { Ratchets::Design.check unless $no_autocheck }
+
+
+module Ratchets
+
+  # Design module. Hold all contexts.
+
+  module Design
+
+    self.specifications
+      @specificaitons = []
+    end
+
+    def self.specification(desc, &block)
+      contexts << Specificaiton.new(desc, &block)
+    end
+
+    class Context
+
+      self.contexts
+        @contexts = []
+      end
+
+      def self.context(desc, &block)
+        contexts << Context.new(desc, &block)
+      end
+
+      def self.check
+        contexts.each do |context|
+          context.check
+        end
+      end
+
+      def self.outline
+        contexts.each do |context|
+          puts "= " + context.description
+          context.specifications.each do |spec|
+            puts "* " + spec
+          end
+        end
+      end
+
+  end
+
+  # Design Context. Context contains unit specifications.
+
+  class Design::Context
+    attr :description
+    attr :specifications
+
+    def initialize(name, description, &block)
+      @description = description
+      @context     = block
+      @specifications = []
+
+      #@context_class = Class.new do
+      #  def setup; end
+      #  def teardown; end
+      #end
+
+      instance_eval(&block)
+    end
+
+    def setup(&setup_block)
+      @context_class.instance_eval do
+        define_method(:setup, &setup_block)
+      end
+    end
+
+    def teardown(&teardown_block)
+      @context_class.instance_eval do
+        define_method(:teardown, &teardown_block)
+      end
+    end
+
+    #def specify(desc, &spec_block)
+    #  @specifications << desc
+    #  @context_class.instance_eval do
+    #    define_method(desc, &spec_block)
+    #  end
+    #end
+
+    def method_missing(name, *args, &block)
+      @specifications << Specification.new(name, args[0], &block)
+    end
+
+
+    def check
+      @specifications.each do |spec|
+        begin
+          context = @context_class.new
+          context.setup
+          context.send(spec)
+          context.teardown
+        rescue Exception => e
+          # TODO: make output compatible with unit_diff
+          print "\n", (Assertion === e ? "Failure: " : "Error: ")
+          puts "#{spec}: \n #{e}"
+          puts e.backtrace
+        end
+      end
+    end
+
+  end
+
+  #
+
+  class Specification
+    attr :relation, :description, :specification
+
+    def initialize(relation, decription, &specification)
+      @relation      = relation
+      @description   = description
+      @specificaiton = specification
+    end
+  end
+
+
+#   # Unit of design specification.
+#
+#   class Design::Context::Specification
+#     attr :description
+#     attr :check_routine
+#
+#     def initialize(desc, &check)
+#       @description = desc
+#       @check_routine = check
+#     end
+#
+#     def to_proc
+#       @check_routine
+#     end
+#   end
+
+end #module Ratchets
+
+
+
+
+# EXAMPLE
+
+if __FILE__ == $0
+
+  Ratchets::Design.specification "Example Specification" do
+
+    context "demonstrate basic assertions" do
+
+      specify "fail if should is false" do
+        4.should == 3
+      end
+
+      specify "fail if should_not is true" do
+        4.should_not == 4
+      end
+
+      specify "fail on should raise" do
+        lambda{raise ArgumentError}.should.raise? SyntaxError
+      end
+
+    end
+
+  end
+
+  $no_autocheck = true
+
+  Ratchets::Design.outline
+
+end
+
+
+if __FILE__ == $0
+
+  Ratchets::Design.specification "Example Specification" do
+
+    demonstrate "demonstrate basic assertions" do
+
+      that "4.must == 3 fails" do
+        4.should == 3
+      end
+
+      that "4.must_not == 4 fails" do
+        4.should_not == 4
+      end
+
+      that "raise ArgumentError does not raise a SyntaxError" do
+        lambda{raise ArgumentError}.should.raise? SyntaxError
+      end
+
+    end
+
+  end
+
+  $no_autocheck = true
+
+  Ratchets::Design.outline
+
+end