test-belt 0.2.1 → 1.0.0

data/.gitignore

@@ -1,4 +1,5 @@
 /pkg/
 /doc/
 /coverage/
-*.log
+*.log
+.bundle

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    test-belt (1.0.0)
+      kelredd-useful (~> 0.4.0)
+      leftright (~> 0.9.0)
+      shoulda (~> 2.11)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    json (1.5.1)
+    kelredd-useful (0.4.1)
+      json
+    leftright (0.9.1)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  test-belt!

data/lib/test_belt/callbacks.rb

@@ -0,0 +1,22 @@
+require 'test_belt/callbacks/test'
+require 'test_belt/callbacks/case'
+require 'test_belt/callbacks/suite'
+
+module TestBelt::Callbacks
+
+  # Test Belt adds callbacks for test cases, test case classes, and overall
+  # test suites.  Use these callbacks to help setup/teardown your tests.  All
+  # callbacks inherit to subclasses and are run in inheritance order.  So, a
+  # superclass's callbacks run before and subclass callbacks.  Test
+  # callbacks are run in the scope of the test case.  Other callbacks are run
+  # outside the test case scope.
+
+  def self.included(receiving_test_class)
+    if receiving_test_class.ancestors.include?(::Test::Unit::TestCase)
+      receiving_test_class.send(:include, Test)
+      receiving_test_class.send(:include, Case)
+      receiving_test_class.send(:include, Suite)
+    end
+  end
+
+end

data/lib/test_belt/callbacks/case.rb

@@ -0,0 +1,86 @@
+module TestBelt::Callbacks
+  module Case
+
+    # Like their before/after brothers above, the _once callbacks run
+    # before/after tests respectively.  The difference is that they only run
+    # once for the entire case.  The before/setup callback will run before the
+    # first test for the class while the after/teardown callback will run after
+    # the last test for the class.
+
+    # Usage:
+    #   class SomeTest < Test::Unit::TestCase
+    #     include TestBelt::Callbacks::Case
+    #
+    #     before_once {
+    #       # anything here runs before the first test for this class
+    #     }
+    #     after_once {
+    #       # anything here runs after the last test for this class
+    #     }
+    #
+    #     should 'do stuff' do
+    #       assert true
+    #     end
+    #   end
+
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def setup_once(&block)
+        raise ArgumentError, "please provide a setup block" unless block_given?
+        @_testbelt_once_setups ||= []
+        @_testbelt_once_setups << block
+      end
+      alias_method :before_once, :setup_once
+
+      def _testbelt_once_setups
+        ((begin; superclass._testbelt_once_setups; rescue NoMethodError; []; end) || []) +
+        (@_testbelt_once_setups || [])
+      end
+
+      def teardown_once(&block)
+        raise ArgumentError, "please provide a teardown block" unless block_given?
+        @_testbelt_once_teardowns ||= []
+        @_testbelt_once_teardowns << block
+      end
+      alias_method :after_once, :teardown_once
+
+      def _testbelt_once_teardowns
+        ((begin; superclass._testbelt_once_teardowns; rescue NoMethodError; []; end) || []) +
+        (@_testbelt_once_teardowns || [])
+      end
+    end
+
+  end
+end
+
+module Test::Unit
+  class TestSuite
+    # override the TestSuite with TestCase callbacks
+    alias_method :run_without_testbelt_callbacks, :run
+
+    def run(*args, &block) # :nodoc:
+      if( !tests.empty? &&
+          (testclass = tests.first).kind_of?(::Test::Unit::TestCase) &&
+          testclass.class.ancestors.include?(::TestBelt::Callbacks::Case)
+        )
+        tests.first.class._testbelt_once_setups.each do |callback|
+          callback.call
+        end
+      end
+      run_without_testbelt_callbacks *args, &block
+      if( !tests.empty? &&
+          (testclass = tests.first).kind_of?(::Test::Unit::TestCase) &&
+          testclass.class.ancestors.include?(::TestBelt::Callbacks::Case)
+        )
+        tests.first.class._testbelt_once_teardowns.reverse.each do |callback|
+          callback.call
+        end
+      end
+    end
+
+  end
+end

data/lib/test_belt/callbacks/suite.rb

