testify 0.0.0 → 1.0.0

data/.rspec

@@ -0,0 +1 @@
+-c

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+
+gem 'classy'
+
+group :development do
+  gem 'jeweler'
+end
+
+group :test do
+  gem 'rspec'
+end

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 John Hyland and Emily Price
+Copyright (c) 2010 John Hyland
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -2,6 +2,105 @@
 
 Testify is a test framework framework.  Think "Rack for testing."
 
+== Overview
+
+Like Rack, Testify is typically going to be run as a stack of applications that
+implement a +call+ method.  In typical usage, the stack will be assembled by a
+Runner and consist of a Framework and optionally some middleware, but this
+isn't a requirement.
+
+The source and detailed documentation can be found at
+http://github.com/djspinmonkey/testify and
+http://rdoc.info/projects/djspinmonkey/testify, respectively.
+
+== Testify Applications
+
+A Testify Application is any object that implements a +call+ method accepting a
+single argument.  The one argument will be a hash (canonically called env), and
+the return value should be an array of TestResult objects.
+
+=== The +env+ Hash
+
+The +env+ hash should be an instance of Hash with one of the following keys
+defined:
+
+[:files] an array of filenames containing the tests
+[:path] a path containing the files containing the tests
+
+In addition, all of the following keys should be defined:
+
+[:testify_version] An array of integers representing this version of Testify
+[:hooks] A hash of callbacks - see below.
+
+Given that Testify is still at a fairly early stage of development, it is quite
+possible that more required keys will be added later.
+
+=== Middleware
+
+Middleware will generally either modify the env hash before the framework gets
+it (eg, to execute only a subset of tests), or modify the TestResult objects on
+the way back out (eg, to colorize the result text).  If you want to respond to
+a particular event as it happens (eg, send a Growl notification when a test
+fails), it is probably best to do this by adding a hook rather than looking at
+the returned TestResult objects, since call() will not return until all the
+tests have finished running.
+
+=== Frameworks
+
+A Framework object is responsible for actually running the tests and generating
+TestResult objects.  Frameworks are required to respect all of the hooks
+described below.  Generally, Frameworks should inherit from
+Testify::Framework::Base and should have at least one alias in order to benefit
+from all of Testify's built-in functionality, but neither of these is a
+requirement.  (See the Aliasable module in the Classy gem for a more thorough
+description of aliases.  http://github.com/djspinmonkey/classy)
+
+At least initially, most Framework classes will likely be adaptors for existing
+test frameworks (RSpec, Test::Unit, etc).
+
+=== Hooks
+
+env[:hooks] is a hash containing arrays of callable objects (usually Procs,
+but anything responding to +call+ will work) which will be called in specific
+circumstances.  The following keys should supported:
+
+[:before_all]  Will be called before running any tests.  An array of Test
+               objects will be passed in.  A middleware app might use this hook
+               instead of simply running immediately if it needed access to
+               individual tests instead of just files, or if it needed to run
+               after all other middleware.  For example, if some other
+               middleware later in the stack were excluding some subset of tests
+               from running, you might need to be sure you were operating only
+               on the tests that would actually be run.
+[:after_all]   Will be called after running all tests.  An array of TestResult
+               objects will be passed in.  Middleware setting this hook should
+               probably just work with the array of TestResults returned from
+               calling the next Testify app on the stack instead, unless it
+               needs to run before the results pass through any other
+               middleware.  Note that there is no guarantee another hook may not
+               be added prior to yours, however.
+[:before_each] Will be called before running each individual test.  A single
+               Test object will be passed in.  
+[:after_each]  Will be called after running each individual test.  A single
+               TestResult object will be passed in.  
+[:after_status] Points to a hash containing symbols as the keys, and arrays of
+                callable objects to be called whenever a TestResult is generated
+                with the status corresponding to that symbol.  The TestResult
+                will be passed in.
+
+If using the values provided by +Testify.env_defaults+, values for the first
+four keys will be initialized to empty arrays, and +:after_status+ will be
+initialized to an empty hash.
+
+Like the +env+ hash, this is highly subject to change at this point.
+
+== TODO
+
+* Write adaptors for common test frameworks (rspec and minitest first, probably).
+* Write an autotest-like Runner
+* Write some useful middleware (growl notifications, colorized output, etc)
+* World domination!
+
 == Note on Patches/Pull Requests
  
 * Fork the project.
@@ -15,4 +114,4 @@ Testify is a test framework framework.  Think "Rack for testing."
 
 == Copyright
 
-Copyright (c) 2009 John Hyland and Emily Price. See LICENSE for details.
+Copyright (c) 2010 John Hyland. See LICENSE for details.

data/Rakefile

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'rake'
+require 'rspec/core/rake_task'
 
 begin
   require 'jeweler'
@@ -9,7 +10,8 @@ begin
     #gem.description = %Q{TODO: longer description of your gem}
     gem.email = "github@djspinmonkey.com"
     gem.homepage = "http://github.com/djspinmonkey/testify"
-    gem.authors = ["John Hyland", "Emily Price"]
+    gem.authors = ["John Hyland"]
+    gem.add_dependency "classy", ">= 1.0.0"
     gem.add_development_dependency "rspec", ">= 1.2.9"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
@@ -18,28 +20,27 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
+RSpec::Core::RakeTask.new do |t|
 end
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
 end
 
-task :spec => :check_dependencies
+task :spec
 
 task :default => :spec
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "testify #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+# This is generating some annoying warnings - commented out for now until I
+# figure out how to quiet it down.
+#
+#require 'rdoc/task'
+#RDoc::Task.new do |rdoc|
+#  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+#
+#  rdoc.rdoc_dir = 'rdoc'
+#  rdoc.title = "testify #{version}"
+#  rdoc.rdoc_files.include('README*')
+#  rdoc.rdoc_files.include('lib/**/*.rb')
+#end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/framework.rb

@@ -0,0 +1,115 @@
+module Testify
+  # The module which all Framework classes are recommended to inherit.
+  # Framework provides a few utility methods and a means to keep track of all
+  # Framework classes (via Aliasable).  Framework objects are Testify apps, so
+  # subclasses must implement a +call+ method as described in the README.rdoc
+  # file.  It is also good practice to declare at least one alias (see the
+  # Aliasable module in the Classy gem for more details).
+  #
+  module Framework
+    include Aliasable
+
+    # The default set of statuses
+    #
+    DEFAULT_STATUSES = [ :passed, :pending, :failed, :error ]
+
+    # Extend the ClassMethods module and set the default statuses.
+    #
+    # :nodoc:
+    #
+    def self.included( klass )
+      klass.extend Testify::Framework::ClassMethods
+      klass.statuses *Testify::Framework::DEFAULT_STATUSES.dup
+      super
+    end
+
+    # Returns an array of absolute paths to each file defined by an +env+
+    # hash.  The default implementation either returns the array of files, if
+    # :files is defined in the hash, or returns every file found in a
+    # traversal of the path in the :path key.  Raises an exception if neither
+    # is defined, since that is not a valid +env+ hash.
+    #
+    # If a particular framework should only process files with names matching
+    # a particular glob pattern (eg, RSpec only wants files that match
+    # `*_spec.rb`), it can specify this with +file_pattern+.
+    #
+    def files( env )
+      return env[:files] if env.include? :files
+      raise(ArgumentError, "env hash must include either :files or :path") unless env.include? :path
+
+      file_glob = self.class.class_eval { @file_pattern } || '*'
+      Dir.glob(File.join(env[:path], '**', file_glob))
+    end
+
+    # Run all the appropriate hooks before running any tests at all.
+    #
+    def run_before_all_hooks( env )
+      env[:hooks][:before_all].each { |hook| hook.call }
+    end
+
+    # Run all the appropriate hooks before running each test.
+    #
+    def run_before_each_hooks( env )
+      env[:hooks][:before_each].each { |hook| hook.call }
+    end
+
+    # Run all the appropriate hooks after running all the tests
+    #
+    def run_after_all_hooks( env, results )
+      env[:hooks][:after_all].each { |hook| hook.call(results) }
+    end
+
+    # Run all the appropriate hooks after running each test individually
+    # (including the hooks for a particular status).
+    #
+    def run_after_each_hooks( env, result )
+      hooks = env[:hooks][:after_each]
+      hooks += env[:hooks][:after_status][result.status].to_a  # .to_a in case it's nil
+      hooks.each { |hook| hook.call(result) }
+    end
+
+    module ClassMethods
+      # Gets and sets an array of symbols corresponding to the possible
+      # TestResult statuses that might be set by this Framework.
+      #
+      # For example, a framework with tests that can only pass or fail might
+      # like like this:
+      #
+      #   class SomeFramework 
+      #     include Testify::Framework
+      #
+      #     statuses :passed, :failed
+      #
+      #     ...
+      #   end
+      #
+      #   SomeFramework.statuses  # => [ :passed, :failed ]
+      #
+      def statuses( *new_statuses )
+        if new_statuses.any?
+          @statuses = new_statuses
+        end
+        @statuses
+      end
+
+      # Accepts a glob pattern that limits the paths returned by `#files`.
+      # Only paths with filenames that match this pattern will be returned by
+      # +.files+.
+      #
+      # For example, if all your framework's test files should end in
+      # _mytests.rb, you might do this:
+      #
+      #   class MyTestFramework
+      #     include Testify::Framework
+      #
+      #     file_pattern '*_mytests.rb'
+      #
+      #     ...
+      #   end
+      #
+      def file_pattern( pattern )
+        self.class_eval { @file_pattern = pattern }
+      end
+    end
+  end
+end

data/lib/middleware.rb

@@ -0,0 +1,20 @@
+module Testify
+  module Middleware
+    include Aliasable
+
+    # By default, Testify middleware is initialized with only the next app on
+    # the stack.  If you override this, you may also need to override
+    # Runner.construct_app_stack.
+    #
+    def initialize(app)
+      @app = app
+    end
+
+    # By default, the middleware base class just calls the next app on the
+    # stack - you will almost certainly want to override this method.
+    #
+    def call(env)
+      @app.call(env)
+    end
+  end
+end

data/lib/runner.rb

@@ -0,0 +1,138 @@
+module Testify
+
+  # Runner is a Testify app intended to sit at the top of a Testify stack and
+  # provide a simple mechanism for running a set of tests.  If you're writing
+  # an autotest-like application, Runner is what you would use.  Runner uses
+  # Templatable from the Classy gem, so you can either subclass Runner and use
+  # DSL-like class methods to define its behavior, or instantiate it directly
+  # and configure the instance.
+  #
+  # For example,
+  #
+  #     class SampleRunner
+  #       include Testify::Runner
+  #
+  #       framework :rspec
+  #       middleware :growl, :red_green
+  #     end
+  #
+  #     @runner = SampleRunner.new
+  #
+  # would be equivalent to
+  #
+  #     @runner = Testify::Runner::Base.new
+  #     @runner.framework = Testify::Framework::RspecAdaptor
+  #     @runner.middleware = [Testify::Middleware::Growl, Testify::Middleware::RedGreen]
+  #
+  # Which approach is best depends on your needs, or you can use a mixture of
+  # the two.
+  #
+  module Runner
+    def self.included( klass )
+      klass.class_eval do
+        extend Templatable
+        extend Testify::Runner::ClassMethods
+
+        attr_accessor :status, :framework_instance, :test_results
+        templatable_attr :framework, :middleware
+
+        @@middleware = []
+      end
+      super
+    end
+
+    # Allows the framework to be specified on an instance of Runner.  See +.framework+.
+    #
+    def framework= (fw)
+      @framework = Testify::Framework::Base.find(fw)
+    end
+
+    # Allows the middleware array to be specified for an instance of Runner.  See +.middleware+.
+    #
+    # Note: The class method accepts a list, but the instance method must be passed an actual array.
+    #
+    # Example:
+    #
+    #     runner = YourRunner.new
+    #     runner.middleware = [:dots, :colorize]
+    #
+    def middleware=( middleware )
+      @middleware = middleware.map { |mw| Testify::Middleware.find(mw) }
+    end
+
+    # Constructs the stack of middleware and framework.  If you are doing
+    # something unconventional (eg, creating middleware that requires
+    # additional initialization parameters), you may need to override this
+    # method.
+    #
+    def construct_app_stack
+      @framework_instance ||= framework.new
+      top_app = @framework_instance
+
+      middleware.each do |mw_class|
+        top_app = mw_class.new(top_app)
+      end
+
+      top_app
+    end
+
+    # Run the tests.  Accepts a hash that will be merged in to the default env
+    # and passed to the Testify app stack.
+    #
+    def run( options = {} )
+      top_app = construct_app_stack
+
+      env = Testify.env_defaults.merge options
+      @test_results = top_app.call(env)
+
+      @status = @test_results.collect(&:status).max  # XXX: Optimize?
+
+      @test_results
+    end
+
+    module ClassMethods
+      # Defines and/or returns the framework to use.  This can be any class whose
+      # instances are Testify apps, and an instance of this class will be placed
+      # at the bottom of the Testify stack used by Runner#run.  Typically, this
+      # will probably be a test framework built on Testify or (more likely, at
+      # least for now) a Testify adaptor for some existing framework.  If the
+      # class descends from Testify::Framework::Base and defines an alias (eg,
+      # aka :rspec), you may use that alias instead of passing in the actual
+      # class.
+      #
+      # Example:
+      #
+      #     class YourRunner < Testify::Runner::Base
+      #       framework :rspec
+      #     end
+      #     @runner = YourRunner.new
+      #     @runner.framework         # <= Testify::Framework::RspecAdaptor
+      #
+      # Note that you can also specify the framework on an instance, using
+      # +#framework=+.
+      #
+      #     @runner = Testify::Runner.new
+      #     @runner.framework YourAwesomeTestifyFrameworkClass
+      #
+      def framework( fw = nil )
+        self.framework = Testify::Framework.find(fw) if fw
+        self.send(:class_variable_get, :@@framework)
+      end
+
+      # Defines and/or returns the middleware to use, in the same manner as
+      # +.framework+.  Note that this completely replaces any previous
+      # middleware specified for this class.
+      #
+      # Example:
+      #
+      #     class YourRunner < Testify::Runner::Base
+      #       middleware :dots, :colorize
+      #     end
+      #
+      def middleware( *middlewares )
+        self.middleware = middlewares.map { |mw| Testify::Middleware.find(mw) } unless middlewares.empty?
+        self.send(:class_variable_get, :@@middleware)
+      end
+    end
+  end
+end

data/lib/test_result.rb

@@ -0,0 +1,18 @@
+module Testify
+
+  # A TestResult object represents the results of running a single test,
+  # whatever that means in the context of your framework.
+  #
+  class TestResult
+    attr_accessor :status, :message, :file, :line
+
+    def initialize (options = {})
+      @status   = options[:status]
+      @message  = options[:message]
+      @file     = options[:file]
+      @line     = options[:line]
+    end
+
+  end
+
+end

data/lib/testify.rb

@@ -0,0 +1,41 @@
+# gems
+require 'classy'
+
+# Make sure we're grabbing the right version of everything.
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'framework'
+require 'runner'
+require 'middleware'
+require 'test_result'
+
+# Put the LOAD_PATH back the way it was.
+$LOAD_PATH.shift
+
+# The Testify module provides some general-purpose functions that aren't
+# specific to any single component.
+module Testify
+
+  # Provides some reasonable defaults to create a new env hash.  This method
+  # does not fill in :path or :files, so you'll need to explicitly specify one
+  # or the other.
+  #
+  def self.env_defaults
+    { :testify_version => Testify.version,
+      :hooks => { :before_all => [], 
+                  :after_all => [], 
+                  :before_each => [], 
+                  :after_each => [], 
+                  :after_status => {},
+                }
+    }
+  end
+
+  # Returns the current version as an array.  (Eg, version 1.2.3 would be
+  # returned as [1, 2, 3].)
+  #
+  def self.version
+    File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp.split('.').collect { |n| n.to_i }
+  end
+
+end

data/samples/README

@@ -0,0 +1,9 @@
+This is a sample Testify-based setup.  The framework is called (imaginatively
+enough) AwesomeTestFramework - this is the same level as RSpec or minitest.
+The runner is called AwesomeRunner - think of the 'rspec' command or
+'autotest'.  And for flavor we've added some middleware to output valuable
+information while the tests run and append some footer text at the end.
+
+To see it in action, just run this:
+
+  ./awesome_runner.rb awesome_tests

data/samples/awesome_runner.rb

@@ -0,0 +1,28 @@
+require_relative '../lib/testify'
+require_relative 'awesome_test_framework'
+require_relative 'dots'
+require_relative 'summary'
+
+class AwesomeRunner
+  include Testify::Runner
+
+  # Specify the framework we want to use.  This alias is defined in
+  # AwesomeTestFramework.
+  #
+  framework :awesome
+
+  # Specify the middleware.  Again, this is defined in RadMiddleware.
+  #
+  middleware :summary, :dots
+end
+
+# Instantiate the runner and run the tests.
+#
+tests_path = File.join(File.dirname(__FILE__), 'awesome_tests')
+@runner = AwesomeRunner.new
+results = @runner.run(:path => tests_path)
+
+#puts "#{results.size} tests run"
+#results.each do |res|
+#  puts "#{res.status} - #{res.message}"
+#end

data/samples/awesome_test_framework.rb

@@ -0,0 +1,51 @@
+# A sample test framework built using Testify.
+#
+class AwesomeTestFramework
+  include Testify::Framework
+
+  # Specify an alias for this framework.
+  #
+  aka :awesome
+
+  # These are the statuses this framework might return, in increasing order of severity.
+  #
+  statuses :pass, :fail, :error
+
+  # This is what a test file for this framework looks like.
+  #
+  file_pattern '*.aws'
+
+  # This is where you do your thing.  In a real test framework, you'd probably
+  # be testing assertions and setting up contexts and generally making the
+  # magic happen here (or at least calling the libraries where the magic
+  # happens).  
+  #
+  # In this example, we're just reading test results out of a file and calling
+  # the appropriate hooks.
+  #
+  def call( env )
+    results = []
+
+    run_before_all_hooks(env)
+
+    files(env).each do |file|
+      open file do |f|
+        f.lines.each_with_index do |line, line_number|
+          run_before_each_hooks(env)
+
+          message, status = * line.split(':')
+          status = status.strip.to_sym
+          result = Testify::TestResult.new( :file => file, :line => line_number, :message => message, :status => status )
+          results << result
+
+          run_after_each_hooks(env, result)
+        end
+      end
+    end
+
+    run_after_all_hooks(env, results)
+
+    results
+  end
+
+end

data/samples/awesome_tests/asplode.aws

@@ -0,0 +1,3 @@
+five should be an integer: pass
+love should be in the air: pass
+garble barf: asplode

data/samples/awesome_tests/failing.aws

@@ -0,0 +1,3 @@
+axioms should not be testable: pass
+goods should be fungible: pass
+this framework should be awesome: fail

data/samples/awesome_tests/passing.aws

@@ -0,0 +1,3 @@
+true should be true: pass
+1 + 1 should equal 2: pass
+this test should pass: pass

data/samples/dots.rb

@@ -0,0 +1,31 @@
+# Output a dot every time a test passes, an F when it fails, or a E on an
+# error.  On any other status, it prints a ?.
+#
+class Dots 
+  include Testify::Middleware
+
+  aka :dots
+
+  def call( env )
+    # Output dots (et al) as each test runs.
+    #
+    env[:hooks][:after_each].push(lambda do |result|
+      case result.status
+      when :pass
+        print '.'
+      when :fail
+        print 'F'
+      when :error
+        print 'E'
+      else
+        print '?'
+      end
+    end)
+
+    # Output a couple newlines at the end after all the tests have run.
+    #
+    env[:hooks][:after_all].push(lambda { |ignored| puts; puts })
+
+    @app.call(env)
+  end
+end

data/samples/summary.rb

@@ -0,0 +1,19 @@
+# Output a summary of the test results after they've all been run.
+#
+class Summary 
+  include Testify::Middleware
+
+  aka :summary
+
+  def call( env )
+    results = @app.call(env)
+
+    summary = Hash.new(0)
+    results.each { |res| summary[res.status] += 1 }
+
+    puts "Ran #{results.size} tests in all"
+    summary.each { |status, count| puts "#{count} tests with status #{status}" }
+
+    results
+  end
+end

data/spec/framework_spec.rb

@@ -0,0 +1,81 @@
+require_relative 'spec_helper'
+
+describe "Testify::Framework" do
+
+  before :all  do
+    Testify::Framework.forget_aliases
+
+    destroy_class :VanillaFramework
+    class VanillaFramework 
+      include Testify::Framework
+      aka :vanilla
+    end
+    @framework = VanillaFramework.new
+  end
+
+  it "should be able to specify known aliases" do
+    Testify::Framework.find(:vanilla).should equal VanillaFramework
+  end
+
+  it "should raise an ArgumentError if a given alias is already taken" do
+    lambda {
+      class ThisIsTheRepeat 
+        include Testify::Framework
+        aka :vanilla
+      end
+    }.should raise_error(ArgumentError)
+
+  end
+
+  it "should be able to specify a status ranking without affecting other Frameworks" do
+    class ChangedFramework 
+      include Testify::Framework
+      statuses :passed, :failed, :exploded
+    end
+
+    VanillaFramework.statuses.should eql Testify::Framework::DEFAULT_STATUSES
+    ChangedFramework.statuses.should eql [ :passed, :failed, :exploded ]
+  end
+
+  context '#files' do
+    before do 
+      @test_path = File.join(File.dirname(__FILE__), "sample_tests")
+      all_files = ['failing_tests', 'mixed_tests', 'passing_tests', 'test_helper']
+      test_files = all_files - ['test_helper']
+      @all_paths  = all_files.collect  { |f| File.join(File.dirname(__FILE__), 'sample_tests', f) }
+      @test_paths = test_files.collect { |f| File.join(File.dirname(__FILE__), 'sample_tests', f) }
+    end
+
+    after do
+      VanillaFramework.file_pattern nil
+    end
+
+    it "should find files specified by :path" do
+      env = { :path => @test_path }
+      @framework.files(env).sort.should eql @all_paths
+    end
+
+    it "should find files specified by :files" do
+      env = { :files => @all_paths }
+      @framework.files(env).sort.should eql @all_paths
+    end
+
+    it "should raise an ArgumentError if neither :files nor :path is defined" do
+      env = {}
+      lambda { 
+        @framework.files(env) 
+      }.should raise_exception ArgumentError
+    end
+
+    it "should respect the .file_pattern setting" do
+      class VanillaFramework
+        file_pattern '*_tests'
+      end
+
+      env = { :path => @test_path }
+      @framework.files(env).sort.should eql @test_paths
+    end
+  end
+
+end
+

data/spec/middleware_spec.rb

@@ -0,0 +1,5 @@
+require_relative 'spec_helper'
+
+describe "Testify::Middleware::Base" do
+  # It doesn't actually do anything that doesn't come from a module.
+end

data/spec/runner_spec.rb

@@ -0,0 +1,101 @@
+require_relative 'spec_helper'
+
+describe "Testify::Runner" do
+
+  before :each do
+    Testify::Middleware.forget_aliases
+    Testify::Framework.forget_aliases
+
+    destroy_class :SomeMiddleware
+    class SomeMiddleware
+      include Testify::Middleware
+      aka :some_middleware
+    end
+
+    destroy_class :SomeMoreMiddleware
+    class SomeMoreMiddleware
+      include Testify::Middleware
+      aka :more_middleware
+    end
+
+    destroy_class :SomeTestFramework
+    class SomeTestFramework
+      include Testify::Framework
+
+      aka :some_test_framework
+      attr_accessor :env
+
+      def call (env)
+        @env = env
+        [Testify::TestResult.new(:message => "Testing", :status => :pass)]
+      end
+    end
+
+    destroy_class :TestRunner
+    class TestRunner
+      include Testify::Runner
+    end
+    @runner = TestRunner.new
+
+    @test_path = File.expand_path(File.join(File.dirname(__FILE__), 'sample_tests'))
+  end
+
+  it "should be able to specify a test framework by alias" do
+    class TestRunner
+      framework :some_test_framework
+    end
+
+    TestRunner.framework.should eql SomeTestFramework
+    @runner.framework.should eql SomeTestFramework
+  end
+
+  it "should be able to specify a test framework by class" do
+    class TestRunner
+      framework SomeTestFramework
+    end
+
+    TestRunner.framework.should eql SomeTestFramework
+    @runner.framework.should eql SomeTestFramework
+  end
+
+  it "should be able to specify middleware by alias" do
+    class TestRunner
+      middleware :some_middleware, :more_middleware
+    end
+
+    TestRunner.middleware.should eql [SomeMiddleware, SomeMoreMiddleware]
+    @runner.middleware.should eql [SomeMiddleware, SomeMoreMiddleware]
+  end
+
+  context "#run" do
+    it "should accept options and put them in the env hash" do
+      framework = SomeTestFramework.new
+      @runner.framework_instance = framework
+      @runner.run :foo => 'bar'
+      framework.env[:foo].should == 'bar'
+    end
+  end
+
+  context "just created" do
+    it "should have a nil status" do
+      @runner.status.should be_nil
+    end
+  end
+
+  context "with a test framework defined" do
+    before do
+      @runner.framework = SampleFramework
+    end
+
+    context "after running" do
+      before do
+        test_path = File.join(File.dirname(__FILE__), "sample_tests")
+        @runner.run :path => test_path
+      end
+
+      it "should have a status" do
+        @runner.status.should_not be_nil
+      end
+    end
+  end
+end

data/spec/sample_framework.rb

@@ -0,0 +1,33 @@
+# A sample Testify framework intended to be used while testing Testify.  A
+# "test" consists of a line in the file, which should contain the status
+# and optionally a colon and a message.
+#
+# Example test file:
+#   fail:The thing is not in the place.
+#   success
+#   pending:Need to implement cat napkins.
+#   success
+#
+class SampleFramework 
+  include Testify::Framework
+
+  aka :sample
+
+  # Run the tests.
+  #
+  def call (env)
+    results = []
+
+    files(env).each do |file|
+      line_number = 0
+      File.open(file).each_line do |line|
+        line_number += 1
+        (status, message) = line.split(':')
+        results.push Testify::TestResult.new(:status => status.to_sym, :message => message, :file => file, :line => line_number)
+      end
+    end
+
+    results
+  end
+
+end

data/spec/sample_tests/failing_tests

@@ -0,0 +1,7 @@
+require 'spec_helper.rb'
+
+describe "Something broken" do
+  it "should fail" do
+    true.should be false
+  end
+end

data/spec/sample_tests/mixed_tests

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "Something that sorta works but is broken in parts" do
+  it "should pass some things" do
+    true.should be true
+  end
+
+  it "should fail others" do
+    "foo".should be "bar"
+  end
+end

data/spec/sample_tests/passing_tests

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "Something that works" do
+  it "should pass" do
+    true.should be true
+  end
+
+  it "should still pass" do
+    "foo".should == "foo"
+  end
+end

data/spec/sample_tests/test_helper

@@ -0,0 +1,5 @@
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+end

data/spec/spec_helper.rb

@@ -1,9 +1,14 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'testify'
-require 'spec'
-require 'spec/autorun'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'testify')
+require_relative '../lib/testify'
+require_relative 'sample_framework'
+require 'rspec'
 
