test-belt 0.2.1 → 1.0.0

data/lib/test_belt/matchers/have_accessors.rb

@@ -0,0 +1,23 @@
+require 'test_belt/matchers/have_readers'
+require 'test_belt/matchers/have_writers'
+
+module TestBelt::Matchers
+  module HaveAccessors
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def have_accessors(*meths)
+        meths.collect do |meth|
+          [ ::TestBelt::Matchers::HaveReaders::Matcher.new(meth),
+            ::TestBelt::Matchers::HaveWriters::Matcher.new(meth)
+          ]
+        end.flatten
+      end
+      alias_method :have_accessor, :have_accessors
+    end
+
+  end
+end

data/lib/test_belt/matchers/have_class_methods.rb

@@ -0,0 +1,40 @@
+module TestBelt::Matchers
+  module HaveClassMethods
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def have_class_methods(*meths)
+        meths.collect do |meth|
+          Matcher.new(meth)
+        end
+      end
+      alias_method :have_class_method, :have_class_methods
+    end
+
+    class Matcher < ::TestBelt::Matchers::Base
+      def initialize(method)
+        unless method.kind_of?(::String) || method.kind_of?(::Symbol)
+          raise ArgumentError, "please specify the method name using a string or symbol"
+        end
+        @method = method
+      end
+
+      def desc
+        "respond to class method ##{@method}"
+      end
+
+      def matches?(subject)
+        @subject = subject
+        subject.class.respond_to?(@method)
+      end
+
+      def fail_message
+        "#{@subject.class.name} does not have the class method ##{@method}"
+      end
+    end
+
+  end
+end

data/lib/test_belt/matchers/have_files.rb

@@ -0,0 +1,38 @@
+module TestBelt::Matchers
+  module HaveFiles
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def have_files(*files)
+        files.collect do |file|
+          Matcher.new(file)
+        end
+      end
+      alias_method :have_file, :have_files
+      alias_method :have_directories, :have_files
+      alias_method :have_directory, :have_files
+    end
+
+    class Matcher < ::TestBelt::Matchers::Base
+      def initialize(file_path)
+        @file_path = file_path
+      end
+
+      def desc
+        "have the file path '#{@file_path}'"
+      end
+
+      def matches?(subject)
+        File.exists?(@file_path)
+      end
+
+      def fail_message
+        "'#{@file}' does not exist"
+      end
+    end
+
+  end
+end

data/lib/test_belt/matchers/have_instance_methods.rb

@@ -0,0 +1,44 @@
+module TestBelt::Matchers
+  module HaveInstanceMethods
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def have_instance_methods(*meths)
+        meths.collect do |meth|
+          Matcher.new(meth)
+        end
+      end
+      alias_method :have_instance_method, :have_instance_methods
+    end
+
+    class Matcher < ::TestBelt::Matchers::Base
+      def initialize(method)
+        unless method.kind_of?(::String) || method.kind_of?(::Symbol)
+          raise ArgumentError, "please specify the method name using a string or symbol"
+        end
+        @method = method
+      end
+
+      def method_type
+        "instance method"
+      end
+
+      def desc
+        "respond to #{method_type} ##{@method}"
+      end
+
+      def matches?(subject)
+        @subject = subject
+        subject.respond_to?(@method)
+      end
+
+      def fail_message
+        "#{@subject.class.name} does not have instance method ##{@method}"
+      end
+    end
+
+  end
+end

data/lib/test_belt/matchers/have_readers.rb

@@ -0,0 +1,26 @@
+require 'test_belt/matchers/have_instance_methods'
+
+module TestBelt::Matchers
+  module HaveReaders
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def have_readers(*meths)
+        meths.collect do |meth|
+          Matcher.new(meth)
+        end
+      end
+      alias_method :have_reader, :have_readers
+    end
+
+    class Matcher < ::TestBelt::Matchers::HaveInstanceMethods::Matcher
+      def method_type
+        "reader"
+      end
+    end
+
+  end
+end

data/lib/test_belt/matchers/have_writers.rb

@@ -0,0 +1,30 @@
+require 'test_belt/matchers/have_instance_methods'
+
+module TestBelt::Matchers
+  module HaveWriters
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def have_writers(*meths)
+        meths.collect do |meth|
+          Matcher.new(meth)
+        end
+      end
+      alias_method :have_writer, :have_writers
+    end
+
+    class Matcher < ::TestBelt::Matchers::HaveInstanceMethods::Matcher
+      def initialize(method)
+        super("#{method}=")
+      end
+
+      def method_type
+        "writer"
+      end
+    end
+
+  end
+end

data/lib/test_belt/should.rb

