assert 0.1.0

data/lib/assert/result_set.rb

@@ -0,0 +1,14 @@
+module Assert
+  class ResultSet < ::Array
+
+    attr_accessor :view
+
+    def <<(result)
+      super
+      if @view && @view.respond_to?(:print_runtime_result)
+        @view.print_runtime_result(result)
+      end
+    end
+
+  end
+end

data/lib/assert/runner.rb

@@ -0,0 +1,60 @@
+require 'assert/view/terminal'
+
+module Assert
+  class Runner
+
+    # a Runner runs a suite of tests.
+
+    def initialize(suite, view)
+      raise ArgumentError if !suite.kind_of?(Suite)
+      @suite = suite
+      @view = view
+    end
+
+    def run(*args)
+      @suite.setup_blocks.each do |setup| # TODO: tests!
+        setup.call
+      end
+      @view.render do
+        benchmark { run_suite }
+      end
+      @suite.teardown_blocks.each do |teardown| # TODO: tests!
+        teardown.call
+      end
+      count(:failed) + count(:errored)
+    end
+
+    def count(type)
+      @suite.count(type)
+    end
+
+    protected
+
+    def tests_to_run
+      tests = @suite.tests
+
+      # order tests randomly
+      max = tests.size
+      srand
+      seed = srand % 0xFFFF
+      srand seed
+      tests.sort.sort_by { rand max }
+      tests
+    end
+
+    private
+
+    def benchmark
+      @suite.start_time = Time.now
+      yield if block_given?
+      @suite.end_time = Time.now
+    end
+
+    def run_suite
+      # TODO: parallel running
+      tests_to_run.each {|test| test.run(@view)}
+    end
+
+  end
+
+end

data/lib/assert/setup/autorun.rb

@@ -0,0 +1,34 @@
+require 'assert/runner'
+
+module Assert
+
+  # a flag to know if at_exit hook has been installed already
+  @@at_exit_installed ||= false
+
+  class << self
+
+    # install at_exit hook (if needed) (runs at process exit)
+    # this ensures the test suite won't run unitl all test files are loaded
+    # (this is essentially a direct rip from Minitest)
+    def autorun
+      at_exit do
+        # don't run if there was an exception
+        next if $!
+
+        # the order here is important. The at_exit handler must be
+        # installed before anyone else gets a chance to install their
+        # own, that way we can be assured that our exit will be last
+        # to run (at_exit stacks).
+
+        exit_code = nil
+        at_exit { exit(false) if exit_code && exit_code != 0 }
+        # TODO: read options from a config for extentions??
+        Runner.new(self.suite, self.view).run
+      end unless @@at_exit_installed
+      @@at_exit_installed = true
+    end
+
+  end
+
+end
+

data/lib/assert/setup/helpers.rb

@@ -0,0 +1,62 @@
+module Assert
+  module Helpers
+
+    # when Assert is required it will automatically require in two helper files
+    # if they exist:
+    # * "./test/helper.rb - package-specific helpers
+    # * ~/.assert.rb - user-specific helpers (options, view, etc...)
+    # the user-specific helper file will always be required in after the
+    # package-specific one
+
+    class << self
+
+      # assume the test dir path is ./test and look for helpers in ./test/helper.rb
+      PACKAGE_TEST_DIR = "test"
+      PACKAGE_HELPER_FILE = "helper"
+      TEST_REGEX = /^#{PACKAGE_TEST_DIR}$|^#{PACKAGE_TEST_DIR}\/|\/#{PACKAGE_TEST_DIR}\/|\/#{PACKAGE_TEST_DIR}$/
+
+      USER_TEST_HELPER = "~/.assert"
+
+      def load(caller_info)
+        if (crp = caller_root_path(caller_info))
+          require_package_test_helper(crp)
+        end
+        require_user_test_helper
+      end
+
+      private
+
+      def require_user_test_helper
+        begin
+          require File.expand_path(USER_TEST_HELPER)
+        rescue LoadError => err
+          # do nothing
+        end
+      end
+
+      # require the package's test/helper file if it exists
+      def require_package_test_helper(root_path)
+        begin
+          require package_helper_file(root_path)
+        rescue LoadError => err
+          warn err.message
+        end
+      end
+
+      def package_helper_file(root_path)
+        File.join(root_path, PACKAGE_TEST_DIR, PACKAGE_HELPER_FILE+'.rb')
+      end
+
+      # this method inspects the caller info and finds the caller's root path
+      # this expects the caller's root path to be the parent dir of the first
+      # parent dir of caller named TEST_DIR
+      def caller_root_path(caller_info)
+        caller_dirname = File.expand_path(File.dirname(caller_info[0]))
+        if (test_dir_pos = caller_dirname.index(TEST_REGEX)) > 0
+          root_dir = caller_dirname[0..(test_dir_pos-1)]
+        end
+      end
+    end
+
+  end
+end

