tst 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Arun Srinivasan
+
+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.md

@@ -0,0 +1,190 @@
+# Tst
+
+A small testing library that tries not to do too much.
+
+You get a top-level `tst` method, a few `assert` methods, and readable test
+output.
+
+# Installation
+
+Standard issue:
+
+    gem install tst
+
+# Usage
+
+The `tst` method is available on the top-level, takes an optional name and
+a required block, like so:
+
+```ruby
+tst "Array-indexing is not 1-based" do
+  arr = [1, 2, 3, 4, 5]
+  assert arr[1] != 1
+end
+```
+
+If the block runs to completion without raising anything, it passes.
+
+If one of assertion methods (see below) raises, it counts as a failure.
+
+If the block raises for any other reason, it's an exception.
+
+### Assertions
+
+Within a `tst` block, you have access to 3 assert methods: `assert`,
+`assert_equal`, and `assert_raises`. They do what you'd expect.
+
+If those don't cover your needs, just write your own:
+
+```ruby
+module Tst
+
+  # The assertions live in the Assertions module and are available
+  # to the `tst` blocks.
+  module Assertions
+
+    # No naming or argument rules, it's just a method.
+    # Define it how you please.
+    def sums_to_42(*args)
+      actual = args.inject(0) { |sum, arg| sum + arg }
+
+      # return without raising to pass
+      return if actual == 42
+
+      # Tst::Failure is a subclass of StandardError that takes
+      # 3 arguments: Failure.new(message, expected, actual)
+      #
+      # message - a brief description of the failure
+      # expected - the expected value
+      # actual - the actual value
+      raise Tst::Failure.new("#{args} doesn't sum to 42", 42, actual)
+    end
+  end
+end
+
+# Now just use your custom assertion in a test
+tst "some array sums to 42" do
+  sums_to_42(40, 1, 1) # This will pass just fine
+  sums_to_42(40, 1, 2) # This will fail
+end
+```
+
+Running that test will yield output like:
+
+    $ tst 'some_array.rb'
+    F
+    F1: [40, 1, 2] doesn't sum to 42 - "some array sums to 42"
+      exp: 42
+      act: 43
+    * some_array.rb:<lineno>:in `block in <top (required)>'
+
+### Running tests
+
+Tst comes with a command-line runner, named "tst".
+
+    $ tst
+    Usage: tst [options] files
+
+      -h, --help       Displays this message
+
+      -I, --libdir     A directory to add to the load path
+                       (can be used multiple times: "-I lib -I test"
+
+      -r, --reporter   Specify a reporter to use. "pretty" or "plain".
+                       Defaults to "plain"
+
+      files            Specifies which test files to run. Is passed through to
+                       Dir.glob, so anything it accepts is valid. NOTE: use
+                       quotes to make sure nothing gets swallowed.
+
+You can also run tests programmatically. Here's a sample rake task, for
+instance:
+
+```ruby
+require 'tst'
+
+desc 'Run the tests'
+task :test do
+  Tst.run 'test/*.rb',
+    :load_paths => ['.', 'lib'],              # same as -I above
+    :reporter => Tst::Reporters::Pretty.new   # same as -r above
+end
+```
+
+# Meanderings
+
+### Why aren't there setup and teardown methods?
+
+Having setup and teardown methods makes it harder to look at one test and see
+what's happening, as it's easy for relevant stuff to be scrolled off the
+screen, or even hidden in a superclass. And the names are totally generic.
+
+And we're in ruby! You can get what you need by just writing a method _with
+a name_ that encapsulates what you need. Take a look at
+"test/plain_reporter.rb" for an example.
+
+### Lightness
+
+Tst tries to avoid weight, in various forms:
+
+**Weighty Structure**
+
+Tst has no grouping - TestCases, Context blocks, etc, because we're in ruby,
+where such ceremony is unnecessary. It is not required to make the testing
+tools work, and I'm not sure it yields much benefit. We already put our test
+code into files with names. Is further taxonomy really necessary?
+
+I believe the lack of ceremony is easier to understand, learn, use, and is
+nicer to look at.
+
+**Conceptual weight**
+
+This may just be a personal preference thing, but I don't understand the appeal
+of the 'english-y' DSL's.
+
+```ruby
+                                   # Test tool concepts
+                                   # ------------------
+# Compare this...
+tst "a new Thing is not empty" do  # :tst
+  thing = Thing.new
+  assert !thing.empty?             # :assert
+end
+
+# ... to this (RSpec):
+describe Thing do                  # :describe
+  let(:thing) { Thing.new }        # :let
+
+  it "should be empty" do          # :it
+    thing.should be_empty          # :should
+  end                              # magic :be_* method
+                                   # how :thing gets in scope
+end
+
+# or with even more magic:
+describe Thing do                  # :describe
+  it { should be_empty }           # :it
+end                                # magic Thing initialization
+                                   # implicit :subject
+                                   # :should (w/ implicit :subject)
+                                   # :be_*
+```
+
+Some argue that the RSpec examples read well, but look at how much you need to
+know to understand what's going on.
+
+Don't get me wrong. RSpec is a pretty cool implementation of an interesting
+idea, but I'm not convinced that it's worth the conceptual overhead when you
+consider what you get.
+
+**Code weight**
+
+Just looking in the 'lib' directories:
+
+- test/unit: 6313
+- rspec: 5460
+- minitest: 1210
+- tst: 220
+
+The core of tst's testing engine is really just 122 lines (see 'tst.rb'). The
+other 98 is IO/reporting code.

data/Rakefile

@@ -0,0 +1,45 @@
+$:.unshift File.expand_path('lib')
+require 'tst'
+
+version = Tst::VERSION
+
+desc 'Run the tests'
+task :test do
+  Tst.run 'test/*.rb',
+    :load_paths => ['.', 'lib'],
+    :reporter => Tst::Reporters::Pretty.new
+end
+
+namespace :test do
+  desc 'For fun, run the fixtures'
+  task :fixtures do
+    Tst.run 'test/fixtures/*.rb',
+      :load_paths => ['.', 'lib'],
+      :reporter => Tst::Reporters::Pretty.new
+  end
+end
+
+namespace :gem do
+  desc 'Clean up generated files'
+  task :clean do
+    sh 'rm -rf pkg'
+  end
+
+  desc "Build the gem"
+  task :build => :clean do
+    sh "mkdir pkg"
+    sh "gem build tst.gemspec"
+    sh "mv tst-#{version}.gem pkg/"
+  end
+
+  desc "Release v#{version}"
+  task :release => :build do
+    sh "git commit --allow-empty -a -m 'Release #{version}'"
+    sh "git tag v#{version}"
+    sh "git push origin master"
+    sh "git push origin v#{version}"
+    sh "gem push pkg/#{name}-#{version}.gem"
+  end
+end
+
+task :default => :test

data/bin/tst

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('lib')
+require 'getoptlong'
+require 'tst'
+
+Banner = <<-Banner
+Usage: tst [options] files
+
+  -h, --help       Displays this message
+
+  -I, --libdir     A directory to add to the load path
+                   (can be used multiple times: "-I lib -I test"
+
+  -r, --reporter   Specify a reporter to use. "pretty" or "plain".
+                   Defaults to "plain"
+
+  files            Specifies which test files to run. Is passed through to
+                   Dir.glob, so anything it accepts is valid. NOTE: use
+                   quotes to make sure nothing gets swallowed.
+Banner
+
+def parse_options!(options)
+  GetoptLong.new(
+    ['--help', '-h', GetoptLong::NO_ARGUMENT],
+    ['--libdir', '-I', GetoptLong::REQUIRED_ARGUMENT],
+    ['--reporter', '-r', GetoptLong::REQUIRED_ARGUMENT]
+  ).each do |switch, arg|
+    case switch
+    when '--help'
+      exit_with(Banner)
+    when '--reporter'
+      set_reporter(arg, options) || exit_with("Unknown reporter '#{arg}'.")
+    when '--libdir'
+      add_include_dir(arg, options)
+    end
+  end
+
+  exit_with(Banner) unless glob = ARGV.shift
+  return glob, options
+end
+
+def set_reporter(reporter, options)
+  case reporter
+  when "pretty"
+    options[:reporter] = Tst::Reporters::Pretty.new
+    true
+  when "plain"
+    true
+  else
+    false
+  end
+end
+
+def add_include_dir(dir, options)
+  options[:load_paths] << dir
+end
+
+def exit_with(msg)
+  puts msg
+  exit
+end
+
+glob, options = parse_options!(
+  :reporter => Tst::Reporters::Plain.new,
+  :load_paths => []
+)
+
+Tst.run(glob, options)

data/lib/tst/reporters/plain.rb

@@ -0,0 +1,87 @@
+module Tst
+  module Reporters
+    class Plain
+      attr_reader :io, :results
+
+      def initialize(io = $stdout)
+        @io = io
+      end
+
+      def success(result)   io.print('.') end
+      def failure(result)   io.print('F') end
+      def exception(result) io.print('E') end
+
+      def summarize(results)
+        @results = results
+        summary = ["\n"] + failures + exceptions + conclusion
+        summary.each { |line| io.puts(line) }
+      end
+
+      def failures
+        results.failures.each_with_index.flat_map do |failure, i|
+          failure_details(failure.name, failure.exception, i)
+        end
+      end
+
+      def failure_details(name, exception, i)
+        [ failure_header(name, exception, i),
+          expected_actual(exception),
+          backtrace(exception.backtrace),
+          "" ]
+      end
+
+      def failure_header(name, exception, i)
+        "F#{i+1}: #{exception.message} - #{name.inspect}"
+      end
+
+      def expected_actual(exception)
+        ["  exp: #{exception.expected.inspect}",
+         "  got: #{exception.actual.inspect}"
+        ].join("\n")
+      end
+
+      def exceptions
+        results.exceptions.each_with_index.flat_map do |exception, i|
+          exception_details(exception.name, exception.exception, i)
+        end
+      end
+
+      def exception_details(name, exception, i)
+        [ exception_header(name, exception, i),
+          backtrace(exception.backtrace),
+          "" ]
+      end
+
+      def exception_header(name, exception, i)
+        "E#{i+1}: #{exception.inspect} - #{name.inspect}"
+      end
+
+
+      def backtrace(trace)
+        filter_backtrace(trace).map { |line| "* #{line}" }.join("\n")
+      end
+
+      def conclusion
+        [ "#{elapsed}: #{passed}, #{failed}, #{raised}." ]
+      end
+
+      def elapsed
+        "Ran %d tests in %.6fs" % [results.count, results.elapsed]
+      end
+      def passed; "#{results.successes.count} passed"  end
+      def failed; "#{results.failures.count} failed"   end
+      def raised; "#{results.exceptions.count} raised" end
+
+      def filter_backtrace(backtrace)
+        backtrace.reject do |line|
+          line =~ BACKTRACE_FILTER
+        end.map do |line|
+          line.gsub("#{Dir.pwd}/", "")
+        end
+      end
+
+      BACKTRACE_FILTER =
+        /lib\/tst\.rb|bin\/tst|\/(ruby|jruby|rbx)[-\/]([0-9\.])+|Rakefile/
+    end
+  end
+end

data/lib/tst/reporters/pretty.rb

@@ -0,0 +1,29 @@
+module Tst
+  module Reporters
+    class Pretty < Plain
+      def color(n, s) "\e[#{n}m#{s}\e[0m" end
+
+      def black(s)   color(30, s) end
+      def red(s)     color(31, s) end
+      def green(s)   color(32, s) end
+      def yellow(s)  color(33, s) end
+      def blue(s)    color(34, s) end
+      def magenta(s) color(35, s) end
+      def cyan(s)    color(36, s) end
+      def white(s)   color(37, s) end
+
+      def success(result)   io.print green('.')  end
+      def failure(result)   io.print red('F')    end
+      def exception(result) io.print yellow('E') end
+
+      def failure_header(*)   red(super)    end
+      def expected_actual(*)  white(super)  end
+      def backtrace(*)        cyan(super)   end
+      def exception_header(*) yellow(super) end
+
+      def passed; green(super)  end
+      def failed; red(super)    end
+      def raised; yellow(super) end
+    end
+  end
+end

data/lib/tst/reporters.rb

@@ -0,0 +1,25 @@
+require 'tst/reporters/plain'
+require 'tst/reporters/pretty'
+
+# ### Reporters ###
+#
+# Reporters are actually very simple.
+#
+# A reporter is just any object that responds to the following
+# methods: `success`, `failure`, `exception`, `summarize`.
+#
+# `success`, `failure`, and `exception` get called as the tests
+# are running - for real-time reporting.
+#
+# When called, they receive a Result instance as an argument, so
+# you could list the name of each test after it ran.
+#
+# After all the tests run, the `summarize` method gets called with
+# a Results (note the plural) object, which has information about
+# the the tests that were run.
+#
+# Take a look at 'lib/tst.rb' for details about Result and Results.
+#
+# And take a look at the "plain" and "pretty" reporters in the
+# 'lib/tst/reporters/' directory to see a couple of actual
+# implementations.

data/lib/tst.rb

@@ -0,0 +1,267 @@
+require 'tst/reporters'
+
+# Tst
+module Tst
+  VERSION = "0.0.1"
+
+  # ### Failure ###
+  #
+  # An error class that carries data about test failures.
+  class Failure < StandardError
+    attr_reader :message, :expected, :actual
+
+    # Takes the `message`, `expected`, and `actual` parameters
+    # and stuffs them into instance variables.
+    def initialize(message, expected, actual)
+      @message = message
+      @expected = expected
+      @actual = actual
+      super(message)
+    end
+  end
+
+  # ### Assertions ###
+  #
+  # Defines a few `assert` methods for use in tests.
+  #
+  # If you'd like to define your own assertion methods,
+  # open up the module and do so:
+  #
+  #     module Tst::Assertions
+  #       def assert_seven(actual)
+  #         # return without raising to pass
+  #         return if actual == 7
+  #
+  #         # raise a Tst::Failure to fail
+  #         raise Tst::Failure.new('Not 7', 7, actual)
+  #       end
+  #     end
+  #
+  # Because `Assertions` is included into `Test`, your
+  # new methods will be available in `tst` blocks.
+  module Assertions
+    # *assert*, the lie detector.
+    #
+    # It fails if `value` is `false` or `nil`. Succeeds otherwise.
+    def assert(value)
+      return if value
+      raise Failure.new("Failure: Truthiness", "not false or nil", value)
+    end
+
+    # *assert_equal*, the egalitarian.
+    #
+    # Fails unless it's arguments are equal (with `==`).
+    def assert_equal(expected, actual)
+      return if expected == actual
+      raise Failure.new("Equality Failure", expected, actual)
+    end
+
+    # *assert_raises*, the pessimist.
+    #
+    # Succeeds if it catches an error AND that error is
+    # a `kind_of?` the `expected` error.
+    #
+    # Fails otherwise.
+    def assert_raises(expected=StandardError)
+      begin
+        yield
+      rescue => actual
+        return if actual.kind_of?(expected)
+        raise Failure.new("Failure: Unexpected Exception", expected, actual)
+      end
+      raise Failure.new("Failure: No Exception", expected, "Nothing raised.")
+    end
+  end
+
+  # ### Test ###
+  #
+  # An instance of test is basically only responsible for providing
+  # a scope within which to run a block.
+  #
+  # It includes the Assertions module so that the assertions
+  # methods are available to you inside your tests.
+  class Test
+    include Assertions
+
+    attr_reader :name
+
+    def initialize(name, &block)
+      @name = name
+      @block = block
+    end
+
+    def run
+      instance_eval &@block
+    end
+  end
+
+  # Set up some constants to represent test outcomes.
+  SUCCEEDED = :success
+  FAILED = :failure
+  RAISED = :exception
+
+  # ### Result ###
+  #
+  # A tidy little place to store test result information.
+  # The values should be self-explanatory.
+  Result = Struct.new(:name, :status, :elapsed, :exception)
+
+
+  # ### Results ###
+  #
+  # A collection class that keeps track of test results.
+  class Results
+    attr_reader :count, :elapsed, :results
+
+    # It starts out with everything zeroed out.
+    def initialize
+      @count = 0
+      @elapsed = 0
+      @results = []
+    end
+
+    # Collects incoming `result`s and updates `count` and `elapsed`
+    # to reflect the new `result`.
+    def <<(result)
+      @count += 1
+      @elapsed += result.elapsed
+      results << result
+    end
+
+    # Accessors to pull out the subset of tests you need.
+    def successes; results.select { |r| r.status == SUCCEEDED } end
+    def failures; results.select { |r| r.status == FAILED } end
+    def exceptions; results.select { |r| r.status == RAISED } end
+  end
+
+  # ### Runner ###
+  #
+  # Collects and runs your tests.
+  class Runner
+    attr_reader :tests, :results, :reporter
+
+    # A new Runner accepts a Reporter instance, which it delegates
+    # to for displaying results. It defaults to the plain reporter.
+    #
+    # Look at 'lib/tst/reporters.rb' for more information on reporters.
+    def initialize(reporter=nil)
+      @tests = []
+      @results = Results.new
+      @reporter = reporter || Reporters::Plain.new
+    end
+
+    # Collects incoming tests.
+    def <<(test)
+      tests << test
+    end
+
+    # Runs all the tests it has and then hands control
+    # over to `reporter` to tell you about it.
+    def run!
+      tests.each { |test| run_test(test) }
+      reporter.summarize(results)
+    end
+
+    # The actual machinery for running a test.
+    def run_test(test)
+      start = Time.now
+      test.run
+      status = SUCCEEDED
+    rescue Failure => exception
+      status = FAILED
+    rescue StandardError => exception
+      status = RAISED
+    ensure
+      elapsed = Time.now - start
+      record(test.name, status, elapsed, exception)
+    end
+
+    # Adds a result to `results` and calls the `success`,
+    # `failure`, or `exception` method on `reporter` so
+    # it can show you your results as they come in.
+    def record(name, status, elapsed, exception=nil)
+      result = Result.new(name, status, elapsed, exception)
+      results << result
+      reporter.send(status, result)
+    end
+  end
+
+  # ### FileRunner ###
+  #
+  # A little wrapper class (around a Runner) to allow
+  # for easily running tests that are in files.
+  class FileRunner
+    attr_reader :runner
+
+    # Runs the tests in the files represented by `glob`.
+    #
+    # `glob`: is any string that `Dir.glob` knows how to handle.
+    #
+    # Accepts the following options:
+    #   `:reporter`:   any object that responds_to the reporter
+    #                  interface
+    #                  (see 'lib/tst/reporters.rb' for details)
+    #
+    #   `:load_paths`: an Array of directories to be added to
+    #                  the load path before running the tests.
+    #
+    # Note that `run` makes a new Runner each time it's called,
+    # allowing it to be called several times on the same
+    # FileRunner instance while still doing the right thing.
+    def run(glob, options={})
+      @runner = Runner.new options[:reporter]
+      load_files(glob, options[:load_paths] || [])
+      runner.run!
+    end
+
+    # Collects incoming tests and hands them off to the `runner`.
+    def <<(test)
+      runner << test
+    end
+
+    # Modifies the load path if necessary and loads all the
+    # test files.
+    def load_files(glob, load_paths)
+      load_paths.each { |path| $:.unshift(path) }
+      Dir[glob].each { |file| load(file, true) }
+    end
+  end
+
+  # Module-level accessor to a FileRunner instance.
+  def self.file_runner
+    @file_runner ||= FileRunner.new
+  end
+
+  # Hands a test off to `file_runner`. This is called by
+  # the top-level `tst` method (i.e., the one you use to
+  # write your tests with).
+  def self.add_test(name, &block)
+    file_runner << Test.new(name, &block)
+  end
+
+  # The module-level API entry point.
+  #
+  # An example from Tst's own Rakefile:
+  #
+  #     task :test do
+  #       Tst.run 'test/*.rb',
+  #         :load_paths => ['.', 'lib'],
+  #         :reporter => Tst::Reporters::Pretty.new
+  #     end
+  def self.run(glob, options={})
+    file_runner.run(glob, options)
+  end
+end
+
+# The `tst` method.
+#
+# Acts as proxy to `Tst.add_test`. This is the method you
+# actually call as a consumer of the library.
+#
+#     tst "the answer is correct" do
+#       answer = Answer.new
+#       assert_equal 42, answer
+#     end
+def tst(name=nil, &block)
+  Tst.add_test(name, &block)
+end

data/test/assertions.rb

@@ -0,0 +1,61 @@
+# :assert
+
+tst "assert(nil) raises" do
+  assert_raises Tst::Failure do
+    assert nil
+  end
+end
+
+tst "assert(false) raises" do
+  assert_raises Tst::Failure do
+    assert false
+  end
+end
+
+tst "assert(true) does NOT raise" do
+  assert true
+end
+
+tst "assert(0) does NOT raise" do
+  assert 0
+end
+
+tst "assert('') does NOT raise" do
+  assert 'asdf'
+end
+
+
+# :assert_equal
+
+tst "assert_equal raises if things are NOT ==" do
+  assert_raises Tst::Failure do
+    assert_equal "Arthur Dent", "Ford Prefect"
+  end
+end
+
+tst "assert_equal does NOT raise if things are ==" do
+  assert_equal 42, 42
+end
+
+
+# :assert_raises
+
+tst "assert_raises raises if its block does NOT raise something" do
+  assert_raises Tst::Failure do
+    assert_raises { }
+  end
+end
+
+tst "assert_raises raises if its block doesn't raise the right thing" do
+  assert_raises Tst::Failure do
+    assert_raises(NameError) { raise RuntimeError }
+  end
+end
+
+tst "assert_raises does NOT raise if it gets the expected error" do
+  assert_raises(NameError) { raise NameError }
+end
+
+tst "assert_raises does NOT raise on expected error subclass" do
+  assert_raises(ArgumentError) { raise Class.new(ArgumentError) }
+end

data/test/fixtures/exception.rb

@@ -0,0 +1,3 @@
+tst "one 'exceptional' test" do
+  raise "I'm a teapot"
+end

data/test/fixtures/failure.rb

@@ -0,0 +1,3 @@
+tst "one failing test" do
+  assert false
+end

data/test/fixtures/success.rb

@@ -0,0 +1,3 @@
+tst "one passing test" do
+  assert true
+end

data/test/plain_reporter.rb

@@ -0,0 +1,56 @@
+require 'stringio'
+
+def tst_runner_output(glob, expected)
+  tst "running #{glob}" do
+    io = StringIO.new('')
+    reporter = Tst::Reporters::Plain.new(io)
+    Tst.run glob, :reporter => reporter
+    assert_equal expected, io.string.gsub(/0\.\d+/, 'X.XXX')
+  end
+end
+
+tst_runner_output "test/fixtures/success.rb", <<-end
+.
+Ran 1 tests in X.XXXs: 1 passed, 0 failed, 0 raised.
+end
+
+tst_runner_output "test/fixtures/failure.rb", <<-end
+F
+F1: Failure: Truthiness - \"one failing test\"
+  exp: \"not false or nil\"
+  got: false
+* test/fixtures/failure.rb:2:in `block in <top (required)>'
+* test/plain_reporter.rb:7:in `block in tst_runner_output'
+
+Ran 1 tests in X.XXXs: 0 passed, 1 failed, 0 raised.
+end
+
+tst_runner_output "test/fixtures/exception.rb", <<-end
+E
+E1: #<RuntimeError: I'm a teapot> - \"one 'exceptional' test\"
+* test/fixtures/exception.rb:2:in `block in <top (required)>'
+* test/plain_reporter.rb:7:in `block in tst_runner_output'
+
+Ran 1 tests in X.XXXs: 0 passed, 0 failed, 1 raised.
+end
+
+tst_runner_output "test/fixtures/{exception,success,failure}.rb", <<-end
+E.F
+F1: Failure: Truthiness - \"one failing test\"
+  exp: \"not false or nil\"
+  got: false
+* test/fixtures/failure.rb:2:in `block in <top (required)>'
+* test/plain_reporter.rb:7:in `block in tst_runner_output'
+
+E1: #<RuntimeError: I'm a teapot> - \"one 'exceptional' test\"
+* test/fixtures/exception.rb:2:in `block in <top (required)>'
+* test/plain_reporter.rb:7:in `block in tst_runner_output'
+
+Ran 3 tests in X.XXXs: 1 passed, 1 failed, 1 raised.
+end
+
+tst_runner_output "test/fixtures/does_not_exist.rb", <<-end
+
+Ran 0 tests in X.XXXs: 0 passed, 0 failed, 0 raised.
+end
+

data/test/test.rb

@@ -0,0 +1,23 @@
+# One nice thing is that each test gets a fresh scope,
+# which helps mitigate state leakage...
+tst "tests don't have access to top-level instance variables" do
+  @outside = "I'm outside"
+
+  Tst::Test.new "instance variable" do
+    @outside = "I'm inside, muahahaha!"
+  end.run
+
+  assert_equal "I'm outside", @outside
+end
+
+# ... but ruby block scope can be a bitch.
+tst "for better or for worse, local variables are fair game" do
+  outside = "I'm outside"
+
+  Tst::Test.new "local variable" do
+    outside = "I'm inside, muahahaha!"
+  end.run
+
+  assert_equal "I'm inside, muahahaha!", outside
+end
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: tst
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Arun Srinivasan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-26 00:00:00.000000000 Z
+dependencies: []
+description: A small testing library that tries not to do too much.
+email: satchmorun@gmail.com
+executables:
+- tst
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- Rakefile
+- bin/tst
+- lib/tst/reporters/plain.rb
+- lib/tst/reporters/pretty.rb
+- lib/tst/reporters.rb
+- lib/tst.rb
+- test/assertions.rb
+- test/fixtures/exception.rb
+- test/fixtures/failure.rb
+- test/fixtures/success.rb
+- test/plain_reporter.rb
+- test/test.rb
+homepage: http://github.com/satchmorun/tst
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A small testing library that tries not to do too much.
+test_files:
+- test/assertions.rb
+- test/fixtures/exception.rb
+- test/fixtures/failure.rb
+- test/fixtures/success.rb
+- test/plain_reporter.rb
+- test/test.rb