@@ -0,0 +1,76 @@
+module TestBelt
+  module Should
+
+    # This defines a class method 'should' that takes a string
+    # describing the test and a block that executes the test.  The
+    # test will be named:
+    #   "test: #{context} should #{description}."
+
+    # Usage:
+    # class SomeTest < Test::Unit::TestCase
+    #   extend TestBelt::Should
+    # end
+
+    def should(matchers_or_desc, &block)
+      tests = should_tests(matchers_or_desc, &block)
+      context = should_context
+
+      each_should(context, tests) do |name, code|
+        define_method(name) do
+          begin
+            self.class._testbelt_setups.each {|sb| instance_eval(&sb)}
+            instance_eval(&code)
+          ensure
+            self.class._testbelt_teardowns.reverse.each {|tb| instance_eval(&tb)}
+          end
+        end
+      end
+    end
+
+    # This method is identical to the should version, however this one does
+    # nothing but skip any tests described or matched on
+    def should_eventually(matchers_or_desc, &block)
+      tests = should_tests(matchers_or_desc, &block)
+      context = should_context
+
+      each_should(context, tests) do |name, code|
+        define_method(name) { skip }
+      end
+    end
+
+    private
+
+    def each_should(context, tests)
+      tests.each do |t|
+        yield should_test_name(context, t[0]), t[1]
+      end
+    end
+
+    def should_tests(matchers_or_desc, &block)
+      unless matchers_or_desc.kind_of?(::Array) || block_given?
+        raise ArgumentError, "either specify a test block and description or a set of matchers"
+      end
+
+      if matchers_or_desc.kind_of?(::Array)
+        matchers_or_desc.collect do |matcher|
+          [matcher.desc, Proc.new {assert_matcher(matcher)}]
+        end
+      else
+        [[matchers_or_desc.to_s, block]]
+      end
+    end
+
+    def should_context
+      ''  # TODO: context stuff needs to be added to test name
+    end
+
+    def should_test_name(context, name)
+      test_name = ["test:", "should", "#{name}.  "].flatten.join(' ').to_sym
+      if instance_methods.include?(test_name.to_s)
+        warn "  * WARNING: '#{test_name}' is already defined"
+      end
+      test_name
+    end
+
+  end
+end

data/lib/test_belt/skip.rb

@@ -0,0 +1,41 @@
+module Test::Unit
+  class TestCase
+
+    alias_method(:orig_add_error, :add_error)
+    def add_error(*args, &block)
+      unless args.first.kind_of?(::TestBelt::TestSkipped)
+        orig_add_error *args, &block
+      end
+    end
+
+  end
+end
+
+module TestBelt
+  class TestSkipped < Exception; end
+
+  module Skip
+
+    # Sometimes while testing, you may wish to define some tests but not run
+    # them just yet.  LeftRight provides some nice UI for dealing with skipped
+    # tests.  Test Belt provides a handy 'skip' method for test cases.  Use
+    # this method to skip individual tests.  If you wish to skip a whole
+    # context of tests, add the skip method to a before [[Callback]] and all
+    # the tests will be skipped for the class.  Since callbacks inherit, any
+    # subclassed tests will be skipped as well.
+
+    # Usage:
+    #  class SomeTest < Test::Unit::TestCase
+    #    include TestBelt::Skip
+    #  end
+
+    def skip(halt_test=true)
+      if defined? ::LeftRight
+        ::LeftRight.state.skip = true
+        ::LeftRight.state.skipped_count += 1
+      end
+      raise ::TestBelt::TestSkipped if halt_test
+    end
+
+  end
+end

data/lib/test_belt/subject.rb

@@ -0,0 +1,47 @@
+module TestBelt
+  module Subject
+
+    # This provides a class method 'subject' on a TestCase.  Use this method
+    # to initialize the subject of the TestCase.  This may be a model, class,
+    # or whatever.  The subject method takes a block and the result of the
+    # block is used as the subject value.  Note, the block is for every test
+    # withing the scope of the TestCase instance, and after any setup/before
+    # callbacks.  The subject value is available using the 'subject instance
+    # method on the TestCase.  Any sub-classed TestCase that does not define
+    # it's own subject will inherite the subject of it's super class.
+
+    # Usage:
+    # class SomeTest < Test::Unit::TestCase
+    #   include TestBelt::Subject
+    # end
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+      receiver.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      def subject(&block)
+        raise ArgumentError, "please provide a subject block" unless block_given?
+        @_testbelt_subject = block
+      end
+
+      def _testbelt_subject
+        @_testbelt_subject || begin
+          superclass._testbelt_subject
+        rescue NoMethodError
+          nil
+        end
+      end
+    end
+
+    module InstanceMethods
+      def subject
+        @_testbelt_subject ||= if (sb = self.class._testbelt_subject)
+          instance_eval(&sb)
+        end
+      end
+    end
+
+  end
+end

data/lib/test_belt/version.rb

@@ -1,3 +1,3 @@
 module TestBelt
-  VERSION = "0.2.1"
+  VERSION = "1.0.0"
 end

data/test/callbacks_test.rb