data/lib/assert/setup/suite.rb

@@ -0,0 +1,12 @@
+require 'assert/context'
+require 'assert/suite'
+
+module Assert
+
+  # Setup the default global suite for collecting tests as contexts are defined
+  @@suite = Suite.new
+  class << self
+    def suite; @@suite; end
+  end
+
+end

data/lib/assert/setup/view.rb

@@ -0,0 +1,11 @@
+require 'assert/view/terminal'
+
+module Assert
+
+  # Setup the default view to render test results (override in user or package helpers)
+  @@view = View::Terminal.new(self.suite, $stdout)
+  class << self
+    def view; @@view; end
+  end
+
+end

data/lib/assert/suite.rb

@@ -0,0 +1,128 @@
+require 'assert/test'
+
+module Assert
+  class Suite < ::Hash
+
+    # A suite is a set of tests to run.  When a test class subclasses
+    # the Context class, that test class is pushed to the suite.
+
+    attr_accessor :start_time, :end_time, :setup_blocks, :teardown_blocks
+
+    def run_time
+      (@end_time || 0) - (@start_time || 0)
+    end
+
+    def <<(context_klass)
+      # gsub off any trailing 'Test'
+      self[context_klass] ||= []
+    end
+
+    def contexts
+      self.keys.sort{|a,b| a.to_s <=> b.to_s}
+    end
+
+    def tests
+      prep
+      self.values.flatten
+    end
+
+    def ordered_tests(klass=nil)
+      prep
+      (klass.nil? ? self.contexts : [klass]).inject([]) do |tests, klass|
+        tests += (self[klass] || [])
+      end
+    end
+
+    def ordered_results(klass=nil)
+      ordered_tests(klass).inject([]) do |results, test|
+        results += test.results
+      end
+    end
+
+    def test_count(klass=nil)
+      prep
+      count_tests(klass.nil? ? self.values : [self[klass]])
+    end
+
+    def result_count(type=nil)
+      prep
+      count_results(self.values, type)
+    end
+
+    def count(thing)
+      case thing
+      when :tests
+        test_count
+      when :results
+        result_count
+      when :passed, :pass
+        result_count(:pass)
+      when :failed, :fail
+        result_count(:fail)
+      when :ignored, :ignore
+        result_count(:ignore)
+      when :skipped, :skip
+        result_count(:skip)
+      when :errored, :error
+        result_count(:error)
+      else
+        0
+      end
+    end
+
+    def setup_blocks
+      @setup_blocks ||= []
+    end
+
+    def teardown_blocks
+      @teardown_blocks ||= []
+    end
+
+    # TODO: tests!
+    def setup(&block)
+      raise ArgumentError, "please provide a setup block" unless block_given?
+      self.setup_blocks << block
+    end
+
+    # TODO: tests!
+    def teardown(&block)
+      raise ArgumentError, "please provide a teardown block" unless block_given?
+      self.teardown_blocks << block
+    end
+
+    protected
+
+    def local_public_test_methods(klass)
+      methods = klass.public_instance_methods
+      while (klass.superclass)
+        methods -= (klass = klass.superclass).public_instance_methods
+      end
+      methods.delete_if {|method_name| method_name !~ /^test./ }
+    end
+
+    private
+
+    def count_tests(test_sets)
+      test_sets.inject(0) {|count, tests| count += tests.size}
+    end
+
+    def count_results(test_sets, type)
+      self.values.flatten.inject(0){|count, test| count += test.result_count(type) }
+    end
+
+    def prep
+      if @prepared != true
+        # look for local public methods starting with 'test_'and add
+        self.each do |context_class, tests|
+          local_public_test_methods(context_class).each do |meth|
+            tests << Test.new(meth.to_s, context_class, meth)
+          end
+          tests.uniq
+        end
+      end
+      @prepared = true
+    end
+
+  end
+
+end

