tack 0.0.0 → 0.0.1

data/README.rdoc

@@ -1,6 +1,6 @@
 = tack
 
-Description goes here.
+USE AT YOUR OWN RISK. This is highly experimental and the interface is changing rapidly. 
 
 == Note on Patches/Pull Requests
  
@@ -13,6 +13,10 @@ Description goes here.
    bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
+== Acknowledgements
+
+Tack is heavily inspired by Rack and Faraday and borrows ideas and code from both. Early versions of the Test::Unit and RSpec adapters borrowed code from Hydra.
+
 == Copyright
 
 Copyright (c) 2010 Ben Brinckerhoff. See LICENSE for details.

data/Rakefile

@@ -10,7 +10,9 @@ begin
     gem.email = "ben@bbrinck.com"
     gem.homepage = "http://github.com/bhb/tack"
     gem.authors = ["Ben Brinckerhoff"]
+    gem.add_dependency "test-unit", "~> 1.0" if RUBY_VERSION=~/1\.9/
     gem.add_development_dependency "shoulda"
+    gem.add_development_dependency "test-construct"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/bin/tack

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'tack'
+require 'pp'
+require 'optparse'
+
+def require_ruby_debug
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'ruby-debug'
+end
+
+options = {}
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: tack [options] [file]"
+  opts.on("-I","--include PATH", "specify $LOAD_PATH (may be used more than once)") do |path|
+    options[:include] = path.split(":")
+  end
+  opts.on("-n", "--name PATTERN", "run only tests that match pattern") do |pattern|
+    if pattern=~/^\/.*\/$/
+     options[:pattern] = Regexp.new(pattern[1..-2])
+    else
+      options[:pattern] = pattern
+    end
+  end
+  opts.on("-u", "--debugger", "Enable ruby-debugging.") do
+    require_ruby_debug
+  end
+  opts.on_tail("-h","--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+args = ARGV
+option_parser.parse! args
+options[:paths] = ARGV
+
+if includes = options[:include]
+  $LOAD_PATH.unshift *includes
+end
+
+runner = Tack::Runner.new(:root => Dir.pwd) do |runner|
+  runner.use Tack::Formatters::Profiler, :tests => 3
+  runner.use Tack::Formatters::TotalTime
+  runner.use Tack::Formatters::PrintFailures  
+  runner.use Tack::Formatters::BasicSummary
+  runner.use Tack::Formatters::ProgressBar
+end
+
+set = Tack::TestSet.new(Dir.pwd)
+tests = set.tests_for(options[:paths], Tack::TestPattern.new(options[:pattern]))
+
+runner.run(tests)
+
+exit 0
+
+
+

data/lib/tack.rb

@@ -0,0 +1,30 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+module Tack
+
+  autoload :Runner, 'tack/runner'
+  autoload :TestSet, 'tack/test_set'
+  autoload :Middleware, 'tack/middleware'
+  autoload :TestPattern, 'tack/test_pattern'
+  
+
+  module Adapters
+
+    autoload :Adapter, 'tack/adapters/adapter'
+    autoload :RSpecAdapter, 'tack/adapters/rspec_adapter'
+    autoload :TestUnitAdapter, 'tack/adapters/test_unit_adapter'
+
+  end
+  
+  module Formatters
+    
+    autoload :BasicSummary, 'tack/formatters/basic_summary'
+    autoload :ProgressBar, 'tack/formatters/progress_bar'
+    autoload :Profiler, 'tack/formatters/profiler'
+    autoload :TotalTime, 'tack/formatters/total_time'
+    autoload :PrintFailures, 'tack/formatters/print_failures'
+
+  end
+
+end

data/lib/tack/adapters/adapter.rb

@@ -0,0 +1,25 @@
+module Tack
+
+  module Adapters
+
+    class Adapter
+
+      def self.for(path)
+        # Using a simple path-based heuristic for now
+        case path
+        when /test.rb$/ 
+          TestUnitAdapter.new
+        when /spec.rb$/
+          RSpecAdapter.new
+        else
+          raise "Cannot determine an adapter for path #{path}"
+        end
+      end
+
+    end
+
+  end
+
+end
+
+

data/lib/tack/adapters/rspec_adapter.rb

@@ -0,0 +1,106 @@
+require 'spec'
+require 'spec/runner/formatter/base_formatter'
+
+if defined?(Spec)
+  module Spec
+    module Runner
+      class << self
+        # stop the auto-run at_exit
+        def run
+          return 0
+        end 
+      end
+    end
+  end
+end
+
+module Spec
+  module Runner
+    module Formatter
+      # Stolen from Hydra for now
+      class TackFormatter < BaseFormatter
+        
+        attr_accessor :results
+        
+        def initialize(options)
+          io = StringIO.new # suppress output
+          super(options, io)
+          @results = { :passed => [],
+            :failed => [],
+            :pending => []}
+        end
+
+        # Stifle the output of pending examples
+        def example_pending(example)
+          @results[:pending] << {
+            :description => example.description,
+          }
+        end
+
+        def example_passed(example)
+          @results[:passed] << {
+            :description => example.description,
+          }
+        end
+
+        def example_failed(example, counter, error=nil)
+          @results[:failed] <<
+            {
+            :description => example.description,
+            :failure => build_failure(example, error)
+          }
+        end
+
+        private
+        
+        def build_failure(example, error)
+          case error.exception
+          when Spec::Expectations::ExpectationNotMetError
+            { :message => error.exception.message,
+              :backtrace => error.exception.backtrace}
+          else
+            { :message => "#{error.exception.class} was raised: #{error.exception.message}",
+              :backtrace => error.exception.backtrace}
+          end
+        end
+
+      end
+    end
+  end
+end
+
+module Tack
+
+  module Adapters
+
+    class RSpecAdapter
+
+      def tests_for(file, pattern)
+        Spec::Runner.options.instance_variable_set(:@formatters, [Spec::Runner::Formatter::TackFormatter.new(Spec::Runner.options.formatter_options)])
+        Spec::Runner.options.instance_variable_set(:@example_groups, [])
+        Spec::Runner.options.instance_variable_set(:@files, [file])
+        Spec::Runner.options.instance_variable_set(:@files_loaded, false)
+        runner = Spec::Runner::ExampleGroupRunner.new(Spec::Runner.options)
+        runner.load_files([file])
+        example_groups = runner.send(:example_groups)
+        examples = example_groups.inject([]) do |arr, group|
+          arr += group.examples
+        end
+        examples.map {|example| [file, example.description]}.select {|file,description| description.match(pattern)}
+      end
+      
+      def run(file, test)
+        Spec::Runner.options.instance_variable_set(:@examples, [test])
+        Spec::Runner.options.instance_variable_set(:@example_groups, [])
+        Spec::Runner.options.instance_variable_set(:@files, [file])
+        Spec::Runner.options.instance_variable_set(:@files_loaded, false)
+        formatter = Spec::Runner::Formatter::TackFormatter.new(Spec::Runner.options.formatter_options)
+        Spec::Runner.options.instance_variable_set(:@formatters, [formatter])
+        Spec::Runner.options.run_examples
+        formatter.results
+      end
+
+    end
+
+  end
+end

data/lib/tack/adapters/test_unit_adapter.rb

@@ -0,0 +1,114 @@
+if RUBY_VERSION=~/1.9/
+  gem 'test-unit', '~> 1.0'
+end
+require 'test/unit'
+require 'test/unit/testresult'
+
+Test::Unit.run = true
+
+module Tack
+
+  module Adapters
+
+    class TestUnitAdapter
+
+      def tests_for(file, pattern)
+        require file
+        classes = test_classes_for(file)
+        classes.inject([]) do |tests, klass|
+          tests += test_methods(klass).map {|method_name| [file, method_name.to_s]}.select {|file, method_name| method_name.match(pattern)}
+        end
+      end
+
+      def run(path, description)
+        results = { :passed => [],
+          :failed => [],
+          :pending => []}
+        require(path)
+        # Note that this won't work if there are multiple classes in a file
+        klass = test_classes_for(path).first 
+        test = klass.new(description)
+        result = Test::Unit::TestResult.new
+
+        result.add_listener(Test::Unit::TestResult::FAULT) do |failure|
+          results[:failed] << build_result(description, failure)
+        end
+        
+        test.run(result) do |started,name|
+          # We do nothing here
+          # but this method requires a block
+        end
+        if result.passed?
+          results[:passed] << build_result(description)
+        end
+        results
+      end
+
+      private
+      
+      def build_result(description, failure=nil)
+        { :description => description, 
+          :failure => build_failure(failure) }
+      end
+
+      def build_failure(failure)
+        return {} if failure.nil?
+        case failure
+        when Test::Unit::Error
+          { :message => "#{failure.exception.class} was raised: #{failure.exception.message}",
+            :backtrace => failure.exception.backtrace }
+        else
+          { :message => failure.message,
+            :backtrace => failure.location }
+        end
+      end
+
+      def test_classes_for(file)
+        # taken from from hydra
+        #code = ""
+        #    File.open(file) {|buffer| code = buffer.read}
+        code = File.read(file)
+        matches = code.scan(/class\s+([\S]+)/)
+        klasses = matches.collect do |c|
+          begin
+            if c.first.respond_to? :constantize
+              c.first.constantize
+            else
+              eval(c.first)
+            end
+          rescue NameError
+            # means we could not load [c.first], but thats ok, its just not
+            # one of the classes we want to test
+            nil
+          rescue SyntaxError
+            # see above
+            nil
+          end
+        end
+        return klasses.select{|k| k.respond_to? 'suite'}
+      end
+
+      def test_methods(test_class)
+        test_class.instance_methods.select do |method_name|
+          method_name =~ /^test./ &&
+            (test_class.instance_method(method_name).arity == 0 ||
+             test_class.instance_method(method_name).arity == -1
+             )
+        end
+      end
+
+      def get_test_classes
+        test_classes = []
+        ObjectSpace.each_object(Class) do |klass|
+          if(Test::Unit::TestCase > klass)
+            test_classes << klass
+          end
+        end
+        test_classes
+      end
+
+    end
+
+  end
+
+end

data/lib/tack/formatters/basic_summary.rb

@@ -0,0 +1,22 @@
+module Tack
+
+  module Formatters
+
+    class BasicSummary
+      include Middleware
+
+      def initialize(app)
+        @app = app
+      end
+
+      def run_suite(tests)
+        returning @app.run_suite(tests) do |results|
+          puts "%d tests, %d failures, %d pending" % [results.values.flatten.length, results[:failed].length, results[:pending].length]
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/tack/formatters/print_failures.rb

@@ -0,0 +1,43 @@
+module Tack
+
+  module Formatters
+
+    class PrintFailures
+      include Middleware
+
+      def initialize(app)
+        @app = app
+      end
+
+      def run_suite(tests)
+        returning @app.run_suite(tests) do |results|
+          results[:failed].each_with_index do |result, index|
+            print_failure(index+1, result)
+          end
+        end
+      end
+
+      private
+
+      def format_backtrace(backtrace)
+        return "" if backtrace.nil?
+        "["+backtrace.map { |line| backtrace_line(line) }.join("\n")+"]:"
+      end
+
+      def backtrace_line(line)
+        line.sub(/\A([^:]+:\d+)$/, '\\1:')
+      end
+
+      def print_failure(counter, result)
+        puts
+        puts "#{counter.to_s})"
+        puts result[:description]
+        puts format_backtrace(result[:failure][:backtrace])
+        puts result[:failure][:message]
+      end
+
+    end
+
+  end
+
+end

data/lib/tack/formatters/profiler.rb

@@ -0,0 +1,39 @@
+module Tack
+
+  module Formatters
+
+    class Profiler
+      include Middleware
+
+      def initialize(app, args)
+        @app = app
+        @num_tests = args.fetch(:tests) { 10 }
+        @times = []
+      end
+
+      def run_suite(tests)
+        returning @app.run_suite(tests) do |results|
+          puts "\n\nTop #{@num_tests} slowest examples:\n"
+          @times = @times.sort_by do |description, time|
+            time
+          end.reverse
+          @times[0..@num_tests-1].each do |description, time| 
+            print "%.7f" % time
+            puts " #{description}"
+          end
+        end
+      end
+
+      def run_test(file, description)
+        time = Time.now
+        returning @app.run_test(file,description) do 
+          @times << [description, Time.now - time]
+        end
+      end
+
+    end
+    
+  end
+
+end
+

data/lib/tack/formatters/progress_bar.rb

@@ -0,0 +1,36 @@
+module Tack
+
+  module Formatters
+
+    class ProgressBar
+      include Middleware
+
+      def initialize(app)
+        @app = app
+      end
+
+      def run_suite(tests)
+        returning @app.run_suite(tests) do 
+          puts
+        end
+      end
+
+      def run_test(file, description)
+        returning @app.run_test(file, description) do |result|
+          result[:passed].each do
+            print "."
+          end
+          result[:pending].each do
+            print "P"
+          end
+          result[:failed].each do
+            print "F"
+          end
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/tack/formatters/total_time.rb

@@ -0,0 +1,23 @@
+module Tack
+
+  module Formatters
+
+    class TotalTime
+      include Middleware
+
+      def initialize(app)
+        @app = app
+      end
+
+      def run_suite(tests)
+        time = Time.now
+        returning @app.run_suite(tests) do
+          puts "Finished in %.7f seconds." % (Time.now - time)
+        end
+      end
+
+    end
+    
+  end
+
+end

data/lib/tack/middleware.rb

@@ -0,0 +1,22 @@
+module Tack
+
+  module Middleware
+    
+    def run_suite(tests)
+      @app.run_suite(tests)
+    end
+
+    def run_test(file, description)
+      @app.run_test(file, description)
+    end
+
+    # not necessary for the middleware API, but handy for implementing
+    # middleware methods
+    def returning(value)
+      yield(value)
+      value
+    end
+
+  end
+
+end

data/lib/tack/runner.rb

@@ -0,0 +1,50 @@
+module Tack
+
+  class Runner
+    
+    def initialize(args)
+      if(args.is_a?(Hash))
+        @root_dir = args.fetch(:root)
+      else
+        @root_dir = args
+      end
+      @handlers = []
+      yield self if block_given?
+    end
+
+    def run(tests)
+      to_app if @start_app.nil?
+      @start_app.run_suite(tests)
+    end
+
+    def run_suite(tests)
+      results = { :passed => [],
+        :failed => [],
+        :pending => []}
+      tests.each do |path, description|
+        result = @start_app.run_test(path, description)
+        results[:passed] += result[:passed]
+        results[:failed] += result[:failed]
+        results[:pending] += result[:pending]
+      end
+      results
+    end
+
+    def run_test(path, description)
+      adapter = Adapters::Adapter.for(path)
+      adapter.run(path, description)
+    end
+
+    def use(middleware, *args, &block)
+      @handlers << lambda { |app|
+        middleware.new(app, *args, &block) }
+    end
+
+    def to_app
+      inner_app = self
+      @start_app = @handlers.reverse.inject(inner_app) { |a, e| e.call(a) }
+    end
+
+  end
+
+end

data/lib/tack/test_pattern.rb

@@ -0,0 +1,21 @@
+module Tack
+
+  class TestPattern < Regexp
+
+    DEFAULT = /.*/
+
+    def initialize(pattern=nil)
+      pattern = case pattern
+                when nil
+                    DEFAULT
+                when String, Regexp
+                    pattern
+                else
+                  DEFAULT
+                end
+      super(pattern)
+    end
+
+  end
+
+end

data/lib/tack/test_set.rb

@@ -0,0 +1,39 @@
+module Tack
+
+  class TestSet
+    
+    def initialize(root_dir)
+      @root_dir = root_dir
+    end
+
+    def tests_for(paths, pattern=TestPattern.new)
+      paths = Array(paths).map { |path| path.to_s}
+      files = paths.inject([]) do |files, path|
+        if File.directory?(path)
+          files += Dir[File.join(path,"**/*")].select {|f| valid_test_file?(f)}
+        else
+          files << path
+        end
+      end
+
+      files.inject([]) do |tests, file|
+        adapter = Adapters::Adapter.for(file)
+        tests += adapter.tests_for(file, pattern)
+      end
+    end
+
+    private 
+
+    def valid_test_file?(path)
+      return false if File.directory?(path)
+      case path
+      when /_test.rb$/, /_spec.rb$/
+          true
+      else
+        false
+      end
+    end
+
+  end
+
+end

data/test/acceptance/rspec_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+
+class RSpecTest < Test::Unit::TestCase
+
+  def with_rspec_context(args)
+    body = args.fetch(:body)
+    describe = args.fetch(:describe)
+    within_construct(false) do |c|
+      file_name = 'fake_spec.rb'
+      c.file file_name do
+        <<-EOS
+        describe #{describe} do
+      
+        #{body}
+
+        end
+        EOS
+      end
+      path = c+file_name.to_s
+      yield path
+    end
+  end
+
+  should "grab all specs" do
+    body = <<-EOS
+    specify "something" do
+    end
+
+    it "should do something" do
+    end
+    EOS
+    with_rspec_context :describe => String, :body => body do |path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      assert_equal 2, tests.length
+      assert_equal [path.to_s, "something"], tests.sort.last
+      assert_equal [path.to_s, "should do something"], tests.sort.first
+    end
+  end
+
+  should "find specs that match substring" do
+    body = <<-EOS
+    specify "something" do
+    end
+
+    it "does nothing" do
+    end
+    EOS
+    with_rspec_context :describe => String, :body => body do |path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path, "some")
+      assert_equal 1, tests.length
+      assert_equal [path.to_s, "something"], tests.sort.first
+    end
+  end
+
+  should "find specs that match regular expression" do
+    body = <<-EOS
+    specify "something" do
+    end
+
+    it "does nothing" do
+    end
+    EOS
+    with_rspec_context :describe => String, :body => body do |path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path, /does/)
+      assert_equal 1, tests.length
+      assert_equal [path.to_s, "does nothing"], tests.sort.first
+    end
+  end
+
+  should "run failing spec" do
+    body = <<-EOS
+    specify "append length is sum of component string lengths" do
+      ("ab"+"cd").length.should == ("ab".length - "cd".length)
+    end
+    EOS
+    with_rspec_context :describe => String, :body => body do |path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      runner = Tack::Runner.new(path.parent)
+      results = runner.run(tests)
+      
+      assert_equal 0, results[:passed].length
+      assert_equal 1, results[:failed].length
+      result = results[:failed].first
+      assert_equal "append length is sum of component string lengths", result[:description]
+      assert_equal "expected: 0,\n     got: 4 (using ==)", result[:failure][:message]
+      assert_kind_of Array, result[:failure][:backtrace]
+    end
+  end
+
+  should "run spec that raises error" do
+    body = <<-EOS
+    specify "append length is sum of component string lengths" do
+      raise "failing!"
+    end
+    EOS
+    with_rspec_context :describe => String, :body => body do |path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      runner = Tack::Runner.new(path.parent)
+      results = runner.run(tests)
+      
+      assert_equal 0, results[:passed].length
+      assert_equal 1, results[:failed].length
+
+      result = results[:failed].first
+      assert_equal "append length is sum of component string lengths", result[:description]
+      assert_match /was raised/, result[:failure][:message]
+      assert_kind_of Array, result[:failure][:backtrace]
+    end
+  end
+
+  should "run successful spec" do
+    body = <<-EOS
+    specify "append length is sum of component string lengths" do
+      ("ab"+"cd").length.should == ("ab".length + "cd".length)
+    end
+    EOS
+    with_rspec_context :describe => String, :body => body do |path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      runner = Tack::Runner.new(path.parent)
+      results = runner.run(tests)
+      
+      assert_equal 1, results[:passed].length
+      assert_equal 0, results[:failed].length
+      assert_equal "append length is sum of component string lengths", results[:passed].first[:description]
+    end
+  end
+
+end