-Spec::Runner.configure do |config|
-  
+RSpec.configure do |config|
+end
+
+# Doesn't work for anything inside a module (eg, if you try to remove
+# Testify::Framework::RSpec this will totally blow up).
+def destroy_class ( klass )
+  klass = klass.name.to_s if klass.kind_of? Class
+  Object.class_exec { remove_const klass } if Object.const_defined? klass
 end

data/spec/test_result_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe "Testify::TestResult" do
+  it "should be instantializable with a hash of attributes" do
+    res = Testify::TestResult.new(:file => 'woo_tests.rb', :line => 42, :status => :error, :message => "Your test asploded.")
+    res.status.should == :error
+    res.message.should == "Your test asploded."
+    res.file.should == 'woo_tests.rb'
+    res.line.should == 42
+  end
+end

data/spec/testify_spec.rb

@@ -1,7 +1,23 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 
 describe "Testify" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+
+  context '.env_defaults' do
+    it "should provide an env hash with some default values" do
+      defaults = Testify.env_defaults
+
+      # Verify the values on these ones
+      defaults[:testify_version].should == Testify.version
+      defaults[:hooks].should == { :before_all => [], :after_all => [], :before_each => [], :after_each => [], :after_status => {} }
+    end
   end
+
+  context '.version' do
+    it "should return an array of three integers" do
+      version = Testify.version
+      version.should have(3).parts
+      version.each { |n| n.should be_an Integer }
+    end
+  end
+
 end