data/lib/assert/test.rb

@@ -0,0 +1,90 @@
+require 'assert/result'
+require 'assert/result_set'
+
+module Assert
+  class Test
+
+    # a Test is some code/method to run in the scope of a Context.  After a
+    # a test runs, it should have some assertions which are its results.
+
+    attr_reader :name, :code, :context_class
+    attr_accessor :results
+
+    def initialize(name, context_class, code = nil, &block)
+      @context_class = context_class
+      @name = name_from_context(name)
+      @code = (code || block)
+      @results = ResultSet.new
+    end
+
+    def run(view=nil)
+      @results.view = view
+      begin
+        run_scope = @context_class.new(self)
+        run_setup(run_scope)
+        if @code.kind_of?(::Proc)
+          run_scope.instance_eval(&@code)
+        elsif run_scope.respond_to?(@code.to_s)
+          run_scope.send(@code.to_s)
+        end
+      rescue Result::TestSkipped => err
+        @results << Result::Skip.new(self.name, err)
+      rescue Exception => err
+        @results << Result::Error.new(self.name, err)
+      ensure
+        begin
+          run_teardown(run_scope) if run_scope
+        rescue Exception => teardown_err
+          @results << Result::Error.new(self.name, teardown_err)
+        end
+      end
+      @results.view = nil
+      @results
+    end
+
+    def run_setup(scope)
+      @context_class.all_setup_blocks.each do |setup|
+        scope.instance_eval(&setup)
+      end
+    end
+
+    def run_teardown(scope)
+      @context_class.all_teardown_blocks.each do |teardown|
+        scope.instance_eval(&teardown)
+      end
+    end
+
+    Assert::Result.types.each do |name, klass|
+      define_method "#{name}_results" do
+        @results.select{|r| r.kind_of?(klass) }
+      end
+    end
+
+    def result_count(type=nil)
+      if Assert::Result.types.include?(type)
+        self.send("#{type}_results").size
+      else
+        @results.size
+      end
+    end
+
+    def <=>(other_test)
+      self.name <=> other_test.name
+    end
+
+    def inspect
+      attributes_string = ([ :name, :context_class, :results ].collect do |attr|
+        "@#{attr}=#{self.send(attr).inspect}"
+      end).join(" ")
+      "#<#{self.class} #{attributes_string}>"
+    end
+
+    protected
+
+    def name_from_context(name)
+      name = name.gsub(/^test:\s+should/, "should")
+      [ @context_class.full_description, name ].compact.join(" ")
+    end
+
+  end
+end

data/lib/assert/version.rb

@@ -0,0 +1,3 @@
+module Assert
+  VERSION = "0.1.0"
+end

data/lib/assert/view/base.rb

@@ -0,0 +1,54 @@
+require 'assert/options'
+
+module Assert::View
+
+  class Base
+    include Assert::Options
+
+    attr_reader :suite
+
+    def initialize(suite, output_io)
+      @suite = suite
+      @out = output_io
+    end
+
+    # override this to define how a view calls the runner and renders its results
+    def render(*args, &runner)
+    end
+
+    def print_runtime_result(result)
+      sym = result.to_sym
+      if self.respond_to?(:options)
+        io_print(self.options.send("#{sym}_abbrev"))
+      end
+    end
+
+    protected
+
+    def io_puts(msg, opts={})
+      @out.puts(io_msg(msg, opts={}))
+    end
+
+    def io_print(msg, opts={})
+      @out.print(io_msg(msg, opts={}))
+    end
+
+    def io_msg(msg, opts={})
+      if msg.kind_of?(::Symbol) && self.respond_to?(msg)
+        self.send(msg).to_s
+      else
+        msg.to_s
+      end
+    end
+
+    def run_time(format='%.6f')
+      format % @suite.run_time
+    end
+
+    def count(type)
+      @suite.count(type)
+    end
+
+  end
+
+end