data/test/acceptance/test_unit_test.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+
+class TestUnitTest < Test::Unit::TestCase
+
+  def remove_test_class_definition(class_name)
+    Object.send(:remove_const, class_name) if Object.const_defined?(class_name)
+  end
+
+  def with_test_class(args)
+    body = args.fetch(:body)
+    class_name = args.fetch(:class_name) { :FakeTest } 
+    within_construct(false) do |c|
+      begin
+        file = c.file 'fake_test.rb' do
+          <<-EOS
+          require 'test/unit'
+    
+          class #{class_name} < Test::Unit::TestCase
+          
+            #{body}
+
+          end
+EOS
+        end
+        path = c + file.to_s
+        yield file.to_s, path
+      ensure
+        remove_test_class_definition(class_name)
+      end
+    end
+  end
+
+  should "grab all tests" do
+    body =<<-EOS
+    def test_one
+    end
+      
+    def test_two
+    end
+    EOS
+    with_test_class(:body => body) do |file_name, path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      assert_equal 2, tests.length
+      assert_equal [file_name, "test_one"], tests.sort.first
+      assert_equal [file_name, "test_two"], tests.sort.last
+    end
+  end
+
+  should "find tests that match substring" do
+    body=<<-EOS
+    def test_one
+    end
+    def test_two
+    end
+    EOS
+    with_test_class(:body => body) do |file_name, path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path, "two")
+      assert_equal 1, tests.length
+      assert_equal [file_name, "test_two"], tests.sort.first
+    end
+  end
+
+  should "find tests that match regular expression" do
+    body=<<-EOS
+    def test_one
+    end
+    def test_two
+    end
+    EOS
+    with_test_class(:body => body) do |file_name, path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path, /two/)
+      assert_equal 1, tests.length
+      assert_equal [file_name, "test_two"], tests.sort.first
+    end
+  end
+
+  should "run failing test" do
+    body =<<-EOS
+    def test_append_length
+      assert_equal ("ab".length - "cd".length), ("ab"+"cd").length
+    end
+EOS
+    with_test_class(:body => body) do |file_name, path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      runner = Tack::Runner.new(path.parent)
+      results = runner.run(tests)
+
+      assert_equal 0, results[:passed].length
+      assert_equal 1, results[:failed].length
+      result = results[:failed].first
+      assert_equal "test_append_length", result[:description]
+      assert_match /expected but was/, result[:failure][:message]
+      assert_kind_of Array, result[:failure][:backtrace]
+    end
+  end
+
+  should "run test with error" do
+    body =<<-EOS
+    def test_append_length
+      raise "failing!"
+    end
+EOS
+    with_test_class(:body => body) do |file_name, path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      runner = Tack::Runner.new(path.parent)
+      results = runner.run(tests)
+
+      assert_equal 0, results[:passed].length
+      assert_equal 1, results[:failed].length
+      result = results[:failed].first
+      assert_equal "test_append_length", result[:description]
+      assert_match /was raised/, result[:failure][:message]
+      assert_kind_of Array, result[:failure][:backtrace]
+    end
+  end
+
+  should "run successful test" do
+    body =<<-EOS
+    def test_append_length
+      assert_equal ("ab".length + "cd".length), ("ab"+"cd").length
+    end
+EOS
+    with_test_class(:body => body) do |file_name, path|
+      set = Tack::TestSet.new(path.parent)
+      tests = set.tests_for(path)
+      runner = Tack::Runner.new(path.parent)
+      results = runner.run(tests)
+      assert_equal 1, results[:passed].length
+      assert_equal 0, results[:failed].length
+      assert_equal "test_append_length", results[:passed].first[:description]
+    end    
+  end
+
+end