metadata

@@ -1,28 +1,61 @@
 --- !ruby/object:Gem::Specification 
 name: testify
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors: 
 - John Hyland
-- Emily Price
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-11-02 00:00:00 -05:00
-default_executable: 
+date: 2011-10-31 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: classy
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: classy
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: 1.2.9
-    version: 
+  type: :development
+  prerelease: false
+  version_requirements: *id004
 description: 
 email: github@djspinmonkey.com
 executables: []
@@ -34,42 +67,62 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .document
-- .gitignore
+- .rspec
+- Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
+- VERSION
+- lib/framework.rb
+- lib/middleware.rb
+- lib/runner.rb
+- lib/test_result.rb
 - lib/testify.rb
-- spec/spec.opts
+- samples/README
+- samples/awesome_runner.rb
+- samples/awesome_test_framework.rb
+- samples/awesome_tests/asplode.aws
+- samples/awesome_tests/failing.aws
+- samples/awesome_tests/passing.aws
+- samples/dots.rb
+- samples/summary.rb
+- spec/framework_spec.rb
+- spec/middleware_spec.rb
+- spec/runner_spec.rb
+- spec/sample_framework.rb
+- spec/sample_tests/failing_tests
+- spec/sample_tests/mixed_tests
+- spec/sample_tests/passing_tests
+- spec/sample_tests/test_helper
 - spec/spec_helper.rb
+- spec/test_result_spec.rb
 - spec/testify_spec.rb
-has_rdoc: true
 homepage: http://github.com/djspinmonkey/testify
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Testify is a test framework framework.  Think "Rack for testing."
-test_files: 
-- spec/spec_helper.rb
-- spec/testify_spec.rb
+test_files: []
+

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/spec/spec.opts

@@ -1 +0,0 @@
---color