@@ -0,0 +1,106 @@
+module TestBelt::Callbacks
+  module Suite
+
+    # Again, similar to the before/after callbacks above, the started/finished
+    # callbacks run before/after tests respectively.  The difference is that
+    # these callbacks run only once for the entire suite of tests (across all
+    # test cases).  The suite_started/on_suite_started callbacks run before the
+    # first test run in the suite of tests.  The suite_finished/on_suite_finished
+    # callbacks run after the last test run in the suite of tests.
+
+    # Usage:
+    #   class SomeTest < Test::Unit::TestCase
+    #     include TestBelt::Callbacks::Suite
+    #
+    #     suite_started {
+    #       # anything here runs before the first test for the suite of tests
+    #     }
+    #     suite_finished {
+    #       # anything here runs after the last test for the suite of tests
+    #     }
+    #
+    #     should 'do stuff' do
+    #       assert true
+    #     end
+    #   end
+
+
+    def self.included(receiver)
+      if !::Test::Unit::TestCase.respond_to?(:suite_started)
+        ::Test::Unit::TestCase.send(:extend, ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def suite_started(&block)
+        raise ArgumentError, "please provide a started block" unless block_given?
+        ::Test::Unit::TestCase._testbelt_started_callbacks ||= []
+        ::Test::Unit::TestCase._testbelt_started_callbacks << block
+      end
+      alias_method :on_suite_started, :suite_started
+
+      def _testbelt_started_callbacks
+        @_testbelt_started_callbacks ||= []
+      end
+
+      def suite_finished(&block)
+        raise ArgumentError, "please provide a finished block" unless block_given?
+        ::Test::Unit::TestCase._testbelt_finished_callbacks ||= []
+        ::Test::Unit::TestCase._testbelt_finished_callbacks << block
+      end
+      alias_method :on_suite_finished, :suite_finished
+
+      def _testbelt_finished_callbacks
+        @_testbelt_finished_callbacks ||= []
+      end
+    end
+
+  end
+end
+
+require 'test/unit/ui/console/testrunner'
+
+module TestBelt::Callbacks
+
+  if defined? ::LeftRight::Runner
+    class Runner < ::LeftRight::Runner; end
+  else
+    class Runner < ::Test::Unit::UI::Console::TestRunner; end
+  end
+
+  class Runner
+    def started(*args)
+      super
+      if ::Test::Unit::TestCase.respond_to?(:suite_started)
+        ::Test::Unit::TestCase._testbelt_started_callbacks.each do |callback|
+          callback.call
+        end
+      end
+    end
+
+    def finished(*args)
+      if ::Test::Unit::TestCase.respond_to?(:suite_finished)
+        ::Test::Unit::TestCase._testbelt_finished_callbacks.reverse.each do |callback|
+          callback.call
+        end
+      end
+      super
+    end
+  end
+
+end
+
+module Test::Unit
+
+  # override the AutoRunner's runner to use TestBelt's
+  # with callback for suite started/finished
+  class AutoRunner
+    alias_method :initialize_without_testbelt_runner, :initialize
+
+    def initialize(*args)
+      initialize_without_testbelt_runner *args
+      @runner = lambda { |r| ::TestBelt::Callbacks::Runner }
+    end
+  end
+
+end

data/lib/test_belt/callbacks/test.rb

@@ -0,0 +1,58 @@
+module TestBelt::Callbacks
+  module Test
+
+    # Test before/setup callbacks run before each test in the test case class.
+    # The after/teardown callbacks run after each test in the test case class.
+    # Each pair does identical logic - they are just an alias of each other so
+    # use what reads better to you.
+
+    # Usage:
+    # <pre>
+    #   class SomeTest < Test::Unit::TestCase
+    #     include TestBelt::Callbacks::Test
+    #
+    #     before {
+    #       # anything here runs before each test
+    #     }
+    #     after {
+    #       # anything here runs after each test
+    #     }
+    #
+    #     should 'do stuff' do
+    #       assert true
+    #     end
+    #   end
+    # </pre>
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def setup(&block)
+        raise ArgumentError, "please provide a setup block" unless block_given?
+        @_testbelt_setups ||= []
+        @_testbelt_setups << block
+      end
+      alias_method :before, :setup
+
+      def _testbelt_setups
+        ((begin; superclass._testbelt_setups; rescue NoMethodError; []; end) || []) +
+        (@_testbelt_setups || [])
+      end
+
+      def teardown(&block)
+        raise ArgumentError, "please provide a teardown block" unless block_given?
+        @_testbelt_teardowns ||= []
+        @_testbelt_teardowns << block
+      end
+      alias_method :after, :teardown
+
+      def _testbelt_teardowns
+        ((begin; superclass._testbelt_teardowns; rescue NoMethodError; []; end) || []) +
+        (@_testbelt_teardowns || [])
+      end
+    end
+
+  end
+end

data/lib/test_belt/context.rb

@@ -0,0 +1,40 @@
+module TestBelt
+  module Context
+
+    # This provides a 'context' method on a TestCase.  Use this method
+    # to describe the context the TestCase is running in.  This may be
+    # a description of the subject or whatever you want.  The context
+    # value will be added to the test name of any tests defined using
+    # the 'should' method provided by should.rb.  Context descriptions
+    # are nested as TestCases are sub-classed.
+
+    # Usage:
+    # class SomeTest < Test::Unit::TestCase
+    #   include TestBelt::Context
+    # end
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+      receiver.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      def context(desc)
+        raise ArgumentError, "no context description provided" if desc.nil?
+        @_testbelt_contexts = [desc]
+      end
+
+      def _testbelt_contexts
+        ((begin; superclass._testbelt_contexts; rescue NoMethodError; []; end) || []) +
+        (@_testbelt_contexts || [])
+      end
+    end
+
+    module InstanceMethods
+      def context
+        self.class._testbelt_contexts.join(' ')
+      end
+    end
+
+  end
+end

data/lib/test_belt/default_test.rb

@@ -0,0 +1,18 @@
+module TestBelt
+  module DefaultTest
+
+    # This overrides the TestCase default_test behavior.  When running
+    # a TestCase, the 'default_test' method is called if no 'test_*'
+    # methods are defined.  The standard method always flunks saying
+    # 'no tests defined' or whatever.  This overrides the standard
+    # method so it won't flunk and you can inherit TestCases freely.
+
+    # Usage:
+    # class SomeTest < Test::Unit::TestCase
+    #   include TestBelt::DefaultTest
+    # end
+
+    def default_test; end
+
+  end
+end

data/lib/test_belt/helper.rb

@@ -1,6 +1,27 @@
 require 'rubygems'
 require 'test/unit'
 require 'leftright'
-require 'shoulda'
-require 'test_belt/shoulda_macros'
-require 'test_belt/test_unit'
+
+require 'test_belt/default_test'
+require 'test_belt/should'
+require 'test_belt/context'
+require 'test_belt/subject'
+require 'test_belt/skip'
+require 'test_belt/callbacks'
+require 'test_belt/matchers'
+
+module TestBelt
+
+  def self.included(receiving_test_class)
+    if receiving_test_class.ancestors.include?(::Test::Unit::TestCase)
+      receiving_test_class.send(:include, DefaultTest)
+      receiving_test_class.send(:extend, Should)
+      receiving_test_class.send(:include, Context)
+      receiving_test_class.send(:include, Subject)
+      receiving_test_class.send(:include, Skip)
+      receiving_test_class.send(:include, Callbacks)
+      receiving_test_class.send(:include, Matchers)
+    end
+  end
+
+end

data/lib/test_belt/matchers.rb

@@ -0,0 +1,29 @@
+require 'test_belt/matchers/base'
+require 'test_belt/matchers/have_instance_methods'
+require 'test_belt/matchers/have_class_methods'
+require 'test_belt/matchers/have_readers'
+require 'test_belt/matchers/have_writers'
+require 'test_belt/matchers/have_accessors'
+require 'test_belt/matchers/have_files'
+
+module TestBelt::Matchers
+
+  # Test Belt provides matchers to test common scenarios.  Use these matchers
+  # in combination with the 'should' method to run common test cases.
+
+  def self.included(receiving_test_class)
+    if receiving_test_class.ancestors.include?(::Test::Unit::TestCase)
+      receiving_test_class.send(:include, HaveInstanceMethods)
+      receiving_test_class.send(:include, HaveClassMethods)
+      receiving_test_class.send(:include, HaveReaders)
+      receiving_test_class.send(:include, HaveWriters)
+      receiving_test_class.send(:include, HaveAccessors)
+      receiving_test_class.send(:include, HaveFiles)
+    end
+  end
+
+  def assert_matcher(matcher)
+    assert_block(matcher.fail_message) { matcher.matches?(subject) }
+  end
+
+end

data/lib/test_belt/matchers/base.rb

@@ -0,0 +1,21 @@
+module TestBelt::Matchers
+
+  # Test Belt provides matchers to test common scenarios.  Use these matchers
+  # in combination with the 'should' method to run common test cases.  All
+  # matchers should subclass this base class.
+
+  class Base
+    def desc
+      raise NotImplementedError, "no description provided for the matcher"
+    end
+
+    def matches?(*args)
+      raise NotImplementedError, "no matches? test logic provided for the matcher"
+    end
+
+    def fail_message
+      raise NotImplementedError, "no fail message provided for the matcher"
+    end
+  end
+
+end