data/test/tack_test.rb

@@ -1,7 +1,9 @@
 require 'test_helper'
 
 class TackTest < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
+
+  should "do whatever" do
+    # nothing here for now
   end
+
 end

data/test/test_helper.rb

@@ -1,10 +1,13 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+require 'construct'
+require 'ruby-debug'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'tack'
 
 class Test::Unit::TestCase
+  include Construct::Helpers
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - Ben Brinckerhoff
@@ -14,8 +14,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-04 00:00:00 -06:00
-default_executable: 
+date: 2010-06-07 00:00:00 -06:00
+default_executable: tack
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: shoulda
@@ -29,10 +29,22 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-construct
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: A Rack-inspired interface for testing libraries
 email: ben@bbrinck.com
-executables: []
-
+executables: 
+- tack
 extensions: []
 
 extra_rdoc_files: 
@@ -45,7 +57,22 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- bin/tack
 - lib/tack.rb
+- lib/tack/adapters/adapter.rb
+- lib/tack/adapters/rspec_adapter.rb
+- lib/tack/adapters/test_unit_adapter.rb
+- lib/tack/formatters/basic_summary.rb
+- lib/tack/formatters/print_failures.rb
+- lib/tack/formatters/profiler.rb
+- lib/tack/formatters/progress_bar.rb
+- lib/tack/formatters/total_time.rb
+- lib/tack/middleware.rb
+- lib/tack/runner.rb
+- lib/tack/test_pattern.rb
+- lib/tack/test_set.rb
+- test/acceptance/rspec_test.rb
+- test/acceptance/test_unit_test.rb
 - test/tack_test.rb
 - test/test_helper.rb
 has_rdoc: true
@@ -79,5 +106,7 @@ signing_key:
 specification_version: 3
 summary: A Rack-inspired interface for testing libraries
 test_files: 
+- test/acceptance/rspec_test.rb
+- test/acceptance/test_unit_test.rb
 - test/tack_test.rb
 - test/test_helper.rb