assert 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+.bundle
+*.gem
+*.log
+.rvmrc

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify dependencies in assert.gemspec
+gemspec
+
+gem 'rake', '~>0.9.2'

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    assert (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (0.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  assert!
+  bundler (~> 1.0)
+  rake (~> 0.9.2)

data/README.rdoc

@@ -0,0 +1,77 @@
+= Assert
+
+Test::Unit style testing framework, just better than Test::Unit.
+
+== What Assert is
+
+* *A framework:* you define tests and the context they run in - Assert runs them.  Everything is pure ruby so use any 3rd party testing tools you like.  Create 3rd party tools that extend Assert behavior.
+* *First Class:* everything is a first class object and can be extended to your liking (and should be)
+* *MVC:* tests and how they are defined (M) and executed (C) are distinct from how you view the test results (V).
+* *Backwards compatible:* (assuming a few minor tweaks) with Test::Unit test suites
+
+== What Assert is not
+
+* *Rspec*
+* *Unit/Functional/Integration/etc:* Assert is agnostic - you define whatever kinds of tests you like (one or more of the above) and assert runs them in context.
+* *Mock/Spec/BDD/Factories/etc:* Assert is the framework and there are a variety of 3rd party tools to do such things - feel free to use whatever you like.
+
+== Description
+
+Assert is a Test::Unit style testing framework.  This means you can write tests in Assert the same way you would with Test::Unit.  In addition, Assert adds some helpers and syntax sugar to enhance the way tests are written - most taken from ideas in Shoulda and Leftright.  Assert uses class-based contexts so if you want to nest your contexts, use good old inheritance.
+
+Assert is tested using itself.  The tests are a pretty good place to look for examples and usage patterns.  In addition (TODO) check out the wiki and ./examples in the source.
+
+== Installation
+
+    gem install assert
+
+== Usage
+
+    require 'assert'
+
+    class MyTests < Assert::Context
+
+      def test_something
+        assert_equal 1, 1
+      end
+
+    end
+
+== The Assert family of testing tools
+
+These are all tools that use and extend Assert.  If you write your own, share it with us and we will post it here.
+
+(TODO)
+
+== Contributing
+
+The source code is hosted on Github.  It's clean, modular, and easy to understand.  Feel free to submit pull requests and file bugs on the issues tracker.
+
+One note, however: please respect that Assert itself is intended to be the flexible, base-level type logic that should change little if at all.  Pull requests for niche functionality or personal testing philosphy stuff will likely not be accepted.
+
+If you wish to extend Assert for your niche purpose/desire/philosophy, please do so in it's own gem (named 'assert-<whatever>') that uses Assert as a dependency.  When you do, tell us about it and we'll add to the Family of tools.
+
+== License
+
+Copyright (c) 2011 Kelly Redding, Collin Redding, and Team Insight
+
+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/Rakefile

@@ -0,0 +1,7 @@
+include Rake::DSL
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'lib/assert/rake_tasks'
+Assert::RakeTasks.for :test

data/assert.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "assert/version"
+
+Gem::Specification.new do |s|
+  s.name        = "assert"
+  s.version     = Assert::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Kelly Redding", "Collin Redding"]
+  s.email       = ["kelly@kelredd.com"]
+  s.homepage    = "http://github.com/teaminsight/assert"
+  s.summary     = %q{Test::Unit style testing framework, just better than Test::Unit.}
+  s.description = %q{Test::Unit style testing framework, just better than Test::Unit.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("bundler", ["~> 1.0"])
+end

data/examples/empty_test.rb

@@ -0,0 +1,5 @@
+require 'assert'
+
+class EmptyTest < Assert::Context
+
+end

data/examples/results_test.rb

@@ -0,0 +1,25 @@
+require 'assert'
+
+class ResultsTest < Assert::Context
+
+  def test_that_passes
+    assert 1==1
+  end
+
+  def test_that_fails
+    assert 1==0
+  end
+
+  def test_that_ignores
+    ignore
+  end
+
+  def test_that_skips
+    skip
+  end
+
+  def test_that_errors
+    raise Exception
+  end
+
+end

data/examples/single_test.rb

@@ -0,0 +1,9 @@
+require 'assert'
+
+class SingleTest < Assert::Context
+
+  def test_this_thing
+    assert 1==1
+  end
+
+end

data/lib/assert.rb

@@ -0,0 +1,8 @@
+require 'assert/setup/suite'
+require 'assert/setup/view'
+
+require 'assert/setup/helpers'
+require 'assert/setup/autorun'
+
+Assert::Helpers.load(caller)
+Assert.autorun

data/lib/assert/assertions.rb

@@ -0,0 +1,253 @@
+module Assert
+  module Assertions
+
+    def assert_block(fail_desc=nil)
+      what_failed_msg ||= "Expected block to return true value."
+      assert(yield, fail_desc, what_failed_msg)
+    end
+
+    def assert_not_block(fail_desc=nil)
+      what_failed_msg ||= "Expected block to return false value."
+      assert(!yield, fail_desc, what_failed_msg)
+    end
+    alias_method :refute_block, :assert_not_block
+
+
+
+    def assert_raises(*args, &block)
+      assertion, fail_desc = check_exception(args, :raises, &block)
+      assert(assertion, fail_desc, "")
+    end
+    alias_method :assert_raise, :assert_raises
+
+    def assert_nothing_raised(*args, &block)
+      assertion, fail_desc = check_exception(args, :not_raises, &block)
+      assert(!assertion, fail_desc, "")
+    end
+    alias_method :assert_not_raises, :assert_nothing_raised
+    alias_method :assert_not_raise, :assert_nothing_raised
+
+
+
+    def assert_kind_of(klass, instance, fail_desc=nil)
+      what_failed_msg = [
+        "Expected #{instance.inspect} to be a kind ",
+        "of #{klass}, not #{instance.class}."
+      ].join
+      assert(instance.kind_of?(klass), fail_desc, what_failed_msg)
+    end
+
+    def assert_not_kind_of(klass, instance, fail_desc=nil)
+      what_failed_msg = [
+        "#{instance.inspect} was not expected to be a ",
+        "kind of #{klass}."
+      ].join
+      assert(!instance.kind_of?(klass), fail_desc, what_failed_msg)
+    end
+    alias_method :refute_kind_of, :assert_not_kind_of
+
+
+
+    def assert_instance_of(klass, instance, fail_desc=nil)
+      what_failed_msg = [
+        "Expected #{instance.inspect} to be an instance ",
+        "of #{klass}, not #{instance.class}."
+      ].join
+      assert(instance.instance_of?(klass), fail_desc, what_failed_msg)
+    end
+
+    def assert_not_instance_of(klass, instance, fail_desc=nil)
+      what_failed_msg = [
+        "#{instance.inspect} was not expected to be an ",
+        "instance of #{klass}."
+      ].join
+      assert(!instance.instance_of?(klass), fail_desc, what_failed_msg)
+    end
+    alias_method :refute_instance_of, :assert_not_instance_of
+
+
+
+    def assert_respond_to(object, method, fail_desc=nil)
+      what_failed_msg = [
+        "Expected #{object.inspect} (#{object.class}) to ",
+        "respond to ##{method}."
+      ].join
+      assert(object.respond_to?(method), fail_desc, what_failed_msg)
+    end
+
+    def assert_not_respond_to(object, method, fail_desc=nil)
+      what_failed_msg = [
+        "#{object.inspect} (#{object.class}) not expected to ",
+        "respond to ##{method}."
+      ].join
+      assert(!object.respond_to?(method), fail_desc, what_failed_msg)
+    end
+    alias_method :refute_respond_to, :assert_not_respond_to
+
+
+
+    def assert_same(left, right, fail_desc=nil)
+      what_failed_msg = [
+        "Expected #{left} (#{left.object_id}) to be the same ",
+        "as #{right} (#{right.object_id})."
+      ].join
+      assert(right.equal?(left), fail_desc, what_failed_msg)
+    end
+
+    def assert_not_same(left, right, fail_desc=nil)
+      what_failed_msg = [
+        "#{left} (#{left.object_id}) not expected to be the same ",
+        "as #{right} (#{right.object_id})."
+      ].join
+      assert(!right.equal?(left), fail_desc, what_failed_msg)
+    end
+    alias_method :refute_same, :assert_not_same
+
+
+
+    def assert_equal(left, right, fail_desc=nil)
+      what_failed_msg = "Expected #{left.inspect}, not #{right.inspect}."
+      assert(right == left, fail_desc, what_failed_msg)
+    end
+
+    def assert_not_equal(left, right, fail_desc=nil)
+      what_failed_msg = [
+        "#{left.inspect} not expected to be equal ", "to #{right.inspect}."
+      ].join
+      assert(right != left, fail_desc, what_failed_msg)
+    end
+    alias_method :refute_equal, :assert_not_equal
+
+
+
+    def assert_match(left, right, fail_desc=nil)
+      what_failed_msg = "Expected #{left.inspect} to match #{right.inspect}."
+      left = /#{Regexp.escape(left)}/ if String === left && String === right
+      assert(left =~ right, fail_desc, what_failed_msg)
+    end
+
+    def assert_not_match(left, right, fail_desc=nil)
+      what_failed_msg = [
+        "#{left.inspect} not expected to ", "match #{right.inspect}."
+      ].join
+      left = /#{Regexp.escape(left)}/ if String === left && String === right
+      assert(left !~ right, fail_desc, what_failed_msg)
+    end
+    alias_method :refute_match, :assert_not_match
+    alias_method :assert_no_match, :assert_not_match
+
+
+
+    # TODO: tests!
+    def assert_empty(collection, fail_desc=nil)
+      what_failed_msg = "Expected #{collection.inspect} to be empty."
+      assert(collection.empty?, fail_desc, what_failed_msg)
+    end
+
+    def assert_not_empty(collection, fail_desc=nil)
+      what_failed_msg = "Expected #{collection.inspect} to not be empty."
+      assert(!collection.empty?, fail_desc, what_failed_msg)
+    end
+    alias_method :refute_empty, :assert_not_empty
+
+
+
+    # TODO: tests!
+    def assert_includes(collection, object, fail_desc=nil)
+      what_failed_msg = "Expected #{collection.inspect} to include #{object.inspect}."
+      assert(collection.include?(object), fail_desc, what_failed_msg)
+    end
+
+    def assert_not_included(collection, object, fail_desc=nil)
+      what_failed_msg = "Expected #{collection.inspect} to not include #{object.inspect}."
+      assert(!collection.include?(object), fail_desc, what_failed_msg)
+    end
+    alias_method :refute_includes, :assert_not_included
+
+
+
+    # TODO: tests!
+    def assert_nil(object, fail_desc=nil)
+      what_failed_msg = "Expected nil, not #{object.inspect}."
+      assert(object.nil?, fail_desc, what_failed_msg)
+    end
+
+    def assert_not_nil(object, fail_desc=nil)
+      what_failed_msg = "Expected #{object.inspect} to not be nil."
+      assert(!object.nil?, fail_desc, what_failed_msg)
+    end
+    alias_method :refute_nil, :assert_not_nil
+
+
+
+    IGNORED_ASSERTION_HELPERS = [ :assert_throws, :assert_nothing_thrown, :assert_send,
+      :assert_operator, :refute_operator, :assert_in_epsilon, :refute_in_epsilon,
+      :assert_in_delta, :refute_in_delta
+    ]
+    def method_missing(method, *args, &block)
+      if IGNORED_ASSERTION_HELPERS.include?(method.to_sym)
+        ignore([
+          "The assertion helper '#{method}' is not supported. Please use ",
+          "another helper or the basic assert."
+        ].join)
+      else
+        super
+      end
+    end
+
+    private
+
+    def check_exception(args, which, &block)
+      fail_desc = String === args.last ? args.pop : nil
+      exceptions = args
+      begin
+        yield
+      rescue Exception => exception
+      end
+      assertion, what_failed_msg = if exception
+        test = exceptions.empty? || exceptions.any? do |exp|
+          exp.instance_of?(Module) ? exception.kind_of?(exp) : exp == exception.class
+        end
+        [ test, exception_details(exception, which) ]
+      else
+        [ false, exception_details(exception, which) ]
+      end
+      what_failed_msg = "#{exceptions_sentence(exceptions)} #{what_failed_msg}"
+      fail_desc = [ fail_desc, what_failed_msg ].compact.join("\n")
+      [ assertion, fail_desc ]
+    end
+
+    def exception_details(exception, which)
+      if exception
+        what_failed_msg = case(which)
+          when :raises
+            "exception expected, not:"
+          when :not_raises
+            "exception was not expected, but was raised:"
+        end
+        backtrace = Assert::Result::Backtrace.new(exception.backtrace)
+        [ what_failed_msg,
+          "Class: <#{exception.class}>",
+          "Message: <#{exception.message.inspect}>",
+          "---Backtrace---",
+          backtrace.filtered.to_s,
+          "---------------"
+        ].compact.join("\n")
+      else
+        case(which)
+        when :raises
+          "exception expected but nothing was raised."
+        end
+      end
+    end
+
+    def exceptions_sentence(exceptions)
+      if exceptions.size <= 1
+        (exceptions.first || "An").to_s
+      else
+        "#{exceptions[0..-2].join(", ")} or #{exceptions[-1]}"
+      end
+    end
+
+  end
+end