@@ -0,0 +1,172 @@
+require "test/helper"
+
+module TestBelt
+
+  class TestCallbacksTest < Test::Unit::TestCase
+    include TestBelt
+
+    context "A test with callbacks"
+    subject { 'subject' }
+    before {
+      @before = 'before'
+      @before_subject = subject
+      @expected_after = 'after'
+    }
+    setup {
+      @setup = 'setup'
+      @setup_subject = subject
+      @expected_teardown = 'teardown'
+    }
+
+    should "run the it's callbacks appropriately" do
+      assert_equal 'before', @before
+      assert_equal 'setup', @setup
+      assert_equal 'subject', @before_subject
+      assert_equal 'subject', @setup_subject
+    end
+
+    after {
+      assert_equal 'after', @expected_after
+    }
+    teardown {
+      assert_equal 'teardown', @expected_teardown
+    }
+  end
+  class RootCallbacksTest < Test::Unit::TestCase
+    include TestBelt
+
+    before {
+      @before = ['root']
+    }
+    after {
+      assert_equal ['nested nested', 'nested'], @after
+    }
+  end
+  class NestedCallbacksTest < RootCallbacksTest
+    before {
+      @before << 'nested'
+    }
+    after {
+      @after << 'nested'
+    }
+  end
+  class NestedNestedCallbacksTest < NestedCallbacksTest
+    should "call it's nested callbacks in order" do
+      assert_equal ['root', 'nested'], @before
+    end
+
+    after {
+      @after = ['nested nested']
+    }
+  end
+
+
+
+
+  class CaseCallbacksTest < Test::Unit::TestCase
+    include TestBelt
+
+    context "A test with case callbacks"
+
+    before_once {
+      @expected_after = 'after'
+      if (@@before_once rescue nil)
+        @before_once_fail = true
+      end
+      @@before_once = true
+    }
+    setup_once {
+      @expected_teardown = 'teardown'
+      if (@@setup_once rescue nil)
+        @setup_once_fail = true
+      end
+      @@setup_once = true
+    }
+
+    should "run the case callbacks just once" do
+      assert true
+    end
+    should "not run the case callbacks more than once" do
+      assert true
+    end
+
+    after_once {
+      if (@@after_once rescue nil)
+        @after_once_fail = true
+      end
+      @@after_once = true
+      raise 'looks like before_once did not run' unless @expected_after == 'after'
+      raise "before_once did not run once" unless (@@before_once rescue nil)
+      raise "before_once ran more than once" unless @before_once_fail.nil?
+      raise "after_once did not run once" unless (@@after_once rescue nil)
+      raise "after_once ran more than once" unless @after_once_fail.nil?
+    }
+    teardown_once {
+      if (@@teardown_once rescue nil)
+        @teardown_once_fail = true
+      end
+      @@teardown_once = true
+      raise 'looks like setup_once did not run' unless @expected_teardown == 'teardown'
+      raise "setup_once did not run once" unless (@@setup_once rescue nil)
+      raise "setup_once ran more than once" unless @setup_once_fail.nil?
+      raise "teardown_once did not run once" unless (@@teardown_once rescue nil)
+      raise "teardown_once ran more than once" unless @teardown_once_fail.nil?
+    }
+  end
+
+
+
+
+  class SuiteCallbacksTest < Test::Unit::TestCase
+    include TestBelt
+
+    context "A test with suite callbacks"
+
+    suite_started {
+      @started_assert = true
+      @expected_finished = 'finished'
+      if (@@started rescue nil)
+        @started_fail = true
+      end
+      @@started = true
+    }
+    on_suite_started {
+      @on_started_assert = true
+      @expected_on_finished = 'on finished'
+      if (@@on_started rescue nil)
+        @on_started_fail = true
+      end
+      @@on_started = true
+    }
+
+    should "run the suite callbacks just once" do
+      assert true
+    end
+    should "not run the suite callbacks more than once" do
+      assert true
+    end
+
+    suite_finished {
+      if (@@finished rescue nil)
+        @finished_fail = true
+      end
+      @@finished = true
+      raise 'looks like suite_started did not run' unless @expected_finished == 'finished'
+      raise "suite_started did not run once" unless (@@started rescue nil)
+      raise "suite_started ran more than once" unless @started_fail.nil?
+      raise "suite_finished did not run once" unless (@@finished rescue nil)
+      raise "suite_finished ran more than once" unless @finished_fail.nil?
+    }
+    on_suite_finished {
+      if (@@on_finished rescue nil)
+        @on_finished_fail = true
+      end
+      @@on_finished = true
+      raise 'looks like on_suite_started did not run' unless @expected_on_finished == 'on finished'
+      raise "on_suite_started did not run once" unless (@@on_started rescue nil)
+      raise "on_suite_started ran more than once" unless @on_started_fail.nil?
+      raise "on_suite_finished did not run once" unless (@@on_finished rescue nil)
+      raise "on_suite_finished ran more than once" unless @on_finished_fail.nil?
+    }
+  end
+end